~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/exfat/namei.c

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
  4  */
  5 
  6 #include <linux/iversion.h>
  7 #include <linux/namei.h>
  8 #include <linux/slab.h>
  9 #include <linux/buffer_head.h>
 10 #include <linux/nls.h>
 11 
 12 #include "exfat_raw.h"
 13 #include "exfat_fs.h"
 14 
 15 static inline unsigned long exfat_d_version(struct dentry *dentry)
 16 {
 17         return (unsigned long) dentry->d_fsdata;
 18 }
 19 
 20 static inline void exfat_d_version_set(struct dentry *dentry,
 21                 unsigned long version)
 22 {
 23         dentry->d_fsdata = (void *) version;
 24 }
 25 
 26 /*
 27  * If new entry was created in the parent, it could create the 8.3 alias (the
 28  * shortname of logname).  So, the parent may have the negative-dentry which
 29  * matches the created 8.3 alias.
 30  *
 31  * If it happened, the negative dentry isn't actually negative anymore.  So,
 32  * drop it.
 33  */
 34 static int exfat_d_revalidate(struct dentry *dentry, unsigned int flags)
 35 {
 36         int ret;
 37 
 38         if (flags & LOOKUP_RCU)
 39                 return -ECHILD;
 40 
 41         /*
 42          * This is not negative dentry. Always valid.
 43          *
 44          * Note, rename() to existing directory entry will have ->d_inode, and
 45          * will use existing name which isn't specified name by user.
 46          *
 47          * We may be able to drop this positive dentry here. But dropping
 48          * positive dentry isn't good idea. So it's unsupported like
 49          * rename("filename", "FILENAME") for now.
 50          */
 51         if (d_really_is_positive(dentry))
 52                 return 1;
 53 
 54         /*
 55          * Drop the negative dentry, in order to make sure to use the case
 56          * sensitive name which is specified by user if this is for creation.
 57          */
 58         if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
 59                 return 0;
 60 
 61         spin_lock(&dentry->d_lock);
 62         ret = inode_eq_iversion(d_inode(dentry->d_parent),
 63                         exfat_d_version(dentry));
 64         spin_unlock(&dentry->d_lock);
 65         return ret;
 66 }
 67 
 68 /* returns the length of a struct qstr, ignoring trailing dots */
 69 static unsigned int exfat_striptail_len(unsigned int len, const char *name)
 70 {
 71         while (len && name[len - 1] == '.')
 72                 len--;
 73         return len;
 74 }
 75 
 76 /*
 77  * Compute the hash for the exfat name corresponding to the dentry.  If the name
 78  * is invalid, we leave the hash code unchanged so that the existing dentry can
 79  * be used. The exfat fs routines will return ENOENT or EINVAL as appropriate.
 80  */
 81 static int exfat_d_hash(const struct dentry *dentry, struct qstr *qstr)
 82 {
 83         struct super_block *sb = dentry->d_sb;
 84         struct nls_table *t = EXFAT_SB(sb)->nls_io;
 85         const unsigned char *name = qstr->name;
 86         unsigned int len = exfat_striptail_len(qstr->len, qstr->name);
 87         unsigned long hash = init_name_hash(dentry);
 88         int i, charlen;
 89         wchar_t c;
 90 
 91         for (i = 0; i < len; i += charlen) {
 92                 charlen = t->char2uni(&name[i], len - i, &c);
 93                 if (charlen < 0)
 94                         return charlen;
 95                 hash = partial_name_hash(exfat_toupper(sb, c), hash);
 96         }
 97 
 98         qstr->hash = end_name_hash(hash);
 99         return 0;
100 }
101 
102 static int exfat_d_cmp(const struct dentry *dentry, unsigned int len,
103                 const char *str, const struct qstr *name)
104 {
105         struct super_block *sb = dentry->d_sb;
106         struct nls_table *t = EXFAT_SB(sb)->nls_io;
107         unsigned int alen = exfat_striptail_len(name->len, name->name);
108         unsigned int blen = exfat_striptail_len(len, str);
109         wchar_t c1, c2;
110         int charlen, i;
111 
112         if (alen != blen)
113                 return 1;
114 
115         for (i = 0; i < len; i += charlen) {
116                 charlen = t->char2uni(&name->name[i], alen - i, &c1);
117                 if (charlen < 0)
118                         return 1;
119                 if (charlen != t->char2uni(&str[i], blen - i, &c2))
120                         return 1;
121 
122                 if (exfat_toupper(sb, c1) != exfat_toupper(sb, c2))
123                         return 1;
124         }
125 
126         return 0;
127 }
128 
129 const struct dentry_operations exfat_dentry_ops = {
130         .d_revalidate   = exfat_d_revalidate,
131         .d_hash         = exfat_d_hash,
132         .d_compare      = exfat_d_cmp,
133 };
134 
135 static int exfat_utf8_d_hash(const struct dentry *dentry, struct qstr *qstr)
136 {
137         struct super_block *sb = dentry->d_sb;
138         const unsigned char *name = qstr->name;
139         unsigned int len = exfat_striptail_len(qstr->len, qstr->name);
140         unsigned long hash = init_name_hash(dentry);
141         int i, charlen;
142         unicode_t u;
143 
144         for (i = 0; i < len; i += charlen) {
145                 charlen = utf8_to_utf32(&name[i], len - i, &u);
146                 if (charlen < 0)
147                         return charlen;
148 
149                 /*
150                  * exfat_toupper() works only for code points up to the U+FFFF.
151                  */
152                 hash = partial_name_hash(u <= 0xFFFF ? exfat_toupper(sb, u) : u,
153                                          hash);
154         }
155 
156         qstr->hash = end_name_hash(hash);
157         return 0;
158 }
159 
160 static int exfat_utf8_d_cmp(const struct dentry *dentry, unsigned int len,
161                 const char *str, const struct qstr *name)
162 {
163         struct super_block *sb = dentry->d_sb;
164         unsigned int alen = exfat_striptail_len(name->len, name->name);
165         unsigned int blen = exfat_striptail_len(len, str);
166         unicode_t u_a, u_b;
167         int charlen, i;
168 
169         if (alen != blen)
170                 return 1;
171 
172         for (i = 0; i < alen; i += charlen) {
173                 charlen = utf8_to_utf32(&name->name[i], alen - i, &u_a);
174                 if (charlen < 0)
175                         return 1;
176                 if (charlen != utf8_to_utf32(&str[i], blen - i, &u_b))
177                         return 1;
178 
179                 if (u_a <= 0xFFFF && u_b <= 0xFFFF) {
180                         if (exfat_toupper(sb, u_a) != exfat_toupper(sb, u_b))
181                                 return 1;
182                 } else {
183                         if (u_a != u_b)
184                                 return 1;
185                 }
186         }
187 
188         return 0;
189 }
190 
191 const struct dentry_operations exfat_utf8_dentry_ops = {
192         .d_revalidate   = exfat_d_revalidate,
193         .d_hash         = exfat_utf8_d_hash,
194         .d_compare      = exfat_utf8_d_cmp,
195 };
196 
197 /* used only in search empty_slot() */
198 #define CNT_UNUSED_NOHIT        (-1)
199 #define CNT_UNUSED_HIT          (-2)
200 /* search EMPTY CONTINUOUS "num_entries" entries */
201 static int exfat_search_empty_slot(struct super_block *sb,
202                 struct exfat_hint_femp *hint_femp, struct exfat_chain *p_dir,
203                 int num_entries)
204 {
205         int i, dentry, num_empty = 0;
206         int dentries_per_clu;
207         unsigned int type;
208         struct exfat_chain clu;
209         struct exfat_dentry *ep;
210         struct exfat_sb_info *sbi = EXFAT_SB(sb);
211         struct buffer_head *bh;
212 
213         dentries_per_clu = sbi->dentries_per_clu;
214 
215         if (hint_femp->eidx != EXFAT_HINT_NONE) {
216                 dentry = hint_femp->eidx;
217                 if (num_entries <= hint_femp->count) {
218                         hint_femp->eidx = EXFAT_HINT_NONE;
219                         return dentry;
220                 }
221 
222                 exfat_chain_dup(&clu, &hint_femp->cur);
223         } else {
224                 exfat_chain_dup(&clu, p_dir);
225                 dentry = 0;
226         }
227 
228         while (clu.dir != EXFAT_EOF_CLUSTER) {
229                 i = dentry & (dentries_per_clu - 1);
230 
231                 for (; i < dentries_per_clu; i++, dentry++) {
232                         ep = exfat_get_dentry(sb, &clu, i, &bh, NULL);
233                         if (!ep)
234                                 return -EIO;
235                         type = exfat_get_entry_type(ep);
236                         brelse(bh);
237 
238                         if (type == TYPE_UNUSED || type == TYPE_DELETED) {
239                                 num_empty++;
240                                 if (hint_femp->eidx == EXFAT_HINT_NONE) {
241                                         hint_femp->eidx = dentry;
242                                         hint_femp->count = CNT_UNUSED_NOHIT;
243                                         exfat_chain_set(&hint_femp->cur,
244                                                 clu.dir, clu.size, clu.flags);
245                                 }
246 
247                                 if (type == TYPE_UNUSED &&
248                                     hint_femp->count != CNT_UNUSED_HIT)
249                                         hint_femp->count = CNT_UNUSED_HIT;
250                         } else {
251                                 if (hint_femp->eidx != EXFAT_HINT_NONE &&
252                                     hint_femp->count == CNT_UNUSED_HIT) {
253                                         /* unused empty group means
254                                          * an empty group which includes
255                                          * unused dentry
256                                          */
257                                         exfat_fs_error(sb,
258                                                 "found bogus dentry(%d) beyond unused empty group(%d) (start_clu : %u, cur_clu : %u)",
259                                                 dentry, hint_femp->eidx,
260                                                 p_dir->dir, clu.dir);
261                                         return -EIO;
262                                 }
263 
264                                 num_empty = 0;
265                                 hint_femp->eidx = EXFAT_HINT_NONE;
266                         }
267 
268                         if (num_empty >= num_entries) {
269                                 /* found and invalidate hint_femp */
270                                 hint_femp->eidx = EXFAT_HINT_NONE;
271                                 return (dentry - (num_entries - 1));
272                         }
273                 }
274 
275                 if (clu.flags == ALLOC_NO_FAT_CHAIN) {
276                         if (--clu.size > 0)
277                                 clu.dir++;
278                         else
279                                 clu.dir = EXFAT_EOF_CLUSTER;
280                 } else {
281                         if (exfat_get_next_cluster(sb, &clu.dir))
282                                 return -EIO;
283                 }
284         }
285 
286         return -ENOSPC;
287 }
288 
289 static int exfat_check_max_dentries(struct inode *inode)
290 {
291         if (EXFAT_B_TO_DEN(i_size_read(inode)) >= MAX_EXFAT_DENTRIES) {
292                 /*
293                  * exFAT spec allows a dir to grow up to 8388608(256MB)
294                  * dentries
295                  */
296                 return -ENOSPC;
297         }
298         return 0;
299 }
300 
301 /* find empty directory entry.
302  * if there isn't any empty slot, expand cluster chain.
303  */
304 static int exfat_find_empty_entry(struct inode *inode,
305                 struct exfat_chain *p_dir, int num_entries)
306 {
307         int dentry;
308         unsigned int ret, last_clu;
309         sector_t sector;
310         loff_t size = 0;
311         struct exfat_chain clu;
312         struct exfat_dentry *ep = NULL;
313         struct super_block *sb = inode->i_sb;
314         struct exfat_sb_info *sbi = EXFAT_SB(sb);
315         struct exfat_inode_info *ei = EXFAT_I(inode);
316         struct exfat_hint_femp hint_femp;
317 
318         hint_femp.eidx = EXFAT_HINT_NONE;
319 
320         if (ei->hint_femp.eidx != EXFAT_HINT_NONE) {
321                 hint_femp = ei->hint_femp;
322                 ei->hint_femp.eidx = EXFAT_HINT_NONE;
323         }
324 
325         while ((dentry = exfat_search_empty_slot(sb, &hint_femp, p_dir,
326                                         num_entries)) < 0) {
327                 if (dentry == -EIO)
328                         break;
329 
330                 if (exfat_check_max_dentries(inode))
331                         return -ENOSPC;
332 
333                 /* we trust p_dir->size regardless of FAT type */
334                 if (exfat_find_last_cluster(sb, p_dir, &last_clu))
335                         return -EIO;
336 
337                 /*
338                  * Allocate new cluster to this directory
339                  */
340                 exfat_chain_set(&clu, last_clu + 1, 0, p_dir->flags);
341 
342                 /* allocate a cluster */
343                 ret = exfat_alloc_cluster(inode, 1, &clu, IS_DIRSYNC(inode));
344                 if (ret)
345                         return ret;
346 
347                 if (exfat_zeroed_cluster(inode, clu.dir))
348                         return -EIO;
349 
350                 /* append to the FAT chain */
351                 if (clu.flags != p_dir->flags) {
352                         /* no-fat-chain bit is disabled,
353                          * so fat-chain should be synced with alloc-bitmap
354                          */
355                         exfat_chain_cont_cluster(sb, p_dir->dir, p_dir->size);
356                         p_dir->flags = ALLOC_FAT_CHAIN;
357                         hint_femp.cur.flags = ALLOC_FAT_CHAIN;
358                 }
359 
360                 if (clu.flags == ALLOC_FAT_CHAIN)
361                         if (exfat_ent_set(sb, last_clu, clu.dir))
362                                 return -EIO;
363 
364                 if (hint_femp.eidx == EXFAT_HINT_NONE) {
365                         /* the special case that new dentry
366                          * should be allocated from the start of new cluster
367                          */
368                         hint_femp.eidx = EXFAT_B_TO_DEN_IDX(p_dir->size, sbi);
369                         hint_femp.count = sbi->dentries_per_clu;
370 
371                         exfat_chain_set(&hint_femp.cur, clu.dir, 0, clu.flags);
372                 }
373                 hint_femp.cur.size++;
374                 p_dir->size++;
375                 size = EXFAT_CLU_TO_B(p_dir->size, sbi);
376 
377                 /* update the directory entry */
378                 if (p_dir->dir != sbi->root_dir) {
379                         struct buffer_head *bh;
380 
381                         ep = exfat_get_dentry(sb,
382                                 &(ei->dir), ei->entry + 1, &bh, &sector);
383                         if (!ep)
384                                 return -EIO;
385 
386                         ep->dentry.stream.valid_size = cpu_to_le64(size);
387                         ep->dentry.stream.size = ep->dentry.stream.valid_size;
388                         ep->dentry.stream.flags = p_dir->flags;
389                         exfat_update_bh(bh, IS_DIRSYNC(inode));
390                         brelse(bh);
391                         if (exfat_update_dir_chksum(inode, &(ei->dir),
392                             ei->entry))
393                                 return -EIO;
394                 }
395 
396                 /* directory inode should be updated in here */
397                 i_size_write(inode, size);
398                 EXFAT_I(inode)->i_size_ondisk += sbi->cluster_size;
399                 EXFAT_I(inode)->i_size_aligned += sbi->cluster_size;
400                 EXFAT_I(inode)->flags = p_dir->flags;
401                 inode->i_blocks += 1 << sbi->sect_per_clus_bits;
402         }
403 
404         return dentry;
405 }
406 
407 /*
408  * Name Resolution Functions :
409  * Zero if it was successful; otherwise nonzero.
410  */
411 static int __exfat_resolve_path(struct inode *inode, const unsigned char *path,
412                 struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname,
413                 int lookup)
414 {
415         int namelen;
416         int lossy = NLS_NAME_NO_LOSSY;
417         struct super_block *sb = inode->i_sb;
418         struct exfat_sb_info *sbi = EXFAT_SB(sb);
419         struct exfat_inode_info *ei = EXFAT_I(inode);
420 
421         /* strip all trailing periods */
422         namelen = exfat_striptail_len(strlen(path), path);
423         if (!namelen)
424                 return -ENOENT;
425 
426         if (strlen(path) > (MAX_NAME_LENGTH * MAX_CHARSET_SIZE))
427                 return -ENAMETOOLONG;
428 
429         /*
430          * strip all leading spaces :
431          * "MS windows 7" supports leading spaces.
432          * So we should skip this preprocessing for compatibility.
433          */
434 
435         /* file name conversion :
436          * If lookup case, we allow bad-name for compatibility.
437          */
438         namelen = exfat_nls_to_utf16(sb, path, namelen, p_uniname,
439                         &lossy);
440         if (namelen < 0)
441                 return namelen; /* return error value */
442 
443         if ((lossy && !lookup) || !namelen)
444                 return -EINVAL;
445 
446         exfat_chain_set(p_dir, ei->start_clu,
447                 EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags);
448 
449         return 0;
450 }
451 
452 static inline int exfat_resolve_path(struct inode *inode,
453                 const unsigned char *path, struct exfat_chain *dir,
454                 struct exfat_uni_name *uni)
455 {
456         return __exfat_resolve_path(inode, path, dir, uni, 0);
457 }
458 
459 static inline int exfat_resolve_path_for_lookup(struct inode *inode,
460                 const unsigned char *path, struct exfat_chain *dir,
461                 struct exfat_uni_name *uni)
462 {
463         return __exfat_resolve_path(inode, path, dir, uni, 1);
464 }
465 
466 static inline loff_t exfat_make_i_pos(struct exfat_dir_entry *info)
467 {
468         return ((loff_t) info->dir.dir << 32) | (info->entry & 0xffffffff);
469 }
470 
471 static int exfat_add_entry(struct inode *inode, const char *path,
472                 struct exfat_chain *p_dir, unsigned int type,
473                 struct exfat_dir_entry *info)
474 {
475         int ret, dentry, num_entries;
476         struct super_block *sb = inode->i_sb;
477         struct exfat_sb_info *sbi = EXFAT_SB(sb);
478         struct exfat_uni_name uniname;
479         struct exfat_chain clu;
480         int clu_size = 0;
481         unsigned int start_clu = EXFAT_FREE_CLUSTER;
482 
483         ret = exfat_resolve_path(inode, path, p_dir, &uniname);
484         if (ret)
485                 goto out;
486 
487         num_entries = exfat_calc_num_entries(&uniname);
488         if (num_entries < 0) {
489                 ret = num_entries;
490                 goto out;
491         }
492 
493         /* exfat_find_empty_entry must be called before alloc_cluster() */
494         dentry = exfat_find_empty_entry(inode, p_dir, num_entries);
495         if (dentry < 0) {
496                 ret = dentry; /* -EIO or -ENOSPC */
497                 goto out;
498         }
499 
500         if (type == TYPE_DIR) {
501                 ret = exfat_alloc_new_dir(inode, &clu);
502                 if (ret)
503                         goto out;
504                 start_clu = clu.dir;
505                 clu_size = sbi->cluster_size;
506         }
507 
508         /* update the directory entry */
509         /* fill the dos name directory entry information of the created file.
510          * the first cluster is not determined yet. (0)
511          */
512         ret = exfat_init_dir_entry(inode, p_dir, dentry, type,
513                 start_clu, clu_size);
514         if (ret)
515                 goto out;
516 
517         ret = exfat_init_ext_entry(inode, p_dir, dentry, num_entries, &uniname);
518         if (ret)
519                 goto out;
520 
521         info->dir = *p_dir;
522         info->entry = dentry;
523         info->flags = ALLOC_NO_FAT_CHAIN;
524         info->type = type;
525 
526         if (type == TYPE_FILE) {
527                 info->attr = ATTR_ARCHIVE;
528                 info->start_clu = EXFAT_EOF_CLUSTER;
529                 info->size = 0;
530                 info->num_subdirs = 0;
531         } else {
532                 info->attr = ATTR_SUBDIR;
533                 info->start_clu = start_clu;
534                 info->size = clu_size;
535                 info->num_subdirs = EXFAT_MIN_SUBDIR;
536         }
537         memset(&info->crtime, 0, sizeof(info->crtime));
538         memset(&info->mtime, 0, sizeof(info->mtime));
539         memset(&info->atime, 0, sizeof(info->atime));
540 out:
541         return ret;
542 }
543 
544 static int exfat_create(struct user_namespace *mnt_userns, struct inode *dir,
545                         struct dentry *dentry, umode_t mode, bool excl)
546 {
547         struct super_block *sb = dir->i_sb;
548         struct inode *inode;
549         struct exfat_chain cdir;
550         struct exfat_dir_entry info;
551         loff_t i_pos;
552         int err;
553 
554         mutex_lock(&EXFAT_SB(sb)->s_lock);
555         exfat_set_volume_dirty(sb);
556         err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_FILE,
557                 &info);
558         exfat_clear_volume_dirty(sb);
559         if (err)
560                 goto unlock;
561 
562         inode_inc_iversion(dir);
563         dir->i_ctime = dir->i_mtime = current_time(dir);
564         if (IS_DIRSYNC(dir))
565                 exfat_sync_inode(dir);
566         else
567                 mark_inode_dirty(dir);
568 
569         i_pos = exfat_make_i_pos(&info);
570         inode = exfat_build_inode(sb, &info, i_pos);
571         err = PTR_ERR_OR_ZERO(inode);
572         if (err)
573                 goto unlock;
574 
575         inode_inc_iversion(inode);
576         inode->i_mtime = inode->i_atime = inode->i_ctime =
577                 EXFAT_I(inode)->i_crtime = current_time(inode);
578         exfat_truncate_atime(&inode->i_atime);
579         /* timestamp is already written, so mark_inode_dirty() is unneeded. */
580 
581         d_instantiate(dentry, inode);
582 unlock:
583         mutex_unlock(&EXFAT_SB(sb)->s_lock);
584         return err;
585 }
586 
587 /* lookup a file */
588 static int exfat_find(struct inode *dir, struct qstr *qname,
589                 struct exfat_dir_entry *info)
590 {
591         int ret, dentry, num_entries, count;
592         struct exfat_chain cdir;
593         struct exfat_uni_name uni_name;
594         struct super_block *sb = dir->i_sb;
595         struct exfat_sb_info *sbi = EXFAT_SB(sb);
596         struct exfat_inode_info *ei = EXFAT_I(dir);
597         struct exfat_dentry *ep, *ep2;
598         struct exfat_entry_set_cache *es;
599         /* for optimized dir & entry to prevent long traverse of cluster chain */
600         struct exfat_hint hint_opt;
601 
602         if (qname->len == 0)
603                 return -ENOENT;
604 
605         /* check the validity of directory name in the given pathname */
606         ret = exfat_resolve_path_for_lookup(dir, qname->name, &cdir, &uni_name);
607         if (ret)
608                 return ret;
609 
610         num_entries = exfat_calc_num_entries(&uni_name);
611         if (num_entries < 0)
612                 return num_entries;
613 
614         /* check the validation of hint_stat and initialize it if required */
615         if (ei->version != (inode_peek_iversion_raw(dir) & 0xffffffff)) {
616                 ei->hint_stat.clu = cdir.dir;
617                 ei->hint_stat.eidx = 0;
618                 ei->version = (inode_peek_iversion_raw(dir) & 0xffffffff);
619                 ei->hint_femp.eidx = EXFAT_HINT_NONE;
620         }
621 
622         /* search the file name for directories */
623         dentry = exfat_find_dir_entry(sb, ei, &cdir, &uni_name,
624                         num_entries, TYPE_ALL, &hint_opt);
625 
626         if (dentry < 0)
627                 return dentry; /* -error value */
628 
629         info->dir = cdir;
630         info->entry = dentry;
631         info->num_subdirs = 0;
632 
633         /* adjust cdir to the optimized value */
634         cdir.dir = hint_opt.clu;
635         if (cdir.flags & ALLOC_NO_FAT_CHAIN)
636                 cdir.size -= dentry / sbi->dentries_per_clu;
637         dentry = hint_opt.eidx;
638         es = exfat_get_dentry_set(sb, &cdir, dentry, ES_2_ENTRIES);
639         if (!es)
640                 return -EIO;
641         ep = exfat_get_dentry_cached(es, 0);
642         ep2 = exfat_get_dentry_cached(es, 1);
643 
644         info->type = exfat_get_entry_type(ep);
645         info->attr = le16_to_cpu(ep->dentry.file.attr);
646         info->size = le64_to_cpu(ep2->dentry.stream.valid_size);
647         if ((info->type == TYPE_FILE) && (info->size == 0)) {
648                 info->flags = ALLOC_NO_FAT_CHAIN;
649                 info->start_clu = EXFAT_EOF_CLUSTER;
650         } else {
651                 info->flags = ep2->dentry.stream.flags;
652                 info->start_clu =
653                         le32_to_cpu(ep2->dentry.stream.start_clu);
654         }
655 
656         exfat_get_entry_time(sbi, &info->crtime,
657                              ep->dentry.file.create_tz,
658                              ep->dentry.file.create_time,
659                              ep->dentry.file.create_date,
660                              ep->dentry.file.create_time_cs);
661         exfat_get_entry_time(sbi, &info->mtime,
662                              ep->dentry.file.modify_tz,
663                              ep->dentry.file.modify_time,
664                              ep->dentry.file.modify_date,
665                              ep->dentry.file.modify_time_cs);
666         exfat_get_entry_time(sbi, &info->atime,
667                              ep->dentry.file.access_tz,
668                              ep->dentry.file.access_time,
669                              ep->dentry.file.access_date,
670                              0);
671         exfat_free_dentry_set(es, false);
672 
673         if (ei->start_clu == EXFAT_FREE_CLUSTER) {
674                 exfat_fs_error(sb,
675                                "non-zero size file starts with zero cluster (size : %llu, p_dir : %u, entry : 0x%08x)",
676                                i_size_read(dir), ei->dir.dir, ei->entry);
677                 return -EIO;
678         }
679 
680         if (info->type == TYPE_DIR) {
681                 exfat_chain_set(&cdir, info->start_clu,
682                                 EXFAT_B_TO_CLU(info->size, sbi), info->flags);
683                 count = exfat_count_dir_entries(sb, &cdir);
684                 if (count < 0)
685                         return -EIO;
686 
687                 info->num_subdirs = count + EXFAT_MIN_SUBDIR;
688         }
689         return 0;
690 }
691 
692 static int exfat_d_anon_disconn(struct dentry *dentry)
693 {
694         return IS_ROOT(dentry) && (dentry->d_flags & DCACHE_DISCONNECTED);
695 }
696 
697 static struct dentry *exfat_lookup(struct inode *dir, struct dentry *dentry,
698                 unsigned int flags)
699 {
700         struct super_block *sb = dir->i_sb;
701         struct inode *inode;
702         struct dentry *alias;
703         struct exfat_dir_entry info;
704         int err;
705         loff_t i_pos;
706         mode_t i_mode;
707 
708         mutex_lock(&EXFAT_SB(sb)->s_lock);
709         err = exfat_find(dir, &dentry->d_name, &info);
710         if (err) {
711                 if (err == -ENOENT) {
712                         inode = NULL;
713                         goto out;
714                 }
715                 goto unlock;
716         }
717 
718         i_pos = exfat_make_i_pos(&info);
719         inode = exfat_build_inode(sb, &info, i_pos);
720         err = PTR_ERR_OR_ZERO(inode);
721         if (err)
722                 goto unlock;
723 
724         i_mode = inode->i_mode;
725         alias = d_find_alias(inode);
726 
727         /*
728          * Checking "alias->d_parent == dentry->d_parent" to make sure
729          * FS is not corrupted (especially double linked dir).
730          */
731         if (alias && alias->d_parent == dentry->d_parent &&
732                         !exfat_d_anon_disconn(alias)) {
733 
734                 /*
735                  * Unhashed alias is able to exist because of revalidate()
736                  * called by lookup_fast. You can easily make this status
737                  * by calling create and lookup concurrently
738                  * In such case, we reuse an alias instead of new dentry
739                  */
740                 if (d_unhashed(alias)) {
741                         WARN_ON(alias->d_name.hash_len !=
742                                 dentry->d_name.hash_len);
743                         exfat_info(sb, "rehashed a dentry(%p) in read lookup",
744                                    alias);
745                         d_drop(dentry);
746                         d_rehash(alias);
747                 } else if (!S_ISDIR(i_mode)) {
748                         /*
749                          * This inode has non anonymous-DCACHE_DISCONNECTED
750                          * dentry. This means, the user did ->lookup() by an
751                          * another name (longname vs 8.3 alias of it) in past.
752                          *
753                          * Switch to new one for reason of locality if possible.
754                          */
755                         d_move(alias, dentry);
756                 }
757                 iput(inode);
758                 mutex_unlock(&EXFAT_SB(sb)->s_lock);
759                 return alias;
760         }
761         dput(alias);
762 out:
763         mutex_unlock(&EXFAT_SB(sb)->s_lock);
764         if (!inode)
765                 exfat_d_version_set(dentry, inode_query_iversion(dir));
766 
767         return d_splice_alias(inode, dentry);
768 unlock:
769         mutex_unlock(&EXFAT_SB(sb)->s_lock);
770         return ERR_PTR(err);
771 }
772 
773 /* remove an entry, BUT don't truncate */
774 static int exfat_unlink(struct inode *dir, struct dentry *dentry)
775 {
776         struct exfat_chain cdir;
777         struct exfat_dentry *ep;
778         struct super_block *sb = dir->i_sb;
779         struct inode *inode = dentry->d_inode;
780         struct exfat_inode_info *ei = EXFAT_I(inode);
781         struct buffer_head *bh;
782         sector_t sector;
783         int num_entries, entry, err = 0;
784 
785         mutex_lock(&EXFAT_SB(sb)->s_lock);
786         exfat_chain_dup(&cdir, &ei->dir);
787         entry = ei->entry;
788         if (ei->dir.dir == DIR_DELETED) {
789                 exfat_err(sb, "abnormal access to deleted dentry");
790                 err = -ENOENT;
791                 goto unlock;
792         }
793 
794         ep = exfat_get_dentry(sb, &cdir, entry, &bh, &sector);
795         if (!ep) {
796                 err = -EIO;
797                 goto unlock;
798         }
799         num_entries = exfat_count_ext_entries(sb, &cdir, entry, ep);
800         if (num_entries < 0) {
801                 err = -EIO;
802                 brelse(bh);
803                 goto unlock;
804         }
805         num_entries++;
806         brelse(bh);
807 
808         exfat_set_volume_dirty(sb);
809         /* update the directory entry */
810         if (exfat_remove_entries(dir, &cdir, entry, 0, num_entries)) {
811                 err = -EIO;
812                 goto unlock;
813         }
814 
815         /* This doesn't modify ei */
816         ei->dir.dir = DIR_DELETED;
817         exfat_clear_volume_dirty(sb);
818 
819         inode_inc_iversion(dir);
820         dir->i_mtime = dir->i_atime = current_time(dir);
821         exfat_truncate_atime(&dir->i_atime);
822         if (IS_DIRSYNC(dir))
823                 exfat_sync_inode(dir);
824         else
825                 mark_inode_dirty(dir);
826 
827         clear_nlink(inode);
828         inode->i_mtime = inode->i_atime = current_time(inode);
829         exfat_truncate_atime(&inode->i_atime);
830         exfat_unhash_inode(inode);
831         exfat_d_version_set(dentry, inode_query_iversion(dir));
832 unlock:
833         mutex_unlock(&EXFAT_SB(sb)->s_lock);
834         return err;
835 }
836 
837 static int exfat_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
838                        struct dentry *dentry, umode_t mode)
839 {
840         struct super_block *sb = dir->i_sb;
841         struct inode *inode;
842         struct exfat_dir_entry info;
843         struct exfat_chain cdir;
844         loff_t i_pos;
845         int err;
846 
847         mutex_lock(&EXFAT_SB(sb)->s_lock);
848         exfat_set_volume_dirty(sb);
849         err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_DIR,
850                 &info);
851         exfat_clear_volume_dirty(sb);
852         if (err)
853                 goto unlock;
854 
855         inode_inc_iversion(dir);
856         dir->i_ctime = dir->i_mtime = current_time(dir);
857         if (IS_DIRSYNC(dir))
858                 exfat_sync_inode(dir);
859         else
860                 mark_inode_dirty(dir);
861         inc_nlink(dir);
862 
863         i_pos = exfat_make_i_pos(&info);
864         inode = exfat_build_inode(sb, &info, i_pos);
865         err = PTR_ERR_OR_ZERO(inode);
866         if (err)
867                 goto unlock;
868 
869         inode_inc_iversion(inode);
870         inode->i_mtime = inode->i_atime = inode->i_ctime =
871                 EXFAT_I(inode)->i_crtime = current_time(inode);
872         exfat_truncate_atime(&inode->i_atime);
873         /* timestamp is already written, so mark_inode_dirty() is unneeded. */
874 
875         d_instantiate(dentry, inode);
876 
877 unlock:
878         mutex_unlock(&EXFAT_SB(sb)->s_lock);
879         return err;
880 }
881 
882 static int exfat_check_dir_empty(struct super_block *sb,
883                 struct exfat_chain *p_dir)
884 {
885         int i, dentries_per_clu;
886         unsigned int type;
887         struct exfat_chain clu;
888         struct exfat_dentry *ep;
889         struct exfat_sb_info *sbi = EXFAT_SB(sb);
890         struct buffer_head *bh;
891 
892         dentries_per_clu = sbi->dentries_per_clu;
893 
894         exfat_chain_dup(&clu, p_dir);
895 
896         while (clu.dir != EXFAT_EOF_CLUSTER) {
897                 for (i = 0; i < dentries_per_clu; i++) {
898                         ep = exfat_get_dentry(sb, &clu, i, &bh, NULL);
899                         if (!ep)
900                                 return -EIO;
901                         type = exfat_get_entry_type(ep);
902                         brelse(bh);
903                         if (type == TYPE_UNUSED)
904                                 return 0;
905 
906                         if (type != TYPE_FILE && type != TYPE_DIR)
907                                 continue;
908 
909                         return -ENOTEMPTY;
910                 }
911 
912                 if (clu.flags == ALLOC_NO_FAT_CHAIN) {
913                         if (--clu.size > 0)
914                                 clu.dir++;
915                         else
916                                 clu.dir = EXFAT_EOF_CLUSTER;
917                 } else {
918                         if (exfat_get_next_cluster(sb, &(clu.dir)))
919                                 return -EIO;
920                 }
921         }
922 
923         return 0;
924 }
925 
926 static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
927 {
928         struct inode *inode = dentry->d_inode;
929         struct exfat_dentry *ep;
930         struct exfat_chain cdir, clu_to_free;
931         struct super_block *sb = inode->i_sb;
932         struct exfat_sb_info *sbi = EXFAT_SB(sb);
933         struct exfat_inode_info *ei = EXFAT_I(inode);
934         struct buffer_head *bh;
935         sector_t sector;
936         int num_entries, entry, err;
937 
938         mutex_lock(&EXFAT_SB(inode->i_sb)->s_lock);
939 
940         exfat_chain_dup(&cdir, &ei->dir);
941         entry = ei->entry;
942 
943         if (ei->dir.dir == DIR_DELETED) {
944                 exfat_err(sb, "abnormal access to deleted dentry");
945                 err = -ENOENT;
946                 goto unlock;
947         }
948 
949         exfat_chain_set(&clu_to_free, ei->start_clu,
950                 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi), ei->flags);
951 
952         err = exfat_check_dir_empty(sb, &clu_to_free);
953         if (err) {
954                 if (err == -EIO)
955                         exfat_err(sb, "failed to exfat_check_dir_empty : err(%d)",
956                                   err);
957                 goto unlock;
958         }
959 
960         ep = exfat_get_dentry(sb, &cdir, entry, &bh, &sector);
961         if (!ep) {
962                 err = -EIO;
963                 goto unlock;
964         }
965 
966         num_entries = exfat_count_ext_entries(sb, &cdir, entry, ep);
967         if (num_entries < 0) {
968                 err = -EIO;
969                 brelse(bh);
970                 goto unlock;
971         }
972         num_entries++;
973         brelse(bh);
974 
975         exfat_set_volume_dirty(sb);
976         err = exfat_remove_entries(dir, &cdir, entry, 0, num_entries);
977         if (err) {
978                 exfat_err(sb, "failed to exfat_remove_entries : err(%d)", err);
979                 goto unlock;
980         }
981         ei->dir.dir = DIR_DELETED;
982         exfat_clear_volume_dirty(sb);
983 
984         inode_inc_iversion(dir);
985         dir->i_mtime = dir->i_atime = current_time(dir);
986         exfat_truncate_atime(&dir->i_atime);
987         if (IS_DIRSYNC(dir))
988                 exfat_sync_inode(dir);
989         else
990                 mark_inode_dirty(dir);
991         drop_nlink(dir);
992 
993         clear_nlink(inode);
994         inode->i_mtime = inode->i_atime = current_time(inode);
995         exfat_truncate_atime(&inode->i_atime);
996         exfat_unhash_inode(inode);
997         exfat_d_version_set(dentry, inode_query_iversion(dir));
998 unlock:
999         mutex_unlock(&EXFAT_SB(inode->i_sb)->s_lock);
1000         return err;
1001 }
1002 
1003 static int exfat_rename_file(struct inode *inode, struct exfat_chain *p_dir,
1004                 int oldentry, struct exfat_uni_name *p_uniname,
1005                 struct exfat_inode_info *ei)
1006 {
1007         int ret, num_old_entries, num_new_entries;
1008         sector_t sector_old, sector_new;
1009         struct exfat_dentry *epold, *epnew;
1010         struct super_block *sb = inode->i_sb;
1011         struct buffer_head *new_bh, *old_bh;
1012         int sync = IS_DIRSYNC(inode);
1013 
1014         epold = exfat_get_dentry(sb, p_dir, oldentry, &old_bh, &sector_old);
1015         if (!epold)
1016                 return -EIO;
1017 
1018         num_old_entries = exfat_count_ext_entries(sb, p_dir, oldentry, epold);
1019         if (num_old_entries < 0)
1020                 return -EIO;
1021         num_old_entries++;
1022 
1023         num_new_entries = exfat_calc_num_entries(p_uniname);
1024         if (num_new_entries < 0)
1025                 return num_new_entries;
1026 
1027         if (num_old_entries < num_new_entries) {
1028                 int newentry;
1029 
1030                 newentry =
1031                         exfat_find_empty_entry(inode, p_dir, num_new_entries);
1032                 if (newentry < 0)
1033                         return newentry; /* -EIO or -ENOSPC */
1034 
1035                 epnew = exfat_get_dentry(sb, p_dir, newentry, &new_bh,
1036                         &sector_new);
1037                 if (!epnew)
1038                         return -EIO;
1039 
1040                 *epnew = *epold;
1041                 if (exfat_get_entry_type(epnew) == TYPE_FILE) {
1042                         epnew->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1043                         ei->attr |= ATTR_ARCHIVE;
1044                 }
1045                 exfat_update_bh(new_bh, sync);
1046                 brelse(old_bh);
1047                 brelse(new_bh);
1048 
1049                 epold = exfat_get_dentry(sb, p_dir, oldentry + 1, &old_bh,
1050                         &sector_old);
1051                 if (!epold)
1052                         return -EIO;
1053                 epnew = exfat_get_dentry(sb, p_dir, newentry + 1, &new_bh,
1054                         &sector_new);
1055                 if (!epnew) {
1056                         brelse(old_bh);
1057                         return -EIO;
1058                 }
1059 
1060                 *epnew = *epold;
1061                 exfat_update_bh(new_bh, sync);
1062                 brelse(old_bh);
1063                 brelse(new_bh);
1064 
1065                 ret = exfat_init_ext_entry(inode, p_dir, newentry,
1066                         num_new_entries, p_uniname);
1067                 if (ret)
1068                         return ret;
1069 
1070                 exfat_remove_entries(inode, p_dir, oldentry, 0,
1071                         num_old_entries);
1072                 ei->entry = newentry;
1073         } else {
1074                 if (exfat_get_entry_type(epold) == TYPE_FILE) {
1075                         epold->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1076                         ei->attr |= ATTR_ARCHIVE;
1077                 }
1078                 exfat_update_bh(old_bh, sync);
1079                 brelse(old_bh);
1080                 ret = exfat_init_ext_entry(inode, p_dir, oldentry,
1081                         num_new_entries, p_uniname);
1082                 if (ret)
1083                         return ret;
1084 
1085                 exfat_remove_entries(inode, p_dir, oldentry, num_new_entries,
1086                         num_old_entries);
1087         }
1088         return 0;
1089 }
1090 
1091 static int exfat_move_file(struct inode *inode, struct exfat_chain *p_olddir,
1092                 int oldentry, struct exfat_chain *p_newdir,
1093                 struct exfat_uni_name *p_uniname, struct exfat_inode_info *ei)
1094 {
1095         int ret, newentry, num_new_entries, num_old_entries;
1096         sector_t sector_mov, sector_new;
1097         struct exfat_dentry *epmov, *epnew;
1098         struct super_block *sb = inode->i_sb;
1099         struct buffer_head *mov_bh, *new_bh;
1100 
1101         epmov = exfat_get_dentry(sb, p_olddir, oldentry, &mov_bh, &sector_mov);
1102         if (!epmov)
1103                 return -EIO;
1104 
1105         num_old_entries = exfat_count_ext_entries(sb, p_olddir, oldentry,
1106                 epmov);
1107         if (num_old_entries < 0)
1108                 return -EIO;
1109         num_old_entries++;
1110 
1111         num_new_entries = exfat_calc_num_entries(p_uniname);
1112         if (num_new_entries < 0)
1113                 return num_new_entries;
1114 
1115         newentry = exfat_find_empty_entry(inode, p_newdir, num_new_entries);
1116         if (newentry < 0)
1117                 return newentry; /* -EIO or -ENOSPC */
1118 
1119         epnew = exfat_get_dentry(sb, p_newdir, newentry, &new_bh, &sector_new);
1120         if (!epnew)
1121                 return -EIO;
1122 
1123         *epnew = *epmov;
1124         if (exfat_get_entry_type(epnew) == TYPE_FILE) {
1125                 epnew->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1126                 ei->attr |= ATTR_ARCHIVE;
1127         }
1128         exfat_update_bh(new_bh, IS_DIRSYNC(inode));
1129         brelse(mov_bh);
1130         brelse(new_bh);
1131 
1132         epmov = exfat_get_dentry(sb, p_olddir, oldentry + 1, &mov_bh,
1133                 &sector_mov);
1134         if (!epmov)
1135                 return -EIO;
1136         epnew = exfat_get_dentry(sb, p_newdir, newentry + 1, &new_bh,
1137                 &sector_new);
1138         if (!epnew) {
1139                 brelse(mov_bh);
1140                 return -EIO;
1141         }
1142 
1143         *epnew = *epmov;
1144         exfat_update_bh(new_bh, IS_DIRSYNC(inode));
1145         brelse(mov_bh);
1146         brelse(new_bh);
1147 
1148         ret = exfat_init_ext_entry(inode, p_newdir, newentry, num_new_entries,
1149                 p_uniname);
1150         if (ret)
1151                 return ret;
1152 
1153         exfat_remove_entries(inode, p_olddir, oldentry, 0, num_old_entries);
1154 
1155         exfat_chain_set(&ei->dir, p_newdir->dir, p_newdir->size,
1156                 p_newdir->flags);
1157 
1158         ei->entry = newentry;
1159         return 0;
1160 }
1161 
1162 static void exfat_update_parent_info(struct exfat_inode_info *ei,
1163                 struct inode *parent_inode)
1164 {
1165         struct exfat_sb_info *sbi = EXFAT_SB(parent_inode->i_sb);
1166         struct exfat_inode_info *parent_ei = EXFAT_I(parent_inode);
1167         loff_t parent_isize = i_size_read(parent_inode);
1168 
1169         /*
1170          * the problem that struct exfat_inode_info caches wrong parent info.
1171          *
1172          * because of flag-mismatch of ei->dir,
1173          * there is abnormal traversing cluster chain.
1174          */
1175         if (unlikely(parent_ei->flags != ei->dir.flags ||
1176                      parent_isize != EXFAT_CLU_TO_B(ei->dir.size, sbi) ||
1177                      parent_ei->start_clu != ei->dir.dir)) {
1178                 exfat_chain_set(&ei->dir, parent_ei->start_clu,
1179                         EXFAT_B_TO_CLU_ROUND_UP(parent_isize, sbi),
1180                         parent_ei->flags);
1181         }
1182 }
1183 
1184 /* rename or move a old file into a new file */
1185 static int __exfat_rename(struct inode *old_parent_inode,
1186                 struct exfat_inode_info *ei, struct inode *new_parent_inode,
1187                 struct dentry *new_dentry)
1188 {
1189         int ret;
1190         int dentry;
1191         struct exfat_chain olddir, newdir;
1192         struct exfat_chain *p_dir = NULL;
1193         struct exfat_uni_name uni_name;
1194         struct exfat_dentry *ep;
1195         struct super_block *sb = old_parent_inode->i_sb;
1196         struct exfat_sb_info *sbi = EXFAT_SB(sb);
1197         const unsigned char *new_path = new_dentry->d_name.name;
1198         struct inode *new_inode = new_dentry->d_inode;
1199         int num_entries;
1200         struct exfat_inode_info *new_ei = NULL;
1201         unsigned int new_entry_type = TYPE_UNUSED;
1202         int new_entry = 0;
1203         struct buffer_head *old_bh, *new_bh = NULL;
1204 
1205         /* check the validity of pointer parameters */
1206         if (new_path == NULL || strlen(new_path) == 0)
1207                 return -EINVAL;
1208 
1209         if (ei->dir.dir == DIR_DELETED) {
1210                 exfat_err(sb, "abnormal access to deleted source dentry");
1211                 return -ENOENT;
1212         }
1213 
1214         exfat_update_parent_info(ei, old_parent_inode);
1215 
1216         exfat_chain_dup(&olddir, &ei->dir);
1217         dentry = ei->entry;
1218 
1219         ep = exfat_get_dentry(sb, &olddir, dentry, &old_bh, NULL);
1220         if (!ep) {
1221                 ret = -EIO;
1222                 goto out;
1223         }
1224         brelse(old_bh);
1225 
1226         /* check whether new dir is existing directory and empty */
1227         if (new_inode) {
1228                 ret = -EIO;
1229                 new_ei = EXFAT_I(new_inode);
1230 
1231                 if (new_ei->dir.dir == DIR_DELETED) {
1232                         exfat_err(sb, "abnormal access to deleted target dentry");
1233                         goto out;
1234                 }
1235 
1236                 exfat_update_parent_info(new_ei, new_parent_inode);
1237 
1238                 p_dir = &(new_ei->dir);
1239                 new_entry = new_ei->entry;
1240                 ep = exfat_get_dentry(sb, p_dir, new_entry, &new_bh, NULL);
1241                 if (!ep)
1242                         goto out;
1243 
1244                 new_entry_type = exfat_get_entry_type(ep);
1245                 brelse(new_bh);
1246 
1247                 /* if new_inode exists, update ei */
1248                 if (new_entry_type == TYPE_DIR) {
1249                         struct exfat_chain new_clu;
1250 
1251                         new_clu.dir = new_ei->start_clu;
1252                         new_clu.size =
1253                                 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),
1254                                 sbi);
1255                         new_clu.flags = new_ei->flags;
1256 
1257                         ret = exfat_check_dir_empty(sb, &new_clu);
1258                         if (ret)
1259                                 goto out;
1260                 }
1261         }
1262 
1263         /* check the validity of directory name in the given new pathname */
1264         ret = exfat_resolve_path(new_parent_inode, new_path, &newdir,
1265                         &uni_name);
1266         if (ret)
1267                 goto out;
1268 
1269         exfat_set_volume_dirty(sb);
1270 
1271         if (olddir.dir == newdir.dir)
1272                 ret = exfat_rename_file(new_parent_inode, &olddir, dentry,
1273                                 &uni_name, ei);
1274         else
1275                 ret = exfat_move_file(new_parent_inode, &olddir, dentry,
1276                                 &newdir, &uni_name, ei);
1277 
1278         if (!ret && new_inode) {
1279                 /* delete entries of new_dir */
1280                 ep = exfat_get_dentry(sb, p_dir, new_entry, &new_bh, NULL);
1281                 if (!ep) {
1282                         ret = -EIO;
1283                         goto del_out;
1284                 }
1285 
1286                 num_entries = exfat_count_ext_entries(sb, p_dir, new_entry, ep);
1287                 if (num_entries < 0) {
1288                         ret = -EIO;
1289                         goto del_out;
1290                 }
1291                 brelse(new_bh);
1292 
1293                 if (exfat_remove_entries(new_inode, p_dir, new_entry, 0,
1294                                 num_entries + 1)) {
1295                         ret = -EIO;
1296                         goto del_out;
1297                 }
1298 
1299                 /* Free the clusters if new_inode is a dir(as if exfat_rmdir) */
1300                 if (new_entry_type == TYPE_DIR) {
1301                         /* new_ei, new_clu_to_free */
1302                         struct exfat_chain new_clu_to_free;
1303 
1304                         exfat_chain_set(&new_clu_to_free, new_ei->start_clu,
1305                                 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),
1306                                 sbi), new_ei->flags);
1307 
1308                         if (exfat_free_cluster(new_inode, &new_clu_to_free)) {
1309                                 /* just set I/O error only */
1310                                 ret = -EIO;
1311                         }
1312 
1313                         i_size_write(new_inode, 0);
1314                         new_ei->start_clu = EXFAT_EOF_CLUSTER;
1315                         new_ei->flags = ALLOC_NO_FAT_CHAIN;
1316                 }
1317 del_out:
1318                 /* Update new_inode ei
1319                  * Prevent syncing removed new_inode
1320                  * (new_ei is already initialized above code ("if (new_inode)")
1321                  */
1322                 new_ei->dir.dir = DIR_DELETED;
1323         }
1324         exfat_clear_volume_dirty(sb);
1325 out:
1326         return ret;
1327 }
1328 
1329 static int exfat_rename(struct user_namespace *mnt_userns,
1330                         struct inode *old_dir, struct dentry *old_dentry,
1331                         struct inode *new_dir, struct dentry *new_dentry,
1332                         unsigned int flags)
1333 {
1334         struct inode *old_inode, *new_inode;
1335         struct super_block *sb = old_dir->i_sb;
1336         loff_t i_pos;
1337         int err;
1338 
1339         /*
1340          * The VFS already checks for existence, so for local filesystems
1341          * the RENAME_NOREPLACE implementation is equivalent to plain rename.
1342          * Don't support any other flags
1343          */
1344         if (flags & ~RENAME_NOREPLACE)
1345                 return -EINVAL;
1346 
1347         mutex_lock(&EXFAT_SB(sb)->s_lock);
1348         old_inode = old_dentry->d_inode;
1349         new_inode = new_dentry->d_inode;
1350 
1351         err = __exfat_rename(old_dir, EXFAT_I(old_inode), new_dir, new_dentry);
1352         if (err)
1353                 goto unlock;
1354 
1355         inode_inc_iversion(new_dir);
1356         new_dir->i_ctime = new_dir->i_mtime = new_dir->i_atime =
1357                 EXFAT_I(new_dir)->i_crtime = current_time(new_dir);
1358         exfat_truncate_atime(&new_dir->i_atime);
1359         if (IS_DIRSYNC(new_dir))
1360                 exfat_sync_inode(new_dir);
1361         else
1362                 mark_inode_dirty(new_dir);
1363 
1364         i_pos = ((loff_t)EXFAT_I(old_inode)->dir.dir << 32) |
1365                 (EXFAT_I(old_inode)->entry & 0xffffffff);
1366         exfat_unhash_inode(old_inode);
1367         exfat_hash_inode(old_inode, i_pos);
1368         if (IS_DIRSYNC(new_dir))
1369                 exfat_sync_inode(old_inode);
1370         else
1371                 mark_inode_dirty(old_inode);
1372 
1373         if (S_ISDIR(old_inode->i_mode) && old_dir != new_dir) {
1374                 drop_nlink(old_dir);
1375                 if (!new_inode)
1376                         inc_nlink(new_dir);
1377         }
1378 
1379         inode_inc_iversion(old_dir);
1380         old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
1381         if (IS_DIRSYNC(old_dir))
1382                 exfat_sync_inode(old_dir);
1383         else
1384                 mark_inode_dirty(old_dir);
1385 
1386         if (new_inode) {
1387                 exfat_unhash_inode(new_inode);
1388 
1389                 /* skip drop_nlink if new_inode already has been dropped */
1390                 if (new_inode->i_nlink) {
1391                         drop_nlink(new_inode);
1392                         if (S_ISDIR(new_inode->i_mode))
1393                                 drop_nlink(new_inode);
1394                 } else {
1395                         exfat_warn(sb, "abnormal access to an inode dropped");
1396                         WARN_ON(new_inode->i_nlink == 0);
1397                 }
1398                 new_inode->i_ctime = EXFAT_I(new_inode)->i_crtime =
1399                         current_time(new_inode);
1400         }
1401 
1402 unlock:
1403         mutex_unlock(&EXFAT_SB(sb)->s_lock);
1404         return err;
1405 }
1406 
1407 const struct inode_operations exfat_dir_inode_operations = {
1408         .create         = exfat_create,
1409         .lookup         = exfat_lookup,
1410         .unlink         = exfat_unlink,
1411         .mkdir          = exfat_mkdir,
1412         .rmdir          = exfat_rmdir,
1413         .rename         = exfat_rename,
1414         .setattr        = exfat_setattr,
1415         .getattr        = exfat_getattr,
1416 };
1417 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp