Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2004, OGAWA Hirofumi
0004  */
0005 
0006 #include <linux/blkdev.h>
0007 #include <linux/sched/signal.h>
0008 #include <linux/backing-dev-defs.h>
0009 #include "fat.h"
0010 
0011 struct fatent_operations {
0012     void (*ent_blocknr)(struct super_block *, int, int *, sector_t *);
0013     void (*ent_set_ptr)(struct fat_entry *, int);
0014     int (*ent_bread)(struct super_block *, struct fat_entry *,
0015              int, sector_t);
0016     int (*ent_get)(struct fat_entry *);
0017     void (*ent_put)(struct fat_entry *, int);
0018     int (*ent_next)(struct fat_entry *);
0019 };
0020 
0021 static DEFINE_SPINLOCK(fat12_entry_lock);
0022 
0023 static void fat12_ent_blocknr(struct super_block *sb, int entry,
0024                   int *offset, sector_t *blocknr)
0025 {
0026     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0027     int bytes = entry + (entry >> 1);
0028     WARN_ON(!fat_valid_entry(sbi, entry));
0029     *offset = bytes & (sb->s_blocksize - 1);
0030     *blocknr = sbi->fat_start + (bytes >> sb->s_blocksize_bits);
0031 }
0032 
0033 static void fat_ent_blocknr(struct super_block *sb, int entry,
0034                 int *offset, sector_t *blocknr)
0035 {
0036     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0037     int bytes = (entry << sbi->fatent_shift);
0038     WARN_ON(!fat_valid_entry(sbi, entry));
0039     *offset = bytes & (sb->s_blocksize - 1);
0040     *blocknr = sbi->fat_start + (bytes >> sb->s_blocksize_bits);
0041 }
0042 
0043 static void fat12_ent_set_ptr(struct fat_entry *fatent, int offset)
0044 {
0045     struct buffer_head **bhs = fatent->bhs;
0046     if (fatent->nr_bhs == 1) {
0047         WARN_ON(offset >= (bhs[0]->b_size - 1));
0048         fatent->u.ent12_p[0] = bhs[0]->b_data + offset;
0049         fatent->u.ent12_p[1] = bhs[0]->b_data + (offset + 1);
0050     } else {
0051         WARN_ON(offset != (bhs[0]->b_size - 1));
0052         fatent->u.ent12_p[0] = bhs[0]->b_data + offset;
0053         fatent->u.ent12_p[1] = bhs[1]->b_data;
0054     }
0055 }
0056 
0057 static void fat16_ent_set_ptr(struct fat_entry *fatent, int offset)
0058 {
0059     WARN_ON(offset & (2 - 1));
0060     fatent->u.ent16_p = (__le16 *)(fatent->bhs[0]->b_data + offset);
0061 }
0062 
0063 static void fat32_ent_set_ptr(struct fat_entry *fatent, int offset)
0064 {
0065     WARN_ON(offset & (4 - 1));
0066     fatent->u.ent32_p = (__le32 *)(fatent->bhs[0]->b_data + offset);
0067 }
0068 
0069 static int fat12_ent_bread(struct super_block *sb, struct fat_entry *fatent,
0070                int offset, sector_t blocknr)
0071 {
0072     struct buffer_head **bhs = fatent->bhs;
0073 
0074     WARN_ON(blocknr < MSDOS_SB(sb)->fat_start);
0075     fatent->fat_inode = MSDOS_SB(sb)->fat_inode;
0076 
0077     bhs[0] = sb_bread(sb, blocknr);
0078     if (!bhs[0])
0079         goto err;
0080 
0081     if ((offset + 1) < sb->s_blocksize)
0082         fatent->nr_bhs = 1;
0083     else {
0084         /* This entry is block boundary, it needs the next block */
0085         blocknr++;
0086         bhs[1] = sb_bread(sb, blocknr);
0087         if (!bhs[1])
0088             goto err_brelse;
0089         fatent->nr_bhs = 2;
0090     }
0091     fat12_ent_set_ptr(fatent, offset);
0092     return 0;
0093 
0094 err_brelse:
0095     brelse(bhs[0]);
0096 err:
0097     fat_msg_ratelimit(sb, KERN_ERR, "FAT read failed (blocknr %llu)",
0098               (llu)blocknr);
0099     return -EIO;
0100 }
0101 
0102 static int fat_ent_bread(struct super_block *sb, struct fat_entry *fatent,
0103              int offset, sector_t blocknr)
0104 {
0105     const struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;
0106 
0107     WARN_ON(blocknr < MSDOS_SB(sb)->fat_start);
0108     fatent->fat_inode = MSDOS_SB(sb)->fat_inode;
0109     fatent->bhs[0] = sb_bread(sb, blocknr);
0110     if (!fatent->bhs[0]) {
0111         fat_msg_ratelimit(sb, KERN_ERR, "FAT read failed (blocknr %llu)",
0112                   (llu)blocknr);
0113         return -EIO;
0114     }
0115     fatent->nr_bhs = 1;
0116     ops->ent_set_ptr(fatent, offset);
0117     return 0;
0118 }
0119 
0120 static int fat12_ent_get(struct fat_entry *fatent)
0121 {
0122     u8 **ent12_p = fatent->u.ent12_p;
0123     int next;
0124 
0125     spin_lock(&fat12_entry_lock);
0126     if (fatent->entry & 1)
0127         next = (*ent12_p[0] >> 4) | (*ent12_p[1] << 4);
0128     else
0129         next = (*ent12_p[1] << 8) | *ent12_p[0];
0130     spin_unlock(&fat12_entry_lock);
0131 
0132     next &= 0x0fff;
0133     if (next >= BAD_FAT12)
0134         next = FAT_ENT_EOF;
0135     return next;
0136 }
0137 
0138 static int fat16_ent_get(struct fat_entry *fatent)
0139 {
0140     int next = le16_to_cpu(*fatent->u.ent16_p);
0141     WARN_ON((unsigned long)fatent->u.ent16_p & (2 - 1));
0142     if (next >= BAD_FAT16)
0143         next = FAT_ENT_EOF;
0144     return next;
0145 }
0146 
0147 static int fat32_ent_get(struct fat_entry *fatent)
0148 {
0149     int next = le32_to_cpu(*fatent->u.ent32_p) & 0x0fffffff;
0150     WARN_ON((unsigned long)fatent->u.ent32_p & (4 - 1));
0151     if (next >= BAD_FAT32)
0152         next = FAT_ENT_EOF;
0153     return next;
0154 }
0155 
0156 static void fat12_ent_put(struct fat_entry *fatent, int new)
0157 {
0158     u8 **ent12_p = fatent->u.ent12_p;
0159 
0160     if (new == FAT_ENT_EOF)
0161         new = EOF_FAT12;
0162 
0163     spin_lock(&fat12_entry_lock);
0164     if (fatent->entry & 1) {
0165         *ent12_p[0] = (new << 4) | (*ent12_p[0] & 0x0f);
0166         *ent12_p[1] = new >> 4;
0167     } else {
0168         *ent12_p[0] = new & 0xff;
0169         *ent12_p[1] = (*ent12_p[1] & 0xf0) | (new >> 8);
0170     }
0171     spin_unlock(&fat12_entry_lock);
0172 
0173     mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
0174     if (fatent->nr_bhs == 2)
0175         mark_buffer_dirty_inode(fatent->bhs[1], fatent->fat_inode);
0176 }
0177 
0178 static void fat16_ent_put(struct fat_entry *fatent, int new)
0179 {
0180     if (new == FAT_ENT_EOF)
0181         new = EOF_FAT16;
0182 
0183     *fatent->u.ent16_p = cpu_to_le16(new);
0184     mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
0185 }
0186 
0187 static void fat32_ent_put(struct fat_entry *fatent, int new)
0188 {
0189     WARN_ON(new & 0xf0000000);
0190     new |= le32_to_cpu(*fatent->u.ent32_p) & ~0x0fffffff;
0191     *fatent->u.ent32_p = cpu_to_le32(new);
0192     mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
0193 }
0194 
0195 static int fat12_ent_next(struct fat_entry *fatent)
0196 {
0197     u8 **ent12_p = fatent->u.ent12_p;
0198     struct buffer_head **bhs = fatent->bhs;
0199     u8 *nextp = ent12_p[1] + 1 + (fatent->entry & 1);
0200 
0201     fatent->entry++;
0202     if (fatent->nr_bhs == 1) {
0203         WARN_ON(ent12_p[0] > (u8 *)(bhs[0]->b_data +
0204                             (bhs[0]->b_size - 2)));
0205         WARN_ON(ent12_p[1] > (u8 *)(bhs[0]->b_data +
0206                             (bhs[0]->b_size - 1)));
0207         if (nextp < (u8 *)(bhs[0]->b_data + (bhs[0]->b_size - 1))) {
0208             ent12_p[0] = nextp - 1;
0209             ent12_p[1] = nextp;
0210             return 1;
0211         }
0212     } else {
0213         WARN_ON(ent12_p[0] != (u8 *)(bhs[0]->b_data +
0214                             (bhs[0]->b_size - 1)));
0215         WARN_ON(ent12_p[1] != (u8 *)bhs[1]->b_data);
0216         ent12_p[0] = nextp - 1;
0217         ent12_p[1] = nextp;
0218         brelse(bhs[0]);
0219         bhs[0] = bhs[1];
0220         fatent->nr_bhs = 1;
0221         return 1;
0222     }
0223     ent12_p[0] = NULL;
0224     ent12_p[1] = NULL;
0225     return 0;
0226 }
0227 
0228 static int fat16_ent_next(struct fat_entry *fatent)
0229 {
0230     const struct buffer_head *bh = fatent->bhs[0];
0231     fatent->entry++;
0232     if (fatent->u.ent16_p < (__le16 *)(bh->b_data + (bh->b_size - 2))) {
0233         fatent->u.ent16_p++;
0234         return 1;
0235     }
0236     fatent->u.ent16_p = NULL;
0237     return 0;
0238 }
0239 
0240 static int fat32_ent_next(struct fat_entry *fatent)
0241 {
0242     const struct buffer_head *bh = fatent->bhs[0];
0243     fatent->entry++;
0244     if (fatent->u.ent32_p < (__le32 *)(bh->b_data + (bh->b_size - 4))) {
0245         fatent->u.ent32_p++;
0246         return 1;
0247     }
0248     fatent->u.ent32_p = NULL;
0249     return 0;
0250 }
0251 
0252 static const struct fatent_operations fat12_ops = {
0253     .ent_blocknr    = fat12_ent_blocknr,
0254     .ent_set_ptr    = fat12_ent_set_ptr,
0255     .ent_bread  = fat12_ent_bread,
0256     .ent_get    = fat12_ent_get,
0257     .ent_put    = fat12_ent_put,
0258     .ent_next   = fat12_ent_next,
0259 };
0260 
0261 static const struct fatent_operations fat16_ops = {
0262     .ent_blocknr    = fat_ent_blocknr,
0263     .ent_set_ptr    = fat16_ent_set_ptr,
0264     .ent_bread  = fat_ent_bread,
0265     .ent_get    = fat16_ent_get,
0266     .ent_put    = fat16_ent_put,
0267     .ent_next   = fat16_ent_next,
0268 };
0269 
0270 static const struct fatent_operations fat32_ops = {
0271     .ent_blocknr    = fat_ent_blocknr,
0272     .ent_set_ptr    = fat32_ent_set_ptr,
0273     .ent_bread  = fat_ent_bread,
0274     .ent_get    = fat32_ent_get,
0275     .ent_put    = fat32_ent_put,
0276     .ent_next   = fat32_ent_next,
0277 };
0278 
0279 static inline void lock_fat(struct msdos_sb_info *sbi)
0280 {
0281     mutex_lock(&sbi->fat_lock);
0282 }
0283 
0284 static inline void unlock_fat(struct msdos_sb_info *sbi)
0285 {
0286     mutex_unlock(&sbi->fat_lock);
0287 }
0288 
0289 void fat_ent_access_init(struct super_block *sb)
0290 {
0291     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0292 
0293     mutex_init(&sbi->fat_lock);
0294 
0295     if (is_fat32(sbi)) {
0296         sbi->fatent_shift = 2;
0297         sbi->fatent_ops = &fat32_ops;
0298     } else if (is_fat16(sbi)) {
0299         sbi->fatent_shift = 1;
0300         sbi->fatent_ops = &fat16_ops;
0301     } else if (is_fat12(sbi)) {
0302         sbi->fatent_shift = -1;
0303         sbi->fatent_ops = &fat12_ops;
0304     } else {
0305         fat_fs_error(sb, "invalid FAT variant, %u bits", sbi->fat_bits);
0306     }
0307 }
0308 
0309 static void mark_fsinfo_dirty(struct super_block *sb)
0310 {
0311     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0312 
0313     if (sb_rdonly(sb) || !is_fat32(sbi))
0314         return;
0315 
0316     __mark_inode_dirty(sbi->fsinfo_inode, I_DIRTY_SYNC);
0317 }
0318 
0319 static inline int fat_ent_update_ptr(struct super_block *sb,
0320                      struct fat_entry *fatent,
0321                      int offset, sector_t blocknr)
0322 {
0323     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0324     const struct fatent_operations *ops = sbi->fatent_ops;
0325     struct buffer_head **bhs = fatent->bhs;
0326 
0327     /* Is this fatent's blocks including this entry? */
0328     if (!fatent->nr_bhs || bhs[0]->b_blocknr != blocknr)
0329         return 0;
0330     if (is_fat12(sbi)) {
0331         if ((offset + 1) < sb->s_blocksize) {
0332             /* This entry is on bhs[0]. */
0333             if (fatent->nr_bhs == 2) {
0334                 brelse(bhs[1]);
0335                 fatent->nr_bhs = 1;
0336             }
0337         } else {
0338             /* This entry needs the next block. */
0339             if (fatent->nr_bhs != 2)
0340                 return 0;
0341             if (bhs[1]->b_blocknr != (blocknr + 1))
0342                 return 0;
0343         }
0344     }
0345     ops->ent_set_ptr(fatent, offset);
0346     return 1;
0347 }
0348 
0349 int fat_ent_read(struct inode *inode, struct fat_entry *fatent, int entry)
0350 {
0351     struct super_block *sb = inode->i_sb;
0352     struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
0353     const struct fatent_operations *ops = sbi->fatent_ops;
0354     int err, offset;
0355     sector_t blocknr;
0356 
0357     if (!fat_valid_entry(sbi, entry)) {
0358         fatent_brelse(fatent);
0359         fat_fs_error(sb, "invalid access to FAT (entry 0x%08x)", entry);
0360         return -EIO;
0361     }
0362 
0363     fatent_set_entry(fatent, entry);
0364     ops->ent_blocknr(sb, entry, &offset, &blocknr);
0365 
0366     if (!fat_ent_update_ptr(sb, fatent, offset, blocknr)) {
0367         fatent_brelse(fatent);
0368         err = ops->ent_bread(sb, fatent, offset, blocknr);
0369         if (err)
0370             return err;
0371     }
0372     return ops->ent_get(fatent);
0373 }
0374 
0375 /* FIXME: We can write the blocks as more big chunk. */
0376 static int fat_mirror_bhs(struct super_block *sb, struct buffer_head **bhs,
0377               int nr_bhs)
0378 {
0379     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0380     struct buffer_head *c_bh;
0381     int err, n, copy;
0382 
0383     err = 0;
0384     for (copy = 1; copy < sbi->fats; copy++) {
0385         sector_t backup_fat = sbi->fat_length * copy;
0386 
0387         for (n = 0; n < nr_bhs; n++) {
0388             c_bh = sb_getblk(sb, backup_fat + bhs[n]->b_blocknr);
0389             if (!c_bh) {
0390                 err = -ENOMEM;
0391                 goto error;
0392             }
0393             /* Avoid race with userspace read via bdev */
0394             lock_buffer(c_bh);
0395             memcpy(c_bh->b_data, bhs[n]->b_data, sb->s_blocksize);
0396             set_buffer_uptodate(c_bh);
0397             unlock_buffer(c_bh);
0398             mark_buffer_dirty_inode(c_bh, sbi->fat_inode);
0399             if (sb->s_flags & SB_SYNCHRONOUS)
0400                 err = sync_dirty_buffer(c_bh);
0401             brelse(c_bh);
0402             if (err)
0403                 goto error;
0404         }
0405     }
0406 error:
0407     return err;
0408 }
0409 
0410 int fat_ent_write(struct inode *inode, struct fat_entry *fatent,
0411           int new, int wait)
0412 {
0413     struct super_block *sb = inode->i_sb;
0414     const struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;
0415     int err;
0416 
0417     ops->ent_put(fatent, new);
0418     if (wait) {
0419         err = fat_sync_bhs(fatent->bhs, fatent->nr_bhs);
0420         if (err)
0421             return err;
0422     }
0423     return fat_mirror_bhs(sb, fatent->bhs, fatent->nr_bhs);
0424 }
0425 
0426 static inline int fat_ent_next(struct msdos_sb_info *sbi,
0427                    struct fat_entry *fatent)
0428 {
0429     if (sbi->fatent_ops->ent_next(fatent)) {
0430         if (fatent->entry < sbi->max_cluster)
0431             return 1;
0432     }
0433     return 0;
0434 }
0435 
0436 static inline int fat_ent_read_block(struct super_block *sb,
0437                      struct fat_entry *fatent)
0438 {
0439     const struct fatent_operations *ops = MSDOS_SB(sb)->fatent_ops;
0440     sector_t blocknr;
0441     int offset;
0442 
0443     fatent_brelse(fatent);
0444     ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
0445     return ops->ent_bread(sb, fatent, offset, blocknr);
0446 }
0447 
0448 static void fat_collect_bhs(struct buffer_head **bhs, int *nr_bhs,
0449                 struct fat_entry *fatent)
0450 {
0451     int n, i;
0452 
0453     for (n = 0; n < fatent->nr_bhs; n++) {
0454         for (i = 0; i < *nr_bhs; i++) {
0455             if (fatent->bhs[n] == bhs[i])
0456                 break;
0457         }
0458         if (i == *nr_bhs) {
0459             get_bh(fatent->bhs[n]);
0460             bhs[i] = fatent->bhs[n];
0461             (*nr_bhs)++;
0462         }
0463     }
0464 }
0465 
0466 int fat_alloc_clusters(struct inode *inode, int *cluster, int nr_cluster)
0467 {
0468     struct super_block *sb = inode->i_sb;
0469     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0470     const struct fatent_operations *ops = sbi->fatent_ops;
0471     struct fat_entry fatent, prev_ent;
0472     struct buffer_head *bhs[MAX_BUF_PER_PAGE];
0473     int i, count, err, nr_bhs, idx_clus;
0474 
0475     BUG_ON(nr_cluster > (MAX_BUF_PER_PAGE / 2));    /* fixed limit */
0476 
0477     lock_fat(sbi);
0478     if (sbi->free_clusters != -1 && sbi->free_clus_valid &&
0479         sbi->free_clusters < nr_cluster) {
0480         unlock_fat(sbi);
0481         return -ENOSPC;
0482     }
0483 
0484     err = nr_bhs = idx_clus = 0;
0485     count = FAT_START_ENT;
0486     fatent_init(&prev_ent);
0487     fatent_init(&fatent);
0488     fatent_set_entry(&fatent, sbi->prev_free + 1);
0489     while (count < sbi->max_cluster) {
0490         if (fatent.entry >= sbi->max_cluster)
0491             fatent.entry = FAT_START_ENT;
0492         fatent_set_entry(&fatent, fatent.entry);
0493         err = fat_ent_read_block(sb, &fatent);
0494         if (err)
0495             goto out;
0496 
0497         /* Find the free entries in a block */
0498         do {
0499             if (ops->ent_get(&fatent) == FAT_ENT_FREE) {
0500                 int entry = fatent.entry;
0501 
0502                 /* make the cluster chain */
0503                 ops->ent_put(&fatent, FAT_ENT_EOF);
0504                 if (prev_ent.nr_bhs)
0505                     ops->ent_put(&prev_ent, entry);
0506 
0507                 fat_collect_bhs(bhs, &nr_bhs, &fatent);
0508 
0509                 sbi->prev_free = entry;
0510                 if (sbi->free_clusters != -1)
0511                     sbi->free_clusters--;
0512 
0513                 cluster[idx_clus] = entry;
0514                 idx_clus++;
0515                 if (idx_clus == nr_cluster)
0516                     goto out;
0517 
0518                 /*
0519                  * fat_collect_bhs() gets ref-count of bhs,
0520                  * so we can still use the prev_ent.
0521                  */
0522                 prev_ent = fatent;
0523             }
0524             count++;
0525             if (count == sbi->max_cluster)
0526                 break;
0527         } while (fat_ent_next(sbi, &fatent));
0528     }
0529 
0530     /* Couldn't allocate the free entries */
0531     sbi->free_clusters = 0;
0532     sbi->free_clus_valid = 1;
0533     err = -ENOSPC;
0534 
0535 out:
0536     unlock_fat(sbi);
0537     mark_fsinfo_dirty(sb);
0538     fatent_brelse(&fatent);
0539     if (!err) {
0540         if (inode_needs_sync(inode))
0541             err = fat_sync_bhs(bhs, nr_bhs);
0542         if (!err)
0543             err = fat_mirror_bhs(sb, bhs, nr_bhs);
0544     }
0545     for (i = 0; i < nr_bhs; i++)
0546         brelse(bhs[i]);
0547 
0548     if (err && idx_clus)
0549         fat_free_clusters(inode, cluster[0]);
0550 
0551     return err;
0552 }
0553 
0554 int fat_free_clusters(struct inode *inode, int cluster)
0555 {
0556     struct super_block *sb = inode->i_sb;
0557     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0558     const struct fatent_operations *ops = sbi->fatent_ops;
0559     struct fat_entry fatent;
0560     struct buffer_head *bhs[MAX_BUF_PER_PAGE];
0561     int i, err, nr_bhs;
0562     int first_cl = cluster, dirty_fsinfo = 0;
0563 
0564     nr_bhs = 0;
0565     fatent_init(&fatent);
0566     lock_fat(sbi);
0567     do {
0568         cluster = fat_ent_read(inode, &fatent, cluster);
0569         if (cluster < 0) {
0570             err = cluster;
0571             goto error;
0572         } else if (cluster == FAT_ENT_FREE) {
0573             fat_fs_error(sb, "%s: deleting FAT entry beyond EOF",
0574                      __func__);
0575             err = -EIO;
0576             goto error;
0577         }
0578 
0579         if (sbi->options.discard) {
0580             /*
0581              * Issue discard for the sectors we no longer
0582              * care about, batching contiguous clusters
0583              * into one request
0584              */
0585             if (cluster != fatent.entry + 1) {
0586                 int nr_clus = fatent.entry - first_cl + 1;
0587 
0588                 sb_issue_discard(sb,
0589                     fat_clus_to_blknr(sbi, first_cl),
0590                     nr_clus * sbi->sec_per_clus,
0591                     GFP_NOFS, 0);
0592 
0593                 first_cl = cluster;
0594             }
0595         }
0596 
0597         ops->ent_put(&fatent, FAT_ENT_FREE);
0598         if (sbi->free_clusters != -1) {
0599             sbi->free_clusters++;
0600             dirty_fsinfo = 1;
0601         }
0602 
0603         if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {
0604             if (sb->s_flags & SB_SYNCHRONOUS) {
0605                 err = fat_sync_bhs(bhs, nr_bhs);
0606                 if (err)
0607                     goto error;
0608             }
0609             err = fat_mirror_bhs(sb, bhs, nr_bhs);
0610             if (err)
0611                 goto error;
0612             for (i = 0; i < nr_bhs; i++)
0613                 brelse(bhs[i]);
0614             nr_bhs = 0;
0615         }
0616         fat_collect_bhs(bhs, &nr_bhs, &fatent);
0617     } while (cluster != FAT_ENT_EOF);
0618 
0619     if (sb->s_flags & SB_SYNCHRONOUS) {
0620         err = fat_sync_bhs(bhs, nr_bhs);
0621         if (err)
0622             goto error;
0623     }
0624     err = fat_mirror_bhs(sb, bhs, nr_bhs);
0625 error:
0626     fatent_brelse(&fatent);
0627     for (i = 0; i < nr_bhs; i++)
0628         brelse(bhs[i]);
0629     unlock_fat(sbi);
0630     if (dirty_fsinfo)
0631         mark_fsinfo_dirty(sb);
0632 
0633     return err;
0634 }
0635 EXPORT_SYMBOL_GPL(fat_free_clusters);
0636 
0637 struct fatent_ra {
0638     sector_t cur;
0639     sector_t limit;
0640 
0641     unsigned int ra_blocks;
0642     sector_t ra_advance;
0643     sector_t ra_next;
0644     sector_t ra_limit;
0645 };
0646 
0647 static void fat_ra_init(struct super_block *sb, struct fatent_ra *ra,
0648             struct fat_entry *fatent, int ent_limit)
0649 {
0650     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0651     const struct fatent_operations *ops = sbi->fatent_ops;
0652     sector_t blocknr, block_end;
0653     int offset;
0654     /*
0655      * This is the sequential read, so ra_pages * 2 (but try to
0656      * align the optimal hardware IO size).
0657      * [BTW, 128kb covers the whole sectors for FAT12 and FAT16]
0658      */
0659     unsigned long ra_pages = sb->s_bdi->ra_pages;
0660     unsigned int reada_blocks;
0661 
0662     if (fatent->entry >= ent_limit)
0663         return;
0664 
0665     if (ra_pages > sb->s_bdi->io_pages)
0666         ra_pages = rounddown(ra_pages, sb->s_bdi->io_pages);
0667     reada_blocks = ra_pages << (PAGE_SHIFT - sb->s_blocksize_bits + 1);
0668 
0669     /* Initialize the range for sequential read */
0670     ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
0671     ops->ent_blocknr(sb, ent_limit - 1, &offset, &block_end);
0672     ra->cur = 0;
0673     ra->limit = (block_end + 1) - blocknr;
0674 
0675     /* Advancing the window at half size */
0676     ra->ra_blocks = reada_blocks >> 1;
0677     ra->ra_advance = ra->cur;
0678     ra->ra_next = ra->cur;
0679     ra->ra_limit = ra->cur + min_t(sector_t, reada_blocks, ra->limit);
0680 }
0681 
0682 /* Assuming to be called before reading a new block (increments ->cur). */
0683 static void fat_ent_reada(struct super_block *sb, struct fatent_ra *ra,
0684               struct fat_entry *fatent)
0685 {
0686     if (ra->ra_next >= ra->ra_limit)
0687         return;
0688 
0689     if (ra->cur >= ra->ra_advance) {
0690         struct msdos_sb_info *sbi = MSDOS_SB(sb);
0691         const struct fatent_operations *ops = sbi->fatent_ops;
0692         struct blk_plug plug;
0693         sector_t blocknr, diff;
0694         int offset;
0695 
0696         ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
0697 
0698         diff = blocknr - ra->cur;
0699         blk_start_plug(&plug);
0700         /*
0701          * FIXME: we would want to directly use the bio with
0702          * pages to reduce the number of segments.
0703          */
0704         for (; ra->ra_next < ra->ra_limit; ra->ra_next++)
0705             sb_breadahead(sb, ra->ra_next + diff);
0706         blk_finish_plug(&plug);
0707 
0708         /* Advance the readahead window */
0709         ra->ra_advance += ra->ra_blocks;
0710         ra->ra_limit += min_t(sector_t,
0711                       ra->ra_blocks, ra->limit - ra->ra_limit);
0712     }
0713     ra->cur++;
0714 }
0715 
0716 int fat_count_free_clusters(struct super_block *sb)
0717 {
0718     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0719     const struct fatent_operations *ops = sbi->fatent_ops;
0720     struct fat_entry fatent;
0721     struct fatent_ra fatent_ra;
0722     int err = 0, free;
0723 
0724     lock_fat(sbi);
0725     if (sbi->free_clusters != -1 && sbi->free_clus_valid)
0726         goto out;
0727 
0728     free = 0;
0729     fatent_init(&fatent);
0730     fatent_set_entry(&fatent, FAT_START_ENT);
0731     fat_ra_init(sb, &fatent_ra, &fatent, sbi->max_cluster);
0732     while (fatent.entry < sbi->max_cluster) {
0733         /* readahead of fat blocks */
0734         fat_ent_reada(sb, &fatent_ra, &fatent);
0735 
0736         err = fat_ent_read_block(sb, &fatent);
0737         if (err)
0738             goto out;
0739 
0740         do {
0741             if (ops->ent_get(&fatent) == FAT_ENT_FREE)
0742                 free++;
0743         } while (fat_ent_next(sbi, &fatent));
0744         cond_resched();
0745     }
0746     sbi->free_clusters = free;
0747     sbi->free_clus_valid = 1;
0748     mark_fsinfo_dirty(sb);
0749     fatent_brelse(&fatent);
0750 out:
0751     unlock_fat(sbi);
0752     return err;
0753 }
0754 
0755 static int fat_trim_clusters(struct super_block *sb, u32 clus, u32 nr_clus)
0756 {
0757     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0758     return sb_issue_discard(sb, fat_clus_to_blknr(sbi, clus),
0759                 nr_clus * sbi->sec_per_clus, GFP_NOFS, 0);
0760 }
0761 
0762 int fat_trim_fs(struct inode *inode, struct fstrim_range *range)
0763 {
0764     struct super_block *sb = inode->i_sb;
0765     struct msdos_sb_info *sbi = MSDOS_SB(sb);
0766     const struct fatent_operations *ops = sbi->fatent_ops;
0767     struct fat_entry fatent;
0768     struct fatent_ra fatent_ra;
0769     u64 ent_start, ent_end, minlen, trimmed = 0;
0770     u32 free = 0;
0771     int err = 0;
0772 
0773     /*
0774      * FAT data is organized as clusters, trim at the granulary of cluster.
0775      *
0776      * fstrim_range is in byte, convert values to cluster index.
0777      * Treat sectors before data region as all used, not to trim them.
0778      */
0779     ent_start = max_t(u64, range->start>>sbi->cluster_bits, FAT_START_ENT);
0780     ent_end = ent_start + (range->len >> sbi->cluster_bits) - 1;
0781     minlen = range->minlen >> sbi->cluster_bits;
0782 
0783     if (ent_start >= sbi->max_cluster || range->len < sbi->cluster_size)
0784         return -EINVAL;
0785     if (ent_end >= sbi->max_cluster)
0786         ent_end = sbi->max_cluster - 1;
0787 
0788     fatent_init(&fatent);
0789     lock_fat(sbi);
0790     fatent_set_entry(&fatent, ent_start);
0791     fat_ra_init(sb, &fatent_ra, &fatent, ent_end + 1);
0792     while (fatent.entry <= ent_end) {
0793         /* readahead of fat blocks */
0794         fat_ent_reada(sb, &fatent_ra, &fatent);
0795 
0796         err = fat_ent_read_block(sb, &fatent);
0797         if (err)
0798             goto error;
0799         do {
0800             if (ops->ent_get(&fatent) == FAT_ENT_FREE) {
0801                 free++;
0802             } else if (free) {
0803                 if (free >= minlen) {
0804                     u32 clus = fatent.entry - free;
0805 
0806                     err = fat_trim_clusters(sb, clus, free);
0807                     if (err && err != -EOPNOTSUPP)
0808                         goto error;
0809                     if (!err)
0810                         trimmed += free;
0811                     err = 0;
0812                 }
0813                 free = 0;
0814             }
0815         } while (fat_ent_next(sbi, &fatent) && fatent.entry <= ent_end);
0816 
0817         if (fatal_signal_pending(current)) {
0818             err = -ERESTARTSYS;
0819             goto error;
0820         }
0821 
0822         if (need_resched()) {
0823             fatent_brelse(&fatent);
0824             unlock_fat(sbi);
0825             cond_resched();
0826             lock_fat(sbi);
0827         }
0828     }
0829     /* handle scenario when tail entries are all free */
0830     if (free && free >= minlen) {
0831         u32 clus = fatent.entry - free;
0832 
0833         err = fat_trim_clusters(sb, clus, free);
0834         if (err && err != -EOPNOTSUPP)
0835             goto error;
0836         if (!err)
0837             trimmed += free;
0838         err = 0;
0839     }
0840 
0841 error:
0842     fatent_brelse(&fatent);
0843     unlock_fat(sbi);
0844 
0845     range->len = trimmed << sbi->cluster_bits;
0846 
0847     return err;
0848 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!