drivers/staging/exfat/exfat_core.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
   4  */
   5
   6 #include <linux/types.h>
   7 #include <linux/buffer_head.h>
   8 #include <linux/fs.h>
   9 #include <linux/mutex.h>
  10 #include <linux/blkdev.h>
  11 #include <linux/slab.h>
  12 #include "exfat.h"
  13
  14 static void __set_sb_dirty(struct super_block *sb)
  15 {
  16         struct exfat_sb_info *sbi = EXFAT_SB(sb);
  17
  18         sbi->s_dirt = 1;
  19 }
  20
  21 static u8 name_buf[MAX_PATH_LENGTH * MAX_CHARSET_SIZE];
  22
  23 static char *reserved_names[] = {
  24         "AUX     ", "CON     ", "NUL     ", "PRN     ",
  25         "COM1    ", "COM2    ", "COM3    ", "COM4    ",
  26         "COM5    ", "COM6    ", "COM7    ", "COM8    ", "COM9    ",
  27         "LPT1    ", "LPT2    ", "LPT3    ", "LPT4    ",
  28         "LPT5    ", "LPT6    ", "LPT7    ", "LPT8    ", "LPT9    ",
  29         NULL
  30 };
  31
  32 static u8 free_bit[] = {
  33         0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, /*   0 ~  19 */
  34         0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, /*  20 ~  39 */
  35         0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, /*  40 ~  59 */
  36         0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, /*  60 ~  79 */
  37         0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, /*  80 ~  99 */
  38         0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, /* 100 ~ 119 */
  39         0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, /* 120 ~ 139 */
  40         0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, /* 140 ~ 159 */
  41         0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, /* 160 ~ 179 */
  42         0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, /* 180 ~ 199 */
  43         0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, /* 200 ~ 219 */
  44         0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, /* 220 ~ 239 */
  45         0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0                 /* 240 ~ 254 */
  46 };
  47
  48 static u8 used_bit[] = {
  49         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, /*   0 ~  19 */
  50         2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, /*  20 ~  39 */
  51         2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, /*  40 ~  59 */
  52         4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, /*  60 ~  79 */
  53         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, /*  80 ~  99 */
  54         3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, /* 100 ~ 119 */
  55         4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, /* 120 ~ 139 */
  56         3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, /* 140 ~ 159 */
  57         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, /* 160 ~ 179 */
  58         4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, /* 180 ~ 199 */
  59         3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, /* 200 ~ 219 */
  60         5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, /* 220 ~ 239 */
  61         4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8              /* 240 ~ 255 */
  62 };
  63
  64 #define BITMAP_LOC(v)           ((v) >> 3)
  65 #define BITMAP_SHIFT(v)         ((v) & 0x07)
  66
  67 static inline s32 exfat_bitmap_test(u8 *bitmap, int i)
  68 {
  69         u8 data;
  70
  71         data = bitmap[BITMAP_LOC(i)];
  72         if ((data >> BITMAP_SHIFT(i)) & 0x01)
  73                 return 1;
  74         return 0;
  75 }
  76
  77 static inline void exfat_bitmap_set(u8 *bitmap, int i)
  78 {
  79         bitmap[BITMAP_LOC(i)] |= (0x01 << BITMAP_SHIFT(i));
  80 }
  81
  82 static inline void exfat_bitmap_clear(u8 *bitmap, int i)
  83 {
  84         bitmap[BITMAP_LOC(i)] &= ~(0x01 << BITMAP_SHIFT(i));
  85 }
  86
  87 /*
  88  *  File System Management Functions
  89  */
  90
  91 void fs_set_vol_flags(struct super_block *sb, u32 new_flag)
  92 {
  93         struct pbr_sector_t *p_pbr;
  94         struct bpbex_t *p_bpb;
  95         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
  96
  97         if (p_fs->vol_flag == new_flag)
  98                 return;
  99
 100         p_fs->vol_flag = new_flag;
 101
 102         if (p_fs->vol_type == EXFAT) {
 103                 if (!p_fs->pbr_bh) {
 104                         if (sector_read(sb, p_fs->PBR_sector,
 105                                         &p_fs->pbr_bh, 1) != FFS_SUCCESS)
 106                                 return;
 107                 }
 108
 109                 p_pbr = (struct pbr_sector_t *)p_fs->pbr_bh->b_data;
 110                 p_bpb = (struct bpbex_t *)p_pbr->bpb;
 111                 SET16(p_bpb->vol_flags, (u16)new_flag);
 112
 113                 /* XXX duyoung
 114                  * what can we do here? (cuz fs_set_vol_flags() is void)
 115                  */
 116                 if ((new_flag == VOL_DIRTY) && (!buffer_dirty(p_fs->pbr_bh)))
 117                         sector_write(sb, p_fs->PBR_sector, p_fs->pbr_bh, 1);
 118                 else
 119                         sector_write(sb, p_fs->PBR_sector, p_fs->pbr_bh, 0);
 120         }
 121 }
 122
 123 void fs_error(struct super_block *sb)
 124 {
 125         struct exfat_mount_options *opts = &EXFAT_SB(sb)->options;
 126
 127         if (opts->errors == EXFAT_ERRORS_PANIC) {
 128                 panic("[EXFAT] Filesystem panic from previous error\n");
 129         } else if ((opts->errors == EXFAT_ERRORS_RO) && !sb_rdonly(sb)) {
 130                 sb->s_flags |= SB_RDONLY;
 131                 pr_err("[EXFAT] Filesystem has been set read-only\n");
 132         }
 133 }
 134
 135 /*
 136  *  Cluster Management Functions
 137  */
 138
 139 s32 clear_cluster(struct super_block *sb, u32 clu)
 140 {
 141         sector_t s, n;
 142         s32 ret = FFS_SUCCESS;
 143         struct buffer_head *tmp_bh = NULL;
 144         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 145         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 146
 147         if (clu == CLUSTER_32(0)) { /* FAT16 root_dir */
 148                 s = p_fs->root_start_sector;
 149                 n = p_fs->data_start_sector;
 150         } else {
 151                 s = START_SECTOR(clu);
 152                 n = s + p_fs->sectors_per_clu;
 153         }
 154
 155         for (; s < n; s++) {
 156                 ret = sector_read(sb, s, &tmp_bh, 0);
 157                 if (ret != FFS_SUCCESS)
 158                         return ret;
 159
 160                 memset((char *)tmp_bh->b_data, 0x0, p_bd->sector_size);
 161                 ret = sector_write(sb, s, tmp_bh, 0);
 162                 if (ret != FFS_SUCCESS)
 163                         break;
 164         }
 165
 166         brelse(tmp_bh);
 167         return ret;
 168 }
 169
 170 s32 fat_alloc_cluster(struct super_block *sb, s32 num_alloc,
 171                       struct chain_t *p_chain)
 172 {
 173         int i, num_clusters = 0;
 174         u32 new_clu, last_clu = CLUSTER_32(~0), read_clu;
 175         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 176
 177         new_clu = p_chain->dir;
 178         if (new_clu == CLUSTER_32(~0))
 179                 new_clu = p_fs->clu_srch_ptr;
 180         else if (new_clu >= p_fs->num_clusters)
 181                 new_clu = 2;
 182
 183         __set_sb_dirty(sb);
 184
 185         p_chain->dir = CLUSTER_32(~0);
 186
 187         for (i = 2; i < p_fs->num_clusters; i++) {
 188                 if (FAT_read(sb, new_clu, &read_clu) != 0)
 189                         return -1;
 190
 191                 if (read_clu == CLUSTER_32(0)) {
 192                         if (FAT_write(sb, new_clu, CLUSTER_32(~0)) < 0)
 193                                 return -1;
 194                         num_clusters++;
 195
 196                         if (p_chain->dir == CLUSTER_32(~0)) {
 197                                 p_chain->dir = new_clu;
 198                         } else {
 199                                 if (FAT_write(sb, last_clu, new_clu) < 0)
 200                                         return -1;
 201                         }
 202
 203                         last_clu = new_clu;
 204
 205                         if ((--num_alloc) == 0) {
 206                                 p_fs->clu_srch_ptr = new_clu;
 207                                 if (p_fs->used_clusters != UINT_MAX)
 208                                         p_fs->used_clusters += num_clusters;
 209
 210                                 return num_clusters;
 211                         }
 212                 }
 213                 if ((++new_clu) >= p_fs->num_clusters)
 214                         new_clu = 2;
 215         }
 216
 217         p_fs->clu_srch_ptr = new_clu;
 218         if (p_fs->used_clusters != UINT_MAX)
 219                 p_fs->used_clusters += num_clusters;
 220
 221         return num_clusters;
 222 }
 223
 224 s32 exfat_alloc_cluster(struct super_block *sb, s32 num_alloc,
 225                         struct chain_t *p_chain)
 226 {
 227         s32 num_clusters = 0;
 228         u32 hint_clu, new_clu, last_clu = CLUSTER_32(~0);
 229         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 230
 231         hint_clu = p_chain->dir;
 232         if (hint_clu == CLUSTER_32(~0)) {
 233                 hint_clu = test_alloc_bitmap(sb, p_fs->clu_srch_ptr - 2);
 234                 if (hint_clu == CLUSTER_32(~0))
 235                         return 0;
 236         } else if (hint_clu >= p_fs->num_clusters) {
 237                 hint_clu = 2;
 238                 p_chain->flags = 0x01;
 239         }
 240
 241         __set_sb_dirty(sb);
 242
 243         p_chain->dir = CLUSTER_32(~0);
 244
 245         while ((new_clu = test_alloc_bitmap(sb, hint_clu - 2)) != CLUSTER_32(~0)) {
 246                 if (new_clu != hint_clu) {
 247                         if (p_chain->flags == 0x03) {
 248                                 exfat_chain_cont_cluster(sb, p_chain->dir,
 249                                                          num_clusters);
 250                                 p_chain->flags = 0x01;
 251                         }
 252                 }
 253
 254                 if (set_alloc_bitmap(sb, new_clu - 2) != FFS_SUCCESS)
 255                         return -1;
 256
 257                 num_clusters++;
 258
 259                 if (p_chain->flags == 0x01) {
 260                         if (FAT_write(sb, new_clu, CLUSTER_32(~0)) < 0)
 261                                 return -1;
 262                 }
 263
 264                 if (p_chain->dir == CLUSTER_32(~0)) {
 265                         p_chain->dir = new_clu;
 266                 } else {
 267                         if (p_chain->flags == 0x01) {
 268                                 if (FAT_write(sb, last_clu, new_clu) < 0)
 269                                         return -1;
 270                         }
 271                 }
 272                 last_clu = new_clu;
 273
 274                 if ((--num_alloc) == 0) {
 275                         p_fs->clu_srch_ptr = hint_clu;
 276                         if (p_fs->used_clusters != UINT_MAX)
 277                                 p_fs->used_clusters += num_clusters;
 278
 279                         p_chain->size += num_clusters;
 280                         return num_clusters;
 281                 }
 282
 283                 hint_clu = new_clu + 1;
 284                 if (hint_clu >= p_fs->num_clusters) {
 285                         hint_clu = 2;
 286
 287                         if (p_chain->flags == 0x03) {
 288                                 exfat_chain_cont_cluster(sb, p_chain->dir,
 289                                                          num_clusters);
 290                                 p_chain->flags = 0x01;
 291                         }
 292                 }
 293         }
 294
 295         p_fs->clu_srch_ptr = hint_clu;
 296         if (p_fs->used_clusters != UINT_MAX)
 297                 p_fs->used_clusters += num_clusters;
 298
 299         p_chain->size += num_clusters;
 300         return num_clusters;
 301 }
 302
 303 void fat_free_cluster(struct super_block *sb, struct chain_t *p_chain,
 304                       s32 do_relse)
 305 {
 306         s32 num_clusters = 0;
 307         u32 clu, prev;
 308         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 309         int i;
 310         sector_t sector;
 311
 312         if ((p_chain->dir == CLUSTER_32(0)) || (p_chain->dir == CLUSTER_32(~0)))
 313                 return;
 314         __set_sb_dirty(sb);
 315         clu = p_chain->dir;
 316
 317         if (p_chain->size <= 0)
 318                 return;
 319
 320         do {
 321                 if (p_fs->dev_ejected)
 322                         break;
 323
 324                 if (do_relse) {
 325                         sector = START_SECTOR(clu);
 326                         for (i = 0; i < p_fs->sectors_per_clu; i++)
 327                                 buf_release(sb, sector + i);
 328                 }
 329
 330                 prev = clu;
 331                 if (FAT_read(sb, clu, &clu) == -1)
 332                         break;
 333
 334                 if (FAT_write(sb, prev, CLUSTER_32(0)) < 0)
 335                         break;
 336                 num_clusters++;
 337
 338         } while (clu != CLUSTER_32(~0));
 339
 340         if (p_fs->used_clusters != UINT_MAX)
 341                 p_fs->used_clusters -= num_clusters;
 342 }
 343
 344 void exfat_free_cluster(struct super_block *sb, struct chain_t *p_chain,
 345                         s32 do_relse)
 346 {
 347         s32 num_clusters = 0;
 348         u32 clu;
 349         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 350         int i;
 351         sector_t sector;
 352
 353         if ((p_chain->dir == CLUSTER_32(0)) || (p_chain->dir == CLUSTER_32(~0)))
 354                 return;
 355
 356         if (p_chain->size <= 0) {
 357                 pr_err("[EXFAT] free_cluster : skip free-req clu:%u, because of zero-size truncation\n",
 358                        p_chain->dir);
 359                 return;
 360         }
 361
 362         __set_sb_dirty(sb);
 363         clu = p_chain->dir;
 364
 365         if (p_chain->flags == 0x03) {
 366                 do {
 367                         if (do_relse) {
 368                                 sector = START_SECTOR(clu);
 369                                 for (i = 0; i < p_fs->sectors_per_clu; i++)
 370                                         buf_release(sb, sector + i);
 371                         }
 372
 373                         if (clr_alloc_bitmap(sb, clu - 2) != FFS_SUCCESS)
 374                                 break;
 375                         clu++;
 376
 377                         num_clusters++;
 378                 } while (num_clusters < p_chain->size);
 379         } else {
 380                 do {
 381                         if (p_fs->dev_ejected)
 382                                 break;
 383
 384                         if (do_relse) {
 385                                 sector = START_SECTOR(clu);
 386                                 for (i = 0; i < p_fs->sectors_per_clu; i++)
 387                                         buf_release(sb, sector + i);
 388                         }
 389
 390                         if (clr_alloc_bitmap(sb, clu - 2) != FFS_SUCCESS)
 391                                 break;
 392
 393                         if (FAT_read(sb, clu, &clu) == -1)
 394                                 break;
 395                         num_clusters++;
 396                 } while ((clu != CLUSTER_32(0)) && (clu != CLUSTER_32(~0)));
 397         }
 398
 399         if (p_fs->used_clusters != UINT_MAX)
 400                 p_fs->used_clusters -= num_clusters;
 401 }
 402
 403 u32 find_last_cluster(struct super_block *sb, struct chain_t *p_chain)
 404 {
 405         u32 clu, next;
 406         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 407
 408         clu = p_chain->dir;
 409
 410         if (p_chain->flags == 0x03) {
 411                 clu += p_chain->size - 1;
 412         } else {
 413                 while ((FAT_read(sb, clu, &next) == 0) &&
 414                        (next != CLUSTER_32(~0))) {
 415                         if (p_fs->dev_ejected)
 416                                 break;
 417                         clu = next;
 418                 }
 419         }
 420
 421         return clu;
 422 }
 423
 424 s32 count_num_clusters(struct super_block *sb, struct chain_t *p_chain)
 425 {
 426         int i, count = 0;
 427         u32 clu;
 428         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 429
 430         if ((p_chain->dir == CLUSTER_32(0)) || (p_chain->dir == CLUSTER_32(~0)))
 431                 return 0;
 432
 433         clu = p_chain->dir;
 434
 435         if (p_chain->flags == 0x03) {
 436                 count = p_chain->size;
 437         } else {
 438                 for (i = 2; i < p_fs->num_clusters; i++) {
 439                         count++;
 440                         if (FAT_read(sb, clu, &clu) != 0)
 441                                 return 0;
 442                         if (clu == CLUSTER_32(~0))
 443                                 break;
 444                 }
 445         }
 446
 447         return count;
 448 }
 449
 450 s32 fat_count_used_clusters(struct super_block *sb)
 451 {
 452         int i, count = 0;
 453         u32 clu;
 454         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 455
 456         for (i = 2; i < p_fs->num_clusters; i++) {
 457                 if (FAT_read(sb, i, &clu) != 0)
 458                         break;
 459                 if (clu != CLUSTER_32(0))
 460                         count++;
 461         }
 462
 463         return count;
 464 }
 465
 466 s32 exfat_count_used_clusters(struct super_block *sb)
 467 {
 468         int i, map_i, map_b, count = 0;
 469         u8 k;
 470         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 471         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 472
 473         map_i = map_b = 0;
 474
 475         for (i = 2; i < p_fs->num_clusters; i += 8) {
 476                 k = *(((u8 *)p_fs->vol_amap[map_i]->b_data) + map_b);
 477                 count += used_bit[k];
 478
 479                 if ((++map_b) >= p_bd->sector_size) {
 480                         map_i++;
 481                         map_b = 0;
 482                 }
 483         }
 484
 485         return count;
 486 }
 487
 488 void exfat_chain_cont_cluster(struct super_block *sb, u32 chain, s32 len)
 489 {
 490         if (len == 0)
 491                 return;
 492
 493         while (len > 1) {
 494                 if (FAT_write(sb, chain, chain + 1) < 0)
 495                         break;
 496                 chain++;
 497                 len--;
 498         }
 499         FAT_write(sb, chain, CLUSTER_32(~0));
 500 }
 501
 502 /*
 503  *  Allocation Bitmap Management Functions
 504  */
 505
 506 s32 load_alloc_bitmap(struct super_block *sb)
 507 {
 508         int i, j, ret;
 509         u32 map_size;
 510         u32 type;
 511         sector_t sector;
 512         struct chain_t clu;
 513         struct bmap_dentry_t *ep;
 514         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 515         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 516
 517         clu.dir = p_fs->root_dir;
 518         clu.flags = 0x01;
 519
 520         while (clu.dir != CLUSTER_32(~0)) {
 521                 if (p_fs->dev_ejected)
 522                         break;
 523
 524                 for (i = 0; i < p_fs->dentries_per_clu; i++) {
 525                         ep = (struct bmap_dentry_t *)get_entry_in_dir(sb, &clu,
 526                                                                       i, NULL);
 527                         if (!ep)
 528                                 return FFS_MEDIAERR;
 529
 530                         type = p_fs->fs_func->get_entry_type((struct dentry_t *)ep);
 531
 532                         if (type == TYPE_UNUSED)
 533                                 break;
 534                         if (type != TYPE_BITMAP)
 535                                 continue;
 536
 537                         if (ep->flags == 0x0) {
 538                                 p_fs->map_clu  = GET32_A(ep->start_clu);
 539                                 map_size = (u32)GET64_A(ep->size);
 540
 541                                 p_fs->map_sectors = ((map_size - 1) >> p_bd->sector_size_bits) + 1;
 542
 543                                 p_fs->vol_amap = kmalloc_array(p_fs->map_sectors,
 544                                                                sizeof(struct buffer_head *),
 545                                                                GFP_KERNEL);
 546                                 if (!p_fs->vol_amap)
 547                                         return FFS_MEMORYERR;
 548
 549                                 sector = START_SECTOR(p_fs->map_clu);
 550
 551                                 for (j = 0; j < p_fs->map_sectors; j++) {
 552                                         p_fs->vol_amap[j] = NULL;
 553                                         ret = sector_read(sb, sector + j, &(p_fs->vol_amap[j]), 1);
 554                                         if (ret != FFS_SUCCESS) {
 555                                                 /*  release all buffers and free vol_amap */
 556                                                 i = 0;
 557                                                 while (i < j)
 558                                                         brelse(p_fs->vol_amap[i++]);
 559
 560                                                 kfree(p_fs->vol_amap);
 561                                                 p_fs->vol_amap = NULL;
 562                                                 return ret;
 563                                         }
 564                                 }
 565
 566                                 p_fs->pbr_bh = NULL;
 567                                 return FFS_SUCCESS;
 568                         }
 569                 }
 570
 571                 if (FAT_read(sb, clu.dir, &clu.dir) != 0)
 572                         return FFS_MEDIAERR;
 573         }
 574
 575         return FFS_FORMATERR;
 576 }
 577
 578 void free_alloc_bitmap(struct super_block *sb)
 579 {
 580         int i;
 581         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 582
 583         brelse(p_fs->pbr_bh);
 584
 585         for (i = 0; i < p_fs->map_sectors; i++)
 586                 __brelse(p_fs->vol_amap[i]);
 587
 588         kfree(p_fs->vol_amap);
 589         p_fs->vol_amap = NULL;
 590 }
 591
 592 s32 set_alloc_bitmap(struct super_block *sb, u32 clu)
 593 {
 594         int i, b;
 595         sector_t sector;
 596         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 597         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 598
 599         i = clu >> (p_bd->sector_size_bits + 3);
 600         b = clu & ((p_bd->sector_size << 3) - 1);
 601
 602         sector = START_SECTOR(p_fs->map_clu) + i;
 603
 604         exfat_bitmap_set((u8 *)p_fs->vol_amap[i]->b_data, b);
 605
 606         return sector_write(sb, sector, p_fs->vol_amap[i], 0);
 607 }
 608
 609 s32 clr_alloc_bitmap(struct super_block *sb, u32 clu)
 610 {
 611         int i, b;
 612         sector_t sector;
 613 #ifdef CONFIG_EXFAT_DISCARD
 614         struct exfat_sb_info *sbi = EXFAT_SB(sb);
 615         struct exfat_mount_options *opts = &sbi->options;
 616         int ret;
 617 #endif /* CONFIG_EXFAT_DISCARD */
 618         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 619         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 620
 621         i = clu >> (p_bd->sector_size_bits + 3);
 622         b = clu & ((p_bd->sector_size << 3) - 1);
 623
 624         sector = START_SECTOR(p_fs->map_clu) + i;
 625
 626         exfat_bitmap_clear((u8 *)p_fs->vol_amap[i]->b_data, b);
 627
 628         return sector_write(sb, sector, p_fs->vol_amap[i], 0);
 629
 630 #ifdef CONFIG_EXFAT_DISCARD
 631         if (opts->discard) {
 632                 ret = sb_issue_discard(sb, START_SECTOR(clu),
 633                                        (1 << p_fs->sectors_per_clu_bits),
 634                                        GFP_NOFS, 0);
 635                 if (ret == -EOPNOTSUPP) {
 636                         pr_warn("discard not supported by device, disabling");
 637                         opts->discard = 0;
 638                 }
 639         }
 640 #endif /* CONFIG_EXFAT_DISCARD */
 641 }
 642
 643 u32 test_alloc_bitmap(struct super_block *sb, u32 clu)
 644 {
 645         int i, map_i, map_b;
 646         u32 clu_base, clu_free;
 647         u8 k, clu_mask;
 648         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 649         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 650
 651         clu_base = (clu & ~(0x7)) + 2;
 652         clu_mask = (1 << (clu - clu_base + 2)) - 1;
 653
 654         map_i = clu >> (p_bd->sector_size_bits + 3);
 655         map_b = (clu >> 3) & p_bd->sector_size_mask;
 656
 657         for (i = 2; i < p_fs->num_clusters; i += 8) {
 658                 k = *(((u8 *)p_fs->vol_amap[map_i]->b_data) + map_b);
 659                 if (clu_mask > 0) {
 660                         k |= clu_mask;
 661                         clu_mask = 0;
 662                 }
 663                 if (k < 0xFF) {
 664                         clu_free = clu_base + free_bit[k];
 665                         if (clu_free < p_fs->num_clusters)
 666                                 return clu_free;
 667                 }
 668                 clu_base += 8;
 669
 670                 if (((++map_b) >= p_bd->sector_size) ||
 671                     (clu_base >= p_fs->num_clusters)) {
 672                         if ((++map_i) >= p_fs->map_sectors) {
 673                                 clu_base = 2;
 674                                 map_i = 0;
 675                         }
 676                         map_b = 0;
 677                 }
 678         }
 679
 680         return CLUSTER_32(~0);
 681 }
 682
 683 void sync_alloc_bitmap(struct super_block *sb)
 684 {
 685         int i;
 686         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 687
 688         if (!p_fs->vol_amap)
 689                 return;
 690
 691         for (i = 0; i < p_fs->map_sectors; i++)
 692                 sync_dirty_buffer(p_fs->vol_amap[i]);
 693 }
 694
 695 /*
 696  *  Upcase table Management Functions
 697  */
 698 static s32 __load_upcase_table(struct super_block *sb, sector_t sector,
 699                                u32 num_sectors, u32 utbl_checksum)
 700 {
 701         int i, ret = FFS_ERROR;
 702         u32 j;
 703         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 704         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 705         struct buffer_head *tmp_bh = NULL;
 706         sector_t end_sector = num_sectors + sector;
 707
 708         bool    skip = false;
 709         u32     index = 0;
 710         u16     uni = 0;
 711         u16 **upcase_table;
 712
 713         u32 checksum = 0;
 714
 715         upcase_table = p_fs->vol_utbl = kmalloc(UTBL_COL_COUNT * sizeof(u16 *),
 716                                                 GFP_KERNEL);
 717         if (!upcase_table)
 718                 return FFS_MEMORYERR;
 719         memset(upcase_table, 0, UTBL_COL_COUNT * sizeof(u16 *));
 720
 721         while (sector < end_sector) {
 722                 ret = sector_read(sb, sector, &tmp_bh, 1);
 723                 if (ret != FFS_SUCCESS) {
 724                         pr_debug("sector read (0x%llX)fail\n",
 725                                  (unsigned long long)sector);
 726                         goto error;
 727                 }
 728                 sector++;
 729
 730                 for (i = 0; i < p_bd->sector_size && index <= 0xFFFF; i += 2) {
 731                         uni = GET16(((u8 *)tmp_bh->b_data) + i);
 732
 733                         checksum = ((checksum & 1) ? 0x80000000 : 0) +
 734                                    (checksum >> 1) + *(((u8 *)tmp_bh->b_data) +
 735                                                        i);
 736                         checksum = ((checksum & 1) ? 0x80000000 : 0) +
 737                                    (checksum >> 1) + *(((u8 *)tmp_bh->b_data) +
 738                                                        (i + 1));
 739
 740                         if (skip) {
 741                                 pr_debug("skip from 0x%X ", index);
 742                                 index += uni;
 743                                 pr_debug("to 0x%X (amount of 0x%X)\n",
 744                                          index, uni);
 745                                 skip = false;
 746                         } else if (uni == index) {
 747                                 index++;
 748                         } else if (uni == 0xFFFF) {
 749                                 skip = true;
 750                         } else { /* uni != index , uni != 0xFFFF */
 751                                 u16 col_index = get_col_index(index);
 752
 753                                 if (!upcase_table[col_index]) {
 754                                         pr_debug("alloc = 0x%X\n", col_index);
 755                                         upcase_table[col_index] = kmalloc_array(UTBL_ROW_COUNT,
 756                                                 sizeof(u16), GFP_KERNEL);
 757                                         if (!upcase_table[col_index]) {
 758                                                 ret = FFS_MEMORYERR;
 759                                                 goto error;
 760                                         }
 761
 762                                         for (j = 0; j < UTBL_ROW_COUNT; j++)
 763                                                 upcase_table[col_index][j] = (col_index << LOW_INDEX_BIT) | j;
 764                                 }
 765
 766                                 upcase_table[col_index][get_row_index(index)] = uni;
 767                                 index++;
 768                         }
 769                 }
 770         }
 771         if (index >= 0xFFFF && utbl_checksum == checksum) {
 772                 if (tmp_bh)
 773                         brelse(tmp_bh);
 774                 return FFS_SUCCESS;
 775         }
 776         ret = FFS_ERROR;
 777 error:
 778         if (tmp_bh)
 779                 brelse(tmp_bh);
 780         free_upcase_table(sb);
 781         return ret;
 782 }
 783
 784 static s32 __load_default_upcase_table(struct super_block *sb)
 785 {
 786         int i, ret = FFS_ERROR;
 787         u32 j;
 788         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 789
 790         bool    skip = false;
 791         u32     index = 0;
 792         u16     uni = 0;
 793         u16 **upcase_table;
 794
 795         upcase_table = p_fs->vol_utbl = kmalloc(UTBL_COL_COUNT * sizeof(u16 *),
 796                                                 GFP_KERNEL);
 797         if (!upcase_table)
 798                 return FFS_MEMORYERR;
 799         memset(upcase_table, 0, UTBL_COL_COUNT * sizeof(u16 *));
 800
 801         for (i = 0; index <= 0xFFFF && i < NUM_UPCASE * 2; i += 2) {
 802                 uni = GET16(uni_upcase + i);
 803                 if (skip) {
 804                         pr_debug("skip from 0x%X ", index);
 805                         index += uni;
 806                         pr_debug("to 0x%X (amount of 0x%X)\n", index, uni);
 807                         skip = false;
 808                 } else if (uni == index) {
 809                         index++;
 810                 } else if (uni == 0xFFFF) {
 811                         skip = true;
 812                 } else { /* uni != index , uni != 0xFFFF */
 813                         u16 col_index = get_col_index(index);
 814
 815                         if (!upcase_table[col_index]) {
 816                                 pr_debug("alloc = 0x%X\n", col_index);
 817                                 upcase_table[col_index] = kmalloc_array(UTBL_ROW_COUNT,
 818                                                                         sizeof(u16),
 819                                                                         GFP_KERNEL);
 820                                 if (!upcase_table[col_index]) {
 821                                         ret = FFS_MEMORYERR;
 822                                         goto error;
 823                                 }
 824
 825                                 for (j = 0; j < UTBL_ROW_COUNT; j++)
 826                                         upcase_table[col_index][j] = (col_index << LOW_INDEX_BIT) | j;
 827                         }
 828
 829                         upcase_table[col_index][get_row_index(index)] = uni;
 830                         index++;
 831                 }
 832         }
 833
 834         if (index >= 0xFFFF)
 835                 return FFS_SUCCESS;
 836
 837 error:
 838         /* FATAL error: default upcase table has error */
 839         free_upcase_table(sb);
 840         return ret;
 841 }
 842
 843 s32 load_upcase_table(struct super_block *sb)
 844 {
 845         int i;
 846         u32 tbl_clu, tbl_size;
 847         sector_t sector;
 848         u32 type, num_sectors;
 849         struct chain_t clu;
 850         struct case_dentry_t *ep;
 851         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 852         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 853
 854         clu.dir = p_fs->root_dir;
 855         clu.flags = 0x01;
 856
 857         if (p_fs->dev_ejected)
 858                 return FFS_MEDIAERR;
 859
 860         while (clu.dir != CLUSTER_32(~0)) {
 861                 for (i = 0; i < p_fs->dentries_per_clu; i++) {
 862                         ep = (struct case_dentry_t *)get_entry_in_dir(sb, &clu,
 863                                                                       i, NULL);
 864                         if (!ep)
 865                                 return FFS_MEDIAERR;
 866
 867                         type = p_fs->fs_func->get_entry_type((struct dentry_t *)ep);
 868
 869                         if (type == TYPE_UNUSED)
 870                                 break;
 871                         if (type != TYPE_UPCASE)
 872                                 continue;
 873
 874                         tbl_clu  = GET32_A(ep->start_clu);
 875                         tbl_size = (u32)GET64_A(ep->size);
 876
 877                         sector = START_SECTOR(tbl_clu);
 878                         num_sectors = ((tbl_size - 1) >> p_bd->sector_size_bits) + 1;
 879                         if (__load_upcase_table(sb, sector, num_sectors,
 880                                                 GET32_A(ep->checksum)) != FFS_SUCCESS)
 881                                 break;
 882                         return FFS_SUCCESS;
 883                 }
 884                 if (FAT_read(sb, clu.dir, &clu.dir) != 0)
 885                         return FFS_MEDIAERR;
 886         }
 887         /* load default upcase table */
 888         return __load_default_upcase_table(sb);
 889 }
 890
 891 void free_upcase_table(struct super_block *sb)
 892 {
 893         u32 i;
 894         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 895         u16 **upcase_table;
 896
 897         upcase_table = p_fs->vol_utbl;
 898         for (i = 0; i < UTBL_COL_COUNT; i++)
 899                 kfree(upcase_table[i]);
 900
 901         kfree(p_fs->vol_utbl);
 902         p_fs->vol_utbl = NULL;
 903 }
 904
 905 /*
 906  *  Directory Entry Management Functions
 907  */
 908
 909 u32 fat_get_entry_type(struct dentry_t *p_entry)
 910 {
 911         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
 912
 913         if (*(ep->name) == 0x0)
 914                 return TYPE_UNUSED;
 915
 916         else if (*(ep->name) == 0xE5)
 917                 return TYPE_DELETED;
 918
 919         else if (ep->attr == ATTR_EXTEND)
 920                 return TYPE_EXTEND;
 921
 922         else if ((ep->attr & (ATTR_SUBDIR | ATTR_VOLUME)) == ATTR_VOLUME)
 923                 return TYPE_VOLUME;
 924
 925         else if ((ep->attr & (ATTR_SUBDIR | ATTR_VOLUME)) == ATTR_SUBDIR)
 926                 return TYPE_DIR;
 927
 928         return TYPE_FILE;
 929 }
 930
 931 u32 exfat_get_entry_type(struct dentry_t *p_entry)
 932 {
 933         struct file_dentry_t *ep = (struct file_dentry_t *)p_entry;
 934
 935         if (ep->type == 0x0) {
 936                 return TYPE_UNUSED;
 937         } else if (ep->type < 0x80) {
 938                 return TYPE_DELETED;
 939         } else if (ep->type == 0x80) {
 940                 return TYPE_INVALID;
 941         } else if (ep->type < 0xA0) {
 942                 if (ep->type == 0x81) {
 943                         return TYPE_BITMAP;
 944                 } else if (ep->type == 0x82) {
 945                         return TYPE_UPCASE;
 946                 } else if (ep->type == 0x83) {
 947                         return TYPE_VOLUME;
 948                 } else if (ep->type == 0x85) {
 949                         if (GET16_A(ep->attr) & ATTR_SUBDIR)
 950                                 return TYPE_DIR;
 951                         else
 952                                 return TYPE_FILE;
 953                 }
 954                 return TYPE_CRITICAL_PRI;
 955         } else if (ep->type < 0xC0) {
 956                 if (ep->type == 0xA0)
 957                         return TYPE_GUID;
 958                 else if (ep->type == 0xA1)
 959                         return TYPE_PADDING;
 960                 else if (ep->type == 0xA2)
 961                         return TYPE_ACLTAB;
 962                 return TYPE_BENIGN_PRI;
 963         } else if (ep->type < 0xE0) {
 964                 if (ep->type == 0xC0)
 965                         return TYPE_STREAM;
 966                 else if (ep->type == 0xC1)
 967                         return TYPE_EXTEND;
 968                 else if (ep->type == 0xC2)
 969                         return TYPE_ACL;
 970                 return TYPE_CRITICAL_SEC;
 971         }
 972
 973         return TYPE_BENIGN_SEC;
 974 }
 975
 976 void fat_set_entry_type(struct dentry_t *p_entry, u32 type)
 977 {
 978         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
 979
 980         if (type == TYPE_UNUSED)
 981                 *(ep->name) = 0x0;
 982
 983         else if (type == TYPE_DELETED)
 984                 *(ep->name) = 0xE5;
 985
 986         else if (type == TYPE_EXTEND)
 987                 ep->attr = ATTR_EXTEND;
 988
 989         else if (type == TYPE_DIR)
 990                 ep->attr = ATTR_SUBDIR;
 991
 992         else if (type == TYPE_FILE)
 993                 ep->attr = ATTR_ARCHIVE;
 994
 995         else if (type == TYPE_SYMLINK)
 996                 ep->attr = ATTR_ARCHIVE | ATTR_SYMLINK;
 997 }
 998
 999 void exfat_set_entry_type(struct dentry_t *p_entry, u32 type)
