Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
0004  */
0005 
0006 #include <linux/iversion.h>
0007 #include <linux/namei.h>
0008 #include <linux/slab.h>
0009 #include <linux/buffer_head.h>
0010 #include <linux/nls.h>
0011 
0012 #include "exfat_raw.h"
0013 #include "exfat_fs.h"
0014 
0015 static inline unsigned long exfat_d_version(struct dentry *dentry)
0016 {
0017     return (unsigned long) dentry->d_fsdata;
0018 }
0019 
0020 static inline void exfat_d_version_set(struct dentry *dentry,
0021         unsigned long version)
0022 {
0023     dentry->d_fsdata = (void *) version;
0024 }
0025 
0026 /*
0027  * If new entry was created in the parent, it could create the 8.3 alias (the
0028  * shortname of logname).  So, the parent may have the negative-dentry which
0029  * matches the created 8.3 alias.
0030  *
0031  * If it happened, the negative dentry isn't actually negative anymore.  So,
0032  * drop it.
0033  */
0034 static int exfat_d_revalidate(struct dentry *dentry, unsigned int flags)
0035 {
0036     int ret;
0037 
0038     if (flags & LOOKUP_RCU)
0039         return -ECHILD;
0040 
0041     /*
0042      * This is not negative dentry. Always valid.
0043      *
0044      * Note, rename() to existing directory entry will have ->d_inode, and
0045      * will use existing name which isn't specified name by user.
0046      *
0047      * We may be able to drop this positive dentry here. But dropping
0048      * positive dentry isn't good idea. So it's unsupported like
0049      * rename("filename", "FILENAME") for now.
0050      */
0051     if (d_really_is_positive(dentry))
0052         return 1;
0053 
0054     /*
0055      * Drop the negative dentry, in order to make sure to use the case
0056      * sensitive name which is specified by user if this is for creation.
0057      */
0058     if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
0059         return 0;
0060 
0061     spin_lock(&dentry->d_lock);
0062     ret = inode_eq_iversion(d_inode(dentry->d_parent),
0063             exfat_d_version(dentry));
0064     spin_unlock(&dentry->d_lock);
0065     return ret;
0066 }
0067 
0068 /* returns the length of a struct qstr, ignoring trailing dots if necessary */
0069 static unsigned int exfat_striptail_len(unsigned int len, const char *name,
0070                     bool keep_last_dots)
0071 {
0072     if (!keep_last_dots) {
0073         while (len && name[len - 1] == '.')
0074             len--;
0075     }
0076     return len;
0077 }
0078 
0079 /*
0080  * Compute the hash for the exfat name corresponding to the dentry.  If the name
0081  * is invalid, we leave the hash code unchanged so that the existing dentry can
0082  * be used. The exfat fs routines will return ENOENT or EINVAL as appropriate.
0083  */
0084 static int exfat_d_hash(const struct dentry *dentry, struct qstr *qstr)
0085 {
0086     struct super_block *sb = dentry->d_sb;
0087     struct nls_table *t = EXFAT_SB(sb)->nls_io;
0088     const unsigned char *name = qstr->name;
0089     unsigned int len = exfat_striptail_len(qstr->len, qstr->name,
0090                EXFAT_SB(sb)->options.keep_last_dots);
0091     unsigned long hash = init_name_hash(dentry);
0092     int i, charlen;
0093     wchar_t c;
0094 
0095     for (i = 0; i < len; i += charlen) {
0096         charlen = t->char2uni(&name[i], len - i, &c);
0097         if (charlen < 0)
0098             return charlen;
0099         hash = partial_name_hash(exfat_toupper(sb, c), hash);
0100     }
0101 
0102     qstr->hash = end_name_hash(hash);
0103     return 0;
0104 }
0105 
0106 static int exfat_d_cmp(const struct dentry *dentry, unsigned int len,
0107         const char *str, const struct qstr *name)
0108 {
0109     struct super_block *sb = dentry->d_sb;
0110     struct nls_table *t = EXFAT_SB(sb)->nls_io;
0111     unsigned int alen = exfat_striptail_len(name->len, name->name,
0112                 EXFAT_SB(sb)->options.keep_last_dots);
0113     unsigned int blen = exfat_striptail_len(len, str,
0114                 EXFAT_SB(sb)->options.keep_last_dots);
0115     wchar_t c1, c2;
0116     int charlen, i;
0117 
0118     if (alen != blen)
0119         return 1;
0120 
0121     for (i = 0; i < len; i += charlen) {
0122         charlen = t->char2uni(&name->name[i], alen - i, &c1);
0123         if (charlen < 0)
0124             return 1;
0125         if (charlen != t->char2uni(&str[i], blen - i, &c2))
0126             return 1;
0127 
0128         if (exfat_toupper(sb, c1) != exfat_toupper(sb, c2))
0129             return 1;
0130     }
0131 
0132     return 0;
0133 }
0134 
0135 const struct dentry_operations exfat_dentry_ops = {
0136     .d_revalidate   = exfat_d_revalidate,
0137     .d_hash     = exfat_d_hash,
0138     .d_compare  = exfat_d_cmp,
0139 };
0140 
0141 static int exfat_utf8_d_hash(const struct dentry *dentry, struct qstr *qstr)
0142 {
0143     struct super_block *sb = dentry->d_sb;
0144     const unsigned char *name = qstr->name;
0145     unsigned int len = exfat_striptail_len(qstr->len, qstr->name,
0146                    EXFAT_SB(sb)->options.keep_last_dots);
0147     unsigned long hash = init_name_hash(dentry);
0148     int i, charlen;
0149     unicode_t u;
0150 
0151     for (i = 0; i < len; i += charlen) {
0152         charlen = utf8_to_utf32(&name[i], len - i, &u);
0153         if (charlen < 0)
0154             return charlen;
0155 
0156         /*
0157          * exfat_toupper() works only for code points up to the U+FFFF.
0158          */
0159         hash = partial_name_hash(u <= 0xFFFF ? exfat_toupper(sb, u) : u,
0160                      hash);
0161     }
0162 
0163     qstr->hash = end_name_hash(hash);
0164     return 0;
0165 }
0166 
0167 static int exfat_utf8_d_cmp(const struct dentry *dentry, unsigned int len,
0168         const char *str, const struct qstr *name)
0169 {
0170     struct super_block *sb = dentry->d_sb;
0171     unsigned int alen = exfat_striptail_len(name->len, name->name,
0172                 EXFAT_SB(sb)->options.keep_last_dots);
0173     unsigned int blen = exfat_striptail_len(len, str,
0174                 EXFAT_SB(sb)->options.keep_last_dots);
0175 
0176     unicode_t u_a, u_b;
0177     int charlen, i;
0178 
0179     if (alen != blen)
0180         return 1;
0181 
0182     for (i = 0; i < alen; i += charlen) {
0183         charlen = utf8_to_utf32(&name->name[i], alen - i, &u_a);
0184         if (charlen < 0)
0185             return 1;
0186         if (charlen != utf8_to_utf32(&str[i], blen - i, &u_b))
0187             return 1;
0188 
0189         if (u_a <= 0xFFFF && u_b <= 0xFFFF) {
0190             if (exfat_toupper(sb, u_a) != exfat_toupper(sb, u_b))
0191                 return 1;
0192         } else {
0193             if (u_a != u_b)
0194                 return 1;
0195         }
0196     }
0197 
0198     return 0;
0199 }
0200 
0201 const struct dentry_operations exfat_utf8_dentry_ops = {
0202     .d_revalidate   = exfat_d_revalidate,
0203     .d_hash     = exfat_utf8_d_hash,
0204     .d_compare  = exfat_utf8_d_cmp,
0205 };
0206 
0207 /* used only in search empty_slot() */
0208 #define CNT_UNUSED_NOHIT        (-1)
0209 #define CNT_UNUSED_HIT          (-2)
0210 /* search EMPTY CONTINUOUS "num_entries" entries */
0211 static int exfat_search_empty_slot(struct super_block *sb,
0212         struct exfat_hint_femp *hint_femp, struct exfat_chain *p_dir,
0213         int num_entries)
0214 {
0215     int i, dentry, num_empty = 0;
0216     int dentries_per_clu;
0217     unsigned int type;
0218     struct exfat_chain clu;
0219     struct exfat_dentry *ep;
0220     struct exfat_sb_info *sbi = EXFAT_SB(sb);
0221     struct buffer_head *bh;
0222 
0223     dentries_per_clu = sbi->dentries_per_clu;
0224 
0225     if (hint_femp->eidx != EXFAT_HINT_NONE) {
0226         dentry = hint_femp->eidx;
0227         if (num_entries <= hint_femp->count) {
0228             hint_femp->eidx = EXFAT_HINT_NONE;
0229             return dentry;
0230         }
0231 
0232         exfat_chain_dup(&clu, &hint_femp->cur);
0233     } else {
0234         exfat_chain_dup(&clu, p_dir);
0235         dentry = 0;
0236     }
0237 
0238     while (clu.dir != EXFAT_EOF_CLUSTER) {
0239         i = dentry & (dentries_per_clu - 1);
0240 
0241         for (; i < dentries_per_clu; i++, dentry++) {
0242             ep = exfat_get_dentry(sb, &clu, i, &bh);
0243             if (!ep)
0244                 return -EIO;
0245             type = exfat_get_entry_type(ep);
0246             brelse(bh);
0247 
0248             if (type == TYPE_UNUSED || type == TYPE_DELETED) {
0249                 num_empty++;
0250                 if (hint_femp->eidx == EXFAT_HINT_NONE) {
0251                     hint_femp->eidx = dentry;
0252                     hint_femp->count = CNT_UNUSED_NOHIT;
0253                     exfat_chain_set(&hint_femp->cur,
0254                         clu.dir, clu.size, clu.flags);
0255                 }
0256 
0257                 if (type == TYPE_UNUSED &&
0258                     hint_femp->count != CNT_UNUSED_HIT)
0259                     hint_femp->count = CNT_UNUSED_HIT;
0260             } else {
0261                 if (hint_femp->eidx != EXFAT_HINT_NONE &&
0262                     hint_femp->count == CNT_UNUSED_HIT) {
0263                     /* unused empty group means
0264                      * an empty group which includes
0265                      * unused dentry
0266                      */
0267                     exfat_fs_error(sb,
0268                         "found bogus dentry(%d) beyond unused empty group(%d) (start_clu : %u, cur_clu : %u)",
0269                         dentry, hint_femp->eidx,
0270                         p_dir->dir, clu.dir);
0271                     return -EIO;
0272                 }
0273 
0274                 num_empty = 0;
0275                 hint_femp->eidx = EXFAT_HINT_NONE;
0276             }
0277 
0278             if (num_empty >= num_entries) {
0279                 /* found and invalidate hint_femp */
0280                 hint_femp->eidx = EXFAT_HINT_NONE;
0281                 return (dentry - (num_entries - 1));
0282             }
0283         }
0284 
0285         if (clu.flags == ALLOC_NO_FAT_CHAIN) {
0286             if (--clu.size > 0)
0287                 clu.dir++;
0288             else
0289                 clu.dir = EXFAT_EOF_CLUSTER;
0290         } else {
0291             if (exfat_get_next_cluster(sb, &clu.dir))
0292                 return -EIO;
0293         }
0294     }
0295 
0296     return -ENOSPC;
0297 }
0298 
0299 static int exfat_check_max_dentries(struct inode *inode)
0300 {
0301     if (EXFAT_B_TO_DEN(i_size_read(inode)) >= MAX_EXFAT_DENTRIES) {
0302         /*
0303          * exFAT spec allows a dir to grow up to 8388608(256MB)
0304          * dentries
0305          */
0306         return -ENOSPC;
0307     }
0308     return 0;
0309 }
0310 
0311 /* find empty directory entry.
0312  * if there isn't any empty slot, expand cluster chain.
0313  */
0314 static int exfat_find_empty_entry(struct inode *inode,
0315         struct exfat_chain *p_dir, int num_entries)
0316 {
0317     int dentry;
0318     unsigned int ret, last_clu;
0319     loff_t size = 0;
0320     struct exfat_chain clu;
0321     struct super_block *sb = inode->i_sb;
0322     struct exfat_sb_info *sbi = EXFAT_SB(sb);
0323     struct exfat_inode_info *ei = EXFAT_I(inode);
0324     struct exfat_hint_femp hint_femp;
0325 
0326     hint_femp.eidx = EXFAT_HINT_NONE;
0327 
0328     if (ei->hint_femp.eidx != EXFAT_HINT_NONE) {
0329         hint_femp = ei->hint_femp;
0330         ei->hint_femp.eidx = EXFAT_HINT_NONE;
0331     }
0332 
0333     while ((dentry = exfat_search_empty_slot(sb, &hint_femp, p_dir,
0334                     num_entries)) < 0) {
0335         if (dentry == -EIO)
0336             break;
0337 
0338         if (exfat_check_max_dentries(inode))
0339             return -ENOSPC;
0340 
0341         /* we trust p_dir->size regardless of FAT type */
0342         if (exfat_find_last_cluster(sb, p_dir, &last_clu))
0343             return -EIO;
0344 
0345         /*
0346          * Allocate new cluster to this directory
0347          */
0348         exfat_chain_set(&clu, last_clu + 1, 0, p_dir->flags);
0349 
0350         /* allocate a cluster */
0351         ret = exfat_alloc_cluster(inode, 1, &clu, IS_DIRSYNC(inode));
0352         if (ret)
0353             return ret;
0354 
0355         if (exfat_zeroed_cluster(inode, clu.dir))
0356             return -EIO;
0357 
0358         /* append to the FAT chain */
0359         if (clu.flags != p_dir->flags) {
0360             /* no-fat-chain bit is disabled,
0361              * so fat-chain should be synced with alloc-bitmap
0362              */
0363             exfat_chain_cont_cluster(sb, p_dir->dir, p_dir->size);
0364             p_dir->flags = ALLOC_FAT_CHAIN;
0365             hint_femp.cur.flags = ALLOC_FAT_CHAIN;
0366         }
0367 
0368         if (clu.flags == ALLOC_FAT_CHAIN)
0369             if (exfat_ent_set(sb, last_clu, clu.dir))
0370                 return -EIO;
0371 
0372         if (hint_femp.eidx == EXFAT_HINT_NONE) {
0373             /* the special case that new dentry
0374              * should be allocated from the start of new cluster
0375              */
0376             hint_femp.eidx = EXFAT_B_TO_DEN_IDX(p_dir->size, sbi);
0377             hint_femp.count = sbi->dentries_per_clu;
0378 
0379             exfat_chain_set(&hint_femp.cur, clu.dir, 0, clu.flags);
0380         }
0381         hint_femp.cur.size++;
0382         p_dir->size++;
0383         size = EXFAT_CLU_TO_B(p_dir->size, sbi);
0384 
0385         /* directory inode should be updated in here */
0386         i_size_write(inode, size);
0387         ei->i_size_ondisk += sbi->cluster_size;
0388         ei->i_size_aligned += sbi->cluster_size;
0389         ei->flags = p_dir->flags;
0390         inode->i_blocks += 1 << sbi->sect_per_clus_bits;
0391     }
0392 
0393     return dentry;
0394 }
0395 
0396 /*
0397  * Name Resolution Functions :
0398  * Zero if it was successful; otherwise nonzero.
0399  */
0400 static int __exfat_resolve_path(struct inode *inode, const unsigned char *path,
0401         struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname,
0402         int lookup)
0403 {
0404     int namelen;
0405     int lossy = NLS_NAME_NO_LOSSY;
0406     struct super_block *sb = inode->i_sb;
0407     struct exfat_sb_info *sbi = EXFAT_SB(sb);
0408     struct exfat_inode_info *ei = EXFAT_I(inode);
0409     int pathlen = strlen(path);
0410 
0411     /*
0412      * get the length of the pathname excluding
0413      * trailing periods, if any.
0414      */
0415     namelen = exfat_striptail_len(pathlen, path, false);
0416     if (EXFAT_SB(sb)->options.keep_last_dots) {
0417         /*
0418          * Do not allow the creation of files with names
0419          * ending with period(s).
0420          */
0421         if (!lookup && (namelen < pathlen))
0422             return -EINVAL;
0423         namelen = pathlen;
0424     }
0425     if (!namelen)
0426         return -ENOENT;
0427     if (pathlen > (MAX_NAME_LENGTH * MAX_CHARSET_SIZE))
0428         return -ENAMETOOLONG;
0429 
0430     /*
0431      * strip all leading spaces :
0432      * "MS windows 7" supports leading spaces.
0433      * So we should skip this preprocessing for compatibility.
0434      */
0435 
0436     /* file name conversion :
0437      * If lookup case, we allow bad-name for compatibility.
0438      */
0439     namelen = exfat_nls_to_utf16(sb, path, namelen, p_uniname,
0440             &lossy);
0441     if (namelen < 0)
0442         return namelen; /* return error value */
0443 
0444     if ((lossy && !lookup) || !namelen)
0445         return (lossy & NLS_NAME_OVERLEN) ? -ENAMETOOLONG : -EINVAL;
0446 
0447     exfat_chain_set(p_dir, ei->start_clu,
0448         EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags);
0449 
0450     return 0;
0451 }
0452 
0453 static inline int exfat_resolve_path(struct inode *inode,
0454         const unsigned char *path, struct exfat_chain *dir,
0455         struct exfat_uni_name *uni)
0456 {
0457     return __exfat_resolve_path(inode, path, dir, uni, 0);
0458 }
0459 
0460 static inline int exfat_resolve_path_for_lookup(struct inode *inode,
0461         const unsigned char *path, struct exfat_chain *dir,
0462         struct exfat_uni_name *uni)
0463 {
0464     return __exfat_resolve_path(inode, path, dir, uni, 1);
0465 }
0466 
0467 static inline loff_t exfat_make_i_pos(struct exfat_dir_entry *info)
0468 {
0469     return ((loff_t) info->dir.dir << 32) | (info->entry & 0xffffffff);
0470 }
0471 
0472 static int exfat_add_entry(struct inode *inode, const char *path,
0473         struct exfat_chain *p_dir, unsigned int type,
0474         struct exfat_dir_entry *info)
0475 {
0476     int ret, dentry, num_entries;
0477     struct super_block *sb = inode->i_sb;
0478     struct exfat_sb_info *sbi = EXFAT_SB(sb);
0479     struct exfat_uni_name uniname;
0480     struct exfat_chain clu;
0481     int clu_size = 0;
0482     unsigned int start_clu = EXFAT_FREE_CLUSTER;
0483 
0484     ret = exfat_resolve_path(inode, path, p_dir, &uniname);
0485     if (ret)
0486         goto out;
0487 
0488     num_entries = exfat_calc_num_entries(&uniname);
0489     if (num_entries < 0) {
0490         ret = num_entries;
0491         goto out;
0492     }
0493 
0494     /* exfat_find_empty_entry must be called before alloc_cluster() */
0495     dentry = exfat_find_empty_entry(inode, p_dir, num_entries);
0496     if (dentry < 0) {
0497         ret = dentry; /* -EIO or -ENOSPC */
0498         goto out;
0499     }
0500 
0501     if (type == TYPE_DIR) {
0502         ret = exfat_alloc_new_dir(inode, &clu);
0503         if (ret)
0504             goto out;
0505         start_clu = clu.dir;
0506         clu_size = sbi->cluster_size;
0507     }
0508 
0509     /* update the directory entry */
0510     /* fill the dos name directory entry information of the created file.
0511      * the first cluster is not determined yet. (0)
0512      */
0513     ret = exfat_init_dir_entry(inode, p_dir, dentry, type,
0514         start_clu, clu_size);
0515     if (ret)
0516         goto out;
0517 
0518     ret = exfat_init_ext_entry(inode, p_dir, dentry, num_entries, &uniname);
0519     if (ret)
0520         goto out;
0521 
0522     info->dir = *p_dir;
0523     info->entry = dentry;
0524     info->flags = ALLOC_NO_FAT_CHAIN;
0525     info->type = type;
0526 
0527     if (type == TYPE_FILE) {
0528         info->attr = ATTR_ARCHIVE;
0529         info->start_clu = EXFAT_EOF_CLUSTER;
0530         info->size = 0;
0531         info->num_subdirs = 0;
0532     } else {
0533         info->attr = ATTR_SUBDIR;
0534         info->start_clu = start_clu;
0535         info->size = clu_size;
0536         info->num_subdirs = EXFAT_MIN_SUBDIR;
0537     }
0538     memset(&info->crtime, 0, sizeof(info->crtime));
0539     memset(&info->mtime, 0, sizeof(info->mtime));
0540     memset(&info->atime, 0, sizeof(info->atime));
0541 out:
0542     return ret;
0543 }
0544 
0545 static int exfat_create(struct user_namespace *mnt_userns, struct inode *dir,
0546             struct dentry *dentry, umode_t mode, bool excl)
0547 {
0548     struct super_block *sb = dir->i_sb;
0549     struct inode *inode;
0550     struct exfat_chain cdir;
0551     struct exfat_dir_entry info;
0552     loff_t i_pos;
0553     int err;
0554 
0555     mutex_lock(&EXFAT_SB(sb)->s_lock);
0556     exfat_set_volume_dirty(sb);
0557     err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_FILE,
0558         &info);
0559     if (err)
0560         goto unlock;
0561 
0562     inode_inc_iversion(dir);
0563     dir->i_ctime = dir->i_mtime = current_time(dir);
0564     if (IS_DIRSYNC(dir))
0565         exfat_sync_inode(dir);
0566     else
0567         mark_inode_dirty(dir);
0568 
0569     i_pos = exfat_make_i_pos(&info);
0570     inode = exfat_build_inode(sb, &info, i_pos);
0571     err = PTR_ERR_OR_ZERO(inode);
0572     if (err)
0573         goto unlock;
0574 
0575     inode_inc_iversion(inode);
0576     inode->i_mtime = inode->i_atime = inode->i_ctime =
0577         EXFAT_I(inode)->i_crtime = current_time(inode);
0578     exfat_truncate_atime(&inode->i_atime);
0579     /* timestamp is already written, so mark_inode_dirty() is unneeded. */
0580 
0581     d_instantiate(dentry, inode);
0582 unlock:
0583     mutex_unlock(&EXFAT_SB(sb)->s_lock);
0584     return err;
0585 }
0586 
0587 /* lookup a file */
0588 static int exfat_find(struct inode *dir, struct qstr *qname,
0589         struct exfat_dir_entry *info)
0590 {
0591     int ret, dentry, num_entries, count;
0592     struct exfat_chain cdir;
0593     struct exfat_uni_name uni_name;
0594     struct super_block *sb = dir->i_sb;
0595     struct exfat_sb_info *sbi = EXFAT_SB(sb);
0596     struct exfat_inode_info *ei = EXFAT_I(dir);
0597     struct exfat_dentry *ep, *ep2;
0598     struct exfat_entry_set_cache *es;
0599     /* for optimized dir & entry to prevent long traverse of cluster chain */
0600     struct exfat_hint hint_opt;
0601 
0602     if (qname->len == 0)
0603         return -ENOENT;
0604 
0605     /* check the validity of directory name in the given pathname */
0606     ret = exfat_resolve_path_for_lookup(dir, qname->name, &cdir, &uni_name);
0607     if (ret)
0608         return ret;
0609 
0610     num_entries = exfat_calc_num_entries(&uni_name);
0611     if (num_entries < 0)
0612         return num_entries;
0613 
0614     /* check the validation of hint_stat and initialize it if required */
0615     if (ei->version != (inode_peek_iversion_raw(dir) & 0xffffffff)) {
0616         ei->hint_stat.clu = cdir.dir;
0617         ei->hint_stat.eidx = 0;
0618         ei->version = (inode_peek_iversion_raw(dir) & 0xffffffff);
0619         ei->hint_femp.eidx = EXFAT_HINT_NONE;
0620     }
0621 
0622     /* search the file name for directories */
0623     dentry = exfat_find_dir_entry(sb, ei, &cdir, &uni_name,
0624             num_entries, TYPE_ALL, &hint_opt);
0625 
0626     if (dentry < 0)
0627         return dentry; /* -error value */
0628 
0629     info->dir = cdir;
0630     info->entry = dentry;
0631     info->num_subdirs = 0;
0632 
0633     /* adjust cdir to the optimized value */
0634     cdir.dir = hint_opt.clu;
0635     if (cdir.flags & ALLOC_NO_FAT_CHAIN)
0636         cdir.size -= dentry / sbi->dentries_per_clu;
0637     dentry = hint_opt.eidx;
0638     es = exfat_get_dentry_set(sb, &cdir, dentry, ES_2_ENTRIES);
0639     if (!es)
0640         return -EIO;
0641     ep = exfat_get_dentry_cached(es, 0);
0642     ep2 = exfat_get_dentry_cached(es, 1);
0643 
0644     info->type = exfat_get_entry_type(ep);
0645     info->attr = le16_to_cpu(ep->dentry.file.attr);
0646     info->size = le64_to_cpu(ep2->dentry.stream.valid_size);
0647     if ((info->type == TYPE_FILE) && (info->size == 0)) {
0648         info->flags = ALLOC_NO_FAT_CHAIN;
0649         info->start_clu = EXFAT_EOF_CLUSTER;
0650     } else {
0651         info->flags = ep2->dentry.stream.flags;
0652         info->start_clu =
0653             le32_to_cpu(ep2->dentry.stream.start_clu);
0654     }
0655 
0656     exfat_get_entry_time(sbi, &info->crtime,
0657                  ep->dentry.file.create_tz,
0658                  ep->dentry.file.create_time,
0659                  ep->dentry.file.create_date,
0660                  ep->dentry.file.create_time_cs);
0661     exfat_get_entry_time(sbi, &info->mtime,
0662                  ep->dentry.file.modify_tz,
0663                  ep->dentry.file.modify_time,
0664                  ep->dentry.file.modify_date,
0665                  ep->dentry.file.modify_time_cs);
0666     exfat_get_entry_time(sbi, &info->atime,
0667                  ep->dentry.file.access_tz,
0668                  ep->dentry.file.access_time,
0669                  ep->dentry.file.access_date,
0670                  0);
0671     exfat_free_dentry_set(es, false);
0672 
0673     if (ei->start_clu == EXFAT_FREE_CLUSTER) {
0674         exfat_fs_error(sb,
0675                    "non-zero size file starts with zero cluster (size : %llu, p_dir : %u, entry : 0x%08x)",
0676                    i_size_read(dir), ei->dir.dir, ei->entry);
0677         return -EIO;
0678     }
0679 
0680     if (info->type == TYPE_DIR) {
0681         exfat_chain_set(&cdir, info->start_clu,
0682                 EXFAT_B_TO_CLU(info->size, sbi), info->flags);
0683         count = exfat_count_dir_entries(sb, &cdir);
0684         if (count < 0)
0685             return -EIO;
0686 
0687         info->num_subdirs = count + EXFAT_MIN_SUBDIR;
0688     }
0689     return 0;
0690 }
0691 
0692 static int exfat_d_anon_disconn(struct dentry *dentry)
0693 {
0694     return IS_ROOT(dentry) && (dentry->d_flags & DCACHE_DISCONNECTED);
0695 }
0696 
0697 static struct dentry *exfat_lookup(struct inode *dir, struct dentry *dentry,
0698         unsigned int flags)
0699 {
0700     struct super_block *sb = dir->i_sb;
0701     struct inode *inode;
0702     struct dentry *alias;
0703     struct exfat_dir_entry info;
0704     int err;
0705     loff_t i_pos;
0706     mode_t i_mode;
0707 
0708     mutex_lock(&EXFAT_SB(sb)->s_lock);
0709     err = exfat_find(dir, &dentry->d_name, &info);
0710     if (err) {
0711         if (err == -ENOENT) {
0712             inode = NULL;
0713             goto out;
0714         }
0715         goto unlock;
0716     }
0717 
0718     i_pos = exfat_make_i_pos(&info);
0719     inode = exfat_build_inode(sb, &info, i_pos);
0720     err = PTR_ERR_OR_ZERO(inode);
0721     if (err)
0722         goto unlock;
0723 
0724     i_mode = inode->i_mode;
0725     alias = d_find_alias(inode);
0726 
0727     /*
0728      * Checking "alias->d_parent == dentry->d_parent" to make sure
0729      * FS is not corrupted (especially double linked dir).
0730      */
0731     if (alias && alias->d_parent == dentry->d_parent &&
0732             !exfat_d_anon_disconn(alias)) {
0733 
0734         /*
0735          * Unhashed alias is able to exist because of revalidate()
0736          * called by lookup_fast. You can easily make this status
0737          * by calling create and lookup concurrently
0738          * In such case, we reuse an alias instead of new dentry
0739          */
0740         if (d_unhashed(alias)) {
0741             WARN_ON(alias->d_name.hash_len !=
0742                 dentry->d_name.hash_len);
0743             exfat_info(sb, "rehashed a dentry(%p) in read lookup",
0744                    alias);
0745             d_drop(dentry);
0746             d_rehash(alias);
0747         } else if (!S_ISDIR(i_mode)) {
0748             /*
0749              * This inode has non anonymous-DCACHE_DISCONNECTED
0750              * dentry. This means, the user did ->lookup() by an
0751              * another name (longname vs 8.3 alias of it) in past.
0752              *
0753              * Switch to new one for reason of locality if possible.
0754              */
0755             d_move(alias, dentry);
0756         }
0757         iput(inode);
0758         mutex_unlock(&EXFAT_SB(sb)->s_lock);
0759         return alias;
0760     }
0761     dput(alias);
0762 out:
0763     mutex_unlock(&EXFAT_SB(sb)->s_lock);
0764     if (!inode)
0765         exfat_d_version_set(dentry, inode_query_iversion(dir));
0766 
0767     return d_splice_alias(inode, dentry);
0768 unlock:
0769     mutex_unlock(&EXFAT_SB(sb)->s_lock);
0770     return ERR_PTR(err);
0771 }
0772 
0773 /* remove an entry, BUT don't truncate */
0774 static int exfat_unlink(struct inode *dir, struct dentry *dentry)
0775 {
0776     struct exfat_chain cdir;
0777     struct exfat_dentry *ep;
0778     struct super_block *sb = dir->i_sb;
0779     struct inode *inode = dentry->d_inode;
0780     struct exfat_inode_info *ei = EXFAT_I(inode);
0781     struct buffer_head *bh;
0782     int num_entries, entry, err = 0;
0783 
0784     mutex_lock(&EXFAT_SB(sb)->s_lock);
0785     exfat_chain_dup(&cdir, &ei->dir);
0786     entry = ei->entry;
0787     if (ei->dir.dir == DIR_DELETED) {
0788         exfat_err(sb, "abnormal access to deleted dentry");
0789         err = -ENOENT;
0790         goto unlock;
0791     }
0792 
0793     ep = exfat_get_dentry(sb, &cdir, entry, &bh);
0794     if (!ep) {
0795         err = -EIO;
0796         goto unlock;
0797     }
0798     num_entries = exfat_count_ext_entries(sb, &cdir, entry, ep);
0799     if (num_entries < 0) {
0800         err = -EIO;
0801         brelse(bh);
0802         goto unlock;
0803     }
0804     num_entries++;
0805     brelse(bh);
0806 
0807     exfat_set_volume_dirty(sb);
0808     /* update the directory entry */
0809     if (exfat_remove_entries(dir, &cdir, entry, 0, num_entries)) {
0810         err = -EIO;
0811         goto unlock;
0812     }
0813 
0814     /* This doesn't modify ei */
0815     ei->dir.dir = DIR_DELETED;
0816 
0817     inode_inc_iversion(dir);
0818     dir->i_mtime = dir->i_atime = current_time(dir);
0819     exfat_truncate_atime(&dir->i_atime);
0820     if (IS_DIRSYNC(dir))
0821         exfat_sync_inode(dir);
0822     else
0823         mark_inode_dirty(dir);
0824 
0825     clear_nlink(inode);
0826     inode->i_mtime = inode->i_atime = current_time(inode);
0827     exfat_truncate_atime(&inode->i_atime);
0828     exfat_unhash_inode(inode);
0829     exfat_d_version_set(dentry, inode_query_iversion(dir));
0830 unlock:
0831     mutex_unlock(&EXFAT_SB(sb)->s_lock);
0832     return err;
0833 }
0834 
0835 static int exfat_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
0836                struct dentry *dentry, umode_t mode)
0837 {
0838     struct super_block *sb = dir->i_sb;
0839     struct inode *inode;
0840     struct exfat_dir_entry info;
0841     struct exfat_chain cdir;
0842     loff_t i_pos;
0843     int err;
0844 
0845     mutex_lock(&EXFAT_SB(sb)->s_lock);
0846     exfat_set_volume_dirty(sb);
0847     err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_DIR,
0848         &info);
0849     if (err)
0850         goto unlock;
0851 
0852     inode_inc_iversion(dir);
0853     dir->i_ctime = dir->i_mtime = current_time(dir);
0854     if (IS_DIRSYNC(dir))
0855         exfat_sync_inode(dir);
0856     else
0857         mark_inode_dirty(dir);
0858     inc_nlink(dir);
0859 
0860     i_pos = exfat_make_i_pos(&info);
0861     inode = exfat_build_inode(sb, &info, i_pos);
0862     err = PTR_ERR_OR_ZERO(inode);
0863     if (err)
0864         goto unlock;
0865 
0866     inode_inc_iversion(inode);
0867     inode->i_mtime = inode->i_atime = inode->i_ctime =
0868         EXFAT_I(inode)->i_crtime = current_time(inode);
0869     exfat_truncate_atime(&inode->i_atime);
0870     /* timestamp is already written, so mark_inode_dirty() is unneeded. */
0871 
0872     d_instantiate(dentry, inode);
0873 
0874 unlock:
0875     mutex_unlock(&EXFAT_SB(sb)->s_lock);
0876     return err;
0877 }
0878 
0879 static int exfat_check_dir_empty(struct super_block *sb,
0880         struct exfat_chain *p_dir)
0881 {
0882     int i, dentries_per_clu;
0883     unsigned int type;
0884     struct exfat_chain clu;
0885     struct exfat_dentry *ep;
0886     struct exfat_sb_info *sbi = EXFAT_SB(sb);
0887     struct buffer_head *bh;
0888 
0889     dentries_per_clu = sbi->dentries_per_clu;
0890 
0891     exfat_chain_dup(&clu, p_dir);
0892 
0893     while (clu.dir != EXFAT_EOF_CLUSTER) {
0894         for (i = 0; i < dentries_per_clu; i++) {
0895             ep = exfat_get_dentry(sb, &clu, i, &bh);
0896             if (!ep)
0897                 return -EIO;
0898             type = exfat_get_entry_type(ep);
0899             brelse(bh);
0900             if (type == TYPE_UNUSED)
0901                 return 0;
0902 
0903             if (type != TYPE_FILE && type != TYPE_DIR)
0904                 continue;
0905 
0906             return -ENOTEMPTY;
0907         }
0908 
0909         if (clu.flags == ALLOC_NO_FAT_CHAIN) {
0910             if (--clu.size > 0)
0911                 clu.dir++;
0912             else
0913                 clu.dir = EXFAT_EOF_CLUSTER;
0914         } else {
0915             if (exfat_get_next_cluster(sb, &(clu.dir)))
0916                 return -EIO;
0917         }
0918     }
0919 
0920     return 0;
0921 }
0922 
0923 static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
0924 {
0925     struct inode *inode = dentry->d_inode;
0926     struct exfat_dentry *ep;
0927     struct exfat_chain cdir, clu_to_free;
0928     struct super_block *sb = inode->i_sb;
0929     struct exfat_sb_info *sbi = EXFAT_SB(sb);
0930     struct exfat_inode_info *ei = EXFAT_I(inode);
0931     struct buffer_head *bh;
0932     int num_entries, entry, err;
0933 
0934     mutex_lock(&EXFAT_SB(inode->i_sb)->s_lock);
0935 
0936     exfat_chain_dup(&cdir, &ei->dir);
0937     entry = ei->entry;
0938 
0939     if (ei->dir.dir == DIR_DELETED) {
0940         exfat_err(sb, "abnormal access to deleted dentry");
0941         err = -ENOENT;
0942         goto unlock;
0943     }
0944 
0945     exfat_chain_set(&clu_to_free, ei->start_clu,
0946         EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi), ei->flags);
0947 
0948     err = exfat_check_dir_empty(sb, &clu_to_free);
0949     if (err) {
0950         if (err == -EIO)
0951             exfat_err(sb, "failed to exfat_check_dir_empty : err(%d)",
0952                   err);
0953         goto unlock;
0954     }
0955 
0956     ep = exfat_get_dentry(sb, &cdir, entry, &bh);
0957     if (!ep) {
0958         err = -EIO;
0959         goto unlock;
0960     }
0961 
0962     num_entries = exfat_count_ext_entries(sb, &cdir, entry, ep);
0963     if (num_entries < 0) {
0964         err = -EIO;
0965         brelse(bh);
0966         goto unlock;
0967     }
0968     num_entries++;
0969     brelse(bh);
0970 
0971     exfat_set_volume_dirty(sb);
0972     err = exfat_remove_entries(dir, &cdir, entry, 0, num_entries);
0973     if (err) {
0974         exfat_err(sb, "failed to exfat_remove_entries : err(%d)", err);
0975         goto unlock;
0976     }
0977     ei->dir.dir = DIR_DELETED;
0978 
0979     inode_inc_iversion(dir);
0980     dir->i_mtime = dir->i_atime = current_time(dir);
0981     exfat_truncate_atime(&dir->i_atime);
0982     if (IS_DIRSYNC(dir))
0983         exfat_sync_inode(dir);
0984     else
0985         mark_inode_dirty(dir);
0986     drop_nlink(dir);
0987 
0988     clear_nlink(inode);
0989     inode->i_mtime = inode->i_atime = current_time(inode);
0990     exfat_truncate_atime(&inode->i_atime);
0991     exfat_unhash_inode(inode);
0992     exfat_d_version_set(dentry, inode_query_iversion(dir));
0993 unlock:
0994     mutex_unlock(&EXFAT_SB(inode->i_sb)->s_lock);
0995     return err;
0996 }
0997 
0998 static int exfat_rename_file(struct inode *inode, struct exfat_chain *p_dir,
0999         int oldentry, struct exfat_uni_name *p_uniname,
1000         struct exfat_inode_info *ei)
1001 {
1002     int ret, num_old_entries, num_new_entries;
1003     struct exfat_dentry *epold, *epnew;
1004     struct super_block *sb = inode->i_sb;
1005     struct buffer_head *new_bh, *old_bh;
1006     int sync = IS_DIRSYNC(inode);
1007 
1008     epold = exfat_get_dentry(sb, p_dir, oldentry, &old_bh);
1009     if (!epold)
1010         return -EIO;
1011 
1012     num_old_entries = exfat_count_ext_entries(sb, p_dir, oldentry, epold);
1013     if (num_old_entries < 0)
1014         return -EIO;
1015     num_old_entries++;
1016 
1017     num_new_entries = exfat_calc_num_entries(p_uniname);
1018     if (num_new_entries < 0)
1019         return num_new_entries;
1020 
1021     if (num_old_entries < num_new_entries) {
1022         int newentry;
1023 
1024         newentry =
1025             exfat_find_empty_entry(inode, p_dir, num_new_entries);
1026         if (newentry < 0)
1027             return newentry; /* -EIO or -ENOSPC */
1028 
1029         epnew = exfat_get_dentry(sb, p_dir, newentry, &new_bh);
1030         if (!epnew)
1031             return -EIO;
1032 
1033         *epnew = *epold;
1034         if (exfat_get_entry_type(epnew) == TYPE_FILE) {
1035             epnew->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1036             ei->attr |= ATTR_ARCHIVE;
1037         }
1038         exfat_update_bh(new_bh, sync);
1039         brelse(old_bh);
1040         brelse(new_bh);
1041 
1042         epold = exfat_get_dentry(sb, p_dir, oldentry + 1, &old_bh);
1043         if (!epold)
1044             return -EIO;
1045         epnew = exfat_get_dentry(sb, p_dir, newentry + 1, &new_bh);
1046         if (!epnew) {
1047             brelse(old_bh);
1048             return -EIO;
1049         }
1050 
1051         *epnew = *epold;
1052         exfat_update_bh(new_bh, sync);
1053         brelse(old_bh);
1054         brelse(new_bh);
1055 
1056         ret = exfat_init_ext_entry(inode, p_dir, newentry,
1057             num_new_entries, p_uniname);
1058         if (ret)
1059             return ret;
1060 
1061         exfat_remove_entries(inode, p_dir, oldentry, 0,
1062             num_old_entries);
1063         ei->dir = *p_dir;
1064         ei->entry = newentry;
1065     } else {
1066         if (exfat_get_entry_type(epold) == TYPE_FILE) {
1067             epold->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1068             ei->attr |= ATTR_ARCHIVE;
1069         }
1070         exfat_update_bh(old_bh, sync);
1071         brelse(old_bh);
1072         ret = exfat_init_ext_entry(inode, p_dir, oldentry,
1073             num_new_entries, p_uniname);
1074         if (ret)
1075             return ret;
1076 
1077         exfat_remove_entries(inode, p_dir, oldentry, num_new_entries,
1078             num_old_entries);
1079     }
1080     return 0;
1081 }
1082 
1083 static int exfat_move_file(struct inode *inode, struct exfat_chain *p_olddir,
1084         int oldentry, struct exfat_chain *p_newdir,
1085         struct exfat_uni_name *p_uniname, struct exfat_inode_info *ei)
1086 {
1087     int ret, newentry, num_new_entries, num_old_entries;
1088     struct exfat_dentry *epmov, *epnew;
1089     struct super_block *sb = inode->i_sb;
1090     struct buffer_head *mov_bh, *new_bh;
1091 
1092     epmov = exfat_get_dentry(sb, p_olddir, oldentry, &mov_bh);
1093     if (!epmov)
1094         return -EIO;
1095 
1096     num_old_entries = exfat_count_ext_entries(sb, p_olddir, oldentry,
1097         epmov);
1098     if (num_old_entries < 0)
1099         return -EIO;
1100     num_old_entries++;
1101 
1102     num_new_entries = exfat_calc_num_entries(p_uniname);
1103     if (num_new_entries < 0)
1104         return num_new_entries;
1105 
1106     newentry = exfat_find_empty_entry(inode, p_newdir, num_new_entries);
1107     if (newentry < 0)
1108         return newentry; /* -EIO or -ENOSPC */
1109 
1110     epnew = exfat_get_dentry(sb, p_newdir, newentry, &new_bh);
1111     if (!epnew)
1112         return -EIO;
1113 
1114     *epnew = *epmov;
1115     if (exfat_get_entry_type(epnew) == TYPE_FILE) {
1116         epnew->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1117         ei->attr |= ATTR_ARCHIVE;
1118     }
1119     exfat_update_bh(new_bh, IS_DIRSYNC(inode));
1120     brelse(mov_bh);
1121     brelse(new_bh);
1122 
1123     epmov = exfat_get_dentry(sb, p_olddir, oldentry + 1, &mov_bh);
1124     if (!epmov)
1125         return -EIO;
1126     epnew = exfat_get_dentry(sb, p_newdir, newentry + 1, &new_bh);
1127     if (!epnew) {
1128         brelse(mov_bh);
1129         return -EIO;
1130     }
1131 
1132     *epnew = *epmov;
1133     exfat_update_bh(new_bh, IS_DIRSYNC(inode));
1134     brelse(mov_bh);
1135     brelse(new_bh);
1136 
1137     ret = exfat_init_ext_entry(inode, p_newdir, newentry, num_new_entries,
1138         p_uniname);
1139     if (ret)
1140         return ret;
1141 
1142     exfat_remove_entries(inode, p_olddir, oldentry, 0, num_old_entries);
1143 
1144     exfat_chain_set(&ei->dir, p_newdir->dir, p_newdir->size,
1145         p_newdir->flags);
1146 
1147     ei->entry = newentry;
1148     return 0;
1149 }
1150 
1151 /* rename or move a old file into a new file */
1152 static int __exfat_rename(struct inode *old_parent_inode,
1153         struct exfat_inode_info *ei, struct inode *new_parent_inode,
1154         struct dentry *new_dentry)
1155 {
1156     int ret;
1157     int dentry;
1158     struct exfat_chain olddir, newdir;
1159     struct exfat_chain *p_dir = NULL;
1160     struct exfat_uni_name uni_name;
1161     struct exfat_dentry *ep;
1162     struct super_block *sb = old_parent_inode->i_sb;
1163     struct exfat_sb_info *sbi = EXFAT_SB(sb);
1164     const unsigned char *new_path = new_dentry->d_name.name;
1165     struct inode *new_inode = new_dentry->d_inode;
1166     int num_entries;
1167     struct exfat_inode_info *new_ei = NULL;
1168     unsigned int new_entry_type = TYPE_UNUSED;
1169     int new_entry = 0;
1170     struct buffer_head *old_bh, *new_bh = NULL;
1171 
1172     /* check the validity of pointer parameters */
1173     if (new_path == NULL || strlen(new_path) == 0)
1174         return -EINVAL;
1175 
1176     if (ei->dir.dir == DIR_DELETED) {
1177         exfat_err(sb, "abnormal access to deleted source dentry");
1178         return -ENOENT;
1179     }
1180 
1181     exfat_chain_set(&olddir, EXFAT_I(old_parent_inode)->start_clu,
1182         EXFAT_B_TO_CLU_ROUND_UP(i_size_read(old_parent_inode), sbi),
1183         EXFAT_I(old_parent_inode)->flags);
1184     dentry = ei->entry;
1185 
1186     ep = exfat_get_dentry(sb, &olddir, dentry, &old_bh);
1187     if (!ep) {
1188         ret = -EIO;
1189         goto out;
1190     }
1191     brelse(old_bh);
1192 
1193     /* check whether new dir is existing directory and empty */
1194     if (new_inode) {
1195         ret = -EIO;
1196         new_ei = EXFAT_I(new_inode);
1197 
1198         if (new_ei->dir.dir == DIR_DELETED) {
1199             exfat_err(sb, "abnormal access to deleted target dentry");
1200             goto out;
1201         }
1202 
1203         p_dir = &(new_ei->dir);
1204         new_entry = new_ei->entry;
1205         ep = exfat_get_dentry(sb, p_dir, new_entry, &new_bh);
1206         if (!ep)
1207             goto out;
1208 
1209         new_entry_type = exfat_get_entry_type(ep);
1210         brelse(new_bh);
1211 
1212         /* if new_inode exists, update ei */
1213         if (new_entry_type == TYPE_DIR) {
1214             struct exfat_chain new_clu;
1215 
1216             new_clu.dir = new_ei->start_clu;
1217             new_clu.size =
1218                 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),
1219                 sbi);
1220             new_clu.flags = new_ei->flags;
1221 
1222             ret = exfat_check_dir_empty(sb, &new_clu);
1223             if (ret)
1224                 goto out;
1225         }
1226     }
1227 
1228     /* check the validity of directory name in the given new pathname */
1229     ret = exfat_resolve_path(new_parent_inode, new_path, &newdir,
1230             &uni_name);
1231     if (ret)
1232         goto out;
1233 
1234     exfat_set_volume_dirty(sb);
1235 
1236     if (olddir.dir == newdir.dir)
1237         ret = exfat_rename_file(new_parent_inode, &olddir, dentry,
1238                 &uni_name, ei);
1239     else
1240         ret = exfat_move_file(new_parent_inode, &olddir, dentry,
1241                 &newdir, &uni_name, ei);
1242 
1243     if (!ret && new_inode) {
1244         /* delete entries of new_dir */
1245         ep = exfat_get_dentry(sb, p_dir, new_entry, &new_bh);
1246         if (!ep) {
1247             ret = -EIO;
1248             goto del_out;
1249         }
1250 
1251         num_entries = exfat_count_ext_entries(sb, p_dir, new_entry, ep);
1252         if (num_entries < 0) {
1253             ret = -EIO;
1254             goto del_out;
1255         }
1256         brelse(new_bh);
1257 
1258         if (exfat_remove_entries(new_inode, p_dir, new_entry, 0,
1259                 num_entries + 1)) {
1260             ret = -EIO;
1261             goto del_out;
1262         }
1263 
1264         /* Free the clusters if new_inode is a dir(as if exfat_rmdir) */
1265         if (new_entry_type == TYPE_DIR) {
1266             /* new_ei, new_clu_to_free */
1267             struct exfat_chain new_clu_to_free;
1268 
1269             exfat_chain_set(&new_clu_to_free, new_ei->start_clu,
1270                 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),
1271                 sbi), new_ei->flags);
1272 
1273             if (exfat_free_cluster(new_inode, &new_clu_to_free)) {
1274                 /* just set I/O error only */
1275                 ret = -EIO;
1276             }
1277 
1278             i_size_write(new_inode, 0);
1279             new_ei->start_clu = EXFAT_EOF_CLUSTER;
1280             new_ei->flags = ALLOC_NO_FAT_CHAIN;
1281         }
1282 del_out:
1283         /* Update new_inode ei
1284          * Prevent syncing removed new_inode
1285          * (new_ei is already initialized above code ("if (new_inode)")
1286          */
1287         new_ei->dir.dir = DIR_DELETED;
1288     }
1289 out:
1290     return ret;
1291 }
1292 
1293 static int exfat_rename(struct user_namespace *mnt_userns,
1294             struct inode *old_dir, struct dentry *old_dentry,
1295             struct inode *new_dir, struct dentry *new_dentry,
1296             unsigned int flags)
1297 {
1298     struct inode *old_inode, *new_inode;
1299     struct super_block *sb = old_dir->i_sb;
1300     loff_t i_pos;
1301     int err;
1302 
1303     /*
1304      * The VFS already checks for existence, so for local filesystems
1305      * the RENAME_NOREPLACE implementation is equivalent to plain rename.
1306      * Don't support any other flags
1307      */
1308     if (flags & ~RENAME_NOREPLACE)
1309         return -EINVAL;
1310 
1311     mutex_lock(&EXFAT_SB(sb)->s_lock);
1312     old_inode = old_dentry->d_inode;
1313     new_inode = new_dentry->d_inode;
1314 
1315     err = __exfat_rename(old_dir, EXFAT_I(old_inode), new_dir, new_dentry);
1316     if (err)
1317         goto unlock;
1318 
1319     inode_inc_iversion(new_dir);
1320     new_dir->i_ctime = new_dir->i_mtime = new_dir->i_atime =
1321         EXFAT_I(new_dir)->i_crtime = current_time(new_dir);
1322     exfat_truncate_atime(&new_dir->i_atime);
1323     if (IS_DIRSYNC(new_dir))
1324         exfat_sync_inode(new_dir);
1325     else
1326         mark_inode_dirty(new_dir);
1327 
1328     i_pos = ((loff_t)EXFAT_I(old_inode)->dir.dir << 32) |
1329         (EXFAT_I(old_inode)->entry & 0xffffffff);
1330     exfat_unhash_inode(old_inode);
1331     exfat_hash_inode(old_inode, i_pos);
1332     if (IS_DIRSYNC(new_dir))
1333         exfat_sync_inode(old_inode);
1334     else
1335         mark_inode_dirty(old_inode);
1336 
1337     if (S_ISDIR(old_inode->i_mode) && old_dir != new_dir) {
1338         drop_nlink(old_dir);
1339         if (!new_inode)
1340             inc_nlink(new_dir);
1341     }
1342 
1343     inode_inc_iversion(old_dir);
1344     old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
1345     if (IS_DIRSYNC(old_dir))
1346         exfat_sync_inode(old_dir);
1347     else
1348         mark_inode_dirty(old_dir);
1349 
1350     if (new_inode) {
1351         exfat_unhash_inode(new_inode);
1352 
1353         /* skip drop_nlink if new_inode already has been dropped */
1354         if (new_inode->i_nlink) {
1355             drop_nlink(new_inode);
1356             if (S_ISDIR(new_inode->i_mode))
1357                 drop_nlink(new_inode);
1358         } else {
1359             exfat_warn(sb, "abnormal access to an inode dropped");
1360             WARN_ON(new_inode->i_nlink == 0);
1361         }
1362         new_inode->i_ctime = EXFAT_I(new_inode)->i_crtime =
1363             current_time(new_inode);
1364     }
1365 
1366 unlock:
1367     mutex_unlock(&EXFAT_SB(sb)->s_lock);
1368     return err;
1369 }
1370 
1371 const struct inode_operations exfat_dir_inode_operations = {
1372     .create     = exfat_create,
1373     .lookup     = exfat_lookup,
1374     .unlink     = exfat_unlink,
1375     .mkdir      = exfat_mkdir,
1376     .rmdir      = exfat_rmdir,
1377     .rename     = exfat_rename,
1378     .setattr    = exfat_setattr,
1379     .getattr    = exfat_getattr,
1380 };
[ 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!