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>
23 #define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { i->i_nlink++; if (i->i_nlink >= REISERFS_LINK_MAX) i->i_nlink=1; }
24 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) i->i_nlink--;
26 // directory item contains array of entry headers. This performs
27 // binary search through that array
28 static int bin_search_in_dir_item (struct reiserfs_dir_entry * de, loff_t off)
30 struct item_head * ih = de->de_ih;
31 struct reiserfs_de_head * deh = de->de_deh;
32 int rbound, lbound, j;
35 rbound = I_ENTRY_COUNT (ih) - 1;
37 for (j = (rbound + lbound) / 2; lbound <= rbound; 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;
56 // comment? maybe something like set de to point to what the path points to?
57 static inline void set_de_item_location (struct reiserfs_dir_entry * de, struct path * 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);
66 // de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
67 inline void set_de_name_and_namelen (struct reiserfs_dir_entry * de)
69 struct reiserfs_de_head * deh = de->de_deh + de->de_entry_num;
71 if (de->de_entry_num >= ih_entry_count (de->de_ih))
74 de->de_entrylen = entry_length (de->de_bh, de->de_ih, de->de_entry_num);
75 de->de_namelen = de->de_entrylen - (de_with_sd (deh) ? SD_SIZE : 0);
76 de->de_name = B_I_PITEM (de->de_bh, de->de_ih) + deh_location(deh);
77 if (de->de_name[de->de_namelen - 1] == 0)
78 de->de_namelen = strlen (de->de_name);
82 // what entry points to
83 static inline void set_de_object_key (struct reiserfs_dir_entry * de)
85 if (de->de_entry_num >= ih_entry_count (de->de_ih))
87 de->de_dir_id = deh_dir_id( &(de->de_deh[de->de_entry_num]));
88 de->de_objectid = deh_objectid( &(de->de_deh[de->de_entry_num]));
92 static inline void store_de_entry_key (struct reiserfs_dir_entry * de)
94 struct reiserfs_de_head * deh = de->de_deh + de->de_entry_num;
96 if (de->de_entry_num >= ih_entry_count (de->de_ih))
99 /* store key of the found entry */
100 de->de_entry_key.version = KEY_FORMAT_3_5;
101 de->de_entry_key.on_disk_key.k_dir_id = le32_to_cpu (de->de_ih->ih_key.k_dir_id);
102 de->de_entry_key.on_disk_key.k_objectid = le32_to_cpu (de->de_ih->ih_key.k_objectid);
103 set_cpu_key_k_offset (&(de->de_entry_key), deh_offset (deh));
104 set_cpu_key_k_type (&(de->de_entry_key), TYPE_DIRENTRY);
108 /* We assign a key to each directory item, and place multiple entries
109 in a single directory item. A directory item has a key equal to the
110 key of the first directory entry in it.
112 This function first calls search_by_key, then, if item whose first
113 entry matches is not found it looks for the entry inside directory
114 item found by search_by_key. Fills the path to the entry, and to the
115 entry position in the item
119 /* The function is NOT SCHEDULE-SAFE! */
120 int search_by_entry_key (struct super_block * sb, const struct cpu_key * key,
121 struct path * path, struct reiserfs_dir_entry * de)
125 retval = search_item (sb, key, path);
128 if (!PATH_LAST_POSITION (path)) {
129 reiserfs_warning (sb, "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
133 PATH_LAST_POSITION (path) --;
143 reiserfs_warning (sb, "vs-7002: search_by_entry_key: no path to here");
147 set_de_item_location (de, path);
149 #ifdef CONFIG_REISERFS_CHECK
150 if (!is_direntry_le_ih (de->de_ih) ||
151 COMP_SHORT_KEYS (&(de->de_ih->ih_key), key)) {
152 print_block (de->de_bh, 0, -1, -1);
153 reiserfs_panic (sb, "vs-7005: search_by_entry_key: found item %h is not directory item or "
154 "does not belong to the same directory as key %K", de->de_ih, key);
156 #endif /* CONFIG_REISERFS_CHECK */
158 /* binary search in directory item by third componen t of the
159 key. sets de->de_entry_num of de */
160 retval = bin_search_in_dir_item (de, cpu_key_k_offset (key));
161 path->pos_in_item = de->de_entry_num;
162 if (retval != NAME_NOT_FOUND) {
163 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
164 set_de_name_and_namelen (de);
165 set_de_object_key (de);
172 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
174 /* The third component is hashed, and you can choose from more than
175 one hash function. Per directory hashes are not yet implemented
176 but are thought about. This function should be moved to hashes.c
177 Jedi, please do so. -Hans */
179 static __u32 get_third_component (struct super_block * s,
180 const char * name, int len)
184 if (!len || (len == 1 && name[0] == '.'))
186 if (len == 2 && name[0] == '.' && name[1] == '.')
187 return DOT_DOT_OFFSET;
189 res = REISERFS_SB(s)->s_hash_function (name, len);
191 // take bits from 7-th to 30-th including both bounds
192 res = GET_HASH_VALUE(res);
194 // needed to have no names before "." and ".." those have hash
195 // value == 0 and generation conters 1 and 2 accordingly
197 return res + MAX_GENERATION_NUMBER;
201 static int reiserfs_match (struct reiserfs_dir_entry * de,
202 const char * name, int namelen)
204 int retval = NAME_NOT_FOUND;
206 if ((namelen == de->de_namelen) &&
207 !memcmp(de->de_name, name, de->de_namelen))
208 retval = (de_visible (de->de_deh + de->de_entry_num) ? NAME_FOUND : NAME_FOUND_INVISIBLE);
214 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
216 /* used when hash collisions exist */
219 static int linear_search_in_dir_item (struct cpu_key * key, struct reiserfs_dir_entry * de,
220 const char * name, int namelen)
222 struct reiserfs_de_head * deh = de->de_deh;
226 i = de->de_entry_num;
228 if (i == I_ENTRY_COUNT (de->de_ih) ||
229 GET_HASH_VALUE (deh_offset (deh + i)) != GET_HASH_VALUE (cpu_key_k_offset (key))) {
233 RFALSE( de->de_deh != B_I_DEH (de->de_bh, de->de_ih),
234 "vs-7010: array of entry headers not found");
238 for (; i >= 0; i --, deh --) {
239 if (GET_HASH_VALUE (deh_offset (deh)) !=
240 GET_HASH_VALUE (cpu_key_k_offset (key))) {
241 // hash value does not match, no need to check whole name
242 return NAME_NOT_FOUND;
245 /* mark, that this generation number is used */
246 if (de->de_gen_number_bit_string)
247 set_bit (GET_GENERATION_NUMBER (deh_offset (deh)), (unsigned long *)de->de_gen_number_bit_string);
249 // calculate pointer to name and namelen
250 de->de_entry_num = i;
251 set_de_name_and_namelen (de);
253 if ((retval = reiserfs_match (de, name, namelen)) != NAME_NOT_FOUND) {
254 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
256 // key of pointed object
257 set_de_object_key (de);
259 store_de_entry_key (de);
261 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
266 if (GET_GENERATION_NUMBER (le_ih_k_offset (de->de_ih)) == 0)
267 /* we have reached left most entry in the node. In common we
268 have to go to the left neighbor, but if generation counter
269 is 0 already, we know for sure, that there is no name with
270 the same hash value */
271 // FIXME: this work correctly only because hash value can not
272 // be 0. Btw, in case of Yura's hash it is probably possible,
274 return NAME_NOT_FOUND;
276 RFALSE( de->de_item_num,
277 "vs-7015: two diritems of the same directory in one node?");
279 return GOTO_PREVIOUS_ITEM;
283 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
284 // FIXME: should add something like IOERROR
285 static int reiserfs_find_entry (struct inode * dir, const char * name, int namelen,
286 struct path * path_to_entry, struct reiserfs_dir_entry * de)
288 struct cpu_key key_to_search;
292 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize))
293 return NAME_NOT_FOUND;
295 /* we will search for this key in the tree */
296 make_cpu_key (&key_to_search, dir,
297 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3);
300 retval = search_by_entry_key (dir->i_sb, &key_to_search, path_to_entry, de);
301 if (retval == IO_ERROR) {
302 reiserfs_warning (dir->i_sb, "zam-7001: io error in %s",
307 /* compare names for all entries having given hash value */
308 retval = linear_search_in_dir_item (&key_to_search, de, name, namelen);
309 if (retval != GOTO_PREVIOUS_ITEM) {
310 /* there is no need to scan directory anymore. Given entry found or does not exist */
311 path_to_entry->pos_in_item = de->de_entry_num;
315 /* there is left neighboring item of this directory and given entry can be there */
316 set_cpu_key_k_offset (&key_to_search, le_ih_k_offset (de->de_ih) - 1);
317 pathrelse (path_to_entry);
323 static struct dentry * reiserfs_lookup (struct inode * dir, struct dentry * dentry, struct nameidata *nd)
326 struct inode * inode = NULL;
327 struct reiserfs_dir_entry de;
328 INITIALIZE_PATH (path_to_entry);
330 if (REISERFS_MAX_NAME (dir->i_sb->s_blocksize) < dentry->d_name.len)
331 return ERR_PTR(-ENAMETOOLONG);
333 reiserfs_write_lock(dir->i_sb);
334 de.de_gen_number_bit_string = NULL;
335 retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de);
336 pathrelse (&path_to_entry);
337 if (retval == NAME_FOUND) {
338 /* Hide the .reiserfs_priv directory */
339 if (reiserfs_xattrs (dir->i_sb) &&
340 !old_format_only(dir->i_sb) &&
341 REISERFS_SB(dir->i_sb)->priv_root &&
342 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
343 de.de_objectid == le32_to_cpu (INODE_PKEY(REISERFS_SB(dir->i_sb)->priv_root->d_inode)->k_objectid)) {
344 reiserfs_write_unlock (dir->i_sb);
345 return ERR_PTR (-EACCES);
348 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
349 if (!inode || IS_ERR(inode)) {
350 reiserfs_write_unlock(dir->i_sb);
351 return ERR_PTR(-EACCES);
354 /* Propogate the priv_object flag so we know we're in the priv tree */
355 if (is_reiserfs_priv_object (dir))
356 REISERFS_I(inode)->i_flags |= i_priv_object;
358 reiserfs_write_unlock(dir->i_sb);
359 if ( retval == IO_ERROR ) {
360 return ERR_PTR(-EIO);
364 return d_splice_alias(inode, dentry);
366 d_add(dentry, inode);
372 ** looks up the dentry of the parent directory for child.
373 ** taken from ext2_get_parent
375 struct dentry *reiserfs_get_parent(struct dentry *child)
378 struct inode * inode = NULL;
379 struct reiserfs_dir_entry de;
380 INITIALIZE_PATH (path_to_entry);
381 struct dentry *parent;
382 struct inode *dir = child->d_inode ;
385 if (dir->i_nlink == 0) {
386 return ERR_PTR(-ENOENT);
388 de.de_gen_number_bit_string = NULL;
390 reiserfs_write_lock(dir->i_sb);
391 retval = reiserfs_find_entry (dir, "..", 2, &path_to_entry, &de);
392 pathrelse (&path_to_entry);
393 if (retval != NAME_FOUND) {
394 reiserfs_write_unlock(dir->i_sb);
395 return ERR_PTR(-ENOENT);
397 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
398 reiserfs_write_unlock(dir->i_sb);
400 if (!inode || IS_ERR(inode)) {
401 return ERR_PTR(-EACCES);
403 parent = d_alloc_anon(inode);
406 parent = ERR_PTR(-ENOMEM);
412 /* add entry to the directory (entry can be hidden).
414 insert definition of when hidden directories are used here -Hans
416 Does not mark dir inode dirty, do it after successesfull call to it */
418 static int reiserfs_add_entry (struct reiserfs_transaction_handle *th, struct inode * dir,
419 const char * name, int namelen, struct inode * inode,
422 struct cpu_key entry_key;
423 struct reiserfs_de_head * deh;
424 INITIALIZE_PATH (path);
425 struct reiserfs_dir_entry de;
426 int bit_string [MAX_GENERATION_NUMBER / (sizeof(int) * 8) + 1];
428 char small_buf[32+DEH_SIZE] ; /* 48 bytes now and we avoid kmalloc
429 if we create file with short name */
431 int buflen, paste_size;
434 BUG_ON (!th->t_trans_id);
436 /* cannot allow items to be added into a busy deleted directory */
440 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize))
441 return -ENAMETOOLONG;
443 /* each entry has unique key. compose it */
444 make_cpu_key (&entry_key, dir,
445 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3);
447 /* get memory for composing the entry */
448 buflen = DEH_SIZE + ROUND_UP (namelen);
449 if (buflen > sizeof (small_buf)) {
450 buffer = reiserfs_kmalloc (buflen, GFP_NOFS, dir->i_sb);
456 paste_size = (get_inode_sd_version (dir) == STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
458 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
459 deh = (struct reiserfs_de_head *)buffer;
460 deh->deh_location = 0; /* JDM Endian safe if 0 */
461 put_deh_offset( deh, cpu_key_k_offset( &entry_key ) );
462 deh->deh_state = 0; /* JDM Endian safe if 0 */
463 /* put key (ino analog) to de */
464 deh->deh_dir_id = INODE_PKEY (inode)->k_dir_id; /* safe: k_dir_id is le */
465 deh->deh_objectid = INODE_PKEY (inode)->k_objectid; /* safe: k_objectid is le */
468 memcpy ((char *)(deh + 1), name, namelen);
469 /* padd by 0s to the 4 byte boundary */
470 padd_item ((char *)(deh + 1), ROUND_UP (namelen), namelen);
472 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
473 mark_de_without_sd (deh);
474 visible ? mark_de_visible (deh) : mark_de_hidden (deh);
476 /* find the proper place for the new entry */
477 memset (bit_string, 0, sizeof (bit_string));
478 de.de_gen_number_bit_string = (char *)bit_string;
479 retval = reiserfs_find_entry (dir, name, namelen, &path, &de);
480 if( retval != NAME_NOT_FOUND ) {
481 if (buffer != small_buf)
482 reiserfs_kfree (buffer, buflen, dir->i_sb);
485 if ( retval == IO_ERROR ) {
489 if (retval != NAME_FOUND) {
490 reiserfs_warning (dir->i_sb, "zam-7002:%s: \"reiserfs_find_entry\" "
491 "has returned unexpected value (%d)",
492 __FUNCTION__, retval);
498 gen_number = find_first_zero_bit ((unsigned long *)bit_string, MAX_GENERATION_NUMBER + 1);
499 if (gen_number > MAX_GENERATION_NUMBER) {
500 /* there is no free generation number */
501 reiserfs_warning (dir->i_sb, "reiserfs_add_entry: Congratulations! we have got hash function screwed up");
502 if (buffer != small_buf)
503 reiserfs_kfree (buffer, buflen, dir->i_sb);
507 /* adjust offset of directory enrty */
508 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
509 set_cpu_key_k_offset (&entry_key, deh_offset(deh));
511 /* update max-hash-collisions counter in reiserfs_sb_info */
512 PROC_INFO_MAX( th -> t_super, max_hash_collisions, gen_number );
514 if (gen_number != 0) { /* we need to re-search for the insertion point */
515 if (search_by_entry_key (dir->i_sb, &entry_key, &path, &de) != NAME_NOT_FOUND) {
516 reiserfs_warning (dir->i_sb, "vs-7032: reiserfs_add_entry: "
517 "entry with this key (%K) already exists",
520 if (buffer != small_buf)
521 reiserfs_kfree (buffer, buflen, dir->i_sb);
527 /* perform the insertion of the entry that we have prepared */
528 retval = reiserfs_paste_into_item (th, &path, &entry_key, dir, buffer, paste_size);
529 if (buffer != small_buf)
530 reiserfs_kfree (buffer, buflen, dir->i_sb);
532 reiserfs_check_path(&path) ;
536 dir->i_size += paste_size;
537 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
538 if (!S_ISDIR (inode->i_mode) && visible)
539 // reiserfs_mkdir or reiserfs_rename will do that by itself
540 reiserfs_update_sd (th, dir);
542 reiserfs_check_path(&path) ;
546 /* quota utility function, call if you've had to abort after calling
547 ** new_inode_init, and have not called reiserfs_new_inode yet.
548 ** This should only be called on inodes that do not hav stat data
549 ** inserted into the tree yet.
551 static int drop_new_inode(struct inode *inode) {
553 make_bad_inode(inode) ;
554 inode->i_flags |= S_NOQUOTA;
559 /* utility function that does setup for reiserfs_new_inode.
560 ** DQUOT_ALLOC_INODE cannot be called inside a transaction, so we had
561 ** to pull some bits of reiserfs_new_inode out into this func.
562 ** Yes, the actual quota calls are missing, they are part of the quota
565 static int new_inode_init(struct inode *inode, struct inode *dir, int mode) {
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->i_uid = current->fsuid;
571 inode->i_mode = mode;
573 if (dir->i_mode & S_ISGID) {
574 inode->i_gid = dir->i_gid;
576 inode->i_mode |= S_ISGID;
578 inode->i_gid = current->fsgid;
581 if (DQUOT_ALLOC_INODE(inode)) {
582 drop_new_inode(inode);
588 static int reiserfs_create (struct inode * dir, struct dentry *dentry, int mode,
589 struct nameidata *nd)
592 struct inode * inode;
593 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 ;
594 struct reiserfs_transaction_handle th ;
597 if (!(inode = new_inode(dir->i_sb))) {
600 retval = new_inode_init(inode, dir, mode);
604 locked = reiserfs_cache_default_acl (dir);
606 reiserfs_write_lock(dir->i_sb);
609 reiserfs_write_lock_xattrs (dir->i_sb);
611 retval = journal_begin(&th, dir->i_sb, jbegin_count);
613 drop_new_inode (inode);
617 retval = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode);
622 reiserfs_write_unlock_xattrs (dir->i_sb);
626 inode->i_op = &reiserfs_file_inode_operations;
627 inode->i_fop = &reiserfs_file_operations;
628 inode->i_mapping->a_ops = &reiserfs_address_space_operations ;
630 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
631 inode, 1/*visible*/);
635 reiserfs_update_sd (&th, inode);
636 err = journal_end(&th, dir->i_sb, jbegin_count) ;
642 reiserfs_update_inode_transaction(inode) ;
643 reiserfs_update_inode_transaction(dir) ;
645 d_instantiate(dentry, inode);
646 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
650 reiserfs_write_unlock_xattrs (dir->i_sb);
651 reiserfs_write_unlock(dir->i_sb);
656 static int reiserfs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
659 struct inode * inode;
660 struct reiserfs_transaction_handle th ;
661 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
664 if (!new_valid_dev(rdev))
667 if (!(inode = new_inode(dir->i_sb))) {
670 retval = new_inode_init(inode, dir, mode);
674 locked = reiserfs_cache_default_acl (dir);
676 reiserfs_write_lock(dir->i_sb);
679 reiserfs_write_lock_xattrs (dir->i_sb);
681 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
683 drop_new_inode (inode);
687 retval = reiserfs_new_inode (&th, dir, mode, NULL, 0/*i_size*/, dentry, inode);
693 reiserfs_write_unlock_xattrs (dir->i_sb);
698 inode->i_op = &reiserfs_special_inode_operations;
699 init_special_inode(inode, inode->i_mode, rdev) ;
701 //FIXME: needed for block and char devices only
702 reiserfs_update_sd (&th, inode);
704 reiserfs_update_inode_transaction(inode) ;
705 reiserfs_update_inode_transaction(dir) ;
707 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
708 inode, 1/*visible*/);
712 reiserfs_update_sd (&th, inode);
713 err = journal_end(&th, dir->i_sb, jbegin_count) ;
720 d_instantiate(dentry, inode);
721 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
725 reiserfs_write_unlock_xattrs (dir->i_sb);
726 reiserfs_write_unlock(dir->i_sb);
731 static int reiserfs_mkdir (struct inode * dir, struct dentry *dentry, int mode)
734 struct inode * inode;
735 struct reiserfs_transaction_handle th ;
736 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
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 retval = new_inode_init(inode, dir, mode);
751 locked = reiserfs_cache_default_acl (dir);
753 reiserfs_write_lock(dir->i_sb);
755 reiserfs_write_lock_xattrs (dir->i_sb);
757 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
759 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,
779 reiserfs_write_unlock_xattrs (dir->i_sb);
783 reiserfs_update_inode_transaction(inode) ;
784 reiserfs_update_inode_transaction(dir) ;
786 inode->i_op = &reiserfs_dir_inode_operations;
787 inode->i_fop = &reiserfs_dir_operations;
789 // note, _this_ add_entry will not update dir's stat data
790 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
791 inode, 1/*visible*/);
795 DEC_DIR_INODE_NLINK(dir);
796 reiserfs_update_sd (&th, inode);
797 err = journal_end(&th, dir->i_sb, jbegin_count) ;
804 // the above add_entry did not update dir's stat data
805 reiserfs_update_sd (&th, dir);
807 d_instantiate(dentry, inode);
808 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
811 reiserfs_write_unlock_xattrs (dir->i_sb);
812 reiserfs_write_unlock(dir->i_sb);
816 static inline int reiserfs_empty_dir(struct inode *inode) {
817 /* we can cheat because an old format dir cannot have
818 ** EMPTY_DIR_SIZE, and a new format dir cannot have
819 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
820 ** regardless of disk format version, the directory is empty.
822 if (inode->i_size != EMPTY_DIR_SIZE &&
823 inode->i_size != EMPTY_DIR_SIZE_V1) {
829 static int reiserfs_rmdir (struct inode * dir, struct dentry *dentry)
832 struct inode * inode;
833 struct reiserfs_transaction_handle th ;
835 INITIALIZE_PATH (path);
836 struct reiserfs_dir_entry de;
839 /* we will be doing 2 balancings and update 2 stat data */
840 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
842 reiserfs_write_lock(dir->i_sb);
843 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
847 de.de_gen_number_bit_string = NULL;
848 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
851 } else if ( retval == IO_ERROR) {
856 inode = dentry->d_inode;
858 reiserfs_update_inode_transaction(inode) ;
859 reiserfs_update_inode_transaction(dir) ;
861 if (de.de_objectid != inode->i_ino) {
862 // FIXME: compare key of an object and a key found in the
867 if (!reiserfs_empty_dir(inode)) {
872 /* cut entry from dir directory */
873 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir,
875 0/*new file size - not used here*/);
879 if ( inode->i_nlink != 2 && inode->i_nlink != 1 )
880 reiserfs_warning (inode->i_sb, "%s: empty directory has nlink "
881 "!= 2 (%d)", __FUNCTION__, inode->i_nlink);
884 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
885 reiserfs_update_sd (&th, inode);
887 DEC_DIR_INODE_NLINK(dir)
888 dir->i_size -= (DEH_SIZE + de.de_entrylen);
889 reiserfs_update_sd (&th, dir);
891 /* prevent empty directory from getting lost */
892 add_save_link (&th, inode, 0/* not truncate */);
894 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
895 reiserfs_check_path(&path) ;
897 reiserfs_write_unlock(dir->i_sb);
901 /* we must release path, because we did not call
902 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
903 release path if operation was not complete */
905 err = journal_end(&th, dir->i_sb, jbegin_count) ;
906 reiserfs_write_unlock(dir->i_sb);
907 return err ? err : retval;
910 static int reiserfs_unlink (struct inode * dir, struct dentry *dentry)
913 struct inode * inode;
914 struct reiserfs_dir_entry de;
915 INITIALIZE_PATH (path);
916 struct reiserfs_transaction_handle th ;
918 unsigned long savelink;
920 inode = dentry->d_inode;
922 /* in this transaction we can be doing at max two balancings and update
924 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
926 reiserfs_write_lock(dir->i_sb);
927 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
931 de.de_gen_number_bit_string = NULL;
932 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
935 } else if (retval == IO_ERROR) {
940 reiserfs_update_inode_transaction(inode) ;
941 reiserfs_update_inode_transaction(dir) ;
943 if (de.de_objectid != inode->i_ino) {
944 // FIXME: compare key of an object and a key found in the
950 if (!inode->i_nlink) {
951 reiserfs_warning (inode->i_sb, "%s: deleting nonexistent file "
952 "(%s:%lu), %d", __FUNCTION__,
953 reiserfs_bdevname (inode->i_sb), inode->i_ino,
961 * we schedule before doing the add_save_link call, save the link
962 * count so we don't race
964 savelink = inode->i_nlink;
967 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir, NULL, 0);
972 inode->i_ctime = CURRENT_TIME;
973 reiserfs_update_sd (&th, inode);
975 dir->i_size -= (de.de_entrylen + DEH_SIZE);
976 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
977 reiserfs_update_sd (&th, dir);
980 /* prevent file from getting lost */
981 add_save_link (&th, inode, 0/* not truncate */);
983 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
984 reiserfs_check_path(&path) ;
985 reiserfs_write_unlock(dir->i_sb);
990 err = journal_end(&th, dir->i_sb, jbegin_count) ;
991 reiserfs_check_path(&path) ;
995 reiserfs_write_unlock(dir->i_sb);
999 static int reiserfs_symlink (struct inode * parent_dir,
1000 struct dentry * dentry, const char * symname)
1003 struct inode * inode;
1006 struct reiserfs_transaction_handle th ;
1007 int mode = S_IFLNK | S_IRWXUGO;
1008 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
1010 if (!(inode = new_inode(parent_dir->i_sb))) {
1013 retval = new_inode_init(inode, parent_dir, mode);
1018 reiserfs_write_lock(parent_dir->i_sb);
1019 item_len = ROUND_UP (strlen (symname));
1020 if (item_len > MAX_DIRECT_ITEM_LEN (parent_dir->i_sb->s_blocksize)) {
1021 retval = -ENAMETOOLONG;
1022 drop_new_inode(inode);
1026 name = reiserfs_kmalloc (item_len, GFP_NOFS, parent_dir->i_sb);
1028 drop_new_inode(inode);
1032 memcpy (name, symname, strlen (symname));
1033 padd_item (name, item_len, strlen (symname));
1035 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1037 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count) ;
1039 drop_new_inode (inode);
1040 reiserfs_kfree (name, item_len, parent_dir->i_sb);
1044 retval = reiserfs_new_inode (&th, parent_dir, mode, name, strlen (symname),
1046 reiserfs_kfree (name, item_len, parent_dir->i_sb);
1047 if (retval) { /* reiserfs_new_inode iputs for us */
1051 reiserfs_update_inode_transaction(inode) ;
1052 reiserfs_update_inode_transaction(parent_dir) ;
1054 inode->i_op = &reiserfs_symlink_inode_operations;
1055 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1057 // must be sure this inode is written with this transaction
1059 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1061 retval = reiserfs_add_entry (&th, parent_dir, dentry->d_name.name,
1062 dentry->d_name.len, inode, 1/*visible*/);
1066 reiserfs_update_sd (&th, inode);
1067 err = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1074 d_instantiate(dentry, inode);
1075 retval = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1077 reiserfs_write_unlock(parent_dir->i_sb);
1081 static int reiserfs_link (struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
1084 struct inode *inode = old_dentry->d_inode;
1085 struct reiserfs_transaction_handle th ;
1086 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
1088 reiserfs_write_lock(dir->i_sb);
1089 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1090 //FIXME: sd_nlink is 32 bit for new files
1091 reiserfs_write_unlock(dir->i_sb);
1094 if (inode->i_nlink == 0) {
1095 reiserfs_write_unlock(dir->i_sb);
1099 /* inc before scheduling so reiserfs_unlink knows we are here */
1102 retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
1105 reiserfs_write_unlock (dir->i_sb);
1109 /* create new entry */
1110 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
1111 inode, 1/*visible*/);
1113 reiserfs_update_inode_transaction(inode) ;
1114 reiserfs_update_inode_transaction(dir) ;
1119 err = journal_end(&th, dir->i_sb, jbegin_count) ;
1120 reiserfs_write_unlock(dir->i_sb);
1121 return err ? err : retval;
1124 inode->i_ctime = CURRENT_TIME;
1125 reiserfs_update_sd (&th, inode);
1127 atomic_inc(&inode->i_count) ;
1128 d_instantiate(dentry, inode);
1129 retval = journal_end(&th, dir->i_sb, jbegin_count) ;
1130 reiserfs_write_unlock(dir->i_sb);
1135 // de contains information pointing to an entry which
1136 static int de_still_valid (const char * name, int len, struct reiserfs_dir_entry * de)
1138 struct reiserfs_dir_entry tmp = *de;
1140 // recalculate pointer to name and name length
1141 set_de_name_and_namelen (&tmp);
1142 // FIXME: could check more
1143 if (tmp.de_namelen != len || memcmp (name, de->de_name, len))
1149 static int entry_points_to_object (const char * name, int len, struct reiserfs_dir_entry * de, struct inode * inode)
1151 if (!de_still_valid (name, len, de))
1155 if (!de_visible (de->de_deh + de->de_entry_num))
1156 reiserfs_panic (NULL, "vs-7042: entry_points_to_object: entry must be visible");
1157 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1160 /* this must be added hidden entry */
1161 if (de_visible (de->de_deh + de->de_entry_num))
1162 reiserfs_panic (NULL, "vs-7043: entry_points_to_object: entry must be visible");
1168 /* sets key of objectid the entry has to point to */
1169 static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct reiserfs_key * key)
1171 /* JDM These operations are endian safe - both are le */
1172 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1173 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1178 * process, that is going to call fix_nodes/do_balance must hold only
1179 * one path. If it holds 2 or more, it can get into endless waiting in
1180 * get_empty_nodes or its clones
1182 static int reiserfs_rename (struct inode * old_dir, struct dentry *old_dentry,
1183 struct inode * new_dir, struct dentry *new_dentry)
1186 INITIALIZE_PATH (old_entry_path);
1187 INITIALIZE_PATH (new_entry_path);
1188 INITIALIZE_PATH (dot_dot_entry_path);
1189 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih ;
1190 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1191 struct inode * old_inode, * new_dentry_inode;
1192 struct reiserfs_transaction_handle th ;
1194 umode_t old_inode_mode;
1195 unsigned long savelink = 1;
1196 struct timespec ctime;
1198 /* three balancings: (1) old name removal, (2) new name insertion
1199 and (3) maybe "save" link insertion
1200 stat data updates: (1) old directory,
1201 (2) new directory and (3) maybe old object stat data (when it is
1202 directory) and (4) maybe stat data of object to which new entry
1203 pointed initially and (5) maybe block containing ".." of
1204 renamed directory */
1205 jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 5;
1207 old_inode = old_dentry->d_inode;
1208 new_dentry_inode = new_dentry->d_inode;
1210 // make sure, that oldname still exists and points to an object we
1211 // are going to rename
1212 old_de.de_gen_number_bit_string = NULL;
1213 reiserfs_write_lock(old_dir->i_sb);
1214 retval = reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len,
1215 &old_entry_path, &old_de);
1216 pathrelse (&old_entry_path);
1217 if (retval == IO_ERROR) {
1218 reiserfs_write_unlock(old_dir->i_sb);
1222 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1223 reiserfs_write_unlock(old_dir->i_sb);
1227 old_inode_mode = old_inode->i_mode;
1228 if (S_ISDIR(old_inode_mode)) {
1229 // make sure, that directory being renamed has correct ".."
1230 // and that its new parent directory has not too many links
1233 if (new_dentry_inode) {
1234 if (!reiserfs_empty_dir(new_dentry_inode)) {
1235 reiserfs_write_unlock(old_dir->i_sb);
1240 /* directory is renamed, its parent directory will be changed,
1241 ** so find ".." entry
1243 dot_dot_de.de_gen_number_bit_string = NULL;
1244 retval = reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de);
1245 pathrelse (&dot_dot_entry_path);
1246 if (retval != NAME_FOUND) {
1247 reiserfs_write_unlock(old_dir->i_sb);
1251 /* inode number of .. must equal old_dir->i_ino */
1252 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1253 reiserfs_write_unlock(old_dir->i_sb);
1258 retval = journal_begin(&th, old_dir->i_sb, jbegin_count) ;
1260 reiserfs_write_unlock (old_dir->i_sb);
1265 /* add new entry (or find the existing one) */
1266 retval = reiserfs_add_entry (&th, new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1268 if (retval == -EEXIST) {
1269 if (!new_dentry_inode) {
1270 reiserfs_panic (old_dir->i_sb,
1271 "vs-7050: new entry is found, new inode == 0\n");
1273 } else if (retval) {
1274 int err = journal_end(&th, old_dir->i_sb, jbegin_count) ;
1275 reiserfs_write_unlock(old_dir->i_sb);
1276 return err ? err : retval;
1279 reiserfs_update_inode_transaction(old_dir) ;
1280 reiserfs_update_inode_transaction(new_dir) ;
1282 /* this makes it so an fsync on an open fd for the old name will
1283 ** commit the rename operation
1285 reiserfs_update_inode_transaction(old_inode) ;
1287 if (new_dentry_inode)
1288 reiserfs_update_inode_transaction(new_dentry_inode) ;
1291 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1292 if (search_by_entry_key (new_dir->i_sb, &old_de.de_entry_key, &old_entry_path, &old_de) != NAME_FOUND)
1295 copy_item_head(&old_entry_ih, get_ih(&old_entry_path)) ;
1297 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1) ;
1299 // look for new name by reiserfs_find_entry
1300 new_de.de_gen_number_bit_string = NULL;
1301 retval = reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1302 &new_entry_path, &new_de);
1303 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1304 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1305 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND)
1308 copy_item_head(&new_entry_ih, get_ih(&new_entry_path)) ;
1310 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1) ;
1312 if (S_ISDIR(old_inode->i_mode)) {
1313 if (search_by_entry_key (new_dir->i_sb, &dot_dot_de.de_entry_key, &dot_dot_entry_path, &dot_dot_de) != NAME_FOUND)
1315 copy_item_head(&dot_dot_ih, get_ih(&dot_dot_entry_path)) ;
1316 // node containing ".." gets into transaction
1317 reiserfs_prepare_for_journal(old_inode->i_sb, dot_dot_de.de_bh, 1) ;
1319 /* we should check seals here, not do
1320 this stuff, yes? Then, having
1321 gathered everything into RAM we
1322 should lock the buffers, yes? -Hans */
1323 /* probably. our rename needs to hold more
1324 ** than one path at once. The seals would
1325 ** have to be written to deal with multi-path
1328 /* sanity checking before doing the rename - avoid races many
1329 ** of the above checks could have scheduled. We have to be
1330 ** sure our items haven't been shifted by another process.
1332 if (item_moved(&new_entry_ih, &new_entry_path) ||
1333 !entry_points_to_object(new_dentry->d_name.name,
1334 new_dentry->d_name.len,
1335 &new_de, new_dentry_inode) ||
1336 item_moved(&old_entry_ih, &old_entry_path) ||
1337 !entry_points_to_object (old_dentry->d_name.name,
1338 old_dentry->d_name.len,
1339 &old_de, old_inode)) {
1340 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1341 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1342 if (S_ISDIR(old_inode_mode))
1343 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1346 if (S_ISDIR(old_inode_mode)) {
1347 if ( item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1348 !entry_points_to_object ( "..", 2, &dot_dot_de, old_dir) ) {
1349 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1350 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1351 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1356 RFALSE( S_ISDIR(old_inode_mode) &&
1357 !buffer_journal_prepared(dot_dot_de.de_bh), "" );
1362 /* ok, all the changes can be done in one fell swoop when we
1363 have claimed all the buffers needed.*/
1365 mark_de_visible (new_de.de_deh + new_de.de_entry_num);
1366 set_ino_in_dir_entry (&new_de, INODE_PKEY (old_inode));
1367 journal_mark_dirty (&th, old_dir->i_sb, new_de.de_bh);
1369 mark_de_hidden (old_de.de_deh + old_de.de_entry_num);
1370 journal_mark_dirty (&th, old_dir->i_sb, old_de.de_bh);
1371 ctime = CURRENT_TIME;
1372 old_dir->i_ctime = old_dir->i_mtime = ctime;
1373 new_dir->i_ctime = new_dir->i_mtime = ctime;
1374 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1376 old_inode->i_ctime = ctime;
1378 if (new_dentry_inode) {
1379 // adjust link number of the victim
1380 if (S_ISDIR(new_dentry_inode->i_mode)) {
1381 new_dentry_inode->i_nlink = 0;
1383 new_dentry_inode->i_nlink--;
1385 new_dentry_inode->i_ctime = ctime;
1386 savelink = new_dentry_inode->i_nlink;
1389 if (S_ISDIR(old_inode_mode)) {
1390 // adjust ".." of renamed directory
1391 set_ino_in_dir_entry (&dot_dot_de, INODE_PKEY (new_dir));
1392 journal_mark_dirty (&th, new_dir->i_sb, dot_dot_de.de_bh);
1394 if (!new_dentry_inode)
1395 /* there (in new_dir) was no directory, so it got new link
1396 (".." of renamed directory) */
1397 INC_DIR_INODE_NLINK(new_dir);
1399 /* old directory lost one link - ".. " of renamed directory */
1400 DEC_DIR_INODE_NLINK(old_dir);
1403 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1404 pathrelse (&new_entry_path);
1405 pathrelse (&dot_dot_entry_path);
1407 // FIXME: this reiserfs_cut_from_item's return value may screw up
1408 // anybody, but it will panic if will not be able to find the
1409 // entry. This needs one more clean up
1410 if (reiserfs_cut_from_item (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL, 0) < 0)
1411 reiserfs_warning (old_dir->i_sb, "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
1413 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1415 reiserfs_update_sd (&th, old_dir);
1416 reiserfs_update_sd (&th, new_dir);
1417 reiserfs_update_sd (&th, old_inode);
1419 if (new_dentry_inode) {
1421 add_save_link (&th, new_dentry_inode, 0/* not truncate */);
1422 reiserfs_update_sd (&th, new_dentry_inode);
1425 retval = journal_end(&th, old_dir->i_sb, jbegin_count) ;
1426 reiserfs_write_unlock(old_dir->i_sb);
1431 * directories can handle most operations...
1433 struct inode_operations reiserfs_dir_inode_operations = {
1434 //&reiserfs_dir_operations, /* default_file_ops */
1435 .create = reiserfs_create,
1436 .lookup = reiserfs_lookup,
1437 .link = reiserfs_link,
1438 .unlink = reiserfs_unlink,
1439 .symlink = reiserfs_symlink,
1440 .mkdir = reiserfs_mkdir,
1441 .rmdir = reiserfs_rmdir,
1442 .mknod = reiserfs_mknod,
1443 .rename = reiserfs_rename,
1444 .setattr = reiserfs_setattr,
1445 .setxattr = reiserfs_setxattr,
1446 .getxattr = reiserfs_getxattr,
1447 .listxattr = reiserfs_listxattr,
1448 .removexattr = reiserfs_removexattr,
1449 .permission = reiserfs_permission,
1453 * symlink operations.. same as page_symlink_inode_operations, with xattr
1456 struct inode_operations reiserfs_symlink_inode_operations = {
1457 .readlink = generic_readlink,
1458 .follow_link = page_follow_link_light,
1459 .put_link = page_put_link,
1460 .setattr = reiserfs_setattr,
1461 .setxattr = reiserfs_setxattr,
1462 .getxattr = reiserfs_getxattr,
1463 .listxattr = reiserfs_listxattr,
1464 .removexattr = reiserfs_removexattr,
1465 .permission = reiserfs_permission,
1471 * special file operations.. just xattr/acl stuff
1473 struct inode_operations reiserfs_special_inode_operations = {
1474 .setattr = reiserfs_setattr,
1475 .setxattr = reiserfs_setxattr,
1476 .getxattr = reiserfs_getxattr,
1477 .listxattr = reiserfs_listxattr,
1478 .removexattr = reiserfs_removexattr,
1479 .permission = reiserfs_permission,