linux/fs/fat/fatent.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) 2004, OGAWA Hirofumi
   4 */
   5
   6#include <linux/blkdev.h>
   7#include <linux/sched/signal.h>
   8#include "fat.h"
   9
  10struct fatent_operations {
  11        void (*ent_blocknr)(struct super_block *, int, int *, sector_t *);
  12        void (*ent_set_ptr)(struct fat_entry *, int);
  13        int (*ent_bread)(struct super_block *, struct fat_entry *,
  14                         int, sector_t);
  15        int (*ent_get)(struct fat_entry *);
  16        void (*ent_put)(struct fat_entry *, int);
  17        int (*ent_next)(struct fat_entry *);
  18};
  19
  20static DEFINE_SPINLOCK(fat12_entry_lock);
  21
  22static void fat12_ent_blocknr(struct super_block *sb, int entry,
  23                              int *offset, sector_t *blocknr)
  24{
  25        struct msdos_sb_info *sbi = MSDOS_SB(sb);
  26        int bytes = entry + (entry >> 1);
  27        WARN_ON(!fat_valid_entry(sbi, entry));
  28        *offset = bytes & (sb->s_blocksize - 1);
  29        *blocknr = sbi->fat_start + (bytes >> sb->s_blocksize_bits);
  30}
  31
  32static void fat_ent_blocknr(struct super_block *sb, int entry,
  33                            int *offset, sector_t *blocknr)
  34{
  35        struct msdos_sb_info *sbi = MSDOS_SB(sb);
  36        int bytes = (entry << sbi->fatent_shift);
  37        WARN_ON(!fat_valid_entry(sbi, entry));
  38        *offset = bytes & (sb->s_blocksize - 1);
  39        *blocknr = sbi->fat_start + (bytes >> sb->s_blocksize_bits);
  40}
  41
  42static void fat12_ent_set_ptr(struct fat_entry *fatent, int offset)
  43{
  44        struct buffer_head **bhs = fatent->bhs;
  45        if (fatent->nr_bhs == 1) {
  46                WARN_ON(offset >= (bhs[0]->b_size - 1));
  47                fatent->u.ent12_p[0] = bhs[0]->b_data + offset;
  48                fatent->u.ent12_p[1] = bhs[0]->b_data + (offset + 1);
  49        } else {
  50                WARN_ON(offset != (bhs[0]->b_size - 1));
  51                fatent->u.ent12_p[0] = bhs[0]->b_data + offset;
  52                fatent->u.ent12_p[1] = bhs[1]->b_data;
  53        }
  54}
  55
  56static void fat16_ent_set_ptr(struct fat_entry *fatent, int offset)
  57{
  58        WARN_ON(offset & (2 - 1));
  59        fatent->u.ent16_p = (__le16 *)(fatent->bhs[0]->b_data + offset);
  60}
  61
  62static void fat32_ent_set_ptr(struct fat_entry *fatent, int offset)
  63{
  64        WARN_ON(offset & (4 - 1));
  65        fatent->u.ent32_p = (__le32 *)(fatent->bhs[0]->b_data + offset);
  66}
  67
  68static int fat12_ent_bread(struct super_block *sb, struct fat_entry *fatent,
  69                           int offset, sector_t blocknr)
  70{
  71        struct buffer_head **bhs = fatent->bhs;
  72
  73        WARN_ON(blocknr < MSDOS_SB(sb)->fat_start);
  74        fatent->fat_inode = MSDOS_SB(sb)->fat_inode;
  75
  76        bhs[0] = sb_bread(sb, blocknr);
  77        if (!bhs[0])
  78                goto err;
  79
  80        if ((offset + 1) < sb->s_blocksize)
  81                fatent->nr_bhs = 1;
  82        else {
  83                /* This entry is block boundary, it needs the next block */
  84                blocknr++;
  85                bhs[1] = sb_bread(sb, blocknr);
  86                if (!bhs[1])
  87                        goto err_brelse;
  88                fatent->nr_bhs = 2;
  89        }
  90        fat12_ent_set_ptr(fatent, offset);
  91        return 0;
  92
  93err_brelse:
  94        brelse(bhs[0]);
  95err:
  96        fat_msg(sb, KERN_ERR, "FAT read failed (blocknr %llu)", (llu)blocknr);
  97        return -EIO;
  98}
  99
 100static int fat_ent_bread(struct super_block *sb, struct fat_entry *fatent,
 101                         int offset, sector_t blocknr)
 102{
 103        const struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;
 104
 105        WARN_ON(blocknr < MSDOS_SB(sb)->fat_start);
 106        fatent->fat_inode = MSDOS_SB(sb)->fat_inode;
 107        fatent->bhs[0] = sb_bread(sb, blocknr);
 108        if (!fatent->bhs[0]) {
 109                fat_msg(sb, KERN_ERR, "FAT read failed (blocknr %llu)",
 110                       (llu)blocknr);
 111                return -EIO;
 112        }
 113        fatent->nr_bhs = 1;
 114        ops->ent_set_ptr(fatent, offset);
 115        return 0;
 116}
 117
 118static int fat12_ent_get(struct fat_entry *fatent)
 119{
 120        u8 **ent12_p = fatent->u.ent12_p;
 121        int next;
 122
 123        spin_lock(&fat12_entry_lock);
 124        if (fatent->entry & 1)
 125                next = (*ent12_p[0] >> 4) | (*ent12_p[1] << 4);
 126        else
 127                next = (*ent12_p[1] << 8) | *ent12_p[0];
 128        spin_unlock(&fat12_entry_lock);
 129
 130        next &= 0x0fff;
 131        if (next >= BAD_FAT12)
 132                next = FAT_ENT_EOF;
 133        return next;
 134}
 135
 136static int fat16_ent_get(struct fat_entry *fatent)
 137{
 138        int next = le16_to_cpu(*fatent->u.ent16_p);
 139        WARN_ON((unsigned long)fatent->u.ent16_p & (2 - 1));
 140        if (next >= BAD_FAT16)
 141                next = FAT_ENT_EOF;
 142        return next;
 143}
 144
 145static int fat32_ent_get(struct fat_entry *fatent)
 146{
 147        int next = le32_to_cpu(*fatent->u.ent32_p) & 0x0fffffff;
 148        WARN_ON((unsigned long)fatent->u.ent32_p & (4 - 1));
 149        if (next >= BAD_FAT32)
 150                next = FAT_ENT_EOF;
 151        return next;
 152}
 153
 154static void fat12_ent_put(struct fat_entry *fatent, int new)
 155{
 156        u8 **ent12_p = fatent->u.ent12_p;
 157
 158        if (new == FAT_ENT_EOF)
 159                new = EOF_FAT12;
 160
 161        spin_lock(&fat12_entry_lock);
 162        if (fatent->entry & 1) {
 163                *ent12_p[0] = (new << 4) | (*ent12_p[0] & 0x0f);
 164                *ent12_p[1] = new >> 4;
 165        } else {
 166                *ent12_p[0] = new & 0xff;
 167                *ent12_p[1] = (*ent12_p[1] & 0xf0) | (new >> 8);
 168        }
 169        spin_unlock(&fat12_entry_lock);
 170
 171        mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
 172        if (fatent->nr_bhs == 2)
 173                mark_buffer_dirty_inode(fatent->bhs[1], fatent->fat_inode);
 174}
 175
 176static void fat16_ent_put(struct fat_entry *fatent, int new)
 177{
 178        if (new == FAT_ENT_EOF)
 179                new = EOF_FAT16;
 180
 181        *fatent->u.ent16_p = cpu_to_le16(new);
 182        mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
 183}
 184
 185static void fat32_ent_put(struct fat_entry *fatent, int new)
 186{
 187        WARN_ON(new & 0xf0000000);
 188        new |= le32_to_cpu(*fatent->u.ent32_p) & ~0x0fffffff;
 189        *fatent->u.ent32_p = cpu_to_le32(new);
 190        mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
 191}
 192
 193static int fat12_ent_next(struct fat_entry *fatent)
 194{
 195        u8 **ent12_p = fatent->u.ent12_p;
 196        struct buffer_head **bhs = fatent->bhs;
 197        u8 *nextp = ent12_p[1] + 1 + (fatent->entry & 1);
 198
 199        fatent->entry++;
 200        if (fatent->nr_bhs == 1) {
 201                WARN_ON(ent12_p[0] > (u8 *)(bhs[0]->b_data +
 202                                                        (bhs[0]->b_size - 2)));
 203                WARN_ON(ent12_p[1] > (u8 *)(bhs[0]->b_data +
 204                                                        (bhs[0]->b_size - 1)));
 205                if (nextp < (u8 *)(bhs[0]->b_data + (bhs[0]->b_size - 1))) {
 206                        ent12_p[0] = nextp - 1;
 207                        ent12_p[1] = nextp;
 208                        return 1;
 209                }
 210        } else {
 211                WARN_ON(ent12_p[0] != (u8 *)(bhs[0]->b_data +
 212                                                        (bhs[0]->b_size - 1)));
 213                WARN_ON(ent12_p[1] != (u8 *)bhs[1]->b_data);
 214                ent12_p[0] = nextp - 1;
 215                ent12_p[1] = nextp;
 216                brelse(bhs[0]);
 217                bhs[0] = bhs[1];
 218                fatent->nr_bhs = 1;
 219                return 1;
 220        }
 221        ent12_p[0] = NULL;
 222        ent12_p[1] = NULL;
 223        return 0;
 224}
 225
 226static int fat16_ent_next(struct fat_entry *fatent)
 227{
 228        const struct buffer_head *bh = fatent->bhs[0];
 229        fatent->entry++;
 230        if (fatent->u.ent16_p < (__le16 *)(bh->b_data + (bh->b_size - 2))) {
 231                fatent->u.ent16_p++;
 232                return 1;
 233        }
 234        fatent->u.ent16_p = NULL;
 235        return 0;
 236}
 237
 238static int fat32_ent_next(struct fat_entry *fatent)
 239{
 240        const struct buffer_head *bh = fatent->bhs[0];
 241        fatent->entry++;
 242        if (fatent->u.ent32_p < (__le32 *)(bh->b_data + (bh->b_size - 4))) {
 243                fatent->u.ent32_p++;
 244                return 1;
 245        }
 246        fatent->u.ent32_p = NULL;
 247        return 0;
 248}
 249
 250static const struct fatent_operations fat12_ops = {
 251        .ent_blocknr    = fat12_ent_blocknr,
 252        .ent_set_ptr    = fat12_ent_set_ptr,
 253        .ent_bread      = fat12_ent_bread,
 254        .ent_get        = fat12_ent_get,
 255        .ent_put        = fat12_ent_put,
 256        .ent_next       = fat12_ent_next,
 257};
 258
 259static const struct fatent_operations fat16_ops = {
 260        .ent_blocknr    = fat_ent_blocknr,
 261        .ent_set_ptr    = fat16_ent_set_ptr,
 262        .ent_bread      = fat_ent_bread,
 263        .ent_get        = fat16_ent_get,
 264        .ent_put        = fat16_ent_put,
 265        .ent_next       = fat16_ent_next,
 266};
 267
 268static const struct fatent_operations fat32_ops = {
 269        .ent_blocknr    = fat_ent_blocknr,
 270        .ent_set_ptr    = fat32_ent_set_ptr,
 271        .ent_bread      = fat_ent_bread,
 272        .ent_get        = fat32_ent_get,
 273        .ent_put        = fat32_ent_put,
 274        .ent_next       = fat32_ent_next,
 275};
 276
 277static inline void lock_fat(struct msdos_sb_info *sbi)
 278{
 279        mutex_lock(&sbi->fat_lock);
 280}
 281
 282static inline void unlock_fat(struct msdos_sb_info *sbi)
 283{
 284        mutex_unlock(&sbi->fat_lock);
 285}
 286
 287void fat_ent_access_init(struct super_block *sb)
 288{
 289        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 290
 291        mutex_init(&sbi->fat_lock);
 292
 293        if (is_fat32(sbi)) {
 294                sbi->fatent_shift = 2;
 295                sbi->fatent_ops = &fat32_ops;
 296        } else if (is_fat16(sbi)) {
 297                sbi->fatent_shift = 1;
 298                sbi->fatent_ops = &fat16_ops;
 299        } else if (is_fat12(sbi)) {
 300                sbi->fatent_shift = -1;
 301                sbi->fatent_ops = &fat12_ops;
 302        } else {
 303                fat_fs_error(sb, "invalid FAT variant, %u bits", sbi->fat_bits);
 304        }
 305}
 306
 307static void mark_fsinfo_dirty(struct super_block *sb)
 308{
 309        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 310
 311        if (sb_rdonly(sb) || !is_fat32(sbi))
 312                return;
 313
 314        __mark_inode_dirty(sbi->fsinfo_inode, I_DIRTY_SYNC);
 315}
 316
 317static inline int fat_ent_update_ptr(struct super_block *sb,
 318                                     struct fat_entry *fatent,
 319                                     int offset, sector_t blocknr)
 320{
 321        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 322        const struct fatent_operations *ops = sbi->fatent_ops;
 323        struct buffer_head **bhs = fatent->bhs;
 324
 325        /* Is this fatent's blocks including this entry? */
 326        if (!fatent->nr_bhs || bhs[0]->b_blocknr != blocknr)
 327                return 0;
 328        if (is_fat12(sbi)) {
 329                if ((offset + 1) < sb->s_blocksize) {
 330                        /* This entry is on bhs[0]. */
 331                        if (fatent->nr_bhs == 2) {
 332                                brelse(bhs[1]);
 333                                fatent->nr_bhs = 1;
 334                        }
 335                } else {
 336                        /* This entry needs the next block. */
 337                        if (fatent->nr_bhs != 2)
 338                                return 0;
 339                        if (bhs[1]->b_blocknr != (blocknr + 1))
 340                                return 0;
 341                }
 342        }
 343        ops->ent_set_ptr(fatent, offset);
 344        return 1;
 345}
 346
 347int fat_ent_read(struct inode *inode, struct fat_entry *fatent, int entry)
 348{
 349        struct super_block *sb = inode->i_sb;
 350        struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
 351        const struct fatent_operations *ops = sbi->fatent_ops;
 352        int err, offset;
 353        sector_t blocknr;
 354
 355        if (!fat_valid_entry(sbi, entry)) {
 356                fatent_brelse(fatent);
 357                fat_fs_error(sb, "invalid access to FAT (entry 0x%08x)", entry);
 358                return -EIO;
 359        }
 360
 361        fatent_set_entry(fatent, entry);
 362        ops->ent_blocknr(sb, entry, &offset, &blocknr);
 363
 364        if (!fat_ent_update_ptr(sb, fatent, offset, blocknr)) {
 365                fatent_brelse(fatent);
 366                err = ops->ent_bread(sb, fatent, offset, blocknr);
 367                if (err)
 368                        return err;
 369        }
 370        return ops->ent_get(fatent);
 371}
 372
 373/* FIXME: We can write the blocks as more big chunk. */
 374static int fat_mirror_bhs(struct super_block *sb, struct buffer_head **bhs,
 375                          int nr_bhs)
 376{
 377        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 378        struct buffer_head *c_bh;
 379        int err, n, copy;
 380
 381        err = 0;
 382        for (copy = 1; copy < sbi->fats; copy++) {
 383                sector_t backup_fat = sbi->fat_length * copy;
 384
 385                for (n = 0; n < nr_bhs; n++) {
 386                        c_bh = sb_getblk(sb, backup_fat + bhs[n]->b_blocknr);
 387                        if (!c_bh) {
 388                                err = -ENOMEM;
 389                                goto error;
 390                        }
 391                        /* Avoid race with userspace read via bdev */
 392                        lock_buffer(c_bh);
 393                        memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize);
 394                        set_buffer_uptodate(c_bh);
 395                        unlock_buffer(c_bh);
 396                        mark_buffer_dirty_inode(c_bh, sbi->fat_inode);
 397                        if (sb->s_flags & SB_SYNCHRONOUS)
 398                                err = sync_dirty_buffer(c_bh);
 399                        brelse(c_bh);
 400                        if (err)
 401                                goto error;
 402                }
 403        }
 404error:
 405        return err;
 406}
 407
 408int fat_ent_write(struct inode *inode, struct fat_entry *fatent,
 409                  int new, int wait)
 410{
 411        struct super_block *sb = inode->i_sb;
 412        const struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;
 413        int err;
 414
 415        ops->ent_put(fatent, new);
 416        if (wait) {
 417                err = fat_sync_bhs(fatent->bhs, fatent->nr_bhs);
 418                if (err)
 419                        return err;
 420        }
 421        return fat_mirror_bhs(sb, fatent->bhs, fatent->nr_bhs);
 422}
 423
 424static inline int fat_ent_next(struct msdos_sb_info *sbi,
 425                               struct fat_entry *fatent)
 426{
 427        if (sbi->fatent_ops->ent_next(fatent)) {
 428                if (fatent->entry < sbi->max_cluster)
 429                        return 1;
 430        }
 431        return 0;
 432}
 433
 434static inline int fat_ent_read_block(struct super_block *sb,
 435                                     struct fat_entry *fatent)
 436{
 437        const struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;
 438        sector_t blocknr;
 439        int offset;
 440
 441        fatent_brelse(fatent);
 442        ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
 443        return ops->ent_bread(sb, fatent, offset, blocknr);
 444}
 445
 446static void fat_collect_bhs(struct buffer_head **bhs, int *nr_bhs,
 447                            struct fat_entry *fatent)
 448{
 449        int n, i;
 450
 451        for (n = 0; n < fatent->nr_bhs; n++) {
 452                for (i = 0; i < *nr_bhs; i++) {
 453                        if (fatent->bhs[n] == bhs[i])
 454                                break;
 455                }
 456                if (i == *nr_bhs) {
 457                        get_bh(fatent->bhs[n]);
 458                        bhs[i] = fatent->bhs[n];
 459                        (*nr_bhs)++;
 460                }
 461        }
 462}
 463
 464int fat_alloc_clusters(struct inode *inode, int *cluster, int nr_cluster)
 465{
 466        struct super_block *sb = inode->i_sb;
 467        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 468        const struct fatent_operations *ops = sbi->fatent_ops;
 469        struct fat_entry fatent, prev_ent;
 470        struct buffer_head *bhs[MAX_BUF_PER_PAGE];
 471        int i, count, err, nr_bhs, idx_clus;
 472
 473        BUG_ON(nr_cluster > (MAX_BUF_PER_PAGE / 2));    /* fixed limit */
 474
 475        lock_fat(sbi);
 476        if (sbi->free_clusters != -1 && sbi->free_clus_valid &&
 477            sbi->free_clusters < nr_cluster) {
 478                unlock_fat(sbi);
 479                return -ENOSPC;
 480        }
 481
 482        err = nr_bhs = idx_clus = 0;
 483        count = FAT_START_ENT;
 484        fatent_init(&prev_ent);
 485        fatent_init(&fatent);
 486        fatent_set_entry(&fatent, sbi->prev_free + 1);
 487        while (count < sbi->max_cluster) {
 488                if (fatent.entry >= sbi->max_cluster)
 489                        fatent.entry = FAT_START_ENT;
 490                fatent_set_entry(&fatent, fatent.entry);
 491                err = fat_ent_read_block(sb, &fatent);
 492                if (err)
 493                        goto out;
 494
 495                /* Find the free entries in a block */
 496                do {
 497                        if (ops->ent_get(&fatent) == FAT_ENT_FREE) {
 498                                int entry = fatent.entry;
 499
 500                                /* make the cluster chain */
 501                                ops->ent_put(&fatent, FAT_ENT_EOF);
 502                                if (prev_ent.nr_bhs)
 503                                        ops->ent_put(&prev_ent, entry);
 504
 505                                fat_collect_bhs(bhs, &nr_bhs, &fatent);
 506
 507                                sbi->prev_free = entry;
 508                                if (sbi->free_clusters != -1)
 509                                        sbi->free_clusters--;
 510
 511                                cluster[idx_clus] = entry;
 512                                idx_clus++;
 513                                if (idx_clus == nr_cluster)
 514                                        goto out;
 515
 516                                /*
 517                                 * fat_collect_bhs() gets ref-count of bhs,
 518                                 * so we can still use the prev_ent.
 519                                 */
 520                                prev_ent = fatent;
 521                        }
 522                        count++;
 523                        if (count == sbi->max_cluster)
 524                                break;
 525                } while (fat_ent_next(sbi, &fatent));
 526        }
 527
 528        /* Couldn't allocate the free entries */
 529        sbi->free_clusters = 0;
 530        sbi->free_clus_valid = 1;
 531        err = -ENOSPC;
 532
 533out:
 534        unlock_fat(sbi);
 535        mark_fsinfo_dirty(sb);
 536        fatent_brelse(&fatent);
 537        if (!err) {
 538                if (inode_needs_sync(inode))
 539                        err = fat_sync_bhs(bhs, nr_bhs);
 540                if (!err)
 541                        err = fat_mirror_bhs(sb, bhs, nr_bhs);
 542        }
 543        for (i = 0; i < nr_bhs; i++)
 544                brelse(bhs[i]);
 545
 546        if (err && idx_clus)
 547                fat_free_clusters(inode, cluster[0]);
 548
 549        return err;
 550}
 551
 552int fat_free_clusters(struct inode *inode, int cluster)
 553{
 554        struct super_block *sb = inode->i_sb;
 555        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 556        const struct fatent_operations *ops = sbi->fatent_ops;
 557        struct fat_entry fatent;
 558        struct buffer_head *bhs[MAX_BUF_PER_PAGE];
 559        int i, err, nr_bhs;
 560        int first_cl = cluster, dirty_fsinfo = 0;
 561
 562        nr_bhs = 0;
 563        fatent_init(&fatent);
 564        lock_fat(sbi);
 565        do {
 566                cluster = fat_ent_read(inode, &fatent, cluster);
 567                if (cluster < 0) {
 568                        err = cluster;
 569                        goto error;
 570                } else if (cluster == FAT_ENT_FREE) {
 571                        fat_fs_error(sb, "%s: deleting FAT entry beyond EOF",
 572                                     __func__);
 573                        err = -EIO;
 574                        goto error;
 575                }
 576
 577                if (sbi->options.discard) {
 578                        /*
 579                         * Issue discard for the sectors we no longer
 580                         * care about, batching contiguous clusters
 581                         * into one request
 582                         */
 583                        if (cluster != fatent.entry + 1) {
 584                                int nr_clus = fatent.entry - first_cl + 1;
 585
 586                                sb_issue_discard(sb,
 587                                        fat_clus_to_blknr(sbi, first_cl),
 588                                        nr_clus * sbi->sec_per_clus,
 589                                        GFP_NOFS, 0);
 590
 591                                first_cl = cluster;
 592                        }
 593                }
 594
 595                ops->ent_put(&fatent, FAT_ENT_FREE);
 596                if (sbi->free_clusters != -1) {
 597                        sbi->free_clusters++;
 598                        dirty_fsinfo = 1;
 599                }
 600
 601                if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {
 602                        if (sb->s_flags & SB_SYNCHRONOUS) {
 603                                err = fat_sync_bhs(bhs, nr_bhs);
 604                                if (err)
 605                                        goto error;
 606                        }
 607                        err = fat_mirror_bhs(sb, bhs, nr_bhs);
 608                        if (err)
 609                                goto error;
 610                        for (i = 0; i < nr_bhs; i++)
 611                                brelse(bhs[i]);
 612                        nr_bhs = 0;
 613                }
 614                fat_collect_bhs(bhs, &nr_bhs, &fatent);
 615        } while (cluster != FAT_ENT_EOF);
 616
 617        if (sb->s_flags & SB_SYNCHRONOUS) {
 618                err = fat_sync_bhs(bhs, nr_bhs);
 619                if (err)
 620                        goto error;
 621        }
 622        err = fat_mirror_bhs(sb, bhs, nr_bhs);
 623error:
 624        fatent_brelse(&fatent);
 625        for (i = 0; i < nr_bhs; i++)
 626                brelse(bhs[i]);
 627        unlock_fat(sbi);
 628        if (dirty_fsinfo)
 629                mark_fsinfo_dirty(sb);
 630
 631        return err;
 632}
 633EXPORT_SYMBOL_GPL(fat_free_clusters);
 634
 635/* 128kb is the whole sectors for FAT12 and FAT16 */
 636#define FAT_READA_SIZE          (128 * 1024)
 637
 638static void fat_ent_reada(struct super_block *sb, struct fat_entry *fatent,
 639                          unsigned long reada_blocks)
 640{
 641        const struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;
 642        sector_t blocknr;
 643        int i, offset;
 644
 645        ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
 646
 647        for (i = 0; i < reada_blocks; i++)
 648                sb_breadahead(sb, blocknr + i);
 649}
 650
 651int fat_count_free_clusters(struct super_block *sb)
 652{
 653        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 654        const struct fatent_operations *ops = sbi->fatent_ops;
 655        struct fat_entry fatent;
 656        unsigned long reada_blocks, reada_mask, cur_block;
 657        int err = 0, free;
 658
 659        lock_fat(sbi);
 660        if (sbi->free_clusters != -1 && sbi->free_clus_valid)
 661                goto out;
 662
 663        reada_blocks = FAT_READA_SIZE >> sb->s_blocksize_bits;
 664        reada_mask = reada_blocks - 1;
 665        cur_block = 0;
 666
 667        free = 0;
 668        fatent_init(&fatent);
 669        fatent_set_entry(&fatent, FAT_START_ENT);
 670        while (fatent.entry < sbi->max_cluster) {
 671                /* readahead of fat blocks */
 672                if ((cur_block & reada_mask) == 0) {
 673                        unsigned long rest = sbi->fat_length - cur_block;
 674                        fat_ent_reada(sb, &fatent, min(reada_blocks, rest));
 675                }
 676                cur_block++;
 677
 678                err = fat_ent_read_block(sb, &fatent);
 679                if (err)
 680                        goto out;
 681
 682                do {
 683                        if (ops->ent_get(&fatent) == FAT_ENT_FREE)
 684                                free++;
 685                } while (fat_ent_next(sbi, &fatent));
 686                cond_resched();
 687        }
 688        sbi->free_clusters = free;
 689        sbi->free_clus_valid = 1;
 690        mark_fsinfo_dirty(sb);
 691        fatent_brelse(&fatent);
 692out:
 693        unlock_fat(sbi);
 694        return err;
 695}
 696
 697static int fat_trim_clusters(struct super_block *sb, u32 clus, u32 nr_clus)
 698{
 699        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 700        return sb_issue_discard(sb, fat_clus_to_blknr(sbi, clus),
 701                                nr_clus * sbi->sec_per_clus, GFP_NOFS, 0);
 702}
 703
 704int fat_trim_fs(struct inode *inode, struct fstrim_range *range)
 705{
 706        struct super_block *sb = inode->i_sb;
 707        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 708        const struct fatent_operations *ops = sbi->fatent_ops;
 709        struct fat_entry fatent;
 710        u64 ent_start, ent_end, minlen, trimmed = 0;
 711        u32 free = 0;
 712        unsigned long reada_blocks, reada_mask, cur_block = 0;
 713        int err = 0;
 714
 715        /*
 716         * FAT data is organized as clusters, trim at the granulary of cluster.
 717         *
 718         * fstrim_range is in byte, convert vaules to cluster index.
 719         * Treat sectors before data region as all used, not to trim them.
 720         */
 721        ent_start = max_t(u64, range->start>>sbi->cluster_bits, FAT_START_ENT);
 722        ent_end = ent_start + (range->len >> sbi->cluster_bits) - 1;
 723        minlen = range->minlen >> sbi->cluster_bits;
 724
 725        if (ent_start >= sbi->max_cluster || range->len < sbi->cluster_size)
 726                return -EINVAL;
 727        if (ent_end >= sbi->max_cluster)
 728                ent_end = sbi->max_cluster - 1;
 729
 730        reada_blocks = FAT_READA_SIZE >> sb->s_blocksize_bits;
 731        reada_mask = reada_blocks - 1;
 732
 733        fatent_init(&fatent);
 734        lock_fat(sbi);
 735        fatent_set_entry(&fatent, ent_start);
 736        while (fatent.entry <= ent_end) {
 737                /* readahead of fat blocks */
 738                if ((cur_block & reada_mask) == 0) {
 739                        unsigned long rest = sbi->fat_length - cur_block;
 740                        fat_ent_reada(sb, &fatent, min(reada_blocks, rest));
 741                }
 742                cur_block++;
 743
 744                err = fat_ent_read_block(sb, &fatent);
 745                if (err)
 746                        goto error;
 747                do {
 748                        if (ops->ent_get(&fatent) == FAT_ENT_FREE) {
 749                                free++;
 750                        } else if (free) {
 751                                if (free >= minlen) {
 752                                        u32 clus = fatent.entry - free;
 753
 754                                        err = fat_trim_clusters(sb, clus, free);
 755                                        if (err && err != -EOPNOTSUPP)
 756                                                goto error;
 757                                        if (!err)
 758                                                trimmed += free;
 759                                        err = 0;
 760                                }
 761                                free = 0;
 762                        }
 763                } while (fat_ent_next(sbi, &fatent) && fatent.entry <= ent_end);
 764
 765                if (fatal_signal_pending(current)) {
 766                        err = -ERESTARTSYS;
 767                        goto error;
 768                }
 769
 770                if (need_resched()) {
 771                        fatent_brelse(&fatent);
 772                        unlock_fat(sbi);
 773                        cond_resched();
 774                        lock_fat(sbi);
 775                }
 776        }
 777        /* handle scenario when tail entries are all free */
 778        if (free && free >= minlen) {
 779                u32 clus = fatent.entry - free;
 780
 781                err = fat_trim_clusters(sb, clus, free);
 782                if (err && err != -EOPNOTSUPP)
 783                        goto error;
 784                if (!err)
 785                        trimmed += free;
 786                err = 0;
 787        }
 788
 789error:
 790        fatent_brelse(&fatent);
 791        unlock_fat(sbi);
 792
 793        range->len = trimmed << sbi->cluster_bits;
 794
 795        return err;
 796}
 797