Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
0003  *
0004  * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
0005  *
0006  * Trivial Changes:
0007  * Rights granted to Hans Reiser to redistribute under other terms providing
0008  * he accepts all liability including but not limited to patent, fitness
0009  * for purpose, and direct or indirect claims arising from failure to perform.
0010  *
0011  * NO WARRANTY
0012  */
0013 
0014 #include <linux/time.h>
0015 #include <linux/bitops.h>
0016 #include <linux/slab.h>
0017 #include "reiserfs.h"
0018 #include "acl.h"
0019 #include "xattr.h"
0020 #include <linux/quotaops.h>
0021 
0022 #define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) set_nlink(i, 1); }
0023 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
0024 
0025 /*
0026  * directory item contains array of entry headers. This performs
0027  * binary search through that array
0028  */
0029 static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
0030 {
0031     struct item_head *ih = de->de_ih;
0032     struct reiserfs_de_head *deh = de->de_deh;
0033     int rbound, lbound, j;
0034 
0035     lbound = 0;
0036     rbound = ih_entry_count(ih) - 1;
0037 
0038     for (j = (rbound + lbound) / 2; lbound <= rbound;
0039          j = (rbound + lbound) / 2) {
0040         if (off < deh_offset(deh + j)) {
0041             rbound = j - 1;
0042             continue;
0043         }
0044         if (off > deh_offset(deh + j)) {
0045             lbound = j + 1;
0046             continue;
0047         }
0048         /* this is not name found, but matched third key component */
0049         de->de_entry_num = j;
0050         return NAME_FOUND;
0051     }
0052 
0053     de->de_entry_num = lbound;
0054     return NAME_NOT_FOUND;
0055 }
0056 
0057 /*
0058  * comment?  maybe something like set de to point to what the path points to?
0059  */
0060 static inline void set_de_item_location(struct reiserfs_dir_entry *de,
0061                     struct treepath *path)
0062 {
0063     de->de_bh = get_last_bh(path);
0064     de->de_ih = tp_item_head(path);
0065     de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
0066     de->de_item_num = PATH_LAST_POSITION(path);
0067 }
0068 
0069 /*
0070  * de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
0071  */
0072 inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
0073 {
0074     struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
0075 
0076     BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
0077 
0078     de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
0079     de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
0080     de->de_name = ih_item_body(de->de_bh, de->de_ih) + deh_location(deh);
0081     if (de->de_name[de->de_namelen - 1] == 0)
0082         de->de_namelen = strlen(de->de_name);
0083 }
0084 
0085 /* what entry points to */
0086 static inline void set_de_object_key(struct reiserfs_dir_entry *de)
0087 {
0088     BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
0089     de->de_dir_id = deh_dir_id(&de->de_deh[de->de_entry_num]);
0090     de->de_objectid = deh_objectid(&de->de_deh[de->de_entry_num]);
0091 }
0092 
0093 static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
0094 {
0095     struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
0096 
0097     BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
0098 
0099     /* store key of the found entry */
0100     de->de_entry_key.version = KEY_FORMAT_3_5;
0101     de->de_entry_key.on_disk_key.k_dir_id =
0102         le32_to_cpu(de->de_ih->ih_key.k_dir_id);
0103     de->de_entry_key.on_disk_key.k_objectid =
0104         le32_to_cpu(de->de_ih->ih_key.k_objectid);
0105     set_cpu_key_k_offset(&de->de_entry_key, deh_offset(deh));
0106     set_cpu_key_k_type(&de->de_entry_key, TYPE_DIRENTRY);
0107 }
0108 
0109 /*
0110  * We assign a key to each directory item, and place multiple entries in a
0111  * single directory item.  A directory item has a key equal to the key of
0112  * the first directory entry in it.
0113 
0114  * This function first calls search_by_key, then, if item whose first entry
0115  * matches is not found it looks for the entry inside directory item found
0116  * by search_by_key. Fills the path to the entry, and to the entry position
0117  * in the item
0118  */
0119 /* The function is NOT SCHEDULE-SAFE! */
0120 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
0121             struct treepath *path, struct reiserfs_dir_entry *de)
0122 {
0123     int retval;
0124 
0125     retval = search_item(sb, key, path);
0126     switch (retval) {
0127     case ITEM_NOT_FOUND:
0128         if (!PATH_LAST_POSITION(path)) {
0129             reiserfs_error(sb, "vs-7000", "search_by_key "
0130                        "returned item position == 0");
0131             pathrelse(path);
0132             return IO_ERROR;
0133         }
0134         PATH_LAST_POSITION(path)--;
0135         break;
0136 
0137     case ITEM_FOUND:
0138         break;
0139 
0140     case IO_ERROR:
0141         return retval;
0142 
0143     default:
0144         pathrelse(path);
0145         reiserfs_error(sb, "vs-7002", "no path to here");
0146         return IO_ERROR;
0147     }
0148 
0149     set_de_item_location(de, path);
0150 
0151 #ifdef CONFIG_REISERFS_CHECK
0152     if (!is_direntry_le_ih(de->de_ih) ||
0153         COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) {
0154         print_block(de->de_bh, 0, -1, -1);
0155         reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
0156                    "item or does not belong to the same directory "
0157                    "as key %K", de->de_ih, key);
0158     }
0159 #endif              /* CONFIG_REISERFS_CHECK */
0160 
0161     /*
0162      * binary search in directory item by third component of the
0163      * key. sets de->de_entry_num of de
0164      */
0165     retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
0166     path->pos_in_item = de->de_entry_num;
0167     if (retval != NAME_NOT_FOUND) {
0168         /*
0169          * ugly, but rename needs de_bh, de_deh, de_name,
0170          * de_namelen, de_objectid set
0171          */
0172         set_de_name_and_namelen(de);
0173         set_de_object_key(de);
0174     }
0175     return retval;
0176 }
0177 
0178 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
0179 
0180 /*
0181  * The third component is hashed, and you can choose from more than
0182  * one hash function.  Per directory hashes are not yet implemented
0183  * but are thought about. This function should be moved to hashes.c
0184  * Jedi, please do so.  -Hans
0185  */
0186 static __u32 get_third_component(struct super_block *s,
0187                  const char *name, int len)
0188 {
0189     __u32 res;
0190 
0191     if (!len || (len == 1 && name[0] == '.'))
0192         return DOT_OFFSET;
0193     if (len == 2 && name[0] == '.' && name[1] == '.')
0194         return DOT_DOT_OFFSET;
0195 
0196     res = REISERFS_SB(s)->s_hash_function(name, len);
0197 
0198     /* take bits from 7-th to 30-th including both bounds */
0199     res = GET_HASH_VALUE(res);
0200     if (res == 0)
0201         /*
0202          * needed to have no names before "." and ".." those have hash
0203          * value == 0 and generation conters 1 and 2 accordingly
0204          */
0205         res = 128;
0206     return res + MAX_GENERATION_NUMBER;
0207 }
0208 
0209 static int reiserfs_match(struct reiserfs_dir_entry *de,
0210               const char *name, int namelen)
0211 {
0212     int retval = NAME_NOT_FOUND;
0213 
0214     if ((namelen == de->de_namelen) &&
0215         !memcmp(de->de_name, name, de->de_namelen))
0216         retval =
0217             (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
0218              NAME_FOUND_INVISIBLE);
0219 
0220     return retval;
0221 }
0222 
0223 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
0224 
0225 /* used when hash collisions exist */
0226 
0227 static int linear_search_in_dir_item(struct cpu_key *key,
0228                      struct reiserfs_dir_entry *de,
0229                      const char *name, int namelen)
0230 {
0231     struct reiserfs_de_head *deh = de->de_deh;
0232     int retval;
0233     int i;
0234 
0235     i = de->de_entry_num;
0236 
0237     if (i == ih_entry_count(de->de_ih) ||
0238         GET_HASH_VALUE(deh_offset(deh + i)) !=
0239         GET_HASH_VALUE(cpu_key_k_offset(key))) {
0240         i--;
0241     }
0242 
0243     RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
0244            "vs-7010: array of entry headers not found");
0245 
0246     deh += i;
0247 
0248     for (; i >= 0; i--, deh--) {
0249         /* hash value does not match, no need to check whole name */
0250         if (GET_HASH_VALUE(deh_offset(deh)) !=
0251             GET_HASH_VALUE(cpu_key_k_offset(key))) {
0252             return NAME_NOT_FOUND;
0253         }
0254 
0255         /* mark that this generation number is used */
0256         if (de->de_gen_number_bit_string)
0257             set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
0258                 de->de_gen_number_bit_string);
0259 
0260         /* calculate pointer to name and namelen */
0261         de->de_entry_num = i;
0262         set_de_name_and_namelen(de);
0263 
0264         /*
0265          * de's de_name, de_namelen, de_recordlen are set.
0266          * Fill the rest.
0267          */
0268         if ((retval =
0269              reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
0270 
0271             /* key of pointed object */
0272             set_de_object_key(de);
0273 
0274             store_de_entry_key(de);
0275 
0276             /* retval can be NAME_FOUND or NAME_FOUND_INVISIBLE */
0277             return retval;
0278         }
0279     }
0280 
0281     if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
0282         /*
0283          * we have reached left most entry in the node. In common we
0284          * have to go to the left neighbor, but if generation counter
0285          * is 0 already, we know for sure, that there is no name with
0286          * the same hash value
0287          */
0288         /*
0289          * FIXME: this work correctly only because hash value can not
0290          *  be 0. Btw, in case of Yura's hash it is probably possible,
0291          * so, this is a bug
0292          */
0293         return NAME_NOT_FOUND;
0294 
0295     RFALSE(de->de_item_num,
0296            "vs-7015: two diritems of the same directory in one node?");
0297 
0298     return GOTO_PREVIOUS_ITEM;
0299 }
0300 
0301 /*
0302  * may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
0303  * FIXME: should add something like IOERROR
0304  */
0305 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
0306                    struct treepath *path_to_entry,
0307                    struct reiserfs_dir_entry *de)
0308 {
0309     struct cpu_key key_to_search;
0310     int retval;
0311 
0312     if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
0313         return NAME_NOT_FOUND;
0314 
0315     /* we will search for this key in the tree */
0316     make_cpu_key(&key_to_search, dir,
0317              get_third_component(dir->i_sb, name, namelen),
0318              TYPE_DIRENTRY, 3);
0319 
0320     while (1) {
0321         retval =
0322             search_by_entry_key(dir->i_sb, &key_to_search,
0323                     path_to_entry, de);
0324         if (retval == IO_ERROR) {
0325             reiserfs_error(dir->i_sb, "zam-7001", "io error");
0326             return IO_ERROR;
0327         }
0328 
0329         /* compare names for all entries having given hash value */
0330         retval =
0331             linear_search_in_dir_item(&key_to_search, de, name,
0332                           namelen);
0333         /*
0334          * there is no need to scan directory anymore.
0335          * Given entry found or does not exist
0336          */
0337         if (retval != GOTO_PREVIOUS_ITEM) {
0338             path_to_entry->pos_in_item = de->de_entry_num;
0339             return retval;
0340         }
0341 
0342         /*
0343          * there is left neighboring item of this directory
0344          * and given entry can be there
0345          */
0346         set_cpu_key_k_offset(&key_to_search,
0347                      le_ih_k_offset(de->de_ih) - 1);
0348         pathrelse(path_to_entry);
0349 
0350     }           /* while (1) */
0351 }
0352 
0353 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
0354                       unsigned int flags)
0355 {
0356     int retval;
0357     struct inode *inode = NULL;
0358     struct reiserfs_dir_entry de;
0359     INITIALIZE_PATH(path_to_entry);
0360 
0361     if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
0362         return ERR_PTR(-ENAMETOOLONG);
0363 
0364     reiserfs_write_lock(dir->i_sb);
0365 
0366     de.de_gen_number_bit_string = NULL;
0367     retval =
0368         reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
0369                 &path_to_entry, &de);
0370     pathrelse(&path_to_entry);
0371     if (retval == NAME_FOUND) {
0372         inode = reiserfs_iget(dir->i_sb,
0373                       (struct cpu_key *)&de.de_dir_id);
0374         if (!inode || IS_ERR(inode)) {
0375             reiserfs_write_unlock(dir->i_sb);
0376             return ERR_PTR(-EACCES);
0377         }
0378 
0379         /*
0380          * Propagate the private flag so we know we're
0381          * in the priv tree.  Also clear IOP_XATTR
0382          * since we don't have xattrs on xattr files.
0383          */
0384         if (IS_PRIVATE(dir)) {
0385             inode->i_flags |= S_PRIVATE;
0386             inode->i_opflags &= ~IOP_XATTR;
0387         }
0388     }
0389     reiserfs_write_unlock(dir->i_sb);
0390     if (retval == IO_ERROR) {
0391         return ERR_PTR(-EIO);
0392     }
0393 
0394     return d_splice_alias(inode, dentry);
0395 }
0396 
0397 /*
0398  * looks up the dentry of the parent directory for child.
0399  * taken from ext2_get_parent
0400  */
0401 struct dentry *reiserfs_get_parent(struct dentry *child)
0402 {
0403     int retval;
0404     struct inode *inode = NULL;
0405     struct reiserfs_dir_entry de;
0406     INITIALIZE_PATH(path_to_entry);
0407     struct inode *dir = d_inode(child);
0408 
0409     if (dir->i_nlink == 0) {
0410         return ERR_PTR(-ENOENT);
0411     }
0412     de.de_gen_number_bit_string = NULL;
0413 
0414     reiserfs_write_lock(dir->i_sb);
0415     retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
0416     pathrelse(&path_to_entry);
0417     if (retval != NAME_FOUND) {
0418         reiserfs_write_unlock(dir->i_sb);
0419         return ERR_PTR(-ENOENT);
0420     }
0421     inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&de.de_dir_id);
0422     reiserfs_write_unlock(dir->i_sb);
0423 
0424     return d_obtain_alias(inode);
0425 }
0426 
0427 /* add entry to the directory (entry can be hidden).
0428 
0429 insert definition of when hidden directories are used here -Hans
0430 
0431  Does not mark dir   inode dirty, do it after successesfull call to it */
0432 
0433 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
0434                   struct inode *dir, const char *name, int namelen,
0435                   struct inode *inode, int visible)
0436 {
0437     struct cpu_key entry_key;
0438     struct reiserfs_de_head *deh;
0439     INITIALIZE_PATH(path);
0440     struct reiserfs_dir_entry de;
0441     DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
0442     int gen_number;
0443 
0444     /*
0445      * 48 bytes now and we avoid kmalloc if we
0446      * create file with short name
0447      */
0448     char small_buf[32 + DEH_SIZE];
0449 
0450     char *buffer;
0451     int buflen, paste_size;
0452     int retval;
0453 
0454     BUG_ON(!th->t_trans_id);
0455 
0456     /* cannot allow items to be added into a busy deleted directory */
0457     if (!namelen)
0458         return -EINVAL;
0459 
0460     if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
0461         return -ENAMETOOLONG;
0462 
0463     /* each entry has unique key. compose it */
0464     make_cpu_key(&entry_key, dir,
0465              get_third_component(dir->i_sb, name, namelen),
0466              TYPE_DIRENTRY, 3);
0467 
0468     /* get memory for composing the entry */
0469     buflen = DEH_SIZE + ROUND_UP(namelen);
0470     if (buflen > sizeof(small_buf)) {
0471         buffer = kmalloc(buflen, GFP_NOFS);
0472         if (!buffer)
0473             return -ENOMEM;
0474     } else
0475         buffer = small_buf;
0476 
0477     paste_size =
0478         (get_inode_sd_version(dir) ==
0479          STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
0480 
0481     /*
0482      * fill buffer : directory entry head, name[, dir objectid | ,
0483      * stat data | ,stat data, dir objectid ]
0484      */
0485     deh = (struct reiserfs_de_head *)buffer;
0486     deh->deh_location = 0;  /* JDM Endian safe if 0 */
0487     put_deh_offset(deh, cpu_key_k_offset(&entry_key));
0488     deh->deh_state = 0; /* JDM Endian safe if 0 */
0489     /* put key (ino analog) to de */
0490 
0491     /* safe: k_dir_id is le */
0492     deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id;
0493     /* safe: k_objectid is le */
0494     deh->deh_objectid = INODE_PKEY(inode)->k_objectid;
0495 
0496     /* copy name */
0497     memcpy((char *)(deh + 1), name, namelen);
0498     /* padd by 0s to the 4 byte boundary */
0499     padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
0500 
0501     /*
0502      * entry is ready to be pasted into tree, set 'visibility'
0503      * and 'stat data in entry' attributes
0504      */
0505     mark_de_without_sd(deh);
0506     visible ? mark_de_visible(deh) : mark_de_hidden(deh);
0507 
0508     /* find the proper place for the new entry */
0509     memset(bit_string, 0, sizeof(bit_string));
0510     de.de_gen_number_bit_string = bit_string;
0511     retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
0512     if (retval != NAME_NOT_FOUND) {
0513         if (buffer != small_buf)
0514             kfree(buffer);
0515         pathrelse(&path);
0516 
0517         if (retval == IO_ERROR) {
0518             return -EIO;
0519         }
0520 
0521         if (retval != NAME_FOUND) {
0522             reiserfs_error(dir->i_sb, "zam-7002",
0523                        "reiserfs_find_entry() returned "
0524                        "unexpected value (%d)", retval);
0525         }
0526 
0527         return -EEXIST;
0528     }
0529 
0530     gen_number =
0531         find_first_zero_bit(bit_string,
0532                 MAX_GENERATION_NUMBER + 1);
0533     if (gen_number > MAX_GENERATION_NUMBER) {
0534         /* there is no free generation number */
0535         reiserfs_warning(dir->i_sb, "reiserfs-7010",
0536                  "Congratulations! we have got hash function "
0537                  "screwed up");
0538         if (buffer != small_buf)
0539             kfree(buffer);
0540         pathrelse(&path);
0541         return -EBUSY;
0542     }
0543     /* adjust offset of directory enrty */
0544     put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
0545     set_cpu_key_k_offset(&entry_key, deh_offset(deh));
0546 
0547     /* update max-hash-collisions counter in reiserfs_sb_info */
0548     PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
0549 
0550     /* we need to re-search for the insertion point */
0551     if (gen_number != 0) {
0552         if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
0553             NAME_NOT_FOUND) {
0554             reiserfs_warning(dir->i_sb, "vs-7032",
0555                      "entry with this key (%K) already "
0556                      "exists", &entry_key);
0557 
0558             if (buffer != small_buf)
0559                 kfree(buffer);
0560             pathrelse(&path);
0561             return -EBUSY;
0562         }
0563     }
0564 
0565     /* perform the insertion of the entry that we have prepared */
0566     retval =
0567         reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
0568                      paste_size);
0569     if (buffer != small_buf)
0570         kfree(buffer);
0571     if (retval) {
0572         reiserfs_check_path(&path);
0573         return retval;
0574     }
0575 
0576     dir->i_size += paste_size;
0577     dir->i_mtime = dir->i_ctime = current_time(dir);
0578     if (!S_ISDIR(inode->i_mode) && visible)
0579         /* reiserfs_mkdir or reiserfs_rename will do that by itself */
0580         reiserfs_update_sd(th, dir);
0581 
0582     reiserfs_check_path(&path);
0583     return 0;
0584 }
0585 
0586 /*
0587  * quota utility function, call if you've had to abort after calling
0588  * new_inode_init, and have not called reiserfs_new_inode yet.
0589  * This should only be called on inodes that do not have stat data
0590  * inserted into the tree yet.
0591  */
0592 static int drop_new_inode(struct inode *inode)
0593 {
0594     dquot_drop(inode);
0595     make_bad_inode(inode);
0596     inode->i_flags |= S_NOQUOTA;
0597     iput(inode);
0598     return 0;
0599 }
0600 
0601 /*
0602  * utility function that does setup for reiserfs_new_inode.
0603  * dquot_initialize needs lots of credits so it's better to have it
0604  * outside of a transaction, so we had to pull some bits of
0605  * reiserfs_new_inode out into this func.
0606  */
0607 static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
0608 {
0609     /*
0610      * Make inode invalid - just in case we are going to drop it before
0611      * the initialization happens
0612      */
0613     INODE_PKEY(inode)->k_objectid = 0;
0614 
0615     /*
0616      * the quota init calls have to know who to charge the quota to, so
0617      * we have to set uid and gid here
0618      */
0619     inode_init_owner(&init_user_ns, inode, dir, mode);
0620     return dquot_initialize(inode);
0621 }
0622 
0623 static int reiserfs_create(struct user_namespace *mnt_userns, struct inode *dir,
0624                struct dentry *dentry, umode_t mode, bool excl)
0625 {
0626     int retval;
0627     struct inode *inode;
0628     /*
0629      * We need blocks for transaction + (user+group)*(quotas
0630      * for new inode + update of quota for directory owner)
0631      */
0632     int jbegin_count =
0633         JOURNAL_PER_BALANCE_CNT * 2 +
0634         2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
0635          REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
0636     struct reiserfs_transaction_handle th;
0637     struct reiserfs_security_handle security;
0638 
0639     retval = dquot_initialize(dir);
0640     if (retval)
0641         return retval;
0642 
0643     if (!(inode = new_inode(dir->i_sb))) {
0644         return -ENOMEM;
0645     }
0646     retval = new_inode_init(inode, dir, mode);
0647     if (retval) {
0648         drop_new_inode(inode);
0649         return retval;
0650     }
0651 
0652     jbegin_count += reiserfs_cache_default_acl(dir);
0653     retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
0654     if (retval < 0) {
0655         drop_new_inode(inode);
0656         return retval;
0657     }
0658     jbegin_count += retval;
0659     reiserfs_write_lock(dir->i_sb);
0660 
0661     retval = journal_begin(&th, dir->i_sb, jbegin_count);
0662     if (retval) {
0663         drop_new_inode(inode);
0664         goto out_failed;
0665     }
0666 
0667     retval =
0668         reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
0669                    inode, &security);
0670     if (retval)
0671         goto out_failed;
0672 
0673     inode->i_op = &reiserfs_file_inode_operations;
0674     inode->i_fop = &reiserfs_file_operations;
0675     inode->i_mapping->a_ops = &reiserfs_address_space_operations;
0676 
0677     retval =
0678         reiserfs_add_entry(&th, dir, dentry->d_name.name,
0679                    dentry->d_name.len, inode, 1 /*visible */ );
0680     if (retval) {
0681         int err;
0682         drop_nlink(inode);
0683         reiserfs_update_sd(&th, inode);
0684         err = journal_end(&th);
0685         if (err)
0686             retval = err;
0687         unlock_new_inode(inode);
0688         iput(inode);
0689         goto out_failed;
0690     }
0691     reiserfs_update_inode_transaction(inode);
0692     reiserfs_update_inode_transaction(dir);
0693 
0694     d_instantiate_new(dentry, inode);
0695     retval = journal_end(&th);
0696 
0697 out_failed:
0698     reiserfs_write_unlock(dir->i_sb);
0699     return retval;
0700 }
0701 
0702 static int reiserfs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
0703               struct dentry *dentry, umode_t mode, dev_t rdev)
0704 {
0705     int retval;
0706     struct inode *inode;
0707     struct reiserfs_transaction_handle th;
0708     struct reiserfs_security_handle security;
0709     /*
0710      * We need blocks for transaction + (user+group)*(quotas
0711      * for new inode + update of quota for directory owner)
0712      */
0713     int jbegin_count =
0714         JOURNAL_PER_BALANCE_CNT * 3 +
0715         2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
0716          REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
0717 
0718     retval = dquot_initialize(dir);
0719     if (retval)
0720         return retval;
0721 
0722     if (!(inode = new_inode(dir->i_sb))) {
0723         return -ENOMEM;
0724     }
0725     retval = new_inode_init(inode, dir, mode);
0726     if (retval) {
0727         drop_new_inode(inode);
0728         return retval;
0729     }
0730 
0731     jbegin_count += reiserfs_cache_default_acl(dir);
0732     retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
0733     if (retval < 0) {
0734         drop_new_inode(inode);
0735         return retval;
0736     }
0737     jbegin_count += retval;
0738     reiserfs_write_lock(dir->i_sb);
0739 
0740     retval = journal_begin(&th, dir->i_sb, jbegin_count);
0741     if (retval) {
0742         drop_new_inode(inode);
0743         goto out_failed;
0744     }
0745 
0746     retval =
0747         reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
0748                    inode, &security);
0749     if (retval) {
0750         goto out_failed;
0751     }
0752 
0753     inode->i_op = &reiserfs_special_inode_operations;
0754     init_special_inode(inode, inode->i_mode, rdev);
0755 
0756     /* FIXME: needed for block and char devices only */
0757     reiserfs_update_sd(&th, inode);
0758 
0759     reiserfs_update_inode_transaction(inode);
0760     reiserfs_update_inode_transaction(dir);
0761 
0762     retval =
0763         reiserfs_add_entry(&th, dir, dentry->d_name.name,
0764                    dentry->d_name.len, inode, 1 /*visible */ );
0765     if (retval) {
0766         int err;
0767         drop_nlink(inode);
0768         reiserfs_update_sd(&th, inode);
0769         err = journal_end(&th);
0770         if (err)
0771             retval = err;
0772         unlock_new_inode(inode);
0773         iput(inode);
0774         goto out_failed;
0775     }
0776 
0777     d_instantiate_new(dentry, inode);
0778     retval = journal_end(&th);
0779 
0780 out_failed:
0781     reiserfs_write_unlock(dir->i_sb);
0782     return retval;
0783 }
0784 
0785 static int reiserfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
0786               struct dentry *dentry, umode_t mode)
0787 {
0788     int retval;
0789     struct inode *inode;
0790     struct reiserfs_transaction_handle th;
0791     struct reiserfs_security_handle security;
0792     /*
0793      * We need blocks for transaction + (user+group)*(quotas
0794      * for new inode + update of quota for directory owner)
0795      */
0796     int jbegin_count =
0797         JOURNAL_PER_BALANCE_CNT * 3 +
0798         2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
0799          REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
0800 
0801     retval = dquot_initialize(dir);
0802     if (retval)
0803         return retval;
0804 
0805 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
0806     /*
0807      * set flag that new packing locality created and new blocks
0808      * for the content of that directory are not displaced yet
0809      */
0810     REISERFS_I(dir)->new_packing_locality = 1;
0811 #endif
0812     mode = S_IFDIR | mode;
0813     if (!(inode = new_inode(dir->i_sb))) {
0814         return -ENOMEM;
0815     }
0816     retval = new_inode_init(inode, dir, mode);
0817     if (retval) {
0818         drop_new_inode(inode);
0819         return retval;
0820     }
0821 
0822     jbegin_count += reiserfs_cache_default_acl(dir);
0823     retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
0824     if (retval < 0) {
0825         drop_new_inode(inode);
0826         return retval;
0827     }
0828     jbegin_count += retval;
0829     reiserfs_write_lock(dir->i_sb);
0830 
0831     retval = journal_begin(&th, dir->i_sb, jbegin_count);
0832     if (retval) {
0833         drop_new_inode(inode);
0834         goto out_failed;
0835     }
0836 
0837     /*
0838      * inc the link count now, so another writer doesn't overflow
0839      * it while we sleep later on.
0840      */
0841     INC_DIR_INODE_NLINK(dir)
0842 
0843     retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */,
0844                     old_format_only(dir->i_sb) ?
0845                     EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
0846                     dentry, inode, &security);
0847     if (retval) {
0848         DEC_DIR_INODE_NLINK(dir)
0849         goto out_failed;
0850     }
0851 
0852     reiserfs_update_inode_transaction(inode);
0853     reiserfs_update_inode_transaction(dir);
0854 
0855     inode->i_op = &reiserfs_dir_inode_operations;
0856     inode->i_fop = &reiserfs_dir_operations;
0857 
0858     /* note, _this_ add_entry will not update dir's stat data */
0859     retval =
0860         reiserfs_add_entry(&th, dir, dentry->d_name.name,
0861                    dentry->d_name.len, inode, 1 /*visible */ );
0862     if (retval) {
0863         int err;
0864         clear_nlink(inode);
0865         DEC_DIR_INODE_NLINK(dir);
0866         reiserfs_update_sd(&th, inode);
0867         err = journal_end(&th);
0868         if (err)
0869             retval = err;
0870         unlock_new_inode(inode);
0871         iput(inode);
0872         goto out_failed;
0873     }
0874     /* the above add_entry did not update dir's stat data */
0875     reiserfs_update_sd(&th, dir);
0876 
0877     d_instantiate_new(dentry, inode);
0878     retval = journal_end(&th);
0879 out_failed:
0880     reiserfs_write_unlock(dir->i_sb);
0881     return retval;
0882 }
0883 
0884 static inline int reiserfs_empty_dir(struct inode *inode)
0885 {
0886     /*
0887      * we can cheat because an old format dir cannot have
0888      * EMPTY_DIR_SIZE, and a new format dir cannot have
0889      * EMPTY_DIR_SIZE_V1.  So, if the inode is either size,
0890      * regardless of disk format version, the directory is empty.
0891      */
0892     if (inode->i_size != EMPTY_DIR_SIZE &&
0893         inode->i_size != EMPTY_DIR_SIZE_V1) {
0894         return 0;
0895     }
0896     return 1;
0897 }
0898 
0899 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
0900 {
0901     int retval, err;
0902     struct inode *inode;
0903     struct reiserfs_transaction_handle th;
0904     int jbegin_count;
0905     INITIALIZE_PATH(path);
0906     struct reiserfs_dir_entry de;
0907 
0908     /*
0909      * we will be doing 2 balancings and update 2 stat data, we
0910      * change quotas of the owner of the directory and of the owner
0911      * of the parent directory.  The quota structure is possibly
0912      * deleted only on last iput => outside of this transaction
0913      */
0914     jbegin_count =
0915         JOURNAL_PER_BALANCE_CNT * 2 + 2 +
0916         4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
0917 
0918     retval = dquot_initialize(dir);
0919     if (retval)
0920         return retval;
0921 
0922     reiserfs_write_lock(dir->i_sb);
0923     retval = journal_begin(&th, dir->i_sb, jbegin_count);
0924     if (retval)
0925         goto out_rmdir;
0926 
0927     de.de_gen_number_bit_string = NULL;
0928     if ((retval =
0929          reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
0930                  &path, &de)) == NAME_NOT_FOUND) {
0931         retval = -ENOENT;
0932         goto end_rmdir;
0933     } else if (retval == IO_ERROR) {
0934         retval = -EIO;
0935         goto end_rmdir;
0936     }
0937 
0938     inode = d_inode(dentry);
0939 
0940     reiserfs_update_inode_transaction(inode);
0941     reiserfs_update_inode_transaction(dir);
0942 
0943     if (de.de_objectid != inode->i_ino) {
0944         /*
0945          * FIXME: compare key of an object and a key found in the entry
0946          */
0947         retval = -EIO;
0948         goto end_rmdir;
0949     }
0950     if (!reiserfs_empty_dir(inode)) {
0951         retval = -ENOTEMPTY;
0952         goto end_rmdir;
0953     }
0954 
0955     /* cut entry from dir directory */
0956     retval = reiserfs_cut_from_item(&th, &path, &de.de_entry_key,
0957                     dir, NULL,  /* page */
0958                     0 /*new file size - not used here */ );
0959     if (retval < 0)
0960         goto end_rmdir;
0961 
0962     if (inode->i_nlink != 2 && inode->i_nlink != 1)
0963         reiserfs_error(inode->i_sb, "reiserfs-7040",
0964                    "empty directory has nlink != 2 (%d)",
0965                    inode->i_nlink);
0966 
0967     clear_nlink(inode);
0968     inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(dir);
0969     reiserfs_update_sd(&th, inode);
0970 
0971     DEC_DIR_INODE_NLINK(dir)
0972     dir->i_size -= (DEH_SIZE + de.de_entrylen);
0973     reiserfs_update_sd(&th, dir);
0974 
0975     /* prevent empty directory from getting lost */
0976     add_save_link(&th, inode, 0 /* not truncate */ );
0977 
0978     retval = journal_end(&th);
0979     reiserfs_check_path(&path);
0980 out_rmdir:
0981     reiserfs_write_unlock(dir->i_sb);
0982     return retval;
0983 
0984 end_rmdir:
0985     /*
0986      * we must release path, because we did not call
0987      * reiserfs_cut_from_item, or reiserfs_cut_from_item does not
0988      * release path if operation was not complete
0989      */
0990     pathrelse(&path);
0991     err = journal_end(&th);
0992     reiserfs_write_unlock(dir->i_sb);
0993     return err ? err : retval;
0994 }
0995 
0996 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
0997 {
0998     int retval, err;
0999     struct inode *inode;
1000     struct reiserfs_dir_entry de;
1001     INITIALIZE_PATH(path);
1002     struct reiserfs_transaction_handle th;
1003     int jbegin_count;
1004     unsigned long savelink;
1005 
1006     retval = dquot_initialize(dir);
1007     if (retval)
1008         return retval;
1009 
1010     inode = d_inode(dentry);
1011 
1012     /*
1013      * in this transaction we can be doing at max two balancings and
1014      * update two stat datas, we change quotas of the owner of the
1015      * directory and of the owner of the parent directory. The quota
1016      * structure is possibly deleted only on iput => outside of
1017      * this transaction
1018      */
1019     jbegin_count =
1020         JOURNAL_PER_BALANCE_CNT * 2 + 2 +
1021         4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1022 
1023     reiserfs_write_lock(dir->i_sb);
1024     retval = journal_begin(&th, dir->i_sb, jbegin_count);
1025     if (retval)
1026         goto out_unlink;
1027 
1028     de.de_gen_number_bit_string = NULL;
1029     if ((retval =
1030          reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
1031                  &path, &de)) == NAME_NOT_FOUND) {
1032         retval = -ENOENT;
1033         goto end_unlink;
1034     } else if (retval == IO_ERROR) {
1035         retval = -EIO;
1036         goto end_unlink;
1037     }
1038 
1039     reiserfs_update_inode_transaction(inode);
1040     reiserfs_update_inode_transaction(dir);
1041 
1042     if (de.de_objectid != inode->i_ino) {
1043         /*
1044          * FIXME: compare key of an object and a key found in the entry
1045          */
1046         retval = -EIO;
1047         goto end_unlink;
1048     }
1049 
1050     if (!inode->i_nlink) {
1051         reiserfs_warning(inode->i_sb, "reiserfs-7042",
1052                  "deleting nonexistent file (%lu), %d",
1053                  inode->i_ino, inode->i_nlink);
1054         set_nlink(inode, 1);
1055     }
1056 
1057     drop_nlink(inode);
1058 
1059     /*
1060      * we schedule before doing the add_save_link call, save the link
1061      * count so we don't race
1062      */
1063     savelink = inode->i_nlink;
1064 
1065     retval =
1066         reiserfs_cut_from_item(&th, &path, &de.de_entry_key, dir, NULL,
1067                    0);
1068     if (retval < 0) {
1069         inc_nlink(inode);
1070         goto end_unlink;
1071     }
1072     inode->i_ctime = current_time(inode);
1073     reiserfs_update_sd(&th, inode);
1074 
1075     dir->i_size -= (de.de_entrylen + DEH_SIZE);
1076     dir->i_ctime = dir->i_mtime = current_time(dir);
1077     reiserfs_update_sd(&th, dir);
1078 
1079     if (!savelink)
1080         /* prevent file from getting lost */
1081         add_save_link(&th, inode, 0 /* not truncate */ );
1082 
1083     retval = journal_end(&th);
1084     reiserfs_check_path(&path);
1085     reiserfs_write_unlock(dir->i_sb);
1086     return retval;
1087 
1088 end_unlink:
1089     pathrelse(&path);
1090     err = journal_end(&th);
1091     reiserfs_check_path(&path);
1092     if (err)
1093         retval = err;
1094 out_unlink:
1095     reiserfs_write_unlock(dir->i_sb);
1096     return retval;
1097 }
1098 
1099 static int reiserfs_symlink(struct user_namespace *mnt_userns,
1100                 struct inode *parent_dir, struct dentry *dentry,
1101                 const char *symname)
1102 {
1103     int retval;
1104     struct inode *inode;
1105     char *name;
1106     int item_len;
1107     struct reiserfs_transaction_handle th;
1108     struct reiserfs_security_handle security;
1109     int mode = S_IFLNK | S_IRWXUGO;
1110     /*
1111      * We need blocks for transaction + (user+group)*(quotas for
1112      * new inode + update of quota for directory owner)
1113      */
1114     int jbegin_count =
1115         JOURNAL_PER_BALANCE_CNT * 3 +
1116         2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1117          REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1118 
1119     retval = dquot_initialize(parent_dir);
1120     if (retval)
1121         return retval;
1122 
1123     if (!(inode = new_inode(parent_dir->i_sb))) {
1124         return -ENOMEM;
1125     }
1126     retval = new_inode_init(inode, parent_dir, mode);
1127     if (retval) {
1128         drop_new_inode(inode);
1129         return retval;
1130     }
1131 
1132     retval = reiserfs_security_init(parent_dir, inode, &dentry->d_name,
1133                     &security);
1134     if (retval < 0) {
1135         drop_new_inode(inode);
1136         return retval;
1137     }
1138     jbegin_count += retval;
1139 
1140     reiserfs_write_lock(parent_dir->i_sb);
1141     item_len = ROUND_UP(strlen(symname));
1142     if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1143         retval = -ENAMETOOLONG;
1144         drop_new_inode(inode);
1145         goto out_failed;
1146     }
1147 
1148     name = kmalloc(item_len, GFP_NOFS);
1149     if (!name) {
1150         drop_new_inode(inode);
1151         retval = -ENOMEM;
1152         goto out_failed;
1153     }
1154     memcpy(name, symname, strlen(symname));
1155     padd_item(name, item_len, strlen(symname));
1156 
1157     retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1158     if (retval) {
1159         drop_new_inode(inode);
1160         kfree(name);
1161         goto out_failed;
1162     }
1163 
1164     retval =
1165         reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1166                    dentry, inode, &security);
1167     kfree(name);
1168     if (retval) {       /* reiserfs_new_inode iputs for us */
1169         goto out_failed;
1170     }
1171 
1172     reiserfs_update_inode_transaction(inode);
1173     reiserfs_update_inode_transaction(parent_dir);
1174 
1175     inode->i_op = &reiserfs_symlink_inode_operations;
1176     inode_nohighmem(inode);
1177     inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1178 
1179     retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1180                     dentry->d_name.len, inode, 1 /*visible */ );
1181     if (retval) {
1182         int err;
1183         drop_nlink(inode);
1184         reiserfs_update_sd(&th, inode);
1185         err = journal_end(&th);
1186         if (err)
1187             retval = err;
1188         unlock_new_inode(inode);
1189         iput(inode);
1190         goto out_failed;
1191     }
1192 
1193     d_instantiate_new(dentry, inode);
1194     retval = journal_end(&th);
1195 out_failed:
1196     reiserfs_write_unlock(parent_dir->i_sb);
1197     return retval;
1198 }
1199 
1200 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1201              struct dentry *dentry)
1202 {
1203     int retval;
1204     struct inode *inode = d_inode(old_dentry);
1205     struct reiserfs_transaction_handle th;
1206     /*
1207      * We need blocks for transaction + update of quotas for
1208      * the owners of the directory
1209      */
1210     int jbegin_count =
1211         JOURNAL_PER_BALANCE_CNT * 3 +
1212         2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1213 
1214     retval = dquot_initialize(dir);
1215     if (retval)
1216         return retval;
1217 
1218     reiserfs_write_lock(dir->i_sb);
1219     if (inode->i_nlink >= REISERFS_LINK_MAX) {
1220         /* FIXME: sd_nlink is 32 bit for new files */
1221         reiserfs_write_unlock(dir->i_sb);
1222         return -EMLINK;
1223     }
1224 
1225     /* inc before scheduling so reiserfs_unlink knows we are here */
1226     inc_nlink(inode);
1227 
1228     retval = journal_begin(&th, dir->i_sb, jbegin_count);
1229     if (retval) {
1230         drop_nlink(inode);
1231         reiserfs_write_unlock(dir->i_sb);
1232         return retval;
1233     }
1234 
1235     /* create new entry */
1236     retval =
1237         reiserfs_add_entry(&th, dir, dentry->d_name.name,
1238                    dentry->d_name.len, inode, 1 /*visible */ );
1239 
1240     reiserfs_update_inode_transaction(inode);
1241     reiserfs_update_inode_transaction(dir);
1242 
1243     if (retval) {
1244         int err;
1245         drop_nlink(inode);
1246         err = journal_end(&th);
1247         reiserfs_write_unlock(dir->i_sb);
1248         return err ? err : retval;
1249     }
1250 
1251     inode->i_ctime = current_time(inode);
1252     reiserfs_update_sd(&th, inode);
1253 
1254     ihold(inode);
1255     d_instantiate(dentry, inode);
1256     retval = journal_end(&th);
1257     reiserfs_write_unlock(dir->i_sb);
1258     return retval;
1259 }
1260 
1261 /* de contains information pointing to an entry which */
1262 static int de_still_valid(const char *name, int len,
1263               struct reiserfs_dir_entry *de)
1264 {
1265     struct reiserfs_dir_entry tmp = *de;
1266 
1267     /* recalculate pointer to name and name length */
1268     set_de_name_and_namelen(&tmp);
1269     /* FIXME: could check more */
1270     if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1271         return 0;
1272     return 1;
1273 }
1274 
1275 static int entry_points_to_object(const char *name, int len,
1276                   struct reiserfs_dir_entry *de,
1277                   struct inode *inode)
1278 {
1279     if (!de_still_valid(name, len, de))
1280         return 0;
1281 
1282     if (inode) {
1283         if (!de_visible(de->de_deh + de->de_entry_num))
1284             reiserfs_panic(inode->i_sb, "vs-7042",
1285                        "entry must be visible");
1286         return (de->de_objectid == inode->i_ino) ? 1 : 0;
1287     }
1288 
1289     /* this must be added hidden entry */
1290     if (de_visible(de->de_deh + de->de_entry_num))
1291         reiserfs_panic(NULL, "vs-7043", "entry must be visible");
1292 
1293     return 1;
1294 }
1295 
1296 /* sets key of objectid the entry has to point to */
1297 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1298                  struct reiserfs_key *key)
1299 {
1300     /* JDM These operations are endian safe - both are le */
1301     de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1302     de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1303 }
1304 
1305 /*
1306  * process, that is going to call fix_nodes/do_balance must hold only
1307  * one path. If it holds 2 or more, it can get into endless waiting in
1308  * get_empty_nodes or its clones
1309  */
1310 static int reiserfs_rename(struct user_namespace *mnt_userns,
1311                struct inode *old_dir, struct dentry *old_dentry,
1312                struct inode *new_dir, struct dentry *new_dentry,
1313                unsigned int flags)
1314 {
1315     int retval;
1316     INITIALIZE_PATH(old_entry_path);
1317     INITIALIZE_PATH(new_entry_path);
1318     INITIALIZE_PATH(dot_dot_entry_path);
1319     struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1320     struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1321     struct inode *old_inode, *new_dentry_inode;
1322     struct reiserfs_transaction_handle th;
1323     int jbegin_count;
1324     umode_t old_inode_mode;
1325     unsigned long savelink = 1;
1326     struct timespec64 ctime;
1327 
1328     if (flags & ~RENAME_NOREPLACE)
1329         return -EINVAL;
1330 
1331     /*
1332      * three balancings: (1) old name removal, (2) new name insertion
1333      * and (3) maybe "save" link insertion
1334      * stat data updates: (1) old directory,
1335      * (2) new directory and (3) maybe old object stat data (when it is
1336      * directory) and (4) maybe stat data of object to which new entry
1337      * pointed initially and (5) maybe block containing ".." of
1338      * renamed directory
1339      * quota updates: two parent directories
1340      */
1341     jbegin_count =
1342         JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1343         4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1344 
1345     retval = dquot_initialize(old_dir);
1346     if (retval)
1347         return retval;
1348     retval = dquot_initialize(new_dir);
1349     if (retval)
1350         return retval;
1351 
1352     old_inode = d_inode(old_dentry);
1353     new_dentry_inode = d_inode(new_dentry);
1354 
1355     /*
1356      * make sure that oldname still exists and points to an object we
1357      * are going to rename
1358      */
1359     old_de.de_gen_number_bit_string = NULL;
1360     reiserfs_write_lock(old_dir->i_sb);
1361     retval =
1362         reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1363                 old_dentry->d_name.len, &old_entry_path,
1364                 &old_de);
1365     pathrelse(&old_entry_path);
1366     if (retval == IO_ERROR) {
1367         reiserfs_write_unlock(old_dir->i_sb);
1368         return -EIO;
1369     }
1370 
1371     if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1372         reiserfs_write_unlock(old_dir->i_sb);
1373         return -ENOENT;
1374     }
1375 
1376     old_inode_mode = old_inode->i_mode;
1377     if (S_ISDIR(old_inode_mode)) {
1378         /*
1379          * make sure that directory being renamed has correct ".."
1380          * and that its new parent directory has not too many links
1381          * already
1382          */
1383         if (new_dentry_inode) {
1384             if (!reiserfs_empty_dir(new_dentry_inode)) {
1385                 reiserfs_write_unlock(old_dir->i_sb);
1386                 return -ENOTEMPTY;
1387             }
1388         }
1389 
1390         /*
1391          * directory is renamed, its parent directory will be changed,
1392          * so find ".." entry
1393          */
1394         dot_dot_de.de_gen_number_bit_string = NULL;
1395         retval =
1396             reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1397                     &dot_dot_de);
1398         pathrelse(&dot_dot_entry_path);
1399         if (retval != NAME_FOUND) {
1400             reiserfs_write_unlock(old_dir->i_sb);
1401             return -EIO;
1402         }
1403 
1404         /* inode number of .. must equal old_dir->i_ino */
1405         if (dot_dot_de.de_objectid != old_dir->i_ino) {
1406             reiserfs_write_unlock(old_dir->i_sb);
1407             return -EIO;
1408         }
1409     }
1410 
1411     retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1412     if (retval) {
1413         reiserfs_write_unlock(old_dir->i_sb);
1414         return retval;
1415     }
1416 
1417     /* add new entry (or find the existing one) */
1418     retval =
1419         reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1420                    new_dentry->d_name.len, old_inode, 0);
1421     if (retval == -EEXIST) {
1422         if (!new_dentry_inode) {
1423             reiserfs_panic(old_dir->i_sb, "vs-7050",
1424                        "new entry is found, new inode == 0");
1425         }
1426     } else if (retval) {
1427         int err = journal_end(&th);
1428         reiserfs_write_unlock(old_dir->i_sb);
1429         return err ? err : retval;
1430     }
1431 
1432     reiserfs_update_inode_transaction(old_dir);
1433     reiserfs_update_inode_transaction(new_dir);
1434 
1435     /*
1436      * this makes it so an fsync on an open fd for the old name will
1437      * commit the rename operation
1438      */
1439     reiserfs_update_inode_transaction(old_inode);
1440 
1441     if (new_dentry_inode)
1442         reiserfs_update_inode_transaction(new_dentry_inode);
1443 
1444     while (1) {
1445         /*
1446          * look for old name using corresponding entry key
1447          * (found by reiserfs_find_entry)
1448          */
1449         if ((retval =
1450              search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1451                      &old_entry_path,
1452                      &old_de)) != NAME_FOUND) {
1453             pathrelse(&old_entry_path);
1454             journal_end(&th);
1455             reiserfs_write_unlock(old_dir->i_sb);
1456             return -EIO;
1457         }
1458 
1459         copy_item_head(&old_entry_ih, tp_item_head(&old_entry_path));
1460 
1461         reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1462 
1463         /* look for new name by reiserfs_find_entry */
1464         new_de.de_gen_number_bit_string = NULL;
1465         retval =
1466             reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1467                     new_dentry->d_name.len, &new_entry_path,
1468                     &new_de);
1469         /*
1470          * reiserfs_add_entry should not return IO_ERROR,
1471          * because it is called with essentially same parameters from
1472          * reiserfs_add_entry above, and we'll catch any i/o errors
1473          * before we get here.
1474          */
1475         if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1476             pathrelse(&new_entry_path);
1477             pathrelse(&old_entry_path);
1478             journal_end(&th);
1479             reiserfs_write_unlock(old_dir->i_sb);
1480             return -EIO;
1481         }
1482 
1483         copy_item_head(&new_entry_ih, tp_item_head(&new_entry_path));
1484 
1485         reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1486 
1487         if (S_ISDIR(old_inode->i_mode)) {
1488             if ((retval =
1489                  search_by_entry_key(new_dir->i_sb,
1490                          &dot_dot_de.de_entry_key,
1491                          &dot_dot_entry_path,
1492                          &dot_dot_de)) != NAME_FOUND) {
1493                 pathrelse(&dot_dot_entry_path);
1494                 pathrelse(&new_entry_path);
1495                 pathrelse(&old_entry_path);
1496                 journal_end(&th);
1497                 reiserfs_write_unlock(old_dir->i_sb);
1498                 return -EIO;
1499             }
1500             copy_item_head(&dot_dot_ih,
1501                        tp_item_head(&dot_dot_entry_path));
1502             /* node containing ".." gets into transaction */
1503             reiserfs_prepare_for_journal(old_inode->i_sb,
1504                              dot_dot_de.de_bh, 1);
1505         }
1506         /*
1507          * we should check seals here, not do
1508          * this stuff, yes? Then, having
1509          * gathered everything into RAM we
1510          * should lock the buffers, yes?  -Hans
1511          */
1512         /*
1513          * probably.  our rename needs to hold more
1514          * than one path at once.  The seals would
1515          * have to be written to deal with multi-path
1516          * issues -chris
1517          */
1518         /*
1519          * sanity checking before doing the rename - avoid races many
1520          * of the above checks could have scheduled.  We have to be
1521          * sure our items haven't been shifted by another process.
1522          */
1523         if (item_moved(&new_entry_ih, &new_entry_path) ||
1524             !entry_points_to_object(new_dentry->d_name.name,
1525                         new_dentry->d_name.len,
1526                         &new_de, new_dentry_inode) ||
1527             item_moved(&old_entry_ih, &old_entry_path) ||
1528             !entry_points_to_object(old_dentry->d_name.name,
1529                         old_dentry->d_name.len,
1530                         &old_de, old_inode)) {
1531             reiserfs_restore_prepared_buffer(old_inode->i_sb,
1532                              new_de.de_bh);
1533             reiserfs_restore_prepared_buffer(old_inode->i_sb,
1534                              old_de.de_bh);
1535             if (S_ISDIR(old_inode_mode))
1536                 reiserfs_restore_prepared_buffer(old_inode->
1537                                  i_sb,
1538                                  dot_dot_de.
1539                                  de_bh);
1540             continue;
1541         }
1542         if (S_ISDIR(old_inode_mode)) {
1543             if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1544                 !entry_points_to_object("..", 2, &dot_dot_de,
1545                             old_dir)) {
1546                 reiserfs_restore_prepared_buffer(old_inode->
1547                                  i_sb,
1548                                  old_de.de_bh);
1549                 reiserfs_restore_prepared_buffer(old_inode->
1550                                  i_sb,
1551                                  new_de.de_bh);
1552                 reiserfs_restore_prepared_buffer(old_inode->
1553                                  i_sb,
1554                                  dot_dot_de.
1555                                  de_bh);
1556                 continue;
1557             }
1558         }
1559 
1560         RFALSE(S_ISDIR(old_inode_mode) &&
1561                !buffer_journal_prepared(dot_dot_de.de_bh), "");
1562 
1563         break;
1564     }
1565 
1566     /*
1567      * ok, all the changes can be done in one fell swoop when we
1568      * have claimed all the buffers needed.
1569      */
1570 
1571     mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1572     set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1573     journal_mark_dirty(&th, new_de.de_bh);
1574 
1575     mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1576     journal_mark_dirty(&th, old_de.de_bh);
1577     ctime = current_time(old_dir);
1578     old_dir->i_ctime = old_dir->i_mtime = ctime;
1579     new_dir->i_ctime = new_dir->i_mtime = ctime;
1580     /*
1581      * thanks to Alex Adriaanse <alex_a@caltech.edu> for patch
1582      * which adds ctime update of renamed object
1583      */
1584     old_inode->i_ctime = ctime;
1585 
1586     if (new_dentry_inode) {
1587         /* adjust link number of the victim */
1588         if (S_ISDIR(new_dentry_inode->i_mode)) {
1589             clear_nlink(new_dentry_inode);
1590         } else {
1591             drop_nlink(new_dentry_inode);
1592         }
1593         new_dentry_inode->i_ctime = ctime;
1594         savelink = new_dentry_inode->i_nlink;
1595     }
1596 
1597     if (S_ISDIR(old_inode_mode)) {
1598         /* adjust ".." of renamed directory */
1599         set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1600         journal_mark_dirty(&th, dot_dot_de.de_bh);
1601 
1602         /*
1603          * there (in new_dir) was no directory, so it got new link
1604          * (".."  of renamed directory)
1605          */
1606         if (!new_dentry_inode)
1607             INC_DIR_INODE_NLINK(new_dir);
1608 
1609         /* old directory lost one link - ".. " of renamed directory */
1610         DEC_DIR_INODE_NLINK(old_dir);
1611     }
1612     /*
1613      * looks like in 2.3.99pre3 brelse is atomic.
1614      * so we can use pathrelse
1615      */
1616     pathrelse(&new_entry_path);
1617     pathrelse(&dot_dot_entry_path);
1618 
1619     /*
1620      * FIXME: this reiserfs_cut_from_item's return value may screw up
1621      * anybody, but it will panic if will not be able to find the
1622      * entry. This needs one more clean up
1623      */
1624     if (reiserfs_cut_from_item
1625         (&th, &old_entry_path, &old_de.de_entry_key, old_dir, NULL,
1626          0) < 0)
1627         reiserfs_error(old_dir->i_sb, "vs-7060",
1628                    "couldn't not cut old name. Fsck later?");
1629 
1630     old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1631 
1632     reiserfs_update_sd(&th, old_dir);
1633     reiserfs_update_sd(&th, new_dir);
1634     reiserfs_update_sd(&th, old_inode);
1635 
1636     if (new_dentry_inode) {
1637         if (savelink == 0)
1638             add_save_link(&th, new_dentry_inode,
1639                       0 /* not truncate */ );
1640         reiserfs_update_sd(&th, new_dentry_inode);
1641     }
1642 
1643     retval = journal_end(&th);
1644     reiserfs_write_unlock(old_dir->i_sb);
1645     return retval;
1646 }
1647 
1648 /* directories can handle most operations...  */
1649 const struct inode_operations reiserfs_dir_inode_operations = {
1650     .create = reiserfs_create,
1651     .lookup = reiserfs_lookup,
1652     .link = reiserfs_link,
1653     .unlink = reiserfs_unlink,
1654     .symlink = reiserfs_symlink,
1655     .mkdir = reiserfs_mkdir,
1656     .rmdir = reiserfs_rmdir,
1657     .mknod = reiserfs_mknod,
1658     .rename = reiserfs_rename,
1659     .setattr = reiserfs_setattr,
1660     .listxattr = reiserfs_listxattr,
1661     .permission = reiserfs_permission,
1662     .get_acl = reiserfs_get_acl,
1663     .set_acl = reiserfs_set_acl,
1664     .fileattr_get = reiserfs_fileattr_get,
1665     .fileattr_set = reiserfs_fileattr_set,
1666 };
1667 
1668 /*
1669  * symlink operations.. same as page_symlink_inode_operations, with xattr
1670  * stuff added
1671  */
1672 const struct inode_operations reiserfs_symlink_inode_operations = {
1673     .get_link   = page_get_link,
1674     .setattr = reiserfs_setattr,
1675     .listxattr = reiserfs_listxattr,
1676     .permission = reiserfs_permission,
1677 };
1678 
1679 /*
1680  * special file operations.. just xattr/acl stuff
1681  */
1682 const struct inode_operations reiserfs_special_inode_operations = {
1683     .setattr = reiserfs_setattr,
1684     .listxattr = reiserfs_listxattr,
1685     .permission = reiserfs_permission,
1686     .get_acl = reiserfs_get_acl,
1687     .set_acl = reiserfs_set_acl,
1688 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!