lib/exfat_dir.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2021 LG Electronics.
   4  *
   5  *   Author(s): Hyunchul Lee <hyc.lee@gmail.com>
   6  */
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <string.h>
  12 #include <time.h>
  13
  14 #include "exfat_ondisk.h"
  15 #include "libexfat.h"
  16 #include "exfat_fs.h"
  17 #include "exfat_dir.h"
  18
  19 static struct path_resolve_ctx path_resolve_ctx;
  20
  21 #define fsck_err(parent, inode, fmt, ...)               \
  22 ({                                                      \
  23                 exfat_resolve_path_parent(&path_resolve_ctx,    \
  24                         parent, inode);                 \
  25                 exfat_err("ERROR: %s: " fmt,            \
  26                         path_resolve_ctx.local_path,    \
  27                         ##__VA_ARGS__);                 \
  28 })
  29
  30 static inline struct buffer_desc *exfat_de_iter_get_buffer(
  31                 struct exfat_de_iter *iter, unsigned int block)
  32 {
  33         return &iter->buffer_desc[block % iter->exfat->buffer_count];
  34 }
  35
  36 static ssize_t write_block(struct exfat_de_iter *iter, unsigned int block)
  37 {
  38         off_t device_offset;
  39         struct exfat *exfat = iter->exfat;
  40         struct buffer_desc *desc;
  41         unsigned int i;
  42
  43         desc = exfat_de_iter_get_buffer(iter, block);
  44
  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) +
  48                                 desc->offset;
  49                         if (exfat_write(exfat->blk_dev->dev_fd,
  50                                         desc->buffer + i * iter->write_size,
  51                                         iter->write_size,
  52                                         device_offset + i * iter->write_size)
  53                                         != (ssize_t)iter->write_size)
  54                                 return -EIO;
  55                         BITMAP_CLEAR(desc->dirty, i);
  56                 }
  57         }
  58         return 0;
  59 }
  60
  61 static int read_ahead_first_blocks(struct exfat_de_iter *iter)
  62 {
  63 #ifdef POSIX_FADV_WILLNEED
  64         struct exfat *exfat = iter->exfat;
  65         clus_t clus_count;
  66         unsigned int size;
  67
  68         clus_count = iter->parent->size / exfat->clus_size;
  69
  70         if (clus_count > 1) {
  71                 iter->ra_begin_offset = 0;
  72                 iter->ra_next_clus = 1;
  73                 size = exfat->clus_size;
  74         } else {
  75                 iter->ra_begin_offset = 0;
  76                 iter->ra_next_clus = 0;
  77                 size = iter->ra_partial_size;
  78         }
  79         return posix_fadvise(exfat->blk_dev->dev_fd,
  80                         exfat_c2o(exfat, iter->parent->first_clus), size,
  81                         POSIX_FADV_WILLNEED);
  82 #else
  83         return -ENOTSUP;
  84 #endif
  85 }
  86
  87 /**
  88  * read the next fragment in advance, and assume the fragment
  89  * which covers @clus is already read.
  90  */
  91 static int read_ahead_next_blocks(struct exfat_de_iter *iter,
  92                 clus_t clus, unsigned int offset, clus_t p_clus)
  93 {
  94 #ifdef POSIX_FADV_WILLNEED
  95         struct exfat *exfat = iter->exfat;
  96         off_t device_offset;
  97         clus_t clus_count, ra_clus, ra_p_clus;
  98         unsigned int size;
  99         int ret = 0;
 100
 101         clus_count = iter->parent->size / exfat->clus_size;
 102         if (clus + 1 < clus_count) {
 103                 ra_clus = clus + 1;
 104                 if (ra_clus == iter->ra_next_clus &&
 105                                 offset >= iter->ra_begin_offset) {
 106                         ret = exfat_get_inode_next_clus(exfat, iter->parent,
 107                                                         p_clus, &ra_p_clus);
 108                         if (ret)
 109                                 return ret;
 110
 111                         if (ra_p_clus == EXFAT_EOF_CLUSTER)
 112                                 return -EIO;
 113
 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,
 118                                         device_offset, size,
 119                                         POSIX_FADV_WILLNEED);
 120                         iter->ra_next_clus = ra_clus + 1;
 121                         iter->ra_begin_offset = 0;
 122                 }
 123         } else {
 124                 if (offset >= iter->ra_begin_offset &&
 125                                 offset + iter->ra_partial_size <=
 126                                 exfat->clus_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;
 134                 }
 135         }
 136
 137         return ret;
 138 #else
 139         return -ENOTSUP;
 140 #endif
 141 }
 142
 143 static int read_ahead_next_dir_blocks(struct exfat_de_iter *iter)
 144 {
 145 #ifdef POSIX_FADV_WILLNEED
 146         struct exfat *exfat = iter->exfat;
 147         struct list_head *current;
 148         struct exfat_inode *next_inode;
 149         off_t offset;
 150
 151         if (list_empty(&exfat->dir_list))
 152                 return -EINVAL;
 153
 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,
 158                                 list);
 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);
 163         }
 164
 165         return 0;
 166 #else
 167         return -ENOTSUP;
 168 #endif
 169 }
 170
 171 static ssize_t read_block(struct exfat_de_iter *iter, unsigned int block)
 172 {
 173         struct exfat *exfat = iter->exfat;
 174         struct buffer_desc *desc, *prev_desc;
 175         off_t device_offset;
 176         ssize_t ret;
 177
 178         desc = exfat_de_iter_get_buffer(iter, block);
 179         if (block == 0) {
 180                 desc->p_clus = iter->parent->first_clus;
 181                 desc->offset = 0;
 182         }
 183
 184         /* if the buffer already contains dirty dentries, write it */
 185         if (write_block(iter, block))
 186                 return -EIO;
 187
 188         if (block > 0) {
 189                 if (block > iter->parent->size / iter->read_size)
 190                         return EOF;
 191
 192                 prev_desc = exfat_de_iter_get_buffer(iter, block - 1);
 193                 if (prev_desc->offset + 2 * iter->read_size <=
 194                                 exfat->clus_size) {
 195                         desc->p_clus = prev_desc->p_clus;
 196                         desc->offset = prev_desc->offset + iter->read_size;
 197                 } else {
 198                         ret = exfat_get_inode_next_clus(exfat, iter->parent,
 199                                                         prev_desc->p_clus, &desc->p_clus);
 200                         desc->offset = 0;
 201                         if (ret)
 202                                 return ret;
 203                         else if (desc->p_clus == EXFAT_EOF_CLUSTER)
 204                                 return EOF;
 205                 }
 206         }
 207
 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);
 211         if (ret <= 0)
 212                 return ret;
 213
 214         /*
 215          * if a buffer is filled with dentries, read blocks ahead of time,
 216          * otherwise read blocks of the next directory in advance.
 217          */
 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,
 222                                 desc->p_clus);
 223         else
 224                 read_ahead_next_dir_blocks(iter);
 225         return ret;
 226 }
 227
 228 int exfat_de_iter_init(struct exfat_de_iter *iter, struct exfat *exfat,
 229                        struct exfat_inode *dir, struct buffer_desc *bd)
 230 {
 231         iter->exfat = exfat;
 232         iter->parent = dir;
 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);
 237         else
 238                 iter->ra_partial_size = exfat->clus_size / 4;
 239         iter->ra_partial_size = MIN(iter->ra_partial_size, 8 * KB);
 240
 241         iter->buffer_desc = bd;
 242
 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;
 247
 248         if (iter->parent->size == 0)
 249                 return EOF;
 250
 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");
 254                 return -EIO;
 255         }
 256
 257         return 0;
 258 }
 259
 260 int exfat_de_iter_get(struct exfat_de_iter *iter,
 261                         int ith, struct exfat_dentry **dentry)
 262 {
 263         off_t next_de_file_offset;
 264         ssize_t ret;
 265         unsigned int block;
 266         struct buffer_desc *bd;
 267
 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);
 271
 272         if (next_de_file_offset + sizeof(struct exfat_dentry) >
 273                 iter->parent->size)
 274                 return EOF;
 275
 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)
 280                         return ret;
 281                 iter->next_read_offset += iter->read_size;
 282         }
 283
 284         if (ith + 1 > iter->max_skip_dentries)
 285                 iter->max_skip_dentries = ith + 1;
 286
 287         bd = exfat_de_iter_get_buffer(iter, block);
 288         *dentry = (struct exfat_dentry *)(bd->buffer +
 289                         next_de_file_offset % iter->read_size);
 290         return 0;
 291 }
 292
 293 int exfat_de_iter_get_dirty(struct exfat_de_iter *iter,
 294                         int ith, struct exfat_dentry **dentry)
 295 {
 296         off_t next_file_offset;
 297         unsigned int block;
 298         int ret, sect_idx;
 299         struct buffer_desc *bd;
 300
 301         ret = exfat_de_iter_get(iter, ith, dentry);
 302         if (!ret) {
 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) /
 307                                 iter->write_size);
 308                 bd = exfat_de_iter_get_buffer(iter, block);
 309                 BITMAP_SET(bd->dirty, sect_idx);
 310         }
 311
 312         return ret;
 313 }
 314
 315 int exfat_de_iter_flush(struct exfat_de_iter *iter)
 316 {
 317         unsigned int i;
 318
 319         for (i = 0; i < iter->exfat->buffer_count; i++)
 320                 if (write_block(iter, i))
 321                         return -EIO;
 322         return 0;
 323 }
 324
 325 int exfat_de_iter_advance(struct exfat_de_iter *iter, int skip_dentries)
 326 {
 327         if (skip_dentries > iter->max_skip_dentries)
 328                 return -EINVAL;
 329
 330         iter->max_skip_dentries = 0;
 331         iter->de_file_offset = iter->de_file_offset +
 332                                 skip_dentries * sizeof(struct exfat_dentry);
 333         return 0;
 334 }
 335
 336 off_t exfat_de_iter_device_offset(struct exfat_de_iter *iter)
 337 {
 338         struct buffer_desc *bd;
 339         unsigned int block;
 340
 341         if ((uint64_t)iter->de_file_offset >= iter->parent->size)
 342                 return EOF;
 343
 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;
 348 }
 349
 350 off_t exfat_de_iter_file_offset(struct exfat_de_iter *iter)
 351 {
 352         return iter->de_file_offset;
 353 }
 354
 355 /*
 356  * try to find the dentry set matched with @filter. this function
 357  * doesn't verify the dentry set.
 358  *
 359  * if found, return 0. if not found, return EOF. otherwise return errno.
 360  */
 361 int exfat_lookup_dentry_set(struct exfat *exfat, struct exfat_inode *parent,
 362                             struct exfat_lookup_filter *filter)
 363 {
 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;
 369         int retval;
 370
 371         if (!exfat->lookup_buffer) {
 372                 exfat->lookup_buffer = exfat_alloc_buffer(exfat);
 373                 if (!exfat->lookup_buffer)
 374                         return -ENOMEM;
 375         }
 376         bd = exfat->lookup_buffer;
 377
 378         retval = exfat_de_iter_init(&de_iter, exfat, parent, bd);
 379         if (retval == EOF || retval)
 380                 goto out;
 381
 382         filter->out.dentry_set = NULL;
 383         while (1) {
 384                 retval = exfat_de_iter_get(&de_iter, 0, &dentry);
 385                 if (retval == EOF) {
 386                         break;
 387                 } else if (retval) {
 388                         fsck_err(parent->parent, parent,
 389                                  "failed to get a dentry. %d\n", retval);
 390                         goto out;
 391                 }
 392
 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;
 397                 }
 398
 399                 dentry_count = 1;
 400                 if (dentry->type == filter->in.type) {
 401                         retval = 0;
 402                         if (filter->in.filter)
 403                                 retval = filter->in.filter(&de_iter,
 404                                                         filter->in.param,
 405                                                         &dentry_count);
 406
 407                         if (retval == 0) {
 408                                 struct exfat_dentry *d;
 409                                 int i;
 410
 411                                 filter->out.dentry_set = calloc(dentry_count,
 412                                                                 sizeof(struct exfat_dentry));
 413                                 if (!filter->out.dentry_set) {
 414                                         retval = -ENOMEM;
 415                                         goto out;
 416                                 }
 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));
 421                                 }
 422                                 filter->out.dentry_count = dentry_count;
 423                                 goto out;
 424                         } else if (retval < 0) {
 425                                 goto out;
 426                         }
 427                 } else if (IS_EXFAT_DELETED(dentry->type)) {
 428                         if (empty_dentry_count == 0) {
 429                                 free_file_offset =
 430                                         exfat_de_iter_file_offset(&de_iter);
 431                                 free_dev_offset =
 432                                         exfat_de_iter_device_offset(&de_iter);
 433                         }
 434
 435                         if (filter->in.dentry_count == 0 ||
 436                             empty_dentry_count < filter->in.dentry_count)
 437                                 empty_dentry_count++;
 438                 }
 439
 440                 exfat_de_iter_advance(&de_iter, dentry_count);
 441         }
 442
 443 out:
 444         if (retval == 0) {
 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;
 452         } else {
 453                 filter->out.file_offset = exfat_de_iter_file_offset(&de_iter);
 454                 filter->out.dev_offset = EOF;
 455         }
 456         return retval;
 457 }
 458
 459 static int filter_lookup_file(struct exfat_de_iter *de_iter,
 460                               void *param, int *dentry_count)
 461 {
 462         struct exfat_dentry *file_de, *stream_de, *name_de;
 463         __le16 *name;
 464         int retval, name_len;
 465         int i;
 466
 467         retval = exfat_de_iter_get(de_iter, 0, &file_de);
 468         if (retval || file_de->type != EXFAT_FILE)
 469                 return 1;
 470
 471         retval = exfat_de_iter_get(de_iter, 1, &stream_de);
 472         if (retval || stream_de->type != EXFAT_STREAM)
 473                 return 1;
 474
 475         name = (__le16 *)param;
 476         name_len = (int)exfat_utf16_len(name, PATH_MAX);
 477
 478         if (file_de->dentry.file.num_ext <
 479                 1 + (name_len + ENTRY_NAME_MAX - 1) / ENTRY_NAME_MAX)
 480                 return 1;
 481
 482         for (i = 2; i <= file_de->dentry.file.num_ext && name_len > 0; i++) {
 483                 int len;
 484
 485                 retval = exfat_de_iter_get(de_iter, i, &name_de);
 486                 if (retval || name_de->type != EXFAT_NAME)
 487                         return 1;
 488
 489                 len = MIN(name_len + 1, ENTRY_NAME_MAX);
 490                 if (memcmp(name_de->dentry.name.unicode_0_14,
 491                            name, len * 2) != 0)
 492                         return 1;
 493
 494                 name += len;
 495                 name_len -= len;
 496         }
 497
 498         *dentry_count = i;
 499         return 0;
 500 }
 501
 502 int exfat_lookup_file_by_utf16name(struct exfat *exfat,
 503                                  struct exfat_inode *parent,
 504                                  __le16 *utf16_name,
 505                                  struct exfat_lookup_filter *filter_out)
 506 {
 507         int retval;
 508
 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;
 513
 514         retval = exfat_lookup_dentry_set(exfat, parent, filter_out);
 515         if (retval < 0)
 516                 return retval;
 517
 518         return 0;
 519 }
 520
 521 int exfat_lookup_file(struct exfat *exfat, struct exfat_inode *parent,
 522                       const char *name, struct exfat_lookup_filter *filter_out)
 523 {
 524         int retval;
 525         __le16 utf16_name[PATH_MAX + 2] = {0, };
 526
 527         retval = (int)exfat_utf16_enc(name, utf16_name, sizeof(utf16_name));
 528         if (retval < 0)
 529                 return retval;
 530
 531         return exfat_lookup_file_by_utf16name(exfat, parent, utf16_name,
 532                         filter_out);
 533 }
 534
 535 void exfat_calc_dentry_checksum(struct exfat_dentry *dentry,
 536                                 uint16_t *checksum, bool primary)
 537 {
 538         unsigned int i;
 539         uint8_t *bytes;
 540
 541         bytes = (uint8_t *)dentry;
 542
 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];
 548
 549         i = primary ? 4 : 2;
 550         for (; i < sizeof(*dentry); i++) {
 551                 *checksum = (*checksum << 15) | (*checksum >> 1);
 552                 *checksum += bytes[i];
 553         }
 554 }
 555
 556 static uint16_t calc_dentry_set_checksum(struct exfat_dentry *dset, int dcount)
 557 {
 558         uint16_t checksum;
 559         int i;
 560
 561         if (dcount < MIN_FILE_DENTRIES)
 562                 return 0;
 563
 564         checksum = 0;
 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);
 568         return checksum;
 569 }
 570
 571 uint16_t exfat_calc_name_hash(struct exfat *exfat,
 572                               __le16 *name, int len)
 573 {
 574         int i;
 575         __le16 ch;
 576         uint16_t chksum = 0;
 577
 578         for (i = 0; i < len; i++) {
 579                 ch = exfat->upcase_table[le16_to_cpu(name[i])];
 580                 ch = cpu_to_le16(ch);
 581
 582                 /* use += to avoid promotion to int; UBSan complaints about signed overflow */
 583                 chksum = (chksum << 15) | (chksum >> 1);
 584                 chksum += ch & 0xFF;
 585                 chksum = (chksum << 15) | (chksum >> 1);
 586                 chksum += ch >> 8;
 587         }
 588         return chksum;
 589 }
 590
 591 static void unix_time_to_exfat_time(time_t unix_time, __u8 *tz, __le16 *date,
 592                                     __le16 *time, __u8 *time_ms)
 593 {
 594         struct tm tm;
 595         __u16 t, d;
 596
 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);
 600
 601         *tz = 0x80;
 602         *date = cpu_to_le16(d);
 603         *time = cpu_to_le16(t);
 604         if (time_ms)
 605                 *time_ms = (tm.tm_sec & 1) * 100;
 606 }
 607
 608 int exfat_build_file_dentry_set(struct exfat *exfat, const char *name,
 609                                 unsigned short attr, struct exfat_dentry **dentry_set,
 610                                 int *dentry_count)
 611 {
 612         struct exfat_dentry *dset;
 613         __le16 utf16_name[PATH_MAX + 2];
 614         int retval;
 615         int dcount, name_len, i;
 616         __le16 e_date, e_time;
 617         __u8 tz, e_time_ms;
 618
 619         memset(utf16_name, 0, sizeof(utf16_name));
 620         retval = exfat_utf16_enc(name, utf16_name, sizeof(utf16_name));
 621         if (retval < 0)
 622                 return retval;
 623
 624         name_len = retval / 2;
 625         dcount = 2 + DIV_ROUND_UP(name_len, ENTRY_NAME_MAX);
 626         dset = calloc(dcount, DENTRY_SIZE);
 627         if (!dset)
 628                 return -ENOMEM;
 629
 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);
 633
 634         unix_time_to_exfat_time(time(NULL), &tz,
 635                                 &e_date, &e_time, &e_time_ms);
 636
 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;
 641
 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;
 646
 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;
 650
 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));
 656
 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,
 661                        ENTRY_NAME_MAX * 2);
 662         }
 663
 664         dset[0].dentry.file.checksum =
 665                 cpu_to_le16(calc_dentry_set_checksum(dset, dcount));
 666
 667         *dentry_set = dset;
 668         *dentry_count = dcount;
 669         return 0;
 670 }
 671
 672 int exfat_update_file_dentry_set(struct exfat *exfat,
 673                                  struct exfat_dentry *dset, int dcount,
 674                                  const char *name,
 675                                  clus_t start_clu, clus_t ccount)
 676 {
 677         int i, name_len;
 678         __le16 utf16_name[PATH_MAX + 2];
 679
 680         if (dset[0].type != EXFAT_FILE || dcount < MIN_FILE_DENTRIES)
 681                 return -EINVAL;
 682
 683         if (name) {
 684                 name_len = (int)exfat_utf16_enc(name,
 685                                                 utf16_name, sizeof(utf16_name));
 686                 if (name_len < 0)
 687                         return name_len;
 688
 689                 name_len /= 2;
 690                 if (dcount != 2 + DIV_ROUND_UP(name_len, ENTRY_NAME_MAX))
 691                         return -EINVAL;
 692
 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);
 696
 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,
 701                                ENTRY_NAME_MAX * 2);
 702                 }
 703         }
 704
 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);
 707         if (start_clu)
 708                 dset[1].dentry.stream.start_clu = cpu_to_le32(start_clu);
 709
 710         dset[0].dentry.file.checksum =
 711                 cpu_to_le16(calc_dentry_set_checksum(dset, dcount));
 712         return 0;
 713 }
 714
 715 static int find_free_cluster(struct exfat *exfat,
 716                              clus_t start, clus_t *new_clu)
 717 {
 718         clus_t end = le32_to_cpu(exfat->bs->bsx.clu_count) +
 719                 EXFAT_FIRST_CLUSTER;
 720
 721         if (!exfat_heap_clus(exfat, start))
 722                 return -EINVAL;
 723
 724         while (start < end) {
 725                 if (exfat_bitmap_find_zero(exfat, exfat->alloc_bitmap,
 726                                            start, new_clu))
 727                         break;
 728                 if (!exfat_bitmap_get(exfat->disk_bitmap, *new_clu))
 729                         return 0;
 730                 start = *new_clu + 1;
 731         }
 732
 733         end = start;
 734         start = EXFAT_FIRST_CLUSTER;
 735         while (start < end) {
 736                 if (exfat_bitmap_find_zero(exfat, exfat->alloc_bitmap,
 737                                            start, new_clu))
 738                         goto out_nospc;
 739                 if (!exfat_bitmap_get(exfat->disk_bitmap, *new_clu))
 740                         return 0;
 741                 start = *new_clu + 1;
 742         }
 743
 744 out_nospc:
 745         *new_clu = EXFAT_EOF_CLUSTER;
 746         return -ENOSPC;
 747 }
 748
 749 static int exfat_map_cluster(struct exfat *exfat, struct exfat_inode *inode,
 750                              off_t file_off, clus_t *mapped_clu)
 751 {
 752         clus_t clu, next, count, last_count;
 753
 754         if (!exfat_heap_clus(exfat, inode->first_clus))
 755                 return -EINVAL;
 756
 757         clu = inode->first_clus;
 758         next = EXFAT_EOF_CLUSTER;
 759         count = 1;
 760         if (file_off == EOF)
 761                 last_count = DIV_ROUND_UP(inode->size, exfat->clus_size);
 762         else
 763                 last_count = file_off / exfat->clus_size + 1;
 764
 765         while (true) {
 766                 if (count * exfat->clus_size > inode->size)
 767                         return -EINVAL;
 768
 769                 if (count == last_count) {
 770                         *mapped_clu = clu;
 771                         return 0;
 772                 }
 773
 774                 if (exfat_get_inode_next_clus(exfat, inode, clu, &next))
 775                         return -EINVAL;
 776
 777                 if (!exfat_heap_clus(exfat, clu))
 778                         return -EINVAL;
 779
 780                 clu = next;
 781                 count++;
 782         }
 783         return -EINVAL;
 784 }
 785
 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)
 789 {
 790         clus_t clus;
 791         unsigned int clus_off, dent_len, first_half_len, sec_half_len;
 792         off_t first_half_off, sec_half_off = 0;
 793
 794         if (exfat_o2c(exfat, dev_off, &clus, &clus_off))
 795                 return -ERANGE;
 796
 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;
 800
 801         first_half_off = dev_off;
 802         if (sec_half_len) {
 803                 clus_t next_clus;
 804
 805                 if (exfat_get_next_clus(exfat, clus, &next_clus))
 806                         return -EIO;
 807                 if (!exfat_heap_clus(exfat, next_clus))
 808                         return -EINVAL;
 809                 sec_half_off = exfat_c2o(exfat, next_clus);
 810         }
 811
 812         if (exfat_write(exfat->blk_dev->dev_fd, dset, first_half_len,
 813                         first_half_off) != (ssize_t)first_half_len)
 814                 return -EIO;
 815
 816         if (sec_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)
 820                         return -EIO;
 821         }
 822
 823         if (next_dev_off) {
 824                 if (sec_half_len)
 825                         *next_dev_off = sec_half_off + sec_half_len;
 826                 else
 827                         *next_dev_off = first_half_off + first_half_len;
 828         }
 829         return 0;
 830 }
 831
 832 static int exfat_alloc_cluster(struct exfat *exfat, struct exfat_inode *inode,
 833                                clus_t *new_clu)
 834 {
 835         clus_t last_clu;
 836         int err;
 837         bool need_dset = inode != exfat->root;
 838
 839         if ((need_dset && !inode->dentry_set) || inode->is_contiguous)
 840                 return -EINVAL;
 841
 842         err = find_free_cluster(exfat, exfat->start_clu, new_clu);
 843         if (err) {
 844                 exfat->start_clu = EXFAT_FIRST_CLUSTER;
 845                 exfat_err("failed to find an free cluster\n");
 846                 return -ENOSPC;
 847         }
 848         exfat->start_clu = *new_clu;
 849
 850         if (exfat_set_fat(exfat, *new_clu, EXFAT_EOF_CLUSTER))
 851                 return -EIO;
 852
 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");
 857                 return -EIO;
 858         }
 859
 860         if (inode->size) {
 861                 err = exfat_map_cluster(exfat, inode, EOF, &last_clu);
 862                 if (err) {
 863                         exfat_err("failed to get the last cluster\n");
 864                         return err;
 865                 }
 866
 867                 if (exfat_set_fat(exfat, last_clu, *new_clu))
 868                         return -EIO;
 869
 870                 if (need_dset) {
 871                         err = exfat_update_file_dentry_set(exfat,
 872                                                            inode->dentry_set,
 873                                                            inode->dentry_count,
 874                                                            NULL, 0,
 875                                                            DIV_ROUND_UP(inode->size,
 876                                                                         exfat->clus_size) + 1);
 877                         if (err)
 878                                 return -EINVAL;
 879                 }
 880         } else {
 881                 if (need_dset) {
 882                         err = exfat_update_file_dentry_set(exfat,
 883                                                            inode->dentry_set,
 884                                                            inode->dentry_count,
 885                                                            NULL, *new_clu, 1);
 886                         if (err)
 887                                 return -EINVAL;
 888                 }
 889         }
 890
 891         if (need_dset && exfat_write_dentry_set(exfat, inode->dentry_set,
 892                                                 inode->dentry_count,
 893                                                 inode->dev_offset, NULL))
 894                 return -EIO;
 895
 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;
 900         return 0;
 901 }
 902
 903 int exfat_add_dentry_set(struct exfat *exfat, struct exfat_dentry_loc *loc,
 904                          struct exfat_dentry *dset, int dcount,
 905                          bool need_next_loc)
 906 {
 907         struct exfat_inode *parent = loc->parent;
 908         off_t dev_off, next_dev_off;
 909
 910         if (parent->is_contiguous ||
 911             (uint64_t)loc->file_offset > parent->size ||
 912             (unsigned int)dcount * DENTRY_SIZE > exfat->clus_size)
 913                 return -EINVAL;
 914
 915         dev_off = loc->dev_offset;
 916         if ((uint64_t)loc->file_offset + dcount * DENTRY_SIZE > parent->size) {
 917                 clus_t new_clus;
 918
 919                 if (exfat_alloc_cluster(exfat, parent, &new_clus))
 920                         return -EIO;
 921                 if ((uint64_t)loc->file_offset == parent->size - exfat->clus_size)
 922                         dev_off = exfat_c2o(exfat, new_clus);
 923         }
 924
 925         if (exfat_write_dentry_set(exfat, dset, dcount, dev_off, &next_dev_off))
 926                 return -EIO;
 927
 928         if (need_next_loc) {
 929                 loc->file_offset += dcount * DENTRY_SIZE;
 930                 loc->dev_offset = next_dev_off;
 931         }
 932         return 0;
 933 }
 934
 935 int exfat_create_file(struct exfat *exfat, struct exfat_inode *parent,
 936                       const char *name, unsigned short attr)
 937 {
 938         struct exfat_dentry *dset;
 939         int err, dcount;
 940         struct exfat_lookup_filter filter;
 941         struct exfat_dentry_loc loc;
 942
 943         err = exfat_lookup_file(exfat, parent, name, &filter);
 944         if (err == 0) {
 945                 dset = filter.out.dentry_set;
 946                 dcount = filter.out.dentry_count;
 947                 if ((le16_to_cpu(dset->dentry.file.attr) & attr) != attr)
 948                         err = -EEXIST;
 949                 goto out;
 950         }
 951
 952         err = exfat_build_file_dentry_set(exfat, name, attr,
 953                                           &dset, &dcount);
 954         if (err)
 955                 return err;
 956
 957         loc.parent = parent;
 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);
 961 out:
 962         free(dset);
 963         return err;
 964 }