738 lines · c
1/*2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README3 */4 5#include <linux/time.h>6#include "reiserfs.h"7 8/*9 * this contains item handlers for old item types: sd, direct,10 * indirect, directory11 */12 13/*14 * and where are the comments? how about saying where we can find an15 * explanation of each item handler method? -Hans16 */17 18/* stat data functions */19static int sd_bytes_number(struct item_head *ih, int block_size)20{21 return 0;22}23 24static void sd_decrement_key(struct cpu_key *key)25{26 key->on_disk_key.k_objectid--;27 set_cpu_key_k_type(key, TYPE_ANY);28 set_cpu_key_k_offset(key, (loff_t)(~0ULL >> 1));29}30 31static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize)32{33 return 0;34}35 36static void sd_print_item(struct item_head *ih, char *item)37{38 printk("\tmode | size | nlinks | first direct | mtime\n");39 if (stat_data_v1(ih)) {40 struct stat_data_v1 *sd = (struct stat_data_v1 *)item;41 42 printk("\t0%-6o | %6u | %2u | %d | %u\n", sd_v1_mode(sd),43 sd_v1_size(sd), sd_v1_nlink(sd),44 sd_v1_first_direct_byte(sd),45 sd_v1_mtime(sd));46 } else {47 struct stat_data *sd = (struct stat_data *)item;48 49 printk("\t0%-6o | %6llu | %2u | %d | %u\n", sd_v2_mode(sd),50 (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),51 sd_v2_rdev(sd), sd_v2_mtime(sd));52 }53}54 55static void sd_check_item(struct item_head *ih, char *item)56{57 /* unused */58}59 60static int sd_create_vi(struct virtual_node *vn,61 struct virtual_item *vi,62 int is_affected, int insert_size)63{64 vi->vi_index = TYPE_STAT_DATA;65 return 0;66}67 68static int sd_check_left(struct virtual_item *vi, int free,69 int start_skip, int end_skip)70{71 BUG_ON(start_skip || end_skip);72 return -1;73}74 75static int sd_check_right(struct virtual_item *vi, int free)76{77 return -1;78}79 80static int sd_part_size(struct virtual_item *vi, int first, int count)81{82 BUG_ON(count);83 return 0;84}85 86static int sd_unit_num(struct virtual_item *vi)87{88 return vi->vi_item_len - IH_SIZE;89}90 91static void sd_print_vi(struct virtual_item *vi)92{93 reiserfs_warning(NULL, "reiserfs-16100",94 "STATDATA, index %d, type 0x%x, %h",95 vi->vi_index, vi->vi_type, vi->vi_ih);96}97 98static struct item_operations stat_data_ops = {99 .bytes_number = sd_bytes_number,100 .decrement_key = sd_decrement_key,101 .is_left_mergeable = sd_is_left_mergeable,102 .print_item = sd_print_item,103 .check_item = sd_check_item,104 105 .create_vi = sd_create_vi,106 .check_left = sd_check_left,107 .check_right = sd_check_right,108 .part_size = sd_part_size,109 .unit_num = sd_unit_num,110 .print_vi = sd_print_vi111};112 113/* direct item functions */114static int direct_bytes_number(struct item_head *ih, int block_size)115{116 return ih_item_len(ih);117}118 119/* FIXME: this should probably switch to indirect as well */120static void direct_decrement_key(struct cpu_key *key)121{122 cpu_key_k_offset_dec(key);123 if (cpu_key_k_offset(key) == 0)124 set_cpu_key_k_type(key, TYPE_STAT_DATA);125}126 127static int direct_is_left_mergeable(struct reiserfs_key *key,128 unsigned long bsize)129{130 int version = le_key_version(key);131 return ((le_key_k_offset(version, key) & (bsize - 1)) != 1);132}133 134static void direct_print_item(struct item_head *ih, char *item)135{136 int j = 0;137 138/* return; */139 printk("\"");140 while (j < ih_item_len(ih))141 printk("%c", item[j++]);142 printk("\"\n");143}144 145static void direct_check_item(struct item_head *ih, char *item)146{147 /* unused */148}149 150static int direct_create_vi(struct virtual_node *vn,151 struct virtual_item *vi,152 int is_affected, int insert_size)153{154 vi->vi_index = TYPE_DIRECT;155 return 0;156}157 158static int direct_check_left(struct virtual_item *vi, int free,159 int start_skip, int end_skip)160{161 int bytes;162 163 bytes = free - free % 8;164 return bytes ? : -1;165}166 167static int direct_check_right(struct virtual_item *vi, int free)168{169 return direct_check_left(vi, free, 0, 0);170}171 172static int direct_part_size(struct virtual_item *vi, int first, int count)173{174 return count;175}176 177static int direct_unit_num(struct virtual_item *vi)178{179 return vi->vi_item_len - IH_SIZE;180}181 182static void direct_print_vi(struct virtual_item *vi)183{184 reiserfs_warning(NULL, "reiserfs-16101",185 "DIRECT, index %d, type 0x%x, %h",186 vi->vi_index, vi->vi_type, vi->vi_ih);187}188 189static struct item_operations direct_ops = {190 .bytes_number = direct_bytes_number,191 .decrement_key = direct_decrement_key,192 .is_left_mergeable = direct_is_left_mergeable,193 .print_item = direct_print_item,194 .check_item = direct_check_item,195 196 .create_vi = direct_create_vi,197 .check_left = direct_check_left,198 .check_right = direct_check_right,199 .part_size = direct_part_size,200 .unit_num = direct_unit_num,201 .print_vi = direct_print_vi202};203 204/* indirect item functions */205static int indirect_bytes_number(struct item_head *ih, int block_size)206{207 return ih_item_len(ih) / UNFM_P_SIZE * block_size;208}209 210/* decrease offset, if it becomes 0, change type to stat data */211static void indirect_decrement_key(struct cpu_key *key)212{213 cpu_key_k_offset_dec(key);214 if (cpu_key_k_offset(key) == 0)215 set_cpu_key_k_type(key, TYPE_STAT_DATA);216}217 218/* if it is not first item of the body, then it is mergeable */219static int indirect_is_left_mergeable(struct reiserfs_key *key,220 unsigned long bsize)221{222 int version = le_key_version(key);223 return (le_key_k_offset(version, key) != 1);224}225 226/* printing of indirect item */227static void start_new_sequence(__u32 * start, int *len, __u32 new)228{229 *start = new;230 *len = 1;231}232 233static int sequence_finished(__u32 start, int *len, __u32 new)234{235 if (start == INT_MAX)236 return 1;237 238 if (start == 0 && new == 0) {239 (*len)++;240 return 0;241 }242 if (start != 0 && (start + *len) == new) {243 (*len)++;244 return 0;245 }246 return 1;247}248 249static void print_sequence(__u32 start, int len)250{251 if (start == INT_MAX)252 return;253 254 if (len == 1)255 printk(" %d", start);256 else257 printk(" %d(%d)", start, len);258}259 260static void indirect_print_item(struct item_head *ih, char *item)261{262 int j;263 __le32 *unp;264 __u32 prev = INT_MAX;265 int num = 0;266 267 unp = (__le32 *) item;268 269 if (ih_item_len(ih) % UNFM_P_SIZE)270 reiserfs_warning(NULL, "reiserfs-16102", "invalid item len");271 272 printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih));273 for (j = 0; j < I_UNFM_NUM(ih); j++) {274 if (sequence_finished(prev, &num, get_block_num(unp, j))) {275 print_sequence(prev, num);276 start_new_sequence(&prev, &num, get_block_num(unp, j));277 }278 }279 print_sequence(prev, num);280 printk("]\n");281}282 283static void indirect_check_item(struct item_head *ih, char *item)284{285 /* unused */286}287 288static int indirect_create_vi(struct virtual_node *vn,289 struct virtual_item *vi,290 int is_affected, int insert_size)291{292 vi->vi_index = TYPE_INDIRECT;293 return 0;294}295 296static int indirect_check_left(struct virtual_item *vi, int free,297 int start_skip, int end_skip)298{299 int bytes;300 301 bytes = free - free % UNFM_P_SIZE;302 return bytes ? : -1;303}304 305static int indirect_check_right(struct virtual_item *vi, int free)306{307 return indirect_check_left(vi, free, 0, 0);308}309 310/*311 * return size in bytes of 'units' units. If first == 0 - calculate312 * from the head (left), otherwise - from tail (right)313 */314static int indirect_part_size(struct virtual_item *vi, int first, int units)315{316 /* unit of indirect item is byte (yet) */317 return units;318}319 320static int indirect_unit_num(struct virtual_item *vi)321{322 /* unit of indirect item is byte (yet) */323 return vi->vi_item_len - IH_SIZE;324}325 326static void indirect_print_vi(struct virtual_item *vi)327{328 reiserfs_warning(NULL, "reiserfs-16103",329 "INDIRECT, index %d, type 0x%x, %h",330 vi->vi_index, vi->vi_type, vi->vi_ih);331}332 333static struct item_operations indirect_ops = {334 .bytes_number = indirect_bytes_number,335 .decrement_key = indirect_decrement_key,336 .is_left_mergeable = indirect_is_left_mergeable,337 .print_item = indirect_print_item,338 .check_item = indirect_check_item,339 340 .create_vi = indirect_create_vi,341 .check_left = indirect_check_left,342 .check_right = indirect_check_right,343 .part_size = indirect_part_size,344 .unit_num = indirect_unit_num,345 .print_vi = indirect_print_vi346};347 348/* direntry functions */349static int direntry_bytes_number(struct item_head *ih, int block_size)350{351 reiserfs_warning(NULL, "vs-16090",352 "bytes number is asked for direntry");353 return 0;354}355 356static void direntry_decrement_key(struct cpu_key *key)357{358 cpu_key_k_offset_dec(key);359 if (cpu_key_k_offset(key) == 0)360 set_cpu_key_k_type(key, TYPE_STAT_DATA);361}362 363static int direntry_is_left_mergeable(struct reiserfs_key *key,364 unsigned long bsize)365{366 if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET)367 return 0;368 return 1;369 370}371 372static void direntry_print_item(struct item_head *ih, char *item)373{374 int i;375 int namelen;376 struct reiserfs_de_head *deh;377 char *name;378 static char namebuf[80];379 380 printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name",381 "Key of pointed object", "Hash", "Gen number", "Status");382 383 deh = (struct reiserfs_de_head *)item;384 385 for (i = 0; i < ih_entry_count(ih); i++, deh++) {386 namelen =387 (i ? (deh_location(deh - 1)) : ih_item_len(ih)) -388 deh_location(deh);389 name = item + deh_location(deh);390 if (name[namelen - 1] == 0)391 namelen = strlen(name);392 393 scnprintf(namebuf, sizeof(namebuf), "\"%.*s\"",394 (int)sizeof(namebuf)-3, name);395 396 printk("%d: %-15s%-15d%-15d%-15lld%-15lld(%s)\n",397 i, namebuf,398 deh_dir_id(deh), deh_objectid(deh),399 GET_HASH_VALUE(deh_offset(deh)),400 GET_GENERATION_NUMBER((deh_offset(deh))),401 (de_hidden(deh)) ? "HIDDEN" : "VISIBLE");402 }403}404 405static void direntry_check_item(struct item_head *ih, char *item)406{407 int i;408 struct reiserfs_de_head *deh;409 410 /* unused */411 deh = (struct reiserfs_de_head *)item;412 for (i = 0; i < ih_entry_count(ih); i++, deh++) {413 ;414 }415}416 417#define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1418 419/*420 * function returns old entry number in directory item in real node421 * using new entry number in virtual item in virtual node422 */423static inline int old_entry_num(int is_affected, int virtual_entry_num,424 int pos_in_item, int mode)425{426 if (mode == M_INSERT || mode == M_DELETE)427 return virtual_entry_num;428 429 if (!is_affected)430 /* cut or paste is applied to another item */431 return virtual_entry_num;432 433 if (virtual_entry_num < pos_in_item)434 return virtual_entry_num;435 436 if (mode == M_CUT)437 return virtual_entry_num + 1;438 439 RFALSE(mode != M_PASTE || virtual_entry_num == 0,440 "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'",441 mode);442 443 return virtual_entry_num - 1;444}445 446/*447 * Create an array of sizes of directory entries for virtual448 * item. Return space used by an item. FIXME: no control over449 * consuming of space used by this item handler450 */451static int direntry_create_vi(struct virtual_node *vn,452 struct virtual_item *vi,453 int is_affected, int insert_size)454{455 struct direntry_uarea *dir_u = vi->vi_uarea;456 int i, j;457 int size = sizeof(struct direntry_uarea);458 struct reiserfs_de_head *deh;459 460 vi->vi_index = TYPE_DIRENTRY;461 462 BUG_ON(!(vi->vi_ih) || !vi->vi_item);463 464 dir_u->flags = 0;465 if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET)466 dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;467 468 deh = (struct reiserfs_de_head *)(vi->vi_item);469 470 /* virtual directory item have this amount of entry after */471 dir_u->entry_count = ih_entry_count(vi->vi_ih) +472 ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :473 (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);474 475 for (i = 0; i < dir_u->entry_count; i++) {476 j = old_entry_num(is_affected, i, vn->vn_pos_in_item,477 vn->vn_mode);478 dir_u->entry_sizes[i] =479 (j ? deh_location(&deh[j - 1]) : ih_item_len(vi->vi_ih)) -480 deh_location(&deh[j]) + DEH_SIZE;481 }482 483 size += (dir_u->entry_count * sizeof(short));484 485 /* set size of pasted entry */486 if (is_affected && vn->vn_mode == M_PASTE)487 dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;488 489#ifdef CONFIG_REISERFS_CHECK490 /* compare total size of entries with item length */491 {492 int k, l;493 494 l = 0;495 for (k = 0; k < dir_u->entry_count; k++)496 l += dir_u->entry_sizes[k];497 498 if (l + IH_SIZE != vi->vi_item_len +499 ((is_affected500 && (vn->vn_mode == M_PASTE501 || vn->vn_mode == M_CUT)) ? insert_size : 0)) {502 reiserfs_panic(NULL, "vs-8025", "(mode==%c, "503 "insert_size==%d), invalid length of "504 "directory item",505 vn->vn_mode, insert_size);506 }507 }508#endif509 510 return size;511 512}513 514/*515 * return number of entries which may fit into specified amount of516 * free space, or -1 if free space is not enough even for 1 entry517 */518static int direntry_check_left(struct virtual_item *vi, int free,519 int start_skip, int end_skip)520{521 int i;522 int entries = 0;523 struct direntry_uarea *dir_u = vi->vi_uarea;524 525 for (i = start_skip; i < dir_u->entry_count - end_skip; i++) {526 /* i-th entry doesn't fit into the remaining free space */527 if (dir_u->entry_sizes[i] > free)528 break;529 530 free -= dir_u->entry_sizes[i];531 entries++;532 }533 534 if (entries == dir_u->entry_count) {535 reiserfs_panic(NULL, "item_ops-1",536 "free space %d, entry_count %d", free,537 dir_u->entry_count);538 }539 540 /* "." and ".." can not be separated from each other */541 if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)542 && entries < 2)543 entries = 0;544 545 return entries ? : -1;546}547 548static int direntry_check_right(struct virtual_item *vi, int free)549{550 int i;551 int entries = 0;552 struct direntry_uarea *dir_u = vi->vi_uarea;553 554 for (i = dir_u->entry_count - 1; i >= 0; i--) {555 /* i-th entry doesn't fit into the remaining free space */556 if (dir_u->entry_sizes[i] > free)557 break;558 559 free -= dir_u->entry_sizes[i];560 entries++;561 }562 BUG_ON(entries == dir_u->entry_count);563 564 /* "." and ".." can not be separated from each other */565 if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)566 && entries > dir_u->entry_count - 2)567 entries = dir_u->entry_count - 2;568 569 return entries ? : -1;570}571 572/* sum of entry sizes between from-th and to-th entries including both edges */573static int direntry_part_size(struct virtual_item *vi, int first, int count)574{575 int i, retval;576 int from, to;577 struct direntry_uarea *dir_u = vi->vi_uarea;578 579 retval = 0;580 if (first == 0)581 from = 0;582 else583 from = dir_u->entry_count - count;584 to = from + count - 1;585 586 for (i = from; i <= to; i++)587 retval += dir_u->entry_sizes[i];588 589 return retval;590}591 592static int direntry_unit_num(struct virtual_item *vi)593{594 struct direntry_uarea *dir_u = vi->vi_uarea;595 596 return dir_u->entry_count;597}598 599static void direntry_print_vi(struct virtual_item *vi)600{601 int i;602 struct direntry_uarea *dir_u = vi->vi_uarea;603 604 reiserfs_warning(NULL, "reiserfs-16104",605 "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",606 vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);607 printk("%d entries: ", dir_u->entry_count);608 for (i = 0; i < dir_u->entry_count; i++)609 printk("%d ", dir_u->entry_sizes[i]);610 printk("\n");611}612 613static struct item_operations direntry_ops = {614 .bytes_number = direntry_bytes_number,615 .decrement_key = direntry_decrement_key,616 .is_left_mergeable = direntry_is_left_mergeable,617 .print_item = direntry_print_item,618 .check_item = direntry_check_item,619 620 .create_vi = direntry_create_vi,621 .check_left = direntry_check_left,622 .check_right = direntry_check_right,623 .part_size = direntry_part_size,624 .unit_num = direntry_unit_num,625 .print_vi = direntry_print_vi626};627 628/* Error catching functions to catch errors caused by incorrect item types. */629static int errcatch_bytes_number(struct item_head *ih, int block_size)630{631 reiserfs_warning(NULL, "green-16001",632 "Invalid item type observed, run fsck ASAP");633 return 0;634}635 636static void errcatch_decrement_key(struct cpu_key *key)637{638 reiserfs_warning(NULL, "green-16002",639 "Invalid item type observed, run fsck ASAP");640}641 642static int errcatch_is_left_mergeable(struct reiserfs_key *key,643 unsigned long bsize)644{645 reiserfs_warning(NULL, "green-16003",646 "Invalid item type observed, run fsck ASAP");647 return 0;648}649 650static void errcatch_print_item(struct item_head *ih, char *item)651{652 reiserfs_warning(NULL, "green-16004",653 "Invalid item type observed, run fsck ASAP");654}655 656static void errcatch_check_item(struct item_head *ih, char *item)657{658 reiserfs_warning(NULL, "green-16005",659 "Invalid item type observed, run fsck ASAP");660}661 662static int errcatch_create_vi(struct virtual_node *vn,663 struct virtual_item *vi,664 int is_affected, int insert_size)665{666 reiserfs_warning(NULL, "green-16006",667 "Invalid item type observed, run fsck ASAP");668 /*669 * We might return -1 here as well, but it won't help as670 * create_virtual_node() from where this operation is called671 * from is of return type void.672 */673 return 0;674}675 676static int errcatch_check_left(struct virtual_item *vi, int free,677 int start_skip, int end_skip)678{679 reiserfs_warning(NULL, "green-16007",680 "Invalid item type observed, run fsck ASAP");681 return -1;682}683 684static int errcatch_check_right(struct virtual_item *vi, int free)685{686 reiserfs_warning(NULL, "green-16008",687 "Invalid item type observed, run fsck ASAP");688 return -1;689}690 691static int errcatch_part_size(struct virtual_item *vi, int first, int count)692{693 reiserfs_warning(NULL, "green-16009",694 "Invalid item type observed, run fsck ASAP");695 return 0;696}697 698static int errcatch_unit_num(struct virtual_item *vi)699{700 reiserfs_warning(NULL, "green-16010",701 "Invalid item type observed, run fsck ASAP");702 return 0;703}704 705static void errcatch_print_vi(struct virtual_item *vi)706{707 reiserfs_warning(NULL, "green-16011",708 "Invalid item type observed, run fsck ASAP");709}710 711static struct item_operations errcatch_ops = {712 .bytes_number = errcatch_bytes_number,713 .decrement_key = errcatch_decrement_key,714 .is_left_mergeable = errcatch_is_left_mergeable,715 .print_item = errcatch_print_item,716 .check_item = errcatch_check_item,717 718 .create_vi = errcatch_create_vi,719 .check_left = errcatch_check_left,720 .check_right = errcatch_check_right,721 .part_size = errcatch_part_size,722 .unit_num = errcatch_unit_num,723 .print_vi = errcatch_print_vi724};725 726#if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3)727#error Item types must use disk-format assigned values.728#endif729 730struct item_operations *item_ops[TYPE_ANY + 1] = {731 &stat_data_ops,732 &indirect_ops,733 &direct_ops,734 &direntry_ops,735 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,736 &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */737};738