~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/reiserfs/item_ops.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 */
 19 static int sd_bytes_number(struct item_head *ih, int block_size)
 20 {
 21         return 0;
 22 }
 23 
 24 static 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 
 31 static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize)
 32 {
 33         return 0;
 34 }
 35 
 36 static 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 
 55 static void sd_check_item(struct item_head *ih, char *item)
 56 {
 57         /* unused */
 58 }
 59 
 60 static 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 
 68 static 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 
 75 static int sd_check_right(struct virtual_item *vi, int free)
 76 {
 77         return -1;
 78 }
 79 
 80 static int sd_part_size(struct virtual_item *vi, int first, int count)
 81 {
 82         BUG_ON(count);
 83         return 0;
 84 }
 85 
 86 static int sd_unit_num(struct virtual_item *vi)
 87 {
 88         return vi->vi_item_len - IH_SIZE;
 89 }
 90 
 91 static 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 
 98 static 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 */
114 static 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 */
120 static 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 
127 static 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 
134 static 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 
145 static void direct_check_item(struct item_head *ih, char *item)
146 {
147         /* unused */
148 }
149 
150 static 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 
158 static 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 
167 static int direct_check_right(struct virtual_item *vi, int free)
168 {
169         return direct_check_left(vi, free, 0, 0);
170 }
171 
172 static int direct_part_size(struct virtual_item *vi, int first, int count)
173 {
174         return count;
175 }
176 
177 static int direct_unit_num(struct virtual_item *vi)
178 {
179         return vi->vi_item_len - IH_SIZE;
180 }
181 
182 static 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 
189 static 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 */
205 static 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 */
211 static 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 */
219 static 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 */
227 static void start_new_sequence(__u32 * start, int *len, __u32 new)
228 {
229         *start = new;
230         *len = 1;
231 }
232 
233 static 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 
249 static 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 
260 static 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 
283 static void indirect_check_item(struct item_head *ih, char *item)
284 {
285         /* unused */
286 }
287 
288 static 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 
296 static 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 
305 static 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  */
314 static 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 
320 static 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 
326 static 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 
333 static 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 */
349 static 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 
356 static 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 
363 static 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 
372 static 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 
412 static 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  */
430 static 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  */
458 static 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  */
525 static 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 
555 static 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 */
580 static 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 
599 static 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 
606 static 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 
620 static 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. */
636 static 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 
643 static 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 
649 static 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 
657 static 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 
663 static 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 
669 static 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 
683 static 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 
691 static 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 
698 static 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 
705 static 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 
712 static 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 
718 static 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 
737 struct 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 };
745 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp