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_error(sb, "vs-7000", "search_by_key "
124 "returned item position == 0");
128 PATH_LAST_POSITION(path)--;
138 reiserfs_error(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);
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);
152 #endif /* CONFIG_REISERFS_CHECK */
154 /* binary search in directory item by third componen t of the
155 key. sets de->de_entry_num of de */
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 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
160 set_de_name_and_namelen(de);
161 set_de_object_key(de);
166 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
168 /* The third component is hashed, and you can choose from more than
169 one hash function. Per directory hashes are not yet implemented
170 but are thought about. This function should be moved to hashes.c
171 Jedi, please do so. -Hans */
173 static __u32 get_third_component(struct super_block *s,
174 const char *name, int len)
178 if (!len || (len == 1 && name[0] == '.'))
180 if (len == 2 && name[0] == '.' && name[1] == '.')
181 return DOT_DOT_OFFSET;
183 res = REISERFS_SB(s)->s_hash_function(name, len);
185 // take bits from 7-th to 30-th including both bounds
186 res = GET_HASH_VALUE(res);
188 // needed to have no names before "." and ".." those have hash
189 // value == 0 and generation conters 1 and 2 accordingly
191 return res + MAX_GENERATION_NUMBER;
194 static int reiserfs_match(struct reiserfs_dir_entry *de,
195 const char *name, int namelen)
197 int retval = NAME_NOT_FOUND;
199 if ((namelen == de->de_namelen) &&
200 !memcmp(de->de_name, name, de->de_namelen))
202 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
203 NAME_FOUND_INVISIBLE);
208 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
210 /* used when hash collisions exist */
212 static int linear_search_in_dir_item(struct cpu_key *key,
213 struct reiserfs_dir_entry *de,
214 const char *name, int namelen)
216 struct reiserfs_de_head *deh = de->de_deh;
220 i = de->de_entry_num;
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))) {
228 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
229 "vs-7010: array of entry headers not found");
233 for (; i >= 0; i--, deh--) {
234 if (GET_HASH_VALUE(deh_offset(deh)) !=
235 GET_HASH_VALUE(cpu_key_k_offset(key))) {
236 // hash value does not match, no need to check whole name
237 return NAME_NOT_FOUND;
240 /* mark, that this generation number is used */
241 if (de->de_gen_number_bit_string)
242 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
243 de->de_gen_number_bit_string);
245 // calculate pointer to name and namelen
246 de->de_entry_num = i;
247 set_de_name_and_namelen(de);
250 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
251 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
253 // key of pointed object
254 set_de_object_key(de);
256 store_de_entry_key(de);
258 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
263 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
264 /* we have reached left most entry in the node. In common we
265 have to go to the left neighbor, but if generation counter
266 is 0 already, we know for sure, that there is no name with
267 the same hash value */
268 // FIXME: this work correctly only because hash value can not
269 // be 0. Btw, in case of Yura's hash it is probably possible,
271 return NAME_NOT_FOUND;
273 RFALSE(de->de_item_num,
274 "vs-7015: two diritems of the same directory in one node?");
276 return GOTO_PREVIOUS_ITEM;
279 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
280 // FIXME: should add something like IOERROR
281 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
282 struct treepath *path_to_entry,
283 struct reiserfs_dir_entry *de)
285 struct cpu_key key_to_search;
288 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
289 return NAME_NOT_FOUND;
291 /* we will search for this key in the tree */
292 make_cpu_key(&key_to_search, dir,
293 get_third_component(dir->i_sb, name, namelen),
298 search_by_entry_key(dir->i_sb, &key_to_search,
300 if (retval == IO_ERROR) {
301 reiserfs_error(dir->i_sb, "zam-7001", "io error");
305 /* compare names for all entries having given hash value */
307 linear_search_in_dir_item(&key_to_search, de, name,
309 if (retval != GOTO_PREVIOUS_ITEM) {
310 /* there is no need to scan directory anymore. Given entry found or does not exist */
311 path_to_entry->pos_in_item = de->de_entry_num;
315 /* there is left neighboring item of this directory and given entry can be there */
316 set_cpu_key_k_offset(&key_to_search,
317 le_ih_k_offset(de->de_ih) - 1);
318 pathrelse(path_to_entry);
323 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
324 struct nameidata *nd)
327 struct inode *inode = NULL;
328 struct reiserfs_dir_entry de;
329 INITIALIZE_PATH(path_to_entry);
331 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
332 return ERR_PTR(-ENAMETOOLONG);
334 reiserfs_write_lock(dir->i_sb);
335 de.de_gen_number_bit_string = NULL;
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 /* Hide the .reiserfs_priv directory */
342 if (reiserfs_xattrs(dir->i_sb) &&
343 !old_format_only(dir->i_sb) &&
344 REISERFS_SB(dir->i_sb)->priv_root &&
345 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
347 le32_to_cpu(INODE_PKEY
348 (REISERFS_SB(dir->i_sb)->priv_root->d_inode)->
350 reiserfs_write_unlock(dir->i_sb);
351 return ERR_PTR(-EACCES);
355 reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
356 if (!inode || IS_ERR(inode)) {
357 reiserfs_write_unlock(dir->i_sb);
358 return ERR_PTR(-EACCES);
361 /* Propogate the priv_object flag so we know we're in the priv tree */
362 if (is_reiserfs_priv_object(dir))
363 reiserfs_mark_inode_private(inode);
365 reiserfs_write_unlock(dir->i_sb);
366 if (retval == IO_ERROR) {
367 return ERR_PTR(-EIO);
370 return d_splice_alias(inode, dentry);
374 ** looks up the dentry of the parent directory for child.
375 ** taken from ext2_get_parent
377 struct dentry *reiserfs_get_parent(struct dentry *child)
380 struct inode *inode = NULL;
381 struct reiserfs_dir_entry de;
382 INITIALIZE_PATH(path_to_entry);
383 struct inode *dir = child->d_inode;
385 if (dir->i_nlink == 0) {
386 return ERR_PTR(-ENOENT);
388 de.de_gen_number_bit_string = NULL;
390 reiserfs_write_lock(dir->i_sb);
391 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
392 pathrelse(&path_to_entry);
393 if (retval != NAME_FOUND) {
394 reiserfs_write_unlock(dir->i_sb);
395 return ERR_PTR(-ENOENT);
397 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
398 reiserfs_write_unlock(dir->i_sb);
400 return d_obtain_alias(inode);
403 /* add entry to the directory (entry can be hidden).
405 insert definition of when hidden directories are used here -Hans
407 Does not mark dir inode dirty, do it after successesfull call to it */
409 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
410 struct inode *dir, const char *name, int namelen,
411 struct inode *inode, int visible)
413 struct cpu_key entry_key;
414 struct reiserfs_de_head *deh;
415 INITIALIZE_PATH(path);
416 struct reiserfs_dir_entry de;
417 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
419 char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
420 if we create file with short name */
422 int buflen, paste_size;
425 BUG_ON(!th->t_trans_id);
427 /* cannot allow items to be added into a busy deleted directory */
431 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
432 return -ENAMETOOLONG;
434 /* each entry has unique key. compose it */
435 make_cpu_key(&entry_key, dir,
436 get_third_component(dir->i_sb, name, namelen),
439 /* get memory for composing the entry */
440 buflen = DEH_SIZE + ROUND_UP(namelen);
441 if (buflen > sizeof(small_buf)) {
442 buffer = kmalloc(buflen, GFP_NOFS);
449 (get_inode_sd_version(dir) ==
450 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
452 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
453 deh = (struct reiserfs_de_head *)buffer;
454 deh->deh_location = 0; /* JDM Endian safe if 0 */
455 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
456 deh->deh_state = 0; /* JDM Endian safe if 0 */
457 /* put key (ino analog) to de */
458 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
459 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
462 memcpy((char *)(deh + 1), name, namelen);
463 /* padd by 0s to the 4 byte boundary */
464 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
466 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
467 mark_de_without_sd(deh);
468 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
470 /* find the proper place for the new entry */
471 memset(bit_string, 0, sizeof(bit_string));
472 de.de_gen_number_bit_string = bit_string;
473 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
474 if (retval != NAME_NOT_FOUND) {
475 if (buffer != small_buf)
479 if (retval == IO_ERROR) {
483 if (retval != NAME_FOUND) {
484 reiserfs_error(dir->i_sb, "zam-7002",
485 "reiserfs_find_entry() returned "
486 "unexpected value (%d)", retval);
493 find_first_zero_bit(bit_string,
494 MAX_GENERATION_NUMBER + 1);
495 if (gen_number > MAX_GENERATION_NUMBER) {
496 /* there is no free generation number */
497 reiserfs_warning(dir->i_sb, "reiserfs-7010",
498 "Congratulations! we have got hash function "
500 if (buffer != small_buf)
505 /* adjust offset of directory enrty */
506 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
507 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
509 /* update max-hash-collisions counter in reiserfs_sb_info */
510 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
512 if (gen_number != 0) { /* we need to re-search for the insertion point */
513 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
515 reiserfs_warning(dir->i_sb, "vs-7032",
516 "entry with this key (%K) already "
517 "exists", &entry_key);
519 if (buffer != small_buf)
526 /* perform the insertion of the entry that we have prepared */
528 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
530 if (buffer != small_buf)
533 reiserfs_check_path(&path);
537 dir->i_size += paste_size;
538 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
539 if (!S_ISDIR(inode->i_mode) && visible)
540 // reiserfs_mkdir or reiserfs_rename will do that by itself
541 reiserfs_update_sd(th, dir);
543 reiserfs_check_path(&path);
547 /* quota utility function, call if you've had to abort after calling
548 ** new_inode_init, and have not called reiserfs_new_inode yet.
549 ** This should only be called on inodes that do not have stat data
550 ** inserted into the tree yet.
552 static int drop_new_inode(struct inode *inode)
555 make_bad_inode(inode);
556 inode->i_flags |= S_NOQUOTA;
561 /* utility function that does setup for reiserfs_new_inode.
562 ** DQUOT_INIT needs lots of credits so it's better to have it
563 ** outside of a transaction, so we had to pull some bits of
564 ** reiserfs_new_inode out into this func.
566 static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
569 /* the quota init calls have to know who to charge the quota to, so
570 ** we have to set uid and gid here
572 inode->i_uid = current_fsuid();
573 inode->i_mode = mode;
574 /* Make inode invalid - just in case we are going to drop it before
575 * the initialization happens */
576 INODE_PKEY(inode)->k_objectid = 0;
578 if (dir->i_mode & S_ISGID) {
579 inode->i_gid = dir->i_gid;
581 inode->i_mode |= S_ISGID;
583 inode->i_gid = current_fsgid();
589 static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
590 struct nameidata *nd)
594 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
596 JOURNAL_PER_BALANCE_CNT * 2 +
597 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
598 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
599 struct reiserfs_transaction_handle th;
602 if (!(inode = new_inode(dir->i_sb))) {
605 new_inode_init(inode, dir, mode);
607 locked = reiserfs_cache_default_acl(dir);
609 reiserfs_write_lock(dir->i_sb);
612 reiserfs_write_lock_xattrs(dir->i_sb);
614 retval = journal_begin(&th, dir->i_sb, jbegin_count);
616 drop_new_inode(inode);
621 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
627 reiserfs_write_unlock_xattrs(dir->i_sb);
631 inode->i_op = &reiserfs_file_inode_operations;
632 inode->i_fop = &reiserfs_file_operations;
633 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
636 reiserfs_add_entry(&th, dir, dentry->d_name.name,
637 dentry->d_name.len, inode, 1 /*visible */ );
641 reiserfs_update_sd(&th, inode);
642 err = journal_end(&th, dir->i_sb, jbegin_count);
645 unlock_new_inode(inode);
649 reiserfs_update_inode_transaction(inode);
650 reiserfs_update_inode_transaction(dir);
652 d_instantiate(dentry, inode);
653 unlock_new_inode(inode);
654 retval = journal_end(&th, dir->i_sb, jbegin_count);
658 reiserfs_write_unlock_xattrs(dir->i_sb);
659 reiserfs_write_unlock(dir->i_sb);
663 static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
668 struct reiserfs_transaction_handle th;
669 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
671 JOURNAL_PER_BALANCE_CNT * 3 +
672 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
673 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
676 if (!new_valid_dev(rdev))
679 if (!(inode = new_inode(dir->i_sb))) {
682 new_inode_init(inode, dir, mode);
684 locked = reiserfs_cache_default_acl(dir);
686 reiserfs_write_lock(dir->i_sb);
689 reiserfs_write_lock_xattrs(dir->i_sb);
691 retval = journal_begin(&th, dir->i_sb, jbegin_count);
693 drop_new_inode(inode);
698 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
705 reiserfs_write_unlock_xattrs(dir->i_sb);
709 inode->i_op = &reiserfs_special_inode_operations;
710 init_special_inode(inode, inode->i_mode, rdev);
712 //FIXME: needed for block and char devices only
713 reiserfs_update_sd(&th, inode);
715 reiserfs_update_inode_transaction(inode);
716 reiserfs_update_inode_transaction(dir);
719 reiserfs_add_entry(&th, dir, dentry->d_name.name,
720 dentry->d_name.len, inode, 1 /*visible */ );
724 reiserfs_update_sd(&th, inode);
725 err = journal_end(&th, dir->i_sb, jbegin_count);
728 unlock_new_inode(inode);
733 d_instantiate(dentry, inode);
734 unlock_new_inode(inode);
735 retval = journal_end(&th, dir->i_sb, jbegin_count);
739 reiserfs_write_unlock_xattrs(dir->i_sb);
740 reiserfs_write_unlock(dir->i_sb);
744 static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
748 struct reiserfs_transaction_handle th;
749 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
751 JOURNAL_PER_BALANCE_CNT * 3 +
752 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
753 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
756 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
757 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
758 REISERFS_I(dir)->new_packing_locality = 1;
760 mode = S_IFDIR | mode;
761 if (!(inode = new_inode(dir->i_sb))) {
764 new_inode_init(inode, dir, mode);
766 locked = reiserfs_cache_default_acl(dir);
768 reiserfs_write_lock(dir->i_sb);
770 reiserfs_write_lock_xattrs(dir->i_sb);
772 retval = journal_begin(&th, dir->i_sb, jbegin_count);
774 drop_new_inode(inode);
778 /* inc the link count now, so another writer doesn't overflow it while
779 ** we sleep later on.
781 INC_DIR_INODE_NLINK(dir)
783 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
784 old_format_only(dir->i_sb) ?
785 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
793 reiserfs_write_unlock_xattrs(dir->i_sb);
797 reiserfs_update_inode_transaction(inode);
798 reiserfs_update_inode_transaction(dir);
800 inode->i_op = &reiserfs_dir_inode_operations;
801 inode->i_fop = &reiserfs_dir_operations;
803 // note, _this_ add_entry will not update dir's stat data
805 reiserfs_add_entry(&th, dir, dentry->d_name.name,
806 dentry->d_name.len, inode, 1 /*visible */ );
810 DEC_DIR_INODE_NLINK(dir);
811 reiserfs_update_sd(&th, inode);
812 err = journal_end(&th, dir->i_sb, jbegin_count);
815 unlock_new_inode(inode);
819 // the above add_entry did not update dir's stat data
820 reiserfs_update_sd(&th, dir);
822 d_instantiate(dentry, inode);
823 unlock_new_inode(inode);
824 retval = journal_end(&th, dir->i_sb, jbegin_count);
827 reiserfs_write_unlock_xattrs(dir->i_sb);
828 reiserfs_write_unlock(dir->i_sb);
832 static inline int reiserfs_empty_dir(struct inode *inode)
834 /* we can cheat because an old format dir cannot have
835 ** EMPTY_DIR_SIZE, and a new format dir cannot have
836 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
837 ** regardless of disk format version, the directory is empty.
839 if (inode->i_size != EMPTY_DIR_SIZE &&
840 inode->i_size != EMPTY_DIR_SIZE_V1) {
846 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
850 struct reiserfs_transaction_handle th;
852 INITIALIZE_PATH(path);
853 struct reiserfs_dir_entry de;
855 /* we will be doing 2 balancings and update 2 stat data, we change quotas
856 * of the owner of the directory and of the owner of the parent directory.
857 * The quota structure is possibly deleted only on last iput => outside
858 * of this transaction */
860 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
861 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
863 reiserfs_write_lock(dir->i_sb);
864 retval = journal_begin(&th, dir->i_sb, jbegin_count);
868 de.de_gen_number_bit_string = NULL;
870 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
871 &path, &de)) == NAME_NOT_FOUND) {
874 } else if (retval == IO_ERROR) {
879 inode = dentry->d_inode;
881 reiserfs_update_inode_transaction(inode);
882 reiserfs_update_inode_transaction(dir);
884 if (de.de_objectid != inode->i_ino) {
885 // FIXME: compare key of an object and a key found in the
890 if (!reiserfs_empty_dir(inode)) {
895 /* cut entry from dir directory */
896 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL, /* page */
897 0 /*new file size - not used here */ );
901 if (inode->i_nlink != 2 && inode->i_nlink != 1)
902 reiserfs_error(inode->i_sb, "reiserfs-7040",
903 "empty directory has nlink != 2 (%d)",
907 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
908 reiserfs_update_sd(&th, inode);
910 DEC_DIR_INODE_NLINK(dir)
911 dir->i_size -= (DEH_SIZE + de.de_entrylen);
912 reiserfs_update_sd(&th, dir);
914 /* prevent empty directory from getting lost */
915 add_save_link(&th, inode, 0 /* not truncate */ );
917 retval = journal_end(&th, dir->i_sb, jbegin_count);
918 reiserfs_check_path(&path);
920 reiserfs_write_unlock(dir->i_sb);
924 /* we must release path, because we did not call
925 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
926 release path if operation was not complete */
928 err = journal_end(&th, dir->i_sb, jbegin_count);
929 reiserfs_write_unlock(dir->i_sb);
930 return err ? err : retval;
933 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
937 struct reiserfs_dir_entry de;
938 INITIALIZE_PATH(path);
939 struct reiserfs_transaction_handle th;
941 unsigned long savelink;
943 inode = dentry->d_inode;
945 /* in this transaction we can be doing at max two balancings and update
946 * two stat datas, we change quotas of the owner of the directory and of
947 * the owner of the parent directory. The quota structure is possibly
948 * deleted only on iput => outside of this transaction */
950 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
951 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
953 reiserfs_write_lock(dir->i_sb);
954 retval = journal_begin(&th, dir->i_sb, jbegin_count);
958 de.de_gen_number_bit_string = NULL;
960 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
961 &path, &de)) == NAME_NOT_FOUND) {
964 } else if (retval == IO_ERROR) {
969 reiserfs_update_inode_transaction(inode);
970 reiserfs_update_inode_transaction(dir);
972 if (de.de_objectid != inode->i_ino) {
973 // FIXME: compare key of an object and a key found in the
979 if (!inode->i_nlink) {
980 reiserfs_warning(inode->i_sb, "reiserfs-7042",
981 "deleting nonexistent file (%lu), %d",
982 inode->i_ino, inode->i_nlink);
989 * we schedule before doing the add_save_link call, save the link
990 * count so we don't race
992 savelink = inode->i_nlink;
995 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
1001 inode->i_ctime = CURRENT_TIME_SEC;
1002 reiserfs_update_sd(&th, inode);
1004 dir->i_size -= (de.de_entrylen + DEH_SIZE);
1005 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
1006 reiserfs_update_sd(&th, dir);
1009 /* prevent file from getting lost */
1010 add_save_link(&th, inode, 0 /* not truncate */ );
1012 retval = journal_end(&th, dir->i_sb, jbegin_count);
1013 reiserfs_check_path(&path);
1014 reiserfs_write_unlock(dir->i_sb);
1019 err = journal_end(&th, dir->i_sb, jbegin_count);
1020 reiserfs_check_path(&path);
1024 reiserfs_write_unlock(dir->i_sb);
1028 static int reiserfs_symlink(struct inode *parent_dir,
1029 struct dentry *dentry, const char *symname)
1032 struct inode *inode;
1035 struct reiserfs_transaction_handle th;
1036 int mode = S_IFLNK | S_IRWXUGO;
1037 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1039 JOURNAL_PER_BALANCE_CNT * 3 +
1040 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1041 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1043 if (!(inode = new_inode(parent_dir->i_sb))) {
1046 new_inode_init(inode, parent_dir, mode);
1048 reiserfs_write_lock(parent_dir->i_sb);
1049 item_len = ROUND_UP(strlen(symname));
1050 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1051 retval = -ENAMETOOLONG;
1052 drop_new_inode(inode);
1056 name = kmalloc(item_len, GFP_NOFS);
1058 drop_new_inode(inode);
1062 memcpy(name, symname, strlen(symname));
1063 padd_item(name, item_len, strlen(symname));
1065 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1067 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1069 drop_new_inode(inode);
1075 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1078 if (retval) { /* reiserfs_new_inode iputs for us */
1082 reiserfs_update_inode_transaction(inode);
1083 reiserfs_update_inode_transaction(parent_dir);
1085 inode->i_op = &reiserfs_symlink_inode_operations;
1086 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1088 // must be sure this inode is written with this transaction
1090 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1092 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1093 dentry->d_name.len, inode, 1 /*visible */ );
1097 reiserfs_update_sd(&th, inode);
1098 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1101 unlock_new_inode(inode);
1106 d_instantiate(dentry, inode);
1107 unlock_new_inode(inode);
1108 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1110 reiserfs_write_unlock(parent_dir->i_sb);
1114 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1115 struct dentry *dentry)
1118 struct inode *inode = old_dentry->d_inode;
1119 struct reiserfs_transaction_handle th;
1120 /* We need blocks for transaction + update of quotas for the owners of the directory */
1122 JOURNAL_PER_BALANCE_CNT * 3 +
1123 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1125 reiserfs_write_lock(dir->i_sb);
1126 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1127 //FIXME: sd_nlink is 32 bit for new files
1128 reiserfs_write_unlock(dir->i_sb);
1131 if (inode->i_nlink == 0) {
1132 reiserfs_write_unlock(dir->i_sb);
1136 /* inc before scheduling so reiserfs_unlink knows we are here */
1139 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1142 reiserfs_write_unlock(dir->i_sb);
1146 /* create new entry */
1148 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1149 dentry->d_name.len, inode, 1 /*visible */ );
1151 reiserfs_update_inode_transaction(inode);
1152 reiserfs_update_inode_transaction(dir);
1157 err = journal_end(&th, dir->i_sb, jbegin_count);
1158 reiserfs_write_unlock(dir->i_sb);
1159 return err ? err : retval;
1162 inode->i_ctime = CURRENT_TIME_SEC;
1163 reiserfs_update_sd(&th, inode);
1165 atomic_inc(&inode->i_count);
1166 d_instantiate(dentry, inode);
1167 retval = journal_end(&th, dir->i_sb, jbegin_count);
1168 reiserfs_write_unlock(dir->i_sb);
1172 // de contains information pointing to an entry which
1173 static int de_still_valid(const char *name, int len,
1174 struct reiserfs_dir_entry *de)
1176 struct reiserfs_dir_entry tmp = *de;
1178 // recalculate pointer to name and name length
1179 set_de_name_and_namelen(&tmp);
1180 // FIXME: could check more
1181 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1186 static int entry_points_to_object(const char *name, int len,
1187 struct reiserfs_dir_entry *de,
1188 struct inode *inode)
1190 if (!de_still_valid(name, len, de))
1194 if (!de_visible(de->de_deh + de->de_entry_num))
1195 reiserfs_panic(inode->i_sb, "vs-7042",
1196 "entry must be visible");
1197 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1200 /* this must be added hidden entry */
1201 if (de_visible(de->de_deh + de->de_entry_num))
1202 reiserfs_panic(NULL, "vs-7043", "entry must be visible");
1207 /* sets key of objectid the entry has to point to */
1208 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1209 struct reiserfs_key *key)
1211 /* JDM These operations are endian safe - both are le */
1212 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1213 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1217 * process, that is going to call fix_nodes/do_balance must hold only
1218 * one path. If it holds 2 or more, it can get into endless waiting in
1219 * get_empty_nodes or its clones
1221 static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1222 struct inode *new_dir, struct dentry *new_dentry)
1225 INITIALIZE_PATH(old_entry_path);
1226 INITIALIZE_PATH(new_entry_path);
1227 INITIALIZE_PATH(dot_dot_entry_path);
1228 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1229 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1230 struct inode *old_inode, *new_dentry_inode;
1231 struct reiserfs_transaction_handle th;
1233 umode_t old_inode_mode;
1234 unsigned long savelink = 1;
1235 struct timespec ctime;
1237 /* three balancings: (1) old name removal, (2) new name insertion
1238 and (3) maybe "save" link insertion
1239 stat data updates: (1) old directory,
1240 (2) new directory and (3) maybe old object stat data (when it is
1241 directory) and (4) maybe stat data of object to which new entry
1242 pointed initially and (5) maybe block containing ".." of
1244 quota updates: two parent directories */
1246 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1247 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1249 old_inode = old_dentry->d_inode;
1250 new_dentry_inode = new_dentry->d_inode;
1252 // make sure, that oldname still exists and points to an object we
1253 // are going to rename
1254 old_de.de_gen_number_bit_string = NULL;
1255 reiserfs_write_lock(old_dir->i_sb);
1257 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1258 old_dentry->d_name.len, &old_entry_path,
1260 pathrelse(&old_entry_path);
1261 if (retval == IO_ERROR) {
1262 reiserfs_write_unlock(old_dir->i_sb);
1266 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1267 reiserfs_write_unlock(old_dir->i_sb);
1271 old_inode_mode = old_inode->i_mode;
1272 if (S_ISDIR(old_inode_mode)) {
1273 // make sure, that directory being renamed has correct ".."
1274 // and that its new parent directory has not too many links
1277 if (new_dentry_inode) {
1278 if (!reiserfs_empty_dir(new_dentry_inode)) {
1279 reiserfs_write_unlock(old_dir->i_sb);
1284 /* directory is renamed, its parent directory will be changed,
1285 ** so find ".." entry
1287 dot_dot_de.de_gen_number_bit_string = NULL;
1289 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1291 pathrelse(&dot_dot_entry_path);
1292 if (retval != NAME_FOUND) {
1293 reiserfs_write_unlock(old_dir->i_sb);
1297 /* inode number of .. must equal old_dir->i_ino */
1298 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1299 reiserfs_write_unlock(old_dir->i_sb);
1304 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1306 reiserfs_write_unlock(old_dir->i_sb);
1310 /* add new entry (or find the existing one) */
1312 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1313 new_dentry->d_name.len, old_inode, 0);
1314 if (retval == -EEXIST) {
1315 if (!new_dentry_inode) {
1316 reiserfs_panic(old_dir->i_sb, "vs-7050",
1317 "new entry is found, new inode == 0");
1319 } else if (retval) {
1320 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1321 reiserfs_write_unlock(old_dir->i_sb);
1322 return err ? err : retval;
1325 reiserfs_update_inode_transaction(old_dir);
1326 reiserfs_update_inode_transaction(new_dir);
1328 /* this makes it so an fsync on an open fd for the old name will
1329 ** commit the rename operation
1331 reiserfs_update_inode_transaction(old_inode);
1333 if (new_dentry_inode)
1334 reiserfs_update_inode_transaction(new_dentry_inode);
1337 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1339 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1341 &old_de)) != NAME_FOUND) {
1342 pathrelse(&old_entry_path);
1343 journal_end(&th, old_dir->i_sb, jbegin_count);
1344 reiserfs_write_unlock(old_dir->i_sb);
1348 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
1350 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1352 // look for new name by reiserfs_find_entry
1353 new_de.de_gen_number_bit_string = NULL;
1355 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1356 new_dentry->d_name.len, &new_entry_path,
1358 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1359 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1360 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1361 pathrelse(&new_entry_path);
1362 pathrelse(&old_entry_path);
1363 journal_end(&th, old_dir->i_sb, jbegin_count);
1364 reiserfs_write_unlock(old_dir->i_sb);
1368 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1370 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1372 if (S_ISDIR(old_inode->i_mode)) {
1374 search_by_entry_key(new_dir->i_sb,
1375 &dot_dot_de.de_entry_key,
1376 &dot_dot_entry_path,
1377 &dot_dot_de)) != NAME_FOUND) {
1378 pathrelse(&dot_dot_entry_path);
1379 pathrelse(&new_entry_path);
1380 pathrelse(&old_entry_path);
1381 journal_end(&th, old_dir->i_sb, jbegin_count);
1382 reiserfs_write_unlock(old_dir->i_sb);
1385 copy_item_head(&dot_dot_ih,
1386 get_ih(&dot_dot_entry_path));
1387 // node containing ".." gets into transaction
1388 reiserfs_prepare_for_journal(old_inode->i_sb,
1389 dot_dot_de.de_bh, 1);
1391 /* we should check seals here, not do
1392 this stuff, yes? Then, having
1393 gathered everything into RAM we
1394 should lock the buffers, yes? -Hans */
1395 /* probably. our rename needs to hold more
1396 ** than one path at once. The seals would
1397 ** have to be written to deal with multi-path
1400 /* sanity checking before doing the rename - avoid races many
1401 ** of the above checks could have scheduled. We have to be
1402 ** sure our items haven't been shifted by another process.
1404 if (item_moved(&new_entry_ih, &new_entry_path) ||
1405 !entry_points_to_object(new_dentry->d_name.name,
1406 new_dentry->d_name.len,
1407 &new_de, new_dentry_inode) ||
1408 item_moved(&old_entry_ih, &old_entry_path) ||
1409 !entry_points_to_object(old_dentry->d_name.name,
1410 old_dentry->d_name.len,
1411 &old_de, old_inode)) {
1412 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1414 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1416 if (S_ISDIR(old_inode_mode))
1417 reiserfs_restore_prepared_buffer(old_inode->
1423 if (S_ISDIR(old_inode_mode)) {
1424 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1425 !entry_points_to_object("..", 2, &dot_dot_de,
1427 reiserfs_restore_prepared_buffer(old_inode->
1430 reiserfs_restore_prepared_buffer(old_inode->
1433 reiserfs_restore_prepared_buffer(old_inode->
1441 RFALSE(S_ISDIR(old_inode_mode) &&
1442 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1447 /* ok, all the changes can be done in one fell swoop when we
1448 have claimed all the buffers needed. */
1450 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1451 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1452 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1454 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1455 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1456 ctime = CURRENT_TIME_SEC;
1457 old_dir->i_ctime = old_dir->i_mtime = ctime;
1458 new_dir->i_ctime = new_dir->i_mtime = ctime;
1459 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1461 old_inode->i_ctime = ctime;
1463 if (new_dentry_inode) {
1464 // adjust link number of the victim
1465 if (S_ISDIR(new_dentry_inode->i_mode)) {
1466 clear_nlink(new_dentry_inode);
1468 drop_nlink(new_dentry_inode);
1470 new_dentry_inode->i_ctime = ctime;
1471 savelink = new_dentry_inode->i_nlink;
1474 if (S_ISDIR(old_inode_mode)) {
1475 // adjust ".." of renamed directory
1476 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1477 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1479 if (!new_dentry_inode)
1480 /* there (in new_dir) was no directory, so it got new link
1481 (".." of renamed directory) */
1482 INC_DIR_INODE_NLINK(new_dir);
1484 /* old directory lost one link - ".. " of renamed directory */
1485 DEC_DIR_INODE_NLINK(old_dir);
1487 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1488 pathrelse(&new_entry_path);
1489 pathrelse(&dot_dot_entry_path);
1491 // FIXME: this reiserfs_cut_from_item's return value may screw up
1492 // anybody, but it will panic if will not be able to find the
1493 // entry. This needs one more clean up
1494 if (reiserfs_cut_from_item
1495 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1497 reiserfs_error(old_dir->i_sb, "vs-7060",
1498 "couldn't not cut old name. Fsck later?");
1500 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1502 reiserfs_update_sd(&th, old_dir);
1503 reiserfs_update_sd(&th, new_dir);
1504 reiserfs_update_sd(&th, old_inode);
1506 if (new_dentry_inode) {
1508 add_save_link(&th, new_dentry_inode,
1509 0 /* not truncate */ );
1510 reiserfs_update_sd(&th, new_dentry_inode);
1513 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1514 reiserfs_write_unlock(old_dir->i_sb);
1519 * directories can handle most operations...
1521 const struct inode_operations reiserfs_dir_inode_operations = {
1522 //&reiserfs_dir_operations, /* default_file_ops */
1523 .create = reiserfs_create,
1524 .lookup = reiserfs_lookup,
1525 .link = reiserfs_link,
1526 .unlink = reiserfs_unlink,
1527 .symlink = reiserfs_symlink,
1528 .mkdir = reiserfs_mkdir,
1529 .rmdir = reiserfs_rmdir,
1530 .mknod = reiserfs_mknod,
1531 .rename = reiserfs_rename,
1532 .setattr = reiserfs_setattr,
1533 .setxattr = reiserfs_setxattr,
1534 .getxattr = reiserfs_getxattr,
1535 .listxattr = reiserfs_listxattr,
1536 .removexattr = reiserfs_removexattr,
1537 .permission = reiserfs_permission,
1541 * symlink operations.. same as page_symlink_inode_operations, with xattr
1544 const struct inode_operations reiserfs_symlink_inode_operations = {
1545 .readlink = generic_readlink,
1546 .follow_link = page_follow_link_light,
1547 .put_link = page_put_link,
1548 .setattr = reiserfs_setattr,
1549 .setxattr = reiserfs_setxattr,
1550 .getxattr = reiserfs_getxattr,
1551 .listxattr = reiserfs_listxattr,
1552 .removexattr = reiserfs_removexattr,
1553 .permission = reiserfs_permission,
1558 * special file operations.. just xattr/acl stuff
1560 const struct inode_operations reiserfs_special_inode_operations = {
1561 .setattr = reiserfs_setattr,
1562 .setxattr = reiserfs_setxattr,
1563 .getxattr = reiserfs_getxattr,
1564 .listxattr = reiserfs_listxattr,
1565 .removexattr = reiserfs_removexattr,
1566 .permission = reiserfs_permission,