d5ee4ea833
fs/reiserfs/item_ops.c: In function 'indirect_print_item': fs/reiserfs/item_ops.c:278: warning: 'num' may be used uninitialized in this function (akpm: this is probably just gcc being dumb) Signed-off-by: Benoit Boissinot <benoit.boissinot@ens-lyon.fr> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
754 lines
19 KiB
C
754 lines
19 KiB
C
/*
|
|
* Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
|
|
*/
|
|
|
|
#include <linux/time.h>
|
|
#include <linux/reiserfs_fs.h>
|
|
|
|
// this contains item handlers for old item types: sd, direct,
|
|
// indirect, directory
|
|
|
|
/* and where are the comments? how about saying where we can find an
|
|
explanation of each item handler method? -Hans */
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// stat data functions
|
|
//
|
|
static int sd_bytes_number(struct item_head *ih, int block_size)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void sd_decrement_key(struct cpu_key *key)
|
|
{
|
|
key->on_disk_key.k_objectid--;
|
|
set_cpu_key_k_type(key, TYPE_ANY);
|
|
set_cpu_key_k_offset(key, (loff_t) (-1));
|
|
}
|
|
|
|
static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static char *print_time(time_t t)
|
|
{
|
|
static char timebuf[256];
|
|
|
|
sprintf(timebuf, "%ld", t);
|
|
return timebuf;
|
|
}
|
|
|
|
static void sd_print_item(struct item_head *ih, char *item)
|
|
{
|
|
printk("\tmode | size | nlinks | first direct | mtime\n");
|
|
if (stat_data_v1(ih)) {
|
|
struct stat_data_v1 *sd = (struct stat_data_v1 *)item;
|
|
|
|
printk("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd),
|
|
sd_v1_size(sd), sd_v1_nlink(sd),
|
|
sd_v1_first_direct_byte(sd),
|
|
print_time(sd_v1_mtime(sd)));
|
|
} else {
|
|
struct stat_data *sd = (struct stat_data *)item;
|
|
|
|
printk("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd),
|
|
(unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),
|
|
sd_v2_rdev(sd), print_time(sd_v2_mtime(sd)));
|
|
}
|
|
}
|
|
|
|
static void sd_check_item(struct item_head *ih, char *item)
|
|
{
|
|
// FIXME: type something here!
|
|
}
|
|
|
|
static int sd_create_vi(struct virtual_node *vn,
|
|
struct virtual_item *vi,
|
|
int is_affected, int insert_size)
|
|
{
|
|
vi->vi_index = TYPE_STAT_DATA;
|
|
//vi->vi_type |= VI_TYPE_STAT_DATA;// not needed?
|
|
return 0;
|
|
}
|
|
|
|
static int sd_check_left(struct virtual_item *vi, int free,
|
|
int start_skip, int end_skip)
|
|
{
|
|
if (start_skip || end_skip)
|
|
BUG();
|
|
return -1;
|
|
}
|
|
|
|
static int sd_check_right(struct virtual_item *vi, int free)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
static int sd_part_size(struct virtual_item *vi, int first, int count)
|
|
{
|
|
if (count)
|
|
BUG();
|
|
return 0;
|
|
}
|
|
|
|
static int sd_unit_num(struct virtual_item *vi)
|
|
{
|
|
return vi->vi_item_len - IH_SIZE;
|
|
}
|
|
|
|
static void sd_print_vi(struct virtual_item *vi)
|
|
{
|
|
reiserfs_warning(NULL, "STATDATA, index %d, type 0x%x, %h",
|
|
vi->vi_index, vi->vi_type, vi->vi_ih);
|
|
}
|
|
|
|
static struct item_operations stat_data_ops = {
|
|
.bytes_number = sd_bytes_number,
|
|
.decrement_key = sd_decrement_key,
|
|
.is_left_mergeable = sd_is_left_mergeable,
|
|
.print_item = sd_print_item,
|
|
.check_item = sd_check_item,
|
|
|
|
.create_vi = sd_create_vi,
|
|
.check_left = sd_check_left,
|
|
.check_right = sd_check_right,
|
|
.part_size = sd_part_size,
|
|
.unit_num = sd_unit_num,
|
|
.print_vi = sd_print_vi
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// direct item functions
|
|
//
|
|
static int direct_bytes_number(struct item_head *ih, int block_size)
|
|
{
|
|
return ih_item_len(ih);
|
|
}
|
|
|
|
// FIXME: this should probably switch to indirect as well
|
|
static void direct_decrement_key(struct cpu_key *key)
|
|
{
|
|
cpu_key_k_offset_dec(key);
|
|
if (cpu_key_k_offset(key) == 0)
|
|
set_cpu_key_k_type(key, TYPE_STAT_DATA);
|
|
}
|
|
|
|
static int direct_is_left_mergeable(struct reiserfs_key *key,
|
|
unsigned long bsize)
|
|
{
|
|
int version = le_key_version(key);
|
|
return ((le_key_k_offset(version, key) & (bsize - 1)) != 1);
|
|
}
|
|
|
|
static void direct_print_item(struct item_head *ih, char *item)
|
|
{
|
|
int j = 0;
|
|
|
|
// return;
|
|
printk("\"");
|
|
while (j < ih_item_len(ih))
|
|
printk("%c", item[j++]);
|
|
printk("\"\n");
|
|
}
|
|
|
|
static void direct_check_item(struct item_head *ih, char *item)
|
|
{
|
|
// FIXME: type something here!
|
|
}
|
|
|
|
static int direct_create_vi(struct virtual_node *vn,
|
|
struct virtual_item *vi,
|
|
int is_affected, int insert_size)
|
|
{
|
|
vi->vi_index = TYPE_DIRECT;
|
|
//vi->vi_type |= VI_TYPE_DIRECT;
|
|
return 0;
|
|
}
|
|
|
|
static int direct_check_left(struct virtual_item *vi, int free,
|
|
int start_skip, int end_skip)
|
|
{
|
|
int bytes;
|
|
|
|
bytes = free - free % 8;
|
|
return bytes ? : -1;
|
|
}
|
|
|
|
static int direct_check_right(struct virtual_item *vi, int free)
|
|
{
|
|
return direct_check_left(vi, free, 0, 0);
|
|
}
|
|
|
|
static int direct_part_size(struct virtual_item *vi, int first, int count)
|
|
{
|
|
return count;
|
|
}
|
|
|
|
static int direct_unit_num(struct virtual_item *vi)
|
|
{
|
|
return vi->vi_item_len - IH_SIZE;
|
|
}
|
|
|
|
static void direct_print_vi(struct virtual_item *vi)
|
|
{
|
|
reiserfs_warning(NULL, "DIRECT, index %d, type 0x%x, %h",
|
|
vi->vi_index, vi->vi_type, vi->vi_ih);
|
|
}
|
|
|
|
static struct item_operations direct_ops = {
|
|
.bytes_number = direct_bytes_number,
|
|
.decrement_key = direct_decrement_key,
|
|
.is_left_mergeable = direct_is_left_mergeable,
|
|
.print_item = direct_print_item,
|
|
.check_item = direct_check_item,
|
|
|
|
.create_vi = direct_create_vi,
|
|
.check_left = direct_check_left,
|
|
.check_right = direct_check_right,
|
|
.part_size = direct_part_size,
|
|
.unit_num = direct_unit_num,
|
|
.print_vi = direct_print_vi
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// indirect item functions
|
|
//
|
|
|
|
static int indirect_bytes_number(struct item_head *ih, int block_size)
|
|
{
|
|
return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih);
|
|
}
|
|
|
|
// decrease offset, if it becomes 0, change type to stat data
|
|
static void indirect_decrement_key(struct cpu_key *key)
|
|
{
|
|
cpu_key_k_offset_dec(key);
|
|
if (cpu_key_k_offset(key) == 0)
|
|
set_cpu_key_k_type(key, TYPE_STAT_DATA);
|
|
}
|
|
|
|
// if it is not first item of the body, then it is mergeable
|
|
static int indirect_is_left_mergeable(struct reiserfs_key *key,
|
|
unsigned long bsize)
|
|
{
|
|
int version = le_key_version(key);
|
|
return (le_key_k_offset(version, key) != 1);
|
|
}
|
|
|
|
// printing of indirect item
|
|
static void start_new_sequence(__u32 * start, int *len, __u32 new)
|
|
{
|
|
*start = new;
|
|
*len = 1;
|
|
}
|
|
|
|
static int sequence_finished(__u32 start, int *len, __u32 new)
|
|
{
|
|
if (start == INT_MAX)
|
|
return 1;
|
|
|
|
if (start == 0 && new == 0) {
|
|
(*len)++;
|
|
return 0;
|
|
}
|
|
if (start != 0 && (start + *len) == new) {
|
|
(*len)++;
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void print_sequence(__u32 start, int len)
|
|
{
|
|
if (start == INT_MAX)
|
|
return;
|
|
|
|
if (len == 1)
|
|
printk(" %d", start);
|
|
else
|
|
printk(" %d(%d)", start, len);
|
|
}
|
|
|
|
static void indirect_print_item(struct item_head *ih, char *item)
|
|
{
|
|
int j;
|
|
__le32 *unp;
|
|
__u32 prev = INT_MAX;
|
|
int num = 0;
|
|
|
|
unp = (__le32 *) item;
|
|
|
|
if (ih_item_len(ih) % UNFM_P_SIZE)
|
|
reiserfs_warning(NULL, "indirect_print_item: invalid item len");
|
|
|
|
printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih));
|
|
for (j = 0; j < I_UNFM_NUM(ih); j++) {
|
|
if (sequence_finished(prev, &num, get_block_num(unp, j))) {
|
|
print_sequence(prev, num);
|
|
start_new_sequence(&prev, &num, get_block_num(unp, j));
|
|
}
|
|
}
|
|
print_sequence(prev, num);
|
|
printk("]\n");
|
|
}
|
|
|
|
static void indirect_check_item(struct item_head *ih, char *item)
|
|
{
|
|
// FIXME: type something here!
|
|
}
|
|
|
|
static int indirect_create_vi(struct virtual_node *vn,
|
|
struct virtual_item *vi,
|
|
int is_affected, int insert_size)
|
|
{
|
|
vi->vi_index = TYPE_INDIRECT;
|
|
//vi->vi_type |= VI_TYPE_INDIRECT;
|
|
return 0;
|
|
}
|
|
|
|
static int indirect_check_left(struct virtual_item *vi, int free,
|
|
int start_skip, int end_skip)
|
|
{
|
|
int bytes;
|
|
|
|
bytes = free - free % UNFM_P_SIZE;
|
|
return bytes ? : -1;
|
|
}
|
|
|
|
static int indirect_check_right(struct virtual_item *vi, int free)
|
|
{
|
|
return indirect_check_left(vi, free, 0, 0);
|
|
}
|
|
|
|
// return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right)
|
|
static int indirect_part_size(struct virtual_item *vi, int first, int units)
|
|
{
|
|
// unit of indirect item is byte (yet)
|
|
return units;
|
|
}
|
|
|
|
static int indirect_unit_num(struct virtual_item *vi)
|
|
{
|
|
// unit of indirect item is byte (yet)
|
|
return vi->vi_item_len - IH_SIZE;
|
|
}
|
|
|
|
static void indirect_print_vi(struct virtual_item *vi)
|
|
{
|
|
reiserfs_warning(NULL, "INDIRECT, index %d, type 0x%x, %h",
|
|
vi->vi_index, vi->vi_type, vi->vi_ih);
|
|
}
|
|
|
|
static struct item_operations indirect_ops = {
|
|
.bytes_number = indirect_bytes_number,
|
|
.decrement_key = indirect_decrement_key,
|
|
.is_left_mergeable = indirect_is_left_mergeable,
|
|
.print_item = indirect_print_item,
|
|
.check_item = indirect_check_item,
|
|
|
|
.create_vi = indirect_create_vi,
|
|
.check_left = indirect_check_left,
|
|
.check_right = indirect_check_right,
|
|
.part_size = indirect_part_size,
|
|
.unit_num = indirect_unit_num,
|
|
.print_vi = indirect_print_vi
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// direntry functions
|
|
//
|
|
|
|
static int direntry_bytes_number(struct item_head *ih, int block_size)
|
|
{
|
|
reiserfs_warning(NULL, "vs-16090: direntry_bytes_number: "
|
|
"bytes number is asked for direntry");
|
|
return 0;
|
|
}
|
|
|
|
static void direntry_decrement_key(struct cpu_key *key)
|
|
{
|
|
cpu_key_k_offset_dec(key);
|
|
if (cpu_key_k_offset(key) == 0)
|
|
set_cpu_key_k_type(key, TYPE_STAT_DATA);
|
|
}
|
|
|
|
static int direntry_is_left_mergeable(struct reiserfs_key *key,
|
|
unsigned long bsize)
|
|
{
|
|
if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET)
|
|
return 0;
|
|
return 1;
|
|
|
|
}
|
|
|
|
static void direntry_print_item(struct item_head *ih, char *item)
|
|
{
|
|
int i;
|
|
int namelen;
|
|
struct reiserfs_de_head *deh;
|
|
char *name;
|
|
static char namebuf[80];
|
|
|
|
printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name",
|
|
"Key of pointed object", "Hash", "Gen number", "Status");
|
|
|
|
deh = (struct reiserfs_de_head *)item;
|
|
|
|
for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
|
|
namelen =
|
|
(i ? (deh_location(deh - 1)) : ih_item_len(ih)) -
|
|
deh_location(deh);
|
|
name = item + deh_location(deh);
|
|
if (name[namelen - 1] == 0)
|
|
namelen = strlen(name);
|
|
namebuf[0] = '"';
|
|
if (namelen > sizeof(namebuf) - 3) {
|
|
strncpy(namebuf + 1, name, sizeof(namebuf) - 3);
|
|
namebuf[sizeof(namebuf) - 2] = '"';
|
|
namebuf[sizeof(namebuf) - 1] = 0;
|
|
} else {
|
|
memcpy(namebuf + 1, name, namelen);
|
|
namebuf[namelen + 1] = '"';
|
|
namebuf[namelen + 2] = 0;
|
|
}
|
|
|
|
printk("%d: %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n",
|
|
i, namebuf,
|
|
deh_dir_id(deh), deh_objectid(deh),
|
|
GET_HASH_VALUE(deh_offset(deh)),
|
|
GET_GENERATION_NUMBER((deh_offset(deh))),
|
|
(de_hidden(deh)) ? "HIDDEN" : "VISIBLE");
|
|
}
|
|
}
|
|
|
|
static void direntry_check_item(struct item_head *ih, char *item)
|
|
{
|
|
int i;
|
|
struct reiserfs_de_head *deh;
|
|
|
|
// FIXME: type something here!
|
|
deh = (struct reiserfs_de_head *)item;
|
|
for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
|
|
;
|
|
}
|
|
}
|
|
|
|
#define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
|
|
|
|
/*
|
|
* function returns old entry number in directory item in real node
|
|
* using new entry number in virtual item in virtual node */
|
|
static inline int old_entry_num(int is_affected, int virtual_entry_num,
|
|
int pos_in_item, int mode)
|
|
{
|
|
if (mode == M_INSERT || mode == M_DELETE)
|
|
return virtual_entry_num;
|
|
|
|
if (!is_affected)
|
|
/* cut or paste is applied to another item */
|
|
return virtual_entry_num;
|
|
|
|
if (virtual_entry_num < pos_in_item)
|
|
return virtual_entry_num;
|
|
|
|
if (mode == M_CUT)
|
|
return virtual_entry_num + 1;
|
|
|
|
RFALSE(mode != M_PASTE || virtual_entry_num == 0,
|
|
"vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'",
|
|
mode);
|
|
|
|
return virtual_entry_num - 1;
|
|
}
|
|
|
|
/* Create an array of sizes of directory entries for virtual
|
|
item. Return space used by an item. FIXME: no control over
|
|
consuming of space used by this item handler */
|
|
static int direntry_create_vi(struct virtual_node *vn,
|
|
struct virtual_item *vi,
|
|
int is_affected, int insert_size)
|
|
{
|
|
struct direntry_uarea *dir_u = vi->vi_uarea;
|
|
int i, j;
|
|
int size = sizeof(struct direntry_uarea);
|
|
struct reiserfs_de_head *deh;
|
|
|
|
vi->vi_index = TYPE_DIRENTRY;
|
|
|
|
if (!(vi->vi_ih) || !vi->vi_item)
|
|
BUG();
|
|
|
|
dir_u->flags = 0;
|
|
if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET)
|
|
dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
|
|
|
|
deh = (struct reiserfs_de_head *)(vi->vi_item);
|
|
|
|
/* virtual directory item have this amount of entry after */
|
|
dir_u->entry_count = ih_entry_count(vi->vi_ih) +
|
|
((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
|
|
(vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
|
|
|
|
for (i = 0; i < dir_u->entry_count; i++) {
|
|
j = old_entry_num(is_affected, i, vn->vn_pos_in_item,
|
|
vn->vn_mode);
|
|
dir_u->entry_sizes[i] =
|
|
(j ? deh_location(&(deh[j - 1])) : ih_item_len(vi->vi_ih)) -
|
|
deh_location(&(deh[j])) + DEH_SIZE;
|
|
}
|
|
|
|
size += (dir_u->entry_count * sizeof(short));
|
|
|
|
/* set size of pasted entry */
|
|
if (is_affected && vn->vn_mode == M_PASTE)
|
|
dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
|
|
|
|
#ifdef CONFIG_REISERFS_CHECK
|
|
/* compare total size of entries with item length */
|
|
{
|
|
int k, l;
|
|
|
|
l = 0;
|
|
for (k = 0; k < dir_u->entry_count; k++)
|
|
l += dir_u->entry_sizes[k];
|
|
|
|
if (l + IH_SIZE != vi->vi_item_len +
|
|
((is_affected
|
|
&& (vn->vn_mode == M_PASTE
|
|
|| vn->vn_mode == M_CUT)) ? insert_size : 0)) {
|
|
reiserfs_panic(NULL,
|
|
"vs-8025: set_entry_sizes: (mode==%c, insert_size==%d), invalid length of directory item",
|
|
vn->vn_mode, insert_size);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
//
|
|
// return number of entries which may fit into specified amount of
|
|
// free space, or -1 if free space is not enough even for 1 entry
|
|
//
|
|
static int direntry_check_left(struct virtual_item *vi, int free,
|
|
int start_skip, int end_skip)
|
|
{
|
|
int i;
|
|
int entries = 0;
|
|
struct direntry_uarea *dir_u = vi->vi_uarea;
|
|
|
|
for (i = start_skip; i < dir_u->entry_count - end_skip; i++) {
|
|
if (dir_u->entry_sizes[i] > free)
|
|
/* i-th entry doesn't fit into the remaining free space */
|
|
break;
|
|
|
|
free -= dir_u->entry_sizes[i];
|
|
entries++;
|
|
}
|
|
|
|
if (entries == dir_u->entry_count) {
|
|
reiserfs_panic(NULL, "free space %d, entry_count %d\n", free,
|
|
dir_u->entry_count);
|
|
}
|
|
|
|
/* "." and ".." can not be separated from each other */
|
|
if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
|
|
&& entries < 2)
|
|
entries = 0;
|
|
|
|
return entries ? : -1;
|
|
}
|
|
|
|
static int direntry_check_right(struct virtual_item *vi, int free)
|
|
{
|
|
int i;
|
|
int entries = 0;
|
|
struct direntry_uarea *dir_u = vi->vi_uarea;
|
|
|
|
for (i = dir_u->entry_count - 1; i >= 0; i--) {
|
|
if (dir_u->entry_sizes[i] > free)
|
|
/* i-th entry doesn't fit into the remaining free space */
|
|
break;
|
|
|
|
free -= dir_u->entry_sizes[i];
|
|
entries++;
|
|
}
|
|
if (entries == dir_u->entry_count)
|
|
BUG();
|
|
|
|
/* "." and ".." can not be separated from each other */
|
|
if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
|
|
&& entries > dir_u->entry_count - 2)
|
|
entries = dir_u->entry_count - 2;
|
|
|
|
return entries ? : -1;
|
|
}
|
|
|
|
/* sum of entry sizes between from-th and to-th entries including both edges */
|
|
static int direntry_part_size(struct virtual_item *vi, int first, int count)
|
|
{
|
|
int i, retval;
|
|
int from, to;
|
|
struct direntry_uarea *dir_u = vi->vi_uarea;
|
|
|
|
retval = 0;
|
|
if (first == 0)
|
|
from = 0;
|
|
else
|
|
from = dir_u->entry_count - count;
|
|
to = from + count - 1;
|
|
|
|
for (i = from; i <= to; i++)
|
|
retval += dir_u->entry_sizes[i];
|
|
|
|
return retval;
|
|
}
|
|
|
|
static int direntry_unit_num(struct virtual_item *vi)
|
|
{
|
|
struct direntry_uarea *dir_u = vi->vi_uarea;
|
|
|
|
return dir_u->entry_count;
|
|
}
|
|
|
|
static void direntry_print_vi(struct virtual_item *vi)
|
|
{
|
|
int i;
|
|
struct direntry_uarea *dir_u = vi->vi_uarea;
|
|
|
|
reiserfs_warning(NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
|
|
vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
|
|
printk("%d entries: ", dir_u->entry_count);
|
|
for (i = 0; i < dir_u->entry_count; i++)
|
|
printk("%d ", dir_u->entry_sizes[i]);
|
|
printk("\n");
|
|
}
|
|
|
|
static struct item_operations direntry_ops = {
|
|
.bytes_number = direntry_bytes_number,
|
|
.decrement_key = direntry_decrement_key,
|
|
.is_left_mergeable = direntry_is_left_mergeable,
|
|
.print_item = direntry_print_item,
|
|
.check_item = direntry_check_item,
|
|
|
|
.create_vi = direntry_create_vi,
|
|
.check_left = direntry_check_left,
|
|
.check_right = direntry_check_right,
|
|
.part_size = direntry_part_size,
|
|
.unit_num = direntry_unit_num,
|
|
.print_vi = direntry_print_vi
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Error catching functions to catch errors caused by incorrect item types.
|
|
//
|
|
static int errcatch_bytes_number(struct item_head *ih, int block_size)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16001: Invalid item type observed, run fsck ASAP");
|
|
return 0;
|
|
}
|
|
|
|
static void errcatch_decrement_key(struct cpu_key *key)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16002: Invalid item type observed, run fsck ASAP");
|
|
}
|
|
|
|
static int errcatch_is_left_mergeable(struct reiserfs_key *key,
|
|
unsigned long bsize)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16003: Invalid item type observed, run fsck ASAP");
|
|
return 0;
|
|
}
|
|
|
|
static void errcatch_print_item(struct item_head *ih, char *item)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16004: Invalid item type observed, run fsck ASAP");
|
|
}
|
|
|
|
static void errcatch_check_item(struct item_head *ih, char *item)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16005: Invalid item type observed, run fsck ASAP");
|
|
}
|
|
|
|
static int errcatch_create_vi(struct virtual_node *vn,
|
|
struct virtual_item *vi,
|
|
int is_affected, int insert_size)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16006: Invalid item type observed, run fsck ASAP");
|
|
return 0; // We might return -1 here as well, but it won't help as create_virtual_node() from where
|
|
// this operation is called from is of return type void.
|
|
}
|
|
|
|
static int errcatch_check_left(struct virtual_item *vi, int free,
|
|
int start_skip, int end_skip)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16007: Invalid item type observed, run fsck ASAP");
|
|
return -1;
|
|
}
|
|
|
|
static int errcatch_check_right(struct virtual_item *vi, int free)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16008: Invalid item type observed, run fsck ASAP");
|
|
return -1;
|
|
}
|
|
|
|
static int errcatch_part_size(struct virtual_item *vi, int first, int count)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16009: Invalid item type observed, run fsck ASAP");
|
|
return 0;
|
|
}
|
|
|
|
static int errcatch_unit_num(struct virtual_item *vi)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16010: Invalid item type observed, run fsck ASAP");
|
|
return 0;
|
|
}
|
|
|
|
static void errcatch_print_vi(struct virtual_item *vi)
|
|
{
|
|
reiserfs_warning(NULL,
|
|
"green-16011: Invalid item type observed, run fsck ASAP");
|
|
}
|
|
|
|
static struct item_operations errcatch_ops = {
|
|
errcatch_bytes_number,
|
|
errcatch_decrement_key,
|
|
errcatch_is_left_mergeable,
|
|
errcatch_print_item,
|
|
errcatch_check_item,
|
|
|
|
errcatch_create_vi,
|
|
errcatch_check_left,
|
|
errcatch_check_right,
|
|
errcatch_part_size,
|
|
errcatch_unit_num,
|
|
errcatch_print_vi
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
//
|
|
#if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3)
|
|
#error Item types must use disk-format assigned values.
|
|
#endif
|
|
|
|
struct item_operations *item_ops[TYPE_ANY + 1] = {
|
|
&stat_data_ops,
|
|
&indirect_ops,
|
|
&direct_ops,
|
|
&direntry_ops,
|
|
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
|
|
&errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
|
|
};
|