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 = 0;
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 return ERR_PTR (-EACCES);
347 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
348 if (!inode || IS_ERR(inode)) {
349 reiserfs_write_unlock(dir->i_sb);
350 return ERR_PTR(-EACCES);
353 /* Propogate the priv_object flag so we know we're in the priv tree */
354 if (is_reiserfs_priv_object (dir))
355 REISERFS_I(inode)->i_flags |= i_priv_object;
357 reiserfs_write_unlock(dir->i_sb);
358 if ( retval == IO_ERROR ) {
359 return ERR_PTR(-EIO);
363 return d_splice_alias(inode, dentry);
365 d_add(dentry, inode);
371 ** looks up the dentry of the parent directory for child.
372 ** taken from ext2_get_parent
374 struct dentry *reiserfs_get_parent(struct dentry *child)
377 struct inode * inode = NULL;
378 struct reiserfs_dir_entry de;
379 INITIALIZE_PATH (path_to_entry);
380 struct dentry *parent;
381 struct inode *dir = child->d_inode ;
384 if (dir->i_nlink == 0) {
385 return ERR_PTR(-ENOENT);
387 de.de_gen_number_bit_string = 0;
389 reiserfs_write_lock(dir->i_sb);
390 retval = reiserfs_find_entry (dir, "..", 2, &path_to_entry, &de);
391 pathrelse (&path_to_entry);
392 if (retval != NAME_FOUND) {
393 reiserfs_write_unlock(dir->i_sb);
394 return ERR_PTR(-ENOENT);
396 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
397 reiserfs_write_unlock(dir->i_sb);
399 if (!inode || IS_ERR(inode)) {
400 return ERR_PTR(-EACCES);
402 parent = d_alloc_anon(inode);
405 parent = ERR_PTR(-ENOMEM);
411 /* add entry to the directory (entry can be hidden).
413 insert definition of when hidden directories are used here -Hans
415 Does not mark dir inode dirty, do it after successesfull call to it */
417 static int reiserfs_add_entry (struct reiserfs_transaction_handle *th, struct inode * dir,
418 const char * name, int namelen, struct inode * inode,
421 struct cpu_key entry_key;
422 struct reiserfs_de_head * deh;
423 INITIALIZE_PATH (path);
424 struct reiserfs_dir_entry de;
425 int bit_string [MAX_GENERATION_NUMBER / (sizeof(int) * 8) + 1];
427 char small_buf[32+DEH_SIZE] ; /* 48 bytes now and we avoid kmalloc
428 if we create file with short name */
430 int buflen, paste_size;
434 /* cannot allow items to be added into a busy deleted directory */
438 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize))
439 return -ENAMETOOLONG;
441 /* each entry has unique key. compose it */
442 make_cpu_key (&entry_key, dir,
443 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3);
445 /* get memory for composing the entry */
446 buflen = DEH_SIZE + ROUND_UP (namelen);
447 if (buflen > sizeof (small_buf)) {
448 buffer = reiserfs_kmalloc (buflen, GFP_NOFS, dir->i_sb);
454 paste_size = (get_inode_sd_version (dir) == STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
456 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
457 deh = (struct reiserfs_de_head *)buffer;
458 deh->deh_location = 0; /* JDM Endian safe if 0 */
459 put_deh_offset( deh, cpu_key_k_offset( &entry_key ) );
460 deh->deh_state = 0; /* JDM Endian safe if 0 */
461 /* put key (ino analog) to de */
462 deh->deh_dir_id = INODE_PKEY (inode)->k_dir_id; /* safe: k_dir_id is le */
463 deh->deh_objectid = INODE_PKEY (inode)->k_objectid; /* safe: k_objectid is le */
466 memcpy ((char *)(deh + 1), name, namelen);
467 /* padd by 0s to the 4 byte boundary */
468 padd_item ((char *)(deh + 1), ROUND_UP (namelen), namelen);
470 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
471 mark_de_without_sd (deh);
472 visible ? mark_de_visible (deh) : mark_de_hidden (deh);
474 /* find the proper place for the new entry */
475 memset (bit_string, 0, sizeof (bit_string));
476 de.de_gen_number_bit_string = (char *)bit_string;
477 retval = reiserfs_find_entry (dir, name, namelen, &path, &de);
478 if( retval != NAME_NOT_FOUND ) {
479 if (buffer != small_buf)
480 reiserfs_kfree (buffer, buflen, dir->i_sb);
483 if ( retval == IO_ERROR ) {
487 if (retval != NAME_FOUND) {
488 reiserfs_warning (dir->i_sb, "zam-7002:%s: \"reiserfs_find_entry\" "
489 "has returned unexpected value (%d)",
490 __FUNCTION__, retval);
496 gen_number = find_first_zero_bit ((unsigned long *)bit_string, MAX_GENERATION_NUMBER + 1);
497 if (gen_number > MAX_GENERATION_NUMBER) {
498 /* there is no free generation number */
499 reiserfs_warning (dir->i_sb, "reiserfs_add_entry: Congratulations! we have got hash function screwed up");
500 if (buffer != small_buf)
501 reiserfs_kfree (buffer, buflen, dir->i_sb);
505 /* adjust offset of directory enrty */
506 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
507 set_cpu_key_k_offset (&entry_key, deh_offset(deh));
509 /* update max-hash-collisions counter in reiserfs_sb_info */
510 PROC_INFO_MAX( th -> t_super, max_hash_collisions, gen_number );
512 if (gen_number != 0) { /* we need to re-search for the insertion point */
513 if (search_by_entry_key (dir->i_sb, &entry_key, &path, &de) != NAME_NOT_FOUND) {
514 reiserfs_warning (dir->i_sb, "vs-7032: reiserfs_add_entry: "
515 "entry with this key (%K) already exists",
518 if (buffer != small_buf)
519 reiserfs_kfree (buffer, buflen, dir->i_sb);
525 /* perform the insertion of the entry that we have prepared */
526 retval = reiserfs_paste_into_item (th, &path, &entry_key, dir, buffer, paste_size);
527 if (buffer != small_buf)
528 reiserfs_kfree (buffer, buflen, dir->i_sb);
530 reiserfs_check_path(&path) ;
534 dir->i_size += paste_size;
535 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
536 if (!S_ISDIR (inode->i_mode) && visible)
537 // reiserfs_mkdir or reiserfs_rename will do that by itself
538 reiserfs_update_sd (th, dir);
540 reiserfs_check_path(&path) ;
544 /* quota utility function, call if you've had to abort after calling
545 ** new_inode_init, and have not called reiserfs_new_inode yet.
546 ** This should only be called on inodes that do not hav stat data
547 ** inserted into the tree yet.
549 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_ALLOC_INODE cannot be called inside a transaction, so we had
559 ** to pull some bits of reiserfs_new_inode out into this func.
560 ** Yes, the actual quota calls are missing, they are part of the quota
563 static int new_inode_init(struct inode *inode, struct inode *dir, int mode) {
565 /* the quota init calls have to know who to charge the quota to, so
566 ** we have to set uid and gid here
568 inode->i_uid = current->fsuid;
569 inode->i_mode = mode;
571 if (dir->i_mode & S_ISGID) {
572 inode->i_gid = dir->i_gid;
574 inode->i_mode |= S_ISGID;
576 inode->i_gid = current->fsgid;
579 if (DQUOT_ALLOC_INODE(inode)) {
580 drop_new_inode(inode);
586 static int reiserfs_create (struct inode * dir, struct dentry *dentry, int mode,
587 struct nameidata *nd)
590 struct inode * inode;
591 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 ;
592 struct reiserfs_transaction_handle th ;
595 if (!(inode = new_inode(dir->i_sb))) {
598 retval = new_inode_init(inode, dir, mode);
602 locked = reiserfs_cache_default_acl (dir);
604 reiserfs_write_lock(dir->i_sb);
607 reiserfs_write_lock_xattrs (dir->i_sb);
609 journal_begin(&th, dir->i_sb, jbegin_count) ;
610 retval = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode);
613 reiserfs_write_unlock_xattrs (dir->i_sb);
619 inode->i_op = &reiserfs_file_inode_operations;
620 inode->i_fop = &reiserfs_file_operations;
621 inode->i_mapping->a_ops = &reiserfs_address_space_operations ;
623 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
624 inode, 1/*visible*/);
627 reiserfs_update_sd (&th, inode);
628 journal_end(&th, dir->i_sb, jbegin_count) ;
632 reiserfs_update_inode_transaction(inode) ;
633 reiserfs_update_inode_transaction(dir) ;
635 d_instantiate(dentry, inode);
636 journal_end(&th, dir->i_sb, jbegin_count) ;
639 reiserfs_write_unlock(dir->i_sb);
644 static int reiserfs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
647 struct inode * inode;
648 struct reiserfs_transaction_handle th ;
649 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
652 if (!new_valid_dev(rdev))
655 if (!(inode = new_inode(dir->i_sb))) {
658 retval = new_inode_init(inode, dir, mode);
662 locked = reiserfs_cache_default_acl (dir);
664 reiserfs_write_lock(dir->i_sb);
667 reiserfs_write_lock_xattrs (dir->i_sb);
669 journal_begin(&th, dir->i_sb, jbegin_count) ;
671 retval = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode);
674 reiserfs_write_unlock_xattrs (dir->i_sb);
680 inode->i_op = &reiserfs_special_inode_operations;
681 init_special_inode(inode, inode->i_mode, rdev) ;
683 //FIXME: needed for block and char devices only
684 reiserfs_update_sd (&th, inode);
686 reiserfs_update_inode_transaction(inode) ;
687 reiserfs_update_inode_transaction(dir) ;
689 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
690 inode, 1/*visible*/);
693 reiserfs_update_sd (&th, inode);
694 journal_end(&th, dir->i_sb, jbegin_count) ;
699 d_instantiate(dentry, inode);
700 journal_end(&th, dir->i_sb, jbegin_count) ;
703 reiserfs_write_unlock(dir->i_sb);
708 static int reiserfs_mkdir (struct inode * dir, struct dentry *dentry, int mode)
711 struct inode * inode;
712 struct reiserfs_transaction_handle th ;
713 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
716 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
717 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
718 REISERFS_I(dir)->new_packing_locality = 1;
720 mode = S_IFDIR | mode;
721 if (!(inode = new_inode(dir->i_sb))) {
724 retval = new_inode_init(inode, dir, mode);
728 locked = reiserfs_cache_default_acl (dir);
730 reiserfs_write_lock(dir->i_sb);
732 reiserfs_write_lock_xattrs (dir->i_sb);
733 journal_begin(&th, dir->i_sb, jbegin_count) ;
735 /* inc the link count now, so another writer doesn't overflow it while
736 ** we sleep later on.
738 INC_DIR_INODE_NLINK(dir)
740 retval = reiserfs_new_inode (&th, dir, mode, 0/*symlink*/,
741 old_format_only (dir->i_sb) ?
742 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
745 reiserfs_write_unlock_xattrs (dir->i_sb);
751 reiserfs_update_inode_transaction(inode) ;
752 reiserfs_update_inode_transaction(dir) ;
754 inode->i_op = &reiserfs_dir_inode_operations;
755 inode->i_fop = &reiserfs_dir_operations;
757 // note, _this_ add_entry will not update dir's stat data
758 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
759 inode, 1/*visible*/);
762 DEC_DIR_INODE_NLINK(dir);
763 reiserfs_update_sd (&th, inode);
764 journal_end(&th, dir->i_sb, jbegin_count) ;
769 // the above add_entry did not update dir's stat data
770 reiserfs_update_sd (&th, dir);
772 d_instantiate(dentry, inode);
773 journal_end(&th, dir->i_sb, jbegin_count) ;
775 reiserfs_write_unlock(dir->i_sb);
779 static inline int reiserfs_empty_dir(struct inode *inode) {
780 /* we can cheat because an old format dir cannot have
781 ** EMPTY_DIR_SIZE, and a new format dir cannot have
782 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
783 ** regardless of disk format version, the directory is empty.
785 if (inode->i_size != EMPTY_DIR_SIZE &&
786 inode->i_size != EMPTY_DIR_SIZE_V1) {
792 static int reiserfs_rmdir (struct inode * dir, struct dentry *dentry)
795 struct inode * inode;
796 struct reiserfs_transaction_handle th ;
798 INITIALIZE_PATH (path);
799 struct reiserfs_dir_entry de;
802 /* we will be doing 2 balancings and update 2 stat data */
803 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
805 reiserfs_write_lock(dir->i_sb);
806 journal_begin(&th, dir->i_sb, jbegin_count) ;
808 de.de_gen_number_bit_string = 0;
809 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
812 } else if ( retval == IO_ERROR) {
817 inode = dentry->d_inode;
819 reiserfs_update_inode_transaction(inode) ;
820 reiserfs_update_inode_transaction(dir) ;
822 if (de.de_objectid != inode->i_ino) {
823 // FIXME: compare key of an object and a key found in the
828 if (!reiserfs_empty_dir(inode)) {
833 /* cut entry from dir directory */
834 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir,
836 0/*new file size - not used here*/);
840 if ( inode->i_nlink != 2 && inode->i_nlink != 1 )
841 reiserfs_warning (inode->i_sb, "%s: empty directory has nlink "
842 "!= 2 (%d)", __FUNCTION__, inode->i_nlink);
845 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
846 reiserfs_update_sd (&th, inode);
848 DEC_DIR_INODE_NLINK(dir)
849 dir->i_size -= (DEH_SIZE + de.de_entrylen);
850 reiserfs_update_sd (&th, dir);
852 /* prevent empty directory from getting lost */
853 add_save_link (&th, inode, 0/* not truncate */);
855 journal_end(&th, dir->i_sb, jbegin_count) ;
856 reiserfs_check_path(&path) ;
857 reiserfs_write_unlock(dir->i_sb);
861 /* we must release path, because we did not call
862 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
863 release path if operation was not complete */
865 journal_end(&th, dir->i_sb, jbegin_count) ;
866 reiserfs_write_unlock(dir->i_sb);
870 static int reiserfs_unlink (struct inode * dir, struct dentry *dentry)
873 struct inode * inode;
874 struct reiserfs_dir_entry de;
875 INITIALIZE_PATH (path);
876 struct reiserfs_transaction_handle th ;
878 unsigned long savelink;
880 inode = dentry->d_inode;
882 /* in this transaction we can be doing at max two balancings and update
884 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2;
886 reiserfs_write_lock(dir->i_sb);
887 journal_begin(&th, dir->i_sb, jbegin_count) ;
889 de.de_gen_number_bit_string = 0;
890 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
893 } else if (retval == IO_ERROR) {
898 reiserfs_update_inode_transaction(inode) ;
899 reiserfs_update_inode_transaction(dir) ;
901 if (de.de_objectid != inode->i_ino) {
902 // FIXME: compare key of an object and a key found in the
908 if (!inode->i_nlink) {
909 reiserfs_warning (inode->i_sb, "%s: deleting nonexistent file "
910 "(%s:%lu), %d", __FUNCTION__,
911 reiserfs_bdevname (inode->i_sb), inode->i_ino,
919 * we schedule before doing the add_save_link call, save the link
920 * count so we don't race
922 savelink = inode->i_nlink;
925 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir, NULL, 0);
930 inode->i_ctime = CURRENT_TIME;
931 reiserfs_update_sd (&th, inode);
933 dir->i_size -= (de.de_entrylen + DEH_SIZE);
934 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
935 reiserfs_update_sd (&th, dir);
938 /* prevent file from getting lost */
939 add_save_link (&th, inode, 0/* not truncate */);
941 journal_end(&th, dir->i_sb, jbegin_count) ;
942 reiserfs_check_path(&path) ;
943 reiserfs_write_unlock(dir->i_sb);
948 journal_end(&th, dir->i_sb, jbegin_count) ;
949 reiserfs_check_path(&path) ;
950 reiserfs_write_unlock(dir->i_sb);
954 static int reiserfs_symlink (struct inode * parent_dir,
955 struct dentry * dentry, const char * symname)
958 struct inode * inode;
961 struct reiserfs_transaction_handle th ;
962 int mode = S_IFLNK | S_IRWXUGO;
963 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
965 if (!(inode = new_inode(parent_dir->i_sb))) {
968 retval = new_inode_init(inode, parent_dir, mode);
973 reiserfs_write_lock(parent_dir->i_sb);
974 item_len = ROUND_UP (strlen (symname));
975 if (item_len > MAX_DIRECT_ITEM_LEN (parent_dir->i_sb->s_blocksize)) {
976 retval = -ENAMETOOLONG;
977 drop_new_inode(inode);
981 name = reiserfs_kmalloc (item_len, GFP_NOFS, parent_dir->i_sb);
983 drop_new_inode(inode);
987 memcpy (name, symname, strlen (symname));
988 padd_item (name, item_len, strlen (symname));
990 /* We would inherit the default ACL here, but symlinks don't get ACLs */
992 journal_begin(&th, parent_dir->i_sb, jbegin_count) ;
994 retval = reiserfs_new_inode (&th, parent_dir, mode, name, strlen (symname),
996 reiserfs_kfree (name, item_len, parent_dir->i_sb);
997 if (retval) { /* reiserfs_new_inode iputs for us */
1001 reiserfs_update_inode_transaction(inode) ;
1002 reiserfs_update_inode_transaction(parent_dir) ;
1004 inode->i_op = &reiserfs_symlink_inode_operations;
1005 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1007 // must be sure this inode is written with this transaction
1009 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1011 retval = reiserfs_add_entry (&th, parent_dir, dentry->d_name.name,
1012 dentry->d_name.len, inode, 1/*visible*/);
1015 reiserfs_update_sd (&th, inode);
1016 journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1021 d_instantiate(dentry, inode);
1022 journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1024 reiserfs_write_unlock(parent_dir->i_sb);
1028 static int reiserfs_link (struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
1031 struct inode *inode = old_dentry->d_inode;
1032 struct reiserfs_transaction_handle th ;
1033 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
1035 reiserfs_write_lock(dir->i_sb);
1036 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1037 //FIXME: sd_nlink is 32 bit for new files
1038 reiserfs_write_unlock(dir->i_sb);
1041 if (inode->i_nlink == 0) {
1045 /* inc before scheduling so reiserfs_unlink knows we are here */
1048 journal_begin(&th, dir->i_sb, jbegin_count) ;
1050 /* create new entry */
1051 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
1052 inode, 1/*visible*/);
1054 reiserfs_update_inode_transaction(inode) ;
1055 reiserfs_update_inode_transaction(dir) ;
1059 journal_end(&th, dir->i_sb, jbegin_count) ;
1060 reiserfs_write_unlock(dir->i_sb);
1064 inode->i_ctime = CURRENT_TIME;
1065 reiserfs_update_sd (&th, inode);
1067 atomic_inc(&inode->i_count) ;
1068 d_instantiate(dentry, inode);
1069 journal_end(&th, dir->i_sb, jbegin_count) ;
1070 reiserfs_write_unlock(dir->i_sb);
1075 // de contains information pointing to an entry which
1076 static int de_still_valid (const char * name, int len, struct reiserfs_dir_entry * de)
1078 struct reiserfs_dir_entry tmp = *de;
1080 // recalculate pointer to name and name length
1081 set_de_name_and_namelen (&tmp);
1082 // FIXME: could check more
1083 if (tmp.de_namelen != len || memcmp (name, de->de_name, len))
1089 static int entry_points_to_object (const char * name, int len, struct reiserfs_dir_entry * de, struct inode * inode)
1091 if (!de_still_valid (name, len, de))
1095 if (!de_visible (de->de_deh + de->de_entry_num))
1096 reiserfs_panic (0, "vs-7042: entry_points_to_object: entry must be visible");
1097 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1100 /* this must be added hidden entry */
1101 if (de_visible (de->de_deh + de->de_entry_num))
1102 reiserfs_panic (0, "vs-7043: entry_points_to_object: entry must be visible");
1108 /* sets key of objectid the entry has to point to */
1109 static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct key * key)
1111 /* JDM These operations are endian safe - both are le */
1112 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1113 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1118 * process, that is going to call fix_nodes/do_balance must hold only
1119 * one path. If it holds 2 or more, it can get into endless waiting in
1120 * get_empty_nodes or its clones
1122 static int reiserfs_rename (struct inode * old_dir, struct dentry *old_dentry,
1123 struct inode * new_dir, struct dentry *new_dentry)
1126 INITIALIZE_PATH (old_entry_path);
1127 INITIALIZE_PATH (new_entry_path);
1128 INITIALIZE_PATH (dot_dot_entry_path);
1129 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih ;
1130 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1131 struct inode * old_inode, * new_dentry_inode;
1132 struct reiserfs_transaction_handle th ;
1134 umode_t old_inode_mode;
1135 unsigned long savelink = 1;
1136 struct timespec ctime;
1138 /* three balancings: (1) old name removal, (2) new name insertion
1139 and (3) maybe "save" link insertion
1140 stat data updates: (1) old directory,
1141 (2) new directory and (3) maybe old object stat data (when it is
1142 directory) and (4) maybe stat data of object to which new entry
1143 pointed initially and (5) maybe block containing ".." of
1144 renamed directory */
1145 jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 5;
1147 old_inode = old_dentry->d_inode;
1148 new_dentry_inode = new_dentry->d_inode;
1150 // make sure, that oldname still exists and points to an object we
1151 // are going to rename
1152 old_de.de_gen_number_bit_string = 0;
1153 reiserfs_write_lock(old_dir->i_sb);
1154 retval = reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len,
1155 &old_entry_path, &old_de);
1156 pathrelse (&old_entry_path);
1157 if (retval == IO_ERROR) {
1158 reiserfs_write_unlock(old_dir->i_sb);
1162 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1163 reiserfs_write_unlock(old_dir->i_sb);
1167 old_inode_mode = old_inode->i_mode;
1168 if (S_ISDIR(old_inode_mode)) {
1169 // make sure, that directory being renamed has correct ".."
1170 // and that its new parent directory has not too many links
1173 if (new_dentry_inode) {
1174 if (!reiserfs_empty_dir(new_dentry_inode)) {
1175 reiserfs_write_unlock(old_dir->i_sb);
1180 /* directory is renamed, its parent directory will be changed,
1181 ** so find ".." entry
1183 dot_dot_de.de_gen_number_bit_string = 0;
1184 retval = reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de);
1185 pathrelse (&dot_dot_entry_path);
1186 if (retval != NAME_FOUND) {
1187 reiserfs_write_unlock(old_dir->i_sb);
1191 /* inode number of .. must equal old_dir->i_ino */
1192 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1193 reiserfs_write_unlock(old_dir->i_sb);
1198 journal_begin(&th, old_dir->i_sb, jbegin_count) ;
1200 /* add new entry (or find the existing one) */
1201 retval = reiserfs_add_entry (&th, new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1203 if (retval == -EEXIST) {
1204 if (!new_dentry_inode) {
1205 reiserfs_panic (old_dir->i_sb,
1206 "vs-7050: new entry is found, new inode == 0\n");
1208 } else if (retval) {
1209 journal_end(&th, old_dir->i_sb, jbegin_count) ;
1210 reiserfs_write_unlock(old_dir->i_sb);
1214 reiserfs_update_inode_transaction(old_dir) ;
1215 reiserfs_update_inode_transaction(new_dir) ;
1217 /* this makes it so an fsync on an open fd for the old name will
1218 ** commit the rename operation
1220 reiserfs_update_inode_transaction(old_inode) ;
1222 if (new_dentry_inode)
1223 reiserfs_update_inode_transaction(new_dentry_inode) ;
1226 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1227 if (search_by_entry_key (new_dir->i_sb, &old_de.de_entry_key, &old_entry_path, &old_de) != NAME_FOUND)
1230 copy_item_head(&old_entry_ih, get_ih(&old_entry_path)) ;
1232 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1) ;
1234 // look for new name by reiserfs_find_entry
1235 new_de.de_gen_number_bit_string = 0;
1236 retval = reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1237 &new_entry_path, &new_de);
1238 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1239 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1240 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND)
1243 copy_item_head(&new_entry_ih, get_ih(&new_entry_path)) ;
1245 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1) ;
1247 if (S_ISDIR(old_inode->i_mode)) {
1248 if (search_by_entry_key (new_dir->i_sb, &dot_dot_de.de_entry_key, &dot_dot_entry_path, &dot_dot_de) != NAME_FOUND)
1250 copy_item_head(&dot_dot_ih, get_ih(&dot_dot_entry_path)) ;
1251 // node containing ".." gets into transaction
1252 reiserfs_prepare_for_journal(old_inode->i_sb, dot_dot_de.de_bh, 1) ;
1254 /* we should check seals here, not do
1255 this stuff, yes? Then, having
1256 gathered everything into RAM we
1257 should lock the buffers, yes? -Hans */
1258 /* probably. our rename needs to hold more
1259 ** than one path at once. The seals would
1260 ** have to be written to deal with multi-path
1263 /* sanity checking before doing the rename - avoid races many
1264 ** of the above checks could have scheduled. We have to be
1265 ** sure our items haven't been shifted by another process.
1267 if (item_moved(&new_entry_ih, &new_entry_path) ||
1268 !entry_points_to_object(new_dentry->d_name.name,
1269 new_dentry->d_name.len,
1270 &new_de, new_dentry_inode) ||
1271 item_moved(&old_entry_ih, &old_entry_path) ||
1272 !entry_points_to_object (old_dentry->d_name.name,
1273 old_dentry->d_name.len,
1274 &old_de, old_inode)) {
1275 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1276 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1277 if (S_ISDIR(old_inode_mode))
1278 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1281 if (S_ISDIR(old_inode_mode)) {
1282 if ( item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1283 !entry_points_to_object ( "..", 2, &dot_dot_de, old_dir) ) {
1284 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1285 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1286 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1291 RFALSE( S_ISDIR(old_inode_mode) &&
1292 !reiserfs_buffer_prepared(dot_dot_de.de_bh), "" );
1297 /* ok, all the changes can be done in one fell swoop when we
1298 have claimed all the buffers needed.*/
1300 mark_de_visible (new_de.de_deh + new_de.de_entry_num);
1301 set_ino_in_dir_entry (&new_de, INODE_PKEY (old_inode));
1302 journal_mark_dirty (&th, old_dir->i_sb, new_de.de_bh);
1304 mark_de_hidden (old_de.de_deh + old_de.de_entry_num);
1305 journal_mark_dirty (&th, old_dir->i_sb, old_de.de_bh);
1306 ctime = CURRENT_TIME;
1307 old_dir->i_ctime = old_dir->i_mtime = ctime;
1308 new_dir->i_ctime = new_dir->i_mtime = ctime;
1309 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1311 old_inode->i_ctime = ctime;
1313 if (new_dentry_inode) {
1314 // adjust link number of the victim
1315 if (S_ISDIR(new_dentry_inode->i_mode)) {
1316 new_dentry_inode->i_nlink = 0;
1318 new_dentry_inode->i_nlink--;
1320 new_dentry_inode->i_ctime = ctime;
1321 savelink = new_dentry_inode->i_nlink;
1324 if (S_ISDIR(old_inode_mode)) {
1325 // adjust ".." of renamed directory
1326 set_ino_in_dir_entry (&dot_dot_de, INODE_PKEY (new_dir));
1327 journal_mark_dirty (&th, new_dir->i_sb, dot_dot_de.de_bh);
1329 if (!new_dentry_inode)
1330 /* there (in new_dir) was no directory, so it got new link
1331 (".." of renamed directory) */
1332 INC_DIR_INODE_NLINK(new_dir);
1334 /* old directory lost one link - ".. " of renamed directory */
1335 DEC_DIR_INODE_NLINK(old_dir);
1338 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1339 pathrelse (&new_entry_path);
1340 pathrelse (&dot_dot_entry_path);
1342 // FIXME: this reiserfs_cut_from_item's return value may screw up
1343 // anybody, but it will panic if will not be able to find the
1344 // entry. This needs one more clean up
1345 if (reiserfs_cut_from_item (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL, 0) < 0)
1346 reiserfs_warning (old_dir->i_sb, "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
1348 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1350 reiserfs_update_sd (&th, old_dir);
1351 reiserfs_update_sd (&th, new_dir);
1352 reiserfs_update_sd (&th, old_inode);
1354 if (new_dentry_inode) {
1356 add_save_link (&th, new_dentry_inode, 0/* not truncate */);
1357 reiserfs_update_sd (&th, new_dentry_inode);
1360 journal_end(&th, old_dir->i_sb, jbegin_count) ;
1361 reiserfs_write_unlock(old_dir->i_sb);
1366 * directories can handle most operations...
1368 struct inode_operations reiserfs_dir_inode_operations = {
1369 //&reiserfs_dir_operations, /* default_file_ops */
1370 .create = reiserfs_create,
1371 .lookup = reiserfs_lookup,
1372 .link = reiserfs_link,
1373 .unlink = reiserfs_unlink,
1374 .symlink = reiserfs_symlink,
1375 .mkdir = reiserfs_mkdir,
1376 .rmdir = reiserfs_rmdir,
1377 .mknod = reiserfs_mknod,
1378 .rename = reiserfs_rename,
1379 .setattr = reiserfs_setattr,
1380 .setxattr = reiserfs_setxattr,
1381 .getxattr = reiserfs_getxattr,
1382 .listxattr = reiserfs_listxattr,
1383 .removexattr = reiserfs_removexattr,
1384 .permission = reiserfs_permission,
1388 * symlink operations.. same as page_symlink_inode_operations, with xattr
1391 struct inode_operations reiserfs_symlink_inode_operations = {
1392 .readlink = generic_readlink,
1393 .follow_link = page_follow_link_light,
1394 .put_link = page_put_link,
1395 .setattr = reiserfs_setattr,
1396 .setxattr = reiserfs_setxattr,
1397 .getxattr = reiserfs_getxattr,
1398 .listxattr = reiserfs_listxattr,
1399 .removexattr = reiserfs_removexattr,
1400 .permission = reiserfs_permission,
1406 * special file operations.. just xattr/acl stuff
1408 struct inode_operations reiserfs_special_inode_operations = {
1409 .setattr = reiserfs_setattr,
1410 .setxattr = reiserfs_setxattr,
1411 .getxattr = reiserfs_getxattr,
1412 .listxattr = reiserfs_listxattr,
1413 .removexattr = reiserfs_removexattr,
1414 .permission = reiserfs_permission,