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/slab.h>
20 #include <linux/quotaops.h>
22 #define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) set_nlink(i, 1); }
23 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
25 // directory item contains array of entry headers. This performs
26 // binary search through that array
27 static int bin_search_in_dir_item(struct reiserfs_dir_entry
*de
, loff_t off
)
29 struct item_head
*ih
= de
->de_ih
;
30 struct reiserfs_de_head
*deh
= de
->de_deh
;
31 int rbound
, lbound
, j
;
34 rbound
= I_ENTRY_COUNT(ih
) - 1;
36 for (j
= (rbound
+ lbound
) / 2; lbound
<= rbound
;
37 j
= (rbound
+ lbound
) / 2) {
38 if (off
< deh_offset(deh
+ j
)) {
42 if (off
> deh_offset(deh
+ j
)) {
46 // this is not name found, but matched third key component
51 de
->de_entry_num
= lbound
;
52 return NAME_NOT_FOUND
;
55 // comment? maybe something like set de to point to what the path points to?
56 static inline void set_de_item_location(struct reiserfs_dir_entry
*de
,
57 struct treepath
*path
)
59 de
->de_bh
= get_last_bh(path
);
60 de
->de_ih
= get_ih(path
);
61 de
->de_deh
= B_I_DEH(de
->de_bh
, de
->de_ih
);
62 de
->de_item_num
= PATH_LAST_POSITION(path
);
65 // de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
66 inline void set_de_name_and_namelen(struct reiserfs_dir_entry
*de
)
68 struct reiserfs_de_head
*deh
= de
->de_deh
+ de
->de_entry_num
;
70 BUG_ON(de
->de_entry_num
>= ih_entry_count(de
->de_ih
));
72 de
->de_entrylen
= entry_length(de
->de_bh
, de
->de_ih
, de
->de_entry_num
);
73 de
->de_namelen
= de
->de_entrylen
- (de_with_sd(deh
) ? SD_SIZE
: 0);
74 de
->de_name
= B_I_PITEM(de
->de_bh
, de
->de_ih
) + deh_location(deh
);
75 if (de
->de_name
[de
->de_namelen
- 1] == 0)
76 de
->de_namelen
= strlen(de
->de_name
);
79 // what entry points to
80 static inline void set_de_object_key(struct reiserfs_dir_entry
*de
)
82 BUG_ON(de
->de_entry_num
>= ih_entry_count(de
->de_ih
));
83 de
->de_dir_id
= deh_dir_id(&(de
->de_deh
[de
->de_entry_num
]));
84 de
->de_objectid
= deh_objectid(&(de
->de_deh
[de
->de_entry_num
]));
87 static inline void store_de_entry_key(struct reiserfs_dir_entry
*de
)
89 struct reiserfs_de_head
*deh
= de
->de_deh
+ de
->de_entry_num
;
91 BUG_ON(de
->de_entry_num
>= ih_entry_count(de
->de_ih
));
93 /* store key of the found entry */
94 de
->de_entry_key
.version
= KEY_FORMAT_3_5
;
95 de
->de_entry_key
.on_disk_key
.k_dir_id
=
96 le32_to_cpu(de
->de_ih
->ih_key
.k_dir_id
);
97 de
->de_entry_key
.on_disk_key
.k_objectid
=
98 le32_to_cpu(de
->de_ih
->ih_key
.k_objectid
);
99 set_cpu_key_k_offset(&(de
->de_entry_key
), deh_offset(deh
));
100 set_cpu_key_k_type(&(de
->de_entry_key
), TYPE_DIRENTRY
);
103 /* We assign a key to each directory item, and place multiple entries
104 in a single directory item. A directory item has a key equal to the
105 key of the first directory entry in it.
107 This function first calls search_by_key, then, if item whose first
108 entry matches is not found it looks for the entry inside directory
109 item found by search_by_key. Fills the path to the entry, and to the
110 entry position in the item
114 /* The function is NOT SCHEDULE-SAFE! */
115 int search_by_entry_key(struct super_block
*sb
, const struct cpu_key
*key
,
116 struct treepath
*path
, struct reiserfs_dir_entry
*de
)
120 retval
= search_item(sb
, key
, path
);
123 if (!PATH_LAST_POSITION(path
)) {
124 reiserfs_error(sb
, "vs-7000", "search_by_key "
125 "returned item position == 0");
129 PATH_LAST_POSITION(path
)--;
139 reiserfs_error(sb
, "vs-7002", "no path to here");
143 set_de_item_location(de
, path
);
145 #ifdef CONFIG_REISERFS_CHECK
146 if (!is_direntry_le_ih(de
->de_ih
) ||
147 COMP_SHORT_KEYS(&(de
->de_ih
->ih_key
), key
)) {
148 print_block(de
->de_bh
, 0, -1, -1);
149 reiserfs_panic(sb
, "vs-7005", "found item %h is not directory "
150 "item or does not belong to the same directory "
151 "as key %K", de
->de_ih
, key
);
153 #endif /* CONFIG_REISERFS_CHECK */
155 /* binary search in directory item by third componen t of the
156 key. sets de->de_entry_num of de */
157 retval
= bin_search_in_dir_item(de
, cpu_key_k_offset(key
));
158 path
->pos_in_item
= de
->de_entry_num
;
159 if (retval
!= NAME_NOT_FOUND
) {
160 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
161 set_de_name_and_namelen(de
);
162 set_de_object_key(de
);
167 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
169 /* The third component is hashed, and you can choose from more than
170 one hash function. Per directory hashes are not yet implemented
171 but are thought about. This function should be moved to hashes.c
172 Jedi, please do so. -Hans */
174 static __u32
get_third_component(struct super_block
*s
,
175 const char *name
, int len
)
179 if (!len
|| (len
== 1 && name
[0] == '.'))
181 if (len
== 2 && name
[0] == '.' && name
[1] == '.')
182 return DOT_DOT_OFFSET
;
184 res
= REISERFS_SB(s
)->s_hash_function(name
, len
);
186 // take bits from 7-th to 30-th including both bounds
187 res
= GET_HASH_VALUE(res
);
189 // needed to have no names before "." and ".." those have hash
190 // value == 0 and generation conters 1 and 2 accordingly
192 return res
+ MAX_GENERATION_NUMBER
;
195 static int reiserfs_match(struct reiserfs_dir_entry
*de
,
196 const char *name
, int namelen
)
198 int retval
= NAME_NOT_FOUND
;
200 if ((namelen
== de
->de_namelen
) &&
201 !memcmp(de
->de_name
, name
, de
->de_namelen
))
203 (de_visible(de
->de_deh
+ de
->de_entry_num
) ? NAME_FOUND
:
204 NAME_FOUND_INVISIBLE
);
209 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
211 /* used when hash collisions exist */
213 static int linear_search_in_dir_item(struct cpu_key
*key
,
214 struct reiserfs_dir_entry
*de
,
215 const char *name
, int namelen
)
217 struct reiserfs_de_head
*deh
= de
->de_deh
;
221 i
= de
->de_entry_num
;
223 if (i
== I_ENTRY_COUNT(de
->de_ih
) ||
224 GET_HASH_VALUE(deh_offset(deh
+ i
)) !=
225 GET_HASH_VALUE(cpu_key_k_offset(key
))) {
229 RFALSE(de
->de_deh
!= B_I_DEH(de
->de_bh
, de
->de_ih
),
230 "vs-7010: array of entry headers not found");
234 for (; i
>= 0; i
--, deh
--) {
235 if (GET_HASH_VALUE(deh_offset(deh
)) !=
236 GET_HASH_VALUE(cpu_key_k_offset(key
))) {
237 // hash value does not match, no need to check whole name
238 return NAME_NOT_FOUND
;
241 /* mark, that this generation number is used */
242 if (de
->de_gen_number_bit_string
)
243 set_bit(GET_GENERATION_NUMBER(deh_offset(deh
)),
244 de
->de_gen_number_bit_string
);
246 // calculate pointer to name and namelen
247 de
->de_entry_num
= i
;
248 set_de_name_and_namelen(de
);
251 reiserfs_match(de
, name
, namelen
)) != NAME_NOT_FOUND
) {
252 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
254 // key of pointed object
255 set_de_object_key(de
);
257 store_de_entry_key(de
);
259 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
264 if (GET_GENERATION_NUMBER(le_ih_k_offset(de
->de_ih
)) == 0)
265 /* we have reached left most entry in the node. In common we
266 have to go to the left neighbor, but if generation counter
267 is 0 already, we know for sure, that there is no name with
268 the same hash value */
269 // FIXME: this work correctly only because hash value can not
270 // be 0. Btw, in case of Yura's hash it is probably possible,
272 return NAME_NOT_FOUND
;
274 RFALSE(de
->de_item_num
,
275 "vs-7015: two diritems of the same directory in one node?");
277 return GOTO_PREVIOUS_ITEM
;
280 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
281 // FIXME: should add something like IOERROR
282 static int reiserfs_find_entry(struct inode
*dir
, const char *name
, int namelen
,
283 struct treepath
*path_to_entry
,
284 struct reiserfs_dir_entry
*de
)
286 struct cpu_key key_to_search
;
289 if (namelen
> REISERFS_MAX_NAME(dir
->i_sb
->s_blocksize
))
290 return NAME_NOT_FOUND
;
292 /* we will search for this key in the tree */
293 make_cpu_key(&key_to_search
, dir
,
294 get_third_component(dir
->i_sb
, name
, namelen
),
299 search_by_entry_key(dir
->i_sb
, &key_to_search
,
301 if (retval
== IO_ERROR
) {
302 reiserfs_error(dir
->i_sb
, "zam-7001", "io error");
306 /* compare names for all entries having given hash value */
308 linear_search_in_dir_item(&key_to_search
, de
, name
,
310 if (retval
!= GOTO_PREVIOUS_ITEM
) {
311 /* there is no need to scan directory anymore. Given entry found or does not exist */
312 path_to_entry
->pos_in_item
= de
->de_entry_num
;
316 /* there is left neighboring item of this directory and given entry can be there */
317 set_cpu_key_k_offset(&key_to_search
,
318 le_ih_k_offset(de
->de_ih
) - 1);
319 pathrelse(path_to_entry
);
324 static struct dentry
*reiserfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
329 struct inode
*inode
= NULL
;
330 struct reiserfs_dir_entry de
;
331 INITIALIZE_PATH(path_to_entry
);
333 if (REISERFS_MAX_NAME(dir
->i_sb
->s_blocksize
) < dentry
->d_name
.len
)
334 return ERR_PTR(-ENAMETOOLONG
);
337 * Might be called with or without the write lock, must be careful
338 * to not recursively hold it in case we want to release the lock
339 * before rescheduling.
341 lock_depth
= reiserfs_write_lock_once(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 inode
= reiserfs_iget(dir
->i_sb
,
350 (struct cpu_key
*)&(de
.de_dir_id
));
351 if (!inode
|| IS_ERR(inode
)) {
352 reiserfs_write_unlock_once(dir
->i_sb
, lock_depth
);
353 return ERR_PTR(-EACCES
);
356 /* Propagate the private flag so we know we're
357 * in the priv tree */
359 inode
->i_flags
|= S_PRIVATE
;
361 reiserfs_write_unlock_once(dir
->i_sb
, lock_depth
);
362 if (retval
== IO_ERROR
) {
363 return ERR_PTR(-EIO
);
366 return d_splice_alias(inode
, dentry
);
370 ** looks up the dentry of the parent directory for child.
371 ** taken from ext2_get_parent
373 struct dentry
*reiserfs_get_parent(struct dentry
*child
)
376 struct inode
*inode
= NULL
;
377 struct reiserfs_dir_entry de
;
378 INITIALIZE_PATH(path_to_entry
);
379 struct inode
*dir
= child
->d_inode
;
381 if (dir
->i_nlink
== 0) {
382 return ERR_PTR(-ENOENT
);
384 de
.de_gen_number_bit_string
= NULL
;
386 reiserfs_write_lock(dir
->i_sb
);
387 retval
= reiserfs_find_entry(dir
, "..", 2, &path_to_entry
, &de
);
388 pathrelse(&path_to_entry
);
389 if (retval
!= NAME_FOUND
) {
390 reiserfs_write_unlock(dir
->i_sb
);
391 return ERR_PTR(-ENOENT
);
393 inode
= reiserfs_iget(dir
->i_sb
, (struct cpu_key
*)&(de
.de_dir_id
));
394 reiserfs_write_unlock(dir
->i_sb
);
396 return d_obtain_alias(inode
);
399 /* add entry to the directory (entry can be hidden).
401 insert definition of when hidden directories are used here -Hans
403 Does not mark dir inode dirty, do it after successesfull call to it */
405 static int reiserfs_add_entry(struct reiserfs_transaction_handle
*th
,
406 struct inode
*dir
, const char *name
, int namelen
,
407 struct inode
*inode
, int visible
)
409 struct cpu_key entry_key
;
410 struct reiserfs_de_head
*deh
;
411 INITIALIZE_PATH(path
);
412 struct reiserfs_dir_entry de
;
413 DECLARE_BITMAP(bit_string
, MAX_GENERATION_NUMBER
+ 1);
415 char small_buf
[32 + DEH_SIZE
]; /* 48 bytes now and we avoid kmalloc
416 if we create file with short name */
418 int buflen
, paste_size
;
421 BUG_ON(!th
->t_trans_id
);
423 /* cannot allow items to be added into a busy deleted directory */
427 if (namelen
> REISERFS_MAX_NAME(dir
->i_sb
->s_blocksize
))
428 return -ENAMETOOLONG
;
430 /* each entry has unique key. compose it */
431 make_cpu_key(&entry_key
, dir
,
432 get_third_component(dir
->i_sb
, name
, namelen
),
435 /* get memory for composing the entry */
436 buflen
= DEH_SIZE
+ ROUND_UP(namelen
);
437 if (buflen
> sizeof(small_buf
)) {
438 buffer
= kmalloc(buflen
, GFP_NOFS
);
445 (get_inode_sd_version(dir
) ==
446 STAT_DATA_V1
) ? (DEH_SIZE
+ namelen
) : buflen
;
448 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
449 deh
= (struct reiserfs_de_head
*)buffer
;
450 deh
->deh_location
= 0; /* JDM Endian safe if 0 */
451 put_deh_offset(deh
, cpu_key_k_offset(&entry_key
));
452 deh
->deh_state
= 0; /* JDM Endian safe if 0 */
453 /* put key (ino analog) to de */
454 deh
->deh_dir_id
= INODE_PKEY(inode
)->k_dir_id
; /* safe: k_dir_id is le */
455 deh
->deh_objectid
= INODE_PKEY(inode
)->k_objectid
; /* safe: k_objectid is le */
458 memcpy((char *)(deh
+ 1), name
, namelen
);
459 /* padd by 0s to the 4 byte boundary */
460 padd_item((char *)(deh
+ 1), ROUND_UP(namelen
), namelen
);
462 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
463 mark_de_without_sd(deh
);
464 visible
? mark_de_visible(deh
) : mark_de_hidden(deh
);
466 /* find the proper place for the new entry */
467 memset(bit_string
, 0, sizeof(bit_string
));
468 de
.de_gen_number_bit_string
= bit_string
;
469 retval
= reiserfs_find_entry(dir
, name
, namelen
, &path
, &de
);
470 if (retval
!= NAME_NOT_FOUND
) {
471 if (buffer
!= small_buf
)
475 if (retval
== IO_ERROR
) {
479 if (retval
!= NAME_FOUND
) {
480 reiserfs_error(dir
->i_sb
, "zam-7002",
481 "reiserfs_find_entry() returned "
482 "unexpected value (%d)", retval
);
489 find_first_zero_bit(bit_string
,
490 MAX_GENERATION_NUMBER
+ 1);
491 if (gen_number
> MAX_GENERATION_NUMBER
) {
492 /* there is no free generation number */
493 reiserfs_warning(dir
->i_sb
, "reiserfs-7010",
494 "Congratulations! we have got hash function "
496 if (buffer
!= small_buf
)
501 /* adjust offset of directory enrty */
502 put_deh_offset(deh
, SET_GENERATION_NUMBER(deh_offset(deh
), gen_number
));
503 set_cpu_key_k_offset(&entry_key
, deh_offset(deh
));
505 /* update max-hash-collisions counter in reiserfs_sb_info */
506 PROC_INFO_MAX(th
->t_super
, max_hash_collisions
, gen_number
);
508 if (gen_number
!= 0) { /* we need to re-search for the insertion point */
509 if (search_by_entry_key(dir
->i_sb
, &entry_key
, &path
, &de
) !=
511 reiserfs_warning(dir
->i_sb
, "vs-7032",
512 "entry with this key (%K) already "
513 "exists", &entry_key
);
515 if (buffer
!= small_buf
)
522 /* perform the insertion of the entry that we have prepared */
524 reiserfs_paste_into_item(th
, &path
, &entry_key
, dir
, buffer
,
526 if (buffer
!= small_buf
)
529 reiserfs_check_path(&path
);
533 dir
->i_size
+= paste_size
;
534 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME_SEC
;
535 if (!S_ISDIR(inode
->i_mode
) && visible
)
536 // reiserfs_mkdir or reiserfs_rename will do that by itself
537 reiserfs_update_sd(th
, dir
);
539 reiserfs_check_path(&path
);
543 /* quota utility function, call if you've had to abort after calling
544 ** new_inode_init, and have not called reiserfs_new_inode yet.
545 ** This should only be called on inodes that do not have stat data
546 ** inserted into the tree yet.
548 static int drop_new_inode(struct inode
*inode
)
551 make_bad_inode(inode
);
552 inode
->i_flags
|= S_NOQUOTA
;
557 /* utility function that does setup for reiserfs_new_inode.
558 ** dquot_initialize needs lots of credits so it's better to have it
559 ** outside of a transaction, so we had to pull some bits of
560 ** reiserfs_new_inode out into this func.
562 static int new_inode_init(struct inode
*inode
, struct inode
*dir
, umode_t mode
)
564 /* Make inode invalid - just in case we are going to drop it before
565 * the initialization happens */
566 INODE_PKEY(inode
)->k_objectid
= 0;
567 /* the quota init calls have to know who to charge the quota to, so
568 ** we have to set uid and gid here
570 inode_init_owner(inode
, dir
, mode
);
571 dquot_initialize(inode
);
575 static int reiserfs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
580 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
582 JOURNAL_PER_BALANCE_CNT
* 2 +
583 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir
->i_sb
) +
584 REISERFS_QUOTA_TRANS_BLOCKS(dir
->i_sb
));
585 struct reiserfs_transaction_handle th
;
586 struct reiserfs_security_handle security
;
588 dquot_initialize(dir
);
590 if (!(inode
= new_inode(dir
->i_sb
))) {
593 new_inode_init(inode
, dir
, mode
);
595 jbegin_count
+= reiserfs_cache_default_acl(dir
);
596 retval
= reiserfs_security_init(dir
, inode
, &dentry
->d_name
, &security
);
598 drop_new_inode(inode
);
601 jbegin_count
+= retval
;
602 reiserfs_write_lock(dir
->i_sb
);
604 retval
= journal_begin(&th
, dir
->i_sb
, jbegin_count
);
606 drop_new_inode(inode
);
611 reiserfs_new_inode(&th
, dir
, mode
, NULL
, 0 /*i_size */ , dentry
,
616 inode
->i_op
= &reiserfs_file_inode_operations
;
617 inode
->i_fop
= &reiserfs_file_operations
;
618 inode
->i_mapping
->a_ops
= &reiserfs_address_space_operations
;
621 reiserfs_add_entry(&th
, dir
, dentry
->d_name
.name
,
622 dentry
->d_name
.len
, inode
, 1 /*visible */ );
626 reiserfs_update_sd(&th
, inode
);
627 err
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
630 unlock_new_inode(inode
);
634 reiserfs_update_inode_transaction(inode
);
635 reiserfs_update_inode_transaction(dir
);
637 d_instantiate(dentry
, inode
);
638 unlock_new_inode(inode
);
639 retval
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
642 reiserfs_write_unlock(dir
->i_sb
);
646 static int reiserfs_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
651 struct reiserfs_transaction_handle th
;
652 struct reiserfs_security_handle security
;
653 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
655 JOURNAL_PER_BALANCE_CNT
* 3 +
656 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir
->i_sb
) +
657 REISERFS_QUOTA_TRANS_BLOCKS(dir
->i_sb
));
659 if (!new_valid_dev(rdev
))
662 dquot_initialize(dir
);
664 if (!(inode
= new_inode(dir
->i_sb
))) {
667 new_inode_init(inode
, dir
, mode
);
669 jbegin_count
+= reiserfs_cache_default_acl(dir
);
670 retval
= reiserfs_security_init(dir
, inode
, &dentry
->d_name
, &security
);
672 drop_new_inode(inode
);
675 jbegin_count
+= retval
;
676 reiserfs_write_lock(dir
->i_sb
);
678 retval
= journal_begin(&th
, dir
->i_sb
, jbegin_count
);
680 drop_new_inode(inode
);
685 reiserfs_new_inode(&th
, dir
, mode
, NULL
, 0 /*i_size */ , dentry
,
691 inode
->i_op
= &reiserfs_special_inode_operations
;
692 init_special_inode(inode
, inode
->i_mode
, rdev
);
694 //FIXME: needed for block and char devices only
695 reiserfs_update_sd(&th
, inode
);
697 reiserfs_update_inode_transaction(inode
);
698 reiserfs_update_inode_transaction(dir
);
701 reiserfs_add_entry(&th
, dir
, dentry
->d_name
.name
,
702 dentry
->d_name
.len
, inode
, 1 /*visible */ );
706 reiserfs_update_sd(&th
, inode
);
707 err
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
710 unlock_new_inode(inode
);
715 d_instantiate(dentry
, inode
);
716 unlock_new_inode(inode
);
717 retval
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
720 reiserfs_write_unlock(dir
->i_sb
);
724 static int reiserfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
728 struct reiserfs_transaction_handle th
;
729 struct reiserfs_security_handle security
;
731 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
733 JOURNAL_PER_BALANCE_CNT
* 3 +
734 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir
->i_sb
) +
735 REISERFS_QUOTA_TRANS_BLOCKS(dir
->i_sb
));
737 dquot_initialize(dir
);
739 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
740 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
741 REISERFS_I(dir
)->new_packing_locality
= 1;
743 mode
= S_IFDIR
| mode
;
744 if (!(inode
= new_inode(dir
->i_sb
))) {
747 new_inode_init(inode
, dir
, mode
);
749 jbegin_count
+= reiserfs_cache_default_acl(dir
);
750 retval
= reiserfs_security_init(dir
, inode
, &dentry
->d_name
, &security
);
752 drop_new_inode(inode
);
755 jbegin_count
+= retval
;
756 lock_depth
= reiserfs_write_lock_once(dir
->i_sb
);
758 retval
= journal_begin(&th
, dir
->i_sb
, jbegin_count
);
760 drop_new_inode(inode
);
764 /* inc the link count now, so another writer doesn't overflow it while
765 ** we sleep later on.
767 INC_DIR_INODE_NLINK(dir
)
769 retval
= reiserfs_new_inode(&th
, dir
, mode
, NULL
/*symlink */ ,
770 old_format_only(dir
->i_sb
) ?
771 EMPTY_DIR_SIZE_V1
: EMPTY_DIR_SIZE
,
772 dentry
, inode
, &security
);
774 DEC_DIR_INODE_NLINK(dir
)
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
786 reiserfs_add_entry(&th
, dir
, dentry
->d_name
.name
,
787 dentry
->d_name
.len
, inode
, 1 /*visible */ );
791 DEC_DIR_INODE_NLINK(dir
);
792 reiserfs_update_sd(&th
, inode
);
793 err
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
796 unlock_new_inode(inode
);
800 // the above add_entry did not update dir's stat data
801 reiserfs_update_sd(&th
, dir
);
803 d_instantiate(dentry
, inode
);
804 unlock_new_inode(inode
);
805 retval
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
807 reiserfs_write_unlock_once(dir
->i_sb
, lock_depth
);
811 static inline int reiserfs_empty_dir(struct inode
*inode
)
813 /* we can cheat because an old format dir cannot have
814 ** EMPTY_DIR_SIZE, and a new format dir cannot have
815 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
816 ** regardless of disk format version, the directory is empty.
818 if (inode
->i_size
!= EMPTY_DIR_SIZE
&&
819 inode
->i_size
!= EMPTY_DIR_SIZE_V1
) {
825 static int reiserfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
829 struct reiserfs_transaction_handle th
;
831 INITIALIZE_PATH(path
);
832 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 * The quota structure is possibly deleted only on last iput => outside
837 * of this transaction */
839 JOURNAL_PER_BALANCE_CNT
* 2 + 2 +
840 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir
->i_sb
);
842 dquot_initialize(dir
);
844 reiserfs_write_lock(dir
->i_sb
);
845 retval
= journal_begin(&th
, dir
->i_sb
, jbegin_count
);
849 de
.de_gen_number_bit_string
= NULL
;
851 reiserfs_find_entry(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
,
852 &path
, &de
)) == NAME_NOT_FOUND
) {
855 } else if (retval
== IO_ERROR
) {
860 inode
= dentry
->d_inode
;
862 reiserfs_update_inode_transaction(inode
);
863 reiserfs_update_inode_transaction(dir
);
865 if (de
.de_objectid
!= inode
->i_ino
) {
866 // FIXME: compare key of an object and a key found in the
871 if (!reiserfs_empty_dir(inode
)) {
876 /* cut entry from dir directory */
877 retval
= reiserfs_cut_from_item(&th
, &path
, &(de
.de_entry_key
), dir
, NULL
, /* page */
878 0 /*new file size - not used here */ );
882 if (inode
->i_nlink
!= 2 && inode
->i_nlink
!= 1)
883 reiserfs_error(inode
->i_sb
, "reiserfs-7040",
884 "empty directory has nlink != 2 (%d)",
888 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME_SEC
;
889 reiserfs_update_sd(&th
, inode
);
891 DEC_DIR_INODE_NLINK(dir
)
892 dir
->i_size
-= (DEH_SIZE
+ de
.de_entrylen
);
893 reiserfs_update_sd(&th
, dir
);
895 /* prevent empty directory from getting lost */
896 add_save_link(&th
, inode
, 0 /* not truncate */ );
898 retval
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
899 reiserfs_check_path(&path
);
901 reiserfs_write_unlock(dir
->i_sb
);
905 /* we must release path, because we did not call
906 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
907 release path if operation was not complete */
909 err
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
910 reiserfs_write_unlock(dir
->i_sb
);
911 return err
? err
: retval
;
914 static int reiserfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
918 struct reiserfs_dir_entry de
;
919 INITIALIZE_PATH(path
);
920 struct reiserfs_transaction_handle th
;
922 unsigned long savelink
;
925 dquot_initialize(dir
);
927 inode
= dentry
->d_inode
;
929 /* in this transaction we can be doing at max two balancings and update
930 * two stat datas, we change quotas of the owner of the directory and of
931 * the owner of the parent directory. The quota structure is possibly
932 * deleted only on iput => outside of this transaction */
934 JOURNAL_PER_BALANCE_CNT
* 2 + 2 +
935 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir
->i_sb
);
937 depth
= reiserfs_write_lock_once(dir
->i_sb
);
938 retval
= journal_begin(&th
, dir
->i_sb
, jbegin_count
);
942 de
.de_gen_number_bit_string
= NULL
;
944 reiserfs_find_entry(dir
, dentry
->d_name
.name
, dentry
->d_name
.len
,
945 &path
, &de
)) == NAME_NOT_FOUND
) {
948 } else if (retval
== IO_ERROR
) {
953 reiserfs_update_inode_transaction(inode
);
954 reiserfs_update_inode_transaction(dir
);
956 if (de
.de_objectid
!= inode
->i_ino
) {
957 // FIXME: compare key of an object and a key found in the
963 if (!inode
->i_nlink
) {
964 reiserfs_warning(inode
->i_sb
, "reiserfs-7042",
965 "deleting nonexistent file (%lu), %d",
966 inode
->i_ino
, inode
->i_nlink
);
973 * we schedule before doing the add_save_link call, save the link
974 * count so we don't race
976 savelink
= inode
->i_nlink
;
979 reiserfs_cut_from_item(&th
, &path
, &(de
.de_entry_key
), dir
, NULL
,
985 inode
->i_ctime
= CURRENT_TIME_SEC
;
986 reiserfs_update_sd(&th
, inode
);
988 dir
->i_size
-= (de
.de_entrylen
+ DEH_SIZE
);
989 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME_SEC
;
990 reiserfs_update_sd(&th
, dir
);
993 /* prevent file from getting lost */
994 add_save_link(&th
, inode
, 0 /* not truncate */ );
996 retval
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
997 reiserfs_check_path(&path
);
998 reiserfs_write_unlock_once(dir
->i_sb
, depth
);
1003 err
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
1004 reiserfs_check_path(&path
);
1008 reiserfs_write_unlock_once(dir
->i_sb
, depth
);
1012 static int reiserfs_symlink(struct inode
*parent_dir
,
1013 struct dentry
*dentry
, const char *symname
)
1016 struct inode
*inode
;
1019 struct reiserfs_transaction_handle th
;
1020 struct reiserfs_security_handle security
;
1021 int mode
= S_IFLNK
| S_IRWXUGO
;
1022 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1024 JOURNAL_PER_BALANCE_CNT
* 3 +
1025 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir
->i_sb
) +
1026 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir
->i_sb
));
1028 dquot_initialize(parent_dir
);
1030 if (!(inode
= new_inode(parent_dir
->i_sb
))) {
1033 new_inode_init(inode
, parent_dir
, mode
);
1035 retval
= reiserfs_security_init(parent_dir
, inode
, &dentry
->d_name
,
1038 drop_new_inode(inode
);
1041 jbegin_count
+= retval
;
1043 reiserfs_write_lock(parent_dir
->i_sb
);
1044 item_len
= ROUND_UP(strlen(symname
));
1045 if (item_len
> MAX_DIRECT_ITEM_LEN(parent_dir
->i_sb
->s_blocksize
)) {
1046 retval
= -ENAMETOOLONG
;
1047 drop_new_inode(inode
);
1051 name
= kmalloc(item_len
, GFP_NOFS
);
1053 drop_new_inode(inode
);
1057 memcpy(name
, symname
, strlen(symname
));
1058 padd_item(name
, item_len
, strlen(symname
));
1060 retval
= journal_begin(&th
, parent_dir
->i_sb
, jbegin_count
);
1062 drop_new_inode(inode
);
1068 reiserfs_new_inode(&th
, parent_dir
, mode
, name
, strlen(symname
),
1069 dentry
, inode
, &security
);
1071 if (retval
) { /* reiserfs_new_inode iputs for us */
1075 reiserfs_update_inode_transaction(inode
);
1076 reiserfs_update_inode_transaction(parent_dir
);
1078 inode
->i_op
= &reiserfs_symlink_inode_operations
;
1079 inode
->i_mapping
->a_ops
= &reiserfs_address_space_operations
;
1081 // must be sure this inode is written with this transaction
1083 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1085 retval
= reiserfs_add_entry(&th
, parent_dir
, dentry
->d_name
.name
,
1086 dentry
->d_name
.len
, inode
, 1 /*visible */ );
1090 reiserfs_update_sd(&th
, inode
);
1091 err
= journal_end(&th
, parent_dir
->i_sb
, jbegin_count
);
1094 unlock_new_inode(inode
);
1099 d_instantiate(dentry
, inode
);
1100 unlock_new_inode(inode
);
1101 retval
= journal_end(&th
, parent_dir
->i_sb
, jbegin_count
);
1103 reiserfs_write_unlock(parent_dir
->i_sb
);
1107 static int reiserfs_link(struct dentry
*old_dentry
, struct inode
*dir
,
1108 struct dentry
*dentry
)
1111 struct inode
*inode
= old_dentry
->d_inode
;
1112 struct reiserfs_transaction_handle th
;
1113 /* We need blocks for transaction + update of quotas for the owners of the directory */
1115 JOURNAL_PER_BALANCE_CNT
* 3 +
1116 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir
->i_sb
);
1118 dquot_initialize(dir
);
1120 reiserfs_write_lock(dir
->i_sb
);
1121 if (inode
->i_nlink
>= REISERFS_LINK_MAX
) {
1122 //FIXME: sd_nlink is 32 bit for new files
1123 reiserfs_write_unlock(dir
->i_sb
);
1127 /* inc before scheduling so reiserfs_unlink knows we are here */
1130 retval
= journal_begin(&th
, dir
->i_sb
, jbegin_count
);
1133 reiserfs_write_unlock(dir
->i_sb
);
1137 /* create new entry */
1139 reiserfs_add_entry(&th
, dir
, dentry
->d_name
.name
,
1140 dentry
->d_name
.len
, inode
, 1 /*visible */ );
1142 reiserfs_update_inode_transaction(inode
);
1143 reiserfs_update_inode_transaction(dir
);
1148 err
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
1149 reiserfs_write_unlock(dir
->i_sb
);
1150 return err
? err
: retval
;
1153 inode
->i_ctime
= CURRENT_TIME_SEC
;
1154 reiserfs_update_sd(&th
, inode
);
1157 d_instantiate(dentry
, inode
);
1158 retval
= journal_end(&th
, dir
->i_sb
, jbegin_count
);
1159 reiserfs_write_unlock(dir
->i_sb
);
1163 /* de contains information pointing to an entry which */
1164 static int de_still_valid(const char *name
, int len
,
1165 struct reiserfs_dir_entry
*de
)
1167 struct reiserfs_dir_entry tmp
= *de
;
1169 // recalculate pointer to name and name length
1170 set_de_name_and_namelen(&tmp
);
1171 // FIXME: could check more
1172 if (tmp
.de_namelen
!= len
|| memcmp(name
, de
->de_name
, len
))
1177 static int entry_points_to_object(const char *name
, int len
,
1178 struct reiserfs_dir_entry
*de
,
1179 struct inode
*inode
)
1181 if (!de_still_valid(name
, len
, de
))
1185 if (!de_visible(de
->de_deh
+ de
->de_entry_num
))
1186 reiserfs_panic(inode
->i_sb
, "vs-7042",
1187 "entry must be visible");
1188 return (de
->de_objectid
== inode
->i_ino
) ? 1 : 0;
1191 /* this must be added hidden entry */
1192 if (de_visible(de
->de_deh
+ de
->de_entry_num
))
1193 reiserfs_panic(NULL
, "vs-7043", "entry must be visible");
1198 /* sets key of objectid the entry has to point to */
1199 static void set_ino_in_dir_entry(struct reiserfs_dir_entry
*de
,
1200 struct reiserfs_key
*key
)
1202 /* JDM These operations are endian safe - both are le */
1203 de
->de_deh
[de
->de_entry_num
].deh_dir_id
= key
->k_dir_id
;
1204 de
->de_deh
[de
->de_entry_num
].deh_objectid
= key
->k_objectid
;
1208 * process, that is going to call fix_nodes/do_balance must hold only
1209 * one path. If it holds 2 or more, it can get into endless waiting in
1210 * get_empty_nodes or its clones
1212 static int reiserfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1213 struct inode
*new_dir
, struct dentry
*new_dentry
)
1216 INITIALIZE_PATH(old_entry_path
);
1217 INITIALIZE_PATH(new_entry_path
);
1218 INITIALIZE_PATH(dot_dot_entry_path
);
1219 struct item_head new_entry_ih
, old_entry_ih
, dot_dot_ih
;
1220 struct reiserfs_dir_entry old_de
, new_de
, dot_dot_de
;
1221 struct inode
*old_inode
, *new_dentry_inode
;
1222 struct reiserfs_transaction_handle th
;
1224 umode_t old_inode_mode
;
1225 unsigned long savelink
= 1;
1226 struct timespec ctime
;
1228 /* three balancings: (1) old name removal, (2) new name insertion
1229 and (3) maybe "save" link insertion
1230 stat data updates: (1) old directory,
1231 (2) new directory and (3) maybe old object stat data (when it is
1232 directory) and (4) maybe stat data of object to which new entry
1233 pointed initially and (5) maybe block containing ".." of
1235 quota updates: two parent directories */
1237 JOURNAL_PER_BALANCE_CNT
* 3 + 5 +
1238 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir
->i_sb
);
1240 dquot_initialize(old_dir
);
1241 dquot_initialize(new_dir
);
1243 old_inode
= old_dentry
->d_inode
;
1244 new_dentry_inode
= new_dentry
->d_inode
;
1246 // make sure, that oldname still exists and points to an object we
1247 // are going to rename
1248 old_de
.de_gen_number_bit_string
= NULL
;
1249 reiserfs_write_lock(old_dir
->i_sb
);
1251 reiserfs_find_entry(old_dir
, old_dentry
->d_name
.name
,
1252 old_dentry
->d_name
.len
, &old_entry_path
,
1254 pathrelse(&old_entry_path
);
1255 if (retval
== IO_ERROR
) {
1256 reiserfs_write_unlock(old_dir
->i_sb
);
1260 if (retval
!= NAME_FOUND
|| old_de
.de_objectid
!= old_inode
->i_ino
) {
1261 reiserfs_write_unlock(old_dir
->i_sb
);
1265 old_inode_mode
= old_inode
->i_mode
;
1266 if (S_ISDIR(old_inode_mode
)) {
1267 // make sure, that directory being renamed has correct ".."
1268 // and that its new parent directory has not too many links
1271 if (new_dentry_inode
) {
1272 if (!reiserfs_empty_dir(new_dentry_inode
)) {
1273 reiserfs_write_unlock(old_dir
->i_sb
);
1278 /* directory is renamed, its parent directory will be changed,
1279 ** so find ".." entry
1281 dot_dot_de
.de_gen_number_bit_string
= NULL
;
1283 reiserfs_find_entry(old_inode
, "..", 2, &dot_dot_entry_path
,
1285 pathrelse(&dot_dot_entry_path
);
1286 if (retval
!= NAME_FOUND
) {
1287 reiserfs_write_unlock(old_dir
->i_sb
);
1291 /* inode number of .. must equal old_dir->i_ino */
1292 if (dot_dot_de
.de_objectid
!= old_dir
->i_ino
) {
1293 reiserfs_write_unlock(old_dir
->i_sb
);
1298 retval
= journal_begin(&th
, old_dir
->i_sb
, jbegin_count
);
1300 reiserfs_write_unlock(old_dir
->i_sb
);
1304 /* add new entry (or find the existing one) */
1306 reiserfs_add_entry(&th
, new_dir
, new_dentry
->d_name
.name
,
1307 new_dentry
->d_name
.len
, old_inode
, 0);
1308 if (retval
== -EEXIST
) {
1309 if (!new_dentry_inode
) {
1310 reiserfs_panic(old_dir
->i_sb
, "vs-7050",
1311 "new entry is found, new inode == 0");
1313 } else if (retval
) {
1314 int err
= journal_end(&th
, old_dir
->i_sb
, jbegin_count
);
1315 reiserfs_write_unlock(old_dir
->i_sb
);
1316 return err
? err
: retval
;
1319 reiserfs_update_inode_transaction(old_dir
);
1320 reiserfs_update_inode_transaction(new_dir
);
1322 /* this makes it so an fsync on an open fd for the old name will
1323 ** commit the rename operation
1325 reiserfs_update_inode_transaction(old_inode
);
1327 if (new_dentry_inode
)
1328 reiserfs_update_inode_transaction(new_dentry_inode
);
1331 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1333 search_by_entry_key(new_dir
->i_sb
, &old_de
.de_entry_key
,
1335 &old_de
)) != NAME_FOUND
) {
1336 pathrelse(&old_entry_path
);
1337 journal_end(&th
, old_dir
->i_sb
, jbegin_count
);
1338 reiserfs_write_unlock(old_dir
->i_sb
);
1342 copy_item_head(&old_entry_ih
, get_ih(&old_entry_path
));
1344 reiserfs_prepare_for_journal(old_inode
->i_sb
, old_de
.de_bh
, 1);
1346 // look for new name by reiserfs_find_entry
1347 new_de
.de_gen_number_bit_string
= NULL
;
1349 reiserfs_find_entry(new_dir
, new_dentry
->d_name
.name
,
1350 new_dentry
->d_name
.len
, &new_entry_path
,
1352 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1353 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1354 if (retval
!= NAME_FOUND_INVISIBLE
&& retval
!= NAME_FOUND
) {
1355 pathrelse(&new_entry_path
);
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(&new_entry_ih
, get_ih(&new_entry_path
));
1364 reiserfs_prepare_for_journal(old_inode
->i_sb
, new_de
.de_bh
, 1);
1366 if (S_ISDIR(old_inode
->i_mode
)) {
1368 search_by_entry_key(new_dir
->i_sb
,
1369 &dot_dot_de
.de_entry_key
,
1370 &dot_dot_entry_path
,
1371 &dot_dot_de
)) != NAME_FOUND
) {
1372 pathrelse(&dot_dot_entry_path
);
1373 pathrelse(&new_entry_path
);
1374 pathrelse(&old_entry_path
);
1375 journal_end(&th
, old_dir
->i_sb
, jbegin_count
);
1376 reiserfs_write_unlock(old_dir
->i_sb
);
1379 copy_item_head(&dot_dot_ih
,
1380 get_ih(&dot_dot_entry_path
));
1381 // node containing ".." gets into transaction
1382 reiserfs_prepare_for_journal(old_inode
->i_sb
,
1383 dot_dot_de
.de_bh
, 1);
1385 /* we should check seals here, not do
1386 this stuff, yes? Then, having
1387 gathered everything into RAM we
1388 should lock the buffers, yes? -Hans */
1389 /* probably. our rename needs to hold more
1390 ** than one path at once. The seals would
1391 ** have to be written to deal with multi-path
1394 /* sanity checking before doing the rename - avoid races many
1395 ** of the above checks could have scheduled. We have to be
1396 ** sure our items haven't been shifted by another process.
1398 if (item_moved(&new_entry_ih
, &new_entry_path
) ||
1399 !entry_points_to_object(new_dentry
->d_name
.name
,
1400 new_dentry
->d_name
.len
,
1401 &new_de
, new_dentry_inode
) ||
1402 item_moved(&old_entry_ih
, &old_entry_path
) ||
1403 !entry_points_to_object(old_dentry
->d_name
.name
,
1404 old_dentry
->d_name
.len
,
1405 &old_de
, old_inode
)) {
1406 reiserfs_restore_prepared_buffer(old_inode
->i_sb
,
1408 reiserfs_restore_prepared_buffer(old_inode
->i_sb
,
1410 if (S_ISDIR(old_inode_mode
))
1411 reiserfs_restore_prepared_buffer(old_inode
->
1417 if (S_ISDIR(old_inode_mode
)) {
1418 if (item_moved(&dot_dot_ih
, &dot_dot_entry_path
) ||
1419 !entry_points_to_object("..", 2, &dot_dot_de
,
1421 reiserfs_restore_prepared_buffer(old_inode
->
1424 reiserfs_restore_prepared_buffer(old_inode
->
1427 reiserfs_restore_prepared_buffer(old_inode
->
1435 RFALSE(S_ISDIR(old_inode_mode
) &&
1436 !buffer_journal_prepared(dot_dot_de
.de_bh
), "");
1441 /* ok, all the changes can be done in one fell swoop when we
1442 have claimed all the buffers needed. */
1444 mark_de_visible(new_de
.de_deh
+ new_de
.de_entry_num
);
1445 set_ino_in_dir_entry(&new_de
, INODE_PKEY(old_inode
));
1446 journal_mark_dirty(&th
, old_dir
->i_sb
, new_de
.de_bh
);
1448 mark_de_hidden(old_de
.de_deh
+ old_de
.de_entry_num
);
1449 journal_mark_dirty(&th
, old_dir
->i_sb
, old_de
.de_bh
);
1450 ctime
= CURRENT_TIME_SEC
;
1451 old_dir
->i_ctime
= old_dir
->i_mtime
= ctime
;
1452 new_dir
->i_ctime
= new_dir
->i_mtime
= ctime
;
1453 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1455 old_inode
->i_ctime
= ctime
;
1457 if (new_dentry_inode
) {
1458 // adjust link number of the victim
1459 if (S_ISDIR(new_dentry_inode
->i_mode
)) {
1460 clear_nlink(new_dentry_inode
);
1462 drop_nlink(new_dentry_inode
);
1464 new_dentry_inode
->i_ctime
= ctime
;
1465 savelink
= new_dentry_inode
->i_nlink
;
1468 if (S_ISDIR(old_inode_mode
)) {
1469 /* adjust ".." of renamed directory */
1470 set_ino_in_dir_entry(&dot_dot_de
, INODE_PKEY(new_dir
));
1471 journal_mark_dirty(&th
, new_dir
->i_sb
, dot_dot_de
.de_bh
);
1473 if (!new_dentry_inode
)
1474 /* there (in new_dir) was no directory, so it got new link
1475 (".." of renamed directory) */
1476 INC_DIR_INODE_NLINK(new_dir
);
1478 /* old directory lost one link - ".. " of renamed directory */
1479 DEC_DIR_INODE_NLINK(old_dir
);
1481 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1482 pathrelse(&new_entry_path
);
1483 pathrelse(&dot_dot_entry_path
);
1485 // FIXME: this reiserfs_cut_from_item's return value may screw up
1486 // anybody, but it will panic if will not be able to find the
1487 // entry. This needs one more clean up
1488 if (reiserfs_cut_from_item
1489 (&th
, &old_entry_path
, &(old_de
.de_entry_key
), old_dir
, NULL
,
1491 reiserfs_error(old_dir
->i_sb
, "vs-7060",
1492 "couldn't not cut old name. Fsck later?");
1494 old_dir
->i_size
-= DEH_SIZE
+ old_de
.de_entrylen
;
1496 reiserfs_update_sd(&th
, old_dir
);
1497 reiserfs_update_sd(&th
, new_dir
);
1498 reiserfs_update_sd(&th
, old_inode
);
1500 if (new_dentry_inode
) {
1502 add_save_link(&th
, new_dentry_inode
,
1503 0 /* not truncate */ );
1504 reiserfs_update_sd(&th
, new_dentry_inode
);
1507 retval
= journal_end(&th
, old_dir
->i_sb
, jbegin_count
);
1508 reiserfs_write_unlock(old_dir
->i_sb
);
1513 * directories can handle most operations...
1515 const struct inode_operations reiserfs_dir_inode_operations
= {
1516 //&reiserfs_dir_operations, /* default_file_ops */
1517 .create
= reiserfs_create
,
1518 .lookup
= reiserfs_lookup
,
1519 .link
= reiserfs_link
,
1520 .unlink
= reiserfs_unlink
,
1521 .symlink
= reiserfs_symlink
,
1522 .mkdir
= reiserfs_mkdir
,
1523 .rmdir
= reiserfs_rmdir
,
1524 .mknod
= reiserfs_mknod
,
1525 .rename
= reiserfs_rename
,
1526 .setattr
= reiserfs_setattr
,
1527 .setxattr
= reiserfs_setxattr
,
1528 .getxattr
= reiserfs_getxattr
,
1529 .listxattr
= reiserfs_listxattr
,
1530 .removexattr
= reiserfs_removexattr
,
1531 .permission
= reiserfs_permission
,
1532 .get_acl
= reiserfs_get_acl
,
1536 * symlink operations.. same as page_symlink_inode_operations, with xattr
1539 const struct inode_operations reiserfs_symlink_inode_operations
= {
1540 .readlink
= generic_readlink
,
1541 .follow_link
= page_follow_link_light
,
1542 .put_link
= page_put_link
,
1543 .setattr
= reiserfs_setattr
,
1544 .setxattr
= reiserfs_setxattr
,
1545 .getxattr
= reiserfs_getxattr
,
1546 .listxattr
= reiserfs_listxattr
,
1547 .removexattr
= reiserfs_removexattr
,
1548 .permission
= reiserfs_permission
,
1549 .get_acl
= reiserfs_get_acl
,
1554 * special file operations.. just xattr/acl stuff
1556 const struct inode_operations reiserfs_special_inode_operations
= {
1557 .setattr
= reiserfs_setattr
,
1558 .setxattr
= reiserfs_setxattr
,
1559 .getxattr
= reiserfs_getxattr
,
1560 .listxattr
= reiserfs_listxattr
,
1561 .removexattr
= reiserfs_removexattr
,
1562 .permission
= reiserfs_permission
,
1563 .get_acl
= reiserfs_get_acl
,