Loading...
1/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
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, directory
11 */
12
13/*
14 * and where are the comments? how about saying where we can find an
15 * explanation of each item handler method? -Hans
16 */
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_vi
111};
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_vi
202};
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 else
257 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 - calculate
312 * 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_vi
346};
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 namebuf[0] = '"';
393 if (namelen > sizeof(namebuf) - 3) {
394 strncpy(namebuf + 1, name, sizeof(namebuf) - 3);
395 namebuf[sizeof(namebuf) - 2] = '"';
396 namebuf[sizeof(namebuf) - 1] = 0;
397 } else {
398 memcpy(namebuf + 1, name, namelen);
399 namebuf[namelen + 1] = '"';
400 namebuf[namelen + 2] = 0;
401 }
402
403 printk("%d: %-15s%-15d%-15d%-15lld%-15lld(%s)\n",
404 i, namebuf,
405 deh_dir_id(deh), deh_objectid(deh),
406 GET_HASH_VALUE(deh_offset(deh)),
407 GET_GENERATION_NUMBER((deh_offset(deh))),
408 (de_hidden(deh)) ? "HIDDEN" : "VISIBLE");
409 }
410}
411
412static void direntry_check_item(struct item_head *ih, char *item)
413{
414 int i;
415 struct reiserfs_de_head *deh;
416
417 /* unused */
418 deh = (struct reiserfs_de_head *)item;
419 for (i = 0; i < ih_entry_count(ih); i++, deh++) {
420 ;
421 }
422}
423
424#define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
425
426/*
427 * function returns old entry number in directory item in real node
428 * using new entry number in virtual item in virtual node
429 */
430static inline int old_entry_num(int is_affected, int virtual_entry_num,
431 int pos_in_item, int mode)
432{
433 if (mode == M_INSERT || mode == M_DELETE)
434 return virtual_entry_num;
435
436 if (!is_affected)
437 /* cut or paste is applied to another item */
438 return virtual_entry_num;
439
440 if (virtual_entry_num < pos_in_item)
441 return virtual_entry_num;
442
443 if (mode == M_CUT)
444 return virtual_entry_num + 1;
445
446 RFALSE(mode != M_PASTE || virtual_entry_num == 0,
447 "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'",
448 mode);
449
450 return virtual_entry_num - 1;
451}
452
453/*
454 * Create an array of sizes of directory entries for virtual
455 * item. Return space used by an item. FIXME: no control over
456 * consuming of space used by this item handler
457 */
458static int direntry_create_vi(struct virtual_node *vn,
459 struct virtual_item *vi,
460 int is_affected, int insert_size)
461{
462 struct direntry_uarea *dir_u = vi->vi_uarea;
463 int i, j;
464 int size = sizeof(struct direntry_uarea);
465 struct reiserfs_de_head *deh;
466
467 vi->vi_index = TYPE_DIRENTRY;
468
469 BUG_ON(!(vi->vi_ih) || !vi->vi_item);
470
471 dir_u->flags = 0;
472 if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET)
473 dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
474
475 deh = (struct reiserfs_de_head *)(vi->vi_item);
476
477 /* virtual directory item have this amount of entry after */
478 dir_u->entry_count = ih_entry_count(vi->vi_ih) +
479 ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
480 (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
481
482 for (i = 0; i < dir_u->entry_count; i++) {
483 j = old_entry_num(is_affected, i, vn->vn_pos_in_item,
484 vn->vn_mode);
485 dir_u->entry_sizes[i] =
486 (j ? deh_location(&deh[j - 1]) : ih_item_len(vi->vi_ih)) -
487 deh_location(&deh[j]) + DEH_SIZE;
488 }
489
490 size += (dir_u->entry_count * sizeof(short));
491
492 /* set size of pasted entry */
493 if (is_affected && vn->vn_mode == M_PASTE)
494 dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
495
496#ifdef CONFIG_REISERFS_CHECK
497 /* compare total size of entries with item length */
498 {
499 int k, l;
500
501 l = 0;
502 for (k = 0; k < dir_u->entry_count; k++)
503 l += dir_u->entry_sizes[k];
504
505 if (l + IH_SIZE != vi->vi_item_len +
506 ((is_affected
507 && (vn->vn_mode == M_PASTE
508 || vn->vn_mode == M_CUT)) ? insert_size : 0)) {
509 reiserfs_panic(NULL, "vs-8025", "(mode==%c, "
510 "insert_size==%d), invalid length of "
511 "directory item",
512 vn->vn_mode, insert_size);
513 }
514 }
515#endif
516
517 return size;
518
519}
520
521/*
522 * return number of entries which may fit into specified amount of
523 * free space, or -1 if free space is not enough even for 1 entry
524 */
525static int direntry_check_left(struct virtual_item *vi, int free,
526 int start_skip, int end_skip)
527{
528 int i;
529 int entries = 0;
530 struct direntry_uarea *dir_u = vi->vi_uarea;
531
532 for (i = start_skip; i < dir_u->entry_count - end_skip; i++) {
533 /* i-th entry doesn't fit into the remaining free space */
534 if (dir_u->entry_sizes[i] > free)
535 break;
536
537 free -= dir_u->entry_sizes[i];
538 entries++;
539 }
540
541 if (entries == dir_u->entry_count) {
542 reiserfs_panic(NULL, "item_ops-1",
543 "free space %d, entry_count %d", free,
544 dir_u->entry_count);
545 }
546
547 /* "." and ".." can not be separated from each other */
548 if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
549 && entries < 2)
550 entries = 0;
551
552 return entries ? : -1;
553}
554
555static int direntry_check_right(struct virtual_item *vi, int free)
556{
557 int i;
558 int entries = 0;
559 struct direntry_uarea *dir_u = vi->vi_uarea;
560
561 for (i = dir_u->entry_count - 1; i >= 0; i--) {
562 /* i-th entry doesn't fit into the remaining free space */
563 if (dir_u->entry_sizes[i] > free)
564 break;
565
566 free -= dir_u->entry_sizes[i];
567 entries++;
568 }
569 BUG_ON(entries == dir_u->entry_count);
570
571 /* "." and ".." can not be separated from each other */
572 if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
573 && entries > dir_u->entry_count - 2)
574 entries = dir_u->entry_count - 2;
575
576 return entries ? : -1;
577}
578
579/* sum of entry sizes between from-th and to-th entries including both edges */
580static int direntry_part_size(struct virtual_item *vi, int first, int count)
581{
582 int i, retval;
583 int from, to;
584 struct direntry_uarea *dir_u = vi->vi_uarea;
585
586 retval = 0;
587 if (first == 0)
588 from = 0;
589 else
590 from = dir_u->entry_count - count;
591 to = from + count - 1;
592
593 for (i = from; i <= to; i++)
594 retval += dir_u->entry_sizes[i];
595
596 return retval;
597}
598
599static int direntry_unit_num(struct virtual_item *vi)
600{
601 struct direntry_uarea *dir_u = vi->vi_uarea;
602
603 return dir_u->entry_count;
604}
605
606static void direntry_print_vi(struct virtual_item *vi)
607{
608 int i;
609 struct direntry_uarea *dir_u = vi->vi_uarea;
610
611 reiserfs_warning(NULL, "reiserfs-16104",
612 "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
613 vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
614 printk("%d entries: ", dir_u->entry_count);
615 for (i = 0; i < dir_u->entry_count; i++)
616 printk("%d ", dir_u->entry_sizes[i]);
617 printk("\n");
618}
619
620static struct item_operations direntry_ops = {
621 .bytes_number = direntry_bytes_number,
622 .decrement_key = direntry_decrement_key,
623 .is_left_mergeable = direntry_is_left_mergeable,
624 .print_item = direntry_print_item,
625 .check_item = direntry_check_item,
626
627 .create_vi = direntry_create_vi,
628 .check_left = direntry_check_left,
629 .check_right = direntry_check_right,
630 .part_size = direntry_part_size,
631 .unit_num = direntry_unit_num,
632 .print_vi = direntry_print_vi
633};
634
635/* Error catching functions to catch errors caused by incorrect item types. */
636static int errcatch_bytes_number(struct item_head *ih, int block_size)
637{
638 reiserfs_warning(NULL, "green-16001",
639 "Invalid item type observed, run fsck ASAP");
640 return 0;
641}
642
643static void errcatch_decrement_key(struct cpu_key *key)
644{
645 reiserfs_warning(NULL, "green-16002",
646 "Invalid item type observed, run fsck ASAP");
647}
648
649static int errcatch_is_left_mergeable(struct reiserfs_key *key,
650 unsigned long bsize)
651{
652 reiserfs_warning(NULL, "green-16003",
653 "Invalid item type observed, run fsck ASAP");
654 return 0;
655}
656
657static void errcatch_print_item(struct item_head *ih, char *item)
658{
659 reiserfs_warning(NULL, "green-16004",
660 "Invalid item type observed, run fsck ASAP");
661}
662
663static void errcatch_check_item(struct item_head *ih, char *item)
664{
665 reiserfs_warning(NULL, "green-16005",
666 "Invalid item type observed, run fsck ASAP");
667}
668
669static int errcatch_create_vi(struct virtual_node *vn,
670 struct virtual_item *vi,
671 int is_affected, int insert_size)
672{
673 reiserfs_warning(NULL, "green-16006",
674 "Invalid item type observed, run fsck ASAP");
675 /*
676 * We might return -1 here as well, but it won't help as
677 * create_virtual_node() from where this operation is called
678 * from is of return type void.
679 */
680 return 0;
681}
682
683static int errcatch_check_left(struct virtual_item *vi, int free,
684 int start_skip, int end_skip)
685{
686 reiserfs_warning(NULL, "green-16007",
687 "Invalid item type observed, run fsck ASAP");
688 return -1;
689}
690
691static int errcatch_check_right(struct virtual_item *vi, int free)
692{
693 reiserfs_warning(NULL, "green-16008",
694 "Invalid item type observed, run fsck ASAP");
695 return -1;
696}
697
698static int errcatch_part_size(struct virtual_item *vi, int first, int count)
699{
700 reiserfs_warning(NULL, "green-16009",
701 "Invalid item type observed, run fsck ASAP");
702 return 0;
703}
704
705static int errcatch_unit_num(struct virtual_item *vi)
706{
707 reiserfs_warning(NULL, "green-16010",
708 "Invalid item type observed, run fsck ASAP");
709 return 0;
710}
711
712static void errcatch_print_vi(struct virtual_item *vi)
713{
714 reiserfs_warning(NULL, "green-16011",
715 "Invalid item type observed, run fsck ASAP");
716}
717
718static struct item_operations errcatch_ops = {
719 .bytes_number = errcatch_bytes_number,
720 .decrement_key = errcatch_decrement_key,
721 .is_left_mergeable = errcatch_is_left_mergeable,
722 .print_item = errcatch_print_item,
723 .check_item = errcatch_check_item,
724
725 .create_vi = errcatch_create_vi,
726 .check_left = errcatch_check_left,
727 .check_right = errcatch_check_right,
728 .part_size = errcatch_part_size,
729 .unit_num = errcatch_unit_num,
730 .print_vi = errcatch_print_vi
731};
732
733#if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3)
734#error Item types must use disk-format assigned values.
735#endif
736
737struct item_operations *item_ops[TYPE_ANY + 1] = {
738 &stat_data_ops,
739 &indirect_ops,
740 &direct_ops,
741 &direntry_ops,
742 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
743 &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
744};
1/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
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, directory
11 */
12
13/*
14 * and where are the comments? how about saying where we can find an
15 * explanation of each item handler method? -Hans
16 */
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_vi
111};
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_vi
202};
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 else
257 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 - calculate
312 * 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_vi
346};
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 namebuf[0] = '"';
393 if (namelen > sizeof(namebuf) - 3) {
394 strncpy(namebuf + 1, name, sizeof(namebuf) - 3);
395 namebuf[sizeof(namebuf) - 2] = '"';
396 namebuf[sizeof(namebuf) - 1] = 0;
397 } else {
398 memcpy(namebuf + 1, name, namelen);
399 namebuf[namelen + 1] = '"';
400 namebuf[namelen + 2] = 0;
401 }
402
403 printk("%d: %-15s%-15d%-15d%-15lld%-15lld(%s)\n",
404 i, namebuf,
405 deh_dir_id(deh), deh_objectid(deh),
406 GET_HASH_VALUE(deh_offset(deh)),
407 GET_GENERATION_NUMBER((deh_offset(deh))),
408 (de_hidden(deh)) ? "HIDDEN" : "VISIBLE");
409 }
410}
411
412static void direntry_check_item(struct item_head *ih, char *item)
413{
414 int i;
415 struct reiserfs_de_head *deh;
416
417 /* unused */
418 deh = (struct reiserfs_de_head *)item;
419 for (i = 0; i < ih_entry_count(ih); i++, deh++) {
420 ;
421 }
422}
423
424#define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
425
426/*
427 * function returns old entry number in directory item in real node
428 * using new entry number in virtual item in virtual node
429 */
430static inline int old_entry_num(int is_affected, int virtual_entry_num,
431 int pos_in_item, int mode)
432{
433 if (mode == M_INSERT || mode == M_DELETE)
434 return virtual_entry_num;
435
436 if (!is_affected)
437 /* cut or paste is applied to another item */
438 return virtual_entry_num;
439
440 if (virtual_entry_num < pos_in_item)
441 return virtual_entry_num;
442
443 if (mode == M_CUT)
444 return virtual_entry_num + 1;
445
446 RFALSE(mode != M_PASTE || virtual_entry_num == 0,
447 "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'",
448 mode);
449
450 return virtual_entry_num - 1;
451}
452
453/*
454 * Create an array of sizes of directory entries for virtual
455 * item. Return space used by an item. FIXME: no control over
456 * consuming of space used by this item handler
457 */
458static int direntry_create_vi(struct virtual_node *vn,
459 struct virtual_item *vi,
460 int is_affected, int insert_size)
461{
462 struct direntry_uarea *dir_u = vi->vi_uarea;
463 int i, j;
464 int size = sizeof(struct direntry_uarea);
465 struct reiserfs_de_head *deh;
466
467 vi->vi_index = TYPE_DIRENTRY;
468
469 BUG_ON(!(vi->vi_ih) || !vi->vi_item);
470
471 dir_u->flags = 0;
472 if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET)
473 dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
474
475 deh = (struct reiserfs_de_head *)(vi->vi_item);
476
477 /* virtual directory item have this amount of entry after */
478 dir_u->entry_count = ih_entry_count(vi->vi_ih) +
479 ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
480 (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
481
482 for (i = 0; i < dir_u->entry_count; i++) {
483 j = old_entry_num(is_affected, i, vn->vn_pos_in_item,
484 vn->vn_mode);
485 dir_u->entry_sizes[i] =
486 (j ? deh_location(&deh[j - 1]) : ih_item_len(vi->vi_ih)) -
487 deh_location(&deh[j]) + DEH_SIZE;
488 }
489
490 size += (dir_u->entry_count * sizeof(short));
491
492 /* set size of pasted entry */
493 if (is_affected && vn->vn_mode == M_PASTE)
494 dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
495
496#ifdef CONFIG_REISERFS_CHECK
497 /* compare total size of entries with item length */
498 {
499 int k, l;
500
501 l = 0;
502 for (k = 0; k < dir_u->entry_count; k++)
503 l += dir_u->entry_sizes[k];
504
505 if (l + IH_SIZE != vi->vi_item_len +
506 ((is_affected
507 && (vn->vn_mode == M_PASTE
508 || vn->vn_mode == M_CUT)) ? insert_size : 0)) {
509 reiserfs_panic(NULL, "vs-8025", "(mode==%c, "
510 "insert_size==%d), invalid length of "
511 "directory item",
512 vn->vn_mode, insert_size);
513 }
514 }
515#endif
516
517 return size;
518
519}
520
521/*
522 * return number of entries which may fit into specified amount of
523 * free space, or -1 if free space is not enough even for 1 entry
524 */
525static int direntry_check_left(struct virtual_item *vi, int free,
526 int start_skip, int end_skip)
527{
528 int i;
529 int entries = 0;
530 struct direntry_uarea *dir_u = vi->vi_uarea;
531
532 for (i = start_skip; i < dir_u->entry_count - end_skip; i++) {
533 /* i-th entry doesn't fit into the remaining free space */
534 if (dir_u->entry_sizes[i] > free)
535 break;
536
537 free -= dir_u->entry_sizes[i];
538 entries++;
539 }
540
541 if (entries == dir_u->entry_count) {
542 reiserfs_panic(NULL, "item_ops-1",
543 "free space %d, entry_count %d", free,
544 dir_u->entry_count);
545 }
546
547 /* "." and ".." can not be separated from each other */
548 if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
549 && entries < 2)
550 entries = 0;
551
552 return entries ? : -1;
553}
554
555static int direntry_check_right(struct virtual_item *vi, int free)
556{
557 int i;
558 int entries = 0;
559 struct direntry_uarea *dir_u = vi->vi_uarea;
560
561 for (i = dir_u->entry_count - 1; i >= 0; i--) {
562 /* i-th entry doesn't fit into the remaining free space */
563 if (dir_u->entry_sizes[i] > free)
564 break;
565
566 free -= dir_u->entry_sizes[i];
567 entries++;
568 }
569 BUG_ON(entries == dir_u->entry_count);
570
571 /* "." and ".." can not be separated from each other */
572 if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
573 && entries > dir_u->entry_count - 2)
574 entries = dir_u->entry_count - 2;
575
576 return entries ? : -1;
577}
578
579/* sum of entry sizes between from-th and to-th entries including both edges */
580static int direntry_part_size(struct virtual_item *vi, int first, int count)
581{
582 int i, retval;
583 int from, to;
584 struct direntry_uarea *dir_u = vi->vi_uarea;
585
586 retval = 0;
587 if (first == 0)
588 from = 0;
589 else
590 from = dir_u->entry_count - count;
591 to = from + count - 1;
592
593 for (i = from; i <= to; i++)
594 retval += dir_u->entry_sizes[i];
595
596 return retval;
597}
598
599static int direntry_unit_num(struct virtual_item *vi)
600{
601 struct direntry_uarea *dir_u = vi->vi_uarea;
602
603 return dir_u->entry_count;
604}
605
606static void direntry_print_vi(struct virtual_item *vi)
607{
608 int i;
609 struct direntry_uarea *dir_u = vi->vi_uarea;
610
611 reiserfs_warning(NULL, "reiserfs-16104",
612 "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
613 vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
614 printk("%d entries: ", dir_u->entry_count);
615 for (i = 0; i < dir_u->entry_count; i++)
616 printk("%d ", dir_u->entry_sizes[i]);
617 printk("\n");
618}
619
620static struct item_operations direntry_ops = {
621 .bytes_number = direntry_bytes_number,
622 .decrement_key = direntry_decrement_key,
623 .is_left_mergeable = direntry_is_left_mergeable,
624 .print_item = direntry_print_item,
625 .check_item = direntry_check_item,
626
627 .create_vi = direntry_create_vi,
628 .check_left = direntry_check_left,
629 .check_right = direntry_check_right,
630 .part_size = direntry_part_size,
631 .unit_num = direntry_unit_num,
632 .print_vi = direntry_print_vi
633};
634
635/* Error catching functions to catch errors caused by incorrect item types. */
636static int errcatch_bytes_number(struct item_head *ih, int block_size)
637{
638 reiserfs_warning(NULL, "green-16001",
639 "Invalid item type observed, run fsck ASAP");
640 return 0;
641}
642
643static void errcatch_decrement_key(struct cpu_key *key)
644{
645 reiserfs_warning(NULL, "green-16002",
646 "Invalid item type observed, run fsck ASAP");
647}
648
649static int errcatch_is_left_mergeable(struct reiserfs_key *key,
650 unsigned long bsize)
651{
652 reiserfs_warning(NULL, "green-16003",
653 "Invalid item type observed, run fsck ASAP");
654 return 0;
655}
656
657static void errcatch_print_item(struct item_head *ih, char *item)
658{
659 reiserfs_warning(NULL, "green-16004",
660 "Invalid item type observed, run fsck ASAP");
661}
662
663static void errcatch_check_item(struct item_head *ih, char *item)
664{
665 reiserfs_warning(NULL, "green-16005",
666 "Invalid item type observed, run fsck ASAP");
667}
668
669static int errcatch_create_vi(struct virtual_node *vn,
670 struct virtual_item *vi,
671 int is_affected, int insert_size)
672{
673 reiserfs_warning(NULL, "green-16006",
674 "Invalid item type observed, run fsck ASAP");
675 /*
676 * We might return -1 here as well, but it won't help as
677 * create_virtual_node() from where this operation is called
678 * from is of return type void.
679 */
680 return 0;
681}
682
683static int errcatch_check_left(struct virtual_item *vi, int free,
684 int start_skip, int end_skip)
685{
686 reiserfs_warning(NULL, "green-16007",
687 "Invalid item type observed, run fsck ASAP");
688 return -1;
689}
690
691static int errcatch_check_right(struct virtual_item *vi, int free)
692{
693 reiserfs_warning(NULL, "green-16008",
694 "Invalid item type observed, run fsck ASAP");
695 return -1;
696}
697
698static int errcatch_part_size(struct virtual_item *vi, int first, int count)
699{
700 reiserfs_warning(NULL, "green-16009",
701 "Invalid item type observed, run fsck ASAP");
702 return 0;
703}
704
705static int errcatch_unit_num(struct virtual_item *vi)
706{
707 reiserfs_warning(NULL, "green-16010",
708 "Invalid item type observed, run fsck ASAP");
709 return 0;
710}
711
712static void errcatch_print_vi(struct virtual_item *vi)
713{
714 reiserfs_warning(NULL, "green-16011",
715 "Invalid item type observed, run fsck ASAP");
716}
717
718static struct item_operations errcatch_ops = {
719 .bytes_number = errcatch_bytes_number,
720 .decrement_key = errcatch_decrement_key,
721 .is_left_mergeable = errcatch_is_left_mergeable,
722 .print_item = errcatch_print_item,
723 .check_item = errcatch_check_item,
724
725 .create_vi = errcatch_create_vi,
726 .check_left = errcatch_check_left,
727 .check_right = errcatch_check_right,
728 .part_size = errcatch_part_size,
729 .unit_num = errcatch_unit_num,
730 .print_vi = errcatch_print_vi
731};
732
733#if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3)
734#error Item types must use disk-format assigned values.
735#endif
736
737struct item_operations *item_ops[TYPE_ANY + 1] = {
738 &stat_data_ops,
739 &indirect_ops,
740 &direct_ops,
741 &direntry_ops,
742 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
743 &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
744};