1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2021 LG Electronics.
5 * Author(s): Hyunchul Lee <hyc.lee@gmail.com>
14 #include "exfat_ondisk.h"
17 #include "exfat_dir.h"
19 static struct path_resolve_ctx path_resolve_ctx;
21 #define fsck_err(parent, inode, fmt, ...) \
23 exfat_resolve_path_parent(&path_resolve_ctx, \
25 exfat_err("ERROR: %s: " fmt, \
26 path_resolve_ctx.local_path, \
30 static ssize_t write_block(struct exfat_de_iter *iter, unsigned int block)
33 struct exfat *exfat = iter->exfat;
34 struct buffer_desc *desc;
37 desc = &iter->buffer_desc[block & 0x01];
39 for (i = 0; i < iter->read_size / iter->write_size; i++) {
41 device_offset = exfat_c2o(exfat, desc->p_clus) +
43 if (exfat_write(exfat->blk_dev->dev_fd,
44 desc->buffer + i * iter->write_size,
46 device_offset + i * iter->write_size)
47 != (ssize_t)iter->write_size)
55 static int read_ahead_first_blocks(struct exfat_de_iter *iter)
57 #ifdef POSIX_FADV_WILLNEED
58 struct exfat *exfat = iter->exfat;
62 clus_count = iter->parent->size / exfat->clus_size;
65 iter->ra_begin_offset = 0;
66 iter->ra_next_clus = 1;
67 size = exfat->clus_size;
69 iter->ra_begin_offset = 0;
70 iter->ra_next_clus = 0;
71 size = iter->ra_partial_size;
73 return posix_fadvise(exfat->blk_dev->dev_fd,
74 exfat_c2o(exfat, iter->parent->first_clus), size,
82 * read the next fragment in advance, and assume the fragment
83 * which covers @clus is already read.
85 static int read_ahead_next_blocks(struct exfat_de_iter *iter,
86 clus_t clus, unsigned int offset, clus_t p_clus)
88 #ifdef POSIX_FADV_WILLNEED
89 struct exfat *exfat = iter->exfat;
91 clus_t clus_count, ra_clus, ra_p_clus;
95 clus_count = iter->parent->size / exfat->clus_size;
96 if (clus + 1 < clus_count) {
98 if (ra_clus == iter->ra_next_clus &&
99 offset >= iter->ra_begin_offset) {
100 ret = exfat_get_inode_next_clus(exfat, iter->parent,
105 if (ra_p_clus == EXFAT_EOF_CLUSTER)
108 device_offset = exfat_c2o(exfat, ra_p_clus);
109 size = ra_clus + 1 < clus_count ?
110 exfat->clus_size : iter->ra_partial_size;
111 ret = posix_fadvise(exfat->blk_dev->dev_fd,
113 POSIX_FADV_WILLNEED);
114 iter->ra_next_clus = ra_clus + 1;
115 iter->ra_begin_offset = 0;
118 if (offset >= iter->ra_begin_offset &&
119 offset + iter->ra_partial_size <=
121 device_offset = exfat_c2o(exfat, p_clus) +
122 offset + iter->ra_partial_size;
123 ret = posix_fadvise(exfat->blk_dev->dev_fd,
124 device_offset, iter->ra_partial_size,
125 POSIX_FADV_WILLNEED);
126 iter->ra_begin_offset =
127 offset + iter->ra_partial_size;
137 static int read_ahead_next_dir_blocks(struct exfat_de_iter *iter)
139 #ifdef POSIX_FADV_WILLNEED
140 struct exfat *exfat = iter->exfat;
141 struct list_head *current;
142 struct exfat_inode *next_inode;
145 if (list_empty(&exfat->dir_list))
148 current = exfat->dir_list.next;
149 if (iter->parent == list_entry(current, struct exfat_inode, list) &&
150 current->next != &exfat->dir_list) {
151 next_inode = list_entry(current->next, struct exfat_inode,
153 offset = exfat_c2o(exfat, next_inode->first_clus);
154 return posix_fadvise(exfat->blk_dev->dev_fd, offset,
155 iter->ra_partial_size,
156 POSIX_FADV_WILLNEED);
165 static ssize_t read_block(struct exfat_de_iter *iter, unsigned int block)
167 struct exfat *exfat = iter->exfat;
168 struct buffer_desc *desc, *prev_desc;
172 desc = &iter->buffer_desc[block & 0x01];
174 desc->p_clus = iter->parent->first_clus;
178 /* if the buffer already contains dirty dentries, write it */
179 if (write_block(iter, block))
183 if (block > iter->parent->size / iter->read_size)
186 prev_desc = &iter->buffer_desc[(block-1) & 0x01];
187 if (prev_desc->offset + 2 * iter->read_size <=
189 desc->p_clus = prev_desc->p_clus;
190 desc->offset = prev_desc->offset + iter->read_size;
192 ret = exfat_get_inode_next_clus(exfat, iter->parent,
193 prev_desc->p_clus, &desc->p_clus);
197 else if (desc->p_clus == EXFAT_EOF_CLUSTER)
202 device_offset = exfat_c2o(exfat, desc->p_clus) + desc->offset;
203 ret = exfat_read(exfat->blk_dev->dev_fd, desc->buffer,
204 iter->read_size, device_offset);
209 * if a buffer is filled with dentries, read blocks ahead of time,
210 * otherwise read blocks of the next directory in advance.
212 if (desc->buffer[iter->read_size - 32] != EXFAT_LAST)
213 read_ahead_next_blocks(iter,
214 (block * iter->read_size) / exfat->clus_size,
215 (block * iter->read_size) % exfat->clus_size,
218 read_ahead_next_dir_blocks(iter);
222 int exfat_de_iter_init(struct exfat_de_iter *iter, struct exfat *exfat,
223 struct exfat_inode *dir, struct buffer_desc *bd)
227 iter->write_size = exfat->sect_size;
228 iter->read_size = exfat->clus_size <= 4*KB ? exfat->clus_size : 4*KB;
229 if (exfat->clus_size <= 32 * KB)
230 iter->ra_partial_size = MAX(4 * KB, exfat->clus_size / 2);
232 iter->ra_partial_size = exfat->clus_size / 4;
233 iter->ra_partial_size = MIN(iter->ra_partial_size, 8 * KB);
235 iter->buffer_desc = bd;
237 iter->de_file_offset = 0;
238 iter->next_read_offset = iter->read_size;
239 iter->max_skip_dentries = 0;
240 iter->invalid_name_num = 0;
242 if (iter->parent->size == 0)
245 read_ahead_first_blocks(iter);
246 if (read_block(iter, 0) != (ssize_t)iter->read_size) {
247 exfat_err("failed to read directory entries.\n");
254 int exfat_de_iter_get(struct exfat_de_iter *iter,
255 int ith, struct exfat_dentry **dentry)
257 off_t next_de_file_offset;
261 next_de_file_offset = iter->de_file_offset +
262 ith * sizeof(struct exfat_dentry);
263 block = (unsigned int)(next_de_file_offset / iter->read_size);
265 if (next_de_file_offset + sizeof(struct exfat_dentry) >
268 /* the dentry must be in current, or next block which will be read */
269 if (block > iter->de_file_offset / iter->read_size + 1)
272 /* read next cluster if needed */
273 if (next_de_file_offset >= iter->next_read_offset) {
274 ret = read_block(iter, block);
275 if (ret != (ssize_t)iter->read_size)
277 iter->next_read_offset += iter->read_size;
280 if (ith + 1 > iter->max_skip_dentries)
281 iter->max_skip_dentries = ith + 1;
283 *dentry = (struct exfat_dentry *)
284 (iter->buffer_desc[block & 0x01].buffer +
285 next_de_file_offset % iter->read_size);
289 int exfat_de_iter_get_dirty(struct exfat_de_iter *iter,
290 int ith, struct exfat_dentry **dentry)
292 off_t next_file_offset;
296 ret = exfat_de_iter_get(iter, ith, dentry);
298 next_file_offset = iter->de_file_offset +
299 ith * sizeof(struct exfat_dentry);
300 block = (unsigned int)(next_file_offset / iter->read_size);
301 sect_idx = (int)((next_file_offset % iter->read_size) /
303 iter->buffer_desc[block & 0x01].dirty[sect_idx] = 1;
309 int exfat_de_iter_flush(struct exfat_de_iter *iter)
311 if (write_block(iter, 0) || write_block(iter, 1))
316 int exfat_de_iter_advance(struct exfat_de_iter *iter, int skip_dentries)
318 if (skip_dentries > iter->max_skip_dentries)
321 iter->max_skip_dentries = 0;
322 iter->de_file_offset = iter->de_file_offset +
323 skip_dentries * sizeof(struct exfat_dentry);
327 off_t exfat_de_iter_device_offset(struct exfat_de_iter *iter)
329 struct buffer_desc *bd;
332 if ((uint64_t)iter->de_file_offset >= iter->parent->size)
335 block = iter->de_file_offset / iter->read_size;
336 bd = &iter->buffer_desc[block & 0x01];
337 return exfat_c2o(iter->exfat, bd->p_clus) + bd->offset +
338 iter->de_file_offset % iter->read_size;
341 off_t exfat_de_iter_file_offset(struct exfat_de_iter *iter)
343 return iter->de_file_offset;
347 * try to find the dentry set matched with @filter. this function
348 * doesn't verify the dentry set.
350 * if found, return 0. if not found, return EOF. otherwise return errno.
352 int exfat_lookup_dentry_set(struct exfat *exfat, struct exfat_inode *parent,
353 struct exfat_lookup_filter *filter)
355 struct buffer_desc *bd = NULL;
356 struct exfat_dentry *dentry = NULL;
357 off_t free_file_offset = 0, free_dev_offset = 0;
358 struct exfat_de_iter de_iter;
359 int dentry_count, empty_dentry_count = 0;
362 bd = exfat_alloc_buffer(2, exfat->clus_size, exfat->sect_size);
366 retval = exfat_de_iter_init(&de_iter, exfat, parent, bd);
367 if (retval == EOF || retval)
370 filter->out.dentry_set = NULL;
372 retval = exfat_de_iter_get(&de_iter, 0, &dentry);
376 fsck_err(parent->parent, parent,
377 "failed to get a dentry. %d\n", retval);
381 if (!IS_EXFAT_DELETED(dentry->type)) {
382 if (filter->in.dentry_count == 0 ||
383 empty_dentry_count < filter->in.dentry_count)
384 empty_dentry_count = 0;
388 if (dentry->type == filter->in.type) {
390 if (filter->in.filter)
391 retval = filter->in.filter(&de_iter,
396 struct exfat_dentry *d;
399 filter->out.dentry_set = calloc(dentry_count,
400 sizeof(struct exfat_dentry));
401 if (!filter->out.dentry_set) {
405 for (i = 0; i < dentry_count; i++) {
406 exfat_de_iter_get(&de_iter, i, &d);
407 memcpy(filter->out.dentry_set + i, d,
408 sizeof(struct exfat_dentry));
410 filter->out.dentry_count = dentry_count;
412 } else if (retval < 0) {
415 } else if (IS_EXFAT_DELETED(dentry->type)) {
416 if (empty_dentry_count == 0) {
418 exfat_de_iter_file_offset(&de_iter);
420 exfat_de_iter_device_offset(&de_iter);
423 if (filter->in.dentry_count == 0 ||
424 empty_dentry_count < filter->in.dentry_count)
425 empty_dentry_count++;
428 exfat_de_iter_advance(&de_iter, dentry_count);
433 filter->out.file_offset =
434 exfat_de_iter_file_offset(&de_iter);
435 filter->out.dev_offset =
436 exfat_de_iter_device_offset(&de_iter);
437 } else if (retval == EOF && empty_dentry_count) {
438 filter->out.file_offset = free_file_offset;
439 filter->out.dev_offset = free_dev_offset;
441 filter->out.file_offset = exfat_de_iter_file_offset(&de_iter);
442 filter->out.dev_offset = EOF;
445 exfat_free_buffer(bd, 2);
449 static int filter_lookup_file(struct exfat_de_iter *de_iter,
450 void *param, int *dentry_count)
452 struct exfat_dentry *file_de, *stream_de, *name_de;
454 int retval, name_len;
457 retval = exfat_de_iter_get(de_iter, 0, &file_de);
458 if (retval || file_de->type != EXFAT_FILE)
461 retval = exfat_de_iter_get(de_iter, 1, &stream_de);
462 if (retval || stream_de->type != EXFAT_STREAM)
465 name = (__le16 *)param;
466 name_len = (int)exfat_utf16_len(name, PATH_MAX);
468 if (file_de->dentry.file.num_ext <
469 1 + (name_len + ENTRY_NAME_MAX - 1) / ENTRY_NAME_MAX)
472 for (i = 2; i <= file_de->dentry.file.num_ext && name_len > 0; i++) {
475 retval = exfat_de_iter_get(de_iter, i, &name_de);
476 if (retval || name_de->type != EXFAT_NAME)
479 len = MIN(name_len + 1, ENTRY_NAME_MAX);
480 if (memcmp(name_de->dentry.name.unicode_0_14,
492 int exfat_lookup_file_by_utf16name(struct exfat *exfat,
493 struct exfat_inode *parent,
495 struct exfat_lookup_filter *filter_out)
499 filter_out->in.type = EXFAT_FILE;
500 filter_out->in.filter = filter_lookup_file;
501 filter_out->in.param = utf16_name;
502 filter_out->in.dentry_count = 0;
504 retval = exfat_lookup_dentry_set(exfat, parent, filter_out);
511 int exfat_lookup_file(struct exfat *exfat, struct exfat_inode *parent,
512 const char *name, struct exfat_lookup_filter *filter_out)
515 __le16 utf16_name[PATH_MAX + 2] = {0, };
517 retval = (int)exfat_utf16_enc(name, utf16_name, sizeof(utf16_name));
521 return exfat_lookup_file_by_utf16name(exfat, parent, utf16_name,
525 void exfat_calc_dentry_checksum(struct exfat_dentry *dentry,
526 uint16_t *checksum, bool primary)
531 bytes = (uint8_t *)dentry;
533 /* use += to avoid promotion to int; UBSan complaints about signed overflow */
534 *checksum = (*checksum << 15) | (*checksum >> 1);
535 *checksum += bytes[0];
536 *checksum = (*checksum << 15) | (*checksum >> 1);
537 *checksum += bytes[1];
540 for (; i < sizeof(*dentry); i++) {
541 *checksum = (*checksum << 15) | (*checksum >> 1);
542 *checksum += bytes[i];
546 static uint16_t calc_dentry_set_checksum(struct exfat_dentry *dset, int dcount)
551 if (dcount < MIN_FILE_DENTRIES)
555 exfat_calc_dentry_checksum(&dset[0], &checksum, true);
556 for (i = 1; i < dcount; i++)
557 exfat_calc_dentry_checksum(&dset[i], &checksum, false);
561 uint16_t exfat_calc_name_hash(struct exfat *exfat,
562 __le16 *name, int len)
568 for (i = 0; i < len; i++) {
569 ch = exfat->upcase_table[le16_to_cpu(name[i])];
570 ch = cpu_to_le16(ch);
572 /* use += to avoid promotion to int; UBSan complaints about signed overflow */
573 chksum = (chksum << 15) | (chksum >> 1);
575 chksum = (chksum << 15) | (chksum >> 1);
581 static void unix_time_to_exfat_time(time_t unix_time, __u8 *tz, __le16 *date,
582 __le16 *time, __u8 *time_ms)
587 gmtime_r(&unix_time, &tm);
588 d = ((tm.tm_year - 80) << 9) | ((tm.tm_mon + 1) << 5) | tm.tm_mday;
589 t = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec >> 1);
592 *date = cpu_to_le16(d);
593 *time = cpu_to_le16(t);
595 *time_ms = (tm.tm_sec & 1) * 100;
598 int exfat_build_file_dentry_set(struct exfat *exfat, const char *name,
599 unsigned short attr, struct exfat_dentry **dentry_set,
602 struct exfat_dentry *dset;
603 __le16 utf16_name[PATH_MAX + 2];
605 int dcount, name_len, i;
606 __le16 e_date, e_time;
609 memset(utf16_name, 0, sizeof(utf16_name));
610 retval = exfat_utf16_enc(name, utf16_name, sizeof(utf16_name));
614 name_len = retval / 2;
615 dcount = 2 + DIV_ROUND_UP(name_len, ENTRY_NAME_MAX);
616 dset = calloc(1, dcount * DENTRY_SIZE);
620 dset[0].type = EXFAT_FILE;
621 dset[0].dentry.file.num_ext = dcount - 1;
622 dset[0].dentry.file.attr = cpu_to_le16(attr);
624 unix_time_to_exfat_time(time(NULL), &tz,
625 &e_date, &e_time, &e_time_ms);
627 dset[0].dentry.file.create_date = e_date;
628 dset[0].dentry.file.create_time = e_time;
629 dset[0].dentry.file.create_time_ms = e_time_ms;
630 dset[0].dentry.file.create_tz = tz;
632 dset[0].dentry.file.modify_date = e_date;
633 dset[0].dentry.file.modify_time = e_time;
634 dset[0].dentry.file.modify_time_ms = e_time_ms;
635 dset[0].dentry.file.modify_tz = tz;
637 dset[0].dentry.file.access_date = e_date;
638 dset[0].dentry.file.access_time = e_time;
639 dset[0].dentry.file.access_tz = tz;
641 dset[1].type = EXFAT_STREAM;
642 dset[1].dentry.stream.flags = 0x01;
643 dset[1].dentry.stream.name_len = (__u8)name_len;
644 dset[1].dentry.stream.name_hash =
645 cpu_to_le16(exfat_calc_name_hash(exfat, utf16_name, name_len));
647 for (i = 2; i < dcount; i++) {
648 dset[i].type = EXFAT_NAME;
649 memcpy(dset[i].dentry.name.unicode_0_14,
650 utf16_name + (i - 2) * ENTRY_NAME_MAX,
654 dset[0].dentry.file.checksum =
655 cpu_to_le16(calc_dentry_set_checksum(dset, dcount));
658 *dentry_count = dcount;
662 int exfat_update_file_dentry_set(struct exfat *exfat,
663 struct exfat_dentry *dset, int dcount,
665 clus_t start_clu, clus_t ccount)
668 __le16 utf16_name[PATH_MAX + 2];
670 if (dset[0].type != EXFAT_FILE || dcount < MIN_FILE_DENTRIES)
674 name_len = (int)exfat_utf16_enc(name,
675 utf16_name, sizeof(utf16_name));
680 if (dcount != 2 + DIV_ROUND_UP(name_len, ENTRY_NAME_MAX))
683 dset[1].dentry.stream.name_len = (__u8)name_len;
684 dset[1].dentry.stream.name_hash =
685 exfat_calc_name_hash(exfat, utf16_name, name_len);
687 for (i = 2; i < dcount; i++) {
688 dset[i].type = EXFAT_NAME;
689 memcpy(dset[i].dentry.name.unicode_0_14,
690 utf16_name + (i - 2) * ENTRY_NAME_MAX,
695 dset[1].dentry.stream.valid_size = cpu_to_le64(ccount * exfat->clus_size);
696 dset[1].dentry.stream.size = cpu_to_le64(ccount * exfat->clus_size);
698 dset[1].dentry.stream.start_clu = cpu_to_le32(start_clu);
700 dset[0].dentry.file.checksum =
701 cpu_to_le16(calc_dentry_set_checksum(dset, dcount));
705 static int find_free_cluster(struct exfat *exfat,
706 clus_t start, clus_t *new_clu)
708 clus_t end = le32_to_cpu(exfat->bs->bsx.clu_count) +
711 if (!exfat_heap_clus(exfat, start))
714 while (start < end) {
715 if (exfat_bitmap_find_zero(exfat, exfat->alloc_bitmap,
718 if (!exfat_bitmap_get(exfat->disk_bitmap, *new_clu))
720 start = *new_clu + 1;
724 start = EXFAT_FIRST_CLUSTER;
725 while (start < end) {
726 if (exfat_bitmap_find_zero(exfat, exfat->alloc_bitmap,
729 if (!exfat_bitmap_get(exfat->disk_bitmap, *new_clu))
731 start = *new_clu + 1;
735 *new_clu = EXFAT_EOF_CLUSTER;
739 static int exfat_map_cluster(struct exfat *exfat, struct exfat_inode *inode,
740 off_t file_off, clus_t *mapped_clu)
742 clus_t clu, next, count, last_count;
744 if (!exfat_heap_clus(exfat, inode->first_clus))
747 clu = inode->first_clus;
748 next = EXFAT_EOF_CLUSTER;
751 last_count = DIV_ROUND_UP(inode->size, exfat->clus_size);
753 last_count = file_off / exfat->clus_size + 1;
756 if (count * exfat->clus_size > inode->size)
759 if (count == last_count) {
764 if (exfat_get_inode_next_clus(exfat, inode, clu, &next))
767 if (!exfat_heap_clus(exfat, clu))
776 static int exfat_write_dentry_set(struct exfat *exfat,
777 struct exfat_dentry *dset, int dcount,
778 off_t dev_off, off_t *next_dev_off)
781 unsigned int clus_off, dent_len, first_half_len, sec_half_len;
782 off_t first_half_off, sec_half_off = 0;
784 if (exfat_o2c(exfat, dev_off, &clus, &clus_off))
787 dent_len = dcount * DENTRY_SIZE;
788 first_half_len = MIN(dent_len, exfat->clus_size - clus_off);
789 sec_half_len = dent_len - first_half_len;
791 first_half_off = dev_off;
795 if (exfat_get_next_clus(exfat, clus, &next_clus))
797 if (!exfat_heap_clus(exfat, next_clus))
799 sec_half_off = exfat_c2o(exfat, next_clus);
802 if (exfat_write(exfat->blk_dev->dev_fd, dset, first_half_len,
803 first_half_off) != (ssize_t)first_half_len)
807 dset = (struct exfat_dentry *)((char *)dset + first_half_len);
808 if (exfat_write(exfat->blk_dev->dev_fd, dset, sec_half_len,
809 sec_half_off) != (ssize_t)sec_half_len)
815 *next_dev_off = sec_half_off + sec_half_len;
817 *next_dev_off = first_half_off + first_half_len;
822 static int exfat_alloc_cluster(struct exfat *exfat, struct exfat_inode *inode,
827 bool need_dset = inode != exfat->root;
829 if ((need_dset && !inode->dentry_set) || inode->is_contiguous)
832 err = find_free_cluster(exfat, exfat->start_clu, new_clu);
834 exfat->start_clu = EXFAT_FIRST_CLUSTER;
835 exfat_err("failed to find an free cluster\n");
838 exfat->start_clu = *new_clu;
840 if (exfat_set_fat(exfat, *new_clu, EXFAT_EOF_CLUSTER))
843 /* zero out the new cluster */
844 if (exfat_write(exfat->blk_dev->dev_fd, exfat->zero_cluster,
845 exfat->clus_size, exfat_c2o(exfat, *new_clu)) !=
846 (ssize_t)exfat->clus_size) {
847 exfat_err("failed to fill new cluster with zeroes\n");
852 err = exfat_map_cluster(exfat, inode, EOF, &last_clu);
854 exfat_err("failed to get the last cluster\n");
858 if (exfat_set_fat(exfat, last_clu, *new_clu))
862 err = exfat_update_file_dentry_set(exfat,
866 DIV_ROUND_UP(inode->size,
867 exfat->clus_size) + 1);
873 err = exfat_update_file_dentry_set(exfat,
882 if (need_dset && exfat_write_dentry_set(exfat, inode->dentry_set,
884 inode->dev_offset, NULL))
887 exfat_bitmap_set(exfat->alloc_bitmap, *new_clu);
888 if (inode->size == 0)
889 inode->first_clus = *new_clu;
890 inode->size += exfat->clus_size;
894 int exfat_add_dentry_set(struct exfat *exfat, struct exfat_dentry_loc *loc,
895 struct exfat_dentry *dset, int dcount,
898 struct exfat_inode *parent = loc->parent;
899 off_t dev_off, next_dev_off;
901 if (parent->is_contiguous ||
902 (uint64_t)loc->file_offset > parent->size ||
903 (unsigned int)dcount * DENTRY_SIZE > exfat->clus_size)
906 dev_off = loc->dev_offset;
907 if ((uint64_t)loc->file_offset + dcount * DENTRY_SIZE > parent->size) {
910 if (exfat_alloc_cluster(exfat, parent, &new_clus))
912 if ((uint64_t)loc->file_offset == parent->size - exfat->clus_size)
913 dev_off = exfat_c2o(exfat, new_clus);
916 if (exfat_write_dentry_set(exfat, dset, dcount, dev_off, &next_dev_off))
920 loc->file_offset += dcount * DENTRY_SIZE;
921 loc->dev_offset = next_dev_off;
926 int exfat_create_file(struct exfat *exfat, struct exfat_inode *parent,
927 const char *name, unsigned short attr)
929 struct exfat_dentry *dset;
931 struct exfat_lookup_filter filter;
932 struct exfat_dentry_loc loc;
934 err = exfat_lookup_file(exfat, parent, name, &filter);
936 dset = filter.out.dentry_set;
937 dcount = filter.out.dentry_count;
938 if ((le16_to_cpu(dset->dentry.file.attr) & attr) != attr)
943 err = exfat_build_file_dentry_set(exfat, name, attr,
949 loc.file_offset = filter.out.file_offset;
950 loc.dev_offset = filter.out.dev_offset;
951 err = exfat_add_dentry_set(exfat, &loc, dset, dcount, false);