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