2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
4 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
7 * Rights granted to Hans Reiser to redistribute under other terms providing
8 * he accepts all liability including but not limited to patent, fitness
9 * for purpose, and direct or indirect claims arising from failure to perform.
14 #include <linux/time.h>
15 #include <linux/bitops.h>
16 #include <linux/reiserfs_fs.h>
17 #include <linux/reiserfs_acl.h>
18 #include <linux/reiserfs_xattr.h>
19 #include <linux/quotaops.h>
21 #define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) i->i_nlink=1; }
22 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
24 // directory item contains array of entry headers. This performs
25 // binary search through that array
26 static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
28 struct item_head *ih = de->de_ih;
29 struct reiserfs_de_head *deh = de->de_deh;
30 int rbound, lbound, j;
33 rbound = I_ENTRY_COUNT(ih) - 1;
35 for (j = (rbound + lbound) / 2; lbound <= rbound;
36 j = (rbound + lbound) / 2) {
37 if (off < deh_offset(deh + j)) {
41 if (off > deh_offset(deh + j)) {
45 // this is not name found, but matched third key component
50 de->de_entry_num = lbound;
51 return NAME_NOT_FOUND;
54 // comment? maybe something like set de to point to what the path points to?
55 static inline void set_de_item_location(struct reiserfs_dir_entry *de,
56 struct treepath *path)
58 de->de_bh = get_last_bh(path);
59 de->de_ih = get_ih(path);
60 de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
61 de->de_item_num = PATH_LAST_POSITION(path);
64 // de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
65 inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
67 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
69 BUG_ON(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);
78 // what entry points to
79 static inline void set_de_object_key(struct reiserfs_dir_entry *de)
81 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
82 de->de_dir_id = deh_dir_id(&(de->de_deh[de->de_entry_num]));
83 de->de_objectid = deh_objectid(&(de->de_deh[de->de_entry_num]));
86 static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
88 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
90 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
92 /* store key of the found entry */
93 de->de_entry_key.version = KEY_FORMAT_3_5;
94 de->de_entry_key.on_disk_key.k_dir_id =
95 le32_to_cpu(de->de_ih->ih_key.k_dir_id);
96 de->de_entry_key.on_disk_key.k_objectid =
97 le32_to_cpu(de->de_ih->ih_key.k_objectid);
98 set_cpu_key_k_offset(&(de->de_entry_key), deh_offset(deh));
99 set_cpu_key_k_type(&(de->de_entry_key), TYPE_DIRENTRY);
102 /* We assign a key to each directory item, and place multiple entries
103 in a single directory item. A directory item has a key equal to the
104 key of the first directory entry in it.
106 This function first calls search_by_key, then, if item whose first
107 entry matches is not found it looks for the entry inside directory
108 item found by search_by_key. Fills the path to the entry, and to the
109 entry position in the item
113 /* The function is NOT SCHEDULE-SAFE! */
114 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
115 struct treepath *path, struct reiserfs_dir_entry *de)
119 retval = search_item(sb, key, path);
122 if (!PATH_LAST_POSITION(path)) {
123 reiserfs_error(sb, "vs-7000", "search_by_key "
124 "returned item position == 0");
128 PATH_LAST_POSITION(path)--;
138 reiserfs_error(sb, "vs-7002", "no path to here");
142 set_de_item_location(de, path);
144 #ifdef CONFIG_REISERFS_CHECK
145 if (!is_direntry_le_ih(de->de_ih) ||
146 COMP_SHORT_KEYS(&(de->de_ih->ih_key), key)) {
147 print_block(de->de_bh, 0, -1, -1);
148 reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
149 "item or does not belong to the same directory "
150 "as key %K", de->de_ih, key);
152 #endif /* CONFIG_REISERFS_CHECK */
154 /* binary search in directory item by third componen t of the
155 key. sets de->de_entry_num of de */
156 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
157 path->pos_in_item = de->de_entry_num;
158 if (retval != NAME_NOT_FOUND) {
159 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
160 set_de_name_and_namelen(de);
161 set_de_object_key(de);
166 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
168 /* The third component is hashed, and you can choose from more than
169 one hash function. Per directory hashes are not yet implemented
170 but are thought about. This function should be moved to hashes.c
171 Jedi, please do so. -Hans */
173 static __u32 get_third_component(struct super_block *s,
174 const char *name, int len)
178 if (!len || (len == 1 && name[0] == '.'))
180 if (len == 2 && name[0] == '.' && name[1] == '.')
181 return DOT_DOT_OFFSET;
183 res = REISERFS_SB(s)->s_hash_function(name, len);
185 // take bits from 7-th to 30-th including both bounds
186 res = GET_HASH_VALUE(res);
188 // needed to have no names before "." and ".." those have hash
189 // value == 0 and generation conters 1 and 2 accordingly
191 return res + MAX_GENERATION_NUMBER;
194 static int reiserfs_match(struct reiserfs_dir_entry *de,
195 const char *name, int namelen)
197 int retval = NAME_NOT_FOUND;
199 if ((namelen == de->de_namelen) &&
200 !memcmp(de->de_name, name, de->de_namelen))
202 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
203 NAME_FOUND_INVISIBLE);
208 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
210 /* used when hash collisions exist */
212 static int linear_search_in_dir_item(struct cpu_key *key,
213 struct reiserfs_dir_entry *de,
214 const char *name, int namelen)
216 struct reiserfs_de_head *deh = de->de_deh;
220 i = de->de_entry_num;
222 if (i == I_ENTRY_COUNT(de->de_ih) ||
223 GET_HASH_VALUE(deh_offset(deh + i)) !=
224 GET_HASH_VALUE(cpu_key_k_offset(key))) {
228 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
229 "vs-7010: array of entry headers not found");
233 for (; i >= 0; i--, deh--) {
234 if (GET_HASH_VALUE(deh_offset(deh)) !=
235 GET_HASH_VALUE(cpu_key_k_offset(key))) {
236 // hash value does not match, no need to check whole name
237 return NAME_NOT_FOUND;
240 /* mark, that this generation number is used */
241 if (de->de_gen_number_bit_string)
242 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
243 de->de_gen_number_bit_string);
245 // calculate pointer to name and namelen
246 de->de_entry_num = i;
247 set_de_name_and_namelen(de);
250 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;
279 // may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
280 // FIXME: should add something like IOERROR
281 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
282 struct treepath *path_to_entry,
283 struct reiserfs_dir_entry *de)
285 struct cpu_key key_to_search;
288 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
289 return NAME_NOT_FOUND;
291 /* we will search for this key in the tree */
292 make_cpu_key(&key_to_search, dir,
293 get_third_component(dir->i_sb, name, namelen),
298 search_by_entry_key(dir->i_sb, &key_to_search,
300 if (retval == IO_ERROR) {
301 reiserfs_error(dir->i_sb, "zam-7001", "io error");
305 /* compare names for all entries having given hash value */
307 linear_search_in_dir_item(&key_to_search, de, name,
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,
317 le_ih_k_offset(de->de_ih) - 1);
318 pathrelse(path_to_entry);
323 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
324 struct nameidata *nd)
327 struct inode *inode = NULL;
328 struct reiserfs_dir_entry de;
329 INITIALIZE_PATH(path_to_entry);
331 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
332 return ERR_PTR(-ENAMETOOLONG);
334 reiserfs_write_lock(dir->i_sb);
335 de.de_gen_number_bit_string = NULL;
337 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
338 &path_to_entry, &de);
339 pathrelse(&path_to_entry);
340 if (retval == NAME_FOUND) {
341 /* Hide the .reiserfs_priv directory */
342 if (reiserfs_xattrs(dir->i_sb) &&
343 !old_format_only(dir->i_sb) &&
344 REISERFS_SB(dir->i_sb)->priv_root &&
345 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
347 le32_to_cpu(INODE_PKEY
348 (REISERFS_SB(dir->i_sb)->priv_root->d_inode)->
350 reiserfs_write_unlock(dir->i_sb);
351 return ERR_PTR(-EACCES);
355 reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
356 if (!inode || IS_ERR(inode)) {
357 reiserfs_write_unlock(dir->i_sb);
358 return ERR_PTR(-EACCES);
361 /* Propagate the private flag so we know we're
362 * in the priv tree */
364 inode->i_flags |= S_PRIVATE;
366 reiserfs_write_unlock(dir->i_sb);
367 if (retval == IO_ERROR) {
368 return ERR_PTR(-EIO);
371 return d_splice_alias(inode, dentry);
375 ** looks up the dentry of the parent directory for child.
376 ** taken from ext2_get_parent
378 struct dentry *reiserfs_get_parent(struct dentry *child)
381 struct inode *inode = NULL;
382 struct reiserfs_dir_entry de;
383 INITIALIZE_PATH(path_to_entry);
384 struct inode *dir = child->d_inode;
386 if (dir->i_nlink == 0) {
387 return ERR_PTR(-ENOENT);
389 de.de_gen_number_bit_string = NULL;
391 reiserfs_write_lock(dir->i_sb);
392 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
393 pathrelse(&path_to_entry);
394 if (retval != NAME_FOUND) {
395 reiserfs_write_unlock(dir->i_sb);
396 return ERR_PTR(-ENOENT);
398 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
399 reiserfs_write_unlock(dir->i_sb);
401 return d_obtain_alias(inode);
404 /* add entry to the directory (entry can be hidden).
406 insert definition of when hidden directories are used here -Hans
408 Does not mark dir inode dirty, do it after successesfull call to it */
410 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
411 struct inode *dir, const char *name, int namelen,
412 struct inode *inode, int visible)
414 struct cpu_key entry_key;
415 struct reiserfs_de_head *deh;
416 INITIALIZE_PATH(path);
417 struct reiserfs_dir_entry de;
418 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
420 char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
421 if we create file with short name */
423 int buflen, paste_size;
426 BUG_ON(!th->t_trans_id);
428 /* cannot allow items to be added into a busy deleted directory */
432 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
433 return -ENAMETOOLONG;
435 /* each entry has unique key. compose it */
436 make_cpu_key(&entry_key, dir,
437 get_third_component(dir->i_sb, name, namelen),
440 /* get memory for composing the entry */
441 buflen = DEH_SIZE + ROUND_UP(namelen);
442 if (buflen > sizeof(small_buf)) {
443 buffer = kmalloc(buflen, GFP_NOFS);
450 (get_inode_sd_version(dir) ==
451 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
453 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
454 deh = (struct reiserfs_de_head *)buffer;
455 deh->deh_location = 0; /* JDM Endian safe if 0 */
456 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
457 deh->deh_state = 0; /* JDM Endian safe if 0 */
458 /* put key (ino analog) to de */
459 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
460 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
463 memcpy((char *)(deh + 1), name, namelen);
464 /* padd by 0s to the 4 byte boundary */
465 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
467 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
468 mark_de_without_sd(deh);
469 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
471 /* find the proper place for the new entry */
472 memset(bit_string, 0, sizeof(bit_string));
473 de.de_gen_number_bit_string = bit_string;
474 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
475 if (retval != NAME_NOT_FOUND) {
476 if (buffer != small_buf)
480 if (retval == IO_ERROR) {
484 if (retval != NAME_FOUND) {
485 reiserfs_error(dir->i_sb, "zam-7002",
486 "reiserfs_find_entry() returned "
487 "unexpected value (%d)", retval);
494 find_first_zero_bit(bit_string,
495 MAX_GENERATION_NUMBER + 1);
496 if (gen_number > MAX_GENERATION_NUMBER) {
497 /* there is no free generation number */
498 reiserfs_warning(dir->i_sb, "reiserfs-7010",
499 "Congratulations! we have got hash function "
501 if (buffer != small_buf)
506 /* adjust offset of directory enrty */
507 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
508 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
510 /* update max-hash-collisions counter in reiserfs_sb_info */
511 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
513 if (gen_number != 0) { /* we need to re-search for the insertion point */
514 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
516 reiserfs_warning(dir->i_sb, "vs-7032",
517 "entry with this key (%K) already "
518 "exists", &entry_key);
520 if (buffer != small_buf)
527 /* perform the insertion of the entry that we have prepared */
529 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
531 if (buffer != small_buf)
534 reiserfs_check_path(&path);
538 dir->i_size += paste_size;
539 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
540 if (!S_ISDIR(inode->i_mode) && visible)
541 // reiserfs_mkdir or reiserfs_rename will do that by itself
542 reiserfs_update_sd(th, dir);
544 reiserfs_check_path(&path);
548 /* quota utility function, call if you've had to abort after calling
549 ** new_inode_init, and have not called reiserfs_new_inode yet.
550 ** This should only be called on inodes that do not have stat data
551 ** inserted into the tree yet.
553 static int drop_new_inode(struct inode *inode)
556 make_bad_inode(inode);
557 inode->i_flags |= S_NOQUOTA;
562 /* utility function that does setup for reiserfs_new_inode.
563 ** DQUOT_INIT needs lots of credits so it's better to have it
564 ** outside of a transaction, so we had to pull some bits of
565 ** reiserfs_new_inode out into this func.
567 static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
570 /* the quota init calls have to know who to charge the quota to, so
571 ** we have to set uid and gid here
573 inode->i_uid = current_fsuid();
574 inode->i_mode = mode;
575 /* Make inode invalid - just in case we are going to drop it before
576 * the initialization happens */
577 INODE_PKEY(inode)->k_objectid = 0;
579 if (dir->i_mode & S_ISGID) {
580 inode->i_gid = dir->i_gid;
582 inode->i_mode |= S_ISGID;
584 inode->i_gid = current_fsgid();
590 static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
591 struct nameidata *nd)
595 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
597 JOURNAL_PER_BALANCE_CNT * 2 +
598 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
599 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
600 struct reiserfs_transaction_handle th;
603 if (!(inode = new_inode(dir->i_sb))) {
606 new_inode_init(inode, dir, mode);
608 locked = reiserfs_cache_default_acl(dir);
610 reiserfs_write_lock(dir->i_sb);
612 retval = journal_begin(&th, dir->i_sb, jbegin_count);
614 drop_new_inode(inode);
619 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
624 inode->i_op = &reiserfs_file_inode_operations;
625 inode->i_fop = &reiserfs_file_operations;
626 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
629 reiserfs_add_entry(&th, dir, dentry->d_name.name,
630 dentry->d_name.len, inode, 1 /*visible */ );
634 reiserfs_update_sd(&th, inode);
635 err = journal_end(&th, dir->i_sb, jbegin_count);
638 unlock_new_inode(inode);
642 reiserfs_update_inode_transaction(inode);
643 reiserfs_update_inode_transaction(dir);
645 d_instantiate(dentry, inode);
646 unlock_new_inode(inode);
647 retval = journal_end(&th, dir->i_sb, jbegin_count);
650 reiserfs_write_unlock(dir->i_sb);
654 static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
659 struct reiserfs_transaction_handle th;
660 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
662 JOURNAL_PER_BALANCE_CNT * 3 +
663 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
664 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
667 if (!new_valid_dev(rdev))
670 if (!(inode = new_inode(dir->i_sb))) {
673 new_inode_init(inode, dir, mode);
675 locked = reiserfs_cache_default_acl(dir);
677 reiserfs_write_lock(dir->i_sb);
679 retval = journal_begin(&th, dir->i_sb, jbegin_count);
681 drop_new_inode(inode);
686 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
692 inode->i_op = &reiserfs_special_inode_operations;
693 init_special_inode(inode, inode->i_mode, rdev);
695 //FIXME: needed for block and char devices only
696 reiserfs_update_sd(&th, inode);
698 reiserfs_update_inode_transaction(inode);
699 reiserfs_update_inode_transaction(dir);
702 reiserfs_add_entry(&th, dir, dentry->d_name.name,
703 dentry->d_name.len, inode, 1 /*visible */ );
707 reiserfs_update_sd(&th, inode);
708 err = journal_end(&th, dir->i_sb, jbegin_count);
711 unlock_new_inode(inode);
716 d_instantiate(dentry, inode);
717 unlock_new_inode(inode);
718 retval = journal_end(&th, dir->i_sb, jbegin_count);
721 reiserfs_write_unlock(dir->i_sb);
725 static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
729 struct reiserfs_transaction_handle th;
730 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
732 JOURNAL_PER_BALANCE_CNT * 3 +
733 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
734 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
737 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
738 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
739 REISERFS_I(dir)->new_packing_locality = 1;
741 mode = S_IFDIR | mode;
742 if (!(inode = new_inode(dir->i_sb))) {
745 new_inode_init(inode, dir, mode);
747 locked = reiserfs_cache_default_acl(dir);
749 reiserfs_write_lock(dir->i_sb);
751 retval = journal_begin(&th, dir->i_sb, jbegin_count);
753 drop_new_inode(inode);
757 /* inc the link count now, so another writer doesn't overflow it while
758 ** we sleep later on.
760 INC_DIR_INODE_NLINK(dir)
762 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
763 old_format_only(dir->i_sb) ?
764 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
771 reiserfs_update_inode_transaction(inode);
772 reiserfs_update_inode_transaction(dir);
774 inode->i_op = &reiserfs_dir_inode_operations;
775 inode->i_fop = &reiserfs_dir_operations;
777 // note, _this_ add_entry will not update dir's stat data
779 reiserfs_add_entry(&th, dir, dentry->d_name.name,
780 dentry->d_name.len, inode, 1 /*visible */ );
784 DEC_DIR_INODE_NLINK(dir);
785 reiserfs_update_sd(&th, inode);
786 err = journal_end(&th, dir->i_sb, jbegin_count);
789 unlock_new_inode(inode);
793 // the above add_entry did not update dir's stat data
794 reiserfs_update_sd(&th, dir);
796 d_instantiate(dentry, inode);
797 unlock_new_inode(inode);
798 retval = journal_end(&th, dir->i_sb, jbegin_count);
800 reiserfs_write_unlock(dir->i_sb);
804 static inline int reiserfs_empty_dir(struct inode *inode)
806 /* we can cheat because an old format dir cannot have
807 ** EMPTY_DIR_SIZE, and a new format dir cannot have
808 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
809 ** regardless of disk format version, the directory is empty.
811 if (inode->i_size != EMPTY_DIR_SIZE &&
812 inode->i_size != EMPTY_DIR_SIZE_V1) {
818 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
822 struct reiserfs_transaction_handle th;
824 INITIALIZE_PATH(path);
825 struct reiserfs_dir_entry de;
827 /* we will be doing 2 balancings and update 2 stat data, we change quotas
828 * of the owner of the directory and of the owner of the parent directory.
829 * The quota structure is possibly deleted only on last iput => outside
830 * of this transaction */
832 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
833 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
835 reiserfs_write_lock(dir->i_sb);
836 retval = journal_begin(&th, dir->i_sb, jbegin_count);
840 de.de_gen_number_bit_string = NULL;
842 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
843 &path, &de)) == NAME_NOT_FOUND) {
846 } else if (retval == IO_ERROR) {
851 inode = dentry->d_inode;
853 reiserfs_update_inode_transaction(inode);
854 reiserfs_update_inode_transaction(dir);
856 if (de.de_objectid != inode->i_ino) {
857 // FIXME: compare key of an object and a key found in the
862 if (!reiserfs_empty_dir(inode)) {
867 /* cut entry from dir directory */
868 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL, /* page */
869 0 /*new file size - not used here */ );
873 if (inode->i_nlink != 2 && inode->i_nlink != 1)
874 reiserfs_error(inode->i_sb, "reiserfs-7040",
875 "empty directory has nlink != 2 (%d)",
879 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
880 reiserfs_update_sd(&th, inode);
882 DEC_DIR_INODE_NLINK(dir)
883 dir->i_size -= (DEH_SIZE + de.de_entrylen);
884 reiserfs_update_sd(&th, dir);
886 /* prevent empty directory from getting lost */
887 add_save_link(&th, inode, 0 /* not truncate */ );
889 retval = journal_end(&th, dir->i_sb, jbegin_count);
890 reiserfs_check_path(&path);
892 reiserfs_write_unlock(dir->i_sb);
896 /* we must release path, because we did not call
897 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
898 release path if operation was not complete */
900 err = journal_end(&th, dir->i_sb, jbegin_count);
901 reiserfs_write_unlock(dir->i_sb);
902 return err ? err : retval;
905 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
909 struct reiserfs_dir_entry de;
910 INITIALIZE_PATH(path);
911 struct reiserfs_transaction_handle th;
913 unsigned long savelink;
915 inode = dentry->d_inode;
917 /* in this transaction we can be doing at max two balancings and update
918 * two stat datas, we change quotas of the owner of the directory and of
919 * the owner of the parent directory. The quota structure is possibly
920 * deleted only on iput => outside of this transaction */
922 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
923 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
925 reiserfs_write_lock(dir->i_sb);
926 retval = journal_begin(&th, dir->i_sb, jbegin_count);
930 de.de_gen_number_bit_string = NULL;
932 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
933 &path, &de)) == NAME_NOT_FOUND) {
936 } else if (retval == IO_ERROR) {
941 reiserfs_update_inode_transaction(inode);
942 reiserfs_update_inode_transaction(dir);
944 if (de.de_objectid != inode->i_ino) {
945 // FIXME: compare key of an object and a key found in the
951 if (!inode->i_nlink) {
952 reiserfs_warning(inode->i_sb, "reiserfs-7042",
953 "deleting nonexistent file (%lu), %d",
954 inode->i_ino, inode->i_nlink);
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 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
973 inode->i_ctime = CURRENT_TIME_SEC;
974 reiserfs_update_sd(&th, inode);
976 dir->i_size -= (de.de_entrylen + DEH_SIZE);
977 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
978 reiserfs_update_sd(&th, dir);
981 /* prevent file from getting lost */
982 add_save_link(&th, inode, 0 /* not truncate */ );
984 retval = journal_end(&th, dir->i_sb, jbegin_count);
985 reiserfs_check_path(&path);
986 reiserfs_write_unlock(dir->i_sb);
991 err = journal_end(&th, dir->i_sb, jbegin_count);
992 reiserfs_check_path(&path);
996 reiserfs_write_unlock(dir->i_sb);
1000 static int reiserfs_symlink(struct inode *parent_dir,
1001 struct dentry *dentry, const char *symname)
1004 struct inode *inode;
1007 struct reiserfs_transaction_handle th;
1008 int mode = S_IFLNK | S_IRWXUGO;
1009 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1011 JOURNAL_PER_BALANCE_CNT * 3 +
1012 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1013 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1015 if (!(inode = new_inode(parent_dir->i_sb))) {
1018 new_inode_init(inode, parent_dir, mode);
1020 reiserfs_write_lock(parent_dir->i_sb);
1021 item_len = ROUND_UP(strlen(symname));
1022 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1023 retval = -ENAMETOOLONG;
1024 drop_new_inode(inode);
1028 name = kmalloc(item_len, GFP_NOFS);
1030 drop_new_inode(inode);
1034 memcpy(name, symname, strlen(symname));
1035 padd_item(name, item_len, strlen(symname));
1037 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1039 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1041 drop_new_inode(inode);
1047 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1050 if (retval) { /* reiserfs_new_inode iputs for us */
1054 reiserfs_update_inode_transaction(inode);
1055 reiserfs_update_inode_transaction(parent_dir);
1057 inode->i_op = &reiserfs_symlink_inode_operations;
1058 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1060 // must be sure this inode is written with this transaction
1062 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1064 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1065 dentry->d_name.len, inode, 1 /*visible */ );
1069 reiserfs_update_sd(&th, inode);
1070 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1073 unlock_new_inode(inode);
1078 d_instantiate(dentry, inode);
1079 unlock_new_inode(inode);
1080 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1082 reiserfs_write_unlock(parent_dir->i_sb);
1086 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1087 struct dentry *dentry)
1090 struct inode *inode = old_dentry->d_inode;
1091 struct reiserfs_transaction_handle th;
1092 /* We need blocks for transaction + update of quotas for the owners of the directory */
1094 JOURNAL_PER_BALANCE_CNT * 3 +
1095 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1097 reiserfs_write_lock(dir->i_sb);
1098 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1099 //FIXME: sd_nlink is 32 bit for new files
1100 reiserfs_write_unlock(dir->i_sb);
1103 if (inode->i_nlink == 0) {
1104 reiserfs_write_unlock(dir->i_sb);
1108 /* inc before scheduling so reiserfs_unlink knows we are here */
1111 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1114 reiserfs_write_unlock(dir->i_sb);
1118 /* create new entry */
1120 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1121 dentry->d_name.len, inode, 1 /*visible */ );
1123 reiserfs_update_inode_transaction(inode);
1124 reiserfs_update_inode_transaction(dir);
1129 err = journal_end(&th, dir->i_sb, jbegin_count);
1130 reiserfs_write_unlock(dir->i_sb);
1131 return err ? err : retval;
1134 inode->i_ctime = CURRENT_TIME_SEC;
1135 reiserfs_update_sd(&th, inode);
1137 atomic_inc(&inode->i_count);
1138 d_instantiate(dentry, inode);
1139 retval = journal_end(&th, dir->i_sb, jbegin_count);
1140 reiserfs_write_unlock(dir->i_sb);
1144 // de contains information pointing to an entry which
1145 static int de_still_valid(const char *name, int len,
1146 struct reiserfs_dir_entry *de)
1148 struct reiserfs_dir_entry tmp = *de;
1150 // recalculate pointer to name and name length
1151 set_de_name_and_namelen(&tmp);
1152 // FIXME: could check more
1153 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1158 static int entry_points_to_object(const char *name, int len,
1159 struct reiserfs_dir_entry *de,
1160 struct inode *inode)
1162 if (!de_still_valid(name, len, de))
1166 if (!de_visible(de->de_deh + de->de_entry_num))
1167 reiserfs_panic(inode->i_sb, "vs-7042",
1168 "entry must be visible");
1169 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1172 /* this must be added hidden entry */
1173 if (de_visible(de->de_deh + de->de_entry_num))
1174 reiserfs_panic(NULL, "vs-7043", "entry must be visible");
1179 /* sets key of objectid the entry has to point to */
1180 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1181 struct reiserfs_key *key)
1183 /* JDM These operations are endian safe - both are le */
1184 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1185 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1189 * process, that is going to call fix_nodes/do_balance must hold only
1190 * one path. If it holds 2 or more, it can get into endless waiting in
1191 * get_empty_nodes or its clones
1193 static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1194 struct inode *new_dir, struct dentry *new_dentry)
1197 INITIALIZE_PATH(old_entry_path);
1198 INITIALIZE_PATH(new_entry_path);
1199 INITIALIZE_PATH(dot_dot_entry_path);
1200 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1201 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1202 struct inode *old_inode, *new_dentry_inode;
1203 struct reiserfs_transaction_handle th;
1205 umode_t old_inode_mode;
1206 unsigned long savelink = 1;
1207 struct timespec ctime;
1209 /* three balancings: (1) old name removal, (2) new name insertion
1210 and (3) maybe "save" link insertion
1211 stat data updates: (1) old directory,
1212 (2) new directory and (3) maybe old object stat data (when it is
1213 directory) and (4) maybe stat data of object to which new entry
1214 pointed initially and (5) maybe block containing ".." of
1216 quota updates: two parent directories */
1218 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1219 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1221 old_inode = old_dentry->d_inode;
1222 new_dentry_inode = new_dentry->d_inode;
1224 // make sure, that oldname still exists and points to an object we
1225 // are going to rename
1226 old_de.de_gen_number_bit_string = NULL;
1227 reiserfs_write_lock(old_dir->i_sb);
1229 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1230 old_dentry->d_name.len, &old_entry_path,
1232 pathrelse(&old_entry_path);
1233 if (retval == IO_ERROR) {
1234 reiserfs_write_unlock(old_dir->i_sb);
1238 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1239 reiserfs_write_unlock(old_dir->i_sb);
1243 old_inode_mode = old_inode->i_mode;
1244 if (S_ISDIR(old_inode_mode)) {
1245 // make sure, that directory being renamed has correct ".."
1246 // and that its new parent directory has not too many links
1249 if (new_dentry_inode) {
1250 if (!reiserfs_empty_dir(new_dentry_inode)) {
1251 reiserfs_write_unlock(old_dir->i_sb);
1256 /* directory is renamed, its parent directory will be changed,
1257 ** so find ".." entry
1259 dot_dot_de.de_gen_number_bit_string = NULL;
1261 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1263 pathrelse(&dot_dot_entry_path);
1264 if (retval != NAME_FOUND) {
1265 reiserfs_write_unlock(old_dir->i_sb);
1269 /* inode number of .. must equal old_dir->i_ino */
1270 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1271 reiserfs_write_unlock(old_dir->i_sb);
1276 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1278 reiserfs_write_unlock(old_dir->i_sb);
1282 /* add new entry (or find the existing one) */
1284 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1285 new_dentry->d_name.len, old_inode, 0);
1286 if (retval == -EEXIST) {
1287 if (!new_dentry_inode) {
1288 reiserfs_panic(old_dir->i_sb, "vs-7050",
1289 "new entry is found, new inode == 0");
1291 } else if (retval) {
1292 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1293 reiserfs_write_unlock(old_dir->i_sb);
1294 return err ? err : retval;
1297 reiserfs_update_inode_transaction(old_dir);
1298 reiserfs_update_inode_transaction(new_dir);
1300 /* this makes it so an fsync on an open fd for the old name will
1301 ** commit the rename operation
1303 reiserfs_update_inode_transaction(old_inode);
1305 if (new_dentry_inode)
1306 reiserfs_update_inode_transaction(new_dentry_inode);
1309 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1311 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1313 &old_de)) != NAME_FOUND) {
1314 pathrelse(&old_entry_path);
1315 journal_end(&th, old_dir->i_sb, jbegin_count);
1316 reiserfs_write_unlock(old_dir->i_sb);
1320 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
1322 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1324 // look for new name by reiserfs_find_entry
1325 new_de.de_gen_number_bit_string = NULL;
1327 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1328 new_dentry->d_name.len, &new_entry_path,
1330 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1331 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1332 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1333 pathrelse(&new_entry_path);
1334 pathrelse(&old_entry_path);
1335 journal_end(&th, old_dir->i_sb, jbegin_count);
1336 reiserfs_write_unlock(old_dir->i_sb);
1340 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1342 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1344 if (S_ISDIR(old_inode->i_mode)) {
1346 search_by_entry_key(new_dir->i_sb,
1347 &dot_dot_de.de_entry_key,
1348 &dot_dot_entry_path,
1349 &dot_dot_de)) != NAME_FOUND) {
1350 pathrelse(&dot_dot_entry_path);
1351 pathrelse(&new_entry_path);
1352 pathrelse(&old_entry_path);
1353 journal_end(&th, old_dir->i_sb, jbegin_count);
1354 reiserfs_write_unlock(old_dir->i_sb);
1357 copy_item_head(&dot_dot_ih,
1358 get_ih(&dot_dot_entry_path));
1359 // node containing ".." gets into transaction
1360 reiserfs_prepare_for_journal(old_inode->i_sb,
1361 dot_dot_de.de_bh, 1);
1363 /* we should check seals here, not do
1364 this stuff, yes? Then, having
1365 gathered everything into RAM we
1366 should lock the buffers, yes? -Hans */
1367 /* probably. our rename needs to hold more
1368 ** than one path at once. The seals would
1369 ** have to be written to deal with multi-path
1372 /* sanity checking before doing the rename - avoid races many
1373 ** of the above checks could have scheduled. We have to be
1374 ** sure our items haven't been shifted by another process.
1376 if (item_moved(&new_entry_ih, &new_entry_path) ||
1377 !entry_points_to_object(new_dentry->d_name.name,
1378 new_dentry->d_name.len,
1379 &new_de, new_dentry_inode) ||
1380 item_moved(&old_entry_ih, &old_entry_path) ||
1381 !entry_points_to_object(old_dentry->d_name.name,
1382 old_dentry->d_name.len,
1383 &old_de, old_inode)) {
1384 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1386 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1388 if (S_ISDIR(old_inode_mode))
1389 reiserfs_restore_prepared_buffer(old_inode->
1395 if (S_ISDIR(old_inode_mode)) {
1396 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1397 !entry_points_to_object("..", 2, &dot_dot_de,
1399 reiserfs_restore_prepared_buffer(old_inode->
1402 reiserfs_restore_prepared_buffer(old_inode->
1405 reiserfs_restore_prepared_buffer(old_inode->
1413 RFALSE(S_ISDIR(old_inode_mode) &&
1414 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1419 /* ok, all the changes can be done in one fell swoop when we
1420 have claimed all the buffers needed. */
1422 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1423 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1424 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1426 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1427 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1428 ctime = CURRENT_TIME_SEC;
1429 old_dir->i_ctime = old_dir->i_mtime = ctime;
1430 new_dir->i_ctime = new_dir->i_mtime = ctime;
1431 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1433 old_inode->i_ctime = ctime;
1435 if (new_dentry_inode) {
1436 // adjust link number of the victim
1437 if (S_ISDIR(new_dentry_inode->i_mode)) {
1438 clear_nlink(new_dentry_inode);
1440 drop_nlink(new_dentry_inode);
1442 new_dentry_inode->i_ctime = ctime;
1443 savelink = new_dentry_inode->i_nlink;
1446 if (S_ISDIR(old_inode_mode)) {
1447 // adjust ".." of renamed directory
1448 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1449 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1451 if (!new_dentry_inode)
1452 /* there (in new_dir) was no directory, so it got new link
1453 (".." of renamed directory) */
1454 INC_DIR_INODE_NLINK(new_dir);
1456 /* old directory lost one link - ".. " of renamed directory */
1457 DEC_DIR_INODE_NLINK(old_dir);
1459 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1460 pathrelse(&new_entry_path);
1461 pathrelse(&dot_dot_entry_path);
1463 // FIXME: this reiserfs_cut_from_item's return value may screw up
1464 // anybody, but it will panic if will not be able to find the
1465 // entry. This needs one more clean up
1466 if (reiserfs_cut_from_item
1467 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1469 reiserfs_error(old_dir->i_sb, "vs-7060",
1470 "couldn't not cut old name. Fsck later?");
1472 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1474 reiserfs_update_sd(&th, old_dir);
1475 reiserfs_update_sd(&th, new_dir);
1476 reiserfs_update_sd(&th, old_inode);
1478 if (new_dentry_inode) {
1480 add_save_link(&th, new_dentry_inode,
1481 0 /* not truncate */ );
1482 reiserfs_update_sd(&th, new_dentry_inode);
1485 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1486 reiserfs_write_unlock(old_dir->i_sb);
1491 * directories can handle most operations...
1493 const struct inode_operations reiserfs_dir_inode_operations = {
1494 //&reiserfs_dir_operations, /* default_file_ops */
1495 .create = reiserfs_create,
1496 .lookup = reiserfs_lookup,
1497 .link = reiserfs_link,
1498 .unlink = reiserfs_unlink,
1499 .symlink = reiserfs_symlink,
1500 .mkdir = reiserfs_mkdir,
1501 .rmdir = reiserfs_rmdir,
1502 .mknod = reiserfs_mknod,
1503 .rename = reiserfs_rename,
1504 .setattr = reiserfs_setattr,
1505 .setxattr = reiserfs_setxattr,
1506 .getxattr = reiserfs_getxattr,
1507 .listxattr = reiserfs_listxattr,
1508 .removexattr = reiserfs_removexattr,
1509 .permission = reiserfs_permission,
1513 * symlink operations.. same as page_symlink_inode_operations, with xattr
1516 const struct inode_operations reiserfs_symlink_inode_operations = {
1517 .readlink = generic_readlink,
1518 .follow_link = page_follow_link_light,
1519 .put_link = page_put_link,
1520 .setattr = reiserfs_setattr,
1521 .setxattr = reiserfs_setxattr,
1522 .getxattr = reiserfs_getxattr,
1523 .listxattr = reiserfs_listxattr,
1524 .removexattr = reiserfs_removexattr,
1525 .permission = reiserfs_permission,
1530 * special file operations.. just xattr/acl stuff
1532 const struct inode_operations reiserfs_special_inode_operations = {
1533 .setattr = reiserfs_setattr,
1534 .setxattr = reiserfs_setxattr,
1535 .getxattr = reiserfs_getxattr,
1536 .listxattr = reiserfs_listxattr,
1537 .removexattr = reiserfs_removexattr,
1538 .permission = reiserfs_permission,