fs/fat/fatent.c

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