URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [tags/] [LINUX_2_4_26_OR32/] [linux/] [linux-2.4/] [fs/] [reiserfs/] [item_ops.c] - Rev 1275
Go to most recent revision | Compare with Previous | Blame | View Log
/* * Copyright 2000-2002 by Hans Reiser, licensing governed by reiserfs/README */ #include <linux/sched.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 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\n", vi->vi_index, vi->vi_type, vi->vi_ih); } struct item_operations stat_data_ops = { sd_bytes_number, sd_decrement_key, sd_is_left_mergeable, sd_print_item, sd_check_item, sd_create_vi, sd_check_left, sd_check_right, sd_part_size, sd_unit_num, 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 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\n", vi->vi_index, vi->vi_type, vi->vi_ih); } struct item_operations direct_ops = { direct_bytes_number, direct_decrement_key, direct_is_left_mergeable, direct_print_item, direct_check_item, direct_create_vi, direct_check_left, direct_check_right, direct_part_size, direct_unit_num, 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 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; __u32 * unp, prev = INT_MAX; int num; unp = (__u32 *)item; if (ih_item_len(ih) % UNFM_P_SIZE) printk ("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\n", vi->vi_index, vi->vi_type, vi->vi_ih); } struct item_operations indirect_ops = { indirect_bytes_number, indirect_decrement_key, indirect_is_left_mergeable, indirect_print_item, indirect_check_item, indirect_create_vi, indirect_check_left, indirect_check_right, indirect_part_size, indirect_unit_num, 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 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 (0, "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) { printk ("free spze %d, entry_count %d\n", free, dir_u->entry_count); BUG (); } /* "." 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\n", 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"); } struct item_operations direntry_ops = { direntry_bytes_number, direntry_decrement_key, direntry_is_left_mergeable, direntry_print_item, direntry_check_item, direntry_create_vi, direntry_check_left, direntry_check_right, direntry_part_size, direntry_unit_num, 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\n"); return 0; } static void errcatch_decrement_key (struct cpu_key * key) { reiserfs_warning (NULL, "green-16002: Invalid item type observed, run fsck ASAP\n"); } static int errcatch_is_left_mergeable (struct key * key, unsigned long bsize) { reiserfs_warning (NULL, "green-16003: Invalid item type observed, run fsck ASAP\n"); 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\n"); } static void errcatch_check_item (struct item_head * ih, char * item) { reiserfs_warning (NULL, "green-16005: Invalid item type observed, run fsck ASAP\n"); } 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\n"); 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\n"); 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\n"); 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\n"); return 0; } static int errcatch_unit_num (struct virtual_item * vi) { reiserfs_warning (NULL, "green-16010: Invalid item type observed, run fsck ASAP\n"); return 0; } static void errcatch_print_vi (struct virtual_item * vi) { reiserfs_warning (NULL, "green-16011: Invalid item type observed, run fsck ASAP\n"); } 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) do not compile #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) */ };
Go to most recent revision | Compare with Previous | Blame | View Log