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/smp_lock.h>
20 #include <linux/quotaops.h>
21 #include <linux/vserver/xid.h>
23 #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; }
24 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) i->i_nlink--;
26 // directory item contains array of entry headers. This performs
27 // binary search through that array
28 static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
30 struct item_head *ih = de->de_ih;
31 struct reiserfs_de_head *deh = de->de_deh;
32 int rbound, lbound, j;
35 rbound = I_ENTRY_COUNT(ih) - 1;
37 for (j = (rbound + lbound) / 2; lbound <= rbound;
38 j = (rbound + lbound) / 2) {
39 if (off < deh_offset(deh + j)) {
43 if (off > deh_offset(deh + j)) {
47 // this is not name found, but matched third key component
52 de->de_entry_num = lbound;
53 return NAME_NOT_FOUND;
56 // comment? maybe something like set de to point to what the path points to?
57 static inline void set_de_item_location(struct reiserfs_dir_entry *de,
60 de->de_bh = get_last_bh(path);
61 de->de_ih = get_ih(path);
62 de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
63 de->de_item_num = PATH_LAST_POSITION(path);
66 // de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
67 inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
69 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
71 if (de->de_entry_num >= ih_entry_count(de->de_ih))
74 de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
75 de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
76 de->de_name = B_I_PITEM(de->de_bh, de->de_ih) + deh_location(deh);
77 if (de->de_name[de->de_namelen - 1] == 0)
78 de->de_namelen = strlen(de->de_name);
81 // what entry points to
82 static inline void set_de_object_key(struct reiserfs_dir_entry *de)
84 if (de->de_entry_num >= ih_entry_count(de->de_ih))
86 de->de_dir_id = deh_dir_id(&(de->de_deh[de->de_entry_num]));
87 de->de_objectid = deh_objectid(&(de->de_deh[de->de_entry_num]));
90 static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
92 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
94 if (de->de_entry_num >= ih_entry_count(de->de_ih))
97 /* store key of the found entry */
98 de->de_entry_key.version = KEY_FORMAT_3_5;
99 de->de_entry_key.on_disk_key.k_dir_id =
100 le32_to_cpu(de->de_ih->ih_key.k_dir_id);
101 de->de_entry_key.on_disk_key.k_objectid =
102 le32_to_cpu(de->de_ih->ih_key.k_objectid);
103 set_cpu_key_k_offset(&(de->de_entry_key), deh_offset(deh));
104 set_cpu_key_k_type(&(de->de_entry_key), TYPE_DIRENTRY);
107 /* We assign a key to each directory item, and place multiple entries
108 in a single directory item. A directory item has a key equal to the
109 key of the first directory entry in it.
111 This function first calls search_by_key, then, if item whose first
112 entry matches is not found it looks for the entry inside directory
113 item found by search_by_key. Fills the path to the entry, and to the
114 entry position in the item
118 /* The function is NOT SCHEDULE-SAFE! */
119 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
120 struct path *path, struct reiserfs_dir_entry *de)
124 retval = search_item(sb, key, path);
127 if (!PATH_LAST_POSITION(path)) {
129 "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
133 PATH_LAST_POSITION(path)--;
144 "vs-7002: search_by_entry_key: no path to here");
148 set_de_item_location(de, path);
150 #ifdef CONFIG_REISERFS_CHECK
151 if (!is_direntry_le_ih(de->de_ih) ||
152 COMP_SHORT_KEYS(&(de->de_ih->ih_key), key)) {
153 print_block(de->de_bh, 0, -1, -1);
155 "vs-7005: search_by_entry_key: found item %h is not directory item or "
156 "does not belong to the same directory as key %K",
159 #endif /* CONFIG_REISERFS_CHECK */
161 /* binary search in directory item by third componen t of the
162 key. sets de->de_entry_num of de */
163 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
164 path->pos_in_item = de->de_entry_num;
165 if (retval != NAME_NOT_FOUND) {
166 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
167 set_de_name_and_namelen(de);
168 set_de_object_key(de);
173 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
175 /* The third component is hashed, and you can choose from more than
176 one hash function. Per directory hashes are not yet implemented
177 but are thought about. This function should be moved to hashes.c
178 Jedi, please do so. -Hans */
180 static __u32 get_third_component(struct super_block *s,
181 const char *name, int len)
185 if (!len || (len == 1 && name[0] == '.'))
187 if (len == 2 && name[0] == '.' && name[1] == '.')
188 return DOT_DOT_OFFSET;
190 res = REISERFS_SB(s)->s_hash_function(name, len);
192 // take bits from 7-th to 30-th including both bounds
193 res = GET_HASH_VALUE(res);
195 // needed to have no names before "." and ".." those have hash
196 // value == 0 and generation conters 1 and 2 accordingly
198 return res + MAX_GENERATION_NUMBER;
201 static int reiserfs_match(struct reiserfs_dir_entry *de,
202 const char *name, int namelen)
204 int retval = NAME_NOT_FOUND;
206 if ((namelen == de->de_namelen) &&
207 !memcmp(de->de_name, name, de->de_namelen))
209 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
210 NAME_FOUND_INVISIBLE);
215 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
217 /* used when hash collisions exist */
219 static int linear_search_in_dir_item(struct cpu_key *key,
220 struct reiserfs_dir_entry *de,
221 const char *name, int namelen)
223 struct reiserfs_de_head *deh = de->de_deh;
227 i = de->de_entry_num;
229 if (i == I_ENTRY_COUNT(de->de_ih) ||
230 GET_HASH_VALUE(deh_offset(deh + i)) !=
231 GET_HASH_VALUE(cpu_key_k_offset(key))) {
235 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
236 "vs-7010: array of entry headers not found");
240 for (; i >= 0; i--, deh--) {
241 if (GET_HASH_VALUE(deh_offset(deh)) !=
242 GET_HASH_VALUE(cpu_key_k_offset(key))) {
243 // hash value does not match, no need to check whole name
244 return NAME_NOT_FOUND;
247 /* mark, that this generation number is used */
248 if (de->de_gen_number_bit_string)
249 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
250 de->de_gen_number_bit_string);
252 // calculate pointer to name and namelen
253 de->de_entry_num = i;
254 set_de_name_and_namelen(de);
257 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
258 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
260 // key of pointed object
261 set_de_object_key(de);
263 store_de_entry_key(de);
265 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
270 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
271 /* we have reached left most entry in the node. In common we
272 have to go to the left neighbor, but if generation counter
273 is 0 already, we know for sure, that there is no name with
274 the same hash value */
275 // FIXME: this work correctly only because hash value can not
276 // be 0. Btw, in case of Yura's hash it is probably possible,
278 return NAME_NOT_FOUND;
280 RFALSE(de->de_item_num,
281 "vs-7015: two diritems of the same directory in one node?");
283 return GOTO_PREVIOUS_ITEM;
286 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
287 // FIXME: should add something like IOERROR
288 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
289 struct path *path_to_entry,
290 struct reiserfs_dir_entry *de)
292 struct cpu_key key_to_search;
295 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
296 return NAME_NOT_FOUND;
298 /* we will search for this key in the tree */
299 make_cpu_key(&key_to_search, dir,
300 get_third_component(dir->i_sb, name, namelen),
305 search_by_entry_key(dir->i_sb, &key_to_search,
307 if (retval == IO_ERROR) {
308 reiserfs_warning(dir->i_sb, "zam-7001: io error in %s",
313 /* compare names for all entries having given hash value */
315 linear_search_in_dir_item(&key_to_search, de, name,
317 if (retval != GOTO_PREVIOUS_ITEM) {
318 /* there is no need to scan directory anymore. Given entry found or does not exist */
319 path_to_entry->pos_in_item = de->de_entry_num;
323 /* there is left neighboring item of this directory and given entry can be there */
324 set_cpu_key_k_offset(&key_to_search,
325 le_ih_k_offset(de->de_ih) - 1);
326 pathrelse(path_to_entry);
331 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
332 struct nameidata *nd)
335 struct inode *inode = NULL;
336 struct reiserfs_dir_entry de;
337 INITIALIZE_PATH(path_to_entry);
339 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
340 return ERR_PTR(-ENAMETOOLONG);
342 reiserfs_write_lock(dir->i_sb);
343 de.de_gen_number_bit_string = NULL;
345 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
346 &path_to_entry, &de);
347 pathrelse(&path_to_entry);
348 if (retval == NAME_FOUND) {
349 /* Hide the .reiserfs_priv directory */
350 if (reiserfs_xattrs(dir->i_sb) &&
351 !old_format_only(dir->i_sb) &&
352 REISERFS_SB(dir->i_sb)->priv_root &&
353 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
355 le32_to_cpu(INODE_PKEY
356 (REISERFS_SB(dir->i_sb)->priv_root->d_inode)->
358 reiserfs_write_unlock(dir->i_sb);
359 return ERR_PTR(-EACCES);
363 reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
364 if (!inode || IS_ERR(inode)) {
365 reiserfs_write_unlock(dir->i_sb);
366 return ERR_PTR(-EACCES);
368 vx_propagate_xid(nd, inode);
370 /* Propogate the priv_object flag so we know we're in the priv tree */
371 if (is_reiserfs_priv_object(dir))
372 reiserfs_mark_inode_private(inode);
374 reiserfs_write_unlock(dir->i_sb);
375 if (retval == IO_ERROR) {
376 return ERR_PTR(-EIO);
379 return d_splice_alias(inode, dentry);
383 ** looks up the dentry of the parent directory for child.
384 ** taken from ext2_get_parent
386 struct dentry *reiserfs_get_parent(struct dentry *child)
389 struct inode *inode = NULL;
390 struct reiserfs_dir_entry de;
391 INITIALIZE_PATH(path_to_entry);
392 struct dentry *parent;
393 struct inode *dir = child->d_inode;
395 if (dir->i_nlink == 0) {
396 return ERR_PTR(-ENOENT);
398 de.de_gen_number_bit_string = NULL;
400 reiserfs_write_lock(dir->i_sb);
401 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
402 pathrelse(&path_to_entry);
403 if (retval != NAME_FOUND) {
404 reiserfs_write_unlock(dir->i_sb);
405 return ERR_PTR(-ENOENT);
407 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
408 reiserfs_write_unlock(dir->i_sb);
410 if (!inode || IS_ERR(inode)) {
411 return ERR_PTR(-EACCES);
413 parent = d_alloc_anon(inode);
416 parent = ERR_PTR(-ENOMEM);
421 /* add entry to the directory (entry can be hidden).
423 insert definition of when hidden directories are used here -Hans
425 Does not mark dir inode dirty, do it after successesfull call to it */
427 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
428 struct inode *dir, const char *name, int namelen,
429 struct inode *inode, int visible)
431 struct cpu_key entry_key;
432 struct reiserfs_de_head *deh;
433 INITIALIZE_PATH(path);
434 struct reiserfs_dir_entry de;
435 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
437 char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
438 if we create file with short name */
440 int buflen, paste_size;
443 BUG_ON(!th->t_trans_id);
445 /* cannot allow items to be added into a busy deleted directory */
449 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
450 return -ENAMETOOLONG;
452 /* each entry has unique key. compose it */
453 make_cpu_key(&entry_key, dir,
454 get_third_component(dir->i_sb, name, namelen),
457 /* get memory for composing the entry */
458 buflen = DEH_SIZE + ROUND_UP(namelen);
459 if (buflen > sizeof(small_buf)) {
460 buffer = kmalloc(buflen, GFP_NOFS);
467 (get_inode_sd_version(dir) ==
468 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
470 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
471 deh = (struct reiserfs_de_head *)buffer;
472 deh->deh_location = 0; /* JDM Endian safe if 0 */
473 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
474 deh->deh_state = 0; /* JDM Endian safe if 0 */
475 /* put key (ino analog) to de */
476 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
477 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
480 memcpy((char *)(deh + 1), name, namelen);
481 /* padd by 0s to the 4 byte boundary */
482 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
484 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
485 mark_de_without_sd(deh);
486 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
488 /* find the proper place for the new entry */
489 memset(bit_string, 0, sizeof(bit_string));
490 de.de_gen_number_bit_string = bit_string;
491 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
492 if (retval != NAME_NOT_FOUND) {
493 if (buffer != small_buf)
497 if (retval == IO_ERROR) {
501 if (retval != NAME_FOUND) {
502 reiserfs_warning(dir->i_sb,
503 "zam-7002:%s: \"reiserfs_find_entry\" "
504 "has returned unexpected value (%d)",
505 __FUNCTION__, retval);
512 find_first_zero_bit(bit_string,
513 MAX_GENERATION_NUMBER + 1);
514 if (gen_number > MAX_GENERATION_NUMBER) {
515 /* there is no free generation number */
516 reiserfs_warning(dir->i_sb,
517 "reiserfs_add_entry: Congratulations! we have got hash function screwed up");
518 if (buffer != small_buf)
523 /* adjust offset of directory enrty */
524 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
525 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
527 /* update max-hash-collisions counter in reiserfs_sb_info */
528 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
530 if (gen_number != 0) { /* we need to re-search for the insertion point */
531 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
533 reiserfs_warning(dir->i_sb,
534 "vs-7032: reiserfs_add_entry: "
535 "entry with this key (%K) already exists",
538 if (buffer != small_buf)
545 /* perform the insertion of the entry that we have prepared */
547 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
549 if (buffer != small_buf)
552 reiserfs_check_path(&path);
556 dir->i_size += paste_size;
557 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
558 if (!S_ISDIR(inode->i_mode) && visible)
559 // reiserfs_mkdir or reiserfs_rename will do that by itself
560 reiserfs_update_sd(th, dir);
562 reiserfs_check_path(&path);
566 /* quota utility function, call if you've had to abort after calling
567 ** new_inode_init, and have not called reiserfs_new_inode yet.
568 ** This should only be called on inodes that do not have stat data
569 ** inserted into the tree yet.
571 static int drop_new_inode(struct inode *inode)
574 make_bad_inode(inode);
575 inode->i_flags |= S_NOQUOTA;
580 /* utility function that does setup for reiserfs_new_inode.
581 ** DQUOT_INIT needs lots of credits so it's better to have it
582 ** outside of a transaction, so we had to pull some bits of
583 ** reiserfs_new_inode out into this func.
585 static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
588 /* the quota init calls have to know who to charge the quota to, so
589 ** we have to set uid and gid here
591 inode->i_uid = current->fsuid;
592 inode->i_mode = mode;
593 /* Make inode invalid - just in case we are going to drop it before
594 * the initialization happens */
595 INODE_PKEY(inode)->k_objectid = 0;
597 if (dir->i_mode & S_ISGID) {
598 inode->i_gid = dir->i_gid;
600 inode->i_mode |= S_ISGID;
602 inode->i_gid = current->fsgid;
604 inode->i_xid = vx_current_fsxid(inode->i_sb);
609 static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
610 struct nameidata *nd)
614 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
616 JOURNAL_PER_BALANCE_CNT * 2 +
617 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
618 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
619 struct reiserfs_transaction_handle th;
622 if (!(inode = new_inode(dir->i_sb))) {
625 new_inode_init(inode, dir, mode);
627 locked = reiserfs_cache_default_acl(dir);
629 reiserfs_write_lock(dir->i_sb);
632 reiserfs_write_lock_xattrs(dir->i_sb);
634 retval = journal_begin(&th, dir->i_sb, jbegin_count);
636 drop_new_inode(inode);
641 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
647 reiserfs_write_unlock_xattrs(dir->i_sb);
651 inode->i_op = &reiserfs_file_inode_operations;
652 inode->i_fop = &reiserfs_file_operations;
653 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
656 reiserfs_add_entry(&th, dir, dentry->d_name.name,
657 dentry->d_name.len, inode, 1 /*visible */ );
661 reiserfs_update_sd(&th, inode);
662 err = journal_end(&th, dir->i_sb, jbegin_count);
668 reiserfs_update_inode_transaction(inode);
669 reiserfs_update_inode_transaction(dir);
671 d_instantiate(dentry, inode);
672 retval = journal_end(&th, dir->i_sb, jbegin_count);
676 reiserfs_write_unlock_xattrs(dir->i_sb);
677 reiserfs_write_unlock(dir->i_sb);
681 static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
686 struct reiserfs_transaction_handle th;
687 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
689 JOURNAL_PER_BALANCE_CNT * 3 +
690 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
691 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
694 if (!new_valid_dev(rdev))
697 if (!(inode = new_inode(dir->i_sb))) {
700 new_inode_init(inode, dir, mode);
702 locked = reiserfs_cache_default_acl(dir);
704 reiserfs_write_lock(dir->i_sb);
707 reiserfs_write_lock_xattrs(dir->i_sb);
709 retval = journal_begin(&th, dir->i_sb, jbegin_count);
711 drop_new_inode(inode);
716 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
723 reiserfs_write_unlock_xattrs(dir->i_sb);
727 inode->i_op = &reiserfs_special_inode_operations;
728 init_special_inode(inode, inode->i_mode, rdev);
730 //FIXME: needed for block and char devices only
731 reiserfs_update_sd(&th, inode);
733 reiserfs_update_inode_transaction(inode);
734 reiserfs_update_inode_transaction(dir);
737 reiserfs_add_entry(&th, dir, dentry->d_name.name,
738 dentry->d_name.len, inode, 1 /*visible */ );
742 reiserfs_update_sd(&th, inode);
743 err = journal_end(&th, dir->i_sb, jbegin_count);
750 d_instantiate(dentry, inode);
751 retval = journal_end(&th, dir->i_sb, jbegin_count);
755 reiserfs_write_unlock_xattrs(dir->i_sb);
756 reiserfs_write_unlock(dir->i_sb);
760 static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
764 struct reiserfs_transaction_handle th;
765 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
767 JOURNAL_PER_BALANCE_CNT * 3 +
768 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
769 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
772 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
773 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
774 REISERFS_I(dir)->new_packing_locality = 1;
776 mode = S_IFDIR | mode;
777 if (!(inode = new_inode(dir->i_sb))) {
780 new_inode_init(inode, dir, mode);
782 locked = reiserfs_cache_default_acl(dir);
784 reiserfs_write_lock(dir->i_sb);
786 reiserfs_write_lock_xattrs(dir->i_sb);
788 retval = journal_begin(&th, dir->i_sb, jbegin_count);
790 drop_new_inode(inode);
794 /* inc the link count now, so another writer doesn't overflow it while
795 ** we sleep later on.
797 INC_DIR_INODE_NLINK(dir)
799 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
800 old_format_only(dir->i_sb) ?
801 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
809 reiserfs_write_unlock_xattrs(dir->i_sb);
813 reiserfs_update_inode_transaction(inode);
814 reiserfs_update_inode_transaction(dir);
816 inode->i_op = &reiserfs_dir_inode_operations;
817 inode->i_fop = &reiserfs_dir_operations;
819 // note, _this_ add_entry will not update dir's stat data
821 reiserfs_add_entry(&th, dir, dentry->d_name.name,
822 dentry->d_name.len, inode, 1 /*visible */ );
826 DEC_DIR_INODE_NLINK(dir);
827 reiserfs_update_sd(&th, inode);
828 err = journal_end(&th, dir->i_sb, jbegin_count);
834 // the above add_entry did not update dir's stat data
835 reiserfs_update_sd(&th, dir);
837 d_instantiate(dentry, inode);
838 retval = journal_end(&th, dir->i_sb, jbegin_count);
841 reiserfs_write_unlock_xattrs(dir->i_sb);
842 reiserfs_write_unlock(dir->i_sb);
846 static inline int reiserfs_empty_dir(struct inode *inode)
848 /* we can cheat because an old format dir cannot have
849 ** EMPTY_DIR_SIZE, and a new format dir cannot have
850 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
851 ** regardless of disk format version, the directory is empty.
853 if (inode->i_size != EMPTY_DIR_SIZE &&
854 inode->i_size != EMPTY_DIR_SIZE_V1) {
860 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
864 struct reiserfs_transaction_handle th;
866 INITIALIZE_PATH(path);
867 struct reiserfs_dir_entry de;
869 /* we will be doing 2 balancings and update 2 stat data, we change quotas
870 * of the owner of the directory and of the owner of the parent directory.
871 * The quota structure is possibly deleted only on last iput => outside
872 * of this transaction */
874 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
875 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
877 reiserfs_write_lock(dir->i_sb);
878 retval = journal_begin(&th, dir->i_sb, jbegin_count);
882 de.de_gen_number_bit_string = NULL;
884 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
885 &path, &de)) == NAME_NOT_FOUND) {
888 } else if (retval == IO_ERROR) {
893 inode = dentry->d_inode;
895 reiserfs_update_inode_transaction(inode);
896 reiserfs_update_inode_transaction(dir);
898 if (de.de_objectid != inode->i_ino) {
899 // FIXME: compare key of an object and a key found in the
904 if (!reiserfs_empty_dir(inode)) {
909 /* cut entry from dir directory */
910 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL, /* page */
911 0 /*new file size - not used here */ );
915 if (inode->i_nlink != 2 && inode->i_nlink != 1)
916 reiserfs_warning(inode->i_sb, "%s: empty directory has nlink "
917 "!= 2 (%d)", __FUNCTION__, inode->i_nlink);
920 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
921 reiserfs_update_sd(&th, inode);
923 DEC_DIR_INODE_NLINK(dir)
924 dir->i_size -= (DEH_SIZE + de.de_entrylen);
925 reiserfs_update_sd(&th, dir);
927 /* prevent empty directory from getting lost */
928 add_save_link(&th, inode, 0 /* not truncate */ );
930 retval = journal_end(&th, dir->i_sb, jbegin_count);
931 reiserfs_check_path(&path);
933 reiserfs_write_unlock(dir->i_sb);
937 /* we must release path, because we did not call
938 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
939 release path if operation was not complete */
941 err = journal_end(&th, dir->i_sb, jbegin_count);
942 reiserfs_write_unlock(dir->i_sb);
943 return err ? err : retval;
946 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
950 struct reiserfs_dir_entry de;
951 INITIALIZE_PATH(path);
952 struct reiserfs_transaction_handle th;
954 unsigned long savelink;
956 inode = dentry->d_inode;
958 /* in this transaction we can be doing at max two balancings and update
959 * two stat datas, we change quotas of the owner of the directory and of
960 * the owner of the parent directory. The quota structure is possibly
961 * deleted only on iput => outside of this transaction */
963 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
964 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
966 reiserfs_write_lock(dir->i_sb);
967 retval = journal_begin(&th, dir->i_sb, jbegin_count);
971 de.de_gen_number_bit_string = NULL;
973 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
974 &path, &de)) == NAME_NOT_FOUND) {
977 } else if (retval == IO_ERROR) {
982 reiserfs_update_inode_transaction(inode);
983 reiserfs_update_inode_transaction(dir);
985 if (de.de_objectid != inode->i_ino) {
986 // FIXME: compare key of an object and a key found in the
992 if (!inode->i_nlink) {
993 reiserfs_warning(inode->i_sb, "%s: deleting nonexistent file "
994 "(%s:%lu), %d", __FUNCTION__,
995 reiserfs_bdevname(inode->i_sb), inode->i_ino,
1003 * we schedule before doing the add_save_link call, save the link
1004 * count so we don't race
1006 savelink = inode->i_nlink;
1009 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
1015 inode->i_ctime = CURRENT_TIME_SEC;
1016 reiserfs_update_sd(&th, inode);
1018 dir->i_size -= (de.de_entrylen + DEH_SIZE);
1019 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
1020 reiserfs_update_sd(&th, dir);
1023 /* prevent file from getting lost */
1024 add_save_link(&th, inode, 0 /* not truncate */ );
1026 retval = journal_end(&th, dir->i_sb, jbegin_count);
1027 reiserfs_check_path(&path);
1028 reiserfs_write_unlock(dir->i_sb);
1033 err = journal_end(&th, dir->i_sb, jbegin_count);
1034 reiserfs_check_path(&path);
1038 reiserfs_write_unlock(dir->i_sb);
1042 static int reiserfs_symlink(struct inode *parent_dir,
1043 struct dentry *dentry, const char *symname)
1046 struct inode *inode;
1049 struct reiserfs_transaction_handle th;
1050 int mode = S_IFLNK | S_IRWXUGO;
1051 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1053 JOURNAL_PER_BALANCE_CNT * 3 +
1054 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1055 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1057 if (!(inode = new_inode(parent_dir->i_sb))) {
1060 new_inode_init(inode, parent_dir, mode);
1062 reiserfs_write_lock(parent_dir->i_sb);
1063 item_len = ROUND_UP(strlen(symname));
1064 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1065 retval = -ENAMETOOLONG;
1066 drop_new_inode(inode);
1070 name = kmalloc(item_len, GFP_NOFS);
1072 drop_new_inode(inode);
1076 memcpy(name, symname, strlen(symname));
1077 padd_item(name, item_len, strlen(symname));
1079 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1081 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1083 drop_new_inode(inode);
1089 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1092 if (retval) { /* reiserfs_new_inode iputs for us */
1096 reiserfs_update_inode_transaction(inode);
1097 reiserfs_update_inode_transaction(parent_dir);
1099 inode->i_op = &reiserfs_symlink_inode_operations;
1100 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1102 // must be sure this inode is written with this transaction
1104 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1106 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1107 dentry->d_name.len, inode, 1 /*visible */ );
1111 reiserfs_update_sd(&th, inode);
1112 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1119 d_instantiate(dentry, inode);
1120 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1122 reiserfs_write_unlock(parent_dir->i_sb);
1126 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1127 struct dentry *dentry)
1130 struct inode *inode = old_dentry->d_inode;
1131 struct reiserfs_transaction_handle th;
1132 /* We need blocks for transaction + update of quotas for the owners of the directory */
1134 JOURNAL_PER_BALANCE_CNT * 3 +
1135 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1137 reiserfs_write_lock(dir->i_sb);
1138 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1139 //FIXME: sd_nlink is 32 bit for new files
1140 reiserfs_write_unlock(dir->i_sb);
1143 if (inode->i_nlink == 0) {
1144 reiserfs_write_unlock(dir->i_sb);
1148 /* inc before scheduling so reiserfs_unlink knows we are here */
1151 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1154 reiserfs_write_unlock(dir->i_sb);
1158 /* create new entry */
1160 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1161 dentry->d_name.len, inode, 1 /*visible */ );
1163 reiserfs_update_inode_transaction(inode);
1164 reiserfs_update_inode_transaction(dir);
1169 err = journal_end(&th, dir->i_sb, jbegin_count);
1170 reiserfs_write_unlock(dir->i_sb);
1171 return err ? err : retval;
1174 inode->i_ctime = CURRENT_TIME_SEC;
1175 reiserfs_update_sd(&th, inode);
1177 atomic_inc(&inode->i_count);
1178 d_instantiate(dentry, inode);
1179 retval = journal_end(&th, dir->i_sb, jbegin_count);
1180 reiserfs_write_unlock(dir->i_sb);
1184 // de contains information pointing to an entry which
1185 static int de_still_valid(const char *name, int len,
1186 struct reiserfs_dir_entry *de)
1188 struct reiserfs_dir_entry tmp = *de;
1190 // recalculate pointer to name and name length
1191 set_de_name_and_namelen(&tmp);
1192 // FIXME: could check more
1193 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1198 static int entry_points_to_object(const char *name, int len,
1199 struct reiserfs_dir_entry *de,
1200 struct inode *inode)
1202 if (!de_still_valid(name, len, de))
1206 if (!de_visible(de->de_deh + de->de_entry_num))
1207 reiserfs_panic(NULL,
1208 "vs-7042: entry_points_to_object: entry must be visible");
1209 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1212 /* this must be added hidden entry */
1213 if (de_visible(de->de_deh + de->de_entry_num))
1214 reiserfs_panic(NULL,
1215 "vs-7043: entry_points_to_object: entry must be visible");
1220 /* sets key of objectid the entry has to point to */
1221 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1222 struct reiserfs_key *key)
1224 /* JDM These operations are endian safe - both are le */
1225 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1226 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1230 * process, that is going to call fix_nodes/do_balance must hold only
1231 * one path. If it holds 2 or more, it can get into endless waiting in
1232 * get_empty_nodes or its clones
1234 static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1235 struct inode *new_dir, struct dentry *new_dentry)
1238 INITIALIZE_PATH(old_entry_path);
1239 INITIALIZE_PATH(new_entry_path);
1240 INITIALIZE_PATH(dot_dot_entry_path);
1241 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1242 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1243 struct inode *old_inode, *new_dentry_inode;
1244 struct reiserfs_transaction_handle th;
1246 umode_t old_inode_mode;
1247 unsigned long savelink = 1;
1248 struct timespec ctime;
1250 /* three balancings: (1) old name removal, (2) new name insertion
1251 and (3) maybe "save" link insertion
1252 stat data updates: (1) old directory,
1253 (2) new directory and (3) maybe old object stat data (when it is
1254 directory) and (4) maybe stat data of object to which new entry
1255 pointed initially and (5) maybe block containing ".." of
1257 quota updates: two parent directories */
1259 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1260 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1262 old_inode = old_dentry->d_inode;
1263 new_dentry_inode = new_dentry->d_inode;
1265 // make sure, that oldname still exists and points to an object we
1266 // are going to rename
1267 old_de.de_gen_number_bit_string = NULL;
1268 reiserfs_write_lock(old_dir->i_sb);
1270 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1271 old_dentry->d_name.len, &old_entry_path,
1273 pathrelse(&old_entry_path);
1274 if (retval == IO_ERROR) {
1275 reiserfs_write_unlock(old_dir->i_sb);
1279 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1280 reiserfs_write_unlock(old_dir->i_sb);
1284 old_inode_mode = old_inode->i_mode;
1285 if (S_ISDIR(old_inode_mode)) {
1286 // make sure, that directory being renamed has correct ".."
1287 // and that its new parent directory has not too many links
1290 if (new_dentry_inode) {
1291 if (!reiserfs_empty_dir(new_dentry_inode)) {
1292 reiserfs_write_unlock(old_dir->i_sb);
1297 /* directory is renamed, its parent directory will be changed,
1298 ** so find ".." entry
1300 dot_dot_de.de_gen_number_bit_string = NULL;
1302 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1304 pathrelse(&dot_dot_entry_path);
1305 if (retval != NAME_FOUND) {
1306 reiserfs_write_unlock(old_dir->i_sb);
1310 /* inode number of .. must equal old_dir->i_ino */
1311 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1312 reiserfs_write_unlock(old_dir->i_sb);
1317 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1319 reiserfs_write_unlock(old_dir->i_sb);
1323 /* add new entry (or find the existing one) */
1325 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1326 new_dentry->d_name.len, old_inode, 0);
1327 if (retval == -EEXIST) {
1328 if (!new_dentry_inode) {
1329 reiserfs_panic(old_dir->i_sb,
1330 "vs-7050: new entry is found, new inode == 0\n");
1332 } else if (retval) {
1333 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1334 reiserfs_write_unlock(old_dir->i_sb);
1335 return err ? err : retval;
1338 reiserfs_update_inode_transaction(old_dir);
1339 reiserfs_update_inode_transaction(new_dir);
1341 /* this makes it so an fsync on an open fd for the old name will
1342 ** commit the rename operation
1344 reiserfs_update_inode_transaction(old_inode);
1346 if (new_dentry_inode)
1347 reiserfs_update_inode_transaction(new_dentry_inode);
1350 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1352 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1354 &old_de)) != NAME_FOUND) {
1355 pathrelse(&old_entry_path);
1356 journal_end(&th, old_dir->i_sb, jbegin_count);
1357 reiserfs_write_unlock(old_dir->i_sb);
1361 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
1363 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1365 // look for new name by reiserfs_find_entry
1366 new_de.de_gen_number_bit_string = NULL;
1368 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1369 new_dentry->d_name.len, &new_entry_path,
1371 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1372 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1373 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1374 pathrelse(&new_entry_path);
1375 pathrelse(&old_entry_path);
1376 journal_end(&th, old_dir->i_sb, jbegin_count);
1377 reiserfs_write_unlock(old_dir->i_sb);
1381 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1383 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1385 if (S_ISDIR(old_inode->i_mode)) {
1387 search_by_entry_key(new_dir->i_sb,
1388 &dot_dot_de.de_entry_key,
1389 &dot_dot_entry_path,
1390 &dot_dot_de)) != NAME_FOUND) {
1391 pathrelse(&dot_dot_entry_path);
1392 pathrelse(&new_entry_path);
1393 pathrelse(&old_entry_path);
1394 journal_end(&th, old_dir->i_sb, jbegin_count);
1395 reiserfs_write_unlock(old_dir->i_sb);
1398 copy_item_head(&dot_dot_ih,
1399 get_ih(&dot_dot_entry_path));
1400 // node containing ".." gets into transaction
1401 reiserfs_prepare_for_journal(old_inode->i_sb,
1402 dot_dot_de.de_bh, 1);
1404 /* we should check seals here, not do
1405 this stuff, yes? Then, having
1406 gathered everything into RAM we
1407 should lock the buffers, yes? -Hans */
1408 /* probably. our rename needs to hold more
1409 ** than one path at once. The seals would
1410 ** have to be written to deal with multi-path
1413 /* sanity checking before doing the rename - avoid races many
1414 ** of the above checks could have scheduled. We have to be
1415 ** sure our items haven't been shifted by another process.
1417 if (item_moved(&new_entry_ih, &new_entry_path) ||
1418 !entry_points_to_object(new_dentry->d_name.name,
1419 new_dentry->d_name.len,
1420 &new_de, new_dentry_inode) ||
1421 item_moved(&old_entry_ih, &old_entry_path) ||
1422 !entry_points_to_object(old_dentry->d_name.name,
1423 old_dentry->d_name.len,
1424 &old_de, old_inode)) {
1425 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1427 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1429 if (S_ISDIR(old_inode_mode))
1430 reiserfs_restore_prepared_buffer(old_inode->
1436 if (S_ISDIR(old_inode_mode)) {
1437 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1438 !entry_points_to_object("..", 2, &dot_dot_de,
1440 reiserfs_restore_prepared_buffer(old_inode->
1443 reiserfs_restore_prepared_buffer(old_inode->
1446 reiserfs_restore_prepared_buffer(old_inode->
1454 RFALSE(S_ISDIR(old_inode_mode) &&
1455 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1460 /* ok, all the changes can be done in one fell swoop when we
1461 have claimed all the buffers needed. */
1463 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1464 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1465 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1467 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1468 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1469 ctime = CURRENT_TIME_SEC;
1470 old_dir->i_ctime = old_dir->i_mtime = ctime;
1471 new_dir->i_ctime = new_dir->i_mtime = ctime;
1472 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1474 old_inode->i_ctime = ctime;
1476 if (new_dentry_inode) {
1477 // adjust link number of the victim
1478 if (S_ISDIR(new_dentry_inode->i_mode)) {
1479 new_dentry_inode->i_nlink = 0;
1481 new_dentry_inode->i_nlink--;
1483 new_dentry_inode->i_ctime = ctime;
1484 savelink = new_dentry_inode->i_nlink;
1487 if (S_ISDIR(old_inode_mode)) {
1488 // adjust ".." of renamed directory
1489 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1490 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1492 if (!new_dentry_inode)
1493 /* there (in new_dir) was no directory, so it got new link
1494 (".." of renamed directory) */
1495 INC_DIR_INODE_NLINK(new_dir);
1497 /* old directory lost one link - ".. " of renamed directory */
1498 DEC_DIR_INODE_NLINK(old_dir);
1500 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1501 pathrelse(&new_entry_path);
1502 pathrelse(&dot_dot_entry_path);
1504 // FIXME: this reiserfs_cut_from_item's return value may screw up
1505 // anybody, but it will panic if will not be able to find the
1506 // entry. This needs one more clean up
1507 if (reiserfs_cut_from_item
1508 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1510 reiserfs_warning(old_dir->i_sb,
1511 "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
1513 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1515 reiserfs_update_sd(&th, old_dir);
1516 reiserfs_update_sd(&th, new_dir);
1517 reiserfs_update_sd(&th, old_inode);
1519 if (new_dentry_inode) {
1521 add_save_link(&th, new_dentry_inode,
1522 0 /* not truncate */ );
1523 reiserfs_update_sd(&th, new_dentry_inode);
1526 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1527 reiserfs_write_unlock(old_dir->i_sb);
1532 * directories can handle most operations...
1534 struct inode_operations reiserfs_dir_inode_operations = {
1535 //&reiserfs_dir_operations, /* default_file_ops */
1536 .create = reiserfs_create,
1537 .lookup = reiserfs_lookup,
1538 .link = reiserfs_link,
1539 .unlink = reiserfs_unlink,
1540 .symlink = reiserfs_symlink,
1541 .mkdir = reiserfs_mkdir,
1542 .rmdir = reiserfs_rmdir,
1543 .mknod = reiserfs_mknod,
1544 .rename = reiserfs_rename,
1545 .setattr = reiserfs_setattr,
1546 .setxattr = reiserfs_setxattr,
1547 .getxattr = reiserfs_getxattr,
1548 .listxattr = reiserfs_listxattr,
1549 .removexattr = reiserfs_removexattr,
1550 .permission = reiserfs_permission,
1551 .sync_flags = reiserfs_sync_flags,
1555 * symlink operations.. same as page_symlink_inode_operations, with xattr
1558 struct inode_operations reiserfs_symlink_inode_operations = {
1559 .readlink = generic_readlink,
1560 .follow_link = page_follow_link_light,
1561 .put_link = page_put_link,
1562 .setattr = reiserfs_setattr,
1563 .setxattr = reiserfs_setxattr,
1564 .getxattr = reiserfs_getxattr,
1565 .listxattr = reiserfs_listxattr,
1566 .removexattr = reiserfs_removexattr,
1567 .permission = reiserfs_permission,
1568 .sync_flags = reiserfs_sync_flags,
1573 * special file operations.. just xattr/acl stuff
1575 struct inode_operations reiserfs_special_inode_operations = {
1576 .setattr = reiserfs_setattr,
1577 .setxattr = reiserfs_setxattr,
1578 .getxattr = reiserfs_getxattr,
1579 .listxattr = reiserfs_listxattr,
1580 .removexattr = reiserfs_removexattr,
1581 .permission = reiserfs_permission,
1582 .sync_flags = reiserfs_sync_flags,