本文整理汇总了C++中reiserfs_panic函数的典型用法代码示例。如果您正苦于以下问题:C++ reiserfs_panic函数的具体用法?C++ reiserfs_panic怎么用?C++ reiserfs_panic使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了reiserfs_panic函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: get_entry_attributes
/* fills the structure with various parameters of directory entry,
including key of the pointed object */
static void get_entry_attributes (struct reiserfs_dir_entry * de, int entry_num)
{
#ifdef REISERFS_CHECK
if (I_ENTRY_COUNT (de->de_ih) < entry_num)
reiserfs_panic (0, "yr-7006: get_entry_attributes: no such entry (%d-th) in the item (%d)",
entry_num, I_ENTRY_COUNT (de->de_ih));
if (de->de_deh != B_I_DEH (de->de_bh, de->de_ih) + entry_num)
reiserfs_panic (0, "yr-7008: get_entry_attributes: dir entry header not found");
#endif /* REISERFS_CHECK */
/* few fields are set already (de_bh, de_item_num, de_deh) */
de->de_entrylen = I_DEH_N_ENTRY_LENGTH (de->de_ih, de->de_deh, entry_num);
de->de_namelen = de->de_entrylen - (de_with_sd (de->de_deh) ? SD_SIZE : 0);
de->de_name = B_I_PITEM (de->de_bh, de->de_ih) + de->de_deh->deh_location;
#ifdef REISERFS_ALIGNED
if ( de->de_name[ de->de_namelen-1 ] == '\0' )
de->de_namelen = strlen(de->de_name);
#endif
/* key of object pointed by entry */
de->de_dir_id = de->de_deh->deh_dir_id;
de->de_objectid = de->de_deh->deh_objectid;
/* key of the entry */
memcpy (&(de->de_entry_key.k_dir_id), &(de->de_ih->ih_key), SHORT_KEY_SIZE);
de->de_entry_key.k_offset = de->de_deh->deh_offset;
de->de_entry_key.k_uniqueness = DIRENTRY_UNIQUENESS;
}
示例2: search_by_entry_key
/* first calls search_by_key, then, if item is not found looks for the entry inside directory item indicated by
search_by_key. (We assign a key to each directory item, and place multiple entries in a single directory item.)
Fills the path to the entry, and to the entry position in the item */
int search_by_entry_key (struct super_block * sb, struct key * key, struct path * path, int * pos_in_item, int * repeat)
{
/* search for a directory item using key of entry */
if (search_by_key (sb, key, path, repeat, DISK_LEAF_NODE_LEVEL, READ_BLOCKS) == ITEM_FOUND) {
*pos_in_item = 0;
return POSITION_FOUND;
}
#ifdef REISERFS_CHECK
if (!PATH_LAST_POSITION (path))
reiserfs_panic (sb, "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
#endif /* REISERFS_CHECK */
PATH_LAST_POSITION (path) --;
#ifdef REISERFS_CHECK
{
struct item_head * ih = B_N_PITEM_HEAD (PATH_PLAST_BUFFER (path), PATH_LAST_POSITION (path));
if (!I_IS_DIRECTORY_ITEM (ih) || COMP_SHORT_KEYS (&(ih->ih_key), key)) {
print_block (PATH_PLAST_BUFFER (path), 0, -1, -1);
reiserfs_panic (sb, "vs-7005: search_by_entry_key: found item %h is not directory item or "
"does not belong to the same directory as key %k", ih, key);
}
}
#endif /* REISERFS_CHECK */
/* binary search in directory item by third component of the key */
return bin_search_in_dir_item (PATH_PITEM_HEAD (path), B_I_DEH (PATH_PLAST_BUFFER (path), PATH_PITEM_HEAD (path)), key, pos_in_item);
}
示例3: reiserfs_find_entry
static int reiserfs_find_entry (struct inode * dir, const char * name, int namelen, struct path * path_to_entry, struct reiserfs_dir_entry * de)
{
struct key key_to_search;
int repeat;
int retval;
if (!dir || !dir->i_sb)
return POSITION_NOT_FOUND;
if ((unsigned int)namelen > REISERFS_MAX_NAME_LEN (dir->i_sb->s_blocksize))
return POSITION_NOT_FOUND;
/* there are no entries having the same third component of key, so
fourth key component is not used */
copy_key (&key_to_search, INODE_PKEY (dir));
key_to_search.k_offset = get_third_component (name, namelen);
key_to_search.k_uniqueness = DIRENTRY_UNIQUENESS;
while (1) {
/* search for a directory item using the formed key */
if (search_by_key (dir->i_sb, &key_to_search, path_to_entry, &repeat, DISK_LEAF_NODE_LEVEL, READ_BLOCKS) == ITEM_NOT_FOUND) {
/* take previous item */
#ifdef REISERFS_CHECK
if (!PATH_LAST_POSITION (path_to_entry))
reiserfs_panic (dir->i_sb, "vs-7010: reiserfs_find_entry: search_by_key returned bad position == 0");
#endif /* REISERFS_CHECK */
PATH_LAST_POSITION (path_to_entry) --;
}
de->de_bh = PATH_PLAST_BUFFER (path_to_entry);
de->de_item_num = PATH_LAST_POSITION (path_to_entry);
de->de_ih = B_N_PITEM_HEAD (de->de_bh, de->de_item_num);
de->de_deh = B_I_DEH (de->de_bh, de->de_ih);
#ifdef REISERFS_CHECK
if (!I_IS_DIRECTORY_ITEM (de->de_ih) || COMP_SHORT_KEYS (&(de->de_ih->ih_key), INODE_PKEY (dir)))
reiserfs_panic (dir->i_sb, "vs-7020: reiserfs_find_entry: item must be an item of the same directory item as inode");
#endif /* REISERFS_CHECK */
/* we do not check whether bin_search_in_dir_item found the given key, even if so, we still have
to compare names */
bin_search_in_dir_item (de->de_ih, de->de_deh, &key_to_search, &(de->de_entry_num));
/* compare names for all entries having given hash value */
retval = linear_search_in_dir_item (&key_to_search, de, name, namelen);
if (retval != GOTO_PREVIOUS_ITEM)
/* there is no need to scan directory anymore. Given entry found or does not exist */
return retval;
/* there is left neighboring item of this directory and given entry can be there */
key_to_search.k_offset = de->de_ih->ih_key.k_offset - 1;
pathrelse (path_to_entry);
} /* while (1) */
}
示例4: reiserfsck_check_tree
static void reiserfsck_check_tree (int dev, int block, int size, check_function_t comp_func)
{
struct buffer_head * bh;
int what_node;
bh = bread (dev, block, size);
if (bh == 0)
reiserfs_panic("reiserfsck_check_tree: unable to read %lu block on device 0x%x\n",
block, dev);
if (!B_IS_IN_TREE (bh)) {
reiserfs_panic (0, "reiserfsck_check_tree: buffer (%b %z) not in tree", bh, bh);
}
what_node = who_is_this (bh->b_data, bh->b_size);
if (what_node != THE_LEAF && what_node != THE_INTERNAL)
die ("Not formatted node");
if (!is_block_used (bh->b_blocknr))
die ("Not marked as used");
if (is_leaf_node (bh) && is_leaf_bad_xx (bh))
die ("Bad leaf");
if (is_internal_node(bh) && is_internal_bad (bh))
die ("bad internal");
if (is_internal_node (bh)) {
int i;
struct disk_child * dc;
dc = B_N_CHILD (bh, 0);
for (i = 0; i <= B_NR_ITEMS (bh); i ++, dc ++) {
reiserfsck_check_tree (dev, dc_block_number(dc), size, comp_func);
g_dkey = B_N_PDELIM_KEY (bh, i);
}
} else if (is_leaf_node (bh)) {
g_right = bh;
if (g_left != 0 && g_dkey != 0) {
comp_func ();
brelse (g_left);
}
g_left = g_right;
return;
} else {
reiserfs_panic ("reiserfsck_check_tree: block %lu has bad block type (%b)",
bh->b_blocknr, bh);
}
brelse (bh);
}
示例5: check_leaf_block_head
static void check_leaf_block_head (struct buffer_head * bh)
{
struct block_head * blkh;
int nr;
blkh = B_BLK_HEAD (bh);
nr = blkh_nr_item(blkh);
if ( nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
reiserfs_panic (0, "vs-6010: check_leaf_block_head: invalid item number %z", bh);
if ( blkh_free_space(blkh) >
bh->b_size - BLKH_SIZE - IH_SIZE * nr )
reiserfs_panic (0, "vs-6020: check_leaf_block_head: invalid free space %z", bh);
}
示例6: compare_neighboring_leaves_in_pass1
static void compare_neighboring_leaves_in_pass1 (void)
{
struct key * left = B_N_PKEY (g_left, B_NR_ITEMS (g_left) - 1);
if (comp_keys (left, B_N_PKEY (g_right, 0)) != -1/*SECOND_GREATER*/)
die ("compare_neighboring_leaves_in_pass1: left key is greater, that the right one");
if (/*comp_keys (B_PRIGHT_DELIM_KEY (g_left), g_dkey) == FIRST_GREATER ||*/
comp_keys (g_dkey, B_N_PKEY (g_right, 0))) {
reiserfs_panic (0, "compare_neighboring_leaves_in_pass1: dkey %k, first key in right %k",
g_dkey, B_N_PKEY (g_right, 0));
}
check_items (g_left);
/*&&&&&&&&&&&&&&&&&&&&&&&&&&
for (i = 0, ih = B_N_PITEM_HEAD (g_left, i); i < B_NR_ITEMS (g_left); i ++, ih ++)
if (is_item_accessed (ih) == YES)
die ("compare_neighboring_leaves_in_pass1: item marked as accessed in g_left");
for (i = 0, ih = B_N_PITEM_HEAD (g_right, i); i < B_NR_ITEMS (g_right); i ++, ih ++)
if (is_item_accessed (ih) == YES)
die ("compare_neighboring_leaves_in_pass1: item marked as accessed in g_right");
&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
}
示例7: check_internal_block_head
static void check_internal_block_head (struct buffer_head * bh)
{
struct block_head * blkh;
blkh = B_BLK_HEAD (bh);
if (!(B_LEVEL (bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL (bh) <= MAX_HEIGHT))
reiserfs_panic (0, "vs-6025: check_internal_block_head: invalid level %z", bh);
if (B_NR_ITEMS (bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
reiserfs_panic (0, "vs-6030: check_internal_block_head: invalid item number %z", bh);
if (B_FREE_SPACE (bh) !=
bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS (bh) - DC_SIZE * (B_NR_ITEMS (bh) + 1))
reiserfs_panic (0, "vs-6040: check_internal_block_head: invalid free space %z", bh);
}
示例8: compare_neighboring_leaves_after_all
static void compare_neighboring_leaves_after_all (void)
{
struct item_head * left = B_N_PITEM_HEAD(g_left, B_NR_ITEMS (g_left) - 1);
struct item_head * right = B_N_PITEM_HEAD(g_right, 0);
/* struct key * left = B_N_PKEY (g_left, B_NR_ITEMS (g_left) - 1);
struct key * right = B_N_PKEY (g_right, 0);*/
/*
if (comp_keys (&left->ih_key, B_PRIGHT_DELIM_KEY (g_left)) != SECOND_GREATER)
die ("compare_neighboring_leaves_after_all: invalid right delimiting key");
*/
if (comp_keys (&left->ih_key, B_N_PKEY (g_right, 0)) != -1/*SECOND_GREATER*/)
die ("compare_neighboring_leaves_after_all: left key is greater than the right one");
if (//comp_le_keys (B_PRIGHT_DELIM_KEY (g_left), g_dkey) != KEYS_IDENTICAL ||
comp_keys (g_dkey, B_N_PKEY (g_right, 0))) {
reiserfs_panic (0, "compare_neighboring_leaves_after all: invalid delimiting keys from left to right (%k %k)",
g_dkey, B_N_PKEY (g_right, 0));
}
if (!not_of_one_file (&left->ih_key, &right->ih_key)) {
// items of one file: check offset correctness
if (is_direct_ih (left) || is_indirect_ih (left))
//if (get_offset(&right->ih_key) != get_offset(&left->ih_key) + get_bytes_number (g_left, left /*B_NR_ITEMS (g_left) - 1*/, 0, CHECK_FREE_BYTES))
if (get_offset(&right->ih_key) != get_offset(&left->ih_key) + get_bytes_number (left, g_left->b_size))
die ("compare_neighboring_leaves_after all: hole between items or items are overlapped");
}
is_there_unaccessed_items (g_left);
}
示例9: check_objectid_map
static void check_objectid_map(struct super_block *s, __le32 * map)
{
if (le32_to_cpu(map[0]) != 1)
reiserfs_panic(s, "vs-15010", "map corrupted: %lx",
(long unsigned int)le32_to_cpu(map[0]));
// FIXME: add something else here
}
示例10: reiserfs_check_lock_depth
/*
* Utility function to force a BUG if it is called without the superblock
* write lock held. caller is the string printed just before calling BUG()
*/
void reiserfs_check_lock_depth(struct super_block *sb, char *caller)
{
struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
if (sb_i->lock_depth < 0)
reiserfs_panic(sb, "%s called without kernel lock held %d",
caller);
}
示例11: entry_points_to_object
static int entry_points_to_object (const char * name, int len, struct reiserfs_dir_entry * de, struct inode * inode)
{
if (!de_still_valid (name, len, de))
return 0;
if (inode) {
if (!de_visible (de->de_deh))
reiserfs_panic (0, "vs-7042: entry_points_to_object: entry must be visible");
return (de->de_objectid == inode->i_ino) ? 1 : 0;
}
/* this must be added hidden entry */
if (de_visible (de->de_deh))
reiserfs_panic (0, "vs-7043: entry_points_to_object: entry must be visible");
return 1;
}
示例12: linear_search_in_dir_item
/* after this function de_entry_num is set correctly only if name
found or there was no entries with given hash value */
static int linear_search_in_dir_item (struct key * key, struct reiserfs_dir_entry * de, const char * name, int namelen)
{
int retval;
int i;
i = de->de_entry_num;
if (i == I_ENTRY_COUNT (de->de_ih) ||
GET_HASH_VALUE (de->de_deh[i].deh_offset) != GET_HASH_VALUE (key->k_offset)) {
i --;
}
#ifdef REISERFS_CHECK
if (de->de_deh != B_I_DEH (de->de_bh, de->de_ih))
reiserfs_panic (0, "vs-7010: linear_search_in_dir_item: array of entry headers not found");
#endif /* REISERFS_CHECK */
de->de_deh += i;
for (; i >= 0; i --, de->de_deh --) {
if (GET_HASH_VALUE (de->de_deh->deh_offset) != GET_HASH_VALUE (key->k_offset)) {
return POSITION_NOT_FOUND;
}
/* mark, that this generation number is used */
if (de->de_gen_number_bit_string)
set_bit (GET_GENERATION_NUMBER (de->de_deh->deh_offset), de->de_gen_number_bit_string);
/* de_bh, de_item_num, de_ih, de_deh are already set. Set others fields */
get_entry_attributes (de, i);
if ((retval = try_name (de, name, namelen)) != POSITION_NOT_FOUND) {
de->de_entry_num = i;
return retval;
}
}
if (GET_GENERATION_NUMBER (de->de_ih->ih_key.k_offset) == 0)
return POSITION_NOT_FOUND;
#ifdef REISERFS_CHECK
if (de->de_ih->ih_key.k_offset <= DOT_DOT_OFFSET || de->de_item_num != 0)
reiserfs_panic (0, "vs-7015: linear_search_in_dir_item: item must be 0-th item in block (%d)", de->de_item_num);
#endif /* REISERFS_CHECK */
return GOTO_PREVIOUS_ITEM;
}
示例13: reiserfs_add_entry
/* add new name into a directory. If it exists in a directory - do
nothing */
int reiserfs_add_entry (reiserfs_filsys_t fs, struct key * dir, char * name,
struct key * key, int fsck_need)
{
struct item_head entry_ih = {{0,}, };
char * entry;
int retval;
INITIALIZE_PATH(path);
int gen_counter;
int item_len;
__u32 hash;
if (reiserfs_find_entry (fs, dir, name, &gen_counter))
return 0;
/* compose entry key to look for its place in the tree */
entry_ih.ih_key.k_dir_id = cpu_to_le32 (dir->k_dir_id);
entry_ih.ih_key.k_objectid = cpu_to_le32 (dir->k_objectid);
hash = hash_value (fs, name) + gen_counter;
if (!strcmp (name, "."))
hash = DOT_OFFSET;
if (!strcmp (name, ".."))
hash = DOT_DOT_OFFSET;
set_type_and_offset (KEY_FORMAT_1, &(entry_ih.ih_key),
hash, TYPE_DIRENTRY);
set_ih_key_format (&entry_ih, KEY_FORMAT_1);
set_entry_count (&entry_ih, 1);
if (SB_VERSION (fs) == REISERFS_VERSION_2)
item_len = DEH_SIZE + ROUND_UP (strlen (name));
else
item_len = DEH_SIZE + strlen (name);
set_ih_item_len (&entry_ih, item_len);
/* fsck may need to insert item which was not reached yet */
set_ih_fsck_need( &entry_ih, fsck_need );
entry = make_entry (0, name, key, get_offset (&(entry_ih.ih_key)));
retval = _search_by_entry_key (fs, &(entry_ih.ih_key), &path);
switch (retval) {
case POSITION_NOT_FOUND:
reiserfs_paste_into_item (fs, &path, entry, item_len);
break;
case DIRECTORY_NOT_FOUND:
set_deh_location( (struct reiserfs_de_head *)entry, DEH_SIZE );
reiserfs_insert_item (fs, &path, &entry_ih, entry);
break;
default:
reiserfs_panic ("reiserfs_add_entry: looking for %k (inserting name \"%s\") "
"search_by_entry_key returned %d",
&(entry_ih.ih_key), name, retval);
}
freemem (entry);
return item_len;
}
示例14: search_by_entry_key
/* The function is NOT SCHEDULE-SAFE! */
int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
struct treepath *path, struct reiserfs_dir_entry *de)
{
int retval;
retval = search_item(sb, key, path);
switch (retval) {
case ITEM_NOT_FOUND:
if (!PATH_LAST_POSITION(path)) {
reiserfs_error(sb, "vs-7000", "search_by_key "
"returned item position == 0");
pathrelse(path);
return IO_ERROR;
}
PATH_LAST_POSITION(path)--;
case ITEM_FOUND:
break;
case IO_ERROR:
return retval;
default:
pathrelse(path);
reiserfs_error(sb, "vs-7002", "no path to here");
return IO_ERROR;
}
set_de_item_location(de, path);
#ifdef CONFIG_REISERFS_CHECK
if (!is_direntry_le_ih(de->de_ih) ||
COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) {
print_block(de->de_bh, 0, -1, -1);
reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
"item or does not belong to the same directory "
"as key %K", de->de_ih, key);
}
#endif /* CONFIG_REISERFS_CHECK */
/*
* binary search in directory item by third component of the
* key. sets de->de_entry_num of de
*/
retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
path->pos_in_item = de->de_entry_num;
if (retval != NAME_NOT_FOUND) {
/*
* ugly, but rename needs de_bh, de_deh, de_name,
* de_namelen, de_objectid set
*/
set_de_name_and_namelen(de);
set_de_object_key(de);
}
return retval;
}
示例15: reiserfs_paste_into_item
void reiserfs_paste_into_item (reiserfs_filsys_t fs, struct path * path,
const void * body, int size)
{
struct tree_balance tb;
_init_tb_struct (&tb, fs, path, size);
if (fix_nodes (M_PASTE, &tb, 0/*ih*/) != CARRY_ON)
reiserfs_panic ("reiserfs_paste_into_item: fix_nodes failed");
do_balance (&tb, 0, body, M_PASTE, 0/*zero num*/);
}