drivers/staging/exfat/exfat_super.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
   4  */
   5
   6 #include <linux/version.h>
   7 #include <linux/module.h>
   8 #include <linux/init.h>
   9 #include <linux/time.h>
  10 #include <linux/slab.h>
  11 #include <linux/seq_file.h>
  12 #include <linux/pagemap.h>
  13 #include <linux/mpage.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/exportfs.h>
  16 #include <linux/mount.h>
  17 #include <linux/vfs.h>
  18 #include <linux/aio.h>
  19 #include <linux/iversion.h>
  20 #include <linux/parser.h>
  21 #include <linux/uio.h>
  22 #include <linux/writeback.h>
  23 #include <linux/log2.h>
  24 #include <linux/hash.h>
  25 #include <linux/backing-dev.h>
  26 #include <linux/sched.h>
  27 #include <linux/fs_struct.h>
  28 #include <linux/namei.h>
  29 #include <linux/time.h>
  30
  31 #include <linux/string.h>
  32 #include <linux/nls.h>
  33 #include <linux/mutex.h>
  34 #include <linux/swap.h>
  35
  36 #define EXFAT_VERSION  "1.3.0"
  37
  38 #include "exfat.h"
  39
  40 static struct kmem_cache *exfat_inode_cachep;
  41
  42 // FIXME use commented lines
  43 // static int exfat_default_codepage = CONFIG_EXFAT_DEFAULT_CODEPAGE;
  44 // static char exfat_default_iocharset[] = CONFIG_EXFAT_DEFAULT_IOCHARSET;
  45 static int exfat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE;
  46 static char exfat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET;
  47
  48 #define INC_IVERSION(x) (inode_inc_iversion(x))
  49 #define GET_IVERSION(x) (inode_peek_iversion_raw(x))
  50 #define SET_IVERSION(x, y) (inode_set_iversion(x, y))
  51
  52 static struct inode *exfat_iget(struct super_block *sb, loff_t i_pos);
  53 static int exfat_sync_inode(struct inode *inode);
  54 static struct inode *exfat_build_inode(struct super_block *sb,
  55                                        struct file_id_t *fid, loff_t i_pos);
  56 static int exfat_write_inode(struct inode *inode,
  57                              struct writeback_control *wbc);
  58 static void exfat_write_super(struct super_block *sb);
  59
  60 #define UNIX_SECS_1980    315532800L
  61
  62 #if BITS_PER_LONG == 64
  63 #define UNIX_SECS_2108    4354819200L
  64 #endif
  65
  66 /* days between 1.1.70 and 1.1.80 (2 leap days) */
  67 #define DAYS_DELTA_DECADE    (365 * 10 + 2)
  68 /* 120 (2100 - 1980) isn't leap year */
  69 #define NO_LEAP_YEAR_2100    (120)
  70 #define IS_LEAP_YEAR(y)    (!((y) & 0x3) && (y) != NO_LEAP_YEAR_2100)
  71
  72 #define SECS_PER_MIN    (60)
  73 #define SECS_PER_HOUR   (60 * SECS_PER_MIN)
  74 #define SECS_PER_DAY    (24 * SECS_PER_HOUR)
  75
  76 #define MAKE_LEAP_YEAR(leap_year, year)                         \
  77         do {                                                    \
  78                 if (unlikely(year > NO_LEAP_YEAR_2100))         \
  79                         leap_year = ((year + 3) / 4) - 1;       \
  80                 else                                            \
  81                         leap_year = ((year + 3) / 4);           \
  82         } while (0)
  83
  84 /* Linear day numbers of the respective 1sts in non-leap years. */
  85 static time_t accum_days_in_year[] = {
  86         /* Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct  Nov  Dec */
  87         0,   0,  31,  59,  90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0,
  88 };
  89
  90 /* Convert a FAT time/date pair to a UNIX date (seconds since 1 1 70). */
  91 static void exfat_time_fat2unix(struct exfat_sb_info *sbi,
  92                                 struct timespec64 *ts, struct date_time_t *tp)
  93 {
  94         time_t year = tp->Year;
  95         time_t ld;
  96
  97         MAKE_LEAP_YEAR(ld, year);
  98
  99         if (IS_LEAP_YEAR(year) && (tp->Month) > 2)
 100                 ld++;
 101
 102         ts->tv_sec = tp->Second +
 103                      tp->Minute * SECS_PER_MIN +
 104                      tp->Hour * SECS_PER_HOUR +
 105                      (ld + accum_days_in_year[(tp->Month)] +
 106                       (tp->Day - 1)) * SECS_PER_DAY +
 107                      (year * 365 + DAYS_DELTA_DECADE) * SECS_PER_DAY +
 108                      sys_tz.tz_minuteswest * SECS_PER_MIN;
 109
 110         ts->tv_nsec = 0;
 111 }
 112
 113 /* Convert linear UNIX date to a FAT time/date pair. */
 114 static void exfat_time_unix2fat(struct exfat_sb_info *sbi,
 115                                 struct timespec64 *ts, struct date_time_t *tp)
 116 {
 117         time_t second = ts->tv_sec;
 118         time_t day, month, year;
 119         time_t ld;
 120
 121         second -= sys_tz.tz_minuteswest * SECS_PER_MIN;
 122
 123         /* Jan 1 GMT 00:00:00 1980. But what about another time zone? */
 124         if (second < UNIX_SECS_1980) {
 125                 tp->Second  = 0;
 126                 tp->Minute  = 0;
 127                 tp->Hour = 0;
 128                 tp->Day  = 1;
 129                 tp->Month  = 1;
 130                 tp->Year = 0;
 131                 return;
 132         }
 133 #if (BITS_PER_LONG == 64)
 134         if (second >= UNIX_SECS_2108) {
 135                 tp->Second  = 59;
 136                 tp->Minute  = 59;
 137                 tp->Hour = 23;
 138                 tp->Day  = 31;
 139                 tp->Month  = 12;
 140                 tp->Year = 127;
 141                 return;
 142         }
 143 #endif
 144         day = second / SECS_PER_DAY - DAYS_DELTA_DECADE;
 145         year = day / 365;
 146         MAKE_LEAP_YEAR(ld, year);
 147         if (year * 365 + ld > day)
 148                 year--;
 149
 150         MAKE_LEAP_YEAR(ld, year);
 151         day -= year * 365 + ld;
 152
 153         if (IS_LEAP_YEAR(year) && day == accum_days_in_year[3]) {
 154                 month = 2;
 155         } else {
 156                 if (IS_LEAP_YEAR(year) && day > accum_days_in_year[3])
 157                         day--;
 158                 for (month = 1; month < 12; month++) {
 159                         if (accum_days_in_year[month + 1] > day)
 160                                 break;
 161                 }
 162         }
 163         day -= accum_days_in_year[month];
 164
 165         tp->Second  = second % SECS_PER_MIN;
 166         tp->Minute  = (second / SECS_PER_MIN) % 60;
 167         tp->Hour = (second / SECS_PER_HOUR) % 24;
 168         tp->Day  = day + 1;
 169         tp->Month  = month;
 170         tp->Year = year;
 171 }
 172
 173 struct timestamp_t *tm_current(struct timestamp_t *tp)
 174 {
 175         struct timespec64 ts;
 176         time_t second, day, leap_day, month, year;
 177
 178         ktime_get_real_ts64(&ts);
 179
 180         second = ts.tv_sec;
 181         second -= sys_tz.tz_minuteswest * SECS_PER_MIN;
 182
 183         /* Jan 1 GMT 00:00:00 1980. But what about another time zone? */
 184         if (second < UNIX_SECS_1980) {
 185                 tp->sec  = 0;
 186                 tp->min  = 0;
 187                 tp->hour = 0;
 188                 tp->day  = 1;
 189                 tp->mon  = 1;
 190                 tp->year = 0;
 191                 return tp;
 192         }
 193 #if BITS_PER_LONG == 64
 194         if (second >= UNIX_SECS_2108) {
 195                 tp->sec  = 59;
 196                 tp->min  = 59;
 197                 tp->hour = 23;
 198                 tp->day  = 31;
 199                 tp->mon  = 12;
 200                 tp->year = 127;
 201                 return tp;
 202         }
 203 #endif
 204
 205         day = second / SECS_PER_DAY - DAYS_DELTA_DECADE;
 206         year = day / 365;
 207
 208         MAKE_LEAP_YEAR(leap_day, year);
 209         if (year * 365 + leap_day > day)
 210                 year--;
 211
 212         MAKE_LEAP_YEAR(leap_day, year);
 213
 214         day -= year * 365 + leap_day;
 215
 216         if (IS_LEAP_YEAR(year) && day == accum_days_in_year[3]) {
 217                 month = 2;
 218         } else {
 219                 if (IS_LEAP_YEAR(year) && day > accum_days_in_year[3])
 220                         day--;
 221                 for (month = 1; month < 12; month++) {
 222                         if (accum_days_in_year[month + 1] > day)
 223                                 break;
 224                 }
 225         }
 226         day -= accum_days_in_year[month];
 227
 228         tp->sec  = second % SECS_PER_MIN;
 229         tp->min  = (second / SECS_PER_MIN) % 60;
 230         tp->hour = (second / SECS_PER_HOUR) % 24;
 231         tp->day  = day + 1;
 232         tp->mon  = month;
 233         tp->year = year;
 234
 235         return tp;
 236 }
 237
 238 static void __lock_super(struct super_block *sb)
 239 {
 240         struct exfat_sb_info *sbi = EXFAT_SB(sb);
 241
 242         mutex_lock(&sbi->s_lock);
 243 }
 244
 245 static void __unlock_super(struct super_block *sb)
 246 {
 247         struct exfat_sb_info *sbi = EXFAT_SB(sb);
 248
 249         mutex_unlock(&sbi->s_lock);
 250 }
 251
 252 static int __is_sb_dirty(struct super_block *sb)
 253 {
 254         struct exfat_sb_info *sbi = EXFAT_SB(sb);
 255
 256         return sbi->s_dirt;
 257 }
 258
 259 static void __set_sb_clean(struct super_block *sb)
 260 {
 261         struct exfat_sb_info *sbi = EXFAT_SB(sb);
 262
 263         sbi->s_dirt = 0;
 264 }
 265
 266 static int __exfat_revalidate(struct dentry *dentry)
 267 {
 268         return 0;
 269 }
 270
 271 static int exfat_revalidate(struct dentry *dentry, unsigned int flags)
 272 {
 273         if (flags & LOOKUP_RCU)
 274                 return -ECHILD;
 275
 276         if (dentry->d_inode)
 277                 return 1;
 278         return __exfat_revalidate(dentry);
 279 }
 280
 281 static int exfat_revalidate_ci(struct dentry *dentry, unsigned int flags)
 282 {
 283         if (flags & LOOKUP_RCU)
 284                 return -ECHILD;
 285
 286         if (dentry->d_inode)
 287                 return 1;
 288
 289         if (!flags)
 290                 return 0;
 291
 292         if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
 293                 return 0;
 294
 295         return __exfat_revalidate(dentry);
 296 }
 297
 298 static unsigned int __exfat_striptail_len(unsigned int len, const char *name)
 299 {
 300         while (len && name[len - 1] == '.')
 301                 len--;
 302         return len;
 303 }
 304
 305 static unsigned int exfat_striptail_len(const struct qstr *qstr)
 306 {
 307         return __exfat_striptail_len(qstr->len, qstr->name);
 308 }
 309
 310 static int exfat_d_hash(const struct dentry *dentry, struct qstr *qstr)
 311 {
 312         qstr->hash = full_name_hash(dentry, qstr->name,
 313                                     exfat_striptail_len(qstr));
 314         return 0;
 315 }
 316
 317 static int exfat_d_hashi(const struct dentry *dentry, struct qstr *qstr)
 318 {
 319         struct super_block *sb = dentry->d_sb;
 320         const unsigned char *name;
 321         unsigned int len;
 322         unsigned long hash;
 323
 324         name = qstr->name;
 325         len = exfat_striptail_len(qstr);
 326
 327         hash = init_name_hash(dentry);
 328         while (len--)
 329                 hash = partial_name_hash(nls_upper(sb, *name++), hash);
 330         qstr->hash = end_name_hash(hash);
 331
 332         return 0;
 333 }
 334
 335 static int exfat_cmpi(const struct dentry *dentry, unsigned int len,
 336                       const char *str, const struct qstr *name)
 337 {
 338         struct nls_table *t = EXFAT_SB(dentry->d_sb)->nls_io;
 339         unsigned int alen, blen;
 340
 341         alen = exfat_striptail_len(name);
 342         blen = __exfat_striptail_len(len, str);
 343         if (alen == blen) {
 344                 if (!t) {
 345                         if (strncasecmp(name->name, str, alen) == 0)
 346                                 return 0;
 347                 } else {
 348                         if (nls_strnicmp(t, name->name, str, alen) == 0)
 349                                 return 0;
 350                 }
 351         }
 352         return 1;
 353 }
 354
 355 static int exfat_cmp(const struct dentry *dentry, unsigned int len,
 356                      const char *str, const struct qstr *name)
 357 {
 358         unsigned int alen, blen;
 359
 360         alen = exfat_striptail_len(name);
 361         blen = __exfat_striptail_len(len, str);
 362         if (alen == blen) {
 363                 if (strncmp(name->name, str, alen) == 0)
 364                         return 0;
 365         }
 366         return 1;
 367 }
 368
 369 static const struct dentry_operations exfat_ci_dentry_ops = {
 370         .d_revalidate   = exfat_revalidate_ci,
 371         .d_hash         = exfat_d_hashi,
 372         .d_compare      = exfat_cmpi,
 373 };
 374
 375 static const struct dentry_operations exfat_dentry_ops = {
 376         .d_revalidate   = exfat_revalidate,
 377         .d_hash         = exfat_d_hash,
 378         .d_compare      = exfat_cmp,
 379 };
 380
 381 static DEFINE_SEMAPHORE(z_sem);
 382
 383 static inline void fs_sync(struct super_block *sb, bool do_sync)
 384 {
 385         if (do_sync)
 386                 bdev_sync(sb);
 387 }
 388
 389 /*
 390  * If ->i_mode can't hold S_IWUGO (i.e. ATTR_RO), we use ->i_attrs to
 391  * save ATTR_RO instead of ->i_mode.
 392  *
 393  * If it's directory and !sbi->options.rodir, ATTR_RO isn't read-only
 394  * bit, it's just used as flag for app.
 395  */
 396 static inline int exfat_mode_can_hold_ro(struct inode *inode)
 397 {
 398         struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
 399
 400         if (S_ISDIR(inode->i_mode))
 401                 return 0;
 402
 403         if ((~sbi->options.fs_fmask) & 0222)
 404                 return 1;
 405         return 0;
 406 }
 407
 408 /* Convert attribute bits and a mask to the UNIX mode. */
 409 static inline mode_t exfat_make_mode(struct exfat_sb_info *sbi, u32 attr,
 410                                      mode_t mode)
 411 {
 412         if ((attr & ATTR_READONLY) && !(attr & ATTR_SUBDIR))
 413                 mode &= ~0222;
 414
 415         if (attr & ATTR_SUBDIR)
 416                 return (mode & ~sbi->options.fs_dmask) | S_IFDIR;
 417         else if (attr & ATTR_SYMLINK)
 418                 return (mode & ~sbi->options.fs_dmask) | S_IFLNK;
 419         else
 420                 return (mode & ~sbi->options.fs_fmask) | S_IFREG;
 421 }
 422
 423 /* Return the FAT attribute byte for this inode */
 424 static inline u32 exfat_make_attr(struct inode *inode)
 425 {
 426         if (exfat_mode_can_hold_ro(inode) && !(inode->i_mode & 0222))
 427                 return (EXFAT_I(inode)->fid.attr) | ATTR_READONLY;
 428         else
 429                 return EXFAT_I(inode)->fid.attr;
 430 }
 431
 432 static inline void exfat_save_attr(struct inode *inode, u32 attr)
 433 {
 434         if (exfat_mode_can_hold_ro(inode))
 435                 EXFAT_I(inode)->fid.attr = attr & ATTR_RWMASK;
 436         else
 437                 EXFAT_I(inode)->fid.attr = attr & (ATTR_RWMASK | ATTR_READONLY);
 438 }
 439
 440 static int ffsMountVol(struct super_block *sb)
 441 {
 442         int i, ret;
 443         struct pbr_sector_t *p_pbr;
 444         struct buffer_head *tmp_bh = NULL;
 445         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 446         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 447
 448         pr_info("[EXFAT] trying to mount...\n");
 449
 450         down(&z_sem);
 451
 452         buf_init(sb);
 453
 454         sema_init(&p_fs->v_sem, 1);
 455         p_fs->dev_ejected = 0;
 456
 457         /* open the block device */
 458         bdev_open(sb);
 459
 460         if (p_bd->sector_size < sb->s_blocksize) {
 461                 ret = FFS_MEDIAERR;
 462                 goto out;
 463         }
 464         if (p_bd->sector_size > sb->s_blocksize)
 465                 sb_set_blocksize(sb, p_bd->sector_size);
 466
 467         /* read Sector 0 */
 468         if (sector_read(sb, 0, &tmp_bh, 1) != FFS_SUCCESS) {
 469                 ret = FFS_MEDIAERR;
 470                 goto out;
 471         }
 472
 473         p_fs->PBR_sector = 0;
 474
 475         p_pbr = (struct pbr_sector_t *) tmp_bh->b_data;
 476
 477         /* check the validity of PBR */
 478         if (GET16_A(p_pbr->signature) != PBR_SIGNATURE) {
 479                 brelse(tmp_bh);
 480                 bdev_close(sb);
 481                 ret = FFS_FORMATERR;
 482                 goto out;
 483         }
 484
 485         /* fill fs_struct */
 486         for (i = 0; i < 53; i++)
 487                 if (p_pbr->bpb[i])
 488                         break;
 489
 490         if (i < 53) {
 491 #ifdef CONFIG_EXFAT_DONT_MOUNT_VFAT
 492                 ret = -EINVAL;
 493                 printk(KERN_INFO "EXFAT: Attempted to mount VFAT filesystem\n");
 494                 goto out;
 495 #else
 496                 if (GET16(p_pbr->bpb + 11)) /* num_fat_sectors */
 497                         ret = fat16_mount(sb, p_pbr);
 498                 else
 499                         ret = fat32_mount(sb, p_pbr);
 500 #endif
 501         } else {
 502                 ret = exfat_mount(sb, p_pbr);
 503         }
 504
 505         brelse(tmp_bh);
 506
 507         if (ret) {
 508                 bdev_close(sb);
 509                 goto out;
 510         }
 511
 512         if (p_fs->vol_type == EXFAT) {
 513                 ret = load_alloc_bitmap(sb);
 514                 if (ret) {
 515                         bdev_close(sb);
 516                         goto out;
 517                 }
 518                 ret = load_upcase_table(sb);
 519                 if (ret) {
 520                         free_alloc_bitmap(sb);
 521                         bdev_close(sb);
 522                         goto out;
 523                 }
 524         }
 525
 526         if (p_fs->dev_ejected) {
 527                 if (p_fs->vol_type == EXFAT) {
 528                         free_upcase_table(sb);
 529                         free_alloc_bitmap(sb);
 530                 }
 531                 bdev_close(sb);
 532                 ret = FFS_MEDIAERR;
 533                 goto out;
 534         }
 535
 536         pr_info("[EXFAT] mounted successfully\n");
 537
 538 out:
 539         up(&z_sem);
 540
 541         return ret;
 542 }
 543
 544 static int ffsUmountVol(struct super_block *sb)
 545 {
 546         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 547         int err = FFS_SUCCESS;
 548
 549         pr_info("[EXFAT] trying to unmount...\n");
 550
 551         down(&z_sem);
 552
 553         /* acquire the lock for file system critical section */
 554         down(&p_fs->v_sem);
 555
 556         fs_sync(sb, false);
 557         fs_set_vol_flags(sb, VOL_CLEAN);
 558
 559         if (p_fs->vol_type == EXFAT) {
 560                 free_upcase_table(sb);
 561                 free_alloc_bitmap(sb);
 562         }
 563
 564         FAT_release_all(sb);
 565         buf_release_all(sb);
 566
 567         /* close the block device */
 568         bdev_close(sb);
 569
 570         if (p_fs->dev_ejected) {
 571                 pr_info("[EXFAT] unmounted with media errors. Device is already ejected.\n");
 572                 err = FFS_MEDIAERR;
 573         }
 574
 575         buf_shutdown(sb);
 576
 577         /* release the lock for file system critical section */
 578         up(&p_fs->v_sem);
 579         up(&z_sem);
 580
 581         pr_info("[EXFAT] unmounted successfully\n");
 582
 583         return err;
 584 }
 585
 586 static int ffsGetVolInfo(struct super_block *sb, struct vol_info_t *info)
 587 {
 588         int err = FFS_SUCCESS;
 589         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 590
 591         /* check the validity of pointer parameters */
 592         if (!info)
 593                 return FFS_ERROR;
 594
 595         /* acquire the lock for file system critical section */
 596         down(&p_fs->v_sem);
 597
 598         if (p_fs->used_clusters == (u32) ~0)
 599                 p_fs->used_clusters = p_fs->fs_func->count_used_clusters(sb);
 600
 601         info->FatType = p_fs->vol_type;
 602         info->ClusterSize = p_fs->cluster_size;
 603         info->NumClusters = p_fs->num_clusters - 2; /* clu 0 & 1 */
 604         info->UsedClusters = p_fs->used_clusters;
 605         info->FreeClusters = info->NumClusters - info->UsedClusters;
 606
 607         if (p_fs->dev_ejected)
 608                 err = FFS_MEDIAERR;
 609
 610         /* release the lock for file system critical section */
 611         up(&p_fs->v_sem);
 612
 613         return err;
 614 }
 615
 616 static int ffsSyncVol(struct super_block *sb, bool do_sync)
 617 {
 618         int err = FFS_SUCCESS;
 619         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 620
 621         /* acquire the lock for file system critical section */
 622         down(&p_fs->v_sem);
 623
 624         /* synchronize the file system */
 625         fs_sync(sb, do_sync);
 626         fs_set_vol_flags(sb, VOL_CLEAN);
 627
 628         if (p_fs->dev_ejected)
 629                 err = FFS_MEDIAERR;
 630
 631         /* release the lock for file system critical section */
 632         up(&p_fs->v_sem);
 633
 634         return err;
 635 }
 636
 637 /*----------------------------------------------------------------------*/
 638 /*  File Operation Functions                                            */
 639 /*----------------------------------------------------------------------*/
 640
 641 static int ffsLookupFile(struct inode *inode, char *path, struct file_id_t *fid)
 642 {
 643         int ret, dentry, num_entries;
 644         struct chain_t dir;
 645         struct uni_name_t uni_name;
 646         struct dos_name_t dos_name;
 647         struct dentry_t *ep, *ep2;
 648         struct entry_set_cache_t *es = NULL;
 649         struct super_block *sb = inode->i_sb;
 650         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 651
 652         pr_debug("%s entered\n", __func__);
 653
 654         /* check the validity of pointer parameters */
 655         if (!fid || !path || (*path == '\0'))
 656                 return FFS_ERROR;
 657
 658         /* acquire the lock for file system critical section */
 659         down(&p_fs->v_sem);
 660
 661         /* check the validity of directory name in the given pathname */
 662         ret = resolve_path(inode, path, &dir, &uni_name);
 663         if (ret)
 664                 goto out;
 665
 666         ret = get_num_entries_and_dos_name(sb, &dir, &uni_name, &num_entries,
 667                                            &dos_name);
 668         if (ret)
 669                 goto out;
 670
 671         /* search the file name for directories */
 672         dentry = p_fs->fs_func->find_dir_entry(sb, &dir, &uni_name, num_entries,
 673                                                &dos_name, TYPE_ALL);
 674         if (dentry < -1) {
 675                 ret = FFS_NOTFOUND;
 676                 goto out;
 677         }
 678
 679         fid->dir.dir = dir.dir;
 680         fid->dir.size = dir.size;
 681         fid->dir.flags = dir.flags;
 682         fid->entry = dentry;
 683
 684         if (dentry == -1) {
 685                 fid->type = TYPE_DIR;
 686                 fid->rwoffset = 0;
 687                 fid->hint_last_off = -1;
 688
 689                 fid->attr = ATTR_SUBDIR;
 690                 fid->flags = 0x01;
 691                 fid->size = 0;
 692                 fid->start_clu = p_fs->root_dir;
 693         } else {
 694                 if (p_fs->vol_type == EXFAT) {
 695                         es = get_entry_set_in_dir(sb, &dir, dentry,
 696                                                   ES_2_ENTRIES, &ep);
 697                         if (!es) {
 698                                 ret =  FFS_MEDIAERR;
 699                                 goto out;
 700                         }
 701                         ep2 = ep+1;
 702                 } else {
 703                         ep = get_entry_in_dir(sb, &dir, dentry, NULL);
 704                         if (!ep) {
 705                                 ret =  FFS_MEDIAERR;
 706                                 goto out;
 707                         }
 708                         ep2 = ep;
 709                 }
 710
 711                 fid->type = p_fs->fs_func->get_entry_type(ep);
 712                 fid->rwoffset = 0;
 713                 fid->hint_last_off = -1;
 714                 fid->attr = p_fs->fs_func->get_entry_attr(ep);
 715
 716                 fid->size = p_fs->fs_func->get_entry_size(ep2);
 717                 if ((fid->type == TYPE_FILE) && (fid->size == 0)) {
 718                         fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
 719                         fid->start_clu = CLUSTER_32(~0);
 720                 } else {
 721                         fid->flags = p_fs->fs_func->get_entry_flag(ep2);
 722                         fid->start_clu = p_fs->fs_func->get_entry_clu0(ep2);
 723                 }
 724
 725                 if (p_fs->vol_type == EXFAT)
 726                         release_entry_set(es);
 727         }
 728
 729         if (p_fs->dev_ejected)
 730                 ret = FFS_MEDIAERR;
 731 out:
 732         /* release the lock for file system critical section */
 733         up(&p_fs->v_sem);
 734
 735         return ret;
 736 }
 737
 738 static int ffsCreateFile(struct inode *inode, char *path, u8 mode,
 739                          struct file_id_t *fid)
 740 {
 741         struct chain_t dir;
 742         struct uni_name_t uni_name;
 743         struct super_block *sb = inode->i_sb;
 744         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 745         int ret;
 746
 747         /* check the validity of pointer parameters */
 748         if (!fid || !path || (*path == '\0'))
 749                 return FFS_ERROR;
 750
 751         /* acquire the lock for file system critical section */
 752         down(&p_fs->v_sem);
 753
 754         /* check the validity of directory name in the given pathname */
 755         ret = resolve_path(inode, path, &dir, &uni_name);
 756         if (ret)
 757                 goto out;
 758
 759         fs_set_vol_flags(sb, VOL_DIRTY);
 760
 761         /* create a new file */
 762         ret = create_file(inode, &dir, &uni_name, mode, fid);
 763
 764 #ifdef CONFIG_EXFAT_DELAYED_SYNC
 765         fs_sync(sb, false);
 766         fs_set_vol_flags(sb, VOL_CLEAN);
 767 #endif
 768
 769         if (p_fs->dev_ejected)
 770                 ret = FFS_MEDIAERR;
 771
 772 out:
 773         /* release the lock for file system critical section */
 774         up(&p_fs->v_sem);
 775
 776         return ret;
 777 }
 778
 779 static int ffsReadFile(struct inode *inode, struct file_id_t *fid, void *buffer,
 780                        u64 count, u64 *rcount)
 781 {
 782         s32 offset, sec_offset, clu_offset;
 783         u32 clu;
 784         int ret = 0;
 785         sector_t LogSector;
 786         u64 oneblkread, read_bytes;
 787         struct buffer_head *tmp_bh = NULL;
 788         struct super_block *sb = inode->i_sb;
 789         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 790         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 791
 792         /* check the validity of the given file id */
 793         if (!fid)
 794                 return FFS_INVALIDFID;
 795
 796         /* check the validity of pointer parameters */
 797         if (!buffer)
 798                 return FFS_ERROR;
 799
 800         /* acquire the lock for file system critical section */
 801         down(&p_fs->v_sem);
 802
 803         /* check if the given file ID is opened */
 804         if (fid->type != TYPE_FILE) {
 805                 ret = FFS_PERMISSIONERR;
 806                 goto out;
 807         }
 808
 809         if (fid->rwoffset > fid->size)
 810                 fid->rwoffset = fid->size;
 811
 812         if (count > (fid->size - fid->rwoffset))
 813                 count = fid->size - fid->rwoffset;
 814
 815         if (count == 0) {
 816                 if (rcount)
 817                         *rcount = 0;
 818                 ret = FFS_EOF;
 819                 goto out;
 820         }
 821
 822         read_bytes = 0;
 823
 824         while (count > 0) {
 825                 clu_offset = (s32)(fid->rwoffset >> p_fs->cluster_size_bits);
 826                 clu = fid->start_clu;
 827
 828                 if (fid->flags == 0x03) {
 829                         clu += clu_offset;
 830                 } else {
 831                         /* hint information */
 832                         if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
 833                             (clu_offset >= fid->hint_last_off)) {
 834                                 clu_offset -= fid->hint_last_off;
 835                                 clu = fid->hint_last_clu;
 836                         }
 837
 838                         while (clu_offset > 0) {
 839                                 /* clu = FAT_read(sb, clu); */
 840                                 if (FAT_read(sb, clu, &clu) == -1)
 841                                         return FFS_MEDIAERR;
 842
 843                                 clu_offset--;
 844                         }
 845                 }
 846
 847                 /* hint information */
 848                 fid->hint_last_off = (s32)(fid->rwoffset >>
 849                                            p_fs->cluster_size_bits);
 850                 fid->hint_last_clu = clu;
 851
 852                 /* byte offset in cluster */
 853                 offset = (s32)(fid->rwoffset & (p_fs->cluster_size-1));
 854
 855                 /* sector offset in cluster */
 856                 sec_offset = offset >> p_bd->sector_size_bits;
 857
 858                 /* byte offset in sector */
 859                 offset &= p_bd->sector_size_mask;
 860
 861                 LogSector = START_SECTOR(clu) + sec_offset;
 862
 863                 oneblkread = (u64)(p_bd->sector_size - offset);
 864                 if (oneblkread > count)
 865                         oneblkread = count;
 866
 867                 if ((offset == 0) && (oneblkread == p_bd->sector_size)) {
 868                         if (sector_read(sb, LogSector, &tmp_bh, 1) !=
 869                             FFS_SUCCESS)
 870                                 goto err_out;
 871                         memcpy((char *)buffer + read_bytes,
 872                                (char *)tmp_bh->b_data, (s32)oneblkread);
 873                 } else {
 874                         if (sector_read(sb, LogSector, &tmp_bh, 1) !=
 875                             FFS_SUCCESS)
 876                                 goto err_out;
 877                         memcpy((char *)buffer + read_bytes,
 878                                (char *)tmp_bh->b_data + offset,
 879                                (s32)oneblkread);
 880                 }
 881                 count -= oneblkread;
 882                 read_bytes += oneblkread;
 883                 fid->rwoffset += oneblkread;
 884         }
 885         brelse(tmp_bh);
 886
 887 /* How did this ever work and not leak a brlse()?? */
 888 err_out:
 889         /* set the size of read bytes */
 890         if (rcount)
 891                 *rcount = read_bytes;
 892
 893         if (p_fs->dev_ejected)
 894                 ret = FFS_MEDIAERR;
 895
 896 out:
 897         /* release the lock for file system critical section */
 898         up(&p_fs->v_sem);
 899
 900         return ret;
 901 }
 902
 903 static int ffsWriteFile(struct inode *inode, struct file_id_t *fid,
 904                         void *buffer, u64 count, u64 *wcount)
 905 {
 906         bool modified = false;
 907         s32 offset, sec_offset, clu_offset;
 908         s32 num_clusters, num_alloc, num_alloced = (s32) ~0;
 909         int ret = 0;
 910         u32 clu, last_clu;
 911         sector_t LogSector, sector = 0;
 912         u64 oneblkwrite, write_bytes;
 913         struct chain_t new_clu;
 914         struct timestamp_t tm;
 915         struct dentry_t *ep, *ep2;
 916         struct entry_set_cache_t *es = NULL;
 917         struct buffer_head *tmp_bh = NULL;
 918         struct super_block *sb = inode->i_sb;
 919         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
 920         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
 921
 922         /* check the validity of the given file id */
 923         if (!fid)
 924                 return FFS_INVALIDFID;
 925
 926         /* check the validity of pointer parameters */
 927         if (!buffer)
 928                 return FFS_ERROR;
 929
 930         /* acquire the lock for file system critical section */
 931         down(&p_fs->v_sem);
 932
 933         /* check if the given file ID is opened */
 934         if (fid->type != TYPE_FILE) {
 935                 ret = FFS_PERMISSIONERR;
 936                 goto out;
 937         }
 938
 939         if (fid->rwoffset > fid->size)
 940                 fid->rwoffset = fid->size;
 941
 942         if (count == 0) {
 943                 if (wcount)
 944                         *wcount = 0;
 945                 ret = FFS_SUCCESS;
 946                 goto out;
 947         }
 948
 949         fs_set_vol_flags(sb, VOL_DIRTY);
 950
 951         if (fid->size == 0)
 952                 num_clusters = 0;
 953         else
 954                 num_clusters = (s32)((fid->size-1) >>
 955                                      p_fs->cluster_size_bits) + 1;
 956
 957         write_bytes = 0;
 958
 959         while (count > 0) {
 960                 clu_offset = (s32)(fid->rwoffset >> p_fs->cluster_size_bits);
 961                 clu = last_clu = fid->start_clu;
 962
 963                 if (fid->flags == 0x03) {
 964                         if ((clu_offset > 0) && (clu != CLUSTER_32(~0))) {
 965                                 last_clu += clu_offset - 1;
 966
 967                                 if (clu_offset == num_clusters)
 968                                         clu = CLUSTER_32(~0);
 969                                 else
 970                                         clu += clu_offset;
 971                         }
 972                 } else {
 973                         /* hint information */
 974                         if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
 975                             (clu_offset >= fid->hint_last_off)) {
 976                                 clu_offset -= fid->hint_last_off;
 977                                 clu = fid->hint_last_clu;
 978                         }
 979
 980                         while ((clu_offset > 0) && (clu != CLUSTER_32(~0))) {
 981                                 last_clu = clu;
 982                                 /* clu = FAT_read(sb, clu); */
 983                                 if (FAT_read(sb, clu, &clu) == -1) {
 984                                         ret = FFS_MEDIAERR;
 985                                         goto out;
 986                                 }
 987                                 clu_offset--;
 988                         }
 989                 }
 990
 991                 if (clu == CLUSTER_32(~0)) {
 992                         num_alloc = (s32)((count - 1) >>
 993                                           p_fs->cluster_size_bits) + 1;
 994                         new_clu.dir = (last_clu == CLUSTER_32(~0)) ?
 995                                         CLUSTER_32(~0) : last_clu+1;
 996                         new_clu.size = 0;
 997                         new_clu.flags = fid->flags;
 998
 999                         /* (1) allocate a chain of clusters */
1000                         num_alloced = p_fs->fs_func->alloc_cluster(sb,
1001                                                                    num_alloc,
1002                                                                    &new_clu);
1003                         if (num_alloced == 0)
1004                                 break;
1005                         if (num_alloced < 0) {
1006                                 ret = FFS_MEDIAERR;
1007                                 goto out;
1008                         }
1009
1010                         /* (2) append to the FAT chain */
1011                         if (last_clu == CLUSTER_32(~0)) {
1012                                 if (new_clu.flags == 0x01)
1013                                         fid->flags = 0x01;
1014                                 fid->start_clu = new_clu.dir;
1015                                 modified = true;
1016                         } else {
1017                                 if (new_clu.flags != fid->flags) {
1018                                         exfat_chain_cont_cluster(sb,
1019                                                                  fid->start_clu,
1020                                                                  num_clusters);
1021                                         fid->flags = 0x01;
1022                                         modified = true;
1023                                 }
1024                                 if (new_clu.flags == 0x01)
1025                                         FAT_write(sb, last_clu, new_clu.dir);
1026                         }
1027
1028                         num_clusters += num_alloced;
1029                         clu = new_clu.dir;
1030                 }
1031
1032                 /* hint information */
1033                 fid->hint_last_off = (s32)(fid->rwoffset >>
1034                                            p_fs->cluster_size_bits);
1035                 fid->hint_last_clu = clu;
1036
1037                 /* byte offset in cluster   */
1038                 offset = (s32)(fid->rwoffset & (p_fs->cluster_size - 1));
1039
1040                 /* sector offset in cluster */
1041                 sec_offset = offset >> p_bd->sector_size_bits;
1042
1043                 /* byte offset in sector    */
1044                 offset &= p_bd->sector_size_mask;
1045
1046                 LogSector = START_SECTOR(clu) + sec_offset;
1047
1048                 oneblkwrite = (u64)(p_bd->sector_size - offset);
1049                 if (oneblkwrite > count)
1050                         oneblkwrite = count;
1051
1052                 if ((offset == 0) && (oneblkwrite == p_bd->sector_size)) {
1053                         if (sector_read(sb, LogSector, &tmp_bh, 0) !=
1054                             FFS_SUCCESS)
1055                                 goto err_out;
1056                         memcpy((char *)tmp_bh->b_data,
1057                                (char *)buffer + write_bytes, (s32)oneblkwrite);
1058                         if (sector_write(sb, LogSector, tmp_bh, 0) !=
1059                             FFS_SUCCESS) {
1060                                 brelse(tmp_bh);
1061                                 goto err_out;
1062                         }
1063                 } else {
1064                         if ((offset > 0) ||
1065                             ((fid->rwoffset+oneblkwrite) < fid->size)) {
1066                                 if (sector_read(sb, LogSector, &tmp_bh, 1) !=
1067                                     FFS_SUCCESS)
1068                                         goto err_out;
1069                         } else {
1070                                 if (sector_read(sb, LogSector, &tmp_bh, 0) !=
1071                                     FFS_SUCCESS)
1072                                         goto err_out;
1073                         }
1074
1075                         memcpy((char *)tmp_bh->b_data + offset,
1076                                (char *)buffer + write_bytes, (s32)oneblkwrite);
1077                         if (sector_write(sb, LogSector, tmp_bh, 0) !=
1078                             FFS_SUCCESS) {
1079                                 brelse(tmp_bh);
1080                                 goto err_out;
1081                         }
1082                 }
1083
1084                 count -= oneblkwrite;
1085                 write_bytes += oneblkwrite;
1086                 fid->rwoffset += oneblkwrite;
1087
1088                 fid->attr |= ATTR_ARCHIVE;
1089
1090                 if (fid->size < fid->rwoffset) {
1091                         fid->size = fid->rwoffset;
1092                         modified = true;
1093                 }
1094         }
1095
1096         brelse(tmp_bh);
1097
1098         /* (3) update the direcoty entry */
1099         if (p_fs->vol_type == EXFAT) {
1100                 es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
1101                                           ES_ALL_ENTRIES, &ep);
1102                 if (!es)
1103                         goto err_out;
1104                 ep2 = ep+1;
1105         } else {
1106                 ep = get_entry_in_dir(sb, &(fid->dir), fid->entry, &sector);
1107                 if (!ep)
1108                         goto err_out;
1109                 ep2 = ep;
1110         }
1111
1112         p_fs->fs_func->set_entry_time(ep, tm_current(&tm), TM_MODIFY);
1113         p_fs->fs_func->set_entry_attr(ep, fid->attr);
1114
1115         if (p_fs->vol_type != EXFAT)
1116                 buf_modify(sb, sector);
1117
1118         if (modified) {
1119                 if (p_fs->fs_func->get_entry_flag(ep2) != fid->flags)
1120                         p_fs->fs_func->set_entry_flag(ep2, fid->flags);
1121
1122                 if (p_fs->fs_func->get_entry_size(ep2) != fid->size)
1123                         p_fs->fs_func->set_entry_size(ep2, fid->size);
1124
1125                 if (p_fs->fs_func->get_entry_clu0(ep2) != fid->start_clu)
1126                         p_fs->fs_func->set_entry_clu0(ep2, fid->start_clu);
1127
1128                 if (p_fs->vol_type != EXFAT)
1129                         buf_modify(sb, sector);
1130         }
1131
1132         if (p_fs->vol_type == EXFAT) {
1133                 update_dir_checksum_with_entry_set(sb, es);
1134                 release_entry_set(es);
1135         }
1136
1137 #ifdef CONFIG_EXFAT_DELAYED_SYNC
1138         fs_sync(sb, false);
1139         fs_set_vol_flags(sb, VOL_CLEAN);
1140 #endif
1141
1142 err_out:
1143         /* set the size of written bytes */
1144         if (wcount)
1145                 *wcount = write_bytes;
1146
1147         if (num_alloced == 0)
1148                 ret = FFS_FULL;
1149
1150         else if (p_fs->dev_ejected)
1151                 ret = FFS_MEDIAERR;
1152
1153 out:
1154         /* release the lock for file system critical section */
1155         up(&p_fs->v_sem);
1156
1157         return ret;
1158 }
1159
1160 static int ffsTruncateFile(struct inode *inode, u64 old_size, u64 new_size)
1161 {
1162         s32 num_clusters;
1163         u32 last_clu = CLUSTER_32(0);
1164         int ret = 0;
1165         sector_t sector = 0;
1166         struct chain_t clu;
1167         struct timestamp_t tm;
1168         struct dentry_t *ep, *ep2;
1169         struct super_block *sb = inode->i_sb;
1170         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1171         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
1172         struct entry_set_cache_t *es = NULL;
1173
1174         pr_debug("%s entered (inode %p size %llu)\n", __func__, inode,
1175                  new_size);
1176
1177         /* acquire the lock for file system critical section */
1178         down(&p_fs->v_sem);
1179
1180         /* check if the given file ID is opened */
1181         if (fid->type != TYPE_FILE) {
1182                 ret = FFS_PERMISSIONERR;
1183                 goto out;
1184         }
1185
1186         if (fid->size != old_size) {
1187                 pr_err("[EXFAT] truncate : can't skip it because of size-mismatch(old:%lld->fid:%lld).\n",
1188                        old_size, fid->size);
1189         }
1190
1191         if (old_size <= new_size) {
1192                 ret = FFS_SUCCESS;
1193                 goto out;
1194         }
1195
1196         fs_set_vol_flags(sb, VOL_DIRTY);
1197
1198         clu.dir = fid->start_clu;
1199         clu.size = (s32)((old_size-1) >> p_fs->cluster_size_bits) + 1;
1200         clu.flags = fid->flags;
1201
1202         if (new_size > 0) {
1203                 num_clusters = (s32)((new_size-1) >>
1204                                      p_fs->cluster_size_bits) + 1;
1205
1206                 if (clu.flags == 0x03) {
1207                         clu.dir += num_clusters;
1208                 } else {
1209                         while (num_clusters > 0) {
1210                                 last_clu = clu.dir;
1211                                 if (FAT_read(sb, clu.dir, &clu.dir) == -1) {
1212                                         ret = FFS_MEDIAERR;
1213                                         goto out;
1214                                 }
1215                                 num_clusters--;
1216                         }
1217                 }
1218
1219                 clu.size -= num_clusters;
1220         }
1221
1222         fid->size = new_size;
1223         fid->attr |= ATTR_ARCHIVE;
1224         if (new_size == 0) {
1225                 fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
1226                 fid->start_clu = CLUSTER_32(~0);
1227         }
1228
1229         /* (1) update the directory entry */
1230         if (p_fs->vol_type == EXFAT) {
1231                 es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
1232                                           ES_ALL_ENTRIES, &ep);
1233                 if (!es) {
1234                         ret = FFS_MEDIAERR;
1235                         goto out;
1236                         }
1237                 ep2 = ep+1;
1238         } else {
1239                 ep = get_entry_in_dir(sb, &(fid->dir), fid->entry, &sector);
1240                 if (!ep) {
1241                         ret = FFS_MEDIAERR;
1242                         goto out;
1243                 }
1244                 ep2 = ep;
1245         }
1246
1247         p_fs->fs_func->set_entry_time(ep, tm_current(&tm), TM_MODIFY);
1248         p_fs->fs_func->set_entry_attr(ep, fid->attr);
1249
1250         p_fs->fs_func->set_entry_size(ep2, new_size);
1251         if (new_size == 0) {
1252                 p_fs->fs_func->set_entry_flag(ep2, 0x01);
1253                 p_fs->fs_func->set_entry_clu0(ep2, CLUSTER_32(0));
1254         }
1255
1256         if (p_fs->vol_type != EXFAT) {
1257                 buf_modify(sb, sector);
1258         } else {
1259                 update_dir_checksum_with_entry_set(sb, es);
1260                 release_entry_set(es);
1261         }
1262
1263         /* (2) cut off from the FAT chain */
1264         if (last_clu != CLUSTER_32(0)) {
1265                 if (fid->flags == 0x01)
1266                         FAT_write(sb, last_clu, CLUSTER_32(~0));
1267         }
1268
1269         /* (3) free the clusters */
1270         p_fs->fs_func->free_cluster(sb, &clu, 0);
1271
1272         /* hint information */
1273         fid->hint_last_off = -1;
1274         if (fid->rwoffset > fid->size)
1275                 fid->rwoffset = fid->size;
1276
1277 #ifdef CONFIG_EXFAT_DELAYED_SYNC
1278         fs_sync(sb, false);
1279         fs_set_vol_flags(sb, VOL_CLEAN);
1280 #endif
1281
1282         if (p_fs->dev_ejected)
1283                 ret = FFS_MEDIAERR;
1284
1285 out:
1286         pr_debug("%s exited (%d)\n", __func__, ret);
1287         /* release the lock for file system critical section */
1288         up(&p_fs->v_sem);
1289
1290         return ret;
1291 }
1292
1293 static void update_parent_info(struct file_id_t *fid,
1294                                struct inode *parent_inode)
1295 {
1296         struct fs_info_t *p_fs = &(EXFAT_SB(parent_inode->i_sb)->fs_info);
1297         struct file_id_t *parent_fid = &(EXFAT_I(parent_inode)->fid);
1298
1299         if (unlikely((parent_fid->flags != fid->dir.flags) ||
1300                      (parent_fid->size !=
1301                       (fid->dir.size << p_fs->cluster_size_bits)) ||
1302                      (parent_fid->start_clu != fid->dir.dir))) {
1303                 fid->dir.dir = parent_fid->start_clu;
1304                 fid->dir.flags = parent_fid->flags;
1305                 fid->dir.size = ((parent_fid->size + (p_fs->cluster_size-1))
1306                                                 >> p_fs->cluster_size_bits);
1307         }
1308 }
1309
1310 static int ffsMoveFile(struct inode *old_parent_inode, struct file_id_t *fid,
1311                        struct inode *new_parent_inode, struct dentry *new_dentry)
1312 {
1313         s32 ret;
1314         s32 dentry;
1315         struct chain_t olddir, newdir;
1316         struct chain_t *p_dir = NULL;
1317         struct uni_name_t uni_name;
1318         struct dentry_t *ep;
1319         struct super_block *sb = old_parent_inode->i_sb;
1320         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1321         u8 *new_path = (u8 *) new_dentry->d_name.name;
1322         struct inode *new_inode = new_dentry->d_inode;
1323         int num_entries;
1324         struct file_id_t *new_fid = NULL;
1325         s32 new_entry = 0;
1326
1327         /* check the validity of the given file id */
1328         if (!fid)
1329                 return FFS_INVALIDFID;
1330
1331         /* check the validity of pointer parameters */
1332         if (!new_path || (*new_path == '\0'))
1333                 return FFS_ERROR;
1334
1335         /* acquire the lock for file system critical section */
1336         down(&p_fs->v_sem);
1337
1338         update_parent_info(fid, old_parent_inode);
1339
1340         olddir.dir = fid->dir.dir;
1341         olddir.size = fid->dir.size;
1342         olddir.flags = fid->dir.flags;
1343
1344         dentry = fid->entry;
1345
1346         /* check if the old file is "." or ".." */
1347         if (p_fs->vol_type != EXFAT) {
1348                 if ((olddir.dir != p_fs->root_dir) && (dentry < 2)) {
1349                         ret = FFS_PERMISSIONERR;
1350                         goto out2;
1351                 }
1352         }
1353
1354         ep = get_entry_in_dir(sb, &olddir, dentry, NULL);
1355         if (!ep) {
1356                 ret = FFS_MEDIAERR;
1357                 goto out2;
1358         }
1359
1360         if (p_fs->fs_func->get_entry_attr(ep) & ATTR_READONLY) {
1361                 ret = FFS_PERMISSIONERR;
1362                 goto out2;
1363         }
1364
1365         /* check whether new dir is existing directory and empty */
1366         if (new_inode) {
1367                 u32 entry_type;
1368
1369                 ret = FFS_MEDIAERR;
1370                 new_fid = &EXFAT_I(new_inode)->fid;
1371
1372                 update_parent_info(new_fid, new_parent_inode);
1373
1374                 p_dir = &(new_fid->dir);
1375                 new_entry = new_fid->entry;
1376                 ep = get_entry_in_dir(sb, p_dir, new_entry, NULL);
1377                 if (!ep)
1378                         goto out;
1379
1380                 entry_type = p_fs->fs_func->get_entry_type(ep);
1381
1382                 if (entry_type == TYPE_DIR) {
1383                         struct chain_t new_clu;
1384
1385                         new_clu.dir = new_fid->start_clu;
1386                         new_clu.size = (s32)((new_fid->size - 1) >>
1387                                              p_fs->cluster_size_bits) + 1;
1388                         new_clu.flags = new_fid->flags;
1389
1390                         if (!is_dir_empty(sb, &new_clu)) {
1391                                 ret = FFS_FILEEXIST;
1392                                 goto out;
1393                         }
1394                 }
1395         }
1396
1397         /* check the validity of directory name in the given new pathname */
1398         ret = resolve_path(new_parent_inode, new_path, &newdir, &uni_name);
1399         if (ret)
1400                 goto out2;
1401
1402         fs_set_vol_flags(sb, VOL_DIRTY);
1403
1404         if (olddir.dir == newdir.dir)
1405                 ret = rename_file(new_parent_inode, &olddir, dentry, &uni_name,
1406                                   fid);
1407         else
1408                 ret = move_file(new_parent_inode, &olddir, dentry, &newdir,
1409                                 &uni_name, fid);
1410
1411         if ((ret == FFS_SUCCESS) && new_inode) {
1412                 /* delete entries of new_dir */
1413                 ep = get_entry_in_dir(sb, p_dir, new_entry, NULL);
1414                 if (!ep)
1415                         goto out;
1416
1417                 num_entries = p_fs->fs_func->count_ext_entries(sb, p_dir,
1418                                                                new_entry, ep);
1419                 if (num_entries < 0)
1420                         goto out;
1421                 p_fs->fs_func->delete_dir_entry(sb, p_dir, new_entry, 0,
1422                                                 num_entries+1);
1423         }
1424 out:
1425 #ifdef CONFIG_EXFAT_DELAYED_SYNC
1426         fs_sync(sb, false);
1427         fs_set_vol_flags(sb, VOL_CLEAN);
1428 #endif
1429
1430         if (p_fs->dev_ejected)
1431                 ret = FFS_MEDIAERR;
1432 out2:
1433         /* release the lock for file system critical section */
1434         up(&p_fs->v_sem);
1435
1436         return ret;
1437 }
1438
1439 static int ffsRemoveFile(struct inode *inode, struct file_id_t *fid)
1440 {
1441         s32 dentry;
1442         int ret = FFS_SUCCESS;
1443         struct chain_t dir, clu_to_free;
1444         struct dentry_t *ep;
1445         struct super_block *sb = inode->i_sb;
1446         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1447
1448         /* check the validity of the given file id */
1449         if (!fid)
1450                 return FFS_INVALIDFID;
1451
1452         /* acquire the lock for file system critical section */
1453         down(&p_fs->v_sem);
1454
1455         dir.dir = fid->dir.dir;
1456         dir.size = fid->dir.size;
1457         dir.flags = fid->dir.flags;
1458
1459         dentry = fid->entry;
1460
1461         ep = get_entry_in_dir(sb, &dir, dentry, NULL);
1462         if (!ep) {
1463                 ret = FFS_MEDIAERR;
1464                 goto out;
1465         }
1466
1467         if (p_fs->fs_func->get_entry_attr(ep) & ATTR_READONLY) {
1468                 ret = FFS_PERMISSIONERR;
1469                 goto out;
1470         }
1471         fs_set_vol_flags(sb, VOL_DIRTY);
1472
1473         /* (1) update the directory entry */
1474         remove_file(inode, &dir, dentry);
1475
1476         clu_to_free.dir = fid->start_clu;
1477         clu_to_free.size = (s32)((fid->size-1) >> p_fs->cluster_size_bits) + 1;
1478         clu_to_free.flags = fid->flags;
1479
1480         /* (2) free the clusters */
1481         p_fs->fs_func->free_cluster(sb, &clu_to_free, 0);
1482
1483         fid->size = 0;
1484         fid->start_clu = CLUSTER_32(~0);
1485         fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
1486
1487 #ifdef CONFIG_EXFAT_DELAYED_SYNC
1488         fs_sync(sb, false);
1489         fs_set_vol_flags(sb, VOL_CLEAN);
1490 #endif
1491
1492         if (p_fs->dev_ejected)
1493                 ret = FFS_MEDIAERR;
1494 out:
1495         /* release the lock for file system critical section */
1496         up(&p_fs->v_sem);
1497
1498         return ret;
1499 }
1500
1501 #if 0
1502 /* Not currently wired up */
1503 static int ffsSetAttr(struct inode *inode, u32 attr)
1504 {
1505         u32 type;
1506         int ret = FFS_SUCCESS;
1507         sector_t sector = 0;
1508         struct dentry_t *ep;
1509         struct super_block *sb = inode->i_sb;
1510         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1511         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
1512         u8 is_dir = (fid->type == TYPE_DIR) ? 1 : 0;
1513         struct entry_set_cache_t *es = NULL;
1514
1515         if (fid->attr == attr) {
1516                 if (p_fs->dev_ejected)
1517                         return FFS_MEDIAERR;
1518                 return FFS_SUCCESS;
1519         }
1520
1521         if (is_dir) {
1522                 if ((fid->dir.dir == p_fs->root_dir) &&
1523                     (fid->entry == -1)) {
1524                         if (p_fs->dev_ejected)
1525                                 return FFS_MEDIAERR;
1526                         return FFS_SUCCESS;
1527                 }
1528         }
1529
1530         /* acquire the lock for file system critical section */
1531         down(&p_fs->v_sem);
1532
1533         /* get the directory entry of given file */
1534         if (p_fs->vol_type == EXFAT) {
1535                 es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
1536                                           ES_ALL_ENTRIES, &ep);
1537                 if (!es) {
1538                         ret = FFS_MEDIAERR;
1539                         goto out;
1540                 }
1541         } else {
1542                 ep = get_entry_in_dir(sb, &(fid->dir), fid->entry, &sector);
1543                 if (!ep) {
1544                         ret = FFS_MEDIAERR;
1545                         goto out;
1546                 }
1547         }
1548
1549         type = p_fs->fs_func->get_entry_type(ep);
1550
1551         if (((type == TYPE_FILE) && (attr & ATTR_SUBDIR)) ||
1552             ((type == TYPE_DIR) && (!(attr & ATTR_SUBDIR)))) {
1553                 if (p_fs->dev_ejected)
1554                         ret = FFS_MEDIAERR;
1555                 else
1556                         ret = FFS_ERROR;
1557
1558                 if (p_fs->vol_type == EXFAT)
1559                         release_entry_set(es);
1560                 goto out;
1561         }
1562
1563         fs_set_vol_flags(sb, VOL_DIRTY);
1564
1565         /* set the file attribute */
1566         fid->attr = attr;
1567         p_fs->fs_func->set_entry_attr(ep, attr);
1568
1569         if (p_fs->vol_type != EXFAT) {
1570                 buf_modify(sb, sector);
1571         } else {
1572                 update_dir_checksum_with_entry_set(sb, es);
1573                 release_entry_set(es);
1574         }
1575
1576 #ifdef CONFIG_EXFAT_DELAYED_SYNC
1577         fs_sync(sb, false);
1578         fs_set_vol_flags(sb, VOL_CLEAN);
1579 #endif
1580
1581         if (p_fs->dev_ejected)
1582                 ret = FFS_MEDIAERR;
1583 out:
1584         /* release the lock for file system critical section */
1585         up(&p_fs->v_sem);
1586
1587         return ret;
1588 }
1589 #endif
1590
1591 static int ffsReadStat(struct inode *inode, struct dir_entry_t *info)
1592 {
1593         sector_t sector = 0;
1594         s32 count;
1595         int ret = FFS_SUCCESS;
1596         struct chain_t dir;
1597         struct uni_name_t uni_name;
1598         struct timestamp_t tm;
1599         struct dentry_t *ep, *ep2;
1600         struct super_block *sb = inode->i_sb;
1601         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1602         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
1603         struct entry_set_cache_t *es = NULL;
1604         u8 is_dir = (fid->type == TYPE_DIR) ? 1 : 0;
1605
1606         pr_debug("%s entered\n", __func__);
1607
1608         /* acquire the lock for file system critical section */
1609         down(&p_fs->v_sem);
1610
1611         if (is_dir) {
1612                 if ((fid->dir.dir == p_fs->root_dir) &&
1613                     (fid->entry == -1)) {
1614                         info->Attr = ATTR_SUBDIR;
1615                         memset((char *)&info->CreateTimestamp, 0,
1616                                sizeof(struct date_time_t));
1617                         memset((char *)&info->ModifyTimestamp, 0,
1618                                sizeof(struct date_time_t));
1619                         memset((char *)&info->AccessTimestamp, 0,
1620                                sizeof(struct date_time_t));
1621                         strcpy(info->ShortName, ".");
1622                         strcpy(info->Name, ".");
1623
1624                         dir.dir = p_fs->root_dir;
1625                         dir.flags = 0x01;
1626
1627                         if (p_fs->root_dir == CLUSTER_32(0)) {
1628                                 /* FAT16 root_dir */
1629                                 info->Size = p_fs->dentries_in_root <<
1630                                                 DENTRY_SIZE_BITS;
1631                         } else {
1632                                 info->Size = count_num_clusters(sb, &dir) <<
1633                                                 p_fs->cluster_size_bits;
1634                         }
1635
1636                         count = count_dos_name_entries(sb, &dir, TYPE_DIR);
1637                         if (count < 0) {
1638                                 ret = FFS_MEDIAERR;
1639                                 goto out;
1640                         }
1641                         info->NumSubdirs = count;
1642
1643                         if (p_fs->dev_ejected)
1644                                 ret = FFS_MEDIAERR;
1645                         goto out;
1646                 }
1647         }
1648
1649         /* get the directory entry of given file or directory */
1650         if (p_fs->vol_type == EXFAT) {
1651                 es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
1652                                           ES_2_ENTRIES, &ep);
1653                 if (!es) {
1654                         ret = FFS_MEDIAERR;
1655                         goto out;
1656                 }
1657                 ep2 = ep+1;
1658         } else {
1659                 ep = get_entry_in_dir(sb, &(fid->dir), fid->entry, &sector);
1660                 if (!ep) {
1661                         ret = FFS_MEDIAERR;
1662                         goto out;
1663                 }
1664                 ep2 = ep;
1665                 buf_lock(sb, sector);
1666         }
1667
1668         /* set FILE_INFO structure using the acquired struct dentry_t */
1669         info->Attr = p_fs->fs_func->get_entry_attr(ep);
1670
1671         p_fs->fs_func->get_entry_time(ep, &tm, TM_CREATE);
1672         info->CreateTimestamp.Year = tm.year;
1673         info->CreateTimestamp.Month = tm.mon;
1674         info->CreateTimestamp.Day = tm.day;
1675         info->CreateTimestamp.Hour = tm.hour;
1676         info->CreateTimestamp.Minute = tm.min;
1677         info->CreateTimestamp.Second = tm.sec;
1678         info->CreateTimestamp.MilliSecond = 0;
1679
1680         p_fs->fs_func->get_entry_time(ep, &tm, TM_MODIFY);
1681         info->ModifyTimestamp.Year = tm.year;
1682         info->ModifyTimestamp.Month = tm.mon;
1683         info->ModifyTimestamp.Day = tm.day;
1684         info->ModifyTimestamp.Hour = tm.hour;
1685         info->ModifyTimestamp.Minute = tm.min;
1686         info->ModifyTimestamp.Second = tm.sec;
1687         info->ModifyTimestamp.MilliSecond = 0;
1688
1689         memset((char *) &info->AccessTimestamp, 0, sizeof(struct date_time_t));
1690
1691         *(uni_name.name) = 0x0;
1692         /* XXX this is very bad for exfat cuz name is already included in es.
1693          * API should be revised
1694          */
1695         p_fs->fs_func->get_uni_name_from_ext_entry(sb, &(fid->dir), fid->entry,
1696                                                    uni_name.name);
1697         if (*uni_name.name == 0x0 && p_fs->vol_type != EXFAT)
1698                 get_uni_name_from_dos_entry(sb, (struct dos_dentry_t *)ep,
1699                                             &uni_name, 0x1);
1700         nls_uniname_to_cstring(sb, info->Name, &uni_name);
1701
1702         if (p_fs->vol_type == EXFAT) {
1703                 info->NumSubdirs = 2;
1704         } else {
1705                 buf_unlock(sb, sector);
1706                 get_uni_name_from_dos_entry(sb, (struct dos_dentry_t *)ep,
1707                                             &uni_name, 0x0);
1708                 nls_uniname_to_cstring(sb, info->ShortName, &uni_name);
1709                 info->NumSubdirs = 0;
1710         }
1711
1712         info->Size = p_fs->fs_func->get_entry_size(ep2);
1713
1714         if (p_fs->vol_type == EXFAT)
1715                 release_entry_set(es);
1716
1717         if (is_dir) {
1718                 dir.dir = fid->start_clu;
1719                 dir.flags = 0x01;
1720
1721                 if (info->Size == 0)
1722                         info->Size = (u64)count_num_clusters(sb, &dir) <<
1723                                         p_fs->cluster_size_bits;
1724
1725                 count = count_dos_name_entries(sb, &dir, TYPE_DIR);
1726                 if (count < 0) {
1727                         ret = FFS_MEDIAERR;
1728                         goto out;
1729                 }
1730                 info->NumSubdirs += count;
1731         }
1732
1733         if (p_fs->dev_ejected)
1734                 ret = FFS_MEDIAERR;
1735
1736 out:
1737         /* release the lock for file system critical section */
1738         up(&p_fs->v_sem);
1739
1740         pr_debug("%s exited successfully\n", __func__);
1741         return ret;
1742 }
1743
1744 static int ffsWriteStat(struct inode *inode, struct dir_entry_t *info)
1745 {
1746         sector_t sector = 0;
1747         int ret = FFS_SUCCESS;
1748         struct timestamp_t tm;
1749         struct dentry_t *ep, *ep2;
1750         struct entry_set_cache_t *es = NULL;
1751         struct super_block *sb = inode->i_sb;
1752         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1753         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
1754         u8 is_dir = (fid->type == TYPE_DIR) ? 1 : 0;
1755
1756         pr_debug("%s entered (inode %p info %p\n", __func__, inode, info);
1757
1758         /* acquire the lock for file system critical section */
1759         down(&p_fs->v_sem);
1760
1761         if (is_dir) {
1762                 if ((fid->dir.dir == p_fs->root_dir) &&
1763                     (fid->entry == -1)) {
1764                         if (p_fs->dev_ejected)
1765                                 ret = FFS_MEDIAERR;
1766                         ret = FFS_SUCCESS;
1767                         goto out;
1768                 }
1769         }
1770
1771         fs_set_vol_flags(sb, VOL_DIRTY);
1772
1773         /* get the directory entry of given file or directory */
1774         if (p_fs->vol_type == EXFAT) {
1775                 es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
1776                                           ES_ALL_ENTRIES, &ep);
1777                 if (!es) {
1778                         ret = FFS_MEDIAERR;
1779                         goto out;
1780                 }
1781                 ep2 = ep+1;
1782         } else {
1783                 /* for other than exfat */
1784                 ep = get_entry_in_dir(sb, &(fid->dir), fid->entry, &sector);
1785                 if (!ep) {
1786                         ret = FFS_MEDIAERR;
1787                         goto out;
1788                 }
1789                 ep2 = ep;
1790         }
1791
1792         p_fs->fs_func->set_entry_attr(ep, info->Attr);
1793
1794         /* set FILE_INFO structure using the acquired struct dentry_t */
1795         tm.sec  = info->CreateTimestamp.Second;
1796         tm.min  = info->CreateTimestamp.Minute;
1797         tm.hour = info->CreateTimestamp.Hour;
1798         tm.day  = info->CreateTimestamp.Day;
1799         tm.mon  = info->CreateTimestamp.Month;
1800         tm.year = info->CreateTimestamp.Year;
1801         p_fs->fs_func->set_entry_time(ep, &tm, TM_CREATE);
1802
1803         tm.sec  = info->ModifyTimestamp.Second;
1804         tm.min  = info->ModifyTimestamp.Minute;
1805         tm.hour = info->ModifyTimestamp.Hour;
1806         tm.day  = info->ModifyTimestamp.Day;
1807         tm.mon  = info->ModifyTimestamp.Month;
1808         tm.year = info->ModifyTimestamp.Year;
1809         p_fs->fs_func->set_entry_time(ep, &tm, TM_MODIFY);
1810
1811         p_fs->fs_func->set_entry_size(ep2, info->Size);
1812
1813         if (p_fs->vol_type != EXFAT) {
1814                 buf_modify(sb, sector);
1815         } else {
1816                 update_dir_checksum_with_entry_set(sb, es);
1817                 release_entry_set(es);
1818         }
1819
1820         if (p_fs->dev_ejected)
1821                 ret = FFS_MEDIAERR;
1822
1823 out:
1824         /* release the lock for file system critical section */
1825         up(&p_fs->v_sem);
1826
1827         pr_debug("%s exited (%d)\n", __func__, ret);
1828
1829         return ret;
1830 }
1831
1832 static int ffsMapCluster(struct inode *inode, s32 clu_offset, u32 *clu)
1833 {
1834         s32 num_clusters, num_alloced;
1835         bool modified = false;
1836         u32 last_clu;
1837         int ret = FFS_SUCCESS;
1838         sector_t sector = 0;
1839         struct chain_t new_clu;
1840         struct dentry_t *ep;
1841         struct entry_set_cache_t *es = NULL;
1842         struct super_block *sb = inode->i_sb;
1843         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1844         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
1845
1846         /* check the validity of pointer parameters */
1847         if (!clu)
1848                 return FFS_ERROR;
1849
1850         /* acquire the lock for file system critical section */
1851         down(&p_fs->v_sem);
1852
1853         fid->rwoffset = (s64)(clu_offset) << p_fs->cluster_size_bits;
1854
1855         if (EXFAT_I(inode)->mmu_private == 0)
1856                 num_clusters = 0;
1857         else
1858                 num_clusters = (s32)((EXFAT_I(inode)->mmu_private - 1) >>
1859                                      p_fs->cluster_size_bits) + 1;
1860
1861         *clu = last_clu = fid->start_clu;
1862
1863         if (fid->flags == 0x03) {
1864                 if ((clu_offset > 0) && (*clu != CLUSTER_32(~0))) {
1865                         last_clu += clu_offset - 1;
1866
1867                         if (clu_offset == num_clusters)
1868                                 *clu = CLUSTER_32(~0);
1869                         else
1870                                 *clu += clu_offset;
1871                 }
1872         } else {
1873                 /* hint information */
1874                 if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
1875                     (clu_offset >= fid->hint_last_off)) {
1876                         clu_offset -= fid->hint_last_off;
1877                         *clu = fid->hint_last_clu;
1878                 }
1879
1880                 while ((clu_offset > 0) && (*clu != CLUSTER_32(~0))) {
1881                         last_clu = *clu;
1882                         if (FAT_read(sb, *clu, clu) == -1) {
1883                                 ret = FFS_MEDIAERR;
1884                                 goto out;
1885                         }
1886                         clu_offset--;
1887                 }
1888         }
1889
1890         if (*clu == CLUSTER_32(~0)) {
1891                 fs_set_vol_flags(sb, VOL_DIRTY);
1892
1893                 new_clu.dir = (last_clu == CLUSTER_32(~0)) ? CLUSTER_32(~0) :
1894                                         last_clu + 1;
1895                 new_clu.size = 0;
1896                 new_clu.flags = fid->flags;
1897
1898                 /* (1) allocate a cluster */
1899                 num_alloced = p_fs->fs_func->alloc_cluster(sb, 1, &new_clu);
1900                 if (num_alloced < 0) {
1901                         ret = FFS_MEDIAERR;
1902                         goto out;
1903                 } else if (num_alloced == 0) {
1904                         ret = FFS_FULL;
1905                         goto out;
1906                 }
1907
1908                 /* (2) append to the FAT chain */
1909                 if (last_clu == CLUSTER_32(~0)) {
1910                         if (new_clu.flags == 0x01)
1911                                 fid->flags = 0x01;
1912                         fid->start_clu = new_clu.dir;
1913                         modified = true;
1914                 } else {
1915                         if (new_clu.flags != fid->flags) {
1916                                 exfat_chain_cont_cluster(sb, fid->start_clu,
1917                                                          num_clusters);
1918                                 fid->flags = 0x01;
1919                                 modified = true;
1920                         }
1921                         if (new_clu.flags == 0x01)
1922                                 FAT_write(sb, last_clu, new_clu.dir);
1923                 }
1924
1925                 num_clusters += num_alloced;
1926                 *clu = new_clu.dir;
1927
1928                 if (p_fs->vol_type == EXFAT) {
1929                         es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
1930                                                   ES_ALL_ENTRIES, &ep);
1931                         if (!es) {
1932                                 ret = FFS_MEDIAERR;
1933                                 goto out;
1934                         }
1935                         /* get stream entry */
1936                         ep++;
1937                 }
1938
1939                 /* (3) update directory entry */
1940                 if (modified) {
1941                         if (p_fs->vol_type != EXFAT) {
1942                                 ep = get_entry_in_dir(sb, &(fid->dir),
1943                                                       fid->entry, &sector);
1944                                 if (!ep) {
1945                                         ret = FFS_MEDIAERR;
1946                                         goto out;
1947                                 }
1948                         }
1949
1950                         if (p_fs->fs_func->get_entry_flag(ep) != fid->flags)
1951                                 p_fs->fs_func->set_entry_flag(ep, fid->flags);
1952
1953                         if (p_fs->fs_func->get_entry_clu0(ep) != fid->start_clu)
1954                                 p_fs->fs_func->set_entry_clu0(ep,
1955                                                               fid->start_clu);
1956
1957                         if (p_fs->vol_type != EXFAT)
1958                                 buf_modify(sb, sector);
1959                 }
1960
1961                 if (p_fs->vol_type == EXFAT) {
1962                         update_dir_checksum_with_entry_set(sb, es);
1963                         release_entry_set(es);
1964                 }
1965
1966                 /* add number of new blocks to inode */
1967                 inode->i_blocks += num_alloced << (p_fs->cluster_size_bits - 9);
1968         }
1969
1970         /* hint information */
1971         fid->hint_last_off = (s32)(fid->rwoffset >> p_fs->cluster_size_bits);
1972         fid->hint_last_clu = *clu;
1973
1974         if (p_fs->dev_ejected)
1975                 ret = FFS_MEDIAERR;
1976
1977 out:
1978         /* release the lock for file system critical section */
1979         up(&p_fs->v_sem);
1980
1981         return ret;
1982 }
1983
1984 /*----------------------------------------------------------------------*/
1985 /*  Directory Operation Functions                                       */
1986 /*----------------------------------------------------------------------*/
1987
1988 static int ffsCreateDir(struct inode *inode, char *path, struct file_id_t *fid)
1989 {
1990         int ret = FFS_SUCCESS;
1991         struct chain_t dir;
1992         struct uni_name_t uni_name;
1993         struct super_block *sb = inode->i_sb;
1994         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
1995
1996         pr_debug("%s entered\n", __func__);
1997
1998         /* check the validity of pointer parameters */
1999         if (!fid || !path || (*path == '\0'))
2000                 return FFS_ERROR;
2001
2002         /* acquire the lock for file system critical section */
2003         down(&p_fs->v_sem);
2004
2005         /* check the validity of directory name in the given old pathname */
2006         ret = resolve_path(inode, path, &dir, &uni_name);
2007         if (ret)
2008                 goto out;
2009
2010         fs_set_vol_flags(sb, VOL_DIRTY);
2011
2012         ret = create_dir(inode, &dir, &uni_name, fid);
2013
2014 #ifdef CONFIG_EXFAT_DELAYED_SYNC
2015         fs_sync(sb, false);
2016         fs_set_vol_flags(sb, VOL_CLEAN);
2017 #endif
2018
2019         if (p_fs->dev_ejected)
2020                 ret = FFS_MEDIAERR;
2021 out:
2022         /* release the lock for file system critical section */
2023         up(&p_fs->v_sem);
2024
2025         return ret;
2026 }
2027
2028 static int ffsReadDir(struct inode *inode, struct dir_entry_t *dir_entry)
2029 {
2030         int i, dentry, clu_offset;
2031         int ret = FFS_SUCCESS;
2032         s32 dentries_per_clu, dentries_per_clu_bits = 0;
2033         u32 type;
2034         sector_t sector;
2035         struct chain_t dir, clu;
2036         struct uni_name_t uni_name;
2037         struct timestamp_t tm;
2038         struct dentry_t *ep;
2039         struct super_block *sb = inode->i_sb;
2040         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2041         struct fs_func *fs_func = p_fs->fs_func;
2042         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
2043
2044         /* check the validity of pointer parameters */
2045         if (!dir_entry)
2046                 return FFS_ERROR;
2047
2048         /* check if the given file ID is opened */
2049         if (fid->type != TYPE_DIR)
2050                 return FFS_PERMISSIONERR;
2051
2052         /* acquire the lock for file system critical section */
2053         down(&p_fs->v_sem);
2054
2055         if (fid->entry == -1) {
2056                 dir.dir = p_fs->root_dir;
2057                 dir.flags = 0x01;
2058         } else {
2059                 dir.dir = fid->start_clu;
2060                 dir.size = (s32)(fid->size >> p_fs->cluster_size_bits);
2061                 dir.flags = fid->flags;
2062         }
2063
2064         dentry = (s32)fid->rwoffset;
2065
2066         if (dir.dir == CLUSTER_32(0)) {
2067                 /* FAT16 root_dir */
2068                 dentries_per_clu = p_fs->dentries_in_root;
2069
2070                 if (dentry == dentries_per_clu) {
2071                         clu.dir = CLUSTER_32(~0);
2072                 } else {
2073                         clu.dir = dir.dir;
2074                         clu.size = dir.size;
2075                         clu.flags = dir.flags;
2076                 }
2077         } else {
2078                 dentries_per_clu = p_fs->dentries_per_clu;
2079                 dentries_per_clu_bits = ilog2(dentries_per_clu);
2080
2081                 clu_offset = dentry >> dentries_per_clu_bits;
2082                 clu.dir = dir.dir;
2083                 clu.size = dir.size;
2084                 clu.flags = dir.flags;
2085
2086                 if (clu.flags == 0x03) {
2087                         clu.dir += clu_offset;
2088                         clu.size -= clu_offset;
2089                 } else {
2090                         /* hint_information */
2091                         if ((clu_offset > 0) && (fid->hint_last_off > 0) &&
2092                             (clu_offset >= fid->hint_last_off)) {
2093                                 clu_offset -= fid->hint_last_off;
2094                                 clu.dir = fid->hint_last_clu;
2095                         }
2096
2097                         while (clu_offset > 0) {
2098                                 /* clu.dir = FAT_read(sb, clu.dir); */
2099                                 if (FAT_read(sb, clu.dir, &clu.dir) == -1) {
2100                                         ret = FFS_MEDIAERR;
2101                                         goto out;
2102                                 }
2103                                 clu_offset--;
2104                         }
2105                 }
2106         }
2107
2108         while (clu.dir != CLUSTER_32(~0)) {
2109                 if (p_fs->dev_ejected)
2110                         break;
2111
2112                 if (dir.dir == CLUSTER_32(0)) /* FAT16 root_dir */
2113                         i = dentry % dentries_per_clu;
2114                 else
2115                         i = dentry & (dentries_per_clu-1);
2116
2117                 for ( ; i < dentries_per_clu; i++, dentry++) {
2118                         ep = get_entry_in_dir(sb, &clu, i, &sector);
2119                         if (!ep) {
2120                                 ret = FFS_MEDIAERR;
2121                                 goto out;
2122                         }
2123                         type = fs_func->get_entry_type(ep);
2124
2125                         if (type == TYPE_UNUSED)
2126                                 break;
2127
2128                         if ((type != TYPE_FILE) && (type != TYPE_DIR))
2129                                 continue;
2130
2131                         buf_lock(sb, sector);
2132                         dir_entry->Attr = fs_func->get_entry_attr(ep);
2133
2134                         fs_func->get_entry_time(ep, &tm, TM_CREATE);
2135                         dir_entry->CreateTimestamp.Year = tm.year;
2136                         dir_entry->CreateTimestamp.Month = tm.mon;
2137                         dir_entry->CreateTimestamp.Day = tm.day;
2138                         dir_entry->CreateTimestamp.Hour = tm.hour;
2139                         dir_entry->CreateTimestamp.Minute = tm.min;
2140                         dir_entry->CreateTimestamp.Second = tm.sec;
2141                         dir_entry->CreateTimestamp.MilliSecond = 0;
2142
2143                         fs_func->get_entry_time(ep, &tm, TM_MODIFY);
2144                         dir_entry->ModifyTimestamp.Year = tm.year;
2145                         dir_entry->ModifyTimestamp.Month = tm.mon;
2146                         dir_entry->ModifyTimestamp.Day = tm.day;
2147                         dir_entry->ModifyTimestamp.Hour = tm.hour;
2148                         dir_entry->ModifyTimestamp.Minute = tm.min;
2149                         dir_entry->ModifyTimestamp.Second = tm.sec;
2150                         dir_entry->ModifyTimestamp.MilliSecond = 0;
2151
2152                         memset((char *)&dir_entry->AccessTimestamp, 0,
2153                                sizeof(struct date_time_t));
2154
2155                         *(uni_name.name) = 0x0;
2156                         fs_func->get_uni_name_from_ext_entry(sb, &dir, dentry,
2157                                                              uni_name.name);
2158                         if (*uni_name.name == 0x0 && p_fs->vol_type != EXFAT)
2159                                 get_uni_name_from_dos_entry(sb,
2160                                                 (struct dos_dentry_t *)ep,
2161                                                 &uni_name, 0x1);
2162                         nls_uniname_to_cstring(sb, dir_entry->Name, &uni_name);
2163                         buf_unlock(sb, sector);
2164
2165                         if (p_fs->vol_type == EXFAT) {
2166                                 ep = get_entry_in_dir(sb, &clu, i+1, NULL);
2167                                 if (!ep) {
2168                                         ret = FFS_MEDIAERR;
2169                                         goto out;
2170                                 }
2171                         } else {
2172                                 get_uni_name_from_dos_entry(sb,
2173                                                 (struct dos_dentry_t *)ep,
2174                                                 &uni_name, 0x0);
2175                                 nls_uniname_to_cstring(sb, dir_entry->ShortName,
2176                                                        &uni_name);
2177                         }
2178
2179                         dir_entry->Size = fs_func->get_entry_size(ep);
2180
2181                         /* hint information */
2182                         if (dir.dir == CLUSTER_32(0)) { /* FAT16 root_dir */
2183                         } else {
2184                                 fid->hint_last_off = dentry >>
2185                                                         dentries_per_clu_bits;
2186                                 fid->hint_last_clu = clu.dir;
2187                         }
2188
2189                         fid->rwoffset = (s64) ++dentry;
2190
2191                         if (p_fs->dev_ejected)
2192                                 ret = FFS_MEDIAERR;
2193                         goto out;
2194                 }
2195
2196                 if (dir.dir == CLUSTER_32(0))
2197                         break; /* FAT16 root_dir */
2198
2199                 if (clu.flags == 0x03) {
2200                         if ((--clu.size) > 0)
2201                                 clu.dir++;
2202                         else
2203                                 clu.dir = CLUSTER_32(~0);
2204                 } else {
2205                         /* clu.dir = FAT_read(sb, clu.dir); */
2206                         if (FAT_read(sb, clu.dir, &clu.dir) == -1) {
2207                                 ret = FFS_MEDIAERR;
2208                                 goto out;
2209                         }
2210                 }
2211         }
2212
2213         *(dir_entry->Name) = '\0';
2214
2215         fid->rwoffset = (s64) ++dentry;
2216
2217         if (p_fs->dev_ejected)
2218                 ret = FFS_MEDIAERR;
2219
2220 out:
2221         /* release the lock for file system critical section */
2222         up(&p_fs->v_sem);
2223
2224         return ret;
2225 }
2226
2227 static int ffsRemoveDir(struct inode *inode, struct file_id_t *fid)
2228 {
2229         s32 dentry;
2230         int ret = FFS_SUCCESS;
2231         struct chain_t dir, clu_to_free;
2232         struct super_block *sb = inode->i_sb;
2233         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
2234
2235         /* check the validity of the given file id */
2236         if (!fid)
2237                 return FFS_INVALIDFID;
2238
2239         dir.dir = fid->dir.dir;
2240         dir.size = fid->dir.size;
2241         dir.flags = fid->dir.flags;
2242
2243         dentry = fid->entry;
2244
2245         /* check if the file is "." or ".." */
2246         if (p_fs->vol_type != EXFAT) {
2247                 if ((dir.dir != p_fs->root_dir) && (dentry < 2))
2248                         return FFS_PERMISSIONERR;
2249         }
2250
2251         /* acquire the lock for file system critical section */
2252         down(&p_fs->v_sem);
2253
2254         clu_to_free.dir = fid->start_clu;
2255         clu_to_free.size = (s32)((fid->size-1) >> p_fs->cluster_size_bits) + 1;
2256         clu_to_free.flags = fid->flags;
2257
2258         if (!is_dir_empty(sb, &clu_to_free)) {
2259                 ret = FFS_FILEEXIST;
2260                 goto out;
2261         }
2262
2263         fs_set_vol_flags(sb, VOL_DIRTY);
2264
2265         /* (1) update the directory entry */
2266         remove_file(inode, &dir, dentry);
2267
2268         /* (2) free the clusters */
2269         p_fs->fs_func->free_cluster(sb, &clu_to_free, 1);
2270
2271         fid->size = 0;
2272         fid->start_clu = CLUSTER_32(~0);
2273         fid->flags = (p_fs->vol_type == EXFAT) ? 0x03 : 0x01;
2274
2275 #ifdef CONFIG_EXFAT_DELAYED_SYNC
2276         fs_sync(sb, false);
2277         fs_set_vol_flags(sb, VOL_CLEAN);
2278 #endif
2279
2280         if (p_fs->dev_ejected)
2281                 ret = FFS_MEDIAERR;
2282
2283 out:
2284         /* release the lock for file system critical section */
2285         up(&p_fs->v_sem);
2286
2287         return ret;
2288 }
2289
2290 /*======================================================================*/
2291 /*  Directory Entry Operations                                          */
2292 /*======================================================================*/
2293
2294 static int exfat_readdir(struct file *filp, struct dir_context *ctx)
2295 {
2296         struct inode *inode = file_inode(filp);
2297         struct super_block *sb = inode->i_sb;
2298         struct exfat_sb_info *sbi = EXFAT_SB(sb);
2299         struct fs_info_t *p_fs = &(sbi->fs_info);
2300         struct bd_info_t *p_bd = &(EXFAT_SB(sb)->bd_info);
2301         struct dir_entry_t de;
2302         unsigned long inum;
2303         loff_t cpos;
2304         int err = 0;
2305
2306         __lock_super(sb);
2307
2308         cpos = ctx->pos;
2309         /* Fake . and .. for the root directory. */
2310         if ((p_fs->vol_type == EXFAT) || (inode->i_ino == EXFAT_ROOT_INO)) {
2311                 while (cpos < 2) {
2312                         if (inode->i_ino == EXFAT_ROOT_INO)
2313                                 inum = EXFAT_ROOT_INO;
2314                         else if (cpos == 0)
2315                                 inum = inode->i_ino;
2316                         else /* (cpos == 1) */
2317                                 inum = parent_ino(filp->f_path.dentry);
2318
2319                         if (!dir_emit_dots(filp, ctx))
2320                                 goto out;
2321                         cpos++;
2322                         ctx->pos++;
2323                 }
2324                 if (cpos == 2)
2325                         cpos = 0;
2326         }
2327         if (cpos & (DENTRY_SIZE - 1)) {
2328                 err = -ENOENT;
2329                 goto out;
2330         }
2331
2332 get_new:
2333         EXFAT_I(inode)->fid.size = i_size_read(inode);
2334         EXFAT_I(inode)->fid.rwoffset = cpos >> DENTRY_SIZE_BITS;
2335
2336         err = ffsReadDir(inode, &de);
2337         if (err) {
2338                 /* at least we tried to read a sector
2339                  * move cpos to next sector position (should be aligned)
2340                  */
2341                 if (err == FFS_MEDIAERR) {
2342                         cpos += 1 << p_bd->sector_size_bits;
2343                         cpos &= ~((1 << p_bd->sector_size_bits)-1);
2344                 }
2345
2346                 err = -EIO;
2347                 goto end_of_dir;
2348         }
2349
2350         cpos = EXFAT_I(inode)->fid.rwoffset << DENTRY_SIZE_BITS;
2351
2352         if (!de.Name[0])
2353                 goto end_of_dir;
2354
2355         if (!memcmp(de.ShortName, DOS_CUR_DIR_NAME, DOS_NAME_LENGTH)) {
2356                 inum = inode->i_ino;
2357         } else if (!memcmp(de.ShortName, DOS_PAR_DIR_NAME, DOS_NAME_LENGTH)) {
2358                 inum = parent_ino(filp->f_path.dentry);
2359         } else {
2360                 loff_t i_pos = ((loff_t) EXFAT_I(inode)->fid.start_clu << 32) |
2361                                 ((EXFAT_I(inode)->fid.rwoffset-1) & 0xffffffff);
2362                 struct inode *tmp = exfat_iget(sb, i_pos);
2363
2364                 if (tmp) {
2365                         inum = tmp->i_ino;
2366                         iput(tmp);
2367                 } else {
2368                         inum = iunique(sb, EXFAT_ROOT_INO);
2369                 }
2370         }
2371
2372         if (!dir_emit(ctx, de.Name, strlen(de.Name), inum,
2373                       (de.Attr & ATTR_SUBDIR) ? DT_DIR : DT_REG))
2374                 goto out;
2375
2376         ctx->pos = cpos;
2377         goto get_new;
2378
2379 end_of_dir:
2380         ctx->pos = cpos;
2381 out:
2382         __unlock_super(sb);
2383         return err;
2384 }
2385
2386 static int exfat_ioctl_volume_id(struct inode *dir)
2387 {
2388         struct super_block *sb = dir->i_sb;
2389         struct exfat_sb_info *sbi = EXFAT_SB(sb);
2390         struct fs_info_t *p_fs = &(sbi->fs_info);
2391
2392         return p_fs->vol_id;
2393 }
2394
2395 static long exfat_generic_ioctl(struct file *filp, unsigned int cmd,
2396                                 unsigned long arg)
2397 {
2398 struct inode *inode = filp->f_path.dentry->d_inode;
2399 #ifdef CONFIG_EXFAT_KERNEL_DEBUG
2400         unsigned int flags;
2401 #endif /* CONFIG_EXFAT_KERNEL_DEBUG */
2402
2403         switch (cmd) {
2404         case EXFAT_IOCTL_GET_VOLUME_ID:
2405                 return exfat_ioctl_volume_id(inode);
2406 #ifdef CONFIG_EXFAT_KERNEL_DEBUG
2407         case EXFAT_IOC_GET_DEBUGFLAGS: {
2408                 struct super_block *sb = inode->i_sb;
2409                 struct exfat_sb_info *sbi = EXFAT_SB(sb);
2410
2411                 flags = sbi->debug_flags;
2412                 return put_user(flags, (int __user *)arg);
2413         }
2414         case EXFAT_IOC_SET_DEBUGFLAGS: {
2415                 struct super_block *sb = inode->i_sb;
2416                 struct exfat_sb_info *sbi = EXFAT_SB(sb);
2417
2418                 if (!capable(CAP_SYS_ADMIN))
2419                         return -EPERM;
2420
2421                 if (get_user(flags, (int __user *) arg))
2422                         return -EFAULT;
2423
2424                 __lock_super(sb);
2425                 sbi->debug_flags = flags;
2426                 __unlock_super(sb);
2427
2428                 return 0;
2429         }
2430 #endif /* CONFIG_EXFAT_KERNEL_DEBUG */
2431         default:
2432                 return -ENOTTY; /* Inappropriate ioctl for device */
2433         }
2434 }
2435
2436 static const struct file_operations exfat_dir_operations = {
2437         .llseek     = generic_file_llseek,
2438         .read       = generic_read_dir,
2439         .iterate    = exfat_readdir,
2440         .unlocked_ioctl = exfat_generic_ioctl,
2441         .fsync      = generic_file_fsync,
2442 };
2443
2444 static int exfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
2445                         bool excl)
2446 {
2447         struct super_block *sb = dir->i_sb;
2448         struct inode *inode;
2449         struct file_id_t fid;
2450         loff_t i_pos;
2451         int err;
2452
2453         __lock_super(sb);
2454
2455         pr_debug("%s entered\n", __func__);
2456
2457         err = ffsCreateFile(dir, (u8 *) dentry->d_name.name, FM_REGULAR, &fid);
2458         if (err) {
2459                 if (err == FFS_INVALIDPATH)
2460                         err = -EINVAL;
2461                 else if (err == FFS_FILEEXIST)
2462                         err = -EEXIST;
2463                 else if (err == FFS_FULL)
2464                         err = -ENOSPC;
2465                 else if (err == FFS_NAMETOOLONG)
2466                         err = -ENAMETOOLONG;
2467                 else
2468                         err = -EIO;
2469                 goto out;
2470         }
2471         INC_IVERSION(dir);
2472         dir->i_ctime = dir->i_mtime = dir->i_atime = current_time(dir);
2473         if (IS_DIRSYNC(dir))
2474                 (void) exfat_sync_inode(dir);
2475         else
2476                 mark_inode_dirty(dir);
2477
2478         i_pos = ((loff_t) fid.dir.dir << 32) | (fid.entry & 0xffffffff);
2479
2480         inode = exfat_build_inode(sb, &fid, i_pos);
2481         if (IS_ERR(inode)) {
2482                 err = PTR_ERR(inode);
2483                 goto out;
2484         }
2485         INC_IVERSION(inode);
2486         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
2487         /*
2488          * timestamp is already written, so mark_inode_dirty() is unnecessary.
2489          */
2490
2491         dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
2492         d_instantiate(dentry, inode);
2493
2494 out:
2495         __unlock_super(sb);
2496         pr_debug("%s exited\n", __func__);
2497         return err;
2498 }
2499
2500 static int exfat_find(struct inode *dir, struct qstr *qname,
2501                       struct file_id_t *fid)
2502 {
2503         int err;
2504
2505         if (qname->len == 0)
2506                 return -ENOENT;
2507
2508         err = ffsLookupFile(dir, (u8 *) qname->name, fid);
2509         if (err)
2510                 return -ENOENT;
2511
2512         return 0;
2513 }
2514
2515 static int exfat_d_anon_disconn(struct dentry *dentry)
2516 {
2517         return IS_ROOT(dentry) && (dentry->d_flags & DCACHE_DISCONNECTED);
2518 }
2519
2520 static struct dentry *exfat_lookup(struct inode *dir, struct dentry *dentry,
2521                                    unsigned int flags)
2522 {
2523         struct super_block *sb = dir->i_sb;
2524         struct inode *inode;
2525         struct dentry *alias;
2526         int err;
2527         struct file_id_t fid;
2528         loff_t i_pos;
2529         u64 ret;
2530         mode_t i_mode;
2531
2532         __lock_super(sb);
2533         pr_debug("%s entered\n", __func__);
2534         err = exfat_find(dir, &dentry->d_name, &fid);
2535         if (err) {
2536                 if (err == -ENOENT) {
2537                         inode = NULL;
2538                         goto out;
2539                 }
2540                 goto error;
2541         }
2542
2543         i_pos = ((loff_t) fid.dir.dir << 32) | (fid.entry & 0xffffffff);
2544         inode = exfat_build_inode(sb, &fid, i_pos);
2545         if (IS_ERR(inode)) {
2546                 err = PTR_ERR(inode);
2547                 goto error;
2548         }
2549
2550         i_mode = inode->i_mode;
2551         if (S_ISLNK(i_mode) && !EXFAT_I(inode)->target) {
2552                 EXFAT_I(inode)->target = kmalloc(i_size_read(inode) + 1,
2553                                                  GFP_KERNEL);
2554                 if (!EXFAT_I(inode)->target) {
2555                         err = -ENOMEM;
2556                         goto error;
2557                 }
2558                 ffsReadFile(dir, &fid, EXFAT_I(inode)->target,
2559                             i_size_read(inode), &ret);
2560                 *(EXFAT_I(inode)->target + i_size_read(inode)) = '\0';
2561         }
2562
2563         alias = d_find_alias(inode);
2564         if (alias && !exfat_d_anon_disconn(alias)) {
2565                 BUG_ON(d_unhashed(alias));
2566                 if (!S_ISDIR(i_mode))
2567                         d_move(alias, dentry);
2568                 iput(inode);
2569                 __unlock_super(sb);
2570                 pr_debug("%s exited 1\n", __func__);
2571                 return alias;
2572         }
2573         dput(alias);
2574 out:
2575         __unlock_super(sb);
2576         dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
2577         dentry = d_splice_alias(inode, dentry);
2578         if (dentry)
2579                 dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
2580         pr_debug("%s exited 2\n", __func__);
2581         return dentry;
2582
2583 error:
2584         __unlock_super(sb);
2585         pr_debug("%s exited 3\n", __func__);
2586         return ERR_PTR(err);
2587 }
2588
2589 static inline unsigned long exfat_hash(loff_t i_pos)
2590 {
2591         return hash_32(i_pos, EXFAT_HASH_BITS);
2592 }
2593
2594 static void exfat_attach(struct inode *inode, loff_t i_pos)
2595 {
2596         struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
2597         struct hlist_head *head = sbi->inode_hashtable + exfat_hash(i_pos);
2598
2599         spin_lock(&sbi->inode_hash_lock);
2600         EXFAT_I(inode)->i_pos = i_pos;
2601         hlist_add_head(&EXFAT_I(inode)->i_hash_fat, head);
2602         spin_unlock(&sbi->inode_hash_lock);
2603 }
2604
2605 static void exfat_detach(struct inode *inode)
2606 {
2607         struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
2608
2609         spin_lock(&sbi->inode_hash_lock);
2610         hlist_del_init(&EXFAT_I(inode)->i_hash_fat);
2611         EXFAT_I(inode)->i_pos = 0;
2612         spin_unlock(&sbi->inode_hash_lock);
2613 }
2614
2615 static int exfat_unlink(struct inode *dir, struct dentry *dentry)
2616 {
2617         struct inode *inode = dentry->d_inode;
2618         struct super_block *sb = dir->i_sb;
2619         int err;
2620
2621         __lock_super(sb);
2622
2623         pr_debug("%s entered\n", __func__);
2624
2625         EXFAT_I(inode)->fid.size = i_size_read(inode);
2626
2627         err = ffsRemoveFile(dir, &(EXFAT_I(inode)->fid));
2628         if (err) {
2629                 if (err == FFS_PERMISSIONERR)
2630                         err = -EPERM;
2631                 else
2632                         err = -EIO;
2633                 goto out;
2634         }
2635         INC_IVERSION(dir);
2636         dir->i_mtime = dir->i_atime = current_time(dir);
2637         if (IS_DIRSYNC(dir))
2638                 (void) exfat_sync_inode(dir);
2639         else
2640                 mark_inode_dirty(dir);
2641
2642         clear_nlink(inode);
2643         inode->i_mtime = inode->i_atime = current_time(inode);
2644         exfat_detach(inode);
2645         remove_inode_hash(inode);
2646
2647 out:
2648         __unlock_super(sb);
2649         pr_debug("%s exited\n", __func__);
2650         return err;
2651 }
2652
2653 static int exfat_symlink(struct inode *dir, struct dentry *dentry,
2654                          const char *target)
2655 {
2656         struct super_block *sb = dir->i_sb;
2657         struct inode *inode;
2658         struct file_id_t fid;
2659         loff_t i_pos;
2660         int err;
2661         u64 len = (u64) strlen(target);
2662         u64 ret;
2663
2664         __lock_super(sb);
2665
2666         pr_debug("%s entered\n", __func__);
2667
2668         err = ffsCreateFile(dir, (u8 *) dentry->d_name.name, FM_SYMLINK, &fid);
2669         if (err) {
2670                 if (err == FFS_INVALIDPATH)
2671                         err = -EINVAL;
2672                 else if (err == FFS_FILEEXIST)
2673                         err = -EEXIST;
2674                 else if (err == FFS_FULL)
2675                         err = -ENOSPC;
2676                 else
2677                         err = -EIO;
2678                 goto out;
2679         }
2680
2681         err = ffsWriteFile(dir, &fid, (char *) target, len, &ret);
2682
2683         if (err) {
2684                 ffsRemoveFile(dir, &fid);
2685
2686                 if (err == FFS_FULL)
2687                         err = -ENOSPC;
2688                 else
2689                         err = -EIO;
2690                 goto out;
2691         }
2692
2693         INC_IVERSION(dir);
2694         dir->i_ctime = dir->i_mtime = dir->i_atime = current_time(dir);
2695         if (IS_DIRSYNC(dir))
2696                 (void) exfat_sync_inode(dir);
2697         else
2698                 mark_inode_dirty(dir);
2699
2700         i_pos = ((loff_t) fid.dir.dir << 32) | (fid.entry & 0xffffffff);
2701
2702         inode = exfat_build_inode(sb, &fid, i_pos);
2703         if (IS_ERR(inode)) {
2704                 err = PTR_ERR(inode);
2705                 goto out;
2706         }
2707         INC_IVERSION(inode);
2708         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
2709         /* timestamp is already written, so mark_inode_dirty() is unneeded. */
2710
2711         EXFAT_I(inode)->target = kmalloc(len+1, GFP_KERNEL);
2712         if (!EXFAT_I(inode)->target) {
2713                 err = -ENOMEM;
2714                 goto out;
2715         }
2716         memcpy(EXFAT_I(inode)->target, target, len+1);
2717
2718         dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
2719         d_instantiate(dentry, inode);
2720
2721 out:
2722         __unlock_super(sb);
2723         pr_debug("%s exited\n", __func__);
2724         return err;
2725 }
2726
2727 static int exfat_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
2728 {
2729         struct super_block *sb = dir->i_sb;
2730         struct inode *inode;
2731         struct file_id_t fid;
2732         loff_t i_pos;
2733         int err;
2734
2735         __lock_super(sb);
2736
2737         pr_debug("%s entered\n", __func__);
2738
2739         err = ffsCreateDir(dir, (u8 *) dentry->d_name.name, &fid);
2740         if (err) {
2741                 if (err == FFS_INVALIDPATH)
2742                         err = -EINVAL;
2743                 else if (err == FFS_FILEEXIST)
2744                         err = -EEXIST;
2745                 else if (err == FFS_FULL)
2746                         err = -ENOSPC;
2747                 else if (err == FFS_NAMETOOLONG)
2748                         err = -ENAMETOOLONG;
2749                 else
2750                         err = -EIO;
2751                 goto out;
2752         }
2753         INC_IVERSION(dir);
2754         dir->i_ctime = dir->i_mtime = dir->i_atime = current_time(dir);
2755         if (IS_DIRSYNC(dir))
2756                 (void) exfat_sync_inode(dir);
2757         else
2758                 mark_inode_dirty(dir);
2759         inc_nlink(dir);
2760
2761         i_pos = ((loff_t) fid.dir.dir << 32) | (fid.entry & 0xffffffff);
2762
2763         inode = exfat_build_inode(sb, &fid, i_pos);
2764         if (IS_ERR(inode)) {
2765                 err = PTR_ERR(inode);
2766                 goto out;
2767         }
2768         INC_IVERSION(inode);
2769         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
2770         /* timestamp is already written, so mark_inode_dirty() is unneeded. */
2771
2772         dentry->d_time = GET_IVERSION(dentry->d_parent->d_inode);
2773         d_instantiate(dentry, inode);
2774
2775 out:
2776         __unlock_super(sb);
2777         pr_debug("%s exited\n", __func__);
2778         return err;
2779 }
2780
2781 static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
2782 {
2783         struct inode *inode = dentry->d_inode;
2784         struct super_block *sb = dir->i_sb;
2785         int err;
2786
2787         __lock_super(sb);
2788
2789         pr_debug("%s entered\n", __func__);
2790
2791         EXFAT_I(inode)->fid.size = i_size_read(inode);
2792
2793         err = ffsRemoveDir(dir, &(EXFAT_I(inode)->fid));
2794         if (err) {
2795                 if (err == FFS_INVALIDPATH)
2796                         err = -EINVAL;
2797                 else if (err == FFS_FILEEXIST)
2798                         err = -ENOTEMPTY;
2799                 else if (err == FFS_NOTFOUND)
2800                         err = -ENOENT;
2801                 else if (err == FFS_DIRBUSY)
2802                         err = -EBUSY;
2803                 else
2804                         err = -EIO;
2805                 goto out;
2806         }
2807         INC_IVERSION(dir);
2808         dir->i_mtime = dir->i_atime = current_time(dir);
2809         if (IS_DIRSYNC(dir))
2810                 (void) exfat_sync_inode(dir);
2811         else
2812                 mark_inode_dirty(dir);
2813         drop_nlink(dir);
2814
2815         clear_nlink(inode);
2816         inode->i_mtime = inode->i_atime = current_time(inode);
2817         exfat_detach(inode);
2818         remove_inode_hash(inode);
2819
2820 out:
2821         __unlock_super(sb);
2822         pr_debug("%s exited\n", __func__);
2823         return err;
2824 }
2825
2826 static int exfat_rename(struct inode *old_dir, struct dentry *old_dentry,
2827                         struct inode *new_dir, struct dentry *new_dentry,
2828                         unsigned int flags)
2829 {
2830         struct inode *old_inode, *new_inode;
2831         struct super_block *sb = old_dir->i_sb;
2832         loff_t i_pos;
2833         int err;
2834
2835         if (flags)
2836                 return -EINVAL;
2837
2838         __lock_super(sb);
2839
2840         pr_debug("%s entered\n", __func__);
2841
2842         old_inode = old_dentry->d_inode;
2843         new_inode = new_dentry->d_inode;
2844
2845         EXFAT_I(old_inode)->fid.size = i_size_read(old_inode);
2846
2847         err = ffsMoveFile(old_dir, &(EXFAT_I(old_inode)->fid), new_dir,
2848                           new_dentry);
2849         if (err) {
2850                 if (err == FFS_PERMISSIONERR)
2851                         err = -EPERM;
2852                 else if (err == FFS_INVALIDPATH)
2853                         err = -EINVAL;
2854                 else if (err == FFS_FILEEXIST)
2855                         err = -EEXIST;
2856                 else if (err == FFS_NOTFOUND)
2857                         err = -ENOENT;
2858                 else if (err == FFS_FULL)
2859                         err = -ENOSPC;
2860                 else
2861                         err = -EIO;
2862                 goto out;
2863         }
2864         INC_IVERSION(new_dir);
2865         new_dir->i_ctime = new_dir->i_mtime = new_dir->i_atime =
2866                                 current_time(new_dir);
2867         if (IS_DIRSYNC(new_dir))
2868                 (void) exfat_sync_inode(new_dir);
2869         else
2870                 mark_inode_dirty(new_dir);
2871
2872         i_pos = ((loff_t) EXFAT_I(old_inode)->fid.dir.dir << 32) |
2873                         (EXFAT_I(old_inode)->fid.entry & 0xffffffff);
2874
2875         exfat_detach(old_inode);
2876         exfat_attach(old_inode, i_pos);
2877         if (IS_DIRSYNC(new_dir))
2878                 (void) exfat_sync_inode(old_inode);
2879         else
2880                 mark_inode_dirty(old_inode);
2881
2882         if ((S_ISDIR(old_inode->i_mode)) && (old_dir != new_dir)) {
2883                 drop_nlink(old_dir);
2884                 if (!new_inode)
2885                         inc_nlink(new_dir);
2886         }
2887         INC_IVERSION(old_dir);
2888         old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
2889         if (IS_DIRSYNC(old_dir))
2890                 (void) exfat_sync_inode(old_dir);
2891         else
2892                 mark_inode_dirty(old_dir);
2893
2894         if (new_inode) {
2895                 exfat_detach(new_inode);
2896                 drop_nlink(new_inode);
2897                 if (S_ISDIR(new_inode->i_mode))
2898                         drop_nlink(new_inode);
2899                 new_inode->i_ctime = current_time(new_inode);
2900         }
2901
2902 out:
2903         __unlock_super(sb);
2904         pr_debug("%s exited\n", __func__);
2905         return err;
2906 }
2907
2908 static int exfat_cont_expand(struct inode *inode, loff_t size)
2909 {
2910         struct address_space *mapping = inode->i_mapping;
2911         loff_t start = i_size_read(inode), count = size - i_size_read(inode);
2912         int err, err2;
2913
2914         err = generic_cont_expand_simple(inode, size);
2915         if (err != 0)
2916                 return err;
2917
2918         inode->i_ctime = inode->i_mtime = current_time(inode);
2919         mark_inode_dirty(inode);
2920
2921         if (IS_SYNC(inode)) {
2922                 err = filemap_fdatawrite_range(mapping, start,
2923                                                start + count - 1);
2924                 err2 = sync_mapping_buffers(mapping);
2925                 err = (err) ? (err) : (err2);
2926                 err2 = write_inode_now(inode, 1);
2927                 err = (err) ? (err) : (err2);
2928                 if (!err)
2929                         err =  filemap_fdatawait_range(mapping, start,
2930                                                        start + count - 1);
2931         }
2932         return err;
2933 }
2934
2935 static int exfat_allow_set_time(struct exfat_sb_info *sbi, struct inode *inode)
2936 {
2937         mode_t allow_utime = sbi->options.allow_utime;
2938
2939         if (!uid_eq(current_fsuid(), inode->i_uid)) {
2940                 if (in_group_p(inode->i_gid))
2941                         allow_utime >>= 3;
2942                 if (allow_utime & MAY_WRITE)
2943                         return 1;
2944         }
2945
2946         /* use a default check */
2947         return 0;
2948 }
2949
2950 static int exfat_sanitize_mode(const struct exfat_sb_info *sbi,
2951                                struct inode *inode, umode_t *mode_ptr)
2952 {
2953         mode_t i_mode, mask, perm;
2954
2955         i_mode = inode->i_mode;
2956
2957         if (S_ISREG(i_mode) || S_ISLNK(i_mode))
2958                 mask = sbi->options.fs_fmask;
2959         else
2960                 mask = sbi->options.fs_dmask;
2961
2962         perm = *mode_ptr & ~(S_IFMT | mask);
2963
2964         /* Of the r and x bits, all (subject to umask) must be present.*/
2965         if ((perm & 0555) != (i_mode & 0555))
2966                 return -EPERM;
2967
2968         if (exfat_mode_can_hold_ro(inode)) {
2969                 /*
2970                  * Of the w bits, either all (subject to umask) or none must be
2971                  * present.
2972                  */
2973                 if ((perm & 0222) && ((perm & 0222) != (0222 & ~mask)))
2974                         return -EPERM;
2975         } else {
2976                 /*
2977                  * If exfat_mode_can_hold_ro(inode) is false, can't change w
2978                  * bits.
2979                  */
2980                 if ((perm & 0222) != (0222 & ~mask))
2981                         return -EPERM;
2982         }
2983
2984         *mode_ptr &= S_IFMT | perm;
2985
2986         return 0;
2987 }
2988
2989 static void exfat_truncate(struct inode *inode, loff_t old_size)
2990 {
2991         struct super_block *sb = inode->i_sb;
2992         struct exfat_sb_info *sbi = EXFAT_SB(sb);
2993         struct fs_info_t *p_fs = &(sbi->fs_info);
2994         int err;
2995
2996         __lock_super(sb);
2997
2998         /*
2999          * This protects against truncating a file bigger than it was then
3000          * trying to write into the hole.
3001          */
3002         if (EXFAT_I(inode)->mmu_private > i_size_read(inode))
3003                 EXFAT_I(inode)->mmu_private = i_size_read(inode);
3004
3005         if (EXFAT_I(inode)->fid.start_clu == 0)
3006                 goto out;
3007
3008         err = ffsTruncateFile(inode, old_size, i_size_read(inode));
3009         if (err)
3010                 goto out;
3011
3012         inode->i_ctime = inode->i_mtime = current_time(inode);
3013         if (IS_DIRSYNC(inode))
3014                 (void) exfat_sync_inode(inode);
3015         else
3016                 mark_inode_dirty(inode);
3017
3018         inode->i_blocks = ((i_size_read(inode) + (p_fs->cluster_size - 1)) &
3019                            ~((loff_t)p_fs->cluster_size - 1)) >> 9;
3020 out:
3021         __unlock_super(sb);
3022 }
3023
3024 static int exfat_setattr(struct dentry *dentry, struct iattr *attr)
3025 {
3026         struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb);
3027         struct inode *inode = dentry->d_inode;
3028         unsigned int ia_valid;
3029         int error;
3030         loff_t old_size;
3031
3032         pr_debug("%s entered\n", __func__);
3033
3034         if ((attr->ia_valid & ATTR_SIZE)
3035                 && (attr->ia_size > i_size_read(inode))) {
3036                 error = exfat_cont_expand(inode, attr->ia_size);
3037                 if (error || attr->ia_valid == ATTR_SIZE)
3038                         return error;
3039                 attr->ia_valid &= ~ATTR_SIZE;
3040         }
3041
3042         ia_valid = attr->ia_valid;
3043
3044         if ((ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET))
3045                 && exfat_allow_set_time(sbi, inode)) {
3046                 attr->ia_valid &= ~(ATTR_MTIME_SET |
3047                                     ATTR_ATIME_SET |
3048                                     ATTR_TIMES_SET);
3049         }
3050
3051         error = setattr_prepare(dentry, attr);
3052         attr->ia_valid = ia_valid;
3053         if (error)
3054                 return error;
3055
3056         if (((attr->ia_valid & ATTR_UID) &&
3057              (!uid_eq(attr->ia_uid, sbi->options.fs_uid))) ||
3058             ((attr->ia_valid & ATTR_GID) &&
3059              (!gid_eq(attr->ia_gid, sbi->options.fs_gid))) ||
3060             ((attr->ia_valid & ATTR_MODE) &&
3061              (attr->ia_mode & ~(S_IFREG | S_IFLNK | S_IFDIR | 0777)))) {
3062                 return -EPERM;
3063         }
3064
3065         /*
3066          * We don't return -EPERM here. Yes, strange, but this is too
3067          * old behavior.
3068          */
3069         if (attr->ia_valid & ATTR_MODE) {
3070                 if (exfat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
3071                         attr->ia_valid &= ~ATTR_MODE;
3072         }
3073
3074         EXFAT_I(inode)->fid.size = i_size_read(inode);
3075
3076         if (attr->ia_valid & ATTR_SIZE) {
3077                 old_size = i_size_read(inode);
3078                 down_write(&EXFAT_I(inode)->truncate_lock);
3079                 truncate_setsize(inode, attr->ia_size);
3080                 exfat_truncate(inode, old_size);
3081                 up_write(&EXFAT_I(inode)->truncate_lock);
3082         }
3083         setattr_copy(inode, attr);
3084         mark_inode_dirty(inode);
3085
3086         pr_debug("%s exited\n", __func__);
3087         return error;
3088 }
3089
3090 static int exfat_getattr(const struct path *path, struct kstat *stat,
3091                          u32 request_mask, unsigned int flags)
3092 {
3093         struct inode *inode = path->dentry->d_inode;
3094
3095         pr_debug("%s entered\n", __func__);
3096
3097         generic_fillattr(inode, stat);
3098         stat->blksize = EXFAT_SB(inode->i_sb)->fs_info.cluster_size;
3099
3100         pr_debug("%s exited\n", __func__);
3101         return 0;
3102 }
3103
3104 static const struct inode_operations exfat_dir_inode_operations = {
3105         .create        = exfat_create,
3106         .lookup        = exfat_lookup,
3107         .unlink        = exfat_unlink,
3108         .symlink       = exfat_symlink,
3109         .mkdir         = exfat_mkdir,
3110         .rmdir         = exfat_rmdir,
3111         .rename        = exfat_rename,
3112         .setattr       = exfat_setattr,
3113         .getattr       = exfat_getattr,
3114 };
3115
3116 /*======================================================================*/
3117 /*  File Operations                                                     */
3118 /*======================================================================*/
3119 static const char *exfat_get_link(struct dentry *dentry, struct inode *inode,
3120                                   struct delayed_call *done)
3121 {
3122         struct exfat_inode_info *ei = EXFAT_I(inode);
3123
3124         if (ei->target) {
3125                 char *cookie = ei->target;
3126
3127                 if (cookie)
3128                         return (char *)(ei->target);
3129         }
3130         return NULL;
3131 }
3132
3133 static const struct inode_operations exfat_symlink_inode_operations = {
3134                 .get_link = exfat_get_link,
3135 };
3136
3137 static int exfat_file_release(struct inode *inode, struct file *filp)
3138 {
3139         struct super_block *sb = inode->i_sb;
3140
3141         EXFAT_I(inode)->fid.size = i_size_read(inode);
3142         ffsSyncVol(sb, false);
3143         return 0;
3144 }
3145
3146 static const struct file_operations exfat_file_operations = {
3147         .llseek      = generic_file_llseek,
3148         .read_iter   = generic_file_read_iter,
3149         .write_iter  = generic_file_write_iter,
3150         .mmap        = generic_file_mmap,
3151         .release     = exfat_file_release,
3152         .unlocked_ioctl  = exfat_generic_ioctl,
3153         .fsync       = generic_file_fsync,
3154         .splice_read = generic_file_splice_read,
3155 };
3156
3157 static const struct inode_operations exfat_file_inode_operations = {
3158         .setattr     = exfat_setattr,
3159         .getattr     = exfat_getattr,
3160 };
3161
3162 /*======================================================================*/
3163 /*  Address Space Operations                                            */
3164 /*======================================================================*/
3165
3166 static int exfat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
3167                       unsigned long *mapped_blocks, int *create)
3168 {
3169         struct super_block *sb = inode->i_sb;
3170         struct exfat_sb_info *sbi = EXFAT_SB(sb);
3171         struct fs_info_t *p_fs = &(sbi->fs_info);
3172         struct bd_info_t *p_bd = &(sbi->bd_info);
3173         const unsigned long blocksize = sb->s_blocksize;
3174         const unsigned char blocksize_bits = sb->s_blocksize_bits;
3175         sector_t last_block;
3176         int err, clu_offset, sec_offset;
3177         unsigned int cluster;
3178
3179         *phys = 0;
3180         *mapped_blocks = 0;
3181
3182         if ((p_fs->vol_type == FAT12) || (p_fs->vol_type == FAT16)) {
3183                 if (inode->i_ino == EXFAT_ROOT_INO) {
3184                         if (sector <
3185                             (p_fs->dentries_in_root >>
3186                              (p_bd->sector_size_bits-DENTRY_SIZE_BITS))) {
3187                                 *phys = sector + p_fs->root_start_sector;
3188                                 *mapped_blocks = 1;
3189                         }
3190                         return 0;
3191                 }
3192         }
3193
3194         last_block = (i_size_read(inode) + (blocksize - 1)) >> blocksize_bits;
3195         if (sector >= last_block) {
3196                 if (*create == 0)
3197                         return 0;
3198         } else {
3199                 *create = 0;
3200         }
3201
3202         /* cluster offset */
3203         clu_offset = sector >> p_fs->sectors_per_clu_bits;
3204
3205         /* sector offset in cluster */
3206         sec_offset = sector & (p_fs->sectors_per_clu - 1);
3207
3208         EXFAT_I(inode)->fid.size = i_size_read(inode);
3209
3210         err = ffsMapCluster(inode, clu_offset, &cluster);
3211
3212         if (err) {
3213                 if (err == FFS_FULL)
3214                         return -ENOSPC;
3215                 else
3216                         return -EIO;
3217         } else if (cluster != CLUSTER_32(~0)) {
3218                 *phys = START_SECTOR(cluster) + sec_offset;
3219                 *mapped_blocks = p_fs->sectors_per_clu - sec_offset;
3220         }
3221
3222         return 0;
3223 }
3224
3225 static int exfat_get_block(struct inode *inode, sector_t iblock,
3226                            struct buffer_head *bh_result, int create)
3227 {
3228         struct super_block *sb = inode->i_sb;
3229         unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
3230         int err;
3231         unsigned long mapped_blocks;
3232         sector_t phys;
3233
3234         __lock_super(sb);
3235
3236         err = exfat_bmap(inode, iblock, &phys, &mapped_blocks, &create);
3237         if (err) {
3238                 __unlock_super(sb);
3239                 return err;
3240         }
3241
3242         if (phys) {
3243                 max_blocks = min(mapped_blocks, max_blocks);
3244                 if (create) {
3245                         EXFAT_I(inode)->mmu_private += max_blocks <<
3246                                                         sb->s_blocksize_bits;
3247                         set_buffer_new(bh_result);
3248                 }
3249                 map_bh(bh_result, sb, phys);
3250         }
3251
3252         bh_result->b_size = max_blocks << sb->s_blocksize_bits;
3253         __unlock_super(sb);
3254
3255         return 0;
3256 }
3257
3258 static int exfat_readpage(struct file *file, struct page *page)
3259 {
3260         return  mpage_readpage(page, exfat_get_block);
3261 }
3262
3263 static int exfat_readpages(struct file *file, struct address_space *mapping,
3264                            struct list_head *pages, unsigned int nr_pages)
3265 {
3266         return  mpage_readpages(mapping, pages, nr_pages, exfat_get_block);
3267 }
3268
3269 static int exfat_writepage(struct page *page, struct writeback_control *wbc)
3270 {
3271         return block_write_full_page(page, exfat_get_block, wbc);
3272 }
3273
3274 static int exfat_writepages(struct address_space *mapping,
3275                             struct writeback_control *wbc)
3276 {
3277         return mpage_writepages(mapping, wbc, exfat_get_block);
3278 }
3279
3280 static void exfat_write_failed(struct address_space *mapping, loff_t to)
3281 {
3282         struct inode *inode = mapping->host;
3283
3284         if (to > i_size_read(inode)) {
3285                 truncate_pagecache(inode, i_size_read(inode));
3286                 EXFAT_I(inode)->fid.size = i_size_read(inode);
3287                 exfat_truncate(inode, i_size_read(inode));
3288         }
3289 }
3290
3291 static int exfat_write_begin(struct file *file, struct address_space *mapping,
3292                              loff_t pos, unsigned int len, unsigned int flags,
3293                              struct page **pagep, void **fsdata)
3294 {
3295         int ret;
3296
3297         *pagep = NULL;
3298         ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
3299                                exfat_get_block,
3300                                &EXFAT_I(mapping->host)->mmu_private);
3301
3302         if (ret < 0)
3303                 exfat_write_failed(mapping, pos+len);
3304         return ret;
3305 }
3306
3307 static int exfat_write_end(struct file *file, struct address_space *mapping,
3308                            loff_t pos, unsigned int len, unsigned int copied,
3309                            struct page *pagep, void *fsdata)
3310 {
3311         struct inode *inode = mapping->host;
3312         struct file_id_t *fid = &(EXFAT_I(inode)->fid);
3313         int err;
3314
3315         err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata);
3316
3317         if (err < len)
3318                 exfat_write_failed(mapping, pos+len);
3319
3320         if (!(err < 0) && !(fid->attr & ATTR_ARCHIVE)) {
3321                 inode->i_mtime = inode->i_ctime = current_time(inode);
3322                 fid->attr |= ATTR_ARCHIVE;
3323                 mark_inode_dirty(inode);
3324         }
3325         return err;
3326 }
3327
3328 static ssize_t exfat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
3329 {
3330         struct inode *inode = iocb->ki_filp->f_mapping->host;
3331         struct address_space *mapping = iocb->ki_filp->f_mapping;
3332         ssize_t ret;
3333         int rw;
3334
3335         rw = iov_iter_rw(iter);
3336
3337         if (rw == WRITE) {
3338                 if (EXFAT_I(inode)->mmu_private < iov_iter_count(iter))
3339                         return 0;
3340         }
3341         ret = blockdev_direct_IO(iocb, inode, iter, exfat_get_block);
3342
3343         if ((ret < 0) && (rw & WRITE))
3344                 exfat_write_failed(mapping, iov_iter_count(iter));
3345         return ret;
3346 }
3347
3348 static sector_t _exfat_bmap(struct address_space *mapping, sector_t block)
3349 {
3350         sector_t blocknr;
3351
3352         /* exfat_get_cluster() assumes the requested blocknr isn't truncated. */
3353         down_read(&EXFAT_I(mapping->host)->truncate_lock);
3354         blocknr = generic_block_bmap(mapping, block, exfat_get_block);
3355         up_read(&EXFAT_I(mapping->host)->truncate_lock);
3356
3357         return blocknr;
3358 }
3359
3360 static const struct address_space_operations exfat_aops = {
3361         .readpage    = exfat_readpage,
3362         .readpages   = exfat_readpages,
3363         .writepage   = exfat_writepage,
3364         .writepages  = exfat_writepages,
3365         .write_begin = exfat_write_begin,
3366         .write_end   = exfat_write_end,
3367         .direct_IO   = exfat_direct_IO,
3368         .bmap        = _exfat_bmap
3369 };
3370
3371 /*======================================================================*/
3372 /*  Super Operations                                                    */
3373 /*======================================================================*/
3374
3375 static struct inode *exfat_iget(struct super_block *sb, loff_t i_pos)
3376 {
3377         struct exfat_sb_info *sbi = EXFAT_SB(sb);
3378         struct exfat_inode_info *info;
3379         struct hlist_head *head = sbi->inode_hashtable + exfat_hash(i_pos);
3380         struct inode *inode = NULL;
3381
3382         spin_lock(&sbi->inode_hash_lock);
3383         hlist_for_each_entry(info, head, i_hash_fat) {
3384                 BUG_ON(info->vfs_inode.i_sb != sb);
3385
3386                 if (i_pos != info->i_pos)
3387                         continue;
3388                 inode = igrab(&info->vfs_inode);
3389                 if (inode)
3390                         break;
3391         }
3392         spin_unlock(&sbi->inode_hash_lock);
3393         return inode;
3394 }
3395
3396 /* doesn't deal with root inode */
3397 static int exfat_fill_inode(struct inode *inode, struct file_id_t *fid)
3398 {
3399         struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
3400         struct fs_info_t *p_fs = &(sbi->fs_info);
3401         struct dir_entry_t info;
3402
3403         memcpy(&(EXFAT_I(inode)->fid), fid, sizeof(struct file_id_t));
3404
3405         ffsReadStat(inode, &info);
3406
3407         EXFAT_I(inode)->i_pos = 0;
3408         EXFAT_I(inode)->target = NULL;
3409         inode->i_uid = sbi->options.fs_uid;
3410         inode->i_gid = sbi->options.fs_gid;
3411         INC_IVERSION(inode);
3412         inode->i_generation = get_seconds();
3413
3414         if (info.Attr & ATTR_SUBDIR) { /* directory */
3415                 inode->i_generation &= ~1;
3416                 inode->i_mode = exfat_make_mode(sbi, info.Attr, 0777);
3417                 inode->i_op = &exfat_dir_inode_operations;
3418                 inode->i_fop = &exfat_dir_operations;
3419
3420                 i_size_write(inode, info.Size);
3421                 EXFAT_I(inode)->mmu_private = i_size_read(inode);
3422                 set_nlink(inode, info.NumSubdirs);
3423         } else if (info.Attr & ATTR_SYMLINK) { /* symbolic link */
3424                 inode->i_generation |= 1;
3425                 inode->i_mode = exfat_make_mode(sbi, info.Attr, 0777);
3426                 inode->i_op = &exfat_symlink_inode_operations;
3427
3428                 i_size_write(inode, info.Size);
3429                 EXFAT_I(inode)->mmu_private = i_size_read(inode);
3430         } else { /* regular file */
3431                 inode->i_generation |= 1;
3432                 inode->i_mode = exfat_make_mode(sbi, info.Attr, 0777);
3433                 inode->i_op = &exfat_file_inode_operations;
3434                 inode->i_fop = &exfat_file_operations;
3435                 inode->i_mapping->a_ops = &exfat_aops;
3436                 inode->i_mapping->nrpages = 0;
3437
3438                 i_size_write(inode, info.Size);
3439                 EXFAT_I(inode)->mmu_private = i_size_read(inode);
3440         }
3441         exfat_save_attr(inode, info.Attr);
3442
3443         inode->i_blocks = ((i_size_read(inode) + (p_fs->cluster_size - 1))
3444                                 & ~((loff_t)p_fs->cluster_size - 1)) >> 9;
3445
3446         exfat_time_fat2unix(sbi, &inode->i_mtime, &info.ModifyTimestamp);
3447         exfat_time_fat2unix(sbi, &inode->i_ctime, &info.CreateTimestamp);
3448         exfat_time_fat2unix(sbi, &inode->i_atime, &info.AccessTimestamp);
3449
3450         return 0;
3451 }
3452
3453 static struct inode *exfat_build_inode(struct super_block *sb,
3454                                        struct file_id_t *fid, loff_t i_pos)
3455 {
3456         struct inode *inode;
3457         int err;
3458
3459         inode = exfat_iget(sb, i_pos);
3460         if (inode)
3461                 goto out;
3462         inode = new_inode(sb);
3463         if (!inode) {
3464                 inode = ERR_PTR(-ENOMEM);
3465                 goto out;
3466         }
3467         inode->i_ino = iunique(sb, EXFAT_ROOT_INO);
3468         SET_IVERSION(inode, 1);
3469         err = exfat_fill_inode(inode, fid);
3470         if (err) {
3471                 iput(inode);
3472                 inode = ERR_PTR(err);
3473                 goto out;
3474         }
3475         exfat_attach(inode, i_pos);
3476         insert_inode_hash(inode);
3477 out:
3478         return inode;
3479 }
3480
3481 static int exfat_sync_inode(struct inode *inode)
3482 {
3483         return exfat_write_inode(inode, NULL);
3484 }
3485
3486 static struct inode *exfat_alloc_inode(struct super_block *sb)
3487 {
3488         struct exfat_inode_info *ei;
3489
3490         ei = kmem_cache_alloc(exfat_inode_cachep, GFP_NOFS);
3491         if (!ei)
3492                 return NULL;
3493
3494         init_rwsem(&ei->truncate_lock);
3495
3496         return &ei->vfs_inode;
3497 }
3498
3499 static void exfat_destroy_inode(struct inode *inode)
3500 {
3501         kfree(EXFAT_I(inode)->target);
3502         EXFAT_I(inode)->target = NULL;
3503
3504         kmem_cache_free(exfat_inode_cachep, EXFAT_I(inode));
3505 }
3506
3507 static int exfat_write_inode(struct inode *inode, struct writeback_control *wbc)
3508 {
3509         struct super_block *sb = inode->i_sb;
3510         struct exfat_sb_info *sbi = EXFAT_SB(sb);
3511         struct dir_entry_t info;
3512
3513         if (inode->i_ino == EXFAT_ROOT_INO)
3514                 return 0;
3515
3516         info.Attr = exfat_make_attr(inode);
3517         info.Size = i_size_read(inode);
3518
3519         exfat_time_unix2fat(sbi, &inode->i_mtime, &info.ModifyTimestamp);
3520         exfat_time_unix2fat(sbi, &inode->i_ctime, &info.CreateTimestamp);
3521         exfat_time_unix2fat(sbi, &inode->i_atime, &info.AccessTimestamp);
3522
3523         ffsWriteStat(inode, &info);
3524
3525         return 0;
3526 }
3527
3528 static void exfat_evict_inode(struct inode *inode)
3529 {
3530         truncate_inode_pages(&inode->i_data, 0);
3531
3532         if (!inode->i_nlink)
3533                 i_size_write(inode, 0);
3534         invalidate_inode_buffers(inode);
3535         clear_inode(inode);
3536         exfat_detach(inode);
3537
3538         remove_inode_hash(inode);
3539 }
3540
3541 static void exfat_free_super(struct exfat_sb_info *sbi)
3542 {
3543         if (sbi->nls_disk)
3544                 unload_nls(sbi->nls_disk);
3545         if (sbi->nls_io)
3546                 unload_nls(sbi->nls_io);
3547         if (sbi->options.iocharset != exfat_default_iocharset)
3548                 kfree(sbi->options.iocharset);
3549         /* mutex_init is in exfat_fill_super function. only for 3.7+ */
3550         mutex_destroy(&sbi->s_lock);
3551         kfree(sbi);
3552 }
3553
3554 static void exfat_put_super(struct super_block *sb)
3555 {
3556         struct exfat_sb_info *sbi = EXFAT_SB(sb);
3557
3558         if (__is_sb_dirty(sb))
3559                 exfat_write_super(sb);
3560
3561         ffsUmountVol(sb);
3562
3563         sb->s_fs_info = NULL;
3564         exfat_free_super(sbi);
3565 }
3566
3567 static void exfat_write_super(struct super_block *sb)
3568 {
3569         __lock_super(sb);
3570
3571         __set_sb_clean(sb);
3572
3573         if (!sb_rdonly(sb))
3574                 ffsSyncVol(sb, true);
3575
3576         __unlock_super(sb);
3577 }
3578
3579 static int exfat_sync_fs(struct super_block *sb, int wait)
3580 {
3581         int err = 0;
3582
3583         if (__is_sb_dirty(sb)) {
3584                 __lock_super(sb);
3585                 __set_sb_clean(sb);
3586                 err = ffsSyncVol(sb, true);
3587                 __unlock_super(sb);
3588         }
3589
3590         return err;
3591 }
3592
3593 static int exfat_statfs(struct dentry *dentry, struct kstatfs *buf)
3594 {
3595         struct super_block *sb = dentry->d_sb;
3596         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
3597         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
3598         struct vol_info_t info;
3599
3600         if (p_fs->used_clusters == (u32) ~0) {
3601                 if (ffsGetVolInfo(sb, &info) == FFS_MEDIAERR)
3602                         return -EIO;
3603
3604         } else {
3605                 info.FatType = p_fs->vol_type;
3606                 info.ClusterSize = p_fs->cluster_size;
3607                 info.NumClusters = p_fs->num_clusters - 2;
3608                 info.UsedClusters = p_fs->used_clusters;
3609                 info.FreeClusters = info.NumClusters - info.UsedClusters;
3610
3611                 if (p_fs->dev_ejected)
3612                         pr_info("[EXFAT] statfs on device that is ejected\n");
3613         }
3614
3615         buf->f_type = sb->s_magic;
3616         buf->f_bsize = info.ClusterSize;
3617         buf->f_blocks = info.NumClusters;
3618         buf->f_bfree = info.FreeClusters;
3619         buf->f_bavail = info.FreeClusters;
3620         buf->f_fsid.val[0] = (u32)id;
3621         buf->f_fsid.val[1] = (u32)(id >> 32);
3622         buf->f_namelen = 260;
3623
3624         return 0;
3625 }
3626
3627 static int exfat_remount(struct super_block *sb, int *flags, char *data)
3628 {
3629         *flags |= SB_NODIRATIME;
3630         return 0;
3631 }
3632
3633 static int exfat_show_options(struct seq_file *m, struct dentry *root)
3634 {
3635         struct exfat_sb_info *sbi = EXFAT_SB(root->d_sb);
3636         struct exfat_mount_options *opts = &sbi->options;
3637
3638         if (__kuid_val(opts->fs_uid))
3639                 seq_printf(m, ",uid=%u", __kuid_val(opts->fs_uid));
3640         if (__kgid_val(opts->fs_gid))
3641                 seq_printf(m, ",gid=%u", __kgid_val(opts->fs_gid));
3642         seq_printf(m, ",fmask=%04o", opts->fs_fmask);
3643         seq_printf(m, ",dmask=%04o", opts->fs_dmask);
3644         if (opts->allow_utime)
3645                 seq_printf(m, ",allow_utime=%04o", opts->allow_utime);
3646         if (sbi->nls_disk)
3647                 seq_printf(m, ",codepage=%s", sbi->nls_disk->charset);
3648         if (sbi->nls_io)
3649                 seq_printf(m, ",iocharset=%s", sbi->nls_io->charset);
3650         seq_printf(m, ",namecase=%u", opts->casesensitive);
3651         if (opts->errors == EXFAT_ERRORS_CONT)
3652                 seq_puts(m, ",errors=continue");
3653         else if (opts->errors == EXFAT_ERRORS_PANIC)
3654                 seq_puts(m, ",errors=panic");
3655         else
3656                 seq_puts(m, ",errors=remount-ro");
3657 #ifdef CONFIG_EXFAT_DISCARD
3658         if (opts->discard)
3659                 seq_puts(m, ",discard");
3660 #endif
3661         return 0;
3662 }
3663
3664 static const struct super_operations exfat_sops = {
3665         .alloc_inode   = exfat_alloc_inode,
3666         .destroy_inode = exfat_destroy_inode,
3667         .write_inode   = exfat_write_inode,
3668         .evict_inode  = exfat_evict_inode,
3669         .put_super     = exfat_put_super,
3670         .sync_fs       = exfat_sync_fs,
3671         .statfs        = exfat_statfs,
3672         .remount_fs    = exfat_remount,
3673         .show_options  = exfat_show_options,
3674 };
3675
3676 /*======================================================================*/
3677 /*  Export Operations                                                   */
3678 /*======================================================================*/
3679
3680 static struct inode *exfat_nfs_get_inode(struct super_block *sb, u64 ino,
3681                                          u32 generation)
3682 {
3683         struct inode *inode = NULL;
3684
3685         if (ino < EXFAT_ROOT_INO)
3686                 return inode;
3687         inode = ilookup(sb, ino);
3688
3689         if (inode && generation && (inode->i_generation != generation)) {
3690                 iput(inode);
3691                 inode = NULL;
3692         }
3693
3694         return inode;
3695 }
3696
3697 static struct dentry *exfat_fh_to_dentry(struct super_block *sb,
3698                                          struct fid *fid, int fh_len,
3699                                          int fh_type)
3700 {
3701         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
3702                                 exfat_nfs_get_inode);
3703 }
3704
3705 static struct dentry *exfat_fh_to_parent(struct super_block *sb,
3706                                          struct fid *fid, int fh_len,
3707                                          int fh_type)
3708 {
3709         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
3710                                 exfat_nfs_get_inode);
3711 }
3712
3713 static const struct export_operations exfat_export_ops = {
3714         .fh_to_dentry   = exfat_fh_to_dentry,
3715         .fh_to_parent   = exfat_fh_to_parent,
3716 };
3717
3718 /*======================================================================*/
3719 /*  Super Block Read Operations                                         */
3720 /*======================================================================*/
3721
3722 enum {
3723         Opt_uid,
3724         Opt_gid,
3725         Opt_umask,
3726         Opt_dmask,
3727         Opt_fmask,
3728         Opt_allow_utime,
3729         Opt_codepage,
3730         Opt_charset,
3731         Opt_namecase,
3732         Opt_debug,
3733         Opt_err_cont,
3734         Opt_err_panic,
3735         Opt_err_ro,
3736         Opt_utf8_hack,
3737         Opt_err,
3738 #ifdef CONFIG_EXFAT_DISCARD
3739         Opt_discard,
3740 #endif /* EXFAT_CONFIG_DISCARD */
3741 };
3742
3743 static const match_table_t exfat_tokens = {
3744         {Opt_uid, "uid=%u"},
3745         {Opt_gid, "gid=%u"},
3746         {Opt_umask, "umask=%o"},
3747         {Opt_dmask, "dmask=%o"},
3748         {Opt_fmask, "fmask=%o"},
3749         {Opt_allow_utime, "allow_utime=%o"},
3750         {Opt_codepage, "codepage=%u"},
3751         {Opt_charset, "iocharset=%s"},
3752         {Opt_namecase, "namecase=%u"},
3753         {Opt_debug, "debug"},
3754         {Opt_err_cont, "errors=continue"},
3755         {Opt_err_panic, "errors=panic"},
3756         {Opt_err_ro, "errors=remount-ro"},
3757         {Opt_utf8_hack, "utf8"},
3758 #ifdef CONFIG_EXFAT_DISCARD
3759         {Opt_discard, "discard"},
3760 #endif /* CONFIG_EXFAT_DISCARD */
3761         {Opt_err, NULL}
3762 };
3763
3764 static int parse_options(char *options, int silent, int *debug,
3765                          struct exfat_mount_options *opts)
3766 {
3767         char *p;
3768         substring_t args[MAX_OPT_ARGS];
3769         int option;
3770         char *iocharset;
3771
3772         opts->fs_uid = current_uid();
3773         opts->fs_gid = current_gid();
3774         opts->fs_fmask = opts->fs_dmask = current->fs->umask;
3775         opts->allow_utime = (unsigned short) -1;
3776         opts->codepage = exfat_default_codepage;
3777         opts->iocharset = exfat_default_iocharset;
3778         opts->casesensitive = 0;
3779         opts->errors = EXFAT_ERRORS_RO;
3780 #ifdef CONFIG_EXFAT_DISCARD
3781         opts->discard = 0;
3782 #endif
3783         *debug = 0;
3784
3785         if (!options)
3786                 goto out;
3787
3788         while ((p = strsep(&options, ","))) {
3789                 int token;
3790
3791                 if (!*p)
3792                         continue;
3793
3794                 token = match_token(p, exfat_tokens, args);
3795                 switch (token) {
3796                 case Opt_uid:
3797                         if (match_int(&args[0], &option))
3798                                 return 0;
3799                         opts->fs_uid = KUIDT_INIT(option);
3800                         break;
3801                 case Opt_gid:
3802                         if (match_int(&args[0], &option))
3803                                 return 0;
3804                         opts->fs_gid = KGIDT_INIT(option);
3805                         break;
3806                 case Opt_umask:
3807                 case Opt_dmask:
3808                 case Opt_fmask:
3809                         if (match_octal(&args[0], &option))
3810                                 return 0;
3811                         if (token != Opt_dmask)
3812                                 opts->fs_fmask = option;
3813                         if (token != Opt_fmask)
3814                                 opts->fs_dmask = option;
3815                         break;
3816                 case Opt_allow_utime:
3817                         if (match_octal(&args[0], &option))
3818                                 return 0;
3819                         opts->allow_utime = option & 0022;
3820                         break;
3821                 case Opt_codepage:
3822                         if (match_int(&args[0], &option))
3823                                 return 0;
3824                         opts->codepage = option;
3825                         break;
3826                 case Opt_charset:
3827                         if (opts->iocharset != exfat_default_iocharset)
3828                                 kfree(opts->iocharset);
3829                         iocharset = match_strdup(&args[0]);
3830                         if (!iocharset)
3831                                 return -ENOMEM;
3832                         opts->iocharset = iocharset;
3833                         break;
3834                 case Opt_namecase:
3835                         if (match_int(&args[0], &option))
3836                                 return 0;
3837                         opts->casesensitive = option;
3838                         break;
3839                 case Opt_err_cont:
3840                         opts->errors = EXFAT_ERRORS_CONT;
3841                         break;
3842                 case Opt_err_panic:
3843                         opts->errors = EXFAT_ERRORS_PANIC;
3844                         break;
3845                 case Opt_err_ro:
3846                         opts->errors = EXFAT_ERRORS_RO;
3847                         break;
3848                 case Opt_debug:
3849                         *debug = 1;
3850                         break;
3851 #ifdef CONFIG_EXFAT_DISCARD
3852                 case Opt_discard:
3853                         opts->discard = 1;
3854                         break;
3855 #endif /* CONFIG_EXFAT_DISCARD */
3856                 case Opt_utf8_hack:
3857                         break;
3858                 default:
3859                         if (!silent)
3860                                 pr_err("[EXFAT] Unrecognized mount option %s or missing value\n",
3861                                        p);
3862                         return -EINVAL;
3863                 }
3864         }
3865
3866 out:
3867         if (opts->allow_utime == (unsigned short) -1)
3868                 opts->allow_utime = ~opts->fs_dmask & 0022;
3869
3870         return 0;
3871 }
3872
3873 static void exfat_hash_init(struct super_block *sb)
3874 {
3875         struct exfat_sb_info *sbi = EXFAT_SB(sb);
3876         int i;
3877
3878         spin_lock_init(&sbi->inode_hash_lock);
3879         for (i = 0; i < EXFAT_HASH_SIZE; i++)
3880                 INIT_HLIST_HEAD(&sbi->inode_hashtable[i]);
3881 }
3882
3883 static int exfat_read_root(struct inode *inode)
3884 {
3885         struct super_block *sb = inode->i_sb;
3886         struct exfat_sb_info *sbi = EXFAT_SB(sb);
3887         struct fs_info_t *p_fs = &(sbi->fs_info);
3888         struct dir_entry_t info;
3889
3890         EXFAT_I(inode)->fid.dir.dir = p_fs->root_dir;
3891         EXFAT_I(inode)->fid.dir.flags = 0x01;
3892         EXFAT_I(inode)->fid.entry = -1;
3893         EXFAT_I(inode)->fid.start_clu = p_fs->root_dir;
3894         EXFAT_I(inode)->fid.flags = 0x01;
3895         EXFAT_I(inode)->fid.type = TYPE_DIR;
3896         EXFAT_I(inode)->fid.rwoffset = 0;
3897         EXFAT_I(inode)->fid.hint_last_off = -1;
3898
3899         EXFAT_I(inode)->target = NULL;
3900
3901         ffsReadStat(inode, &info);
3902
3903         inode->i_uid = sbi->options.fs_uid;
3904         inode->i_gid = sbi->options.fs_gid;
3905         INC_IVERSION(inode);
3906         inode->i_generation = 0;
3907         inode->i_mode = exfat_make_mode(sbi, ATTR_SUBDIR, 0777);
3908         inode->i_op = &exfat_dir_inode_operations;
3909         inode->i_fop = &exfat_dir_operations;
3910
3911         i_size_write(inode, info.Size);
3912         inode->i_blocks = ((i_size_read(inode) + (p_fs->cluster_size - 1))
3913                                 & ~((loff_t)p_fs->cluster_size - 1)) >> 9;
3914         EXFAT_I(inode)->i_pos = ((loff_t) p_fs->root_dir << 32) | 0xffffffff;
3915         EXFAT_I(inode)->mmu_private = i_size_read(inode);
3916
3917         exfat_save_attr(inode, ATTR_SUBDIR);
3918         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
3919         set_nlink(inode, info.NumSubdirs + 2);
3920
3921         return 0;
3922 }
3923
3924 static void setup_dops(struct super_block *sb)
3925 {
3926         if (EXFAT_SB(sb)->options.casesensitive == 0)
3927                 sb->s_d_op = &exfat_ci_dentry_ops;
3928         else
3929                 sb->s_d_op = &exfat_dentry_ops;
3930 }
3931
3932 static int exfat_fill_super(struct super_block *sb, void *data, int silent)
3933 {
3934         struct inode *root_inode = NULL;
3935         struct exfat_sb_info *sbi;
3936         int debug, ret;
3937         long error;
3938         char buf[50];
3939
3940         /*
3941          * GFP_KERNEL is ok here, because while we do hold the
3942          * supeblock lock, memory pressure can't call back into
3943          * the filesystem, since we're only just about to mount
3944          * it and have no inodes etc active!
3945          */
3946         sbi = kzalloc(sizeof(struct exfat_sb_info), GFP_KERNEL);
3947         if (!sbi)
3948                 return -ENOMEM;
3949         mutex_init(&sbi->s_lock);
3950         sb->s_fs_info = sbi;
3951         sb->s_flags |= SB_NODIRATIME;
3952         sb->s_magic = EXFAT_SUPER_MAGIC;
3953         sb->s_op = &exfat_sops;
3954         sb->s_export_op = &exfat_export_ops;
3955
3956         error = parse_options(data, silent, &debug, &sbi->options);
3957         if (error)
3958                 goto out_fail;
3959
3960         setup_dops(sb);
3961
3962         error = -EIO;
3963         sb_min_blocksize(sb, 512);
3964         sb->s_maxbytes = 0x7fffffffffffffffLL;    /* maximum file size */
3965
3966         ret = ffsMountVol(sb);
3967         if (ret) {
3968                 if (!silent)
3969                         pr_err("[EXFAT] ffsMountVol failed\n");
3970
3971                 goto out_fail;
3972         }
3973
3974         /* set up enough so that it can read an inode */
3975         exfat_hash_init(sb);
3976
3977         /*
3978          * The low byte of FAT's first entry must have same value with
3979          * media-field.  But in real world, too many devices is
3980          * writing wrong value.  So, removed that validity check.
3981          *
3982          * if (FAT_FIRST_ENT(sb, media) != first)
3983          */
3984
3985         /* codepage is not meaningful in exfat */
3986         if (sbi->fs_info.vol_type != EXFAT) {
3987                 error = -EINVAL;
3988                 sprintf(buf, "cp%d", sbi->options.codepage);
3989                 sbi->nls_disk = load_nls(buf);
3990                 if (!sbi->nls_disk) {
3991                         pr_err("[EXFAT] Codepage %s not found\n", buf);
3992                         goto out_fail2;
3993                 }
3994         }
3995
3996         sbi->nls_io = load_nls(sbi->options.iocharset);
3997
3998         error = -ENOMEM;
3999         root_inode = new_inode(sb);
4000         if (!root_inode)
4001                 goto out_fail2;
4002         root_inode->i_ino = EXFAT_ROOT_INO;
4003         SET_IVERSION(root_inode, 1);
4004
4005         error = exfat_read_root(root_inode);
4006         if (error < 0)
4007                 goto out_fail2;
4008         error = -ENOMEM;
4009         exfat_attach(root_inode, EXFAT_I(root_inode)->i_pos);
4010         insert_inode_hash(root_inode);
4011         sb->s_root = d_make_root(root_inode);
4012         if (!sb->s_root) {
4013                 pr_err("[EXFAT] Getting the root inode failed\n");
4014                 goto out_fail2;
4015         }
4016
4017         return 0;
4018
4019 out_fail2:
4020         ffsUmountVol(sb);
4021 out_fail:
4022         if (root_inode)
4023                 iput(root_inode);
4024         sb->s_fs_info = NULL;
4025         exfat_free_super(sbi);
4026         return error;
4027 }
4028
4029 static struct dentry *exfat_fs_mount(struct file_system_type *fs_type,
4030                                      int flags, const char *dev_name,
4031                                      void *data)
4032 {
4033         return mount_bdev(fs_type, flags, dev_name, data, exfat_fill_super);
4034 }
4035
4036 static void init_once(void *foo)
4037 {
4038         struct exfat_inode_info *ei = (struct exfat_inode_info *)foo;
4039
4040         INIT_HLIST_NODE(&ei->i_hash_fat);
4041         inode_init_once(&ei->vfs_inode);
4042 }
4043
4044 static int __init exfat_init_inodecache(void)
4045 {
4046         exfat_inode_cachep = kmem_cache_create("exfat_inode_cache",
4047                                                sizeof(struct exfat_inode_info),
4048                                                0,
4049                                                (SLAB_RECLAIM_ACCOUNT |
4050                                                 SLAB_MEM_SPREAD),
4051                                                init_once);
4052         if (!exfat_inode_cachep)
4053                 return -ENOMEM;
4054         return 0;
4055 }
4056
4057 static void __exit exfat_destroy_inodecache(void)
4058 {
4059         /*
4060          * Make sure all delayed rcu free inodes are flushed before we
4061          * destroy cache.
4062          */
4063         rcu_barrier();
4064         kmem_cache_destroy(exfat_inode_cachep);
4065 }
4066
4067 #ifdef CONFIG_EXFAT_KERNEL_DEBUG
4068 static void exfat_debug_kill_sb(struct super_block *sb)
4069 {
4070         struct exfat_sb_info *sbi = EXFAT_SB(sb);
4071         struct block_device *bdev = sb->s_bdev;
4072         struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
4073
4074         long flags;
4075
4076         if (sbi) {
4077                 flags = sbi->debug_flags;
4078
4079                 if (flags & EXFAT_DEBUGFLAGS_INVALID_UMOUNT) {
4080                         /*
4081                          * invalidate_bdev drops all device cache include
4082                          * dirty. We use this to simulate device removal.
4083                          */
4084                         down(&p_fs->v_sem);
4085                         FAT_release_all(sb);
4086                         buf_release_all(sb);
4087                         up(&p_fs->v_sem);
4088
4089                         invalidate_bdev(bdev);
4090                 }
4091         }
4092
4093         kill_block_super(sb);
4094 }
4095 #endif /* CONFIG_EXFAT_KERNEL_DEBUG */
4096
4097 static struct file_system_type exfat_fs_type = {
4098         .owner       = THIS_MODULE,
4099         .name        = "exfat",
4100         .mount       = exfat_fs_mount,
4101 #ifdef CONFIG_EXFAT_KERNEL_DEBUG
4102         .kill_sb    = exfat_debug_kill_sb,
4103 #else
4104         .kill_sb    = kill_block_super,
4105 #endif /* CONFIG_EXFAT_KERNEL_DEBUG */
4106         .fs_flags    = FS_REQUIRES_DEV,
4107 };
4108
4109 static int __init init_exfat(void)
4110 {
4111         int err;
4112
4113         BUILD_BUG_ON(sizeof(struct dentry_t) != DENTRY_SIZE);
4114         BUILD_BUG_ON(sizeof(struct dos_dentry_t) != DENTRY_SIZE);
4115         BUILD_BUG_ON(sizeof(struct ext_dentry_t) != DENTRY_SIZE);
4116         BUILD_BUG_ON(sizeof(struct file_dentry_t) != DENTRY_SIZE);
4117         BUILD_BUG_ON(sizeof(struct strm_dentry_t) != DENTRY_SIZE);
4118         BUILD_BUG_ON(sizeof(struct name_dentry_t) != DENTRY_SIZE);
4119         BUILD_BUG_ON(sizeof(struct bmap_dentry_t) != DENTRY_SIZE);
4120         BUILD_BUG_ON(sizeof(struct case_dentry_t) != DENTRY_SIZE);
4121         BUILD_BUG_ON(sizeof(struct volm_dentry_t) != DENTRY_SIZE);
4122
4123         pr_info("exFAT: Version %s\n", EXFAT_VERSION);
4124
4125         err = exfat_init_inodecache();
4126         if (err)
4127                 return err;
4128
4129         err = register_filesystem(&exfat_fs_type);
4130         if (err)
4131                 return err;
4132
4133         return 0;
4134 }
4135
4136 static void __exit exit_exfat(void)
4137 {
4138         exfat_destroy_inodecache();
4139         unregister_filesystem(&exfat_fs_type);
4140 }
4141
4142 module_init(init_exfat);
4143 module_exit(exit_exfat);
4144
4145 MODULE_LICENSE("GPL");
4146 MODULE_DESCRIPTION("exFAT Filesystem Driver");
4147 MODULE_ALIAS_FS("exfat");