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; 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;
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, struct path * path)
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);
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);
83 // what entry points to
84 static inline void set_de_object_key (struct reiserfs_dir_entry * de)
86 if (de->de_entry_num >= ih_entry_count (de->de_ih))
88 de->de_dir_id = deh_dir_id( &(de->de_deh[de->de_entry_num]));
89 de->de_objectid = deh_objectid( &(de->de_deh[de->de_entry_num]));
93 static inline void store_de_entry_key (struct reiserfs_dir_entry * de)
95 struct reiserfs_de_head * deh = de->de_deh + de->de_entry_num;
97 if (de->de_entry_num >= ih_entry_count (de->de_ih))
100 /* store key of the found entry */
101 de->de_entry_key.version = KEY_FORMAT_3_5;
102 de->de_entry_key.on_disk_key.k_dir_id = le32_to_cpu (de->de_ih->ih_key.k_dir_id);
103 de->de_entry_key.on_disk_key.k_objectid = 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);
109 /* We assign a key to each directory item, and place multiple entries
110 in a single directory item. A directory item has a key equal to the
111 key of the first directory entry in it.
113 This function first calls search_by_key, then, if item whose first
114 entry matches is not found it looks for the entry inside directory
115 item found by search_by_key. Fills the path to the entry, and to the
116 entry position in the item
120 /* The function is NOT SCHEDULE-SAFE! */
121 int search_by_entry_key (struct super_block * sb, const struct cpu_key * key,
122 struct path * path, struct reiserfs_dir_entry * de)
126 retval = search_item (sb, key, path);
129 if (!PATH_LAST_POSITION (path)) {
130 reiserfs_warning (sb, "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
134 PATH_LAST_POSITION (path) --;
144 reiserfs_warning (sb, "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);
154 reiserfs_panic (sb, "vs-7005: search_by_entry_key: found item %h is not directory item or "
155 "does not belong to the same directory as key %K", de->de_ih, key);
157 #endif /* CONFIG_REISERFS_CHECK */
159 /* binary search in directory item by third componen t of the
160 key. sets de->de_entry_num of de */
161 retval = bin_search_in_dir_item (de, cpu_key_k_offset (key));
162 path->pos_in_item = de->de_entry_num;
163 if (retval != NAME_NOT_FOUND) {
164 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
165 set_de_name_and_namelen (de);
166 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;
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))
209 retval = (de_visible (de->de_deh + de->de_entry_num) ? NAME_FOUND : 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 */
220 static int linear_search_in_dir_item (struct cpu_key * key, 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)) != GET_HASH_VALUE (cpu_key_k_offset (key))) {
234 RFALSE( de->de_deh != B_I_DEH (de->de_bh, de->de_ih),
235 "vs-7010: array of entry headers not found");
239 for (; i >= 0; i --, deh --) {
240 if (GET_HASH_VALUE (deh_offset (deh)) !=
241 GET_HASH_VALUE (cpu_key_k_offset (key))) {
242 // hash value does not match, no need to check whole name
243 return NAME_NOT_FOUND;
246 /* mark, that this generation number is used */
247 if (de->de_gen_number_bit_string)
248 set_bit (GET_GENERATION_NUMBER (deh_offset (deh)), (unsigned long *)de->de_gen_number_bit_string);
250 // calculate pointer to name and namelen
251 de->de_entry_num = i;
252 set_de_name_and_namelen (de);
254 if ((retval = reiserfs_match (de, name, namelen)) != NAME_NOT_FOUND) {
255 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
257 // key of pointed object
258 set_de_object_key (de);
260 store_de_entry_key (de);
262 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
267 if (GET_GENERATION_NUMBER (le_ih_k_offset (de->de_ih)) == 0)
268 /* we have reached left most entry in the node. In common we
269 have to go to the left neighbor, but if generation counter
270 is 0 already, we know for sure, that there is no name with
271 the same hash value */
272 // FIXME: this work correctly only because hash value can not
273 // be 0. Btw, in case of Yura's hash it is probably possible,
275 return NAME_NOT_FOUND;
277 RFALSE( de->de_item_num,
278 "vs-7015: two diritems of the same directory in one node?");
280 return GOTO_PREVIOUS_ITEM;
284 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
285 // FIXME: should add something like IOERROR
286 static int reiserfs_find_entry (struct inode * dir, const char * name, int namelen,
287 struct path * path_to_entry, struct reiserfs_dir_entry * de)
289 struct cpu_key key_to_search;
293 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize))
294 return NAME_NOT_FOUND;
296 /* we will search for this key in the tree */
297 make_cpu_key (&key_to_search, dir,
298 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3);
301 retval = search_by_entry_key (dir->i_sb, &key_to_search, path_to_entry, de);
302 if (retval == IO_ERROR) {
303 reiserfs_warning (dir->i_sb, "zam-7001: io error in %s",
308 /* compare names for all entries having given hash value */
309 retval = linear_search_in_dir_item (&key_to_search, de, name, namelen);
310 if (retval != GOTO_PREVIOUS_ITEM) {
311 /* there is no need to scan directory anymore. Given entry found or does not exist */
312 path_to_entry->pos_in_item = de->de_entry_num;
316 /* there is left neighboring item of this directory and given entry can be there */
317 set_cpu_key_k_offset (&key_to_search, le_ih_k_offset (de->de_ih) - 1);
318 pathrelse (path_to_entry);
324 static struct dentry * reiserfs_lookup (struct inode * dir, struct dentry * dentry, 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;
336 retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de);
337 pathrelse (&path_to_entry);
338 if (retval == NAME_FOUND) {
339 /* Hide the .reiserfs_priv directory */
340 if (reiserfs_xattrs (dir->i_sb) &&
341 !old_format_only(dir->i_sb) &&
342 REISERFS_SB(dir->i_sb)->priv_root &&
343 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
344 de.de_objectid == le32_to_cpu (INODE_PKEY(REISERFS_SB(dir->i_sb)->priv_root->d_inode)->k_objectid)) {
345 reiserfs_write_unlock (dir->i_sb);
346 return ERR_PTR (-EACCES);
349 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
350 if (!inode || IS_ERR(inode)) {
351 reiserfs_write_unlock(dir->i_sb);
352 return ERR_PTR(-EACCES);
354 vx_propagate_xid(nd, inode);
356 /* Propogate the priv_object flag so we know we're in the priv tree */
357 if (is_reiserfs_priv_object (dir))
358 reiserfs_mark_inode_private (inode);
360 reiserfs_write_unlock(dir->i_sb);
361 if ( retval == IO_ERROR ) {
362 return ERR_PTR(-EIO);
366 return d_splice_alias(inode, dentry);
368 d_add(dentry, inode);
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 dentry *parent;
384 struct inode *dir = child->d_inode ;
387 if (dir->i_nlink == 0) {
388 return ERR_PTR(-ENOENT);
390 de.de_gen_number_bit_string = NULL;
392 reiserfs_write_lock(dir->i_sb);
393 retval = reiserfs_find_entry (dir, "..", 2, &path_to_entry, &de);
394 pathrelse (&path_to_entry);
395 if (retval != NAME_FOUND) {
396 reiserfs_write_unlock(dir->i_sb);
397 return ERR_PTR(-ENOENT);
399 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
400 reiserfs_write_unlock(dir->i_sb);
402 if (!inode || IS_ERR(inode)) {
403 return ERR_PTR(-EACCES);
405 parent = d_alloc_anon(inode);
408 parent = ERR_PTR(-ENOMEM);
414 /* add entry to the directory (entry can be hidden).
416 insert definition of when hidden directories are used here -Hans
418 Does not mark dir inode dirty, do it after successesfull call to it */
420 static int reiserfs_add_entry (struct reiserfs_transaction_handle *th, struct inode * dir,
421 const char * name, int namelen, struct inode * inode,
424 struct cpu_key entry_key;
425 struct reiserfs_de_head * deh;
426 INITIALIZE_PATH (path);
427 struct reiserfs_dir_entry de;
428 int bit_string [MAX_GENERATION_NUMBER / (sizeof(int) * 8) + 1];
430 char small_buf[32+DEH_SIZE] ; /* 48 bytes now and we avoid kmalloc
431 if we create file with short name */
433 int buflen, paste_size;
436 BUG_ON (!th->t_trans_id);
438 /* cannot allow items to be added into a busy deleted directory */
442 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize))
443 return -ENAMETOOLONG;
445 /* each entry has unique key. compose it */
446 make_cpu_key (&entry_key, dir,
447 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3);
449 /* get memory for composing the entry */
450 buflen = DEH_SIZE + ROUND_UP (namelen);
451 if (buflen > sizeof (small_buf)) {
452 buffer = reiserfs_kmalloc (buflen, GFP_NOFS, dir->i_sb);
458 paste_size = (get_inode_sd_version (dir) == STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
460 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
461 deh = (struct reiserfs_de_head *)buffer;
462 deh->deh_location = 0; /* JDM Endian safe if 0 */
463 put_deh_offset( deh, cpu_key_k_offset( &entry_key ) );
464 deh->deh_state = 0; /* JDM Endian safe if 0 */
465 /* put key (ino analog) to de */
466 deh->deh_dir_id = INODE_PKEY (inode)->k_dir_id; /* safe: k_dir_id is le */
467 deh->deh_objectid = INODE_PKEY (inode)->k_objectid; /* safe: k_objectid is le */
470 memcpy ((char *)(deh + 1), name, namelen);
471 /* padd by 0s to the 4 byte boundary */
472 padd_item ((char *)(deh + 1), ROUND_UP (namelen), namelen);
474 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
475 mark_de_without_sd (deh);
476 visible ? mark_de_visible (deh) : mark_de_hidden (deh);
478 /* find the proper place for the new entry */
479 memset (bit_string, 0, sizeof (bit_string));
480 de.de_gen_number_bit_string = (char *)bit_string;
481 retval = reiserfs_find_entry (dir, name, namelen, &path, &de);
482 if( retval != NAME_NOT_FOUND ) {
483 if (buffer != small_buf)
484 reiserfs_kfree (buffer, buflen, dir->i_sb);
487 if ( retval == IO_ERROR ) {
491 if (retval != NAME_FOUND) {
492 reiserfs_warning (dir->i_sb, "zam-7002:%s: \"reiserfs_find_entry\" "
493 "has returned unexpected value (%d)",
494 __FUNCTION__, retval);
500 gen_number = find_first_zero_bit ((unsigned long *)bit_string, MAX_GENERATION_NUMBER + 1);
501 if (gen_number > MAX_GENERATION_NUMBER) {
502 /* there is no free generation number */
503 reiserfs_warning (dir->i_sb, "reiserfs_add_entry: Congratulations! we have got hash function screwed up");
504 if (buffer != small_buf)
505 reiserfs_kfree (buffer, buflen, dir->i_sb);
509 /* adjust offset of directory enrty */
510 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
511 set_cpu_key_k_offset (&entry_key, deh_offset(deh));
513 /* update max-hash-collisions counter in reiserfs_sb_info */
514 PROC_INFO_MAX( th -> t_super, max_hash_collisions, gen_number );
516 if (gen_number != 0) { /* we need to re-search for the insertion point */
517 if (search_by_entry_key (dir->i_sb, &entry_key, &path, &de) != NAME_NOT_FOUND) {
518 reiserfs_warning (dir->i_sb, "vs-7032: reiserfs_add_entry: "
519 "entry with this key (%K) already exists",
522 if (buffer != small_buf)
523 reiserfs_kfree (buffer, buflen, dir->i_sb);
529 /* perform the insertion of the entry that we have prepared */
530 retval = reiserfs_paste_into_item (th, &path, &entry_key, dir, buffer, paste_size);
531 if (buffer != small_buf)
532 reiserfs_kfree (buffer, buflen, dir->i_sb);
534 reiserfs_check_path(&path) ;
538 dir->i_size += paste_size;
539 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
540 if (!S_ISDIR (inode->i_mode) && visible)
541 // reiserfs_mkdir or reiserfs_rename will do that by itself
542 reiserfs_update_sd (th, dir);
544 reiserfs_check_path(&path) ;
548 /* quota utility function, call if you've had to abort after calling
549 ** new_inode_init, and have not called reiserfs_new_inode yet.
550 ** This should only be called on inodes that do not have stat data
551 ** inserted into the tree yet.
553 static int drop_new_inode(struct inode *inode) {
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) {
568 /* the quota init calls have to know who to charge the quota to, so
569 ** we have to set uid and gid here
571 inode->i_uid = current->fsuid;
572 inode->i_mode = mode;
574 if (dir->i_mode & S_ISGID) {
575 inode->i_gid = dir->i_gid;
577 inode->i_mode |= S_ISGID;
579 inode->i_gid = current->fsgid;
581 inode->i_xid = vx_current_fsxid(inode->i_sb);
586 static int reiserfs_create (struct inode * dir, struct dentry *dentry, int mode,
587 struct nameidata *nd)
590 struct inode * inode;
591 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
592 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
593 struct reiserfs_transaction_handle th ;
596 if (!(inode = new_inode(dir->i_sb))) {
599 new_inode_init(inode, dir, mode);
601 locked = reiserfs_cache_default_acl (dir);
603 reiserfs_write_lock(dir->i_sb);
606 reiserfs_write_lock_xattrs (dir->i_sb);
608 retval = journal_begin(&th, dir->i_sb, jbegin_count);
610 drop_new_inode (inode);
614 retval = reiserfs_new_inode (&th, dir, mode, NULL, 0/*i_size*/, dentry, inode);
619 reiserfs_write_unlock_xattrs (dir->i_sb);
623 inode->i_op = &reiserfs_file_inode_operations;
624 inode->i_fop = &reiserfs_file_operations;
625 inode->i_mapping->a_ops = &reiserfs_address_space_operations ;
627 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
628 inode, 1/*visible*/);
632 reiserfs_update_sd (&th, inode);
633 err = journal_end(&th, dir->i_sb, jbegin_count) ;
639 reiserfs_update_inode_transaction(inode) ;
640 reiserfs_update_inode_transaction(dir) ;
642 d_instantiate(dentry, inode);
643 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
647 reiserfs_write_unlock_xattrs (dir->i_sb);
648 reiserfs_write_unlock(dir->i_sb);
653 static int reiserfs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
656 struct inode * inode;
657 struct reiserfs_transaction_handle th ;
658 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
659 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
662 if (!new_valid_dev(rdev))
665 if (!(inode = new_inode(dir->i_sb))) {
668 new_inode_init(inode, dir, mode);
670 locked = reiserfs_cache_default_acl (dir);
672 reiserfs_write_lock(dir->i_sb);
675 reiserfs_write_lock_xattrs (dir->i_sb);
677 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
679 drop_new_inode (inode);
683 retval = reiserfs_new_inode (&th, dir, mode, NULL, 0/*i_size*/, dentry, inode);
689 reiserfs_write_unlock_xattrs (dir->i_sb);
694 inode->i_op = &reiserfs_special_inode_operations;
695 init_special_inode(inode, inode->i_mode, rdev) ;
697 //FIXME: needed for block and char devices only
698 reiserfs_update_sd (&th, inode);
700 reiserfs_update_inode_transaction(inode) ;
701 reiserfs_update_inode_transaction(dir) ;
703 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
704 inode, 1/*visible*/);
708 reiserfs_update_sd (&th, inode);
709 err = journal_end(&th, dir->i_sb, jbegin_count) ;
716 d_instantiate(dentry, inode);
717 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
721 reiserfs_write_unlock_xattrs (dir->i_sb);
722 reiserfs_write_unlock(dir->i_sb);
727 static int reiserfs_mkdir (struct inode * dir, struct dentry *dentry, int mode)
730 struct inode * inode;
731 struct reiserfs_transaction_handle th ;
732 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
733 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
736 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
737 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
738 REISERFS_I(dir)->new_packing_locality = 1;
740 mode = S_IFDIR | mode;
741 if (!(inode = new_inode(dir->i_sb))) {
744 new_inode_init(inode, dir, mode);
746 locked = reiserfs_cache_default_acl (dir);
748 reiserfs_write_lock(dir->i_sb);
750 reiserfs_write_lock_xattrs (dir->i_sb);
752 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
754 drop_new_inode (inode);
759 /* inc the link count now, so another writer doesn't overflow it while
760 ** we sleep later on.
762 INC_DIR_INODE_NLINK(dir)
764 retval = reiserfs_new_inode (&th, dir, mode, NULL/*symlink*/,
765 old_format_only (dir->i_sb) ?
766 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
774 reiserfs_write_unlock_xattrs (dir->i_sb);
778 reiserfs_update_inode_transaction(inode) ;
779 reiserfs_update_inode_transaction(dir) ;
781 inode->i_op = &reiserfs_dir_inode_operations;
782 inode->i_fop = &reiserfs_dir_operations;
784 // note, _this_ add_entry will not update dir's stat data
785 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
786 inode, 1/*visible*/);
790 DEC_DIR_INODE_NLINK(dir);
791 reiserfs_update_sd (&th, inode);
792 err = journal_end(&th, dir->i_sb, jbegin_count) ;
799 // the above add_entry did not update dir's stat data
800 reiserfs_update_sd (&th, dir);
802 d_instantiate(dentry, inode);
803 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
806 reiserfs_write_unlock_xattrs (dir->i_sb);
807 reiserfs_write_unlock(dir->i_sb);
811 static inline int reiserfs_empty_dir(struct inode *inode) {
812 /* we can cheat because an old format dir cannot have
813 ** EMPTY_DIR_SIZE, and a new format dir cannot have
814 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
815 ** regardless of disk format version, the directory is empty.
817 if (inode->i_size != EMPTY_DIR_SIZE &&
818 inode->i_size != EMPTY_DIR_SIZE_V1) {
824 static int reiserfs_rmdir (struct inode * dir, struct dentry *dentry)
827 struct inode * inode;
828 struct reiserfs_transaction_handle th ;
830 INITIALIZE_PATH (path);
831 struct reiserfs_dir_entry de;
834 /* we will be doing 2 balancings and update 2 stat data, we change quotas
835 * of the owner of the directory and of the owner of the parent directory */
836 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
838 reiserfs_write_lock(dir->i_sb);
839 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
843 de.de_gen_number_bit_string = NULL;
844 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
847 } else if ( retval == IO_ERROR) {
852 inode = dentry->d_inode;
854 reiserfs_update_inode_transaction(inode) ;
855 reiserfs_update_inode_transaction(dir) ;
857 if (de.de_objectid != inode->i_ino) {
858 // FIXME: compare key of an object and a key found in the
863 if (!reiserfs_empty_dir(inode)) {
868 /* cut entry from dir directory */
869 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir,
871 0/*new file size - not used here*/);
875 if ( inode->i_nlink != 2 && inode->i_nlink != 1 )
876 reiserfs_warning (inode->i_sb, "%s: empty directory has nlink "
877 "!= 2 (%d)", __FUNCTION__, inode->i_nlink);
880 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
881 reiserfs_update_sd (&th, inode);
883 DEC_DIR_INODE_NLINK(dir)
884 dir->i_size -= (DEH_SIZE + de.de_entrylen);
885 reiserfs_update_sd (&th, dir);
887 /* prevent empty directory from getting lost */
888 add_save_link (&th, inode, 0/* not truncate */);
890 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
891 reiserfs_check_path(&path) ;
893 reiserfs_write_unlock(dir->i_sb);
897 /* we must release path, because we did not call
898 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
899 release path if operation was not complete */
901 err = journal_end(&th, dir->i_sb, jbegin_count) ;
902 reiserfs_write_unlock(dir->i_sb);
903 return err ? err : retval;
906 static int reiserfs_unlink (struct inode * dir, struct dentry *dentry)
909 struct inode * inode;
910 struct reiserfs_dir_entry de;
911 INITIALIZE_PATH (path);
912 struct reiserfs_transaction_handle th ;
914 unsigned long savelink;
916 inode = dentry->d_inode;
918 /* in this transaction we can be doing at max two balancings and update
919 two stat datas, we change quotas of the owner of the directory and of
920 the owner of the parent directory */
921 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
923 reiserfs_write_lock(dir->i_sb);
924 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
928 de.de_gen_number_bit_string = NULL;
929 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
932 } else if (retval == IO_ERROR) {
937 reiserfs_update_inode_transaction(inode) ;
938 reiserfs_update_inode_transaction(dir) ;
940 if (de.de_objectid != inode->i_ino) {
941 // FIXME: compare key of an object and a key found in the
947 if (!inode->i_nlink) {
948 reiserfs_warning (inode->i_sb, "%s: deleting nonexistent file "
949 "(%s:%lu), %d", __FUNCTION__,
950 reiserfs_bdevname (inode->i_sb), inode->i_ino,
958 * we schedule before doing the add_save_link call, save the link
959 * count so we don't race
961 savelink = inode->i_nlink;
964 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir, NULL, 0);
969 inode->i_ctime = CURRENT_TIME_SEC;
970 reiserfs_update_sd (&th, inode);
972 dir->i_size -= (de.de_entrylen + DEH_SIZE);
973 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
974 reiserfs_update_sd (&th, dir);
977 /* prevent file from getting lost */
978 add_save_link (&th, inode, 0/* not truncate */);
980 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
981 reiserfs_check_path(&path) ;
982 reiserfs_write_unlock(dir->i_sb);
987 err = journal_end(&th, dir->i_sb, jbegin_count) ;
988 reiserfs_check_path(&path) ;
992 reiserfs_write_unlock(dir->i_sb);
996 static int reiserfs_symlink (struct inode * parent_dir,
997 struct dentry * dentry, const char * symname)
1000 struct inode * inode;
1003 struct reiserfs_transaction_handle th ;
1004 int mode = S_IFLNK | S_IRWXUGO;
1005 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1006 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
1008 if (!(inode = new_inode(parent_dir->i_sb))) {
1011 new_inode_init(inode, parent_dir, mode);
1013 reiserfs_write_lock(parent_dir->i_sb);
1014 item_len = ROUND_UP (strlen (symname));
1015 if (item_len > MAX_DIRECT_ITEM_LEN (parent_dir->i_sb->s_blocksize)) {
1016 retval = -ENAMETOOLONG;
1017 drop_new_inode(inode);
1021 name = reiserfs_kmalloc (item_len, GFP_NOFS, parent_dir->i_sb);
1023 drop_new_inode(inode);
1027 memcpy (name, symname, strlen (symname));
1028 padd_item (name, item_len, strlen (symname));
1030 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1032 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count) ;
1034 drop_new_inode (inode);
1035 reiserfs_kfree (name, item_len, parent_dir->i_sb);
1039 retval = reiserfs_new_inode (&th, parent_dir, mode, name, strlen (symname),
1041 reiserfs_kfree (name, item_len, parent_dir->i_sb);
1042 if (retval) { /* reiserfs_new_inode iputs for us */
1046 reiserfs_update_inode_transaction(inode) ;
1047 reiserfs_update_inode_transaction(parent_dir) ;
1049 inode->i_op = &reiserfs_symlink_inode_operations;
1050 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1052 // must be sure this inode is written with this transaction
1054 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1056 retval = reiserfs_add_entry (&th, parent_dir, dentry->d_name.name,
1057 dentry->d_name.len, inode, 1/*visible*/);
1061 reiserfs_update_sd (&th, inode);
1062 err = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1069 d_instantiate(dentry, inode);
1070 retval = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1072 reiserfs_write_unlock(parent_dir->i_sb);
1076 static int reiserfs_link (struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
1079 struct inode *inode = old_dentry->d_inode;
1080 struct reiserfs_transaction_handle th ;
1081 /* We need blocks for transaction + update of quotas for the owners of the directory */
1082 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * REISERFS_QUOTA_TRANS_BLOCKS;
1084 reiserfs_write_lock(dir->i_sb);
1085 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1086 //FIXME: sd_nlink is 32 bit for new files
1087 reiserfs_write_unlock(dir->i_sb);
1090 if (inode->i_nlink == 0) {
1091 reiserfs_write_unlock(dir->i_sb);
1095 /* inc before scheduling so reiserfs_unlink knows we are here */
1098 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
1101 reiserfs_write_unlock (dir->i_sb);
1105 /* create new entry */
1106 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
1107 inode, 1/*visible*/);
1109 reiserfs_update_inode_transaction(inode) ;
1110 reiserfs_update_inode_transaction(dir) ;
1115 err = journal_end(&th, dir->i_sb, jbegin_count) ;
1116 reiserfs_write_unlock(dir->i_sb);
1117 return err ? err : retval;
1120 inode->i_ctime = CURRENT_TIME_SEC;
1121 reiserfs_update_sd (&th, inode);
1123 atomic_inc(&inode->i_count) ;
1124 d_instantiate(dentry, inode);
1125 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
1126 reiserfs_write_unlock(dir->i_sb);
1131 // de contains information pointing to an entry which
1132 static int de_still_valid (const char * name, int len, struct reiserfs_dir_entry * de)
1134 struct reiserfs_dir_entry tmp = *de;
1136 // recalculate pointer to name and name length
1137 set_de_name_and_namelen (&tmp);
1138 // FIXME: could check more
1139 if (tmp.de_namelen != len || memcmp (name, de->de_name, len))
1145 static int entry_points_to_object (const char * name, int len, struct reiserfs_dir_entry * de, struct inode * inode)
1147 if (!de_still_valid (name, len, de))
1151 if (!de_visible (de->de_deh + de->de_entry_num))
1152 reiserfs_panic (NULL, "vs-7042: entry_points_to_object: entry must be visible");
1153 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1156 /* this must be added hidden entry */
1157 if (de_visible (de->de_deh + de->de_entry_num))
1158 reiserfs_panic (NULL, "vs-7043: entry_points_to_object: entry must be visible");
1164 /* sets key of objectid the entry has to point to */
1165 static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct reiserfs_key * key)
1167 /* JDM These operations are endian safe - both are le */
1168 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1169 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1174 * process, that is going to call fix_nodes/do_balance must hold only
1175 * one path. If it holds 2 or more, it can get into endless waiting in
1176 * get_empty_nodes or its clones
1178 static int reiserfs_rename (struct inode * old_dir, struct dentry *old_dentry,
1179 struct inode * new_dir, struct dentry *new_dentry)
1182 INITIALIZE_PATH (old_entry_path);
1183 INITIALIZE_PATH (new_entry_path);
1184 INITIALIZE_PATH (dot_dot_entry_path);
1185 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih ;
1186 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1187 struct inode * old_inode, * new_dentry_inode;
1188 struct reiserfs_transaction_handle th ;
1190 umode_t old_inode_mode;
1191 unsigned long savelink = 1;
1192 struct timespec ctime;
1194 /* three balancings: (1) old name removal, (2) new name insertion
1195 and (3) maybe "save" link insertion
1196 stat data updates: (1) old directory,
1197 (2) new directory and (3) maybe old object stat data (when it is
1198 directory) and (4) maybe stat data of object to which new entry
1199 pointed initially and (5) maybe block containing ".." of
1201 quota updates: two parent directories */
1202 jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 5 + 4 * REISERFS_QUOTA_TRANS_BLOCKS;
1204 old_inode = old_dentry->d_inode;
1205 new_dentry_inode = new_dentry->d_inode;
1207 // make sure, that oldname still exists and points to an object we
1208 // are going to rename
1209 old_de.de_gen_number_bit_string = NULL;
1210 reiserfs_write_lock(old_dir->i_sb);
1211 retval = reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len,
1212 &old_entry_path, &old_de);
1213 pathrelse (&old_entry_path);
1214 if (retval == IO_ERROR) {
1215 reiserfs_write_unlock(old_dir->i_sb);
1219 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1220 reiserfs_write_unlock(old_dir->i_sb);
1224 old_inode_mode = old_inode->i_mode;
1225 if (S_ISDIR(old_inode_mode)) {
1226 // make sure, that directory being renamed has correct ".."
1227 // and that its new parent directory has not too many links
1230 if (new_dentry_inode) {
1231 if (!reiserfs_empty_dir(new_dentry_inode)) {
1232 reiserfs_write_unlock(old_dir->i_sb);
1237 /* directory is renamed, its parent directory will be changed,
1238 ** so find ".." entry
1240 dot_dot_de.de_gen_number_bit_string = NULL;
1241 retval = reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de);
1242 pathrelse (&dot_dot_entry_path);
1243 if (retval != NAME_FOUND) {
1244 reiserfs_write_unlock(old_dir->i_sb);
1248 /* inode number of .. must equal old_dir->i_ino */
1249 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1250 reiserfs_write_unlock(old_dir->i_sb);
1255 retval = journal_begin(&th, old_dir->i_sb, jbegin_count) ;
1257 reiserfs_write_unlock (old_dir->i_sb);
1261 /* add new entry (or find the existing one) */
1262 retval = reiserfs_add_entry (&th, new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1264 if (retval == -EEXIST) {
1265 if (!new_dentry_inode) {
1266 reiserfs_panic (old_dir->i_sb,
1267 "vs-7050: new entry is found, new inode == 0\n");
1269 } else if (retval) {
1270 int err = journal_end(&th, old_dir->i_sb, jbegin_count) ;
1271 reiserfs_write_unlock(old_dir->i_sb);
1272 return err ? err : retval;
1275 reiserfs_update_inode_transaction(old_dir) ;
1276 reiserfs_update_inode_transaction(new_dir) ;
1278 /* this makes it so an fsync on an open fd for the old name will
1279 ** commit the rename operation
1281 reiserfs_update_inode_transaction(old_inode) ;
1283 if (new_dentry_inode)
1284 reiserfs_update_inode_transaction(new_dentry_inode) ;
1287 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1288 if ((retval = search_by_entry_key (new_dir->i_sb, &old_de.de_entry_key,
1289 &old_entry_path, &old_de)) != NAME_FOUND) {
1290 pathrelse(&old_entry_path);
1291 journal_end(&th, old_dir->i_sb, jbegin_count);
1292 reiserfs_write_unlock(old_dir->i_sb);
1296 copy_item_head(&old_entry_ih, get_ih(&old_entry_path)) ;
1298 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1) ;
1300 // look for new name by reiserfs_find_entry
1301 new_de.de_gen_number_bit_string = NULL;
1302 retval = reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1303 &new_entry_path, &new_de);
1304 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1305 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1306 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1307 pathrelse(&new_entry_path);
1308 pathrelse(&old_entry_path);
1309 journal_end(&th, old_dir->i_sb, jbegin_count);
1310 reiserfs_write_unlock(old_dir->i_sb);
1314 copy_item_head(&new_entry_ih, get_ih(&new_entry_path)) ;
1316 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1) ;
1318 if (S_ISDIR(old_inode->i_mode)) {
1319 if ((retval = search_by_entry_key (new_dir->i_sb, &dot_dot_de.de_entry_key,
1320 &dot_dot_entry_path, &dot_dot_de)) != NAME_FOUND) {
1321 pathrelse(&dot_dot_entry_path);
1322 pathrelse(&new_entry_path);
1323 pathrelse(&old_entry_path);
1324 journal_end(&th, old_dir->i_sb, jbegin_count);
1325 reiserfs_write_unlock(old_dir->i_sb);
1328 copy_item_head(&dot_dot_ih, get_ih(&dot_dot_entry_path)) ;
1329 // node containing ".." gets into transaction
1330 reiserfs_prepare_for_journal(old_inode->i_sb, dot_dot_de.de_bh, 1) ;
1332 /* we should check seals here, not do
1333 this stuff, yes? Then, having
1334 gathered everything into RAM we
1335 should lock the buffers, yes? -Hans */
1336 /* probably. our rename needs to hold more
1337 ** than one path at once. The seals would
1338 ** have to be written to deal with multi-path
1341 /* sanity checking before doing the rename - avoid races many
1342 ** of the above checks could have scheduled. We have to be
1343 ** sure our items haven't been shifted by another process.
1345 if (item_moved(&new_entry_ih, &new_entry_path) ||
1346 !entry_points_to_object(new_dentry->d_name.name,
1347 new_dentry->d_name.len,
1348 &new_de, new_dentry_inode) ||
1349 item_moved(&old_entry_ih, &old_entry_path) ||
1350 !entry_points_to_object (old_dentry->d_name.name,
1351 old_dentry->d_name.len,
1352 &old_de, old_inode)) {
1353 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1354 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1355 if (S_ISDIR(old_inode_mode))
1356 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1359 if (S_ISDIR(old_inode_mode)) {
1360 if ( item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1361 !entry_points_to_object ( "..", 2, &dot_dot_de, old_dir) ) {
1362 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1363 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1364 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1369 RFALSE( S_ISDIR(old_inode_mode) &&
1370 !buffer_journal_prepared(dot_dot_de.de_bh), "" );
1375 /* ok, all the changes can be done in one fell swoop when we
1376 have claimed all the buffers needed.*/
1378 mark_de_visible (new_de.de_deh + new_de.de_entry_num);
1379 set_ino_in_dir_entry (&new_de, INODE_PKEY (old_inode));
1380 journal_mark_dirty (&th, old_dir->i_sb, new_de.de_bh);
1382 mark_de_hidden (old_de.de_deh + old_de.de_entry_num);
1383 journal_mark_dirty (&th, old_dir->i_sb, old_de.de_bh);
1384 ctime = CURRENT_TIME_SEC;
1385 old_dir->i_ctime = old_dir->i_mtime = ctime;
1386 new_dir->i_ctime = new_dir->i_mtime = ctime;
1387 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1389 old_inode->i_ctime = ctime;
1391 if (new_dentry_inode) {
1392 // adjust link number of the victim
1393 if (S_ISDIR(new_dentry_inode->i_mode)) {
1394 new_dentry_inode->i_nlink = 0;
1396 new_dentry_inode->i_nlink--;
1398 new_dentry_inode->i_ctime = ctime;
1399 savelink = new_dentry_inode->i_nlink;
1402 if (S_ISDIR(old_inode_mode)) {
1403 // adjust ".." of renamed directory
1404 set_ino_in_dir_entry (&dot_dot_de, INODE_PKEY (new_dir));
1405 journal_mark_dirty (&th, new_dir->i_sb, dot_dot_de.de_bh);
1407 if (!new_dentry_inode)
1408 /* there (in new_dir) was no directory, so it got new link
1409 (".." of renamed directory) */
1410 INC_DIR_INODE_NLINK(new_dir);
1412 /* old directory lost one link - ".. " of renamed directory */
1413 DEC_DIR_INODE_NLINK(old_dir);
1416 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1417 pathrelse (&new_entry_path);
1418 pathrelse (&dot_dot_entry_path);
1420 // FIXME: this reiserfs_cut_from_item's return value may screw up
1421 // anybody, but it will panic if will not be able to find the
1422 // entry. This needs one more clean up
1423 if (reiserfs_cut_from_item (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL, 0) < 0)
1424 reiserfs_warning (old_dir->i_sb, "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
1426 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1428 reiserfs_update_sd (&th, old_dir);
1429 reiserfs_update_sd (&th, new_dir);
1430 reiserfs_update_sd (&th, old_inode);
1432 if (new_dentry_inode) {
1434 add_save_link (&th, new_dentry_inode, 0/* not truncate */);
1435 reiserfs_update_sd (&th, new_dentry_inode);
1438 retval = journal_end(&th, old_dir->i_sb, jbegin_count) ;
1439 reiserfs_write_unlock(old_dir->i_sb);
1444 * directories can handle most operations...
1446 struct inode_operations reiserfs_dir_inode_operations = {
1447 //&reiserfs_dir_operations, /* default_file_ops */
1448 .create = reiserfs_create,
1449 .lookup = reiserfs_lookup,
1450 .link = reiserfs_link,
1451 .unlink = reiserfs_unlink,
1452 .symlink = reiserfs_symlink,
1453 .mkdir = reiserfs_mkdir,
1454 .rmdir = reiserfs_rmdir,
1455 .mknod = reiserfs_mknod,
1456 .rename = reiserfs_rename,
1457 .setattr = reiserfs_setattr,
1458 .setxattr = reiserfs_setxattr,
1459 .getxattr = reiserfs_getxattr,
1460 .listxattr = reiserfs_listxattr,
1461 .removexattr = reiserfs_removexattr,
1462 .permission = reiserfs_permission,
1466 * symlink operations.. same as page_symlink_inode_operations, with xattr
1469 struct inode_operations reiserfs_symlink_inode_operations = {
1470 .readlink = generic_readlink,
1471 .follow_link = page_follow_link_light,
1472 .put_link = page_put_link,
1473 .setattr = reiserfs_setattr,
1474 .setxattr = reiserfs_setxattr,
1475 .getxattr = reiserfs_getxattr,
1476 .listxattr = reiserfs_listxattr,
1477 .removexattr = reiserfs_removexattr,
1478 .permission = reiserfs_permission,
1484 * special file operations.. just xattr/acl stuff
1486 struct inode_operations reiserfs_special_inode_operations = {
1487 .setattr = reiserfs_setattr,
1488 .setxattr = reiserfs_setxattr,
1489 .getxattr = reiserfs_getxattr,
1490 .listxattr = reiserfs_listxattr,
1491 .removexattr = reiserfs_removexattr,
1492 .permission = reiserfs_permission,