1000 {
1001         struct file_dentry_t *ep = (struct file_dentry_t *)p_entry;
1002
1003         if (type == TYPE_UNUSED) {
1004                 ep->type = 0x0;
1005         } else if (type == TYPE_DELETED) {
1006                 ep->type &= ~0x80;
1007         } else if (type == TYPE_STREAM) {
1008                 ep->type = 0xC0;
1009         } else if (type == TYPE_EXTEND) {
1010                 ep->type = 0xC1;
1011         } else if (type == TYPE_BITMAP) {
1012                 ep->type = 0x81;
1013         } else if (type == TYPE_UPCASE) {
1014                 ep->type = 0x82;
1015         } else if (type == TYPE_VOLUME) {
1016                 ep->type = 0x83;
1017         } else if (type == TYPE_DIR) {
1018                 ep->type = 0x85;
1019                 SET16_A(ep->attr, ATTR_SUBDIR);
1020         } else if (type == TYPE_FILE) {
1021                 ep->type = 0x85;
1022                 SET16_A(ep->attr, ATTR_ARCHIVE);
1023         } else if (type == TYPE_SYMLINK) {
1024                 ep->type = 0x85;
1025                 SET16_A(ep->attr, ATTR_ARCHIVE | ATTR_SYMLINK);
1026         }
1027 }
1028
1029 u32 fat_get_entry_attr(struct dentry_t *p_entry)
1030 {
1031         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1032
1033         return (u32)ep->attr;
1034 }
1035
1036 u32 exfat_get_entry_attr(struct dentry_t *p_entry)
1037 {
1038         struct file_dentry_t *ep = (struct file_dentry_t *)p_entry;
1039
1040         return (u32)GET16_A(ep->attr);
1041 }
1042
1043 void fat_set_entry_attr(struct dentry_t *p_entry, u32 attr)
1044 {
1045         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1046
1047         ep->attr = (u8)attr;
1048 }
1049
1050 void exfat_set_entry_attr(struct dentry_t *p_entry, u32 attr)
1051 {
1052         struct file_dentry_t *ep = (struct file_dentry_t *)p_entry;
1053
1054         SET16_A(ep->attr, (u16)attr);
1055 }
1056
1057 u8 fat_get_entry_flag(struct dentry_t *p_entry)
1058 {
1059         return 0x01;
1060 }
1061
1062 u8 exfat_get_entry_flag(struct dentry_t *p_entry)
1063 {
1064         struct strm_dentry_t *ep = (struct strm_dentry_t *)p_entry;
1065
1066         return ep->flags;
1067 }
1068
1069 void fat_set_entry_flag(struct dentry_t *p_entry, u8 flags)
1070 {
1071 }
1072
1073 void exfat_set_entry_flag(struct dentry_t *p_entry, u8 flags)
1074 {
1075         struct strm_dentry_t *ep = (struct strm_dentry_t *)p_entry;
1076
1077         ep->flags = flags;
1078 }
1079
1080 u32 fat_get_entry_clu0(struct dentry_t *p_entry)
1081 {
1082         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1083
1084         return ((u32)GET16_A(ep->start_clu_hi) << 16) |
1085                 GET16_A(ep->start_clu_lo);
1086 }
1087
1088 u32 exfat_get_entry_clu0(struct dentry_t *p_entry)
1089 {
1090         struct strm_dentry_t *ep = (struct strm_dentry_t *)p_entry;
1091
1092         return GET32_A(ep->start_clu);
1093 }
1094
1095 void fat_set_entry_clu0(struct dentry_t *p_entry, u32 start_clu)
1096 {
1097         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1098
1099         SET16_A(ep->start_clu_lo, CLUSTER_16(start_clu));
1100         SET16_A(ep->start_clu_hi, CLUSTER_16(start_clu >> 16));
1101 }
1102
1103 void exfat_set_entry_clu0(struct dentry_t *p_entry, u32 start_clu)
1104 {
1105         struct strm_dentry_t *ep = (struct strm_dentry_t *)p_entry;
1106
1107         SET32_A(ep->start_clu, start_clu);
1108 }
1109
1110 u64 fat_get_entry_size(struct dentry_t *p_entry)
1111 {
1112         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1113
1114         return (u64)GET32_A(ep->size);
1115 }
1116
1117 u64 exfat_get_entry_size(struct dentry_t *p_entry)
1118 {
1119         struct strm_dentry_t *ep = (struct strm_dentry_t *)p_entry;
1120
1121         return GET64_A(ep->valid_size);
1122 }
1123
1124 void fat_set_entry_size(struct dentry_t *p_entry, u64 size)
1125 {
1126         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1127
1128         SET32_A(ep->size, (u32)size);
1129 }
1130
1131 void exfat_set_entry_size(struct dentry_t *p_entry, u64 size)
1132 {
1133         struct strm_dentry_t *ep = (struct strm_dentry_t *)p_entry;
1134
1135         SET64_A(ep->valid_size, size);
1136         SET64_A(ep->size, size);
1137 }
1138
1139 void fat_get_entry_time(struct dentry_t *p_entry, struct timestamp_t *tp,
1140                         u8 mode)
1141 {
1142         u16 t = 0x00, d = 0x21;
1143         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1144
1145         switch (mode) {
1146         case TM_CREATE:
1147                 t = GET16_A(ep->create_time);
1148                 d = GET16_A(ep->create_date);
1149                 break;
1150         case TM_MODIFY:
1151                 t = GET16_A(ep->modify_time);
1152                 d = GET16_A(ep->modify_date);
1153                 break;
1154         }
1155
1156         tp->sec  = (t & 0x001F) << 1;
1157         tp->min  = (t >> 5) & 0x003F;
1158         tp->hour = (t >> 11);
1159         tp->day  = (d & 0x001F);
1160         tp->mon  = (d >> 5) & 0x000F;
1161         tp->year = (d >> 9);
1162 }
1163
1164 void exfat_get_entry_time(struct dentry_t *p_entry, struct timestamp_t *tp,
1165                           u8 mode)
1166 {
1167         u16 t = 0x00, d = 0x21;
1168         struct file_dentry_t *ep = (struct file_dentry_t *)p_entry;
1169
1170         switch (mode) {
1171         case TM_CREATE:
1172                 t = GET16_A(ep->create_time);
1173                 d = GET16_A(ep->create_date);
1174                 break;
1175         case TM_MODIFY:
1176                 t = GET16_A(ep->modify_time);
1177                 d = GET16_A(ep->modify_date);
1178                 break;
1179         case TM_ACCESS:
1180                 t = GET16_A(ep->access_time);
1181                 d = GET16_A(ep->access_date);
1182                 break;
1183         }
1184
1185         tp->sec  = (t & 0x001F) << 1;
1186         tp->min  = (t >> 5) & 0x003F;
1187         tp->hour = (t >> 11);
1188         tp->day  = (d & 0x001F);
1189         tp->mon  = (d >> 5) & 0x000F;
1190         tp->year = (d >> 9);
1191 }
1192
1193 void fat_set_entry_time(struct dentry_t *p_entry, struct timestamp_t *tp,
1194                         u8 mode)
1195 {
1196         u16 t, d;
1197         struct dos_dentry_t *ep = (struct dos_dentry_t *)p_entry;
1198
1199         t = (tp->hour << 11) | (tp->min << 5) | (tp->sec >> 1);
1200         d = (tp->year <<  9) | (tp->mon << 5) |  tp->day;
1201
1202         switch (mode) {
1203         case TM_CREATE:
1204                 SET16_A(ep->create_time, t);
1205                 SET16_A(ep->create_date, d);
1206                 break;
1207         case TM_MODIFY:
1208                 SET16_A(ep->modify_time, t);
1209                 SET16_A(ep->modify_date, d);
1210                 break;
1211         }
1212 }
1213
1214 void exfat_set_entry_time(struct dentry_t *p_entry, struct timestamp_t *tp,
1215                           u8 mode)
1216 {
1217         u16 t, d;
1218         struct file_dentry_t *ep = (struct file_dentry_t *)p_entry;
1219
1220         t = (tp->hour << 11) | (tp->min << 5) | (tp->sec >> 1);
1221         d = (tp->year <<  9) | (tp->mon << 5) |  tp->day;
1222
1223         switch (mode) {
1224         case TM_CREATE:
1225                 SET16_A(ep->create_time, t);
1226                 SET16_A(ep->create_date, d);
1227                 break;
1228         case TM_MODIFY:
1229                 SET16_A(ep->modify_time, t);
1230                 SET16_A(ep->modify_date, d);
1231                 break;
1232         case TM_ACCESS:
1233                 SET16_A(ep->access_time, t);
1234                 SET16_A(ep->access_date, d);
1235                 break;
1236         }
1237 }
1238
1239 s32 fat_init_dir_entry(struct super_block *sb, struct chain_t *p_dir, s32 entry,
1240                        u32 type, u32 start_clu, u64 size)
1241 {
1242         sector_t sector;
1243         struct dos_dentry_t *dos_ep;
1244
1245         dos_ep = (struct dos_dentry_t *)get_entry_in_dir(sb, p_dir, entry,
1246                                                          &sector);
1247         if (!dos_ep)
1248                 return FFS_MEDIAERR;
1249
1250         init_dos_entry(dos_ep, type, start_clu);
1251         buf_modify(sb, sector);
1252
1253         return FFS_SUCCESS;
1254 }
1255
1256 s32 exfat_init_dir_entry(struct super_block *sb, struct chain_t *p_dir,
1257                          s32 entry, u32 type, u32 start_clu, u64 size)
1258 {
1259         sector_t sector;
1260         u8 flags;
1261         struct file_dentry_t *file_ep;
1262         struct strm_dentry_t *strm_ep;
1263
1264         flags = (type == TYPE_FILE) ? 0x01 : 0x03;
1265
1266         /* we cannot use get_entry_set_in_dir here because file ep is not initialized yet */
1267         file_ep = (struct file_dentry_t *)get_entry_in_dir(sb, p_dir, entry,
1268                                                            &sector);
1269         if (!file_ep)
1270                 return FFS_MEDIAERR;
1271
1272         strm_ep = (struct strm_dentry_t *)get_entry_in_dir(sb, p_dir, entry + 1,
1273                                                            &sector);
1274         if (!strm_ep)
1275                 return FFS_MEDIAERR;
1276
1277         init_file_entry(file_ep, type);
1278         buf_modify(sb, sector);
1279
1280         init_strm_entry(strm_ep, flags, start_clu, size);
1281         buf_modify(sb, sector);
1282
1283         return FFS_SUCCESS;
1284 }
1285
1286 static s32 fat_init_ext_entry(struct super_block *sb, struct chain_t *p_dir,
1287                               s32 entry, s32 num_entries,
1288                               struct uni_name_t *p_uniname,
1289                               struct dos_name_t *p_dosname)
1290 {
1291         int i;
1292         sector_t sector;
1293         u8 chksum;
1294         u16 *uniname = p_uniname->name;
1295         struct dos_dentry_t *dos_ep;
1296         struct ext_dentry_t *ext_ep;
1297
1298         dos_ep = (struct dos_dentry_t *)get_entry_in_dir(sb, p_dir, entry,
1299                                                          &sector);
1300         if (!dos_ep)
1301                 return FFS_MEDIAERR;
1302
1303         dos_ep->lcase = p_dosname->name_case;
1304         memcpy(dos_ep->name, p_dosname->name, DOS_NAME_LENGTH);
1305         buf_modify(sb, sector);
1306
1307         if ((--num_entries) > 0) {
1308                 chksum = calc_checksum_1byte((void *)dos_ep->name,
1309                                              DOS_NAME_LENGTH, 0);
1310
1311                 for (i = 1; i < num_entries; i++) {
1312                         ext_ep = (struct ext_dentry_t *)get_entry_in_dir(sb,
1313                                                                          p_dir,
1314                                                                          entry - i,
1315                                                                          &sector);
1316                         if (!ext_ep)
1317                                 return FFS_MEDIAERR;
1318
1319                         init_ext_entry(ext_ep, i, chksum, uniname);
1320                         buf_modify(sb, sector);
1321                         uniname += 13;
1322                 }
1323
1324                 ext_ep = (struct ext_dentry_t *)get_entry_in_dir(sb, p_dir,
1325                                                                  entry - i,
1326                                                                  &sector);
1327                 if (!ext_ep)
1328                         return FFS_MEDIAERR;
1329
1330                 init_ext_entry(ext_ep, i + 0x40, chksum, uniname);
1331                 buf_modify(sb, sector);
1332         }
1333
1334         return FFS_SUCCESS;
1335 }
1336
1337 static s32 exfat_init_ext_entry(struct super_block *sb, struct chain_t *p_dir,
1338                                 s32 entry, s32 num_entries,
1339                                 struct uni_name_t *p_uniname,
1340                                 struct dos_name_t *p_dosname)
1341 {
1342         int i;
1343         sector_t sector;
1344         u16 *uniname = p_uniname->name;
1345         struct file_dentry_t *file_ep;
1346         struct strm_dentry_t *strm_ep;
1347         struct name_dentry_t *name_ep;
1348
1349         file_ep = (struct file_dentry_t *)get_entry_in_dir(sb, p_dir, entry,
1350                                                            &sector);
1351         if (!file_ep)
1352                 return FFS_MEDIAERR;
1353
1354         file_ep->num_ext = (u8)(num_entries - 1);
1355         buf_modify(sb, sector);
1356
1357         strm_ep = (struct strm_dentry_t *)get_entry_in_dir(sb, p_dir, entry + 1,
1358                                                            &sector);
1359         if (!strm_ep)
1360                 return FFS_MEDIAERR;
1361
1362         strm_ep->name_len = p_uniname->name_len;
1363         SET16_A(strm_ep->name_hash, p_uniname->name_hash);
1364         buf_modify(sb, sector);
1365
1366         for (i = 2; i < num_entries; i++) {
1367                 name_ep = (struct name_dentry_t *)get_entry_in_dir(sb, p_dir,
1368                                                                    entry + i,
1369                                                                    &sector);
1370                 if (!name_ep)
1371                         return FFS_MEDIAERR;
1372
1373                 init_name_entry(name_ep, uniname);
1374                 buf_modify(sb, sector);
1375                 uniname += 15;
1376         }
1377
1378         update_dir_checksum(sb, p_dir, entry);
1379
1380         return FFS_SUCCESS;
1381 }
1382
1383 void init_dos_entry(struct dos_dentry_t *ep, u32 type, u32 start_clu)
1384 {
1385         struct timestamp_t tm, *tp;
1386
1387         fat_set_entry_type((struct dentry_t *)ep, type);
1388         SET16_A(ep->start_clu_lo, CLUSTER_16(start_clu));
1389         SET16_A(ep->start_clu_hi, CLUSTER_16(start_clu >> 16));
1390         SET32_A(ep->size, 0);
1391
1392         tp = tm_current(&tm);
1393         fat_set_entry_time((struct dentry_t *)ep, tp, TM_CREATE);
1394         fat_set_entry_time((struct dentry_t *)ep, tp, TM_MODIFY);
1395         SET16_A(ep->access_date, 0);
1396         ep->create_time_ms = 0;
1397 }
1398
1399 void init_ext_entry(struct ext_dentry_t *ep, s32 order, u8 chksum, u16 *uniname)
1400 {
1401         int i;
1402         bool end = false;
1403
1404         fat_set_entry_type((struct dentry_t *)ep, TYPE_EXTEND);
1405         ep->order = (u8)order;
1406         ep->sysid = 0;
1407         ep->checksum = chksum;
1408         SET16_A(ep->start_clu, 0);
1409
1410         for (i = 0; i < 10; i += 2) {
1411                 if (!end) {
1412                         SET16(ep->unicode_0_4 + i, *uniname);
1413                         if (*uniname == 0x0)
1414                                 end = true;
1415                         else
1416                                 uniname++;
1417                 } else {
1418                         SET16(ep->unicode_0_4 + i, 0xFFFF);
1419                 }
1420         }
1421
1422         for (i = 0; i < 12; i += 2) {
1423                 if (!end) {
1424                         SET16_A(ep->unicode_5_10 + i, *uniname);
1425                         if (*uniname == 0x0)
1426                                 end = true;
1427                         else
1428                                 uniname++;
1429                 } else {
1430                         SET16_A(ep->unicode_5_10 + i, 0xFFFF);
1431                 }
1432         }
1433
1434         for (i = 0; i < 4; i += 2) {
1435                 if (!end) {
1436                         SET16_A(ep->unicode_11_12 + i, *uniname);
1437                         if (*uniname == 0x0)
1438                                 end = true;
1439                         else
1440                                 uniname++;
1441                 } else {
1442                         SET16_A(ep->unicode_11_12 + i, 0xFFFF);
1443                 }
1444         }
1445 }
1446
1447 void init_file_entry(struct file_dentry_t *ep, u32 type)
1448 {
1449         struct timestamp_t tm, *tp;
1450
1451         exfat_set_entry_type((struct dentry_t *)ep, type);
1452
1453         tp = tm_current(&tm);
1454         exfat_set_entry_time((struct dentry_t *)ep, tp, TM_CREATE);
1455         exfat_set_entry_time((struct dentry_t *)ep, tp, TM_MODIFY);
1456         exfat_set_entry_time((struct dentry_t *)ep, tp, TM_ACCESS);
1457         ep->create_time_ms = 0;
1458         ep->modify_time_ms = 0;
1459         ep->access_time_ms = 0;
1460 }
1461
1462 void init_strm_entry(struct strm_dentry_t *ep, u8 flags, u32 start_clu, u64 size)
1463 {
1464         exfat_set_entry_type((struct dentry_t *)ep, TYPE_STREAM);
1465         ep->flags = flags;
1466         SET32_A(ep->start_clu, start_clu);
1467         SET64_A(ep->valid_size, size);
1468         SET64_A(ep->size, size);
1469 }
1470
1471 void init_name_entry(struct name_dentry_t *ep, u16 *uniname)
1472 {
1473         int i;
1474
1475         exfat_set_entry_type((struct dentry_t *)ep, TYPE_EXTEND);
1476         ep->flags = 0x0;
1477
1478         for (i = 0; i < 30; i++, i++) {
1479                 SET16_A(ep->unicode_0_14 + i, *uniname);
1480                 if (*uniname == 0x0)
1481                         break;
1482                 uniname++;
1483         }
1484 }
1485
1486 void fat_delete_dir_entry(struct super_block *sb, struct chain_t *p_dir,
1487                 s32 entry, s32 order, s32 num_entries)
1488 {
1489         int i;
1490         sector_t sector;
1491         struct dentry_t *ep;
1492         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1493
1494         for (i = num_entries - 1; i >= order; i--) {
1495                 ep = get_entry_in_dir(sb, p_dir, entry - i, &sector);
1496                 if (!ep)
1497                         return;
1498
1499                 p_fs->fs_func->set_entry_type(ep, TYPE_DELETED);
1500                 buf_modify(sb, sector);
1501         }
1502 }
1503
1504 void exfat_delete_dir_entry(struct super_block *sb, struct chain_t *p_dir,
1505                 s32 entry, s32 order, s32 num_entries)
1506 {
1507         int i;
1508         sector_t sector;
1509         struct dentry_t *ep;
1510         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1511
1512         for (i = order; i < num_entries; i++) {
1513                 ep = get_entry_in_dir(sb, p_dir, entry + i, &sector);
1514                 if (!ep)
1515                         return;
1516
1517                 p_fs->fs_func->set_entry_type(ep, TYPE_DELETED);
1518                 buf_modify(sb, sector);
1519         }
1520 }
1521
1522 void update_dir_checksum(struct super_block *sb, struct chain_t *p_dir,
1523                          s32 entry)
1524 {
1525         int i, num_entries;
1526         sector_t sector;
1527         u16 chksum;
1528         struct file_dentry_t *file_ep;
1529         struct dentry_t *ep;
1530
1531         file_ep = (struct file_dentry_t *)get_entry_in_dir(sb, p_dir, entry,
1532                                                            &sector);
1533         if (!file_ep)
1534                 return;
1535
1536         buf_lock(sb, sector);
1537
1538         num_entries = (s32)file_ep->num_ext + 1;
1539         chksum = calc_checksum_2byte((void *)file_ep, DENTRY_SIZE, 0,
1540                                      CS_DIR_ENTRY);
1541
1542         for (i = 1; i < num_entries; i++) {
1543                 ep = get_entry_in_dir(sb, p_dir, entry + i, NULL);
1544                 if (!ep) {
1545                         buf_unlock(sb, sector);
1546                         return;
1547                 }
1548
1549                 chksum = calc_checksum_2byte((void *)ep, DENTRY_SIZE, chksum,
1550                                              CS_DEFAULT);
1551         }
1552
1553         SET16_A(file_ep->checksum, chksum);
1554         buf_modify(sb, sector);
1555         buf_unlock(sb, sector);
1556 }
1557
1558 void update_dir_checksum_with_entry_set(struct super_block *sb,
1559                                         struct entry_set_cache_t *es)
1560 {
1561         struct dentry_t *ep;
1562         u16 chksum = 0;
1563         s32 chksum_type = CS_DIR_ENTRY, i;
1564
1565         ep = (struct dentry_t *)&(es->__buf);
1566         for (i = 0; i < es->num_entries; i++) {
1567                 pr_debug("%s ep %p\n", __func__, ep);
1568                 chksum = calc_checksum_2byte((void *)ep, DENTRY_SIZE, chksum,
1569                                              chksum_type);
1570                 ep++;
1571                 chksum_type = CS_DEFAULT;
1572         }
1573
1574         ep = (struct dentry_t *)&(es->__buf);
1575         SET16_A(((struct file_dentry_t *)ep)->checksum, chksum);
1576         write_whole_entry_set(sb, es);
1577 }
1578
1579 static s32 _walk_fat_chain(struct super_block *sb, struct chain_t *p_dir,
1580                            s32 byte_offset, u32 *clu)
1581 {
1582         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1583         s32 clu_offset;
1584         u32 cur_clu;
1585
1586         clu_offset = byte_offset >> p_fs->cluster_size_bits;
1587         cur_clu = p_dir->dir;
1588
1589         if (p_dir->flags == 0x03) {
1590                 cur_clu += clu_offset;
1591         } else {
1592                 while (clu_offset > 0) {
1593                         if (FAT_read(sb, cur_clu, &cur_clu) == -1)
1594                                 return FFS_MEDIAERR;
1595                         clu_offset--;
1596                 }
1597         }
1598
1599         if (clu)
1600                 *clu = cur_clu;
1601         return FFS_SUCCESS;
1602 }
1603
1604 s32 find_location(struct super_block *sb, struct chain_t *p_dir, s32 entry,
1605                   sector_t *sector, s32 *offset)
1606 {
1607         s32 off, ret;
1608         u32 clu = 0;
1609         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1610         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
1611
1612         off = entry << DENTRY_SIZE_BITS;
1613
1614         if (p_dir->dir == CLUSTER_32(0)) { /* FAT16 root_dir */
1615                 *offset = off & p_bd->sector_size_mask;
1616                 *sector = off >> p_bd->sector_size_bits;
1617                 *sector += p_fs->root_start_sector;
1618         } else {
1619                 ret = _walk_fat_chain(sb, p_dir, off, &clu);
1620                 if (ret != FFS_SUCCESS)
1621                         return ret;
1622
1623                 /* byte offset in cluster */
1624                 off &= p_fs->cluster_size - 1;
1625
1626                 /* byte offset in sector    */
1627                 *offset = off & p_bd->sector_size_mask;
1628
1629                 /* sector offset in cluster */
1630                 *sector = off >> p_bd->sector_size_bits;
1631                 *sector += START_SECTOR(clu);
1632         }
1633         return FFS_SUCCESS;
1634 }
1635
1636 struct dentry_t *get_entry_with_sector(struct super_block *sb, sector_t sector,
1637                                        s32 offset)
1638 {
1639         u8 *buf;
1640
1641         buf = buf_getblk(sb, sector);
1642
1643         if (!buf)
1644                 return NULL;
1645
1646         return (struct dentry_t *)(buf + offset);
1647 }
1648
1649 struct dentry_t *get_entry_in_dir(struct super_block *sb, struct chain_t *p_dir,
1650                                   s32 entry, sector_t *sector)
1651 {
1652         s32 off;
1653         sector_t sec;
1654         u8 *buf;
1655
1656         if (find_location(sb, p_dir, entry, &sec, &off) != FFS_SUCCESS)
1657                 return NULL;
1658
1659         buf = buf_getblk(sb, sec);
1660
1661         if (!buf)
1662                 return NULL;
1663
1664         if (sector)
1665                 *sector = sec;
1666         return (struct dentry_t *)(buf + off);
1667 }
1668
1669 /* returns a set of dentries for a file or dir.
1670  * Note that this is a copy (dump) of dentries so that user should call write_entry_set()
1671  * to apply changes made in this entry set to the real device.
1672  * in:
1673  *   sb+p_dir+entry: indicates a file/dir
1674  *   type:  specifies how many dentries should be included.
1675  * out:
1676  *   file_ep: will point the first dentry(= file dentry) on success
1677  * return:
1678  *   pointer of entry set on success,
1679  *   NULL on failure.
1680  */
1681
1682 #define ES_MODE_STARTED                         0
1683 #define ES_MODE_GET_FILE_ENTRY                  1
1684 #define ES_MODE_GET_STRM_ENTRY                  2
1685 #define ES_MODE_GET_NAME_ENTRY                  3
1686 #define ES_MODE_GET_CRITICAL_SEC_ENTRY          4
1687 struct entry_set_cache_t *get_entry_set_in_dir(struct super_block *sb,
1688                                                struct chain_t *p_dir, s32 entry,
1689                                                u32 type,
1690                                                struct dentry_t **file_ep)
1691 {
1692         s32 off, ret, byte_offset;
1693         u32 clu = 0;
1694         sector_t sec;
1695         u32 entry_type;
1696         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1697         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
1698         struct entry_set_cache_t *es = NULL;
1699         struct dentry_t *ep, *pos;
1700         u8 *buf;
1701         u8 num_entries;
1702         s32 mode = ES_MODE_STARTED;
1703         size_t bufsize;
1704
1705         pr_debug("%s entered p_dir dir %u flags %x size %d\n",
1706                 __func__, p_dir->dir, p_dir->flags, p_dir->size);
1707
1708         byte_offset = entry << DENTRY_SIZE_BITS;
1709         ret = _walk_fat_chain(sb, p_dir, byte_offset, &clu);
1710         if (ret != FFS_SUCCESS)
1711                 return NULL;
1712
1713         /* byte offset in cluster */
1714         byte_offset &= p_fs->cluster_size - 1;
1715
1716         /* byte offset in sector    */
1717         off = byte_offset & p_bd->sector_size_mask;
1718
1719         /* sector offset in cluster */
1720         sec = byte_offset >> p_bd->sector_size_bits;
1721         sec += START_SECTOR(clu);
1722
1723         buf = buf_getblk(sb, sec);
1724         if (!buf)
1725                 goto err_out;
1726
1727         ep = (struct dentry_t *)(buf + off);
1728         entry_type = p_fs->fs_func->get_entry_type(ep);
1729
1730         if ((entry_type != TYPE_FILE)
1731                 && (entry_type != TYPE_DIR))
1732                 goto err_out;
1733
1734         if (type == ES_ALL_ENTRIES)
1735                 num_entries = ((struct file_dentry_t *)ep)->num_ext + 1;
1736         else
1737                 num_entries = type;
1738
1739         bufsize = offsetof(struct entry_set_cache_t, __buf) + (num_entries) *
1740                   sizeof(struct dentry_t);
1741         pr_debug("%s: trying to kmalloc %zx bytes for %d entries\n", __func__,
1742                  bufsize, num_entries);
1743         es = kmalloc(bufsize, GFP_KERNEL);
1744         if (!es)
1745                 goto err_out;
1746
1747         es->num_entries = num_entries;
1748         es->sector = sec;
1749         es->offset = off;
1750         es->alloc_flag = p_dir->flags;
1751
1752         pos = (struct dentry_t *)&es->__buf;
1753
1754         while (num_entries) {
1755                 /*
1756                  * instead of copying whole sector, we will check every entry.
1757                  * this will provide minimum stablity and consistency.
1758                  */
1759                 entry_type = p_fs->fs_func->get_entry_type(ep);
1760
1761                 if ((entry_type == TYPE_UNUSED) || (entry_type == TYPE_DELETED))
1762                         goto err_out;
1763
1764                 switch (mode) {
1765                 case ES_MODE_STARTED:
1766                         if ((entry_type == TYPE_FILE) || (entry_type == TYPE_DIR))
1767                                 mode = ES_MODE_GET_FILE_ENTRY;
1768                         else
1769                                 goto err_out;
1770                         break;
1771                 case ES_MODE_GET_FILE_ENTRY:
1772                         if (entry_type == TYPE_STREAM)
1773                                 mode = ES_MODE_GET_STRM_ENTRY;
1774                         else
1775                                 goto err_out;
1776                         break;
1777                 case ES_MODE_GET_STRM_ENTRY:
1778                         if (entry_type == TYPE_EXTEND)
1779                                 mode = ES_MODE_GET_NAME_ENTRY;
1780                         else
1781                                 goto err_out;
1782                         break;
1783                 case ES_MODE_GET_NAME_ENTRY:
1784                         if (entry_type == TYPE_EXTEND)
1785                                 break;
1786                         else if (entry_type == TYPE_STREAM)
1787                                 goto err_out;
1788                         else if (entry_type & TYPE_CRITICAL_SEC)
1789                                 mode = ES_MODE_GET_CRITICAL_SEC_ENTRY;
1790                         else
1791                                 goto err_out;
1792                         break;
1793                 case ES_MODE_GET_CRITICAL_SEC_ENTRY:
1794                         if ((entry_type == TYPE_EXTEND) ||
1795                             (entry_type == TYPE_STREAM))
1796                                 goto err_out;
1797                         else if ((entry_type & TYPE_CRITICAL_SEC) !=
1798                                  TYPE_CRITICAL_SEC)
1799                                 goto err_out;
1800                         break;
1801                 }
1802
1803                 memcpy(pos, ep, sizeof(struct dentry_t));
1804
1805                 if (--num_entries == 0)
1806                         break;
1807
1808                 if (((off + DENTRY_SIZE) & p_bd->sector_size_mask) <
1809                     (off &  p_bd->sector_size_mask)) {
1810                         /* get the next sector */
1811                         if (IS_LAST_SECTOR_IN_CLUSTER(sec)) {
1812                                 if (es->alloc_flag == 0x03) {
1813                                         clu++;
1814                                 } else {
1815                                         if (FAT_read(sb, clu, &clu) == -1)
1816                                                 goto err_out;
1817                                 }
1818                                 sec = START_SECTOR(clu);
1819                         } else {
1820                                 sec++;
1821                         }
1822                         buf = buf_getblk(sb, sec);
1823                         if (!buf)
1824                                 goto err_out;
1825                         off = 0;
1826                         ep = (struct dentry_t *)(buf);
1827                 } else {
1828                         ep++;
1829                         off += DENTRY_SIZE;
1830                 }
1831                 pos++;
1832         }
1833
1834         if (file_ep)
1835                 *file_ep = (struct dentry_t *)&(es->__buf);
1836
1837         pr_debug("%s exiting es %p sec %llu offset %d flags %d, num_entries %u buf ptr %p\n",
1838                    __func__, es, (unsigned long long)es->sector, es->offset,
1839                    es->alloc_flag, es->num_entries, &es->__buf);
1840         return es;
1841 err_out:
1842         pr_debug("%s exited NULL (es %p)\n", __func__, es);
1843         kfree(es);
1844         return NULL;
1845 }
1846
1847 void release_entry_set(struct entry_set_cache_t *es)
1848 {
1849         pr_debug("%s es=%p\n", __func__, es);
1850         kfree(es);
1851 }
1852
1853 static s32 __write_partial_entries_in_entry_set(struct super_block *sb,
1854                                                 struct entry_set_cache_t *es,
1855                                                 sector_t sec, s32 off, u32 count)
1856 {
1857         s32 num_entries, buf_off = (off - es->offset);
1858         u32 remaining_byte_in_sector, copy_entries;
1859         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1860         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
1861         u32 clu;
1862         u8 *buf, *esbuf = (u8 *)&(es->__buf);
1863
1864         pr_debug("%s entered es %p sec %llu off %d count %d\n",
1865                 __func__, es, (unsigned long long)sec, off, count);
1866         num_entries = count;
1867
1868         while (num_entries) {
1869                 /* white per sector base */
1870                 remaining_byte_in_sector = (1 << p_bd->sector_size_bits) - off;
1871                 copy_entries = min_t(s32,
1872                                      remaining_byte_in_sector >> DENTRY_SIZE_BITS,
1873                                      num_entries);
1874                 buf = buf_getblk(sb, sec);
1875                 if (!buf)
1876                         goto err_out;
1877                 pr_debug("es->buf %p buf_off %u\n", esbuf, buf_off);
1878                 pr_debug("copying %d entries from %p to sector %llu\n",
1879                         copy_entries, (esbuf + buf_off),
1880                         (unsigned long long)sec);
1881                 memcpy(buf + off, esbuf + buf_off,
1882                        copy_entries << DENTRY_SIZE_BITS);
1883                 buf_modify(sb, sec);
1884                 num_entries -= copy_entries;
1885
1886                 if (num_entries) {
1887                         /* get next sector */
1888                         if (IS_LAST_SECTOR_IN_CLUSTER(sec)) {
1889                                 clu = GET_CLUSTER_FROM_SECTOR(sec);
1890                                 if (es->alloc_flag == 0x03) {
1891                                         clu++;
1892                                 } else {
1893                                         if (FAT_read(sb, clu, &clu) == -1)
1894                                                 goto err_out;
1895                                 }
1896                                 sec = START_SECTOR(clu);
1897                         } else {
1898                                 sec++;
1899                         }
1900                         off = 0;
1901                         buf_off += copy_entries << DENTRY_SIZE_BITS;
1902                 }
1903         }
1904
1905         pr_debug("%s exited successfully\n", __func__);
1906         return FFS_SUCCESS;
1907 err_out:
1908         pr_debug("%s failed\n", __func__);
1909         return FFS_ERROR;
1910 }
1911
1912 /* write back all entries in entry set */
1913 s32 write_whole_entry_set(struct super_block *sb, struct entry_set_cache_t *es)
1914 {
1915         return __write_partial_entries_in_entry_set(sb, es, es->sector,
1916                                                     es->offset,
1917                                                     es->num_entries);
1918 }
1919
1920 /* write back some entries in entry set */
1921 s32 write_partial_entries_in_entry_set(struct super_block *sb,
1922         struct entry_set_cache_t *es, struct dentry_t *ep, u32 count)
1923 {
1924         s32 ret, byte_offset, off;
1925         u32 clu = 0;
1926         sector_t sec;
1927         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1928         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
1929         struct chain_t dir;
1930
1931         /* vaidity check */
1932         if (ep + count  > ((struct dentry_t *)&(es->__buf)) + es->num_entries)
1933                 return FFS_ERROR;
1934
1935         dir.dir = GET_CLUSTER_FROM_SECTOR(es->sector);
1936         dir.flags = es->alloc_flag;
1937         dir.size = 0xffffffff;          /* XXX */
1938
1939         byte_offset = (es->sector - START_SECTOR(dir.dir)) <<
1940                         p_bd->sector_size_bits;
1941         byte_offset += ((void **)ep - &(es->__buf)) + es->offset;
1942
1943         ret = _walk_fat_chain(sb, &dir, byte_offset, &clu);
1944         if (ret != FFS_SUCCESS)
1945                 return ret;
1946
1947         /* byte offset in cluster */
1948         byte_offset &= p_fs->cluster_size - 1;
1949
1950         /* byte offset in sector    */
1951         off = byte_offset & p_bd->sector_size_mask;
1952
1953         /* sector offset in cluster */
1954         sec = byte_offset >> p_bd->sector_size_bits;
1955         sec += START_SECTOR(clu);
1956         return __write_partial_entries_in_entry_set(sb, es, sec, off, count);
1957 }
1958
1959 /* search EMPTY CONTINUOUS "num_entries" entries */
1960 s32 search_deleted_or_unused_entry(struct super_block *sb,
1961                                    struct chain_t *p_dir, s32 num_entries)
1962 {
1963         int i, dentry, num_empty = 0;
1964         s32 dentries_per_clu;
1965         u32 type;
1966         struct chain_t clu;
1967         struct dentry_t *ep;
1968         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1969
1970         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
1971                 dentries_per_clu = p_fs->dentries_in_root;
1972         else
1973                 dentries_per_clu = p_fs->dentries_per_clu;
1974
1975         if (p_fs->hint_uentry.dir == p_dir->dir) {
1976                 if (p_fs->hint_uentry.entry == -1)
1977                         return -1;
1978
1979                 clu.dir = p_fs->hint_uentry.clu.dir;
1980                 clu.size = p_fs->hint_uentry.clu.size;
1981                 clu.flags = p_fs->hint_uentry.clu.flags;
1982
1983                 dentry = p_fs->hint_uentry.entry;
1984         } else {
1985                 p_fs->hint_uentry.entry = -1;
1986
1987                 clu.dir = p_dir->dir;
1988                 clu.size = p_dir->size;
1989                 clu.flags = p_dir->flags;
1990
1991                 dentry = 0;
1992         }
1993
1994         while (clu.dir != CLUSTER_32(~0)) {
1995                 if (p_fs->dev_ejected)
1996                         break;
1997
1998                 if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
1999                         i = dentry % dentries_per_clu;
2000                 else
2001                         i = dentry & (dentries_per_clu - 1);
2002
2003                 for (; i < dentries_per_clu; i++, dentry++) {
2004                         ep = get_entry_in_dir(sb, &clu, i, NULL);
2005                         if (!ep)
2006                                 return -1;
2007
2008                         type = p_fs->fs_func->get_entry_type(ep);
2009
2010                         if (type == TYPE_UNUSED) {
2011                                 num_empty++;
2012                                 if (p_fs->hint_uentry.entry == -1) {
2013                                         p_fs->hint_uentry.dir = p_dir->dir;
2014                                         p_fs->hint_uentry.entry = dentry;
2015
2016                                         p_fs->hint_uentry.clu.dir = clu.dir;
2017                                         p_fs->hint_uentry.clu.size = clu.size;
2018                                         p_fs->hint_uentry.clu.flags = clu.flags;
2019                                 }
2020                         } else if (type == TYPE_DELETED) {
2021                                 num_empty++;
2022                         } else {
2023                                 num_empty = 0;
2024                         }
2025
2026                         if (num_empty >= num_entries) {
2027                                 p_fs->hint_uentry.dir = CLUSTER_32(~0);
2028                                 p_fs->hint_uentry.entry = -1;
2029
2030                                 if (p_fs->vol_type == EXFAT)
2031                                         return dentry - (num_entries - 1);
2032                                 else
2033                                         return dentry;
2034                         }
2035                 }
2036
2037                 if (p_dir->dir == CLUSTER_32(0))
2038                         break; /* FAT16 root_dir */
2039
2040                 if (clu.flags == 0x03) {
2041                         if ((--clu.size) > 0)
2042                                 clu.dir++;
2043                         else
2044                                 clu.dir = CLUSTER_32(~0);
2045                 } else {
2046                         if (FAT_read(sb, clu.dir, &clu.dir) != 0)
2047                                 return -1;
2048                 }
2049         }
2050
2051         return -1;
2052 }
2053
2054 s32 find_empty_entry(struct inode *inode, struct chain_t *p_dir, s32 num_entries)
2055 {
2056         s32 ret, dentry;
2057         u32 last_clu;
2058         sector_t sector;
2059         u64 size = 0;
2060         struct chain_t clu;
2061         struct dentry_t *ep = NULL;
2062         struct super_block *sb = inode->i_sb;
2063         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2064         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
2065
2066         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
2067                 return search_deleted_or_unused_entry(sb, p_dir, num_entries);
2068
2069         while ((dentry = search_deleted_or_unused_entry(sb, p_dir, num_entries)) < 0) {
2070                 if (p_fs->dev_ejected)
2071                         break;
2072
2073                 if (p_fs->vol_type == EXFAT) {
2074                         if (p_dir->dir != p_fs->root_dir)
2075                                 size = i_size_read(inode);
2076                 }
2077
2078                 last_clu = find_last_cluster(sb, p_dir);
2079                 clu.dir = last_clu + 1;
2080                 clu.size = 0;
2081                 clu.flags = p_dir->flags;
2082
2083                 /* (1) allocate a cluster */
2084                 ret = p_fs->fs_func->alloc_cluster(sb, 1, &clu);
2085                 if (ret < 1)
2086                         return -1;
2087
2088                 if (clear_cluster(sb, clu.dir) != FFS_SUCCESS)
2089                         return -1;
2090
2091                 /* (2) append to the FAT chain */
2092                 if (clu.flags != p_dir->flags) {
2093                         exfat_chain_cont_cluster(sb, p_dir->dir, p_dir->size);
2094                         p_dir->flags = 0x01;
2095                         p_fs->hint_uentry.clu.flags = 0x01;
2096                 }
2097                 if (clu.flags == 0x01)
2098                         if (FAT_write(sb, last_clu, clu.dir) < 0)
2099                                 return -1;
2100
2101                 if (p_fs->hint_uentry.entry == -1) {
2102                         p_fs->hint_uentry.dir = p_dir->dir;
2103                         p_fs->hint_uentry.entry = p_dir->size << (p_fs->cluster_size_bits - DENTRY_SIZE_BITS);
2104
2105                         p_fs->hint_uentry.clu.dir = clu.dir;
2106                         p_fs->hint_uentry.clu.size = 0;
2107                         p_fs->hint_uentry.clu.flags = clu.flags;
2108                 }
2109                 p_fs->hint_uentry.clu.size++;
2110                 p_dir->size++;
2111
2112                 /* (3) update the directory entry */
2113                 if (p_fs->vol_type == EXFAT) {
2114                         if (p_dir->dir != p_fs->root_dir) {
2115                                 size += p_fs->cluster_size;
2116
2117                                 ep = get_entry_in_dir(sb, &fid->dir,
2118                                                       fid->entry + 1, &sector);
2119                                 if (!ep)
2120                                         return -1;
2121                                 p_fs->fs_func->set_entry_size(ep, size);
2122                                 p_fs->fs_func->set_entry_flag(ep, p_dir->flags);
2123                                 buf_modify(sb, sector);
2124
2125                                 update_dir_checksum(sb, &(fid->dir),
2126                                                     fid->entry);
2127                         }
2128                 }
2129
2130                 i_size_write(inode, i_size_read(inode) + p_fs->cluster_size);
2131                 EXFAT_I(inode)->mmu_private += p_fs->cluster_size;
2132                 EXFAT_I(inode)->fid.size += p_fs->cluster_size;
2133                 EXFAT_I(inode)->fid.flags = p_dir->flags;
2134                 inode->i_blocks += 1 << (p_fs->cluster_size_bits - 9);
2135         }
2136
2137         return dentry;
2138 }
2139
2140 /* return values of fat_find_dir_entry()
2141  * >= 0 : return dir entiry position with the name in dir
2142  * -1 : (root dir, ".") it is the root dir itself
2143  * -2 : entry with the name does not exist
2144  */
2145 s32 fat_find_dir_entry(struct super_block *sb, struct chain_t *p_dir,
2146                        struct uni_name_t *p_uniname, s32 num_entries,
2147                        struct dos_name_t *p_dosname, u32 type)
2148 {
2149         int i, dentry = 0, len;
2150         s32 order = 0;
2151         bool is_feasible_entry = true, has_ext_entry = false;
2152         s32 dentries_per_clu;
2153         u32 entry_type;
2154         u16 entry_uniname[14], *uniname = NULL, unichar;
2155         struct chain_t clu;
2156         struct dentry_t *ep;
2157         struct dos_dentry_t *dos_ep;
2158         struct ext_dentry_t *ext_ep;
2159         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2160
2161         if (p_dir->dir == p_fs->root_dir) {
2162                 if ((!nls_uniname_cmp(sb, p_uniname->name,
2163                                       (u16 *)UNI_CUR_DIR_NAME)) ||
2164                         (!nls_uniname_cmp(sb, p_uniname->name,
2165                                           (u16 *)UNI_PAR_DIR_NAME)))
2166                         return -1; // special case, root directory itself
2167         }
2168
2169         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
2170                 dentries_per_clu = p_fs->dentries_in_root;
2171         else
2172                 dentries_per_clu = p_fs->dentries_per_clu;
2173
2174         clu.dir = p_dir->dir;
2175         clu.flags = p_dir->flags;
2176
2177         while (clu.dir != CLUSTER_32(~0)) {
2178                 if (p_fs->dev_ejected)
2179                         break;
2180
2181                 for (i = 0; i < dentries_per_clu; i++, dentry++) {
2182                         ep = get_entry_in_dir(sb, &clu, i, NULL);
2183                         if (!ep)
2184                                 return -2;
2185
2186                         entry_type = p_fs->fs_func->get_entry_type(ep);
2187
2188                         if ((entry_type == TYPE_FILE) || (entry_type == TYPE_DIR)) {
2189                                 if ((type == TYPE_ALL) || (type == entry_type)) {
2190                                         if (is_feasible_entry && has_ext_entry)
2191                                                 return dentry;
2192
2193                                         dos_ep = (struct dos_dentry_t *)ep;
2194                                         if (!nls_dosname_cmp(sb, p_dosname->name, dos_ep->name))
2195                                                 return dentry;
2196                                 }
2197                                 is_feasible_entry = true;
2198                                 has_ext_entry = false;
2199                         } else if (entry_type == TYPE_EXTEND) {
2200                                 if (is_feasible_entry) {
2201                                         ext_ep = (struct ext_dentry_t *)ep;
2202                                         if (ext_ep->order > 0x40) {
2203                                                 order = (s32)(ext_ep->order - 0x40);
2204                                                 uniname = p_uniname->name + 13 * (order - 1);
2205                                         } else {
2206                                                 order = (s32)ext_ep->order;
2207                                                 uniname -= 13;
2208                                         }
2209
2210                                         len = extract_uni_name_from_ext_entry(ext_ep, entry_uniname, order);
2211
2212                                         unichar = *(uniname + len);
2213                                         *(uniname + len) = 0x0;
2214
2215                                         if (nls_uniname_cmp(sb, uniname, entry_uniname))
2216                                                 is_feasible_entry = false;
2217
2218                                         *(uniname + len) = unichar;
2219                                 }
2220                                 has_ext_entry = true;
2221                         } else if (entry_type == TYPE_UNUSED) {
2222                                 return -2;
2223                         }
2224                         is_feasible_entry = true;
2225                         has_ext_entry = false;
2226                 }
2227
2228                 if (p_dir->dir == CLUSTER_32(0))
2229                         break; /* FAT16 root_dir */
2230
2231                 if (FAT_read(sb, clu.dir, &clu.dir) != 0)
2232                         return -2;
2233         }
2234
2235         return -2;
2236 }
2237
2238 /* return values of exfat_find_dir_entry()
2239  * >= 0 : return dir entiry position with the name in dir
2240  * -1 : (root dir, ".") it is the root dir itself
2241  * -2 : entry with the name does not exist
2242  */
2243 s32 exfat_find_dir_entry(struct super_block *sb, struct chain_t *p_dir,
2244                          struct uni_name_t *p_uniname, s32 num_entries,
2245                          struct dos_name_t *p_dosname, u32 type)
2246 {
2247         int i = 0, dentry = 0, num_ext_entries = 0, len, step;
2248         s32 order = 0;
2249         bool is_feasible_entry = false;
2250         s32 dentries_per_clu, num_empty = 0;
2251         u32 entry_type;
2252         u16 entry_uniname[16], *uniname = NULL, unichar;
2253         struct chain_t clu;
2254         struct dentry_t *ep;
2255         struct file_dentry_t *file_ep;
2256         struct strm_dentry_t *strm_ep;
2257         struct name_dentry_t *name_ep;
2258         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2259
2260         if (p_dir->dir == p_fs->root_dir) {
2261                 if ((!nls_uniname_cmp(sb, p_uniname->name,
2262                                       (u16 *)UNI_CUR_DIR_NAME)) ||
2263                         (!nls_uniname_cmp(sb, p_uniname->name,
2264                                           (u16 *)UNI_PAR_DIR_NAME)))
2265                         return -1; // special case, root directory itself
2266         }
2267
2268         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
2269                 dentries_per_clu = p_fs->dentries_in_root;
2270         else
2271                 dentries_per_clu = p_fs->dentries_per_clu;
2272
2273         clu.dir = p_dir->dir;
2274         clu.size = p_dir->size;
2275         clu.flags = p_dir->flags;
2276
2277         p_fs->hint_uentry.dir = p_dir->dir;
2278         p_fs->hint_uentry.entry = -1;
2279
2280         while (clu.dir != CLUSTER_32(~0)) {
2281                 if (p_fs->dev_ejected)
2282                         break;
2283
2284                 while (i < dentries_per_clu) {
2285                         ep = get_entry_in_dir(sb, &clu, i, NULL);
2286                         if (!ep)
2287                                 return -2;
2288
2289                         entry_type = p_fs->fs_func->get_entry_type(ep);
2290                         step = 1;
2291
2292                         if ((entry_type == TYPE_UNUSED) || (entry_type == TYPE_DELETED)) {
2293                                 is_feasible_entry = false;
2294
2295                                 if (p_fs->hint_uentry.entry == -1) {
2296                                         num_empty++;
2297
2298                                         if (num_empty == 1) {
2299                                                 p_fs->hint_uentry.clu.dir = clu.dir;
2300                                                 p_fs->hint_uentry.clu.size = clu.size;
2301                                                 p_fs->hint_uentry.clu.flags = clu.flags;
2302                                         }
2303                                         if ((num_empty >= num_entries) || (entry_type == TYPE_UNUSED))
2304                                                 p_fs->hint_uentry.entry = dentry - (num_empty - 1);
2305                                 }
2306
2307                                 if (entry_type == TYPE_UNUSED)
2308                                         return -2;
2309                         } else {
2310                                 num_empty = 0;
2311
2312                                 if ((entry_type == TYPE_FILE) || (entry_type == TYPE_DIR)) {
2313                                         file_ep = (struct file_dentry_t *)ep;
2314                                         if ((type == TYPE_ALL) || (type == entry_type)) {
2315                                                 num_ext_entries = file_ep->num_ext;
2316                                                 is_feasible_entry = true;
2317                                         } else {
2318                                                 is_feasible_entry = false;
2319                                                 step = file_ep->num_ext + 1;
2320                                         }
2321                                 } else if (entry_type == TYPE_STREAM) {
2322                                         if (is_feasible_entry) {
2323                                                 strm_ep = (struct strm_dentry_t *)ep;
2324                                                 if (p_uniname->name_hash == GET16_A(strm_ep->name_hash) &&
2325                                                     p_uniname->name_len == strm_ep->name_len) {
2326                                                         order = 1;
2327                                                 } else {
2328                                                         is_feasible_entry = false;
2329                                                         step = num_ext_entries;
2330                                                 }
2331                                         }
2332                                 } else if (entry_type == TYPE_EXTEND) {
2333                                         if (is_feasible_entry) {
2334                                                 name_ep = (struct name_dentry_t *)ep;
2335
2336                                                 if ((++order) == 2)
2337                                                         uniname = p_uniname->name;
2338                                                 else
2339                                                         uniname += 15;
2340
2341                                                 len = extract_uni_name_from_name_entry(name_ep,
2342                                                                 entry_uniname, order);
2343
2344                                                 unichar = *(uniname + len);
2345                                                 *(uniname + len) = 0x0;
2346
2347                                                 if (nls_uniname_cmp(sb, uniname, entry_uniname)) {
2348                                                         is_feasible_entry = false;
2349                                                         step = num_ext_entries - order + 1;
2350                                                 } else if (order == num_ext_entries) {
2351                                                         p_fs->hint_uentry.dir = CLUSTER_32(~0);
2352                                                         p_fs->hint_uentry.entry = -1;
2353                                                         return dentry - (num_ext_entries);
2354                                                 }
2355
2356                                                 *(uniname + len) = unichar;
2357                                         }
2358                                 } else {
2359                                         is_feasible_entry = false;
2360                                 }
2361                         }
2362
2363                         i += step;
2364                         dentry += step;
2365                 }
2366
2367                 i -= dentries_per_clu;
2368
2369                 if (p_dir->dir == CLUSTER_32(0))
2370                         break; /* FAT16 root_dir */
2371
2372                 if (clu.flags == 0x03) {
2373                         if ((--clu.size) > 0)
2374                                 clu.dir++;
2375                         else
2376                                 clu.dir = CLUSTER_32(~0);
2377                 } else {
2378                         if (FAT_read(sb, clu.dir, &clu.dir) != 0)
2379                                 return -2;
2380                 }
2381         }
2382
2383         return -2;
2384 }
2385
2386 s32 fat_count_ext_entries(struct super_block *sb, struct chain_t *p_dir,
2387                           s32 entry, struct dentry_t *p_entry)
2388 {
2389         s32 count = 0;
2390         u8 chksum;
2391         struct dos_dentry_t *dos_ep = (struct dos_dentry_t *)p_entry;
2392         struct ext_dentry_t *ext_ep;
2393         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2394
2395         chksum = calc_checksum_1byte((void *)dos_ep->name, DOS_NAME_LENGTH, 0);
2396
2397         for (entry--; entry >= 0; entry--) {
2398                 ext_ep = (struct ext_dentry_t *)get_entry_in_dir(sb, p_dir,
2399                                                                  entry, NULL);
2400                 if (!ext_ep)
2401                         return -1;
2402
2403                 if ((p_fs->fs_func->get_entry_type((struct dentry_t *)ext_ep) ==
2404                      TYPE_EXTEND) && (ext_ep->checksum == chksum)) {
2405                         count++;
2406                         if (ext_ep->order > 0x40)
2407                                 return count;
2408                 } else {
2409                         return count;
2410                 }
2411         }
2412
2413         return count;
2414 }
2415
2416 s32 exfat_count_ext_entries(struct super_block *sb, struct chain_t *p_dir,
2417                             s32 entry, struct dentry_t *p_entry)
2418 {
2419         int i, count = 0;
2420         u32 type;
2421         struct file_dentry_t *file_ep = (struct file_dentry_t *)p_entry;
2422         struct dentry_t *ext_ep;
2423         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2424
2425         for (i = 0, entry++; i < file_ep->num_ext; i++, entry++) {
2426                 ext_ep = get_entry_in_dir(sb, p_dir, entry, NULL);
2427                 if (!ext_ep)
2428                         return -1;
2429
2430                 type = p_fs->fs_func->get_entry_type(ext_ep);
2431                 if ((type == TYPE_EXTEND) || (type == TYPE_STREAM))
2432                         count++;
2433                 else
2434                         return count;
2435         }
2436
2437         return count;
2438 }
2439
2440 s32 count_dos_name_entries(struct super_block *sb, struct chain_t *p_dir,
2441                            u32 type)
2442 {
2443         int i, count = 0;
2444         s32 dentries_per_clu;
2445         u32 entry_type;
2446         struct chain_t clu;
2447         struct dentry_t *ep;
2448         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2449
2450         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
2451                 dentries_per_clu = p_fs->dentries_in_root;
2452         else
2453                 dentries_per_clu = p_fs->dentries_per_clu;
2454
2455         clu.dir = p_dir->dir;
2456         clu.size = p_dir->size;
2457         clu.flags = p_dir->flags;
2458
2459         while (clu.dir != CLUSTER_32(~0)) {
2460                 if (p_fs->dev_ejected)
2461                         break;
2462
2463                 for (i = 0; i < dentries_per_clu; i++) {
2464                         ep = get_entry_in_dir(sb, &clu, i, NULL);
2465                         if (!ep)
2466                                 return -1;
2467
2468                         entry_type = p_fs->fs_func->get_entry_type(ep);
2469
2470                         if (entry_type == TYPE_UNUSED)
2471                                 return count;
2472                         if (!(type & TYPE_CRITICAL_PRI) &&
2473                             !(type & TYPE_BENIGN_PRI))
2474                                 continue;
2475
2476                         if ((type == TYPE_ALL) || (type == entry_type))
2477                                 count++;
2478                 }
2479
2480                 if (p_dir->dir == CLUSTER_32(0))
2481                         break; /* FAT16 root_dir */
2482
2483                 if (clu.flags == 0x03) {
2484                         if ((--clu.size) > 0)
2485                                 clu.dir++;
2486                         else
2487                                 clu.dir = CLUSTER_32(~0);
2488                 } else {
2489                         if (FAT_read(sb, clu.dir, &clu.dir) != 0)
2490                                 return -1;
2491                 }
2492         }
2493
2494         return count;
2495 }
2496
2497 bool is_dir_empty(struct super_block *sb, struct chain_t *p_dir)
2498 {
2499         int i, count = 0;
2500         s32 dentries_per_clu;
2501         u32 type;
2502         struct chain_t clu;
2503         struct dentry_t *ep;
2504         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2505
2506         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
2507                 dentries_per_clu = p_fs->dentries_in_root;
2508         else
2509                 dentries_per_clu = p_fs->dentries_per_clu;
2510
2511         clu.dir = p_dir->dir;
2512         clu.size = p_dir->size;
2513         clu.flags = p_dir->flags;
2514
2515         while (clu.dir != CLUSTER_32(~0)) {
2516                 if (p_fs->dev_ejected)
2517                         break;
2518
2519                 for (i = 0; i < dentries_per_clu; i++) {
2520                         ep = get_entry_in_dir(sb, &clu, i, NULL);
2521                         if (!ep)
2522                                 break;
2523
2524                         type = p_fs->fs_func->get_entry_type(ep);
2525
2526                         if (type == TYPE_UNUSED)
2527                                 return true;
2528                         if ((type != TYPE_FILE) && (type != TYPE_DIR))
2529                                 continue;
2530
2531                         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
2532                                 return false;
2533
2534                         if (p_fs->vol_type == EXFAT)
2535                                 return false;
2536                         if ((p_dir->dir == p_fs->root_dir) || ((++count) > 2))
2537                                 return false;
2538                 }
2539
2540                 if (p_dir->dir == CLUSTER_32(0))
2541                         break; /* FAT16 root_dir */
2542
2543                 if (clu.flags == 0x03) {
2544                         if ((--clu.size) > 0)
2545                                 clu.dir++;
2546                         else
2547                                 clu.dir = CLUSTER_32(~0);
2548                 }
2549                 if (FAT_read(sb, clu.dir, &clu.dir) != 0)
2550                         break;
2551         }
2552
2553         return true;
2554 }
2555
2556 /*
2557  *  Name Conversion Functions
2558  */
2559
2560 /* input  : dir, uni_name
2561  * output : num_of_entry, dos_name(format : aaaaaa~1.bbb)
2562  */
2563 s32 get_num_entries_and_dos_name(struct super_block *sb, struct chain_t *p_dir,
2564                                  struct uni_name_t *p_uniname, s32 *entries,
2565                                  struct dos_name_t *p_dosname)
2566 {
2567         s32 ret, num_entries;
2568         bool lossy = false;
2569         char **r;
2570         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2571
2572         num_entries = p_fs->fs_func->calc_num_entries(p_uniname);
2573         if (num_entries == 0)
2574                 return FFS_INVALIDPATH;
2575
2576         if (p_fs->vol_type != EXFAT) {
2577                 nls_uniname_to_dosname(sb, p_dosname, p_uniname, &lossy);
2578
2579                 if (lossy) {
2580                         ret = fat_generate_dos_name(sb, p_dir, p_dosname);
2581                         if (ret)
2582                                 return ret;
2583                 } else {
2584                         for (r = reserved_names; *r; r++) {
2585                                 if (!strncmp((void *)p_dosname->name, *r, 8))
2586                                         return FFS_INVALIDPATH;
2587                         }
2588
2589                         if (p_dosname->name_case != 0xFF)
2590                                 num_entries = 1;
2591                 }
2592
2593                 if (num_entries > 1)
2594                         p_dosname->name_case = 0x0;
2595         }
2596
2597         *entries = num_entries;
2598
2599         return FFS_SUCCESS;
2600 }
2601
2602 void get_uni_name_from_dos_entry(struct super_block *sb,
2603                                  struct dos_dentry_t *ep,
2604                                  struct uni_name_t *p_uniname, u8 mode)
2605 {
2606         struct dos_name_t dos_name;
2607
2608         if (mode == 0x0)
2609                 dos_name.name_case = 0x0;
2610         else
2611                 dos_name.name_case = ep->lcase;
2612
2613         memcpy(dos_name.name, ep->name, DOS_NAME_LENGTH);
2614         nls_dosname_to_uniname(sb, p_uniname, &dos_name);
2615 }
2616
2617 void fat_get_uni_name_from_ext_entry(struct super_block *sb,
2618                                      struct chain_t *p_dir, s32 entry,
2619                                      u16 *uniname)
2620 {
2621         int i;
2622         struct ext_dentry_t *ep;
2623         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2624
2625         for (entry--, i = 1; entry >= 0; entry--, i++) {
2626                 ep = (struct ext_dentry_t *)get_entry_in_dir(sb, p_dir, entry,
2627                                                              NULL);
2628                 if (!ep)
2629                         return;
2630
2631                 if (p_fs->fs_func->get_entry_type((struct dentry_t *)ep) ==
2632                     TYPE_EXTEND) {
2633                         extract_uni_name_from_ext_entry(ep, uniname, i);
2634                         if (ep->order > 0x40)
2635                                 return;
2636                 } else {
2637                         return;
2638                 }
2639
2640                 uniname += 13;
2641         }
2642 }
2643
2644 void exfat_get_uni_name_from_ext_entry(struct super_block *sb,
2645                                        struct chain_t *p_dir, s32 entry,
2646                                        u16 *uniname)
2647 {
2648         int i;
2649         struct dentry_t *ep;
2650         struct entry_set_cache_t *es;
2651         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2652
2653         es = get_entry_set_in_dir(sb, p_dir, entry, ES_ALL_ENTRIES, &ep);
2654         if (!es || es->num_entries < 3) {
2655                 if (es)
2656                         release_entry_set(es);
2657                 return;
2658         }
2659
2660         ep += 2;
2661
2662         /*
2663          * First entry  : file entry
2664          * Second entry : stream-extension entry
2665          * Third entry  : first file-name entry
2666          * So, the index of first file-name dentry should start from 2.
2667          */
2668         for (i = 2; i < es->num_entries; i++, ep++) {
2669                 if (p_fs->fs_func->get_entry_type(ep) == TYPE_EXTEND)
2670                         extract_uni_name_from_name_entry((struct name_dentry_t *)
2671                                                          ep, uniname, i);
2672                 else
2673                         goto out;
2674                 uniname += 15;
2675         }
2676
2677 out:
2678         release_entry_set(es);
2679 }
2680
2681 s32 extract_uni_name_from_ext_entry(struct ext_dentry_t *ep, u16 *uniname,
2682                                     s32 order)
2683 {
2684         int i, len = 0;
2685
2686         for (i = 0; i < 10; i += 2) {
2687                 *uniname = GET16(ep->unicode_0_4 + i);
2688                 if (*uniname == 0x0)
2689                         return len;
2690                 uniname++;
2691                 len++;
2692         }
2693
2694         if (order < 20) {
2695                 for (i = 0; i < 12; i += 2) {
2696                         *uniname = GET16_A(ep->unicode_5_10 + i);
2697                         if (*uniname == 0x0)
2698                                 return len;
2699                         uniname++;
2700                         len++;
2701                 }
2702         } else {
2703                 for (i = 0; i < 8; i += 2) {
2704                         *uniname = GET16_A(ep->unicode_5_10 + i);
2705                         if (*uniname == 0x0)
2706                                 return len;
2707                         uniname++;
2708                         len++;
2709                 }
2710                 *uniname = 0x0; /* uniname[MAX_NAME_LENGTH-1] */
2711                 return len;
2712         }
2713
2714         for (i = 0; i < 4; i += 2) {
2715                 *uniname = GET16_A(ep->unicode_11_12 + i);
2716                 if (*uniname == 0x0)
2717                         return len;
2718                 uniname++;
2719                 len++;
2720         }
2721
2722         *uniname = 0x0;
2723         return len;
2724 }
2725
2726 s32 extract_uni_name_from_name_entry(struct name_dentry_t *ep, u16 *uniname,
2727                                      s32 order)
2728 {
2729         int i, len = 0;
2730
2731         for (i = 0; i < 30; i += 2) {
2732                 *uniname = GET16_A(ep->unicode_0_14 + i);
2733                 if (*uniname == 0x0)
2734                         return len;
2735                 uniname++;
2736                 len++;
2737         }
2738
2739         *uniname = 0x0;
2740         return len;
2741 }
2742
2743 s32 fat_generate_dos_name(struct super_block *sb, struct chain_t *p_dir,
2744                           struct dos_name_t *p_dosname)
2745 {
2746         int i, j, count = 0;
2747         bool count_begin = false;
2748         s32 dentries_per_clu;
2749         u32 type;
2750         u8 bmap[128/* 1 ~ 1023 */];
2751         struct chain_t clu;
2752         struct dos_dentry_t *ep;
2753         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2754
2755         memset(bmap, 0, sizeof(bmap));
2756         exfat_bitmap_set(bmap, 0);
2757
2758         if (p_dir->dir == CLUSTER_32(0)) /* FAT16 root_dir */
2759                 dentries_per_clu = p_fs->dentries_in_root;
2760         else
2761                 dentries_per_clu = p_fs->dentries_per_clu;
2762
2763         clu.dir = p_dir->dir;
2764         clu.flags = p_dir->flags;
2765
2766         while (clu.dir != CLUSTER_32(~0)) {
2767                 if (p_fs->dev_ejected)
2768                         break;
2769
2770                 for (i = 0; i < dentries_per_clu; i++) {
2771                         ep = (struct dos_dentry_t *)get_entry_in_dir(sb, &clu,
2772                                                                      i, NULL);
2773                         if (!ep)
2774                                 return FFS_MEDIAERR;
2775
2776                         type = p_fs->fs_func->get_entry_type((struct dentry_t *)
2777                                                              ep);
2778
2779                         if (type == TYPE_UNUSED)
2780                                 break;
2781                         if ((type != TYPE_FILE) && (type != TYPE_DIR))
2782                                 continue;
2783
2784                         count = 0;
2785                         count_begin = false;
2786
2787                         for (j = 0; j < 8; j++) {
2788                                 if (ep->name[j] == ' ')
2789                                         break;
2790
2791                                 if (ep->name[j] == '~') {
2792                                         count_begin = true;
2793                                 } else if (count_begin) {
2794                                         if ((ep->name[j] >= '0') &&
2795                                             (ep->name[j] <= '9')) {
2796                                                 count = count * 10 +
2797                                                         (ep->name[j] - '0');
2798                                         } else {
2799                                                 count = 0;
2800                                                 count_begin = false;
2801                                         }
2802                                 }
2803                         }
2804
2805                         if ((count > 0) && (count < 1024))
2806                                 exfat_bitmap_set(bmap, count);
2807                 }
2808
2809                 if (p_dir->dir == CLUSTER_32(0))
2810                         break; /* FAT16 root_dir */
2811
2812                 if (FAT_read(sb, clu.dir, &clu.dir) != 0)
2813                         return FFS_MEDIAERR;
2814         }
2815
2816         count = 0;
2817         for (i = 0; i < 128; i++) {
2818                 if (bmap[i] != 0xFF) {
2819                         for (j = 0; j < 8; j++) {
2820                                 if (exfat_bitmap_test(&bmap[i], j) == 0) {
2821                                         count = (i << 3) + j;
2822                                         break;
2823                                 }
2824                         }
2825                         if (count != 0)
2826                                 break;
2827                 }
2828         }
2829
2830         if ((count == 0) || (count >= 1024))
2831                 return FFS_FILEEXIST;
2832         fat_attach_count_to_dos_name(p_dosname->name, count);
2833
2834         /* Now dos_name has DOS~????.EXT */
2835         return FFS_SUCCESS;
2836 }
2837
2838 void fat_attach_count_to_dos_name(u8 *dosname, s32 count)
2839 {
2840         int i, j, length;
2841         char str_count[6];
2842
2843         snprintf(str_count, sizeof(str_count), "~%d", count);
2844         length = strlen(str_count);
2845
2846         i = 0;
2847         j = 0;
2848         while (j <= (8 - length)) {
2849                 i = j;
2850                 if (dosname[j] == ' ')
2851                         break;
2852                 if (dosname[j] & 0x80)
2853                         j += 2;
2854                 else
2855                         j++;
2856         }
2857
2858         for (j = 0; j < length; i++, j++)
2859                 dosname[i] = (u8)str_count[j];
2860
2861         if (i == 7)
2862                 dosname[7] = ' ';
2863 }
2864
2865 s32 fat_calc_num_entries(struct uni_name_t *p_uniname)
2866 {
2867         s32 len;
2868
2869         len = p_uniname->name_len;
2870         if (len == 0)
2871                 return 0;
2872
2873         /* 1 dos name entry + extended entries */
2874         return (len - 1) / 13 + 2;
2875 }
2876
2877 s32 exfat_calc_num_entries(struct uni_name_t *p_uniname)
2878 {
2879         s32 len;
2880
2881         len = p_uniname->name_len;
2882         if (len == 0)
2883                 return 0;
2884
2885         /* 1 file entry + 1 stream entry + name entries */
2886         return (len - 1) / 15 + 3;
2887 }
2888
2889 u8 calc_checksum_1byte(void *data, s32 len, u8 chksum)
2890 {
2891         int i;
2892         u8 *c = (u8 *)data;
2893
2894         for (i = 0; i < len; i++, c++)
2895                 chksum = (((chksum & 1) << 7) | ((chksum & 0xFE) >> 1)) + *c;
2896
2897         return chksum;
2898 }
2899
2900 u16 calc_checksum_2byte(void *data, s32 len, u16 chksum, s32 type)
2901 {
2902         int i;
2903         u8 *c = (u8 *)data;
2904
2905         switch (type) {
2906         case CS_DIR_ENTRY:
2907                 for (i = 0; i < len; i++, c++) {
2908                         if ((i == 2) || (i == 3))
2909                                 continue;
2910                         chksum = (((chksum & 1) << 15) |
2911                                   ((chksum & 0xFFFE) >> 1)) + (u16)*c;
2912                 }
2913                 break;
2914         default
2915                         :
2916                 for (i = 0; i < len; i++, c++)
2917                         chksum = (((chksum & 1) << 15) |
2918                                   ((chksum & 0xFFFE) >> 1)) + (u16)*c;
2919         }
2920
2921         return chksum;
2922 }
2923
2924 u32 calc_checksum_4byte(void *data, s32 len, u32 chksum, s32 type)
2925 {
2926         int i;
2927         u8 *c = (u8 *)data;
2928
2929         switch (type) {
2930         case CS_PBR_SECTOR:
2931                 for (i = 0; i < len; i++, c++) {
2932                         if ((i == 106) || (i == 107) || (i == 112))
2933                                 continue;
2934                         chksum = (((chksum & 1) << 31) |
2935                                   ((chksum & 0xFFFFFFFE) >> 1)) + (u32)*c;
2936                 }
2937                 break;
2938         default
2939                         :
2940                 for (i = 0; i < len; i++, c++)
2941                         chksum = (((chksum & 1) << 31) |
2942                                   ((chksum & 0xFFFFFFFE) >> 1)) + (u32)*c;
2943         }
2944
2945         return chksum;
2946 }
2947
2948 /*
2949  *  Name Resolution Functions
2950  */
2951
2952 /* return values of resolve_path()
2953  * > 0 : return the length of the path
2954  * < 0 : return error
2955  */
2956 s32 resolve_path(struct inode *inode, char *path, struct chain_t *p_dir,
2957                  struct uni_name_t *p_uniname)
2958 {
2959         bool lossy = false;
2960         struct super_block *sb = inode->i_sb;
2961         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2962         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
2963
2964         if (strscpy(name_buf, path, sizeof(name_buf)) < 0)
2965                 return FFS_INVALIDPATH;
2966
2967         nls_cstring_to_uniname(sb, p_uniname, name_buf, &lossy);
2968         if (lossy)
2969                 return FFS_INVALIDPATH;
2970
2971         fid->size = i_size_read(inode);
2972
2973         p_dir->dir = fid->start_clu;
2974         p_dir->size = (s32)(fid->size >> p_fs->cluster_size_bits);
2975         p_dir->flags = fid->flags;
2976
2977         return FFS_SUCCESS;
2978 }
2979
2980 /*
2981  *  File Operation Functions
2982  */
2983 static struct fs_func fat_fs_func = {
2984         .alloc_cluster = fat_alloc_cluster,
2985         .free_cluster = fat_free_cluster,
2986         .count_used_clusters = fat_count_used_clusters,
2987
2988         .init_dir_entry = fat_init_dir_entry,
2989         .init_ext_entry = fat_init_ext_entry,
2990         .find_dir_entry = fat_find_dir_entry,
2991         .delete_dir_entry = fat_delete_dir_entry,
2992         .get_uni_name_from_ext_entry = fat_get_uni_name_from_ext_entry,
2993         .count_ext_entries = fat_count_ext_entries,
2994         .calc_num_entries = fat_calc_num_entries,
2995
2996         .get_entry_type = fat_get_entry_type,
2997         .set_entry_type = fat_set_entry_type,
2998         .get_entry_attr = fat_get_entry_attr,
2999         .set_entry_attr = fat_set_entry_attr,
3000         .get_entry_flag = fat_get_entry_flag,
3001         .set_entry_flag = fat_set_entry_flag,
3002         .get_entry_clu0 = fat_get_entry_clu0,
3003         .set_entry_clu0 = fat_set_entry_clu0,
3004         .get_entry_size = fat_get_entry_size,
3005         .set_entry_size = fat_set_entry_size,
3006         .get_entry_time = fat_get_entry_time,
3007         .set_entry_time = fat_set_entry_time,
3008 };
3009
3010 s32 fat16_mount(struct super_block *sb, struct pbr_sector_t *p_pbr)
3011 {
3012         s32 num_reserved, num_root_sectors;
3013         struct bpb16_t *p_bpb = (struct bpb16_t *)p_pbr->bpb;
3014         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3015         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
3016
3017         if (p_bpb->num_fats == 0)
3018                 return FFS_FORMATERR;
3019
3020         num_root_sectors = GET16(p_bpb->num_root_entries) << DENTRY_SIZE_BITS;
3021         num_root_sectors = ((num_root_sectors - 1) >>
3022                             p_bd->sector_size_bits) + 1;
3023
3024         p_fs->sectors_per_clu = p_bpb->sectors_per_clu;
3025         p_fs->sectors_per_clu_bits = ilog2(p_bpb->sectors_per_clu);
3026         p_fs->cluster_size_bits = p_fs->sectors_per_clu_bits +
3027                                   p_bd->sector_size_bits;
3028         p_fs->cluster_size = 1 << p_fs->cluster_size_bits;
3029
3030         p_fs->num_FAT_sectors = GET16(p_bpb->num_fat_sectors);
3031
3032         p_fs->FAT1_start_sector = p_fs->PBR_sector + GET16(p_bpb->num_reserved);
3033         if (p_bpb->num_fats == 1)
3034                 p_fs->FAT2_start_sector = p_fs->FAT1_start_sector;
3035         else
3036                 p_fs->FAT2_start_sector = p_fs->FAT1_start_sector +
3037                                           p_fs->num_FAT_sectors;
3038
3039         p_fs->root_start_sector = p_fs->FAT2_start_sector +
3040                                   p_fs->num_FAT_sectors;
3041         p_fs->data_start_sector = p_fs->root_start_sector + num_root_sectors;
3042
3043         p_fs->num_sectors = GET16(p_bpb->num_sectors);
3044         if (p_fs->num_sectors == 0)
3045                 p_fs->num_sectors = GET32(p_bpb->num_huge_sectors);
3046
3047         num_reserved = p_fs->data_start_sector - p_fs->PBR_sector;
3048         p_fs->num_clusters = ((p_fs->num_sectors - num_reserved) >>
3049                               p_fs->sectors_per_clu_bits) + 2;
3050         /* because the cluster index starts with 2 */
3051
3052         if (p_fs->num_clusters < FAT12_THRESHOLD)
3053                 p_fs->vol_type = FAT12;
3054         else
3055                 p_fs->vol_type = FAT16;
3056         p_fs->vol_id = GET32(p_bpb->vol_serial);
3057
3058         p_fs->root_dir = 0;
3059         p_fs->dentries_in_root = GET16(p_bpb->num_root_entries);
3060         p_fs->dentries_per_clu = 1 << (p_fs->cluster_size_bits -
3061                                        DENTRY_SIZE_BITS);
3062
3063         p_fs->vol_flag = VOL_CLEAN;
3064         p_fs->clu_srch_ptr = 2;
3065         p_fs->used_clusters = UINT_MAX;
3066
3067         p_fs->fs_func = &fat_fs_func;
3068
3069         return FFS_SUCCESS;
3070 }
3071
3072 s32 fat32_mount(struct super_block *sb, struct pbr_sector_t *p_pbr)
3073 {
3074         s32 num_reserved;
3075         struct bpb32_t *p_bpb = (struct bpb32_t *)p_pbr->bpb;
3076         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3077         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
3078
3079         if (p_bpb->num_fats == 0)
3080                 return FFS_FORMATERR;
3081
3082         p_fs->sectors_per_clu = p_bpb->sectors_per_clu;
3083         p_fs->sectors_per_clu_bits = ilog2(p_bpb->sectors_per_clu);
3084         p_fs->cluster_size_bits = p_fs->sectors_per_clu_bits +
3085                                   p_bd->sector_size_bits;
3086         p_fs->cluster_size = 1 << p_fs->cluster_size_bits;
3087
3088         p_fs->num_FAT_sectors = GET32(p_bpb->num_fat32_sectors);
3089
3090         p_fs->FAT1_start_sector = p_fs->PBR_sector + GET16(p_bpb->num_reserved);
3091         if (p_bpb->num_fats == 1)
3092                 p_fs->FAT2_start_sector = p_fs->FAT1_start_sector;
3093         else
3094                 p_fs->FAT2_start_sector = p_fs->FAT1_start_sector +
3095                                           p_fs->num_FAT_sectors;
3096
3097         p_fs->root_start_sector = p_fs->FAT2_start_sector +
3098                                   p_fs->num_FAT_sectors;
3099         p_fs->data_start_sector = p_fs->root_start_sector;
3100
3101         p_fs->num_sectors = GET32(p_bpb->num_huge_sectors);
3102         num_reserved = p_fs->data_start_sector - p_fs->PBR_sector;
3103
3104         p_fs->num_clusters = ((p_fs->num_sectors - num_reserved) >>
3105                               p_fs->sectors_per_clu_bits) + 2;
3106         /* because the cluster index starts with 2 */
3107
3108         p_fs->vol_type = FAT32;
3109         p_fs->vol_id = GET32(p_bpb->vol_serial);
3110
3111         p_fs->root_dir = GET32(p_bpb->root_cluster);
3112         p_fs->dentries_in_root = 0;
3113         p_fs->dentries_per_clu = 1 << (p_fs->cluster_size_bits -
3114                                        DENTRY_SIZE_BITS);
3115
3116         p_fs->vol_flag = VOL_CLEAN;
3117         p_fs->clu_srch_ptr = 2;
3118         p_fs->used_clusters = UINT_MAX;
3119
3120         p_fs->fs_func = &fat_fs_func;
3121
3122         return FFS_SUCCESS;
3123 }
3124
3125 static struct fs_func exfat_fs_func = {
3126         .alloc_cluster = exfat_alloc_cluster,
3127         .free_cluster = exfat_free_cluster,
3128         .count_used_clusters = exfat_count_used_clusters,
3129
3130         .init_dir_entry = exfat_init_dir_entry,
3131         .init_ext_entry = exfat_init_ext_entry,
3132         .find_dir_entry = exfat_find_dir_entry,
3133         .delete_dir_entry = exfat_delete_dir_entry,
3134         .get_uni_name_from_ext_entry = exfat_get_uni_name_from_ext_entry,
3135         .count_ext_entries = exfat_count_ext_entries,
3136         .calc_num_entries = exfat_calc_num_entries,
3137
3138         .get_entry_type = exfat_get_entry_type,
3139         .set_entry_type = exfat_set_entry_type,
3140         .get_entry_attr = exfat_get_entry_attr,
3141         .set_entry_attr = exfat_set_entry_attr,
3142         .get_entry_flag = exfat_get_entry_flag,
3143         .set_entry_flag = exfat_set_entry_flag,
3144         .get_entry_clu0 = exfat_get_entry_clu0,
3145         .set_entry_clu0 = exfat_set_entry_clu0,
3146         .get_entry_size = exfat_get_entry_size,
3147         .set_entry_size = exfat_set_entry_size,
3148         .get_entry_time = exfat_get_entry_time,
3149         .set_entry_time = exfat_set_entry_time,
3150 };
3151
3152 s32 exfat_mount(struct super_block *sb, struct pbr_sector_t *p_pbr)
3153 {
3154         struct bpbex_t *p_bpb = (struct bpbex_t *)p_pbr->bpb;
3155         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3156         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
3157
3158         if (p_bpb->num_fats == 0)
3159                 return FFS_FORMATERR;
3160
3161         p_fs->sectors_per_clu = 1 << p_bpb->sectors_per_clu_bits;
3162         p_fs->sectors_per_clu_bits = p_bpb->sectors_per_clu_bits;
3163         p_fs->cluster_size_bits = p_fs->sectors_per_clu_bits +
3164                                   p_bd->sector_size_bits;
3165         p_fs->cluster_size = 1 << p_fs->cluster_size_bits;
3166
3167         p_fs->num_FAT_sectors = GET32(p_bpb->fat_length);
3168
3169         p_fs->FAT1_start_sector = p_fs->PBR_sector + GET32(p_bpb->fat_offset);
3170         if (p_bpb->num_fats == 1)
3171                 p_fs->FAT2_start_sector = p_fs->FAT1_start_sector;
3172         else
3173                 p_fs->FAT2_start_sector = p_fs->FAT1_start_sector +
3174                                           p_fs->num_FAT_sectors;
3175
3176         p_fs->root_start_sector = p_fs->PBR_sector + GET32(p_bpb->clu_offset);
3177         p_fs->data_start_sector = p_fs->root_start_sector;
3178
3179         p_fs->num_sectors = GET64(p_bpb->vol_length);
3180         p_fs->num_clusters = GET32(p_bpb->clu_count) + 2;
3181         /* because the cluster index starts with 2 */
3182
3183         p_fs->vol_type = EXFAT;
3184         p_fs->vol_id = GET32(p_bpb->vol_serial);
3185
3186         p_fs->root_dir = GET32(p_bpb->root_cluster);
3187         p_fs->dentries_in_root = 0;
3188         p_fs->dentries_per_clu = 1 << (p_fs->cluster_size_bits -
3189                                        DENTRY_SIZE_BITS);
3190
3191         p_fs->vol_flag = (u32)GET16(p_bpb->vol_flags);
3192         p_fs->clu_srch_ptr = 2;
3193         p_fs->used_clusters = UINT_MAX;
3194
3195         p_fs->fs_func = &exfat_fs_func;
3196
3197         return FFS_SUCCESS;
3198 }
3199
3200 s32 create_dir(struct inode *inode, struct chain_t *p_dir,
3201                struct uni_name_t *p_uniname, struct file_id_t *fid)
3202 {
3203         s32 ret, dentry, num_entries;
3204         u64 size;
3205         struct chain_t clu;
3206         struct dos_name_t dos_name, dot_name;
3207         struct super_block *sb = inode->i_sb;
3208         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3209         struct fs_func *fs_func = p_fs->fs_func;
3210
3211         ret = get_num_entries_and_dos_name(sb, p_dir, p_uniname, &num_entries,
3212                                            &dos_name);
3213         if (ret)
3214                 return ret;
3215
3216         /* find_empty_entry must be called before alloc_cluster */
3217         dentry = find_empty_entry(inode, p_dir, num_entries);
3218         if (dentry < 0)
3219                 return FFS_FULL;
3220
3221         clu.dir = CLUSTER_32(~0);
3222         clu.size = 0;
3223         clu.flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
3224
3225         /* (1) allocate a cluster */
3226         ret = fs_func->alloc_cluster(sb, 1, &clu);
3227         if (ret < 0)
3228                 return FFS_MEDIAERR;
3229         else if (ret == 0)
3230                 return FFS_FULL;
3231
3232         ret = clear_cluster(sb, clu.dir);
3233         if (ret != FFS_SUCCESS)
3234                 return ret;
3235
3236         if (p_fs->vol_type == EXFAT) {
3237                 size = p_fs->cluster_size;
3238         } else {
3239                 size = 0;
3240
3241                 /* initialize the . and .. entry
3242                  * Information for . points to itself
3243                  * Information for .. points to parent dir
3244                  */
3245
3246                 dot_name.name_case = 0x0;
3247                 memcpy(dot_name.name, DOS_CUR_DIR_NAME, DOS_NAME_LENGTH);
3248
3249                 ret = fs_func->init_dir_entry(sb, &clu, 0, TYPE_DIR, clu.dir,
3250                                               0);
3251                 if (ret != FFS_SUCCESS)
3252                         return ret;
3253
3254                 ret = fs_func->init_ext_entry(sb, &clu, 0, 1, NULL, &dot_name);
3255                 if (ret != FFS_SUCCESS)
3256                         return ret;
3257
3258                 memcpy(dot_name.name, DOS_PAR_DIR_NAME, DOS_NAME_LENGTH);
3259
3260                 if (p_dir->dir == p_fs->root_dir)
3261                         ret = fs_func->init_dir_entry(sb, &clu, 1, TYPE_DIR,
3262                                                       CLUSTER_32(0), 0);
3263                 else
3264                         ret = fs_func->init_dir_entry(sb, &clu, 1, TYPE_DIR,
3265                                                       p_dir->dir, 0);
3266
3267                 if (ret != FFS_SUCCESS)
3268                         return ret;
3269
3270                 ret = p_fs->fs_func->init_ext_entry(sb, &clu, 1, 1, NULL,
3271                                                     &dot_name);
3272                 if (ret != FFS_SUCCESS)
3273                         return ret;
3274         }
3275
3276         /* (2) update the directory entry */
3277         /* make sub-dir entry in parent directory */
3278         ret = fs_func->init_dir_entry(sb, p_dir, dentry, TYPE_DIR, clu.dir,
3279                                       size);
3280         if (ret != FFS_SUCCESS)
3281                 return ret;
3282
3283         ret = fs_func->init_ext_entry(sb, p_dir, dentry, num_entries, p_uniname,
3284                                       &dos_name);
3285         if (ret != FFS_SUCCESS)
3286                 return ret;
3287
3288         fid->dir.dir = p_dir->dir;
3289         fid->dir.size = p_dir->size;
3290         fid->dir.flags = p_dir->flags;
3291         fid->entry = dentry;
3292
3293         fid->attr = ATTR_SUBDIR;
3294         fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
3295         fid->size = size;
3296         fid->start_clu = clu.dir;
3297
3298         fid->type = TYPE_DIR;
3299         fid->rwoffset = 0;
3300         fid->hint_last_off = -1;
3301
3302         return FFS_SUCCESS;
3303 }
3304
3305 s32 create_file(struct inode *inode, struct chain_t *p_dir,
3306                 struct uni_name_t *p_uniname, u8 mode, struct file_id_t *fid)
3307 {
3308         s32 ret, dentry, num_entries;
3309         struct dos_name_t dos_name;
3310         struct super_block *sb = inode->i_sb;
3311         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3312         struct fs_func *fs_func = p_fs->fs_func;
3313
3314         ret = get_num_entries_and_dos_name(sb, p_dir, p_uniname, &num_entries,
3315                                            &dos_name);
3316         if (ret)
3317                 return ret;
3318
3319         /* find_empty_entry must be called before alloc_cluster() */
3320         dentry = find_empty_entry(inode, p_dir, num_entries);
3321         if (dentry < 0)
3322                 return FFS_FULL;
3323
3324         /* (1) update the directory entry */
3325         /* fill the dos name directory entry information of the created file.
3326          * the first cluster is not determined yet. (0)
3327          */
3328         ret = fs_func->init_dir_entry(sb, p_dir, dentry, TYPE_FILE | mode,
3329                                       CLUSTER_32(0), 0);
3330         if (ret != FFS_SUCCESS)
3331                 return ret;
3332
3333         ret = fs_func->init_ext_entry(sb, p_dir, dentry, num_entries, p_uniname,
3334                                       &dos_name);
3335         if (ret != FFS_SUCCESS)
3336                 return ret;
3337
3338         fid->dir.dir = p_dir->dir;
3339         fid->dir.size = p_dir->size;
3340         fid->dir.flags = p_dir->flags;
3341         fid->entry = dentry;
3342
3343         fid->attr = ATTR_ARCHIVE | mode;
3344         fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
3345         fid->size = 0;
3346         fid->start_clu = CLUSTER_32(~0);
3347
3348         fid->type = TYPE_FILE;
3349         fid->rwoffset = 0;
3350         fid->hint_last_off = -1;
3351
3352         return FFS_SUCCESS;
3353 }
3354
3355 void remove_file(struct inode *inode, struct chain_t *p_dir, s32 entry)
3356 {
3357         s32 num_entries;
3358         sector_t sector;
3359         struct dentry_t *ep;
3360         struct super_block *sb = inode->i_sb;
3361         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3362         struct fs_func *fs_func = p_fs->fs_func;
3363
3364         ep = get_entry_in_dir(sb, p_dir, entry, &sector);
3365         if (!ep)
3366                 return;
3367
3368         buf_lock(sb, sector);
3369
3370         /* buf_lock() before call count_ext_entries() */
3371         num_entries = fs_func->count_ext_entries(sb, p_dir, entry, ep);
3372         if (num_entries < 0) {
3373                 buf_unlock(sb, sector);
3374                 return;
3375         }
3376         num_entries++;
3377
3378         buf_unlock(sb, sector);
3379
3380         /* (1) update the directory entry */
3381         fs_func->delete_dir_entry(sb, p_dir, entry, 0, num_entries);
3382 }
3383
3384 s32 exfat_rename_file(struct inode *inode, struct chain_t *p_dir, s32 oldentry,
3385                       struct uni_name_t *p_uniname, struct file_id_t *fid)
3386 {
3387         s32 ret, newentry = -1, num_old_entries, num_new_entries;
3388         sector_t sector_old, sector_new;
3389         struct dos_name_t dos_name;
3390         struct dentry_t *epold, *epnew;
3391         struct super_block *sb = inode->i_sb;
3392         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3393         struct fs_func *fs_func = p_fs->fs_func;
3394
3395         epold = get_entry_in_dir(sb, p_dir, oldentry, &sector_old);
3396         if (!epold)
3397                 return FFS_MEDIAERR;
3398
3399         buf_lock(sb, sector_old);
3400
3401         /* buf_lock() before call count_ext_entries() */
3402         num_old_entries = fs_func->count_ext_entries(sb, p_dir, oldentry,
3403                                                      epold);
3404         if (num_old_entries < 0) {
3405                 buf_unlock(sb, sector_old);
3406                 return FFS_MEDIAERR;
3407         }
3408         num_old_entries++;
3409
3410         ret = get_num_entries_and_dos_name(sb, p_dir, p_uniname,
3411                                            &num_new_entries, &dos_name);
3412         if (ret) {
3413                 buf_unlock(sb, sector_old);
3414                 return ret;
3415         }
3416
3417         if (num_old_entries < num_new_entries) {
3418                 newentry = find_empty_entry(inode, p_dir, num_new_entries);
3419                 if (newentry < 0) {
3420                         buf_unlock(sb, sector_old);
3421                         return FFS_FULL;
3422                 }
3423
3424                 epnew = get_entry_in_dir(sb, p_dir, newentry, &sector_new);
3425                 if (!epnew) {
3426                         buf_unlock(sb, sector_old);
3427                         return FFS_MEDIAERR;
3428                 }
3429
3430                 memcpy((void *)epnew, (void *)epold, DENTRY_SIZE);
3431                 if (fs_func->get_entry_type(epnew) == TYPE_FILE) {
3432                         fs_func->set_entry_attr(epnew,
3433                                                 fs_func->get_entry_attr(epnew) |
3434                                                 ATTR_ARCHIVE);
3435                         fid->attr |= ATTR_ARCHIVE;
3436                 }
3437                 buf_modify(sb, sector_new);
3438                 buf_unlock(sb, sector_old);
3439
3440                 if (p_fs->vol_type == EXFAT) {
3441                         epold = get_entry_in_dir(sb, p_dir, oldentry + 1,
3442                                                  &sector_old);
3443                         buf_lock(sb, sector_old);
3444                         epnew = get_entry_in_dir(sb, p_dir, newentry + 1,
3445                                                  &sector_new);
3446
3447                         if (!epold || !epnew) {
3448                                 buf_unlock(sb, sector_old);
3449                                 return FFS_MEDIAERR;
3450                         }
3451
3452                         memcpy((void *)epnew, (void *)epold, DENTRY_SIZE);
3453                         buf_modify(sb, sector_new);
3454                         buf_unlock(sb, sector_old);
3455                 }
3456
3457                 ret = fs_func->init_ext_entry(sb, p_dir, newentry,
3458                                               num_new_entries, p_uniname,
3459                                               &dos_name);
3460                 if (ret != FFS_SUCCESS)
3461                         return ret;
3462
3463                 fs_func->delete_dir_entry(sb, p_dir, oldentry, 0,
3464                                           num_old_entries);
3465                 fid->entry = newentry;
3466         } else {
3467                 if (fs_func->get_entry_type(epold) == TYPE_FILE) {
3468                         fs_func->set_entry_attr(epold,
3469                                                 fs_func->get_entry_attr(epold) |
3470                                                 ATTR_ARCHIVE);
3471                         fid->attr |= ATTR_ARCHIVE;
3472                 }
3473                 buf_modify(sb, sector_old);
3474                 buf_unlock(sb, sector_old);
3475
3476                 ret = fs_func->init_ext_entry(sb, p_dir, oldentry,
3477                                               num_new_entries, p_uniname,
3478                                               &dos_name);
3479                 if (ret != FFS_SUCCESS)
3480                         return ret;
3481
3482                 fs_func->delete_dir_entry(sb, p_dir, oldentry, num_new_entries,
3483                                           num_old_entries);
3484         }
3485
3486         return FFS_SUCCESS;
3487 }
3488
3489 s32 move_file(struct inode *inode, struct chain_t *p_olddir, s32 oldentry,
3490               struct chain_t *p_newdir, struct uni_name_t *p_uniname,
3491               struct file_id_t *fid)
3492 {
3493         s32 ret, newentry, num_new_entries, num_old_entries;
3494         sector_t sector_mov, sector_new;
3495         struct chain_t clu;
3496         struct dos_name_t dos_name;
3497         struct dentry_t *epmov, *epnew;
3498         struct super_block *sb = inode->i_sb;
3499         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3500         struct fs_func *fs_func = p_fs->fs_func;
3501
3502         epmov = get_entry_in_dir(sb, p_olddir, oldentry, &sector_mov);
3503         if (!epmov)
3504                 return FFS_MEDIAERR;
3505
3506         /* check if the source and target directory is the same */
3507         if (fs_func->get_entry_type(epmov) == TYPE_DIR &&
3508             fs_func->get_entry_clu0(epmov) == p_newdir->dir)
3509                 return FFS_INVALIDPATH;
3510
3511         buf_lock(sb, sector_mov);
3512
3513         /* buf_lock() before call count_ext_entries() */
3514         num_old_entries = fs_func->count_ext_entries(sb, p_olddir, oldentry,
3515                                                      epmov);
3516         if (num_old_entries < 0) {
3517                 buf_unlock(sb, sector_mov);
3518                 return FFS_MEDIAERR;
3519         }
3520         num_old_entries++;
3521
3522         ret = get_num_entries_and_dos_name(sb, p_newdir, p_uniname,
3523                                            &num_new_entries, &dos_name);
3524         if (ret) {
3525                 buf_unlock(sb, sector_mov);
3526                 return ret;
3527         }
3528
3529         newentry = find_empty_entry(inode, p_newdir, num_new_entries);
3530         if (newentry < 0) {
3531                 buf_unlock(sb, sector_mov);
3532                 return FFS_FULL;
3533         }
3534
3535         epnew = get_entry_in_dir(sb, p_newdir, newentry, &sector_new);
3536         if (!epnew) {
3537                 buf_unlock(sb, sector_mov);
3538                 return FFS_MEDIAERR;
3539         }
3540
3541         memcpy((void *)epnew, (void *)epmov, DENTRY_SIZE);
3542         if (fs_func->get_entry_type(epnew) == TYPE_FILE) {
3543                 fs_func->set_entry_attr(epnew, fs_func->get_entry_attr(epnew) |
3544                                         ATTR_ARCHIVE);
3545                 fid->attr |= ATTR_ARCHIVE;
3546         }
3547         buf_modify(sb, sector_new);
3548         buf_unlock(sb, sector_mov);
3549
3550         if (p_fs->vol_type == EXFAT) {
3551                 epmov = get_entry_in_dir(sb, p_olddir, oldentry + 1,
3552                                          &sector_mov);
3553                 buf_lock(sb, sector_mov);
3554                 epnew = get_entry_in_dir(sb, p_newdir, newentry + 1,
3555                                          &sector_new);
3556                 if (!epmov || !epnew) {
3557                         buf_unlock(sb, sector_mov);
3558                         return FFS_MEDIAERR;
3559                 }
3560
3561                 memcpy((void *)epnew, (void *)epmov, DENTRY_SIZE);
3562                 buf_modify(sb, sector_new);
3563                 buf_unlock(sb, sector_mov);
3564         } else if (fs_func->get_entry_type(epnew) == TYPE_DIR) {
3565                 /* change ".." pointer to new parent dir */
3566                 clu.dir = fs_func->get_entry_clu0(epnew);
3567                 clu.flags = 0x01;
3568
3569                 epnew = get_entry_in_dir(sb, &clu, 1, &sector_new);
3570                 if (!epnew)
3571                         return FFS_MEDIAERR;
3572
3573                 if (p_newdir->dir == p_fs->root_dir)
3574                         fs_func->set_entry_clu0(epnew, CLUSTER_32(0));
3575                 else
3576                         fs_func->set_entry_clu0(epnew, p_newdir->dir);
3577                 buf_modify(sb, sector_new);
3578         }
3579
3580         ret = fs_func->init_ext_entry(sb, p_newdir, newentry, num_new_entries,
3581                                       p_uniname, &dos_name);
3582         if (ret != FFS_SUCCESS)
3583                 return ret;
3584
3585         fs_func->delete_dir_entry(sb, p_olddir, oldentry, 0, num_old_entries);
3586
3587         fid->dir.dir = p_newdir->dir;
3588         fid->dir.size = p_newdir->size;
3589         fid->dir.flags = p_newdir->flags;
3590
3591         fid->entry = newentry;
3592
3593         return FFS_SUCCESS;
3594 }
3595
3596 /*
3597  *  Sector Read/Write Functions
3598  */
3599
3600 int sector_read(struct super_block *sb, sector_t sec, struct buffer_head **bh,
3601                 bool read)
3602 {
3603         s32 ret = FFS_MEDIAERR;
3604         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3605
3606         if ((sec >= (p_fs->PBR_sector + p_fs->num_sectors)) &&
3607             (p_fs->num_sectors > 0)) {
3608                 pr_err("[EXFAT] %s: out of range error! (sec = %llu)\n",
3609                        __func__, (unsigned long long)sec);
3610                 fs_error(sb);
3611                 return ret;
3612         }
3613
3614         if (!p_fs->dev_ejected) {
3615                 ret = bdev_read(sb, sec, bh, 1, read);
3616                 if (ret != FFS_SUCCESS)
3617                         p_fs->dev_ejected = 1;
3618         }
3619
3620         return ret;
3621 }
3622
3623 int sector_write(struct super_block *sb, sector_t sec, struct buffer_head *bh,
3624                  bool sync)
3625 {
3626         s32 ret = FFS_MEDIAERR;
3627         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3628
3629         if (sec >= (p_fs->PBR_sector + p_fs->num_sectors) &&
3630             (p_fs->num_sectors > 0)) {
3631                 pr_err("[EXFAT] %s: out of range error! (sec = %llu)\n",
3632                        __func__, (unsigned long long)sec);
3633                 fs_error(sb);
3634                 return ret;
3635         }
3636
3637         if (!bh) {
3638                 pr_err("[EXFAT] %s: bh is NULL!\n", __func__);
3639                 fs_error(sb);
3640                 return ret;
3641         }
3642
3643         if (!p_fs->dev_ejected) {
3644                 ret = bdev_write(sb, sec, bh, 1, sync);
3645                 if (ret != FFS_SUCCESS)
3646                         p_fs->dev_ejected = 1;
3647         }
3648
3649         return ret;
3650 }
3651
3652 int multi_sector_read(struct super_block *sb, sector_t sec,
3653                       struct buffer_head **bh, s32 num_secs, bool read)
3654 {
3655         s32 ret = FFS_MEDIAERR;
3656         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3657
3658         if (((sec + num_secs) > (p_fs->PBR_sector + p_fs->num_sectors)) &&
3659             (p_fs->num_sectors > 0)) {
3660                 pr_err("[EXFAT] %s: out of range error! (sec = %llu, num_secs = %d)\n",
3661                        __func__, (unsigned long long)sec, num_secs);
3662                 fs_error(sb);
3663                 return ret;
3664         }
3665
3666         if (!p_fs->dev_ejected) {
3667                 ret = bdev_read(sb, sec, bh, num_secs, read);
3668                 if (ret != FFS_SUCCESS)
3669                         p_fs->dev_ejected = 1;
3670         }
3671
3672         return ret;
3673 }
3674
3675 int multi_sector_write(struct super_block *sb, sector_t sec,
3676                        struct buffer_head *bh, s32 num_secs, bool sync)
3677 {
3678         s32 ret = FFS_MEDIAERR;
3679         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3680
3681         if ((sec + num_secs) > (p_fs->PBR_sector + p_fs->num_sectors) &&
3682             (p_fs->num_sectors > 0)) {
3683                 pr_err("[EXFAT] %s: out of range error! (sec = %llu, num_secs = %d)\n",
3684                        __func__, (unsigned long long)sec, num_secs);
3685                 fs_error(sb);
3686                 return ret;
3687         }
3688         if (!bh) {
3689                 pr_err("[EXFAT] %s: bh is NULL!\n", __func__);
3690                 fs_error(sb);
3691                 return ret;
3692         }
3693
3694         if (!p_fs->dev_ejected) {
3695                 ret = bdev_write(sb, sec, bh, num_secs, sync);
3696                 if (ret != FFS_SUCCESS)
3697                         p_fs->dev_ejected = 1;
3698         }
3699
3700         return ret;
3701 }