1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/time.h>
15#include <linux/bitops.h>
16#include <linux/reiserfs_fs.h>
17#include <linux/reiserfs_acl.h>
18#include <linux/reiserfs_xattr.h>
19#include <linux/quotaops.h>
20
21#define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) i->i_nlink=1; }
22#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
23
24
25
26static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
27{
28 struct item_head *ih = de->de_ih;
29 struct reiserfs_de_head *deh = de->de_deh;
30 int rbound, lbound, j;
31
32 lbound = 0;
33 rbound = I_ENTRY_COUNT(ih) - 1;
34
35 for (j = (rbound + lbound) / 2; lbound <= rbound;
36 j = (rbound + lbound) / 2) {
37 if (off < deh_offset(deh + j)) {
38 rbound = j - 1;
39 continue;
40 }
41 if (off > deh_offset(deh + j)) {
42 lbound = j + 1;
43 continue;
44 }
45
46 de->de_entry_num = j;
47 return NAME_FOUND;
48 }
49
50 de->de_entry_num = lbound;
51 return NAME_NOT_FOUND;
52}
53
54
55static inline void set_de_item_location(struct reiserfs_dir_entry *de,
56 struct treepath *path)
57{
58 de->de_bh = get_last_bh(path);
59 de->de_ih = get_ih(path);
60 de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
61 de->de_item_num = PATH_LAST_POSITION(path);
62}
63
64
65inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
66{
67 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
68
69 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
70
71 de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
72 de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
73 de->de_name = B_I_PITEM(de->de_bh, de->de_ih) + deh_location(deh);
74 if (de->de_name[de->de_namelen - 1] == 0)
75 de->de_namelen = strlen(de->de_name);
76}
77
78
79static inline void set_de_object_key(struct reiserfs_dir_entry *de)
80{
81 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
82 de->de_dir_id = deh_dir_id(&(de->de_deh[de->de_entry_num]));
83 de->de_objectid = deh_objectid(&(de->de_deh[de->de_entry_num]));
84}
85
86static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
87{
88 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
89
90 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
91
92
93 de->de_entry_key.version = KEY_FORMAT_3_5;
94 de->de_entry_key.on_disk_key.k_dir_id =
95 le32_to_cpu(de->de_ih->ih_key.k_dir_id);
96 de->de_entry_key.on_disk_key.k_objectid =
97 le32_to_cpu(de->de_ih->ih_key.k_objectid);
98 set_cpu_key_k_offset(&(de->de_entry_key), deh_offset(deh));
99 set_cpu_key_k_type(&(de->de_entry_key), TYPE_DIRENTRY);
100}
101
102
103
104
105
106
107
108
109
110
111
112
113
114int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
115 struct treepath *path, struct reiserfs_dir_entry *de)
116{
117 int retval;
118
119 retval = search_item(sb, key, path);
120 switch (retval) {
121 case ITEM_NOT_FOUND:
122 if (!PATH_LAST_POSITION(path)) {
123 reiserfs_error(sb, "vs-7000", "search_by_key "
124 "returned item position == 0");
125 pathrelse(path);
126 return IO_ERROR;
127 }
128 PATH_LAST_POSITION(path)--;
129
130 case ITEM_FOUND:
131 break;
132
133 case IO_ERROR:
134 return retval;
135
136 default:
137 pathrelse(path);
138 reiserfs_error(sb, "vs-7002", "no path to here");
139 return IO_ERROR;
140 }
141
142 set_de_item_location(de, path);
143
144#ifdef CONFIG_REISERFS_CHECK
145 if (!is_direntry_le_ih(de->de_ih) ||
146 COMP_SHORT_KEYS(&(de->de_ih->ih_key), key)) {
147 print_block(de->de_bh, 0, -1, -1);
148 reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
149 "item or does not belong to the same directory "
150 "as key %K", de->de_ih, key);
151 }
152#endif
153
154
155
156 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
157 path->pos_in_item = de->de_entry_num;
158 if (retval != NAME_NOT_FOUND) {
159
160 set_de_name_and_namelen(de);
161 set_de_object_key(de);
162 }
163 return retval;
164}
165
166
167
168
169
170
171
172
173static __u32 get_third_component(struct super_block *s,
174 const char *name, int len)
175{
176 __u32 res;
177
178 if (!len || (len == 1 && name[0] == '.'))
179 return DOT_OFFSET;
180 if (len == 2 && name[0] == '.' && name[1] == '.')
181 return DOT_DOT_OFFSET;
182
183 res = REISERFS_SB(s)->s_hash_function(name, len);
184
185
186 res = GET_HASH_VALUE(res);
187 if (res == 0)
188
189
190 res = 128;
191 return res + MAX_GENERATION_NUMBER;
192}
193
194static int reiserfs_match(struct reiserfs_dir_entry *de,
195 const char *name, int namelen)
196{
197 int retval = NAME_NOT_FOUND;
198
199 if ((namelen == de->de_namelen) &&
200 !memcmp(de->de_name, name, de->de_namelen))
201 retval =
202 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
203 NAME_FOUND_INVISIBLE);
204
205 return retval;
206}
207
208
209
210
211
212static int linear_search_in_dir_item(struct cpu_key *key,
213 struct reiserfs_dir_entry *de,
214 const char *name, int namelen)
215{
216 struct reiserfs_de_head *deh = de->de_deh;
217 int retval;
218 int i;
219
220 i = de->de_entry_num;
221
222 if (i == I_ENTRY_COUNT(de->de_ih) ||
223 GET_HASH_VALUE(deh_offset(deh + i)) !=
224 GET_HASH_VALUE(cpu_key_k_offset(key))) {
225 i--;
226 }
227
228 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
229 "vs-7010: array of entry headers not found");
230
231 deh += i;
232
233 for (; i >= 0; i--, deh--) {
234 if (GET_HASH_VALUE(deh_offset(deh)) !=
235 GET_HASH_VALUE(cpu_key_k_offset(key))) {
236
237 return NAME_NOT_FOUND;
238 }
239
240
241 if (de->de_gen_number_bit_string)
242 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
243 de->de_gen_number_bit_string);
244
245
246 de->de_entry_num = i;
247 set_de_name_and_namelen(de);
248
249 if ((retval =
250 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
251
252
253
254 set_de_object_key(de);
255
256 store_de_entry_key(de);
257
258
259 return retval;
260 }
261 }
262
263 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
264
265
266
267
268
269
270
271 return NAME_NOT_FOUND;
272
273 RFALSE(de->de_item_num,
274 "vs-7015: two diritems of the same directory in one node?");
275
276 return GOTO_PREVIOUS_ITEM;
277}
278
279
280
281static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
282 struct treepath *path_to_entry,
283 struct reiserfs_dir_entry *de)
284{
285 struct cpu_key key_to_search;
286 int retval;
287
288 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
289 return NAME_NOT_FOUND;
290
291
292 make_cpu_key(&key_to_search, dir,
293 get_third_component(dir->i_sb, name, namelen),
294 TYPE_DIRENTRY, 3);
295
296 while (1) {
297 retval =
298 search_by_entry_key(dir->i_sb, &key_to_search,
299 path_to_entry, de);
300 if (retval == IO_ERROR) {
301 reiserfs_error(dir->i_sb, "zam-7001", "io error");
302 return IO_ERROR;
303 }
304
305
306 retval =
307 linear_search_in_dir_item(&key_to_search, de, name,
308 namelen);
309 if (retval != GOTO_PREVIOUS_ITEM) {
310
311 path_to_entry->pos_in_item = de->de_entry_num;
312 return retval;
313 }
314
315
316 set_cpu_key_k_offset(&key_to_search,
317 le_ih_k_offset(de->de_ih) - 1);
318 pathrelse(path_to_entry);
319
320 }
321}
322
323static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
324 struct nameidata *nd)
325{
326 int retval;
327 struct inode *inode = NULL;
328 struct reiserfs_dir_entry de;
329 INITIALIZE_PATH(path_to_entry);
330
331 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
332 return ERR_PTR(-ENAMETOOLONG);
333
334 reiserfs_write_lock(dir->i_sb);
335 de.de_gen_number_bit_string = NULL;
336 retval =
337 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
338 &path_to_entry, &de);
339 pathrelse(&path_to_entry);
340 if (retval == NAME_FOUND) {
341 inode = reiserfs_iget(dir->i_sb,
342 (struct cpu_key *)&(de.de_dir_id));
343 if (!inode || IS_ERR(inode)) {
344 reiserfs_write_unlock(dir->i_sb);
345 return ERR_PTR(-EACCES);
346 }
347
348
349
350 if (IS_PRIVATE(dir))
351 inode->i_flags |= S_PRIVATE;
352 }
353 reiserfs_write_unlock(dir->i_sb);
354 if (retval == IO_ERROR) {
355 return ERR_PTR(-EIO);
356 }
357
358 return d_splice_alias(inode, dentry);
359}
360
361
362
363
364
365struct dentry *reiserfs_get_parent(struct dentry *child)
366{
367 int retval;
368 struct inode *inode = NULL;
369 struct reiserfs_dir_entry de;
370 INITIALIZE_PATH(path_to_entry);
371 struct inode *dir = child->d_inode;
372
373 if (dir->i_nlink == 0) {
374 return ERR_PTR(-ENOENT);
375 }
376 de.de_gen_number_bit_string = NULL;
377
378 reiserfs_write_lock(dir->i_sb);
379 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
380 pathrelse(&path_to_entry);
381 if (retval != NAME_FOUND) {
382 reiserfs_write_unlock(dir->i_sb);
383 return ERR_PTR(-ENOENT);
384 }
385 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
386 reiserfs_write_unlock(dir->i_sb);
387
388 return d_obtain_alias(inode);
389}
390
391
392
393
394
395
396
397static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
398 struct inode *dir, const char *name, int namelen,
399 struct inode *inode, int visible)
400{
401 struct cpu_key entry_key;
402 struct reiserfs_de_head *deh;
403 INITIALIZE_PATH(path);
404 struct reiserfs_dir_entry de;
405 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
406 int gen_number;
407 char small_buf[32 + DEH_SIZE];
408
409 char *buffer;
410 int buflen, paste_size;
411 int retval;
412
413 BUG_ON(!th->t_trans_id);
414
415
416 if (!namelen)
417 return -EINVAL;
418
419 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
420 return -ENAMETOOLONG;
421
422
423 make_cpu_key(&entry_key, dir,
424 get_third_component(dir->i_sb, name, namelen),
425 TYPE_DIRENTRY, 3);
426
427
428 buflen = DEH_SIZE + ROUND_UP(namelen);
429 if (buflen > sizeof(small_buf)) {
430 buffer = kmalloc(buflen, GFP_NOFS);
431 if (!buffer)
432 return -ENOMEM;
433 } else
434 buffer = small_buf;
435
436 paste_size =
437 (get_inode_sd_version(dir) ==
438 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
439
440
441 deh = (struct reiserfs_de_head *)buffer;
442 deh->deh_location = 0;
443 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
444 deh->deh_state = 0;
445
446 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id;
447 deh->deh_objectid = INODE_PKEY(inode)->k_objectid;
448
449
450 memcpy((char *)(deh + 1), name, namelen);
451
452 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
453
454
455 mark_de_without_sd(deh);
456 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
457
458
459 memset(bit_string, 0, sizeof(bit_string));
460 de.de_gen_number_bit_string = bit_string;
461 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
462 if (retval != NAME_NOT_FOUND) {
463 if (buffer != small_buf)
464 kfree(buffer);
465 pathrelse(&path);
466
467 if (retval == IO_ERROR) {
468 return -EIO;
469 }
470
471 if (retval != NAME_FOUND) {
472 reiserfs_error(dir->i_sb, "zam-7002",
473 "reiserfs_find_entry() returned "
474 "unexpected value (%d)", retval);
475 }
476
477 return -EEXIST;
478 }
479
480 gen_number =
481 find_first_zero_bit(bit_string,
482 MAX_GENERATION_NUMBER + 1);
483 if (gen_number > MAX_GENERATION_NUMBER) {
484
485 reiserfs_warning(dir->i_sb, "reiserfs-7010",
486 "Congratulations! we have got hash function "
487 "screwed up");
488 if (buffer != small_buf)
489 kfree(buffer);
490 pathrelse(&path);
491 return -EBUSY;
492 }
493
494 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
495 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
496
497
498 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
499
500 if (gen_number != 0) {
501 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
502 NAME_NOT_FOUND) {
503 reiserfs_warning(dir->i_sb, "vs-7032",
504 "entry with this key (%K) already "
505 "exists", &entry_key);
506
507 if (buffer != small_buf)
508 kfree(buffer);
509 pathrelse(&path);
510 return -EBUSY;
511 }
512 }
513
514
515 retval =
516 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
517 paste_size);
518 if (buffer != small_buf)
519 kfree(buffer);
520 if (retval) {
521 reiserfs_check_path(&path);
522 return retval;
523 }
524
525 dir->i_size += paste_size;
526 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
527 if (!S_ISDIR(inode->i_mode) && visible)
528
529 reiserfs_update_sd(th, dir);
530
531 reiserfs_check_path(&path);
532 return 0;
533}
534
535
536
537
538
539
540static int drop_new_inode(struct inode *inode)
541{
542 vfs_dq_drop(inode);
543 make_bad_inode(inode);
544 inode->i_flags |= S_NOQUOTA;
545 iput(inode);
546 return 0;
547}
548
549
550
551
552
553
554static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
555{
556
557
558
559
560 inode->i_uid = current_fsuid();
561 inode->i_mode = mode;
562
563
564 INODE_PKEY(inode)->k_objectid = 0;
565
566 if (dir->i_mode & S_ISGID) {
567 inode->i_gid = dir->i_gid;
568 if (S_ISDIR(mode))
569 inode->i_mode |= S_ISGID;
570 } else {
571 inode->i_gid = current_fsgid();
572 }
573 vfs_dq_init(inode);
574 return 0;
575}
576
577static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
578 struct nameidata *nd)
579{
580 int retval;
581 struct inode *inode;
582
583 int jbegin_count =
584 JOURNAL_PER_BALANCE_CNT * 2 +
585 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
586 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
587 struct reiserfs_transaction_handle th;
588 struct reiserfs_security_handle security;
589
590 if (!(inode = new_inode(dir->i_sb))) {
591 return -ENOMEM;
592 }
593 new_inode_init(inode, dir, mode);
594
595 jbegin_count += reiserfs_cache_default_acl(dir);
596 retval = reiserfs_security_init(dir, inode, &security);
597 if (retval < 0) {
598 drop_new_inode(inode);
599 return retval;
600 }
601 jbegin_count += retval;
602 reiserfs_write_lock(dir->i_sb);
603
604 retval = journal_begin(&th, dir->i_sb, jbegin_count);
605 if (retval) {
606 drop_new_inode(inode);
607 goto out_failed;
608 }
609
610 retval =
611 reiserfs_new_inode(&th, dir, mode, NULL, 0 , dentry,
612 inode, &security);
613 if (retval)
614 goto out_failed;
615
616 inode->i_op = &reiserfs_file_inode_operations;
617 inode->i_fop = &reiserfs_file_operations;
618 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
619
620 retval =
621 reiserfs_add_entry(&th, dir, dentry->d_name.name,
622 dentry->d_name.len, inode, 1 );
623 if (retval) {
624 int err;
625 inode->i_nlink--;
626 reiserfs_update_sd(&th, inode);
627 err = journal_end(&th, dir->i_sb, jbegin_count);
628 if (err)
629 retval = err;
630 unlock_new_inode(inode);
631 iput(inode);
632 goto out_failed;
633 }
634 reiserfs_update_inode_transaction(inode);
635 reiserfs_update_inode_transaction(dir);
636
637 d_instantiate(dentry, inode);
638 unlock_new_inode(inode);
639 retval = journal_end(&th, dir->i_sb, jbegin_count);
640
641 out_failed:
642 reiserfs_write_unlock(dir->i_sb);
643 return retval;
644}
645
646static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
647 dev_t rdev)
648{
649 int retval;
650 struct inode *inode;
651 struct reiserfs_transaction_handle th;
652 struct reiserfs_security_handle security;
653
654 int jbegin_count =
655 JOURNAL_PER_BALANCE_CNT * 3 +
656 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
657 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
658
659 if (!new_valid_dev(rdev))
660 return -EINVAL;
661
662 if (!(inode = new_inode(dir->i_sb))) {
663 return -ENOMEM;
664 }
665 new_inode_init(inode, dir, mode);
666
667 jbegin_count += reiserfs_cache_default_acl(dir);
668 retval = reiserfs_security_init(dir, inode, &security);
669 if (retval < 0) {
670 drop_new_inode(inode);
671 return retval;
672 }
673 jbegin_count += retval;
674 reiserfs_write_lock(dir->i_sb);
675
676 retval = journal_begin(&th, dir->i_sb, jbegin_count);
677 if (retval) {
678 drop_new_inode(inode);
679 goto out_failed;
680 }
681
682 retval =
683 reiserfs_new_inode(&th, dir, mode, NULL, 0 , dentry,
684 inode, &security);
685 if (retval) {
686 goto out_failed;
687 }
688
689 inode->i_op = &reiserfs_special_inode_operations;
690 init_special_inode(inode, inode->i_mode, rdev);
691
692
693 reiserfs_update_sd(&th, inode);
694
695 reiserfs_update_inode_transaction(inode);
696 reiserfs_update_inode_transaction(dir);
697
698 retval =
699 reiserfs_add_entry(&th, dir, dentry->d_name.name,
700 dentry->d_name.len, inode, 1 );
701 if (retval) {
702 int err;
703 inode->i_nlink--;
704 reiserfs_update_sd(&th, inode);
705 err = journal_end(&th, dir->i_sb, jbegin_count);
706 if (err)
707 retval = err;
708 unlock_new_inode(inode);
709 iput(inode);
710 goto out_failed;
711 }
712
713 d_instantiate(dentry, inode);
714 unlock_new_inode(inode);
715 retval = journal_end(&th, dir->i_sb, jbegin_count);
716
717 out_failed:
718 reiserfs_write_unlock(dir->i_sb);
719 return retval;
720}
721
722static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
723{
724 int retval;
725 struct inode *inode;
726 struct reiserfs_transaction_handle th;
727 struct reiserfs_security_handle security;
728
729 int jbegin_count =
730 JOURNAL_PER_BALANCE_CNT * 3 +
731 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
732 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
733
734#ifdef DISPLACE_NEW_PACKING_LOCALITIES
735
736 REISERFS_I(dir)->new_packing_locality = 1;
737#endif
738 mode = S_IFDIR | mode;
739 if (!(inode = new_inode(dir->i_sb))) {
740 return -ENOMEM;
741 }
742 new_inode_init(inode, dir, mode);
743
744 jbegin_count += reiserfs_cache_default_acl(dir);
745 retval = reiserfs_security_init(dir, inode, &security);
746 if (retval < 0) {
747 drop_new_inode(inode);
748 return retval;
749 }
750 jbegin_count += retval;
751 reiserfs_write_lock(dir->i_sb);
752
753 retval = journal_begin(&th, dir->i_sb, jbegin_count);
754 if (retval) {
755 drop_new_inode(inode);
756 goto out_failed;
757 }
758
759
760
761
762 INC_DIR_INODE_NLINK(dir)
763
764 retval = reiserfs_new_inode(&th, dir, mode, NULL ,
765 old_format_only(dir->i_sb) ?
766 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
767 dentry, inode, &security);
768 if (retval) {
769 dir->i_nlink--;
770 goto out_failed;
771 }
772
773 reiserfs_update_inode_transaction(inode);
774 reiserfs_update_inode_transaction(dir);
775
776 inode->i_op = &reiserfs_dir_inode_operations;
777 inode->i_fop = &reiserfs_dir_operations;
778
779
780 retval =
781 reiserfs_add_entry(&th, dir, dentry->d_name.name,
782 dentry->d_name.len, inode, 1 );
783 if (retval) {
784 int err;
785 inode->i_nlink = 0;
786 DEC_DIR_INODE_NLINK(dir);
787 reiserfs_update_sd(&th, inode);
788 err = journal_end(&th, dir->i_sb, jbegin_count);
789 if (err)
790 retval = err;
791 unlock_new_inode(inode);
792 iput(inode);
793 goto out_failed;
794 }
795
796 reiserfs_update_sd(&th, dir);
797
798 d_instantiate(dentry, inode);
799 unlock_new_inode(inode);
800 retval = journal_end(&th, dir->i_sb, jbegin_count);
801 out_failed:
802 reiserfs_write_unlock(dir->i_sb);
803 return retval;
804}
805
806static inline int reiserfs_empty_dir(struct inode *inode)
807{
808
809
810
811
812
813 if (inode->i_size != EMPTY_DIR_SIZE &&
814 inode->i_size != EMPTY_DIR_SIZE_V1) {
815 return 0;
816 }
817 return 1;
818}
819
820static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
821{
822 int retval, err;
823 struct inode *inode;
824 struct reiserfs_transaction_handle th;
825 int jbegin_count;
826 INITIALIZE_PATH(path);
827 struct reiserfs_dir_entry de;
828
829
830
831
832
833 jbegin_count =
834 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
835 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
836
837 reiserfs_write_lock(dir->i_sb);
838 retval = journal_begin(&th, dir->i_sb, jbegin_count);
839 if (retval)
840 goto out_rmdir;
841
842 de.de_gen_number_bit_string = NULL;
843 if ((retval =
844 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
845 &path, &de)) == NAME_NOT_FOUND) {
846 retval = -ENOENT;
847 goto end_rmdir;
848 } else if (retval == IO_ERROR) {
849 retval = -EIO;
850 goto end_rmdir;
851 }
852
853 inode = dentry->d_inode;
854
855 reiserfs_update_inode_transaction(inode);
856 reiserfs_update_inode_transaction(dir);
857
858 if (de.de_objectid != inode->i_ino) {
859
860
861 retval = -EIO;
862 goto end_rmdir;
863 }
864 if (!reiserfs_empty_dir(inode)) {
865 retval = -ENOTEMPTY;
866 goto end_rmdir;
867 }
868
869
870 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
871 0 );
872 if (retval < 0)
873 goto end_rmdir;
874
875 if (inode->i_nlink != 2 && inode->i_nlink != 1)
876 reiserfs_error(inode->i_sb, "reiserfs-7040",
877 "empty directory has nlink != 2 (%d)",
878 inode->i_nlink);
879
880 clear_nlink(inode);
881 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
882 reiserfs_update_sd(&th, inode);
883
884 DEC_DIR_INODE_NLINK(dir)
885 dir->i_size -= (DEH_SIZE + de.de_entrylen);
886 reiserfs_update_sd(&th, dir);
887
888
889 add_save_link(&th, inode, 0 );
890
891 retval = journal_end(&th, dir->i_sb, jbegin_count);
892 reiserfs_check_path(&path);
893 out_rmdir:
894 reiserfs_write_unlock(dir->i_sb);
895 return retval;
896
897 end_rmdir:
898
899
900
901 pathrelse(&path);
902 err = journal_end(&th, dir->i_sb, jbegin_count);
903 reiserfs_write_unlock(dir->i_sb);
904 return err ? err : retval;
905}
906
907static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
908{
909 int retval, err;
910 struct inode *inode;
911 struct reiserfs_dir_entry de;
912 INITIALIZE_PATH(path);
913 struct reiserfs_transaction_handle th;
914 int jbegin_count;
915 unsigned long savelink;
916
917 inode = dentry->d_inode;
918
919
920
921
922
923 jbegin_count =
924 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
925 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
926
927 reiserfs_write_lock(dir->i_sb);
928 retval = journal_begin(&th, dir->i_sb, jbegin_count);
929 if (retval)
930 goto out_unlink;
931
932 de.de_gen_number_bit_string = NULL;
933 if ((retval =
934 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
935 &path, &de)) == NAME_NOT_FOUND) {
936 retval = -ENOENT;
937 goto end_unlink;
938 } else if (retval == IO_ERROR) {
939 retval = -EIO;
940 goto end_unlink;
941 }
942
943 reiserfs_update_inode_transaction(inode);
944 reiserfs_update_inode_transaction(dir);
945
946 if (de.de_objectid != inode->i_ino) {
947
948
949 retval = -EIO;
950 goto end_unlink;
951 }
952
953 if (!inode->i_nlink) {
954 reiserfs_warning(inode->i_sb, "reiserfs-7042",
955 "deleting nonexistent file (%lu), %d",
956 inode->i_ino, inode->i_nlink);
957 inode->i_nlink = 1;
958 }
959
960 drop_nlink(inode);
961
962
963
964
965
966 savelink = inode->i_nlink;
967
968 retval =
969 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
970 0);
971 if (retval < 0) {
972 inc_nlink(inode);
973 goto end_unlink;
974 }
975 inode->i_ctime = CURRENT_TIME_SEC;
976 reiserfs_update_sd(&th, inode);
977
978 dir->i_size -= (de.de_entrylen + DEH_SIZE);
979 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
980 reiserfs_update_sd(&th, dir);
981
982 if (!savelink)
983
984 add_save_link(&th, inode, 0 );
985
986 retval = journal_end(&th, dir->i_sb, jbegin_count);
987 reiserfs_check_path(&path);
988 reiserfs_write_unlock(dir->i_sb);
989 return retval;
990
991 end_unlink:
992 pathrelse(&path);
993 err = journal_end(&th, dir->i_sb, jbegin_count);
994 reiserfs_check_path(&path);
995 if (err)
996 retval = err;
997 out_unlink:
998 reiserfs_write_unlock(dir->i_sb);
999 return retval;
1000}
1001
1002static int reiserfs_symlink(struct inode *parent_dir,
1003 struct dentry *dentry, const char *symname)
1004{
1005 int retval;
1006 struct inode *inode;
1007 char *name;
1008 int item_len;
1009 struct reiserfs_transaction_handle th;
1010 struct reiserfs_security_handle security;
1011 int mode = S_IFLNK | S_IRWXUGO;
1012
1013 int jbegin_count =
1014 JOURNAL_PER_BALANCE_CNT * 3 +
1015 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1016 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1017
1018 if (!(inode = new_inode(parent_dir->i_sb))) {
1019 return -ENOMEM;
1020 }
1021 new_inode_init(inode, parent_dir, mode);
1022
1023 retval = reiserfs_security_init(parent_dir, inode, &security);
1024 if (retval < 0) {
1025 drop_new_inode(inode);
1026 return retval;
1027 }
1028 jbegin_count += retval;
1029
1030 reiserfs_write_lock(parent_dir->i_sb);
1031 item_len = ROUND_UP(strlen(symname));
1032 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1033 retval = -ENAMETOOLONG;
1034 drop_new_inode(inode);
1035 goto out_failed;
1036 }
1037
1038 name = kmalloc(item_len, GFP_NOFS);
1039 if (!name) {
1040 drop_new_inode(inode);
1041 retval = -ENOMEM;
1042 goto out_failed;
1043 }
1044 memcpy(name, symname, strlen(symname));
1045 padd_item(name, item_len, strlen(symname));
1046
1047 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1048 if (retval) {
1049 drop_new_inode(inode);
1050 kfree(name);
1051 goto out_failed;
1052 }
1053
1054 retval =
1055 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1056 dentry, inode, &security);
1057 kfree(name);
1058 if (retval) {
1059 goto out_failed;
1060 }
1061
1062 reiserfs_update_inode_transaction(inode);
1063 reiserfs_update_inode_transaction(parent_dir);
1064
1065 inode->i_op = &reiserfs_symlink_inode_operations;
1066 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1067
1068
1069
1070
1071
1072 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1073 dentry->d_name.len, inode, 1 );
1074 if (retval) {
1075 int err;
1076 inode->i_nlink--;
1077 reiserfs_update_sd(&th, inode);
1078 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1079 if (err)
1080 retval = err;
1081 unlock_new_inode(inode);
1082 iput(inode);
1083 goto out_failed;
1084 }
1085
1086 d_instantiate(dentry, inode);
1087 unlock_new_inode(inode);
1088 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1089 out_failed:
1090 reiserfs_write_unlock(parent_dir->i_sb);
1091 return retval;
1092}
1093
1094static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1095 struct dentry *dentry)
1096{
1097 int retval;
1098 struct inode *inode = old_dentry->d_inode;
1099 struct reiserfs_transaction_handle th;
1100
1101 int jbegin_count =
1102 JOURNAL_PER_BALANCE_CNT * 3 +
1103 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1104
1105 reiserfs_write_lock(dir->i_sb);
1106 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1107
1108 reiserfs_write_unlock(dir->i_sb);
1109 return -EMLINK;
1110 }
1111 if (inode->i_nlink == 0) {
1112 reiserfs_write_unlock(dir->i_sb);
1113 return -ENOENT;
1114 }
1115
1116
1117 inc_nlink(inode);
1118
1119 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1120 if (retval) {
1121 inode->i_nlink--;
1122 reiserfs_write_unlock(dir->i_sb);
1123 return retval;
1124 }
1125
1126
1127 retval =
1128 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1129 dentry->d_name.len, inode, 1 );
1130
1131 reiserfs_update_inode_transaction(inode);
1132 reiserfs_update_inode_transaction(dir);
1133
1134 if (retval) {
1135 int err;
1136 inode->i_nlink--;
1137 err = journal_end(&th, dir->i_sb, jbegin_count);
1138 reiserfs_write_unlock(dir->i_sb);
1139 return err ? err : retval;
1140 }
1141
1142 inode->i_ctime = CURRENT_TIME_SEC;
1143 reiserfs_update_sd(&th, inode);
1144
1145 atomic_inc(&inode->i_count);
1146 d_instantiate(dentry, inode);
1147 retval = journal_end(&th, dir->i_sb, jbegin_count);
1148 reiserfs_write_unlock(dir->i_sb);
1149 return retval;
1150}
1151
1152
1153static int de_still_valid(const char *name, int len,
1154 struct reiserfs_dir_entry *de)
1155{
1156 struct reiserfs_dir_entry tmp = *de;
1157
1158
1159 set_de_name_and_namelen(&tmp);
1160
1161 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1162 return 0;
1163 return 1;
1164}
1165
1166static int entry_points_to_object(const char *name, int len,
1167 struct reiserfs_dir_entry *de,
1168 struct inode *inode)
1169{
1170 if (!de_still_valid(name, len, de))
1171 return 0;
1172
1173 if (inode) {
1174 if (!de_visible(de->de_deh + de->de_entry_num))
1175 reiserfs_panic(inode->i_sb, "vs-7042",
1176 "entry must be visible");
1177 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1178 }
1179
1180
1181 if (de_visible(de->de_deh + de->de_entry_num))
1182 reiserfs_panic(NULL, "vs-7043", "entry must be visible");
1183
1184 return 1;
1185}
1186
1187
1188static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1189 struct reiserfs_key *key)
1190{
1191
1192 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1193 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1194}
1195
1196
1197
1198
1199
1200
1201static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1202 struct inode *new_dir, struct dentry *new_dentry)
1203{
1204 int retval;
1205 INITIALIZE_PATH(old_entry_path);
1206 INITIALIZE_PATH(new_entry_path);
1207 INITIALIZE_PATH(dot_dot_entry_path);
1208 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1209 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1210 struct inode *old_inode, *new_dentry_inode;
1211 struct reiserfs_transaction_handle th;
1212 int jbegin_count;
1213 umode_t old_inode_mode;
1214 unsigned long savelink = 1;
1215 struct timespec ctime;
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225 jbegin_count =
1226 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1227 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1228
1229 old_inode = old_dentry->d_inode;
1230 new_dentry_inode = new_dentry->d_inode;
1231
1232
1233
1234 old_de.de_gen_number_bit_string = NULL;
1235 reiserfs_write_lock(old_dir->i_sb);
1236 retval =
1237 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1238 old_dentry->d_name.len, &old_entry_path,
1239 &old_de);
1240 pathrelse(&old_entry_path);
1241 if (retval == IO_ERROR) {
1242 reiserfs_write_unlock(old_dir->i_sb);
1243 return -EIO;
1244 }
1245
1246 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1247 reiserfs_write_unlock(old_dir->i_sb);
1248 return -ENOENT;
1249 }
1250
1251 old_inode_mode = old_inode->i_mode;
1252 if (S_ISDIR(old_inode_mode)) {
1253
1254
1255
1256
1257 if (new_dentry_inode) {
1258 if (!reiserfs_empty_dir(new_dentry_inode)) {
1259 reiserfs_write_unlock(old_dir->i_sb);
1260 return -ENOTEMPTY;
1261 }
1262 }
1263
1264
1265
1266
1267 dot_dot_de.de_gen_number_bit_string = NULL;
1268 retval =
1269 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1270 &dot_dot_de);
1271 pathrelse(&dot_dot_entry_path);
1272 if (retval != NAME_FOUND) {
1273 reiserfs_write_unlock(old_dir->i_sb);
1274 return -EIO;
1275 }
1276
1277
1278 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1279 reiserfs_write_unlock(old_dir->i_sb);
1280 return -EIO;
1281 }
1282 }
1283
1284 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1285 if (retval) {
1286 reiserfs_write_unlock(old_dir->i_sb);
1287 return retval;
1288 }
1289
1290
1291 retval =
1292 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1293 new_dentry->d_name.len, old_inode, 0);
1294 if (retval == -EEXIST) {
1295 if (!new_dentry_inode) {
1296 reiserfs_panic(old_dir->i_sb, "vs-7050",
1297 "new entry is found, new inode == 0");
1298 }
1299 } else if (retval) {
1300 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1301 reiserfs_write_unlock(old_dir->i_sb);
1302 return err ? err : retval;
1303 }
1304
1305 reiserfs_update_inode_transaction(old_dir);
1306 reiserfs_update_inode_transaction(new_dir);
1307
1308
1309
1310
1311 reiserfs_update_inode_transaction(old_inode);
1312
1313 if (new_dentry_inode)
1314 reiserfs_update_inode_transaction(new_dentry_inode);
1315
1316 while (1) {
1317
1318 if ((retval =
1319 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1320 &old_entry_path,
1321 &old_de)) != NAME_FOUND) {
1322 pathrelse(&old_entry_path);
1323 journal_end(&th, old_dir->i_sb, jbegin_count);
1324 reiserfs_write_unlock(old_dir->i_sb);
1325 return -EIO;
1326 }
1327
1328 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
1329
1330 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1331
1332
1333 new_de.de_gen_number_bit_string = NULL;
1334 retval =
1335 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1336 new_dentry->d_name.len, &new_entry_path,
1337 &new_de);
1338
1339
1340 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1341 pathrelse(&new_entry_path);
1342 pathrelse(&old_entry_path);
1343 journal_end(&th, old_dir->i_sb, jbegin_count);
1344 reiserfs_write_unlock(old_dir->i_sb);
1345 return -EIO;
1346 }
1347
1348 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1349
1350 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1351
1352 if (S_ISDIR(old_inode->i_mode)) {
1353 if ((retval =
1354 search_by_entry_key(new_dir->i_sb,
1355 &dot_dot_de.de_entry_key,
1356 &dot_dot_entry_path,
1357 &dot_dot_de)) != NAME_FOUND) {
1358 pathrelse(&dot_dot_entry_path);
1359 pathrelse(&new_entry_path);
1360 pathrelse(&old_entry_path);
1361 journal_end(&th, old_dir->i_sb, jbegin_count);
1362 reiserfs_write_unlock(old_dir->i_sb);
1363 return -EIO;
1364 }
1365 copy_item_head(&dot_dot_ih,
1366 get_ih(&dot_dot_entry_path));
1367
1368 reiserfs_prepare_for_journal(old_inode->i_sb,
1369 dot_dot_de.de_bh, 1);
1370 }
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384 if (item_moved(&new_entry_ih, &new_entry_path) ||
1385 !entry_points_to_object(new_dentry->d_name.name,
1386 new_dentry->d_name.len,
1387 &new_de, new_dentry_inode) ||
1388 item_moved(&old_entry_ih, &old_entry_path) ||
1389 !entry_points_to_object(old_dentry->d_name.name,
1390 old_dentry->d_name.len,
1391 &old_de, old_inode)) {
1392 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1393 new_de.de_bh);
1394 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1395 old_de.de_bh);
1396 if (S_ISDIR(old_inode_mode))
1397 reiserfs_restore_prepared_buffer(old_inode->
1398 i_sb,
1399 dot_dot_de.
1400 de_bh);
1401 continue;
1402 }
1403 if (S_ISDIR(old_inode_mode)) {
1404 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1405 !entry_points_to_object("..", 2, &dot_dot_de,
1406 old_dir)) {
1407 reiserfs_restore_prepared_buffer(old_inode->
1408 i_sb,
1409 old_de.de_bh);
1410 reiserfs_restore_prepared_buffer(old_inode->
1411 i_sb,
1412 new_de.de_bh);
1413 reiserfs_restore_prepared_buffer(old_inode->
1414 i_sb,
1415 dot_dot_de.
1416 de_bh);
1417 continue;
1418 }
1419 }
1420
1421 RFALSE(S_ISDIR(old_inode_mode) &&
1422 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1423
1424 break;
1425 }
1426
1427
1428
1429
1430 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1431 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1432 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1433
1434 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1435 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1436 ctime = CURRENT_TIME_SEC;
1437 old_dir->i_ctime = old_dir->i_mtime = ctime;
1438 new_dir->i_ctime = new_dir->i_mtime = ctime;
1439
1440
1441 old_inode->i_ctime = ctime;
1442
1443 if (new_dentry_inode) {
1444
1445 if (S_ISDIR(new_dentry_inode->i_mode)) {
1446 clear_nlink(new_dentry_inode);
1447 } else {
1448 drop_nlink(new_dentry_inode);
1449 }
1450 new_dentry_inode->i_ctime = ctime;
1451 savelink = new_dentry_inode->i_nlink;
1452 }
1453
1454 if (S_ISDIR(old_inode_mode)) {
1455
1456 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1457 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1458
1459 if (!new_dentry_inode)
1460
1461
1462 INC_DIR_INODE_NLINK(new_dir);
1463
1464
1465 DEC_DIR_INODE_NLINK(old_dir);
1466 }
1467
1468 pathrelse(&new_entry_path);
1469 pathrelse(&dot_dot_entry_path);
1470
1471
1472
1473
1474 if (reiserfs_cut_from_item
1475 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1476 0) < 0)
1477 reiserfs_error(old_dir->i_sb, "vs-7060",
1478 "couldn't not cut old name. Fsck later?");
1479
1480 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1481
1482 reiserfs_update_sd(&th, old_dir);
1483 reiserfs_update_sd(&th, new_dir);
1484 reiserfs_update_sd(&th, old_inode);
1485
1486 if (new_dentry_inode) {
1487 if (savelink == 0)
1488 add_save_link(&th, new_dentry_inode,
1489 0 );
1490 reiserfs_update_sd(&th, new_dentry_inode);
1491 }
1492
1493 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1494 reiserfs_write_unlock(old_dir->i_sb);
1495 return retval;
1496}
1497
1498
1499
1500
1501const struct inode_operations reiserfs_dir_inode_operations = {
1502
1503 .create = reiserfs_create,
1504 .lookup = reiserfs_lookup,
1505 .link = reiserfs_link,
1506 .unlink = reiserfs_unlink,
1507 .symlink = reiserfs_symlink,
1508 .mkdir = reiserfs_mkdir,
1509 .rmdir = reiserfs_rmdir,
1510 .mknod = reiserfs_mknod,
1511 .rename = reiserfs_rename,
1512 .setattr = reiserfs_setattr,
1513 .setxattr = reiserfs_setxattr,
1514 .getxattr = reiserfs_getxattr,
1515 .listxattr = reiserfs_listxattr,
1516 .removexattr = reiserfs_removexattr,
1517 .permission = reiserfs_permission,
1518};
1519
1520
1521
1522
1523
1524const struct inode_operations reiserfs_symlink_inode_operations = {
1525 .readlink = generic_readlink,
1526 .follow_link = page_follow_link_light,
1527 .put_link = page_put_link,
1528 .setattr = reiserfs_setattr,
1529 .setxattr = reiserfs_setxattr,
1530 .getxattr = reiserfs_getxattr,
1531 .listxattr = reiserfs_listxattr,
1532 .removexattr = reiserfs_removexattr,
1533 .permission = reiserfs_permission,
1534
1535};
1536
1537
1538
1539
1540const struct inode_operations reiserfs_special_inode_operations = {
1541 .setattr = reiserfs_setattr,
1542 .setxattr = reiserfs_setxattr,
1543 .getxattr = reiserfs_getxattr,
1544 .listxattr = reiserfs_listxattr,
1545 .removexattr = reiserfs_removexattr,
1546 .permission = reiserfs_permission,
1547
1548};
1549