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 inline struct buffer_desc *exfat_de_iter_get_buffer(
31 struct exfat_de_iter *iter, unsigned int block)
33 return &iter->buffer_desc[block % iter->exfat->buffer_count];
36 static ssize_t write_block(struct exfat_de_iter *iter, unsigned int block)
39 struct exfat *exfat = iter->exfat;
40 struct buffer_desc *desc;
43 desc = exfat_de_iter_get_buffer(iter, block);
45 for (i = 0; i < iter->read_size / iter->write_size; i++) {
46 if (BITMAP_GET(desc->dirty, i)) {
47 device_offset = exfat_c2o(exfat, desc->p_clus) +
49 if (exfat_write(exfat->blk_dev->dev_fd,
50 desc->buffer + i * iter->write_size,
52 device_offset + i * iter->write_size)
53 != (ssize_t)iter->write_size)
55 BITMAP_CLEAR(desc->dirty, i);
61 static int read_ahead_first_blocks(struct exfat_de_iter *iter)
63 #ifdef POSIX_FADV_WILLNEED
64 struct exfat *exfat = iter->exfat;
68 clus_count = iter->parent->size / exfat->clus_size;
71 iter->ra_begin_offset = 0;
72 iter->ra_next_clus = 1;
73 size = exfat->clus_size;
75 iter->ra_begin_offset = 0;
76 iter->ra_next_clus = 0;
77 size = iter->ra_partial_size;
79 return posix_fadvise(exfat->blk_dev->dev_fd,
80 exfat_c2o(exfat, iter->parent->first_clus), size,
88 * read the next fragment in advance, and assume the fragment
89 * which covers @clus is already read.
91 static int read_ahead_next_blocks(struct exfat_de_iter *iter,
92 clus_t clus, unsigned int offset, clus_t p_clus)
94 #ifdef POSIX_FADV_WILLNEED
95 struct exfat *exfat = iter->exfat;
97 clus_t clus_count, ra_clus, ra_p_clus;
101 clus_count = iter->parent->size / exfat->clus_size;
102 if (clus + 1 < clus_count) {
104 if (ra_clus == iter->ra_next_clus &&
105 offset >= iter->ra_begin_offset) {
106 ret = exfat_get_inode_next_clus(exfat, iter->parent,
111 if (ra_p_clus == EXFAT_EOF_CLUSTER)
114 device_offset = exfat_c2o(exfat, ra_p_clus);
115 size = ra_clus + 1 < clus_count ?
116 exfat->clus_size : iter->ra_partial_size;
117 ret = posix_fadvise(exfat->blk_dev->dev_fd,
119 POSIX_FADV_WILLNEED);
120 iter->ra_next_clus = ra_clus + 1;
121 iter->ra_begin_offset = 0;
124 if (offset >= iter->ra_begin_offset &&
125 offset + iter->ra_partial_size <=
127 device_offset = exfat_c2o(exfat, p_clus) +
128 offset + iter->ra_partial_size;
129 ret = posix_fadvise(exfat->blk_dev->dev_fd,
130 device_offset, iter->ra_partial_size,
131 POSIX_FADV_WILLNEED);
132 iter->ra_begin_offset =
133 offset + iter->ra_partial_size;
143 static int read_ahead_next_dir_blocks(struct exfat_de_iter *iter)
145 #ifdef POSIX_FADV_WILLNEED
146 struct exfat *exfat = iter->exfat;
147 struct list_head *current;
148 struct exfat_inode *next_inode;
151 if (list_empty(&exfat->dir_list))
154 current = exfat->dir_list.next;
155 if (iter->parent == list_entry(current, struct exfat_inode, list) &&
156 current->next != &exfat->dir_list) {
157 next_inode = list_entry(current->next, struct exfat_inode,
159 offset = exfat_c2o(exfat, next_inode->first_clus);
160 return posix_fadvise(exfat->blk_dev->dev_fd, offset,
161 iter->ra_partial_size,
162 POSIX_FADV_WILLNEED);
171 static ssize_t read_block(struct exfat_de_iter *iter, unsigned int block)
173 struct exfat *exfat = iter->exfat;
174 struct buffer_desc *desc, *prev_desc;
178 desc = exfat_de_iter_get_buffer(iter, block);
180 desc->p_clus = iter->parent->first_clus;
184 /* if the buffer already contains dirty dentries, write it */
185 if (write_block(iter, block))
189 if (block > iter->parent->size / iter->read_size)
192 prev_desc = exfat_de_iter_get_buffer(iter, block - 1);
193 if (prev_desc->offset + 2 * iter->read_size <=
195 desc->p_clus = prev_desc->p_clus;
196 desc->offset = prev_desc->offset + iter->read_size;
198 ret = exfat_get_inode_next_clus(exfat, iter->parent,
199 prev_desc->p_clus, &desc->p_clus);
203 else if (desc->p_clus == EXFAT_EOF_CLUSTER)
208 device_offset = exfat_c2o(exfat, desc->p_clus) + desc->offset;
209 ret = exfat_read(exfat->blk_dev->dev_fd, desc->buffer,
210 iter->read_size, device_offset);
215 * if a buffer is filled with dentries, read blocks ahead of time,
216 * otherwise read blocks of the next directory in advance.
218 if (desc->buffer[iter->read_size - 32] != EXFAT_LAST)
219 read_ahead_next_blocks(iter,
220 (block * iter->read_size) / exfat->clus_size,
221 (block * iter->read_size) % exfat->clus_size,
224 read_ahead_next_dir_blocks(iter);
228 int exfat_de_iter_init(struct exfat_de_iter *iter, struct exfat *exfat,
229 struct exfat_inode *dir, struct buffer_desc *bd)
233 iter->write_size = exfat->sect_size;
234 iter->read_size = exfat_get_read_size(exfat);
235 if (exfat->clus_size <= 32 * KB)
236 iter->ra_partial_size = MAX(4 * KB, exfat->clus_size / 2);
238 iter->ra_partial_size = exfat->clus_size / 4;
239 iter->ra_partial_size = MIN(iter->ra_partial_size, 8 * KB);
241 iter->buffer_desc = bd;
243 iter->de_file_offset = 0;
244 iter->next_read_offset = iter->read_size;
245 iter->max_skip_dentries = 0;
246 iter->invalid_name_num = 0;
248 if (iter->parent->size == 0)
251 read_ahead_first_blocks(iter);
252 if (read_block(iter, 0) != (ssize_t)iter->read_size) {
253 exfat_err("failed to read directory entries.\n");
260 int exfat_de_iter_get(struct exfat_de_iter *iter,
261 int ith, struct exfat_dentry **dentry)
263 off_t next_de_file_offset;
266 struct buffer_desc *bd;
268 next_de_file_offset = iter->de_file_offset +
269 ith * sizeof(struct exfat_dentry);
270 block = (unsigned int)(next_de_file_offset / iter->read_size);
272 if (next_de_file_offset + sizeof(struct exfat_dentry) >
276 /* read next cluster if needed */
277 if (next_de_file_offset >= iter->next_read_offset) {
278 ret = read_block(iter, block);
279 if (ret != (ssize_t)iter->read_size)
281 iter->next_read_offset += iter->read_size;
284 if (ith + 1 > iter->max_skip_dentries)
285 iter->max_skip_dentries = ith + 1;
287 bd = exfat_de_iter_get_buffer(iter, block);
288 *dentry = (struct exfat_dentry *)(bd->buffer +
289 next_de_file_offset % iter->read_size);
293 int exfat_de_iter_get_dirty(struct exfat_de_iter *iter,
294 int ith, struct exfat_dentry **dentry)
296 off_t next_file_offset;
299 struct buffer_desc *bd;
301 ret = exfat_de_iter_get(iter, ith, dentry);
303 next_file_offset = iter->de_file_offset +
304 ith * sizeof(struct exfat_dentry);
305 block = (unsigned int)(next_file_offset / iter->read_size);
306 sect_idx = (int)((next_file_offset % iter->read_size) /
308 bd = exfat_de_iter_get_buffer(iter, block);
309 BITMAP_SET(bd->dirty, sect_idx);
315 int exfat_de_iter_flush(struct exfat_de_iter *iter)
319 for (i = 0; i < iter->exfat->buffer_count; i++)
320 if (write_block(iter, i))
325 int exfat_de_iter_advance(struct exfat_de_iter *iter, int skip_dentries)
327 if (skip_dentries > iter->max_skip_dentries)
330 iter->max_skip_dentries = 0;
331 iter->de_file_offset = iter->de_file_offset +
332 skip_dentries * sizeof(struct exfat_dentry);
336 off_t exfat_de_iter_device_offset(struct exfat_de_iter *iter)
338 struct buffer_desc *bd;
341 if ((uint64_t)iter->de_file_offset >= iter->parent->size)
344 block = iter->de_file_offset / iter->read_size;
345 bd = exfat_de_iter_get_buffer(iter, block);
346 return exfat_c2o(iter->exfat, bd->p_clus) + bd->offset +
347 iter->de_file_offset % iter->read_size;
350 off_t exfat_de_iter_file_offset(struct exfat_de_iter *iter)
352 return iter->de_file_offset;
356 * try to find the dentry set matched with @filter. this function
357 * doesn't verify the dentry set.
359 * if found, return 0. if not found, return EOF. otherwise return errno.
361 int exfat_lookup_dentry_set(struct exfat *exfat, struct exfat_inode *parent,
362 struct exfat_lookup_filter *filter)
364 struct buffer_desc *bd = NULL;
365 struct exfat_dentry *dentry = NULL;
366 off_t free_file_offset = 0, free_dev_offset = 0;
367 struct exfat_de_iter de_iter;
368 int dentry_count, empty_dentry_count = 0;
371 if (!exfat->lookup_buffer) {
372 exfat->lookup_buffer = exfat_alloc_buffer(exfat);
373 if (!exfat->lookup_buffer)
376 bd = exfat->lookup_buffer;
378 retval = exfat_de_iter_init(&de_iter, exfat, parent, bd);
379 if (retval == EOF || retval)
382 filter->out.dentry_set = NULL;
384 retval = exfat_de_iter_get(&de_iter, 0, &dentry);
388 fsck_err(parent->parent, parent,
389 "failed to get a dentry. %d\n", retval);
393 if (!IS_EXFAT_DELETED(dentry->type)) {
394 if (filter->in.dentry_count == 0 ||
395 empty_dentry_count < filter->in.dentry_count)
396 empty_dentry_count = 0;
400 if (dentry->type == filter->in.type) {
402 if (filter->in.filter)
403 retval = filter->in.filter(&de_iter,
408 struct exfat_dentry *d;
411 filter->out.dentry_set = calloc(dentry_count,
412 sizeof(struct exfat_dentry));
413 if (!filter->out.dentry_set) {
417 for (i = 0; i < dentry_count; i++) {
418 exfat_de_iter_get(&de_iter, i, &d);
419 memcpy(filter->out.dentry_set + i, d,
420 sizeof(struct exfat_dentry));
422 filter->out.dentry_count = dentry_count;
424 } else if (retval < 0) {
427 } else if (IS_EXFAT_DELETED(dentry->type)) {
428 if (empty_dentry_count == 0) {
430 exfat_de_iter_file_offset(&de_iter);
432 exfat_de_iter_device_offset(&de_iter);
435 if (filter->in.dentry_count == 0 ||
436 empty_dentry_count < filter->in.dentry_count)
437 empty_dentry_count++;
440 exfat_de_iter_advance(&de_iter, dentry_count);
445 filter->out.file_offset =
446 exfat_de_iter_file_offset(&de_iter);
447 filter->out.dev_offset =
448 exfat_de_iter_device_offset(&de_iter);
449 } else if (retval == EOF && empty_dentry_count) {
450 filter->out.file_offset = free_file_offset;
451 filter->out.dev_offset = free_dev_offset;
453 filter->out.file_offset = exfat_de_iter_file_offset(&de_iter);
454 filter->out.dev_offset = EOF;
459 static int filter_lookup_file(struct exfat_de_iter *de_iter,
460 void *param, int *dentry_count)
462 struct exfat_dentry *file_de, *stream_de, *name_de;
464 int retval, name_len;
467 retval = exfat_de_iter_get(de_iter, 0, &file_de);
468 if (retval || file_de->type != EXFAT_FILE)
471 retval = exfat_de_iter_get(de_iter, 1, &stream_de);
472 if (retval || stream_de->type != EXFAT_STREAM)
475 name = (__le16 *)param;
476 name_len = (int)exfat_utf16_len(name, PATH_MAX);
478 if (file_de->dentry.file.num_ext <
479 1 + (name_len + ENTRY_NAME_MAX - 1) / ENTRY_NAME_MAX)
482 for (i = 2; i <= file_de->dentry.file.num_ext && name_len > 0; i++) {
485 retval = exfat_de_iter_get(de_iter, i, &name_de);
486 if (retval || name_de->type != EXFAT_NAME)
489 len = MIN(name_len + 1, ENTRY_NAME_MAX);
490 if (memcmp(name_de->dentry.name.unicode_0_14,
502 int exfat_lookup_file_by_utf16name(struct exfat *exfat,
503 struct exfat_inode *parent,
505 struct exfat_lookup_filter *filter_out)
509 filter_out->in.type = EXFAT_FILE;
510 filter_out->in.filter = filter_lookup_file;
511 filter_out->in.param = utf16_name;
512 filter_out->in.dentry_count = 0;
514 retval = exfat_lookup_dentry_set(exfat, parent, filter_out);
521 int exfat_lookup_file(struct exfat *exfat, struct exfat_inode *parent,
522 const char *name, struct exfat_lookup_filter *filter_out)
525 __le16 utf16_name[PATH_MAX + 2] = {0, };
527 retval = (int)exfat_utf16_enc(name, utf16_name, sizeof(utf16_name));
531 return exfat_lookup_file_by_utf16name(exfat, parent, utf16_name,
535 void exfat_calc_dentry_checksum(struct exfat_dentry *dentry,
536 uint16_t *checksum, bool primary)
541 bytes = (uint8_t *)dentry;
543 /* use += to avoid promotion to int; UBSan complaints about signed overflow */
544 *checksum = (*checksum << 15) | (*checksum >> 1);
545 *checksum += bytes[0];
546 *checksum = (*checksum << 15) | (*checksum >> 1);
547 *checksum += bytes[1];
550 for (; i < sizeof(*dentry); i++) {
551 *checksum = (*checksum << 15) | (*checksum >> 1);
552 *checksum += bytes[i];
556 static uint16_t calc_dentry_set_checksum(struct exfat_dentry *dset, int dcount)
561 if (dcount < MIN_FILE_DENTRIES)
565 exfat_calc_dentry_checksum(&dset[0], &checksum, true);
566 for (i = 1; i < dcount; i++)
567 exfat_calc_dentry_checksum(&dset[i], &checksum, false);
571 uint16_t exfat_calc_name_hash(struct exfat *exfat,
572 __le16 *name, int len)
578 for (i = 0; i < len; i++) {
579 ch = exfat->upcase_table[le16_to_cpu(name[i])];
580 ch = cpu_to_le16(ch);
582 /* use += to avoid promotion to int; UBSan complaints about signed overflow */
583 chksum = (chksum << 15) | (chksum >> 1);
585 chksum = (chksum << 15) | (chksum >> 1);
591 static void unix_time_to_exfat_time(time_t unix_time, __u8 *tz, __le16 *date,
592 __le16 *time, __u8 *time_ms)
597 gmtime_r(&unix_time, &tm);
598 d = ((tm.tm_year - 80) << 9) | ((tm.tm_mon + 1) << 5) | tm.tm_mday;
599 t = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec >> 1);
602 *date = cpu_to_le16(d);
603 *time = cpu_to_le16(t);
605 *time_ms = (tm.tm_sec & 1) * 100;
608 int exfat_build_file_dentry_set(struct exfat *exfat, const char *name,
609 unsigned short attr, struct exfat_dentry **dentry_set,
612 struct exfat_dentry *dset;
613 __le16 utf16_name[PATH_MAX + 2];
615 int dcount, name_len, i;
616 __le16 e_date, e_time;
619 memset(utf16_name, 0, sizeof(utf16_name));
620 retval = exfat_utf16_enc(name, utf16_name, sizeof(utf16_name));
624 name_len = retval / 2;
625 dcount = 2 + DIV_ROUND_UP(name_len, ENTRY_NAME_MAX);
626 dset = calloc(dcount, DENTRY_SIZE);
630 dset[0].type = EXFAT_FILE;
631 dset[0].dentry.file.num_ext = dcount - 1;
632 dset[0].dentry.file.attr = cpu_to_le16(attr);
634 unix_time_to_exfat_time(time(NULL), &tz,
635 &e_date, &e_time, &e_time_ms);
637 dset[0].dentry.file.create_date = e_date;
638 dset[0].dentry.file.create_time = e_time;
639 dset[0].dentry.file.create_time_ms = e_time_ms;
640 dset[0].dentry.file.create_tz = tz;
642 dset[0].dentry.file.modify_date = e_date;
643 dset[0].dentry.file.modify_time = e_time;
644 dset[0].dentry.file.modify_time_ms = e_time_ms;
645 dset[0].dentry.file.modify_tz = tz;
647 dset[0].dentry.file.access_date = e_date;
648 dset[0].dentry.file.access_time = e_time;
649 dset[0].dentry.file.access_tz = tz;
651 dset[1].type = EXFAT_STREAM;
652 dset[1].dentry.stream.flags = 0x01;
653 dset[1].dentry.stream.name_len = (__u8)name_len;
654 dset[1].dentry.stream.name_hash =
655 cpu_to_le16(exfat_calc_name_hash(exfat, utf16_name, name_len));
657 for (i = 2; i < dcount; i++) {
658 dset[i].type = EXFAT_NAME;
659 memcpy(dset[i].dentry.name.unicode_0_14,
660 utf16_name + (i - 2) * ENTRY_NAME_MAX,
664 dset[0].dentry.file.checksum =
665 cpu_to_le16(calc_dentry_set_checksum(dset, dcount));
668 *dentry_count = dcount;
672 int exfat_update_file_dentry_set(struct exfat *exfat,
673 struct exfat_dentry *dset, int dcount,
675 clus_t start_clu, clus_t ccount)
678 __le16 utf16_name[PATH_MAX + 2];
680 if (dset[0].type != EXFAT_FILE || dcount < MIN_FILE_DENTRIES)
684 name_len = (int)exfat_utf16_enc(name,
685 utf16_name, sizeof(utf16_name));
690 if (dcount != 2 + DIV_ROUND_UP(name_len, ENTRY_NAME_MAX))
693 dset[1].dentry.stream.name_len = (__u8)name_len;
694 dset[1].dentry.stream.name_hash =
695 exfat_calc_name_hash(exfat, utf16_name, name_len);
697 for (i = 2; i < dcount; i++) {
698 dset[i].type = EXFAT_NAME;
699 memcpy(dset[i].dentry.name.unicode_0_14,
700 utf16_name + (i - 2) * ENTRY_NAME_MAX,
705 dset[1].dentry.stream.valid_size = cpu_to_le64(ccount * exfat->clus_size);
706 dset[1].dentry.stream.size = cpu_to_le64(ccount * exfat->clus_size);
708 dset[1].dentry.stream.start_clu = cpu_to_le32(start_clu);
710 dset[0].dentry.file.checksum =
711 cpu_to_le16(calc_dentry_set_checksum(dset, dcount));
715 static int find_free_cluster(struct exfat *exfat,
716 clus_t start, clus_t *new_clu)
718 clus_t end = le32_to_cpu(exfat->bs->bsx.clu_count) +
721 if (!exfat_heap_clus(exfat, start))
724 while (start < end) {
725 if (exfat_bitmap_find_zero(exfat, exfat->alloc_bitmap,
728 if (!exfat_bitmap_get(exfat->disk_bitmap, *new_clu))
730 start = *new_clu + 1;
734 start = EXFAT_FIRST_CLUSTER;
735 while (start < end) {
736 if (exfat_bitmap_find_zero(exfat, exfat->alloc_bitmap,
739 if (!exfat_bitmap_get(exfat->disk_bitmap, *new_clu))
741 start = *new_clu + 1;
745 *new_clu = EXFAT_EOF_CLUSTER;
749 static int exfat_map_cluster(struct exfat *exfat, struct exfat_inode *inode,
750 off_t file_off, clus_t *mapped_clu)
752 clus_t clu, next, count, last_count;
754 if (!exfat_heap_clus(exfat, inode->first_clus))
757 clu = inode->first_clus;
758 next = EXFAT_EOF_CLUSTER;
761 last_count = DIV_ROUND_UP(inode->size, exfat->clus_size);
763 last_count = file_off / exfat->clus_size + 1;
766 if (count * exfat->clus_size > inode->size)
769 if (count == last_count) {
774 if (exfat_get_inode_next_clus(exfat, inode, clu, &next))
777 if (!exfat_heap_clus(exfat, clu))
786 static int exfat_write_dentry_set(struct exfat *exfat,
787 struct exfat_dentry *dset, int dcount,
788 off_t dev_off, off_t *next_dev_off)
791 unsigned int clus_off, dent_len, first_half_len, sec_half_len;
792 off_t first_half_off, sec_half_off = 0;
794 if (exfat_o2c(exfat, dev_off, &clus, &clus_off))
797 dent_len = dcount * DENTRY_SIZE;
798 first_half_len = MIN(dent_len, exfat->clus_size - clus_off);
799 sec_half_len = dent_len - first_half_len;
801 first_half_off = dev_off;
805 if (exfat_get_next_clus(exfat, clus, &next_clus))
807 if (!exfat_heap_clus(exfat, next_clus))
809 sec_half_off = exfat_c2o(exfat, next_clus);
812 if (exfat_write(exfat->blk_dev->dev_fd, dset, first_half_len,
813 first_half_off) != (ssize_t)first_half_len)
817 dset = (struct exfat_dentry *)((char *)dset + first_half_len);
818 if (exfat_write(exfat->blk_dev->dev_fd, dset, sec_half_len,
819 sec_half_off) != (ssize_t)sec_half_len)
825 *next_dev_off = sec_half_off + sec_half_len;
827 *next_dev_off = first_half_off + first_half_len;
832 static int exfat_alloc_cluster(struct exfat *exfat, struct exfat_inode *inode,
837 bool need_dset = inode != exfat->root;
839 if ((need_dset && !inode->dentry_set) || inode->is_contiguous)
842 err = find_free_cluster(exfat, exfat->start_clu, new_clu);
844 exfat->start_clu = EXFAT_FIRST_CLUSTER;
845 exfat_err("failed to find an free cluster\n");
848 exfat->start_clu = *new_clu;
850 if (exfat_set_fat(exfat, *new_clu, EXFAT_EOF_CLUSTER))
853 /* zero out the new cluster */
854 if (exfat_write_zero(exfat->blk_dev->dev_fd, exfat->clus_size,
855 exfat_c2o(exfat, *new_clu))) {
856 exfat_err("failed to fill new cluster with zeroes\n");
861 err = exfat_map_cluster(exfat, inode, EOF, &last_clu);
863 exfat_err("failed to get the last cluster\n");
867 if (exfat_set_fat(exfat, last_clu, *new_clu))
871 err = exfat_update_file_dentry_set(exfat,
875 DIV_ROUND_UP(inode->size,
876 exfat->clus_size) + 1);
882 err = exfat_update_file_dentry_set(exfat,
891 if (need_dset && exfat_write_dentry_set(exfat, inode->dentry_set,
893 inode->dev_offset, NULL))
896 exfat_bitmap_set(exfat->alloc_bitmap, *new_clu);
897 if (inode->size == 0)
898 inode->first_clus = *new_clu;
899 inode->size += exfat->clus_size;
903 int exfat_add_dentry_set(struct exfat *exfat, struct exfat_dentry_loc *loc,
904 struct exfat_dentry *dset, int dcount,
907 struct exfat_inode *parent = loc->parent;
908 off_t dev_off, next_dev_off;
910 if (parent->is_contiguous ||
911 (uint64_t)loc->file_offset > parent->size ||
912 (unsigned int)dcount * DENTRY_SIZE > exfat->clus_size)
915 dev_off = loc->dev_offset;
916 if ((uint64_t)loc->file_offset + dcount * DENTRY_SIZE > parent->size) {
919 if (exfat_alloc_cluster(exfat, parent, &new_clus))
921 if ((uint64_t)loc->file_offset == parent->size - exfat->clus_size)
922 dev_off = exfat_c2o(exfat, new_clus);
925 if (exfat_write_dentry_set(exfat, dset, dcount, dev_off, &next_dev_off))
929 loc->file_offset += dcount * DENTRY_SIZE;
930 loc->dev_offset = next_dev_off;
935 int exfat_create_file(struct exfat *exfat, struct exfat_inode *parent,
936 const char *name, unsigned short attr)
938 struct exfat_dentry *dset;
940 struct exfat_lookup_filter filter;
941 struct exfat_dentry_loc loc;
943 err = exfat_lookup_file(exfat, parent, name, &filter);
945 dset = filter.out.dentry_set;
946 dcount = filter.out.dentry_count;
947 if ((le16_to_cpu(dset->dentry.file.attr) & attr) != attr)
952 err = exfat_build_file_dentry_set(exfat, name, attr,
958 loc.file_offset = filter.out.file_offset;
959 loc.dev_offset = filter.out.dev_offset;
960 err = exfat_add_dentry_set(exfat, &loc, dset, dcount, false);