2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
4 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
7 * Rights granted to Hans Reiser to redistribute under other terms providing
8 * he accepts all liability including but not limited to patent, fitness
9 * for purpose, and direct or indirect claims arising from failure to perform.
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>
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);
24 // directory item contains array of entry headers. This performs
25 // binary search through that array
26 static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
28 struct item_head *ih = de->de_ih;
29 struct reiserfs_de_head *deh = de->de_deh;
30 int rbound, lbound, j;
33 rbound = I_ENTRY_COUNT(ih) - 1;
35 for (j = (rbound + lbound) / 2; lbound <= rbound;
36 j = (rbound + lbound) / 2) {
37 if (off < deh_offset(deh + j)) {
41 if (off > deh_offset(deh + j)) {
45 // this is not name found, but matched third key component
50 de->de_entry_num = lbound;
51 return NAME_NOT_FOUND;
54 // comment? maybe something like set de to point to what the path points to?
55 static inline void set_de_item_location(struct reiserfs_dir_entry *de,
56 struct treepath *path)
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);
64 // de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
65 inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
67 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
69 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
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);
78 // what entry points to
79 static inline void set_de_object_key(struct reiserfs_dir_entry *de)
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]));
86 static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
88 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
90 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
92 /* store key of the found entry */
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);
102 /* We assign a key to each directory item, and place multiple entries
103 in a single directory item. A directory item has a key equal to the
104 key of the first directory entry in it.
106 This function first calls search_by_key, then, if item whose first
107 entry matches is not found it looks for the entry inside directory
108 item found by search_by_key. Fills the path to the entry, and to the
109 entry position in the item
113 /* The function is NOT SCHEDULE-SAFE! */
114 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
115 struct treepath *path, struct reiserfs_dir_entry *de)
119 retval = search_item(sb, key, path);
122 if (!PATH_LAST_POSITION(path)) {
123 reiserfs_warning(sb, "vs-7000", "search_by_key "
124 "returned item position == 0");
128 PATH_LAST_POSITION(path)--;
138 reiserfs_warning(sb, "vs-7002", "no path to here");
142 set_de_item_location(de, path);
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);
149 "vs-7005: search_by_entry_key: found item %h is not directory item or "
150 "does not belong to the same directory as key %K",
153 #endif /* CONFIG_REISERFS_CHECK */
155 /* binary search in directory item by third componen t of the
156 key. sets de->de_entry_num of de */
157 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
158 path->pos_in_item = de->de_entry_num;
159 if (retval != NAME_NOT_FOUND) {
160 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
161 set_de_name_and_namelen(de);
162 set_de_object_key(de);
167 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
169 /* The third component is hashed, and you can choose from more than
170 one hash function. Per directory hashes are not yet implemented
171 but are thought about. This function should be moved to hashes.c
172 Jedi, please do so. -Hans */
174 static __u32 get_third_component(struct super_block *s,
175 const char *name, int len)
179 if (!len || (len == 1 && name[0] == '.'))
181 if (len == 2 && name[0] == '.' && name[1] == '.')
182 return DOT_DOT_OFFSET;
184 res = REISERFS_SB(s)->s_hash_function(name, len);
186 // take bits from 7-th to 30-th including both bounds
187 res = GET_HASH_VALUE(res);
189 // needed to have no names before "." and ".." those have hash
190 // value == 0 and generation conters 1 and 2 accordingly
192 return res + MAX_GENERATION_NUMBER;
195 static int reiserfs_match(struct reiserfs_dir_entry *de,
196 const char *name, int namelen)
198 int retval = NAME_NOT_FOUND;
200 if ((namelen == de->de_namelen) &&
201 !memcmp(de->de_name, name, de->de_namelen))
203 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
204 NAME_FOUND_INVISIBLE);
209 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
211 /* used when hash collisions exist */
213 static int linear_search_in_dir_item(struct cpu_key *key,
214 struct reiserfs_dir_entry *de,
215 const char *name, int namelen)
217 struct reiserfs_de_head *deh = de->de_deh;
221 i = de->de_entry_num;
223 if (i == I_ENTRY_COUNT(de->de_ih) ||
224 GET_HASH_VALUE(deh_offset(deh + i)) !=
225 GET_HASH_VALUE(cpu_key_k_offset(key))) {
229 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
230 "vs-7010: array of entry headers not found");
234 for (; i >= 0; i--, deh--) {
235 if (GET_HASH_VALUE(deh_offset(deh)) !=
236 GET_HASH_VALUE(cpu_key_k_offset(key))) {
237 // hash value does not match, no need to check whole name
238 return NAME_NOT_FOUND;
241 /* mark, that this generation number is used */
242 if (de->de_gen_number_bit_string)
243 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
244 de->de_gen_number_bit_string);
246 // calculate pointer to name and namelen
247 de->de_entry_num = i;
248 set_de_name_and_namelen(de);
251 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
252 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
254 // key of pointed object
255 set_de_object_key(de);
257 store_de_entry_key(de);
259 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
264 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
265 /* we have reached left most entry in the node. In common we
266 have to go to the left neighbor, but if generation counter
267 is 0 already, we know for sure, that there is no name with
268 the same hash value */
269 // FIXME: this work correctly only because hash value can not
270 // be 0. Btw, in case of Yura's hash it is probably possible,
272 return NAME_NOT_FOUND;
274 RFALSE(de->de_item_num,
275 "vs-7015: two diritems of the same directory in one node?");
277 return GOTO_PREVIOUS_ITEM;
280 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
281 // FIXME: should add something like IOERROR
282 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
283 struct treepath *path_to_entry,
284 struct reiserfs_dir_entry *de)
286 struct cpu_key key_to_search;
289 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
290 return NAME_NOT_FOUND;
292 /* we will search for this key in the tree */
293 make_cpu_key(&key_to_search, dir,
294 get_third_component(dir->i_sb, name, namelen),
299 search_by_entry_key(dir->i_sb, &key_to_search,
301 if (retval == IO_ERROR) {
302 reiserfs_warning(dir->i_sb, "zam-7001", "io error");
306 /* compare names for all entries having given hash value */
308 linear_search_in_dir_item(&key_to_search, de, name,
310 if (retval != GOTO_PREVIOUS_ITEM) {
311 /* there is no need to scan directory anymore. Given entry found or does not exist */
312 path_to_entry->pos_in_item = de->de_entry_num;
316 /* there is left neighboring item of this directory and given entry can be there */
317 set_cpu_key_k_offset(&key_to_search,
318 le_ih_k_offset(de->de_ih) - 1);
319 pathrelse(path_to_entry);
324 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
325 struct nameidata *nd)
328 struct inode *inode = NULL;
329 struct reiserfs_dir_entry de;
330 INITIALIZE_PATH(path_to_entry);
332 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
333 return ERR_PTR(-ENAMETOOLONG);
335 reiserfs_write_lock(dir->i_sb);
336 de.de_gen_number_bit_string = NULL;
338 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
339 &path_to_entry, &de);
340 pathrelse(&path_to_entry);
341 if (retval == NAME_FOUND) {
342 /* Hide the .reiserfs_priv directory */
343 if (reiserfs_xattrs(dir->i_sb) &&
344 !old_format_only(dir->i_sb) &&
345 REISERFS_SB(dir->i_sb)->priv_root &&
346 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
348 le32_to_cpu(INODE_PKEY
349 (REISERFS_SB(dir->i_sb)->priv_root->d_inode)->
351 reiserfs_write_unlock(dir->i_sb);
352 return ERR_PTR(-EACCES);
356 reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
357 if (!inode || IS_ERR(inode)) {
358 reiserfs_write_unlock(dir->i_sb);
359 return ERR_PTR(-EACCES);
362 /* Propogate the priv_object flag so we know we're in the priv tree */
363 if (is_reiserfs_priv_object(dir))
364 reiserfs_mark_inode_private(inode);
366 reiserfs_write_unlock(dir->i_sb);
367 if (retval == IO_ERROR) {
368 return ERR_PTR(-EIO);
371 return d_splice_alias(inode, dentry);
375 ** looks up the dentry of the parent directory for child.
376 ** taken from ext2_get_parent
378 struct dentry *reiserfs_get_parent(struct dentry *child)
381 struct inode *inode = NULL;
382 struct reiserfs_dir_entry de;
383 INITIALIZE_PATH(path_to_entry);
384 struct inode *dir = child->d_inode;
386 if (dir->i_nlink == 0) {
387 return ERR_PTR(-ENOENT);
389 de.de_gen_number_bit_string = NULL;
391 reiserfs_write_lock(dir->i_sb);
392 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
393 pathrelse(&path_to_entry);
394 if (retval != NAME_FOUND) {
395 reiserfs_write_unlock(dir->i_sb);
396 return ERR_PTR(-ENOENT);
398 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
399 reiserfs_write_unlock(dir->i_sb);
401 return d_obtain_alias(inode);
404 /* add entry to the directory (entry can be hidden).
406 insert definition of when hidden directories are used here -Hans
408 Does not mark dir inode dirty, do it after successesfull call to it */
410 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
411 struct inode *dir, const char *name, int namelen,
412 struct inode *inode, int visible)
414 struct cpu_key entry_key;
415 struct reiserfs_de_head *deh;
416 INITIALIZE_PATH(path);
417 struct reiserfs_dir_entry de;
418 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
420 char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
421 if we create file with short name */
423 int buflen, paste_size;
426 BUG_ON(!th->t_trans_id);
428 /* cannot allow items to be added into a busy deleted directory */
432 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
433 return -ENAMETOOLONG;
435 /* each entry has unique key. compose it */
436 make_cpu_key(&entry_key, dir,
437 get_third_component(dir->i_sb, name, namelen),
440 /* get memory for composing the entry */
441 buflen = DEH_SIZE + ROUND_UP(namelen);
442 if (buflen > sizeof(small_buf)) {
443 buffer = kmalloc(buflen, GFP_NOFS);
450 (get_inode_sd_version(dir) ==
451 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
453 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
454 deh = (struct reiserfs_de_head *)buffer;
455 deh->deh_location = 0; /* JDM Endian safe if 0 */
456 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
457 deh->deh_state = 0; /* JDM Endian safe if 0 */
458 /* put key (ino analog) to de */
459 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
460 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
463 memcpy((char *)(deh + 1), name, namelen);
464 /* padd by 0s to the 4 byte boundary */
465 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
467 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
468 mark_de_without_sd(deh);
469 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
471 /* find the proper place for the new entry */
472 memset(bit_string, 0, sizeof(bit_string));
473 de.de_gen_number_bit_string = bit_string;
474 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
475 if (retval != NAME_NOT_FOUND) {
476 if (buffer != small_buf)
480 if (retval == IO_ERROR) {
484 if (retval != NAME_FOUND) {
485 reiserfs_warning(dir->i_sb, "zam-7002",
486 "reiserfs_find_entry() returned "
487 "unexpected value (%d)", retval);
494 find_first_zero_bit(bit_string,
495 MAX_GENERATION_NUMBER + 1);
496 if (gen_number > MAX_GENERATION_NUMBER) {
497 /* there is no free generation number */
498 reiserfs_warning(dir->i_sb, "reiserfs-7010",
499 "Congratulations! we have got hash function "
501 if (buffer != small_buf)
506 /* adjust offset of directory enrty */
507 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
508 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
510 /* update max-hash-collisions counter in reiserfs_sb_info */
511 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
513 if (gen_number != 0) { /* we need to re-search for the insertion point */
514 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
516 reiserfs_warning(dir->i_sb, "vs-7032",
517 "entry with this key (%K) already "
518 "exists", &entry_key);
520 if (buffer != small_buf)
527 /* perform the insertion of the entry that we have prepared */
529 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
531 if (buffer != small_buf)
534 reiserfs_check_path(&path);
538 dir->i_size += paste_size;
539 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
540 if (!S_ISDIR(inode->i_mode) && visible)
541 // reiserfs_mkdir or reiserfs_rename will do that by itself
542 reiserfs_update_sd(th, dir);
544 reiserfs_check_path(&path);
548 /* quota utility function, call if you've had to abort after calling
549 ** new_inode_init, and have not called reiserfs_new_inode yet.
550 ** This should only be called on inodes that do not have stat data
551 ** inserted into the tree yet.
553 static int drop_new_inode(struct inode *inode)
556 make_bad_inode(inode);
557 inode->i_flags |= S_NOQUOTA;
562 /* utility function that does setup for reiserfs_new_inode.
563 ** DQUOT_INIT needs lots of credits so it's better to have it
564 ** outside of a transaction, so we had to pull some bits of
565 ** reiserfs_new_inode out into this func.
567 static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
570 /* the quota init calls have to know who to charge the quota to, so
571 ** we have to set uid and gid here
573 inode->i_uid = current_fsuid();
574 inode->i_mode = mode;
575 /* Make inode invalid - just in case we are going to drop it before
576 * the initialization happens */
577 INODE_PKEY(inode)->k_objectid = 0;
579 if (dir->i_mode & S_ISGID) {
580 inode->i_gid = dir->i_gid;
582 inode->i_mode |= S_ISGID;
584 inode->i_gid = current_fsgid();
590 static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
591 struct nameidata *nd)
595 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
597 JOURNAL_PER_BALANCE_CNT * 2 +
598 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
599 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
600 struct reiserfs_transaction_handle th;
603 if (!(inode = new_inode(dir->i_sb))) {
606 new_inode_init(inode, dir, mode);
608 locked = reiserfs_cache_default_acl(dir);
610 reiserfs_write_lock(dir->i_sb);
613 reiserfs_write_lock_xattrs(dir->i_sb);
615 retval = journal_begin(&th, dir->i_sb, jbegin_count);
617 drop_new_inode(inode);
622 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
628 reiserfs_write_unlock_xattrs(dir->i_sb);
632 inode->i_op = &reiserfs_file_inode_operations;
633 inode->i_fop = &reiserfs_file_operations;
634 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
637 reiserfs_add_entry(&th, dir, dentry->d_name.name,
638 dentry->d_name.len, inode, 1 /*visible */ );
642 reiserfs_update_sd(&th, inode);
643 err = journal_end(&th, dir->i_sb, jbegin_count);
646 unlock_new_inode(inode);
650 reiserfs_update_inode_transaction(inode);
651 reiserfs_update_inode_transaction(dir);
653 d_instantiate(dentry, inode);
654 unlock_new_inode(inode);
655 retval = journal_end(&th, dir->i_sb, jbegin_count);
659 reiserfs_write_unlock_xattrs(dir->i_sb);
660 reiserfs_write_unlock(dir->i_sb);
664 static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
669 struct reiserfs_transaction_handle th;
670 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
672 JOURNAL_PER_BALANCE_CNT * 3 +
673 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
674 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
677 if (!new_valid_dev(rdev))
680 if (!(inode = new_inode(dir->i_sb))) {
683 new_inode_init(inode, dir, mode);
685 locked = reiserfs_cache_default_acl(dir);
687 reiserfs_write_lock(dir->i_sb);
690 reiserfs_write_lock_xattrs(dir->i_sb);
692 retval = journal_begin(&th, dir->i_sb, jbegin_count);
694 drop_new_inode(inode);
699 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
706 reiserfs_write_unlock_xattrs(dir->i_sb);
710 inode->i_op = &reiserfs_special_inode_operations;
711 init_special_inode(inode, inode->i_mode, rdev);
713 //FIXME: needed for block and char devices only
714 reiserfs_update_sd(&th, inode);
716 reiserfs_update_inode_transaction(inode);
717 reiserfs_update_inode_transaction(dir);
720 reiserfs_add_entry(&th, dir, dentry->d_name.name,
721 dentry->d_name.len, inode, 1 /*visible */ );
725 reiserfs_update_sd(&th, inode);
726 err = journal_end(&th, dir->i_sb, jbegin_count);
729 unlock_new_inode(inode);
734 d_instantiate(dentry, inode);
735 unlock_new_inode(inode);
736 retval = journal_end(&th, dir->i_sb, jbegin_count);
740 reiserfs_write_unlock_xattrs(dir->i_sb);
741 reiserfs_write_unlock(dir->i_sb);
745 static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
749 struct reiserfs_transaction_handle th;
750 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
752 JOURNAL_PER_BALANCE_CNT * 3 +
753 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
754 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
757 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
758 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
759 REISERFS_I(dir)->new_packing_locality = 1;
761 mode = S_IFDIR | mode;
762 if (!(inode = new_inode(dir->i_sb))) {
765 new_inode_init(inode, dir, mode);
767 locked = reiserfs_cache_default_acl(dir);
769 reiserfs_write_lock(dir->i_sb);
771 reiserfs_write_lock_xattrs(dir->i_sb);
773 retval = journal_begin(&th, dir->i_sb, jbegin_count);
775 drop_new_inode(inode);
779 /* inc the link count now, so another writer doesn't overflow it while
780 ** we sleep later on.
782 INC_DIR_INODE_NLINK(dir)
784 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
785 old_format_only(dir->i_sb) ?
786 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
794 reiserfs_write_unlock_xattrs(dir->i_sb);
798 reiserfs_update_inode_transaction(inode);
799 reiserfs_update_inode_transaction(dir);
801 inode->i_op = &reiserfs_dir_inode_operations;
802 inode->i_fop = &reiserfs_dir_operations;
804 // note, _this_ add_entry will not update dir's stat data
806 reiserfs_add_entry(&th, dir, dentry->d_name.name,
807 dentry->d_name.len, inode, 1 /*visible */ );
811 DEC_DIR_INODE_NLINK(dir);
812 reiserfs_update_sd(&th, inode);
813 err = journal_end(&th, dir->i_sb, jbegin_count);
816 unlock_new_inode(inode);
820 // the above add_entry did not update dir's stat data
821 reiserfs_update_sd(&th, dir);
823 d_instantiate(dentry, inode);
824 unlock_new_inode(inode);
825 retval = journal_end(&th, dir->i_sb, jbegin_count);
828 reiserfs_write_unlock_xattrs(dir->i_sb);
829 reiserfs_write_unlock(dir->i_sb);
833 static inline int reiserfs_empty_dir(struct inode *inode)
835 /* we can cheat because an old format dir cannot have
836 ** EMPTY_DIR_SIZE, and a new format dir cannot have
837 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
838 ** regardless of disk format version, the directory is empty.
840 if (inode->i_size != EMPTY_DIR_SIZE &&
841 inode->i_size != EMPTY_DIR_SIZE_V1) {
847 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
851 struct reiserfs_transaction_handle th;
853 INITIALIZE_PATH(path);
854 struct reiserfs_dir_entry de;
856 /* we will be doing 2 balancings and update 2 stat data, we change quotas
857 * of the owner of the directory and of the owner of the parent directory.
858 * The quota structure is possibly deleted only on last iput => outside
859 * of this transaction */
861 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
862 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
864 reiserfs_write_lock(dir->i_sb);
865 retval = journal_begin(&th, dir->i_sb, jbegin_count);
869 de.de_gen_number_bit_string = NULL;
871 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
872 &path, &de)) == NAME_NOT_FOUND) {
875 } else if (retval == IO_ERROR) {
880 inode = dentry->d_inode;
882 reiserfs_update_inode_transaction(inode);
883 reiserfs_update_inode_transaction(dir);
885 if (de.de_objectid != inode->i_ino) {
886 // FIXME: compare key of an object and a key found in the
891 if (!reiserfs_empty_dir(inode)) {
896 /* cut entry from dir directory */
897 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL, /* page */
898 0 /*new file size - not used here */ );
902 if (inode->i_nlink != 2 && inode->i_nlink != 1)
903 reiserfs_warning(inode->i_sb, "reiserfs-7040",
904 "empty directory has nlink != 2 (%d)",
908 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
909 reiserfs_update_sd(&th, inode);
911 DEC_DIR_INODE_NLINK(dir)
912 dir->i_size -= (DEH_SIZE + de.de_entrylen);
913 reiserfs_update_sd(&th, dir);
915 /* prevent empty directory from getting lost */
916 add_save_link(&th, inode, 0 /* not truncate */ );
918 retval = journal_end(&th, dir->i_sb, jbegin_count);
919 reiserfs_check_path(&path);
921 reiserfs_write_unlock(dir->i_sb);
925 /* we must release path, because we did not call
926 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
927 release path if operation was not complete */
929 err = journal_end(&th, dir->i_sb, jbegin_count);
930 reiserfs_write_unlock(dir->i_sb);
931 return err ? err : retval;
934 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
938 struct reiserfs_dir_entry de;
939 INITIALIZE_PATH(path);
940 struct reiserfs_transaction_handle th;
942 unsigned long savelink;
944 inode = dentry->d_inode;
946 /* in this transaction we can be doing at max two balancings and update
947 * two stat datas, we change quotas of the owner of the directory and of
948 * the owner of the parent directory. The quota structure is possibly
949 * deleted only on iput => outside of this transaction */
951 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
952 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
954 reiserfs_write_lock(dir->i_sb);
955 retval = journal_begin(&th, dir->i_sb, jbegin_count);
959 de.de_gen_number_bit_string = NULL;
961 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
962 &path, &de)) == NAME_NOT_FOUND) {
965 } else if (retval == IO_ERROR) {
970 reiserfs_update_inode_transaction(inode);
971 reiserfs_update_inode_transaction(dir);
973 if (de.de_objectid != inode->i_ino) {
974 // FIXME: compare key of an object and a key found in the
980 if (!inode->i_nlink) {
981 reiserfs_warning(inode->i_sb, "reiserfs-7042",
982 "deleting nonexistent file (%lu), %d",
983 inode->i_ino, inode->i_nlink);
990 * we schedule before doing the add_save_link call, save the link
991 * count so we don't race
993 savelink = inode->i_nlink;
996 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
1002 inode->i_ctime = CURRENT_TIME_SEC;
1003 reiserfs_update_sd(&th, inode);
1005 dir->i_size -= (de.de_entrylen + DEH_SIZE);
1006 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
1007 reiserfs_update_sd(&th, dir);
1010 /* prevent file from getting lost */
1011 add_save_link(&th, inode, 0 /* not truncate */ );
1013 retval = journal_end(&th, dir->i_sb, jbegin_count);
1014 reiserfs_check_path(&path);
1015 reiserfs_write_unlock(dir->i_sb);
1020 err = journal_end(&th, dir->i_sb, jbegin_count);
1021 reiserfs_check_path(&path);
1025 reiserfs_write_unlock(dir->i_sb);
1029 static int reiserfs_symlink(struct inode *parent_dir,
1030 struct dentry *dentry, const char *symname)
1033 struct inode *inode;
1036 struct reiserfs_transaction_handle th;
1037 int mode = S_IFLNK | S_IRWXUGO;
1038 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1040 JOURNAL_PER_BALANCE_CNT * 3 +
1041 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1042 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1044 if (!(inode = new_inode(parent_dir->i_sb))) {
1047 new_inode_init(inode, parent_dir, mode);
1049 reiserfs_write_lock(parent_dir->i_sb);
1050 item_len = ROUND_UP(strlen(symname));
1051 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1052 retval = -ENAMETOOLONG;
1053 drop_new_inode(inode);
1057 name = kmalloc(item_len, GFP_NOFS);
1059 drop_new_inode(inode);
1063 memcpy(name, symname, strlen(symname));
1064 padd_item(name, item_len, strlen(symname));
1066 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1068 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1070 drop_new_inode(inode);
1076 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1079 if (retval) { /* reiserfs_new_inode iputs for us */
1083 reiserfs_update_inode_transaction(inode);
1084 reiserfs_update_inode_transaction(parent_dir);
1086 inode->i_op = &reiserfs_symlink_inode_operations;
1087 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1089 // must be sure this inode is written with this transaction
1091 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1093 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1094 dentry->d_name.len, inode, 1 /*visible */ );
1098 reiserfs_update_sd(&th, inode);
1099 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1102 unlock_new_inode(inode);
1107 d_instantiate(dentry, inode);
1108 unlock_new_inode(inode);
1109 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1111 reiserfs_write_unlock(parent_dir->i_sb);
1115 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1116 struct dentry *dentry)
1119 struct inode *inode = old_dentry->d_inode;
1120 struct reiserfs_transaction_handle th;
1121 /* We need blocks for transaction + update of quotas for the owners of the directory */
1123 JOURNAL_PER_BALANCE_CNT * 3 +
1124 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1126 reiserfs_write_lock(dir->i_sb);
1127 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1128 //FIXME: sd_nlink is 32 bit for new files
1129 reiserfs_write_unlock(dir->i_sb);
1132 if (inode->i_nlink == 0) {
1133 reiserfs_write_unlock(dir->i_sb);
1137 /* inc before scheduling so reiserfs_unlink knows we are here */
1140 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1143 reiserfs_write_unlock(dir->i_sb);
1147 /* create new entry */
1149 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1150 dentry->d_name.len, inode, 1 /*visible */ );
1152 reiserfs_update_inode_transaction(inode);
1153 reiserfs_update_inode_transaction(dir);
1158 err = journal_end(&th, dir->i_sb, jbegin_count);
1159 reiserfs_write_unlock(dir->i_sb);
1160 return err ? err : retval;
1163 inode->i_ctime = CURRENT_TIME_SEC;
1164 reiserfs_update_sd(&th, inode);
1166 atomic_inc(&inode->i_count);
1167 d_instantiate(dentry, inode);
1168 retval = journal_end(&th, dir->i_sb, jbegin_count);
1169 reiserfs_write_unlock(dir->i_sb);
1173 // de contains information pointing to an entry which
1174 static int de_still_valid(const char *name, int len,
1175 struct reiserfs_dir_entry *de)
1177 struct reiserfs_dir_entry tmp = *de;
1179 // recalculate pointer to name and name length
1180 set_de_name_and_namelen(&tmp);
1181 // FIXME: could check more
1182 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1187 static int entry_points_to_object(const char *name, int len,
1188 struct reiserfs_dir_entry *de,
1189 struct inode *inode)
1191 if (!de_still_valid(name, len, de))
1195 if (!de_visible(de->de_deh + de->de_entry_num))
1196 reiserfs_panic(NULL,
1197 "vs-7042: entry_points_to_object: entry must be visible");
1198 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1201 /* this must be added hidden entry */
1202 if (de_visible(de->de_deh + de->de_entry_num))
1203 reiserfs_panic(NULL,
1204 "vs-7043: entry_points_to_object: entry must be visible");
1209 /* sets key of objectid the entry has to point to */
1210 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1211 struct reiserfs_key *key)
1213 /* JDM These operations are endian safe - both are le */
1214 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1215 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1219 * process, that is going to call fix_nodes/do_balance must hold only
1220 * one path. If it holds 2 or more, it can get into endless waiting in
1221 * get_empty_nodes or its clones
1223 static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1224 struct inode *new_dir, struct dentry *new_dentry)
1227 INITIALIZE_PATH(old_entry_path);
1228 INITIALIZE_PATH(new_entry_path);
1229 INITIALIZE_PATH(dot_dot_entry_path);
1230 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1231 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1232 struct inode *old_inode, *new_dentry_inode;
1233 struct reiserfs_transaction_handle th;
1235 umode_t old_inode_mode;
1236 unsigned long savelink = 1;
1237 struct timespec ctime;
1239 /* three balancings: (1) old name removal, (2) new name insertion
1240 and (3) maybe "save" link insertion
1241 stat data updates: (1) old directory,
1242 (2) new directory and (3) maybe old object stat data (when it is
1243 directory) and (4) maybe stat data of object to which new entry
1244 pointed initially and (5) maybe block containing ".." of
1246 quota updates: two parent directories */
1248 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1249 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1251 old_inode = old_dentry->d_inode;
1252 new_dentry_inode = new_dentry->d_inode;
1254 // make sure, that oldname still exists and points to an object we
1255 // are going to rename
1256 old_de.de_gen_number_bit_string = NULL;
1257 reiserfs_write_lock(old_dir->i_sb);
1259 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1260 old_dentry->d_name.len, &old_entry_path,
1262 pathrelse(&old_entry_path);
1263 if (retval == IO_ERROR) {
1264 reiserfs_write_unlock(old_dir->i_sb);
1268 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1269 reiserfs_write_unlock(old_dir->i_sb);
1273 old_inode_mode = old_inode->i_mode;
1274 if (S_ISDIR(old_inode_mode)) {
1275 // make sure, that directory being renamed has correct ".."
1276 // and that its new parent directory has not too many links
1279 if (new_dentry_inode) {
1280 if (!reiserfs_empty_dir(new_dentry_inode)) {
1281 reiserfs_write_unlock(old_dir->i_sb);
1286 /* directory is renamed, its parent directory will be changed,
1287 ** so find ".." entry
1289 dot_dot_de.de_gen_number_bit_string = NULL;
1291 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1293 pathrelse(&dot_dot_entry_path);
1294 if (retval != NAME_FOUND) {
1295 reiserfs_write_unlock(old_dir->i_sb);
1299 /* inode number of .. must equal old_dir->i_ino */
1300 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1301 reiserfs_write_unlock(old_dir->i_sb);
1306 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1308 reiserfs_write_unlock(old_dir->i_sb);
1312 /* add new entry (or find the existing one) */
1314 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1315 new_dentry->d_name.len, old_inode, 0);
1316 if (retval == -EEXIST) {
1317 if (!new_dentry_inode) {
1318 reiserfs_panic(old_dir->i_sb,
1319 "vs-7050: new entry is found, new inode == 0\n");
1321 } else if (retval) {
1322 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1323 reiserfs_write_unlock(old_dir->i_sb);
1324 return err ? err : retval;
1327 reiserfs_update_inode_transaction(old_dir);
1328 reiserfs_update_inode_transaction(new_dir);
1330 /* this makes it so an fsync on an open fd for the old name will
1331 ** commit the rename operation
1333 reiserfs_update_inode_transaction(old_inode);
1335 if (new_dentry_inode)
1336 reiserfs_update_inode_transaction(new_dentry_inode);
1339 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1341 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1343 &old_de)) != NAME_FOUND) {
1344 pathrelse(&old_entry_path);
1345 journal_end(&th, old_dir->i_sb, jbegin_count);
1346 reiserfs_write_unlock(old_dir->i_sb);
1350 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
1352 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1354 // look for new name by reiserfs_find_entry
1355 new_de.de_gen_number_bit_string = NULL;
1357 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1358 new_dentry->d_name.len, &new_entry_path,
1360 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1361 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1362 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1363 pathrelse(&new_entry_path);
1364 pathrelse(&old_entry_path);
1365 journal_end(&th, old_dir->i_sb, jbegin_count);
1366 reiserfs_write_unlock(old_dir->i_sb);
1370 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1372 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1374 if (S_ISDIR(old_inode->i_mode)) {
1376 search_by_entry_key(new_dir->i_sb,
1377 &dot_dot_de.de_entry_key,
1378 &dot_dot_entry_path,
1379 &dot_dot_de)) != NAME_FOUND) {
1380 pathrelse(&dot_dot_entry_path);
1381 pathrelse(&new_entry_path);
1382 pathrelse(&old_entry_path);
1383 journal_end(&th, old_dir->i_sb, jbegin_count);
1384 reiserfs_write_unlock(old_dir->i_sb);
1387 copy_item_head(&dot_dot_ih,
1388 get_ih(&dot_dot_entry_path));
1389 // node containing ".." gets into transaction
1390 reiserfs_prepare_for_journal(old_inode->i_sb,
1391 dot_dot_de.de_bh, 1);
1393 /* we should check seals here, not do
1394 this stuff, yes? Then, having
1395 gathered everything into RAM we
1396 should lock the buffers, yes? -Hans */
1397 /* probably. our rename needs to hold more
1398 ** than one path at once. The seals would
1399 ** have to be written to deal with multi-path
1402 /* sanity checking before doing the rename - avoid races many
1403 ** of the above checks could have scheduled. We have to be
1404 ** sure our items haven't been shifted by another process.
1406 if (item_moved(&new_entry_ih, &new_entry_path) ||
1407 !entry_points_to_object(new_dentry->d_name.name,
1408 new_dentry->d_name.len,
1409 &new_de, new_dentry_inode) ||
1410 item_moved(&old_entry_ih, &old_entry_path) ||
1411 !entry_points_to_object(old_dentry->d_name.name,
1412 old_dentry->d_name.len,
1413 &old_de, old_inode)) {
1414 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1416 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1418 if (S_ISDIR(old_inode_mode))
1419 reiserfs_restore_prepared_buffer(old_inode->
1425 if (S_ISDIR(old_inode_mode)) {
1426 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1427 !entry_points_to_object("..", 2, &dot_dot_de,
1429 reiserfs_restore_prepared_buffer(old_inode->
1432 reiserfs_restore_prepared_buffer(old_inode->
1435 reiserfs_restore_prepared_buffer(old_inode->
1443 RFALSE(S_ISDIR(old_inode_mode) &&
1444 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1449 /* ok, all the changes can be done in one fell swoop when we
1450 have claimed all the buffers needed. */
1452 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1453 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1454 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1456 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1457 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1458 ctime = CURRENT_TIME_SEC;
1459 old_dir->i_ctime = old_dir->i_mtime = ctime;
1460 new_dir->i_ctime = new_dir->i_mtime = ctime;
1461 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1463 old_inode->i_ctime = ctime;
1465 if (new_dentry_inode) {
1466 // adjust link number of the victim
1467 if (S_ISDIR(new_dentry_inode->i_mode)) {
1468 clear_nlink(new_dentry_inode);
1470 drop_nlink(new_dentry_inode);
1472 new_dentry_inode->i_ctime = ctime;
1473 savelink = new_dentry_inode->i_nlink;
1476 if (S_ISDIR(old_inode_mode)) {
1477 // adjust ".." of renamed directory
1478 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1479 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1481 if (!new_dentry_inode)
1482 /* there (in new_dir) was no directory, so it got new link
1483 (".." of renamed directory) */
1484 INC_DIR_INODE_NLINK(new_dir);
1486 /* old directory lost one link - ".. " of renamed directory */
1487 DEC_DIR_INODE_NLINK(old_dir);
1489 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1490 pathrelse(&new_entry_path);
1491 pathrelse(&dot_dot_entry_path);
1493 // FIXME: this reiserfs_cut_from_item's return value may screw up
1494 // anybody, but it will panic if will not be able to find the
1495 // entry. This needs one more clean up
1496 if (reiserfs_cut_from_item
1497 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1499 reiserfs_warning(old_dir->i_sb, "vs-7060",
1500 "couldn't not cut old name. Fsck later?");
1502 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1504 reiserfs_update_sd(&th, old_dir);
1505 reiserfs_update_sd(&th, new_dir);
1506 reiserfs_update_sd(&th, old_inode);
1508 if (new_dentry_inode) {
1510 add_save_link(&th, new_dentry_inode,
1511 0 /* not truncate */ );
1512 reiserfs_update_sd(&th, new_dentry_inode);
1515 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1516 reiserfs_write_unlock(old_dir->i_sb);
1521 * directories can handle most operations...
1523 const struct inode_operations reiserfs_dir_inode_operations = {
1524 //&reiserfs_dir_operations, /* default_file_ops */
1525 .create = reiserfs_create,
1526 .lookup = reiserfs_lookup,
1527 .link = reiserfs_link,
1528 .unlink = reiserfs_unlink,
1529 .symlink = reiserfs_symlink,
1530 .mkdir = reiserfs_mkdir,
1531 .rmdir = reiserfs_rmdir,
1532 .mknod = reiserfs_mknod,
1533 .rename = reiserfs_rename,
1534 .setattr = reiserfs_setattr,
1535 .setxattr = reiserfs_setxattr,
1536 .getxattr = reiserfs_getxattr,
1537 .listxattr = reiserfs_listxattr,
1538 .removexattr = reiserfs_removexattr,
1539 .permission = reiserfs_permission,
1543 * symlink operations.. same as page_symlink_inode_operations, with xattr
1546 const struct inode_operations reiserfs_symlink_inode_operations = {
1547 .readlink = generic_readlink,
1548 .follow_link = page_follow_link_light,
1549 .put_link = page_put_link,
1550 .setattr = reiserfs_setattr,
1551 .setxattr = reiserfs_setxattr,
1552 .getxattr = reiserfs_getxattr,
1553 .listxattr = reiserfs_listxattr,
1554 .removexattr = reiserfs_removexattr,
1555 .permission = reiserfs_permission,
1560 * special file operations.. just xattr/acl stuff
1562 const struct inode_operations reiserfs_special_inode_operations = {
1563 .setattr = reiserfs_setattr,
1564 .setxattr = reiserfs_setxattr,
1565 .getxattr = reiserfs_getxattr,
1566 .listxattr = reiserfs_listxattr,
1567 .removexattr = reiserfs_removexattr,
1568 .permission = reiserfs_permission,