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/smp_lock.h>
20 #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; }
21 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) i->i_nlink--;
23 // directory item contains array of entry headers. This performs
24 // binary search through that array
25 static int bin_search_in_dir_item (struct reiserfs_dir_entry * de, loff_t off)
27 struct item_head * ih = de->de_ih;
28 struct reiserfs_de_head * deh = de->de_deh;
29 int rbound, lbound, j;
32 rbound = I_ENTRY_COUNT (ih) - 1;
34 for (j = (rbound + lbound) / 2; lbound <= rbound; j = (rbound + lbound) / 2) {
35 if (off < deh_offset (deh + j)) {
39 if (off > deh_offset (deh + j)) {
43 // this is not name found, but matched third key component
48 de->de_entry_num = lbound;
49 return NAME_NOT_FOUND;
53 // comment? maybe something like set de to point to what the path points to?
54 static inline void set_de_item_location (struct reiserfs_dir_entry * de, struct path * path)
56 de->de_bh = get_last_bh (path);
57 de->de_ih = get_ih (path);
58 de->de_deh = B_I_DEH (de->de_bh, de->de_ih);
59 de->de_item_num = PATH_LAST_POSITION (path);
63 // de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
64 inline void set_de_name_and_namelen (struct reiserfs_dir_entry * de)
66 struct reiserfs_de_head * deh = de->de_deh + de->de_entry_num;
68 if (de->de_entry_num >= ih_entry_count (de->de_ih))
71 de->de_entrylen = entry_length (de->de_bh, de->de_ih, de->de_entry_num);
72 de->de_namelen = de->de_entrylen - (de_with_sd (deh) ? SD_SIZE : 0);
73 de->de_name = B_I_PITEM (de->de_bh, de->de_ih) + deh_location(deh);
74 if (de->de_name[de->de_namelen - 1] == 0)
75 de->de_namelen = strlen (de->de_name);
79 // what entry points to
80 static inline void set_de_object_key (struct reiserfs_dir_entry * de)
82 if (de->de_entry_num >= ih_entry_count (de->de_ih))
84 de->de_dir_id = deh_dir_id( &(de->de_deh[de->de_entry_num]));
85 de->de_objectid = deh_objectid( &(de->de_deh[de->de_entry_num]));
89 static inline void store_de_entry_key (struct reiserfs_dir_entry * de)
91 struct reiserfs_de_head * deh = de->de_deh + de->de_entry_num;
93 if (de->de_entry_num >= ih_entry_count (de->de_ih))
96 /* store key of the found entry */
97 de->de_entry_key.version = KEY_FORMAT_3_5;
98 de->de_entry_key.on_disk_key.k_dir_id = le32_to_cpu (de->de_ih->ih_key.k_dir_id);
99 de->de_entry_key.on_disk_key.k_objectid = le32_to_cpu (de->de_ih->ih_key.k_objectid);
100 set_cpu_key_k_offset (&(de->de_entry_key), deh_offset (deh));
101 set_cpu_key_k_type (&(de->de_entry_key), TYPE_DIRENTRY);
105 /* We assign a key to each directory item, and place multiple entries
106 in a single directory item. A directory item has a key equal to the
107 key of the first directory entry in it.
109 This function first calls search_by_key, then, if item whose first
110 entry matches is not found it looks for the entry inside directory
111 item found by search_by_key. Fills the path to the entry, and to the
112 entry position in the item
116 /* The function is NOT SCHEDULE-SAFE! */
117 int search_by_entry_key (struct super_block * sb, const struct cpu_key * key,
118 struct path * path, struct reiserfs_dir_entry * de)
122 retval = search_item (sb, key, path);
125 if (!PATH_LAST_POSITION (path)) {
126 reiserfs_warning ("vs-7000: search_by_entry_key: search_by_key returned item position == 0");
130 PATH_LAST_POSITION (path) --;
140 reiserfs_warning ("vs-7002: search_by_entry_key: no path to here");
144 set_de_item_location (de, path);
146 #ifdef CONFIG_REISERFS_CHECK
147 if (!is_direntry_le_ih (de->de_ih) ||
148 COMP_SHORT_KEYS (&(de->de_ih->ih_key), key)) {
149 print_block (de->de_bh, 0, -1, -1);
150 reiserfs_panic (sb, "vs-7005: search_by_entry_key: found item %h is not directory item or "
151 "does not belong to the same directory 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);
169 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
171 /* The third component is hashed, and you can choose from more than
172 one hash function. Per directory hashes are not yet implemented
173 but are thought about. This function should be moved to hashes.c
174 Jedi, please do so. -Hans */
176 static __u32 get_third_component (struct super_block * s,
177 const char * name, int len)
181 if (!len || (len == 1 && name[0] == '.'))
183 if (len == 2 && name[0] == '.' && name[1] == '.')
184 return DOT_DOT_OFFSET;
186 res = REISERFS_SB(s)->s_hash_function (name, len);
188 // take bits from 7-th to 30-th including both bounds
189 res = GET_HASH_VALUE(res);
191 // needed to have no names before "." and ".." those have hash
192 // value == 0 and generation conters 1 and 2 accordingly
194 return res + MAX_GENERATION_NUMBER;
198 static int reiserfs_match (struct reiserfs_dir_entry * de,
199 const char * name, int namelen)
201 int retval = NAME_NOT_FOUND;
203 if ((namelen == de->de_namelen) &&
204 !memcmp(de->de_name, name, de->de_namelen))
205 retval = (de_visible (de->de_deh + de->de_entry_num) ? NAME_FOUND : NAME_FOUND_INVISIBLE);
211 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
213 /* used when hash collisions exist */
216 static int linear_search_in_dir_item (struct cpu_key * key, struct reiserfs_dir_entry * de,
217 const char * name, int namelen)
219 struct reiserfs_de_head * deh = de->de_deh;
223 i = de->de_entry_num;
225 if (i == I_ENTRY_COUNT (de->de_ih) ||
226 GET_HASH_VALUE (deh_offset (deh + i)) != GET_HASH_VALUE (cpu_key_k_offset (key))) {
230 RFALSE( de->de_deh != B_I_DEH (de->de_bh, de->de_ih),
231 "vs-7010: array of entry headers not found");
235 for (; i >= 0; i --, deh --) {
236 if (GET_HASH_VALUE (deh_offset (deh)) !=
237 GET_HASH_VALUE (cpu_key_k_offset (key))) {
238 // hash value does not match, no need to check whole name
239 return NAME_NOT_FOUND;
242 /* mark, that this generation number is used */
243 if (de->de_gen_number_bit_string)
244 set_bit (GET_GENERATION_NUMBER (deh_offset (deh)), (unsigned long *)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);
250 if ((retval = reiserfs_match (de, name, namelen)) != NAME_NOT_FOUND) {
251 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
253 // key of pointed object
254 set_de_object_key (de);
256 store_de_entry_key (de);
258 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
263 if (GET_GENERATION_NUMBER (le_ih_k_offset (de->de_ih)) == 0)
264 /* we have reached left most entry in the node. In common we
265 have to go to the left neighbor, but if generation counter
266 is 0 already, we know for sure, that there is no name with
267 the same hash value */
268 // FIXME: this work correctly only because hash value can not
269 // be 0. Btw, in case of Yura's hash it is probably possible,
271 return NAME_NOT_FOUND;
273 RFALSE( de->de_item_num,
274 "vs-7015: two diritems of the same directory in one node?");
276 return GOTO_PREVIOUS_ITEM;
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 path * path_to_entry, struct reiserfs_dir_entry * de)
285 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), TYPE_DIRENTRY, 3);
297 retval = search_by_entry_key (dir->i_sb, &key_to_search, path_to_entry, de);
298 if (retval == IO_ERROR) {
299 reiserfs_warning ("zam-7001: io error in %s\n", __FUNCTION__);
303 /* compare names for all entries having given hash value */
304 retval = linear_search_in_dir_item (&key_to_search, de, name, namelen);
305 if (retval != GOTO_PREVIOUS_ITEM) {
306 /* there is no need to scan directory anymore. Given entry found or does not exist */
307 path_to_entry->pos_in_item = de->de_entry_num;
311 /* there is left neighboring item of this directory and given entry can be there */
312 set_cpu_key_k_offset (&key_to_search, le_ih_k_offset (de->de_ih) - 1);
313 pathrelse (path_to_entry);
319 static struct dentry * reiserfs_lookup (struct inode * dir, struct dentry * dentry, struct nameidata *nd)
322 struct inode * inode = NULL;
323 struct reiserfs_dir_entry de;
324 INITIALIZE_PATH (path_to_entry);
326 if (REISERFS_MAX_NAME (dir->i_sb->s_blocksize) < dentry->d_name.len)
327 return ERR_PTR(-ENAMETOOLONG);
329 reiserfs_write_lock(dir->i_sb);
330 de.de_gen_number_bit_string = 0;
331 retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de);
332 pathrelse (&path_to_entry);
333 if (retval == NAME_FOUND) {
334 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
335 if (!inode || IS_ERR(inode)) {
336 reiserfs_write_unlock(dir->i_sb);
337 return ERR_PTR(-EACCES);
340 reiserfs_write_unlock(dir->i_sb);
341 if ( retval == IO_ERROR ) {
342 return ERR_PTR(-EIO);
346 return d_splice_alias(inode, dentry);
348 d_add(dentry, inode);
354 ** looks up the dentry of the parent directory for child.
355 ** taken from ext2_get_parent
357 struct dentry *reiserfs_get_parent(struct dentry *child)
360 struct inode * inode = NULL;
361 struct reiserfs_dir_entry de;
362 INITIALIZE_PATH (path_to_entry);
363 struct dentry *parent;
364 struct inode *dir = child->d_inode ;
367 if (dir->i_nlink == 0) {
368 return ERR_PTR(-ENOENT);
370 de.de_gen_number_bit_string = 0;
372 reiserfs_write_lock(dir->i_sb);
373 retval = reiserfs_find_entry (dir, "..", 2, &path_to_entry, &de);
374 pathrelse (&path_to_entry);
375 if (retval != NAME_FOUND) {
376 reiserfs_write_unlock(dir->i_sb);
377 return ERR_PTR(-ENOENT);
379 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
380 reiserfs_write_unlock(dir->i_sb);
382 if (!inode || IS_ERR(inode)) {
383 return ERR_PTR(-EACCES);
385 parent = d_alloc_anon(inode);
388 parent = ERR_PTR(-ENOMEM);
394 /* add entry to the directory (entry can be hidden).
396 insert definition of when hidden directories are used here -Hans
398 Does not mark dir inode dirty, do it after successesfull call to it */
400 static int reiserfs_add_entry (struct reiserfs_transaction_handle *th, struct inode * dir,
401 const char * name, int namelen, struct inode * inode,
404 struct cpu_key entry_key;
405 struct reiserfs_de_head * deh;
406 INITIALIZE_PATH (path);
407 struct reiserfs_dir_entry de;
408 int bit_string [MAX_GENERATION_NUMBER / (sizeof(int) * 8) + 1];
410 char small_buf[32+DEH_SIZE] ; /* 48 bytes now and we avoid kmalloc
411 if we create file with short name */
413 int buflen, paste_size;
417 /* cannot allow items to be added into a busy deleted directory */
421 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize))
422 return -ENAMETOOLONG;
424 /* each entry has unique key. compose it */
425 make_cpu_key (&entry_key, dir,
426 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3);
428 /* get memory for composing the entry */
429 buflen = DEH_SIZE + ROUND_UP (namelen);
430 if (buflen > sizeof (small_buf)) {
431 buffer = reiserfs_kmalloc (buflen, GFP_NOFS, dir->i_sb);
437 paste_size = (get_inode_sd_version (dir) == STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
439 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
440 deh = (struct reiserfs_de_head *)buffer;
441 deh->deh_location = 0; /* JDM Endian safe if 0 */
442 put_deh_offset( deh, cpu_key_k_offset( &entry_key ) );
443 deh->deh_state = 0; /* JDM Endian safe if 0 */
444 /* put key (ino analog) to de */
445 deh->deh_dir_id = INODE_PKEY (inode)->k_dir_id; /* safe: k_dir_id is le */
446 deh->deh_objectid = INODE_PKEY (inode)->k_objectid; /* safe: k_objectid is le */
449 memcpy ((char *)(deh + 1), name, namelen);
450 /* padd by 0s to the 4 byte boundary */
451 padd_item ((char *)(deh + 1), ROUND_UP (namelen), namelen);
453 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
454 mark_de_without_sd (deh);
455 visible ? mark_de_visible (deh) : mark_de_hidden (deh);
457 /* find the proper place for the new entry */
458 memset (bit_string, 0, sizeof (bit_string));
459 de.de_gen_number_bit_string = (char *)bit_string;
460 retval = reiserfs_find_entry (dir, name, namelen, &path, &de);
461 if( retval != NAME_NOT_FOUND ) {
462 if (buffer != small_buf)
463 reiserfs_kfree (buffer, buflen, dir->i_sb);
466 if ( retval == IO_ERROR ) {
470 if (retval != NAME_FOUND) {
471 reiserfs_warning ("zam-7002:%s: \"reiserfs_find_entry\" has returned"
472 " unexpected value (%d)\n", __FUNCTION__, retval);
478 gen_number = find_first_zero_bit ((unsigned long *)bit_string, MAX_GENERATION_NUMBER + 1);
479 if (gen_number > MAX_GENERATION_NUMBER) {
480 /* there is no free generation number */
481 reiserfs_warning ("reiserfs_add_entry: Congratulations! we have got hash function screwed up\n");
482 if (buffer != small_buf)
483 reiserfs_kfree (buffer, buflen, dir->i_sb);
487 /* adjust offset of directory enrty */
488 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
489 set_cpu_key_k_offset (&entry_key, deh_offset(deh));
491 /* update max-hash-collisions counter in reiserfs_sb_info */
492 PROC_INFO_MAX( th -> t_super, max_hash_collisions, gen_number );
494 if (gen_number != 0) { /* we need to re-search for the insertion point */
495 if (search_by_entry_key (dir->i_sb, &entry_key, &path, &de) != NAME_NOT_FOUND) {
496 reiserfs_warning ("vs-7032: reiserfs_add_entry: "
497 "entry with this key (%K) already exists\n", &entry_key);
499 if (buffer != small_buf)
500 reiserfs_kfree (buffer, buflen, dir->i_sb);
506 /* perform the insertion of the entry that we have prepared */
507 retval = reiserfs_paste_into_item (th, &path, &entry_key, buffer, paste_size);
508 if (buffer != small_buf)
509 reiserfs_kfree (buffer, buflen, dir->i_sb);
511 reiserfs_check_path(&path) ;
515 dir->i_size += paste_size;
516 dir->i_blocks = ((dir->i_size + 511) >> 9);
517 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
518 if (!S_ISDIR (inode->i_mode) && visible)
519 // reiserfs_mkdir or reiserfs_rename will do that by itself
520 reiserfs_update_sd (th, dir);
522 reiserfs_check_path(&path) ;
526 /* quota utility function, call if you've had to abort after calling
527 ** new_inode_init, and have not called reiserfs_new_inode yet.
528 ** This should only be called on inodes that do not hav stat data
529 ** inserted into the tree yet.
531 static int drop_new_inode(struct inode *inode) {
532 make_bad_inode(inode) ;
537 /* utility function that does setup for reiserfs_new_inode.
538 ** DQUOT_ALLOC_INODE cannot be called inside a transaction, so we had
539 ** to pull some bits of reiserfs_new_inode out into this func.
540 ** Yes, the actual quota calls are missing, they are part of the quota
543 static int new_inode_init(struct inode *inode, struct inode *dir, int mode) {
545 /* the quota init calls have to know who to charge the quota to, so
546 ** we have to set uid and gid here
548 inode->i_uid = current->fsuid;
549 inode->i_mode = mode;
551 if (dir->i_mode & S_ISGID) {
552 inode->i_gid = dir->i_gid;
554 inode->i_mode |= S_ISGID;
556 inode->i_gid = current->fsgid;
561 static int reiserfs_create (struct inode * dir, struct dentry *dentry, int mode,
562 struct nameidata *nd)
565 struct inode * inode;
566 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 ;
567 struct reiserfs_transaction_handle th ;
569 if (!(inode = new_inode(dir->i_sb))) {
572 retval = new_inode_init(inode, dir, mode);
576 reiserfs_write_lock(dir->i_sb);
577 journal_begin(&th, dir->i_sb, jbegin_count) ;
578 retval = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode);
583 inode->i_op = &reiserfs_file_inode_operations;
584 inode->i_fop = &reiserfs_file_operations;
585 inode->i_mapping->a_ops = &reiserfs_address_space_operations ;
587 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
588 inode, 1/*visible*/);
591 reiserfs_update_sd (&th, inode);
592 journal_end(&th, dir->i_sb, jbegin_count) ;
596 reiserfs_update_inode_transaction(inode) ;
597 reiserfs_update_inode_transaction(dir) ;
599 d_instantiate(dentry, inode);
600 journal_end(&th, dir->i_sb, jbegin_count) ;
603 reiserfs_write_unlock(dir->i_sb);
608 static int reiserfs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
611 struct inode * inode;
612 struct reiserfs_transaction_handle th ;
613 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
615 if (!new_valid_dev(rdev))
618 if (!(inode = new_inode(dir->i_sb))) {
621 retval = new_inode_init(inode, dir, mode);
625 reiserfs_write_lock(dir->i_sb);
626 journal_begin(&th, dir->i_sb, jbegin_count) ;
628 retval = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode);
633 init_special_inode(inode, mode, rdev) ;
635 //FIXME: needed for block and char devices only
636 reiserfs_update_sd (&th, inode);
638 reiserfs_update_inode_transaction(inode) ;
639 reiserfs_update_inode_transaction(dir) ;
641 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
642 inode, 1/*visible*/);
645 reiserfs_update_sd (&th, inode);
646 journal_end(&th, dir->i_sb, jbegin_count) ;
651 d_instantiate(dentry, inode);
652 journal_end(&th, dir->i_sb, jbegin_count) ;
655 reiserfs_write_unlock(dir->i_sb);
660 static int reiserfs_mkdir (struct inode * dir, struct dentry *dentry, int mode)
663 struct inode * inode;
664 struct reiserfs_transaction_handle th ;
665 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
667 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
668 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
669 REISERFS_I(dir)->new_packing_locality = 1;
671 mode = S_IFDIR | mode;
672 if (!(inode = new_inode(dir->i_sb))) {
675 retval = new_inode_init(inode, dir, mode);
679 reiserfs_write_lock(dir->i_sb);
680 journal_begin(&th, dir->i_sb, jbegin_count) ;
682 /* inc the link count now, so another writer doesn't overflow it while
683 ** we sleep later on.
685 INC_DIR_INODE_NLINK(dir)
687 retval = reiserfs_new_inode (&th, dir, mode, 0/*symlink*/,
688 old_format_only (dir->i_sb) ?
689 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
695 reiserfs_update_inode_transaction(inode) ;
696 reiserfs_update_inode_transaction(dir) ;
698 inode->i_op = &reiserfs_dir_inode_operations;
699 inode->i_fop = &reiserfs_dir_operations;
701 // note, _this_ add_entry will not update dir's stat data
702 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
703 inode, 1/*visible*/);
706 DEC_DIR_INODE_NLINK(dir);
707 reiserfs_update_sd (&th, inode);
708 journal_end(&th, dir->i_sb, jbegin_count) ;
713 // the above add_entry did not update dir's stat data
714 reiserfs_update_sd (&th, dir);
716 d_instantiate(dentry, inode);
717 journal_end(&th, dir->i_sb, jbegin_count) ;
719 reiserfs_write_unlock(dir->i_sb);
723 static inline int reiserfs_empty_dir(struct inode *inode) {
724 /* we can cheat because an old format dir cannot have
725 ** EMPTY_DIR_SIZE, and a new format dir cannot have
726 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
727 ** regardless of disk format version, the directory is empty.
729 if (inode->i_size != EMPTY_DIR_SIZE &&
730 inode->i_size != EMPTY_DIR_SIZE_V1) {
736 static int reiserfs_rmdir (struct inode * dir, struct dentry *dentry)
739 struct inode * inode;
740 struct reiserfs_transaction_handle th ;
742 INITIALIZE_PATH (path);
743 struct reiserfs_dir_entry de;
746 /* we will be doing 2 balancings and update 2 stat data */
747 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
749 reiserfs_write_lock(dir->i_sb);
750 journal_begin(&th, dir->i_sb, jbegin_count) ;
752 de.de_gen_number_bit_string = 0;
753 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
756 } else if ( retval == IO_ERROR) {
761 inode = dentry->d_inode;
763 reiserfs_update_inode_transaction(inode) ;
764 reiserfs_update_inode_transaction(dir) ;
766 if (de.de_objectid != inode->i_ino) {
767 // FIXME: compare key of an object and a key found in the
772 if (!reiserfs_empty_dir(inode)) {
777 /* cut entry from dir directory */
778 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir,
780 0/*new file size - not used here*/);
784 if ( inode->i_nlink != 2 && inode->i_nlink != 1 )
785 printk ("reiserfs_rmdir: empty directory has nlink != 2 (%d)\n", inode->i_nlink);
788 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
789 reiserfs_update_sd (&th, inode);
791 DEC_DIR_INODE_NLINK(dir)
792 dir->i_size -= (DEH_SIZE + de.de_entrylen);
793 dir->i_blocks = ((dir->i_size + 511) >> 9);
794 reiserfs_update_sd (&th, dir);
796 /* prevent empty directory from getting lost */
797 add_save_link (&th, inode, 0/* not truncate */);
799 journal_end(&th, dir->i_sb, jbegin_count) ;
800 reiserfs_check_path(&path) ;
801 reiserfs_write_unlock(dir->i_sb);
805 /* we must release path, because we did not call
806 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
807 release path if operation was not complete */
809 journal_end(&th, dir->i_sb, jbegin_count) ;
810 reiserfs_write_unlock(dir->i_sb);
814 static int reiserfs_unlink (struct inode * dir, struct dentry *dentry)
817 struct inode * inode;
818 struct reiserfs_dir_entry de;
819 INITIALIZE_PATH (path);
820 struct reiserfs_transaction_handle th ;
822 unsigned long savelink;
824 inode = dentry->d_inode;
826 /* in this transaction we can be doing at max two balancings and update
828 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
830 reiserfs_write_lock(dir->i_sb);
831 journal_begin(&th, dir->i_sb, jbegin_count) ;
833 de.de_gen_number_bit_string = 0;
834 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
837 } else if (retval == IO_ERROR) {
842 reiserfs_update_inode_transaction(inode) ;
843 reiserfs_update_inode_transaction(dir) ;
845 if (de.de_objectid != inode->i_ino) {
846 // FIXME: compare key of an object and a key found in the
852 if (!inode->i_nlink) {
853 printk("reiserfs_unlink: deleting nonexistent file (%s:%lu), %d\n",
854 reiserfs_bdevname (inode->i_sb), inode->i_ino, inode->i_nlink);
861 * we schedule before doing the add_save_link call, save the link
862 * count so we don't race
864 savelink = inode->i_nlink;
867 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir, NULL, 0);
872 inode->i_ctime = CURRENT_TIME;
873 reiserfs_update_sd (&th, inode);
875 dir->i_size -= (de.de_entrylen + DEH_SIZE);
876 dir->i_blocks = ((dir->i_size + 511) >> 9);
877 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
878 reiserfs_update_sd (&th, dir);
881 /* prevent file from getting lost */
882 add_save_link (&th, inode, 0/* not truncate */);
884 journal_end(&th, dir->i_sb, jbegin_count) ;
885 reiserfs_check_path(&path) ;
886 reiserfs_write_unlock(dir->i_sb);
891 journal_end(&th, dir->i_sb, jbegin_count) ;
892 reiserfs_check_path(&path) ;
893 reiserfs_write_unlock(dir->i_sb);
897 static int reiserfs_symlink (struct inode * parent_dir,
898 struct dentry * dentry, const char * symname)
901 struct inode * inode;
904 struct reiserfs_transaction_handle th ;
905 int mode = S_IFLNK | S_IRWXUGO;
906 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
908 if (!(inode = new_inode(parent_dir->i_sb))) {
911 retval = new_inode_init(inode, parent_dir, mode);
916 reiserfs_write_lock(parent_dir->i_sb);
917 item_len = ROUND_UP (strlen (symname));
918 if (item_len > MAX_DIRECT_ITEM_LEN (parent_dir->i_sb->s_blocksize)) {
919 retval = -ENAMETOOLONG;
920 drop_new_inode(inode);
924 name = reiserfs_kmalloc (item_len, GFP_NOFS, parent_dir->i_sb);
926 drop_new_inode(inode);
930 memcpy (name, symname, strlen (symname));
931 padd_item (name, item_len, strlen (symname));
933 journal_begin(&th, parent_dir->i_sb, jbegin_count) ;
935 retval = reiserfs_new_inode (&th, parent_dir, mode, name, strlen (symname),
937 reiserfs_kfree (name, item_len, parent_dir->i_sb);
938 if (retval) { /* reiserfs_new_inode iputs for us */
942 reiserfs_update_inode_transaction(inode) ;
943 reiserfs_update_inode_transaction(parent_dir) ;
945 inode->i_op = &page_symlink_inode_operations;
946 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
948 // must be sure this inode is written with this transaction
950 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
952 retval = reiserfs_add_entry (&th, parent_dir, dentry->d_name.name,
953 dentry->d_name.len, inode, 1/*visible*/);
956 reiserfs_update_sd (&th, inode);
957 journal_end(&th, parent_dir->i_sb, jbegin_count) ;
962 d_instantiate(dentry, inode);
963 journal_end(&th, parent_dir->i_sb, jbegin_count) ;
965 reiserfs_write_unlock(parent_dir->i_sb);
969 static int reiserfs_link (struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
972 struct inode *inode = old_dentry->d_inode;
973 struct reiserfs_transaction_handle th ;
974 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
976 reiserfs_write_lock(dir->i_sb);
977 if (inode->i_nlink >= REISERFS_LINK_MAX) {
978 //FIXME: sd_nlink is 32 bit for new files
979 reiserfs_write_unlock(dir->i_sb);
982 if (inode->i_nlink == 0) {
986 /* inc before scheduling so reiserfs_unlink knows we are here */
989 journal_begin(&th, dir->i_sb, jbegin_count) ;
991 /* create new entry */
992 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
993 inode, 1/*visible*/);
995 reiserfs_update_inode_transaction(inode) ;
996 reiserfs_update_inode_transaction(dir) ;
1000 journal_end(&th, dir->i_sb, jbegin_count) ;
1001 reiserfs_write_unlock(dir->i_sb);
1005 inode->i_ctime = CURRENT_TIME;
1006 reiserfs_update_sd (&th, inode);
1008 atomic_inc(&inode->i_count) ;
1009 d_instantiate(dentry, inode);
1010 journal_end(&th, dir->i_sb, jbegin_count) ;
1011 reiserfs_write_unlock(dir->i_sb);
1016 // de contains information pointing to an entry which
1017 static int de_still_valid (const char * name, int len, struct reiserfs_dir_entry * de)
1019 struct reiserfs_dir_entry tmp = *de;
1021 // recalculate pointer to name and name length
1022 set_de_name_and_namelen (&tmp);
1023 // FIXME: could check more
1024 if (tmp.de_namelen != len || memcmp (name, de->de_name, len))
1030 static int entry_points_to_object (const char * name, int len, struct reiserfs_dir_entry * de, struct inode * inode)
1032 if (!de_still_valid (name, len, de))
1036 if (!de_visible (de->de_deh + de->de_entry_num))
1037 reiserfs_panic (0, "vs-7042: entry_points_to_object: entry must be visible");
1038 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1041 /* this must be added hidden entry */
1042 if (de_visible (de->de_deh + de->de_entry_num))
1043 reiserfs_panic (0, "vs-7043: entry_points_to_object: entry must be visible");
1049 /* sets key of objectid the entry has to point to */
1050 static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct key * key)
1052 /* JDM These operations are endian safe - both are le */
1053 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1054 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1059 * process, that is going to call fix_nodes/do_balance must hold only
1060 * one path. If it holds 2 or more, it can get into endless waiting in
1061 * get_empty_nodes or its clones
1063 static int reiserfs_rename (struct inode * old_dir, struct dentry *old_dentry,
1064 struct inode * new_dir, struct dentry *new_dentry)
1067 INITIALIZE_PATH (old_entry_path);
1068 INITIALIZE_PATH (new_entry_path);
1069 INITIALIZE_PATH (dot_dot_entry_path);
1070 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih ;
1071 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1072 struct inode * old_inode, * new_dentry_inode;
1073 struct reiserfs_transaction_handle th ;
1075 umode_t old_inode_mode;
1076 unsigned long savelink = 1;
1077 struct timespec ctime;
1079 /* three balancings: (1) old name removal, (2) new name insertion
1080 and (3) maybe "save" link insertion
1081 stat data updates: (1) old directory,
1082 (2) new directory and (3) maybe old object stat data (when it is
1083 directory) and (4) maybe stat data of object to which new entry
1084 pointed initially and (5) maybe block containing ".." of
1085 renamed directory */
1086 jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 5;
1088 old_inode = old_dentry->d_inode;
1089 new_dentry_inode = new_dentry->d_inode;
1091 // make sure, that oldname still exists and points to an object we
1092 // are going to rename
1093 old_de.de_gen_number_bit_string = 0;
1094 reiserfs_write_lock(old_dir->i_sb);
1095 retval = reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len,
1096 &old_entry_path, &old_de);
1097 pathrelse (&old_entry_path);
1098 if (retval == IO_ERROR) {
1099 reiserfs_write_unlock(old_dir->i_sb);
1103 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1104 reiserfs_write_unlock(old_dir->i_sb);
1108 old_inode_mode = old_inode->i_mode;
1109 if (S_ISDIR(old_inode_mode)) {
1110 // make sure, that directory being renamed has correct ".."
1111 // and that its new parent directory has not too many links
1114 if (new_dentry_inode) {
1115 if (!reiserfs_empty_dir(new_dentry_inode)) {
1116 reiserfs_write_unlock(old_dir->i_sb);
1121 /* directory is renamed, its parent directory will be changed,
1122 ** so find ".." entry
1124 dot_dot_de.de_gen_number_bit_string = 0;
1125 retval = reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de);
1126 pathrelse (&dot_dot_entry_path);
1127 if (retval != NAME_FOUND) {
1128 reiserfs_write_unlock(old_dir->i_sb);
1132 /* inode number of .. must equal old_dir->i_ino */
1133 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1134 reiserfs_write_unlock(old_dir->i_sb);
1139 journal_begin(&th, old_dir->i_sb, jbegin_count) ;
1141 /* add new entry (or find the existing one) */
1142 retval = reiserfs_add_entry (&th, new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1144 if (retval == -EEXIST) {
1145 if (!new_dentry_inode) {
1146 reiserfs_panic (old_dir->i_sb,
1147 "vs-7050: new entry is found, new inode == 0\n");
1149 } else if (retval) {
1150 journal_end(&th, old_dir->i_sb, jbegin_count) ;
1151 reiserfs_write_unlock(old_dir->i_sb);
1155 reiserfs_update_inode_transaction(old_dir) ;
1156 reiserfs_update_inode_transaction(new_dir) ;
1158 /* this makes it so an fsync on an open fd for the old name will
1159 ** commit the rename operation
1161 reiserfs_update_inode_transaction(old_inode) ;
1163 if (new_dentry_inode)
1164 reiserfs_update_inode_transaction(new_dentry_inode) ;
1167 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1168 if (search_by_entry_key (new_dir->i_sb, &old_de.de_entry_key, &old_entry_path, &old_de) != NAME_FOUND)
1171 copy_item_head(&old_entry_ih, get_ih(&old_entry_path)) ;
1173 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1) ;
1175 // look for new name by reiserfs_find_entry
1176 new_de.de_gen_number_bit_string = 0;
1177 retval = reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1178 &new_entry_path, &new_de);
1179 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1180 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1181 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND)
1184 copy_item_head(&new_entry_ih, get_ih(&new_entry_path)) ;
1186 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1) ;
1188 if (S_ISDIR(old_inode->i_mode)) {
1189 if (search_by_entry_key (new_dir->i_sb, &dot_dot_de.de_entry_key, &dot_dot_entry_path, &dot_dot_de) != NAME_FOUND)
1191 copy_item_head(&dot_dot_ih, get_ih(&dot_dot_entry_path)) ;
1192 // node containing ".." gets into transaction
1193 reiserfs_prepare_for_journal(old_inode->i_sb, dot_dot_de.de_bh, 1) ;
1195 /* we should check seals here, not do
1196 this stuff, yes? Then, having
1197 gathered everything into RAM we
1198 should lock the buffers, yes? -Hans */
1199 /* probably. our rename needs to hold more
1200 ** than one path at once. The seals would
1201 ** have to be written to deal with multi-path
1204 /* sanity checking before doing the rename - avoid races many
1205 ** of the above checks could have scheduled. We have to be
1206 ** sure our items haven't been shifted by another process.
1208 if (item_moved(&new_entry_ih, &new_entry_path) ||
1209 !entry_points_to_object(new_dentry->d_name.name,
1210 new_dentry->d_name.len,
1211 &new_de, new_dentry_inode) ||
1212 item_moved(&old_entry_ih, &old_entry_path) ||
1213 !entry_points_to_object (old_dentry->d_name.name,
1214 old_dentry->d_name.len,
1215 &old_de, old_inode)) {
1216 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1217 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1218 if (S_ISDIR(old_inode_mode))
1219 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1222 if (S_ISDIR(old_inode_mode)) {
1223 if ( item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1224 !entry_points_to_object ( "..", 2, &dot_dot_de, old_dir) ) {
1225 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1226 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1227 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1232 RFALSE( S_ISDIR(old_inode_mode) &&
1233 !reiserfs_buffer_prepared(dot_dot_de.de_bh), "" );
1238 /* ok, all the changes can be done in one fell swoop when we
1239 have claimed all the buffers needed.*/
1241 mark_de_visible (new_de.de_deh + new_de.de_entry_num);
1242 set_ino_in_dir_entry (&new_de, INODE_PKEY (old_inode));
1243 journal_mark_dirty (&th, old_dir->i_sb, new_de.de_bh);
1245 mark_de_hidden (old_de.de_deh + old_de.de_entry_num);
1246 journal_mark_dirty (&th, old_dir->i_sb, old_de.de_bh);
1247 ctime = CURRENT_TIME;
1248 old_dir->i_ctime = old_dir->i_mtime = ctime;
1249 new_dir->i_ctime = new_dir->i_mtime = ctime;
1250 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1252 old_inode->i_ctime = ctime;
1254 if (new_dentry_inode) {
1255 // adjust link number of the victim
1256 if (S_ISDIR(new_dentry_inode->i_mode)) {
1257 new_dentry_inode->i_nlink = 0;
1259 new_dentry_inode->i_nlink--;
1261 new_dentry_inode->i_ctime = ctime;
1262 savelink = new_dentry_inode->i_nlink;
1265 if (S_ISDIR(old_inode_mode)) {
1266 // adjust ".." of renamed directory
1267 set_ino_in_dir_entry (&dot_dot_de, INODE_PKEY (new_dir));
1268 journal_mark_dirty (&th, new_dir->i_sb, dot_dot_de.de_bh);
1270 if (!new_dentry_inode)
1271 /* there (in new_dir) was no directory, so it got new link
1272 (".." of renamed directory) */
1273 INC_DIR_INODE_NLINK(new_dir);
1275 /* old directory lost one link - ".. " of renamed directory */
1276 DEC_DIR_INODE_NLINK(old_dir);
1279 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1280 pathrelse (&new_entry_path);
1281 pathrelse (&dot_dot_entry_path);
1283 // FIXME: this reiserfs_cut_from_item's return value may screw up
1284 // anybody, but it will panic if will not be able to find the
1285 // entry. This needs one more clean up
1286 if (reiserfs_cut_from_item (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL, 0) < 0)
1287 reiserfs_warning ("vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?\n");
1289 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1290 old_dir->i_blocks = ((old_dir->i_size + 511) >> 9);
1292 reiserfs_update_sd (&th, old_dir);
1293 reiserfs_update_sd (&th, new_dir);
1294 reiserfs_update_sd (&th, old_inode);
1296 if (new_dentry_inode) {
1298 add_save_link (&th, new_dentry_inode, 0/* not truncate */);
1299 reiserfs_update_sd (&th, new_dentry_inode);
1302 journal_end(&th, old_dir->i_sb, jbegin_count) ;
1303 reiserfs_write_unlock(old_dir->i_sb);
1308 * directories can handle most operations...
1310 struct inode_operations reiserfs_dir_inode_operations = {
1311 //&reiserfs_dir_operations, /* default_file_ops */
1312 .create = reiserfs_create,
1313 .lookup = reiserfs_lookup,
1314 .link = reiserfs_link,
1315 .unlink = reiserfs_unlink,
1316 .symlink = reiserfs_symlink,
1317 .mkdir = reiserfs_mkdir,
1318 .rmdir = reiserfs_rmdir,
1319 .mknod = reiserfs_mknod,
1320 .rename = reiserfs_rename,
1321 .setattr = reiserfs_setattr,