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/config.h>
15 #include <linux/time.h>
16 #include <linux/bitops.h>
17 #include <linux/reiserfs_fs.h>
18 #include <linux/reiserfs_acl.h>
19 #include <linux/reiserfs_xattr.h>
20 #include <linux/smp_lock.h>
21 #include <linux/quotaops.h>
22 #include <linux/vserver/xid.h>
24 #define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { i->i_nlink++; if (i->i_nlink >= REISERFS_LINK_MAX) i->i_nlink=1; }
25 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) i->i_nlink--;
27 // directory item contains array of entry headers. This performs
28 // binary search through that array
29 static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
31 struct item_head *ih = de->de_ih;
32 struct reiserfs_de_head *deh = de->de_deh;
33 int rbound, lbound, j;
36 rbound = I_ENTRY_COUNT(ih) - 1;
38 for (j = (rbound + lbound) / 2; lbound <= rbound;
39 j = (rbound + lbound) / 2) {
40 if (off < deh_offset(deh + j)) {
44 if (off > deh_offset(deh + j)) {
48 // this is not name found, but matched third key component
53 de->de_entry_num = lbound;
54 return NAME_NOT_FOUND;
57 // comment? maybe something like set de to point to what the path points to?
58 static inline void set_de_item_location(struct reiserfs_dir_entry *de,
61 de->de_bh = get_last_bh(path);
62 de->de_ih = get_ih(path);
63 de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
64 de->de_item_num = PATH_LAST_POSITION(path);
67 // de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
68 inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
70 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
72 if (de->de_entry_num >= ih_entry_count(de->de_ih))
75 de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
76 de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
77 de->de_name = B_I_PITEM(de->de_bh, de->de_ih) + deh_location(deh);
78 if (de->de_name[de->de_namelen - 1] == 0)
79 de->de_namelen = strlen(de->de_name);
82 // what entry points to
83 static inline void set_de_object_key(struct reiserfs_dir_entry *de)
85 if (de->de_entry_num >= ih_entry_count(de->de_ih))
87 de->de_dir_id = deh_dir_id(&(de->de_deh[de->de_entry_num]));
88 de->de_objectid = deh_objectid(&(de->de_deh[de->de_entry_num]));
91 static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
93 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
95 if (de->de_entry_num >= ih_entry_count(de->de_ih))
98 /* store key of the found entry */
99 de->de_entry_key.version = KEY_FORMAT_3_5;
100 de->de_entry_key.on_disk_key.k_dir_id =
101 le32_to_cpu(de->de_ih->ih_key.k_dir_id);
102 de->de_entry_key.on_disk_key.k_objectid =
103 le32_to_cpu(de->de_ih->ih_key.k_objectid);
104 set_cpu_key_k_offset(&(de->de_entry_key), deh_offset(deh));
105 set_cpu_key_k_type(&(de->de_entry_key), TYPE_DIRENTRY);
108 /* We assign a key to each directory item, and place multiple entries
109 in a single directory item. A directory item has a key equal to the
110 key of the first directory entry in it.
112 This function first calls search_by_key, then, if item whose first
113 entry matches is not found it looks for the entry inside directory
114 item found by search_by_key. Fills the path to the entry, and to the
115 entry position in the item
119 /* The function is NOT SCHEDULE-SAFE! */
120 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
121 struct path *path, struct reiserfs_dir_entry *de)
125 retval = search_item(sb, key, path);
128 if (!PATH_LAST_POSITION(path)) {
130 "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
134 PATH_LAST_POSITION(path)--;
145 "vs-7002: search_by_entry_key: no path to here");
149 set_de_item_location(de, path);
151 #ifdef CONFIG_REISERFS_CHECK
152 if (!is_direntry_le_ih(de->de_ih) ||
153 COMP_SHORT_KEYS(&(de->de_ih->ih_key), key)) {
154 print_block(de->de_bh, 0, -1, -1);
156 "vs-7005: search_by_entry_key: found item %h is not directory item or "
157 "does not belong to the same directory as key %K",
160 #endif /* CONFIG_REISERFS_CHECK */
162 /* binary search in directory item by third componen t of the
163 key. sets de->de_entry_num of de */
164 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
165 path->pos_in_item = de->de_entry_num;
166 if (retval != NAME_NOT_FOUND) {
167 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
168 set_de_name_and_namelen(de);
169 set_de_object_key(de);
174 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
176 /* The third component is hashed, and you can choose from more than
177 one hash function. Per directory hashes are not yet implemented
178 but are thought about. This function should be moved to hashes.c
179 Jedi, please do so. -Hans */
181 static __u32 get_third_component(struct super_block *s,
182 const char *name, int len)
186 if (!len || (len == 1 && name[0] == '.'))
188 if (len == 2 && name[0] == '.' && name[1] == '.')
189 return DOT_DOT_OFFSET;
191 res = REISERFS_SB(s)->s_hash_function(name, len);
193 // take bits from 7-th to 30-th including both bounds
194 res = GET_HASH_VALUE(res);
196 // needed to have no names before "." and ".." those have hash
197 // value == 0 and generation conters 1 and 2 accordingly
199 return res + MAX_GENERATION_NUMBER;
202 static int reiserfs_match(struct reiserfs_dir_entry *de,
203 const char *name, int namelen)
205 int retval = NAME_NOT_FOUND;
207 if ((namelen == de->de_namelen) &&
208 !memcmp(de->de_name, name, de->de_namelen))
210 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
211 NAME_FOUND_INVISIBLE);
216 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
218 /* used when hash collisions exist */
220 static int linear_search_in_dir_item(struct cpu_key *key,
221 struct reiserfs_dir_entry *de,
222 const char *name, int namelen)
224 struct reiserfs_de_head *deh = de->de_deh;
228 i = de->de_entry_num;
230 if (i == I_ENTRY_COUNT(de->de_ih) ||
231 GET_HASH_VALUE(deh_offset(deh + i)) !=
232 GET_HASH_VALUE(cpu_key_k_offset(key))) {
236 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
237 "vs-7010: array of entry headers not found");
241 for (; i >= 0; i--, deh--) {
242 if (GET_HASH_VALUE(deh_offset(deh)) !=
243 GET_HASH_VALUE(cpu_key_k_offset(key))) {
244 // hash value does not match, no need to check whole name
245 return NAME_NOT_FOUND;
248 /* mark, that this generation number is used */
249 if (de->de_gen_number_bit_string)
250 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
251 de->de_gen_number_bit_string);
253 // calculate pointer to name and namelen
254 de->de_entry_num = i;
255 set_de_name_and_namelen(de);
258 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
259 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
261 // key of pointed object
262 set_de_object_key(de);
264 store_de_entry_key(de);
266 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
271 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
272 /* we have reached left most entry in the node. In common we
273 have to go to the left neighbor, but if generation counter
274 is 0 already, we know for sure, that there is no name with
275 the same hash value */
276 // FIXME: this work correctly only because hash value can not
277 // be 0. Btw, in case of Yura's hash it is probably possible,
279 return NAME_NOT_FOUND;
281 RFALSE(de->de_item_num,
282 "vs-7015: two diritems of the same directory in one node?");
284 return GOTO_PREVIOUS_ITEM;
287 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
288 // FIXME: should add something like IOERROR
289 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
290 struct path *path_to_entry,
291 struct reiserfs_dir_entry *de)
293 struct cpu_key key_to_search;
296 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
297 return NAME_NOT_FOUND;
299 /* we will search for this key in the tree */
300 make_cpu_key(&key_to_search, dir,
301 get_third_component(dir->i_sb, name, namelen),
306 search_by_entry_key(dir->i_sb, &key_to_search,
308 if (retval == IO_ERROR) {
309 reiserfs_warning(dir->i_sb, "zam-7001: io error in %s",
314 /* compare names for all entries having given hash value */
316 linear_search_in_dir_item(&key_to_search, de, name,
318 if (retval != GOTO_PREVIOUS_ITEM) {
319 /* there is no need to scan directory anymore. Given entry found or does not exist */
320 path_to_entry->pos_in_item = de->de_entry_num;
324 /* there is left neighboring item of this directory and given entry can be there */
325 set_cpu_key_k_offset(&key_to_search,
326 le_ih_k_offset(de->de_ih) - 1);
327 pathrelse(path_to_entry);
332 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
333 struct nameidata *nd)
336 struct inode *inode = NULL;
337 struct reiserfs_dir_entry de;
338 INITIALIZE_PATH(path_to_entry);
340 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
341 return ERR_PTR(-ENAMETOOLONG);
343 reiserfs_write_lock(dir->i_sb);
344 de.de_gen_number_bit_string = NULL;
346 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
347 &path_to_entry, &de);
348 pathrelse(&path_to_entry);
349 if (retval == NAME_FOUND) {
350 /* Hide the .reiserfs_priv directory */
351 if (reiserfs_xattrs(dir->i_sb) &&
352 !old_format_only(dir->i_sb) &&
353 REISERFS_SB(dir->i_sb)->priv_root &&
354 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
356 le32_to_cpu(INODE_PKEY
357 (REISERFS_SB(dir->i_sb)->priv_root->d_inode)->
359 reiserfs_write_unlock(dir->i_sb);
360 return ERR_PTR(-EACCES);
364 reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
365 if (!inode || IS_ERR(inode)) {
366 reiserfs_write_unlock(dir->i_sb);
367 return ERR_PTR(-EACCES);
369 vx_propagate_xid(nd, inode);
371 /* Propogate the priv_object flag so we know we're in the priv tree */
372 if (is_reiserfs_priv_object(dir))
373 reiserfs_mark_inode_private(inode);
375 reiserfs_write_unlock(dir->i_sb);
376 if (retval == IO_ERROR) {
377 return ERR_PTR(-EIO);
380 return d_splice_alias(inode, dentry);
384 ** looks up the dentry of the parent directory for child.
385 ** taken from ext2_get_parent
387 struct dentry *reiserfs_get_parent(struct dentry *child)
390 struct inode *inode = NULL;
391 struct reiserfs_dir_entry de;
392 INITIALIZE_PATH(path_to_entry);
393 struct dentry *parent;
394 struct inode *dir = child->d_inode;
396 if (dir->i_nlink == 0) {
397 return ERR_PTR(-ENOENT);
399 de.de_gen_number_bit_string = NULL;
401 reiserfs_write_lock(dir->i_sb);
402 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
403 pathrelse(&path_to_entry);
404 if (retval != NAME_FOUND) {
405 reiserfs_write_unlock(dir->i_sb);
406 return ERR_PTR(-ENOENT);
408 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
409 reiserfs_write_unlock(dir->i_sb);
411 if (!inode || IS_ERR(inode)) {
412 return ERR_PTR(-EACCES);
414 parent = d_alloc_anon(inode);
417 parent = ERR_PTR(-ENOMEM);
422 /* add entry to the directory (entry can be hidden).
424 insert definition of when hidden directories are used here -Hans
426 Does not mark dir inode dirty, do it after successesfull call to it */
428 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
429 struct inode *dir, const char *name, int namelen,
430 struct inode *inode, int visible)
432 struct cpu_key entry_key;
433 struct reiserfs_de_head *deh;
434 INITIALIZE_PATH(path);
435 struct reiserfs_dir_entry de;
436 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
438 char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
439 if we create file with short name */
441 int buflen, paste_size;
444 BUG_ON(!th->t_trans_id);
446 /* cannot allow items to be added into a busy deleted directory */
450 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
451 return -ENAMETOOLONG;
453 /* each entry has unique key. compose it */
454 make_cpu_key(&entry_key, dir,
455 get_third_component(dir->i_sb, name, namelen),
458 /* get memory for composing the entry */
459 buflen = DEH_SIZE + ROUND_UP(namelen);
460 if (buflen > sizeof(small_buf)) {
461 buffer = kmalloc(buflen, GFP_NOFS);
468 (get_inode_sd_version(dir) ==
469 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
471 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
472 deh = (struct reiserfs_de_head *)buffer;
473 deh->deh_location = 0; /* JDM Endian safe if 0 */
474 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
475 deh->deh_state = 0; /* JDM Endian safe if 0 */
476 /* put key (ino analog) to de */
477 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
478 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
481 memcpy((char *)(deh + 1), name, namelen);
482 /* padd by 0s to the 4 byte boundary */
483 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
485 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
486 mark_de_without_sd(deh);
487 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
489 /* find the proper place for the new entry */
490 memset(bit_string, 0, sizeof(bit_string));
491 de.de_gen_number_bit_string = bit_string;
492 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
493 if (retval != NAME_NOT_FOUND) {
494 if (buffer != small_buf)
498 if (retval == IO_ERROR) {
502 if (retval != NAME_FOUND) {
503 reiserfs_warning(dir->i_sb,
504 "zam-7002:%s: \"reiserfs_find_entry\" "
505 "has returned unexpected value (%d)",
506 __FUNCTION__, retval);
513 find_first_zero_bit(bit_string,
514 MAX_GENERATION_NUMBER + 1);
515 if (gen_number > MAX_GENERATION_NUMBER) {
516 /* there is no free generation number */
517 reiserfs_warning(dir->i_sb,
518 "reiserfs_add_entry: Congratulations! we have got hash function screwed up");
519 if (buffer != small_buf)
524 /* adjust offset of directory enrty */
525 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
526 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
528 /* update max-hash-collisions counter in reiserfs_sb_info */
529 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
531 if (gen_number != 0) { /* we need to re-search for the insertion point */
532 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
534 reiserfs_warning(dir->i_sb,
535 "vs-7032: reiserfs_add_entry: "
536 "entry with this key (%K) already exists",
539 if (buffer != small_buf)
546 /* perform the insertion of the entry that we have prepared */
548 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
550 if (buffer != small_buf)
553 reiserfs_check_path(&path);
557 dir->i_size += paste_size;
558 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
559 if (!S_ISDIR(inode->i_mode) && visible)
560 // reiserfs_mkdir or reiserfs_rename will do that by itself
561 reiserfs_update_sd(th, dir);
563 reiserfs_check_path(&path);
567 /* quota utility function, call if you've had to abort after calling
568 ** new_inode_init, and have not called reiserfs_new_inode yet.
569 ** This should only be called on inodes that do not have stat data
570 ** inserted into the tree yet.
572 static int drop_new_inode(struct inode *inode)
575 make_bad_inode(inode);
576 inode->i_flags |= S_NOQUOTA;
581 /* utility function that does setup for reiserfs_new_inode.
582 ** DQUOT_INIT needs lots of credits so it's better to have it
583 ** outside of a transaction, so we had to pull some bits of
584 ** reiserfs_new_inode out into this func.
586 static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
589 /* the quota init calls have to know who to charge the quota to, so
590 ** we have to set uid and gid here
592 inode->i_uid = current->fsuid;
593 inode->i_mode = mode;
594 /* Make inode invalid - just in case we are going to drop it before
595 * the initialization happens */
596 INODE_PKEY(inode)->k_objectid = 0;
598 if (dir->i_mode & S_ISGID) {
599 inode->i_gid = dir->i_gid;
601 inode->i_mode |= S_ISGID;
603 inode->i_gid = current->fsgid;
605 inode->i_xid = vx_current_fsxid(inode->i_sb);
610 static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
611 struct nameidata *nd)
615 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
617 JOURNAL_PER_BALANCE_CNT * 2 +
618 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
619 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
620 struct reiserfs_transaction_handle th;
623 if (!(inode = new_inode(dir->i_sb))) {
626 new_inode_init(inode, dir, mode);
628 locked = reiserfs_cache_default_acl(dir);
630 reiserfs_write_lock(dir->i_sb);
633 reiserfs_write_lock_xattrs(dir->i_sb);
635 retval = journal_begin(&th, dir->i_sb, jbegin_count);
637 drop_new_inode(inode);
642 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
648 reiserfs_write_unlock_xattrs(dir->i_sb);
652 inode->i_op = &reiserfs_file_inode_operations;
653 inode->i_fop = &reiserfs_file_operations;
654 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
657 reiserfs_add_entry(&th, dir, dentry->d_name.name,
658 dentry->d_name.len, inode, 1 /*visible */ );
662 reiserfs_update_sd(&th, inode);
663 err = journal_end(&th, dir->i_sb, jbegin_count);
669 reiserfs_update_inode_transaction(inode);
670 reiserfs_update_inode_transaction(dir);
672 d_instantiate(dentry, inode);
673 retval = journal_end(&th, dir->i_sb, jbegin_count);
677 reiserfs_write_unlock_xattrs(dir->i_sb);
678 reiserfs_write_unlock(dir->i_sb);
682 static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
687 struct reiserfs_transaction_handle th;
688 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
690 JOURNAL_PER_BALANCE_CNT * 3 +
691 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
692 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
695 if (!new_valid_dev(rdev))
698 if (!(inode = new_inode(dir->i_sb))) {
701 new_inode_init(inode, dir, mode);
703 locked = reiserfs_cache_default_acl(dir);
705 reiserfs_write_lock(dir->i_sb);
708 reiserfs_write_lock_xattrs(dir->i_sb);
710 retval = journal_begin(&th, dir->i_sb, jbegin_count);
712 drop_new_inode(inode);
717 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
724 reiserfs_write_unlock_xattrs(dir->i_sb);
728 inode->i_op = &reiserfs_special_inode_operations;
729 init_special_inode(inode, inode->i_mode, rdev);
731 //FIXME: needed for block and char devices only
732 reiserfs_update_sd(&th, inode);
734 reiserfs_update_inode_transaction(inode);
735 reiserfs_update_inode_transaction(dir);
738 reiserfs_add_entry(&th, dir, dentry->d_name.name,
739 dentry->d_name.len, inode, 1 /*visible */ );
743 reiserfs_update_sd(&th, inode);
744 err = journal_end(&th, dir->i_sb, jbegin_count);
751 d_instantiate(dentry, inode);
752 retval = journal_end(&th, dir->i_sb, jbegin_count);
756 reiserfs_write_unlock_xattrs(dir->i_sb);
757 reiserfs_write_unlock(dir->i_sb);
761 static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
765 struct reiserfs_transaction_handle th;
766 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
768 JOURNAL_PER_BALANCE_CNT * 3 +
769 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
770 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
773 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
774 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
775 REISERFS_I(dir)->new_packing_locality = 1;
777 mode = S_IFDIR | mode;
778 if (!(inode = new_inode(dir->i_sb))) {
781 new_inode_init(inode, dir, mode);
783 locked = reiserfs_cache_default_acl(dir);
785 reiserfs_write_lock(dir->i_sb);
787 reiserfs_write_lock_xattrs(dir->i_sb);
789 retval = journal_begin(&th, dir->i_sb, jbegin_count);
791 drop_new_inode(inode);
795 /* inc the link count now, so another writer doesn't overflow it while
796 ** we sleep later on.
798 INC_DIR_INODE_NLINK(dir)
800 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
801 old_format_only(dir->i_sb) ?
802 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
810 reiserfs_write_unlock_xattrs(dir->i_sb);
814 reiserfs_update_inode_transaction(inode);
815 reiserfs_update_inode_transaction(dir);
817 inode->i_op = &reiserfs_dir_inode_operations;
818 inode->i_fop = &reiserfs_dir_operations;
820 // note, _this_ add_entry will not update dir's stat data
822 reiserfs_add_entry(&th, dir, dentry->d_name.name,
823 dentry->d_name.len, inode, 1 /*visible */ );
827 DEC_DIR_INODE_NLINK(dir);
828 reiserfs_update_sd(&th, inode);
829 err = journal_end(&th, dir->i_sb, jbegin_count);
835 // the above add_entry did not update dir's stat data
836 reiserfs_update_sd(&th, dir);
838 d_instantiate(dentry, inode);
839 retval = journal_end(&th, dir->i_sb, jbegin_count);
842 reiserfs_write_unlock_xattrs(dir->i_sb);
843 reiserfs_write_unlock(dir->i_sb);
847 static inline int reiserfs_empty_dir(struct inode *inode)
849 /* we can cheat because an old format dir cannot have
850 ** EMPTY_DIR_SIZE, and a new format dir cannot have
851 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
852 ** regardless of disk format version, the directory is empty.
854 if (inode->i_size != EMPTY_DIR_SIZE &&
855 inode->i_size != EMPTY_DIR_SIZE_V1) {
861 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
865 struct reiserfs_transaction_handle th;
867 INITIALIZE_PATH(path);
868 struct reiserfs_dir_entry de;
870 /* we will be doing 2 balancings and update 2 stat data, we change quotas
871 * of the owner of the directory and of the owner of the parent directory.
872 * The quota structure is possibly deleted only on last iput => outside
873 * of this transaction */
875 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
876 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
878 reiserfs_write_lock(dir->i_sb);
879 retval = journal_begin(&th, dir->i_sb, jbegin_count);
883 de.de_gen_number_bit_string = NULL;
885 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
886 &path, &de)) == NAME_NOT_FOUND) {
889 } else if (retval == IO_ERROR) {
894 inode = dentry->d_inode;
896 reiserfs_update_inode_transaction(inode);
897 reiserfs_update_inode_transaction(dir);
899 if (de.de_objectid != inode->i_ino) {
900 // FIXME: compare key of an object and a key found in the
905 if (!reiserfs_empty_dir(inode)) {
910 /* cut entry from dir directory */
911 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL, /* page */
912 0 /*new file size - not used here */ );
916 if (inode->i_nlink != 2 && inode->i_nlink != 1)
917 reiserfs_warning(inode->i_sb, "%s: empty directory has nlink "
918 "!= 2 (%d)", __FUNCTION__, inode->i_nlink);
921 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
922 reiserfs_update_sd(&th, inode);
924 DEC_DIR_INODE_NLINK(dir)
925 dir->i_size -= (DEH_SIZE + de.de_entrylen);
926 reiserfs_update_sd(&th, dir);
928 /* prevent empty directory from getting lost */
929 add_save_link(&th, inode, 0 /* not truncate */ );
931 retval = journal_end(&th, dir->i_sb, jbegin_count);
932 reiserfs_check_path(&path);
934 reiserfs_write_unlock(dir->i_sb);
938 /* we must release path, because we did not call
939 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
940 release path if operation was not complete */
942 err = journal_end(&th, dir->i_sb, jbegin_count);
943 reiserfs_write_unlock(dir->i_sb);
944 return err ? err : retval;
947 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
951 struct reiserfs_dir_entry de;
952 INITIALIZE_PATH(path);
953 struct reiserfs_transaction_handle th;
955 unsigned long savelink;
957 inode = dentry->d_inode;
959 /* in this transaction we can be doing at max two balancings and update
960 * two stat datas, we change quotas of the owner of the directory and of
961 * the owner of the parent directory. The quota structure is possibly
962 * deleted only on iput => outside of this transaction */
964 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
965 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
967 reiserfs_write_lock(dir->i_sb);
968 retval = journal_begin(&th, dir->i_sb, jbegin_count);
972 de.de_gen_number_bit_string = NULL;
974 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
975 &path, &de)) == NAME_NOT_FOUND) {
978 } else if (retval == IO_ERROR) {
983 reiserfs_update_inode_transaction(inode);
984 reiserfs_update_inode_transaction(dir);
986 if (de.de_objectid != inode->i_ino) {
987 // FIXME: compare key of an object and a key found in the
993 if (!inode->i_nlink) {
994 reiserfs_warning(inode->i_sb, "%s: deleting nonexistent file "
995 "(%s:%lu), %d", __FUNCTION__,
996 reiserfs_bdevname(inode->i_sb), inode->i_ino,
1004 * we schedule before doing the add_save_link call, save the link
1005 * count so we don't race
1007 savelink = inode->i_nlink;
1010 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
1016 inode->i_ctime = CURRENT_TIME_SEC;
1017 reiserfs_update_sd(&th, inode);
1019 dir->i_size -= (de.de_entrylen + DEH_SIZE);
1020 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
1021 reiserfs_update_sd(&th, dir);
1024 /* prevent file from getting lost */
1025 add_save_link(&th, inode, 0 /* not truncate */ );
1027 retval = journal_end(&th, dir->i_sb, jbegin_count);
1028 reiserfs_check_path(&path);
1029 reiserfs_write_unlock(dir->i_sb);
1034 err = journal_end(&th, dir->i_sb, jbegin_count);
1035 reiserfs_check_path(&path);
1039 reiserfs_write_unlock(dir->i_sb);
1043 static int reiserfs_symlink(struct inode *parent_dir,
1044 struct dentry *dentry, const char *symname)
1047 struct inode *inode;
1050 struct reiserfs_transaction_handle th;
1051 int mode = S_IFLNK | S_IRWXUGO;
1052 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1054 JOURNAL_PER_BALANCE_CNT * 3 +
1055 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1056 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1058 if (!(inode = new_inode(parent_dir->i_sb))) {
1061 new_inode_init(inode, parent_dir, mode);
1063 reiserfs_write_lock(parent_dir->i_sb);
1064 item_len = ROUND_UP(strlen(symname));
1065 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1066 retval = -ENAMETOOLONG;
1067 drop_new_inode(inode);
1071 name = kmalloc(item_len, GFP_NOFS);
1073 drop_new_inode(inode);
1077 memcpy(name, symname, strlen(symname));
1078 padd_item(name, item_len, strlen(symname));
1080 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1082 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1084 drop_new_inode(inode);
1090 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1093 if (retval) { /* reiserfs_new_inode iputs for us */
1097 reiserfs_update_inode_transaction(inode);
1098 reiserfs_update_inode_transaction(parent_dir);
1100 inode->i_op = &reiserfs_symlink_inode_operations;
1101 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1103 // must be sure this inode is written with this transaction
1105 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1107 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1108 dentry->d_name.len, inode, 1 /*visible */ );
1112 reiserfs_update_sd(&th, inode);
1113 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1120 d_instantiate(dentry, inode);
1121 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1123 reiserfs_write_unlock(parent_dir->i_sb);
1127 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1128 struct dentry *dentry)
1131 struct inode *inode = old_dentry->d_inode;
1132 struct reiserfs_transaction_handle th;
1133 /* We need blocks for transaction + update of quotas for the owners of the directory */
1135 JOURNAL_PER_BALANCE_CNT * 3 +
1136 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1138 reiserfs_write_lock(dir->i_sb);
1139 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1140 //FIXME: sd_nlink is 32 bit for new files
1141 reiserfs_write_unlock(dir->i_sb);
1144 if (inode->i_nlink == 0) {
1145 reiserfs_write_unlock(dir->i_sb);
1149 /* inc before scheduling so reiserfs_unlink knows we are here */
1152 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1155 reiserfs_write_unlock(dir->i_sb);
1159 /* create new entry */
1161 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1162 dentry->d_name.len, inode, 1 /*visible */ );
1164 reiserfs_update_inode_transaction(inode);
1165 reiserfs_update_inode_transaction(dir);
1170 err = journal_end(&th, dir->i_sb, jbegin_count);
1171 reiserfs_write_unlock(dir->i_sb);
1172 return err ? err : retval;
1175 inode->i_ctime = CURRENT_TIME_SEC;
1176 reiserfs_update_sd(&th, inode);
1178 atomic_inc(&inode->i_count);
1179 d_instantiate(dentry, inode);
1180 retval = journal_end(&th, dir->i_sb, jbegin_count);
1181 reiserfs_write_unlock(dir->i_sb);
1185 // de contains information pointing to an entry which
1186 static int de_still_valid(const char *name, int len,
1187 struct reiserfs_dir_entry *de)
1189 struct reiserfs_dir_entry tmp = *de;
1191 // recalculate pointer to name and name length
1192 set_de_name_and_namelen(&tmp);
1193 // FIXME: could check more
1194 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1199 static int entry_points_to_object(const char *name, int len,
1200 struct reiserfs_dir_entry *de,
1201 struct inode *inode)
1203 if (!de_still_valid(name, len, de))
1207 if (!de_visible(de->de_deh + de->de_entry_num))
1208 reiserfs_panic(NULL,
1209 "vs-7042: entry_points_to_object: entry must be visible");
1210 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1213 /* this must be added hidden entry */
1214 if (de_visible(de->de_deh + de->de_entry_num))
1215 reiserfs_panic(NULL,
1216 "vs-7043: entry_points_to_object: entry must be visible");
1221 /* sets key of objectid the entry has to point to */
1222 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1223 struct reiserfs_key *key)
1225 /* JDM These operations are endian safe - both are le */
1226 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1227 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1231 * process, that is going to call fix_nodes/do_balance must hold only
1232 * one path. If it holds 2 or more, it can get into endless waiting in
1233 * get_empty_nodes or its clones
1235 static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1236 struct inode *new_dir, struct dentry *new_dentry)
1239 INITIALIZE_PATH(old_entry_path);
1240 INITIALIZE_PATH(new_entry_path);
1241 INITIALIZE_PATH(dot_dot_entry_path);
1242 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1243 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1244 struct inode *old_inode, *new_dentry_inode;
1245 struct reiserfs_transaction_handle th;
1247 umode_t old_inode_mode;
1248 unsigned long savelink = 1;
1249 struct timespec ctime;
1251 /* three balancings: (1) old name removal, (2) new name insertion
1252 and (3) maybe "save" link insertion
1253 stat data updates: (1) old directory,
1254 (2) new directory and (3) maybe old object stat data (when it is
1255 directory) and (4) maybe stat data of object to which new entry
1256 pointed initially and (5) maybe block containing ".." of
1258 quota updates: two parent directories */
1260 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1261 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1263 old_inode = old_dentry->d_inode;
1264 new_dentry_inode = new_dentry->d_inode;
1266 // make sure, that oldname still exists and points to an object we
1267 // are going to rename
1268 old_de.de_gen_number_bit_string = NULL;
1269 reiserfs_write_lock(old_dir->i_sb);
1271 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1272 old_dentry->d_name.len, &old_entry_path,
1274 pathrelse(&old_entry_path);
1275 if (retval == IO_ERROR) {
1276 reiserfs_write_unlock(old_dir->i_sb);
1280 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1281 reiserfs_write_unlock(old_dir->i_sb);
1285 old_inode_mode = old_inode->i_mode;
1286 if (S_ISDIR(old_inode_mode)) {
1287 // make sure, that directory being renamed has correct ".."
1288 // and that its new parent directory has not too many links
1291 if (new_dentry_inode) {
1292 if (!reiserfs_empty_dir(new_dentry_inode)) {
1293 reiserfs_write_unlock(old_dir->i_sb);
1298 /* directory is renamed, its parent directory will be changed,
1299 ** so find ".." entry
1301 dot_dot_de.de_gen_number_bit_string = NULL;
1303 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1305 pathrelse(&dot_dot_entry_path);
1306 if (retval != NAME_FOUND) {
1307 reiserfs_write_unlock(old_dir->i_sb);
1311 /* inode number of .. must equal old_dir->i_ino */
1312 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1313 reiserfs_write_unlock(old_dir->i_sb);
1318 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1320 reiserfs_write_unlock(old_dir->i_sb);
1324 /* add new entry (or find the existing one) */
1326 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1327 new_dentry->d_name.len, old_inode, 0);
1328 if (retval == -EEXIST) {
1329 if (!new_dentry_inode) {
1330 reiserfs_panic(old_dir->i_sb,
1331 "vs-7050: new entry is found, new inode == 0\n");
1333 } else if (retval) {
1334 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1335 reiserfs_write_unlock(old_dir->i_sb);
1336 return err ? err : retval;
1339 reiserfs_update_inode_transaction(old_dir);
1340 reiserfs_update_inode_transaction(new_dir);
1342 /* this makes it so an fsync on an open fd for the old name will
1343 ** commit the rename operation
1345 reiserfs_update_inode_transaction(old_inode);
1347 if (new_dentry_inode)
1348 reiserfs_update_inode_transaction(new_dentry_inode);
1351 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1353 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1355 &old_de)) != NAME_FOUND) {
1356 pathrelse(&old_entry_path);
1357 journal_end(&th, old_dir->i_sb, jbegin_count);
1358 reiserfs_write_unlock(old_dir->i_sb);
1362 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
1364 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1366 // look for new name by reiserfs_find_entry
1367 new_de.de_gen_number_bit_string = NULL;
1369 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1370 new_dentry->d_name.len, &new_entry_path,
1372 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1373 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1374 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1375 pathrelse(&new_entry_path);
1376 pathrelse(&old_entry_path);
1377 journal_end(&th, old_dir->i_sb, jbegin_count);
1378 reiserfs_write_unlock(old_dir->i_sb);
1382 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1384 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1386 if (S_ISDIR(old_inode->i_mode)) {
1388 search_by_entry_key(new_dir->i_sb,
1389 &dot_dot_de.de_entry_key,
1390 &dot_dot_entry_path,
1391 &dot_dot_de)) != NAME_FOUND) {
1392 pathrelse(&dot_dot_entry_path);
1393 pathrelse(&new_entry_path);
1394 pathrelse(&old_entry_path);
1395 journal_end(&th, old_dir->i_sb, jbegin_count);
1396 reiserfs_write_unlock(old_dir->i_sb);
1399 copy_item_head(&dot_dot_ih,
1400 get_ih(&dot_dot_entry_path));
1401 // node containing ".." gets into transaction
1402 reiserfs_prepare_for_journal(old_inode->i_sb,
1403 dot_dot_de.de_bh, 1);
1405 /* we should check seals here, not do
1406 this stuff, yes? Then, having
1407 gathered everything into RAM we
1408 should lock the buffers, yes? -Hans */
1409 /* probably. our rename needs to hold more
1410 ** than one path at once. The seals would
1411 ** have to be written to deal with multi-path
1414 /* sanity checking before doing the rename - avoid races many
1415 ** of the above checks could have scheduled. We have to be
1416 ** sure our items haven't been shifted by another process.
1418 if (item_moved(&new_entry_ih, &new_entry_path) ||
1419 !entry_points_to_object(new_dentry->d_name.name,
1420 new_dentry->d_name.len,
1421 &new_de, new_dentry_inode) ||
1422 item_moved(&old_entry_ih, &old_entry_path) ||
1423 !entry_points_to_object(old_dentry->d_name.name,
1424 old_dentry->d_name.len,
1425 &old_de, old_inode)) {
1426 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1428 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1430 if (S_ISDIR(old_inode_mode))
1431 reiserfs_restore_prepared_buffer(old_inode->
1437 if (S_ISDIR(old_inode_mode)) {
1438 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1439 !entry_points_to_object("..", 2, &dot_dot_de,
1441 reiserfs_restore_prepared_buffer(old_inode->
1444 reiserfs_restore_prepared_buffer(old_inode->
1447 reiserfs_restore_prepared_buffer(old_inode->
1455 RFALSE(S_ISDIR(old_inode_mode) &&
1456 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1461 /* ok, all the changes can be done in one fell swoop when we
1462 have claimed all the buffers needed. */
1464 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1465 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1466 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1468 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1469 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1470 ctime = CURRENT_TIME_SEC;
1471 old_dir->i_ctime = old_dir->i_mtime = ctime;
1472 new_dir->i_ctime = new_dir->i_mtime = ctime;
1473 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1475 old_inode->i_ctime = ctime;
1477 if (new_dentry_inode) {
1478 // adjust link number of the victim
1479 if (S_ISDIR(new_dentry_inode->i_mode)) {
1480 new_dentry_inode->i_nlink = 0;
1482 new_dentry_inode->i_nlink--;
1484 new_dentry_inode->i_ctime = ctime;
1485 savelink = new_dentry_inode->i_nlink;
1488 if (S_ISDIR(old_inode_mode)) {
1489 // adjust ".." of renamed directory
1490 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1491 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1493 if (!new_dentry_inode)
1494 /* there (in new_dir) was no directory, so it got new link
1495 (".." of renamed directory) */
1496 INC_DIR_INODE_NLINK(new_dir);
1498 /* old directory lost one link - ".. " of renamed directory */
1499 DEC_DIR_INODE_NLINK(old_dir);
1501 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1502 pathrelse(&new_entry_path);
1503 pathrelse(&dot_dot_entry_path);
1505 // FIXME: this reiserfs_cut_from_item's return value may screw up
1506 // anybody, but it will panic if will not be able to find the
1507 // entry. This needs one more clean up
1508 if (reiserfs_cut_from_item
1509 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1511 reiserfs_warning(old_dir->i_sb,
1512 "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
1514 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1516 reiserfs_update_sd(&th, old_dir);
1517 reiserfs_update_sd(&th, new_dir);
1518 reiserfs_update_sd(&th, old_inode);
1520 if (new_dentry_inode) {
1522 add_save_link(&th, new_dentry_inode,
1523 0 /* not truncate */ );
1524 reiserfs_update_sd(&th, new_dentry_inode);
1527 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1528 reiserfs_write_unlock(old_dir->i_sb);
1533 * directories can handle most operations...
1535 struct inode_operations reiserfs_dir_inode_operations = {
1536 //&reiserfs_dir_operations, /* default_file_ops */
1537 .create = reiserfs_create,
1538 .lookup = reiserfs_lookup,
1539 .link = reiserfs_link,
1540 .unlink = reiserfs_unlink,
1541 .symlink = reiserfs_symlink,
1542 .mkdir = reiserfs_mkdir,
1543 .rmdir = reiserfs_rmdir,
1544 .mknod = reiserfs_mknod,
1545 .rename = reiserfs_rename,
1546 .setattr = reiserfs_setattr,
1547 .setxattr = reiserfs_setxattr,
1548 .getxattr = reiserfs_getxattr,
1549 .listxattr = reiserfs_listxattr,
1550 .removexattr = reiserfs_removexattr,
1551 .permission = reiserfs_permission,
1552 .sync_flags = reiserfs_sync_flags,
1556 * symlink operations.. same as page_symlink_inode_operations, with xattr
1559 struct inode_operations reiserfs_symlink_inode_operations = {
1560 .readlink = generic_readlink,
1561 .follow_link = page_follow_link_light,
1562 .put_link = page_put_link,
1563 .setattr = reiserfs_setattr,
1564 .setxattr = reiserfs_setxattr,
1565 .getxattr = reiserfs_getxattr,
1566 .listxattr = reiserfs_listxattr,
1567 .removexattr = reiserfs_removexattr,
1568 .permission = reiserfs_permission,
1569 .sync_flags = reiserfs_sync_flags,
1574 * special file operations.. just xattr/acl stuff
1576 struct inode_operations reiserfs_special_inode_operations = {
1577 .setattr = reiserfs_setattr,
1578 .setxattr = reiserfs_setxattr,
1579 .getxattr = reiserfs_getxattr,
1580 .listxattr = reiserfs_listxattr,
1581 .removexattr = reiserfs_removexattr,
1582 .permission = reiserfs_permission,
1583 .sync_flags = reiserfs_sync_flags,