1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2004, OGAWA Hirofumi
6 #include <linux/blkdev.h>
7 #include <linux/sched/signal.h>
10 struct 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
*,
15 int (*ent_get
)(struct fat_entry
*);
16 void (*ent_put
)(struct fat_entry
*, int);
17 int (*ent_next
)(struct fat_entry
*);
20 static DEFINE_SPINLOCK(fat12_entry_lock
);
22 static void fat12_ent_blocknr(struct super_block
*sb
, int entry
,
23 int *offset
, sector_t
*blocknr
)
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
);
32 static void fat_ent_blocknr(struct super_block
*sb
, int entry
,
33 int *offset
, sector_t
*blocknr
)
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
);
42 static void fat12_ent_set_ptr(struct fat_entry
*fatent
, int offset
)
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);
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
;
56 static void fat16_ent_set_ptr(struct fat_entry
*fatent
, int offset
)
58 WARN_ON(offset
& (2 - 1));
59 fatent
->u
.ent16_p
= (__le16
*)(fatent
->bhs
[0]->b_data
+ offset
);
62 static void fat32_ent_set_ptr(struct fat_entry
*fatent
, int offset
)
64 WARN_ON(offset
& (4 - 1));
65 fatent
->u
.ent32_p
= (__le32
*)(fatent
->bhs
[0]->b_data
+ offset
);
68 static int fat12_ent_bread(struct super_block
*sb
, struct fat_entry
*fatent
,
69 int offset
, sector_t blocknr
)
71 struct buffer_head
**bhs
= fatent
->bhs
;
73 WARN_ON(blocknr
< MSDOS_SB(sb
)->fat_start
);
74 fatent
->fat_inode
= MSDOS_SB(sb
)->fat_inode
;
76 bhs
[0] = sb_bread(sb
, blocknr
);
80 if ((offset
+ 1) < sb
->s_blocksize
)
83 /* This entry is block boundary, it needs the next block */
85 bhs
[1] = sb_bread(sb
, blocknr
);
90 fat12_ent_set_ptr(fatent
, offset
);
96 fat_msg(sb
, KERN_ERR
, "FAT read failed (blocknr %llu)", (llu
)blocknr
);
100 static int fat_ent_bread(struct super_block
*sb
, struct fat_entry
*fatent
,
101 int offset
, sector_t blocknr
)
103 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
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)",
114 ops
->ent_set_ptr(fatent
, offset
);
118 static int fat12_ent_get(struct fat_entry
*fatent
)
120 u8
**ent12_p
= fatent
->u
.ent12_p
;
123 spin_lock(&fat12_entry_lock
);
124 if (fatent
->entry
& 1)
125 next
= (*ent12_p
[0] >> 4) | (*ent12_p
[1] << 4);
127 next
= (*ent12_p
[1] << 8) | *ent12_p
[0];
128 spin_unlock(&fat12_entry_lock
);
131 if (next
>= BAD_FAT12
)
136 static int fat16_ent_get(struct fat_entry
*fatent
)
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
)
145 static int fat32_ent_get(struct fat_entry
*fatent
)
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
)
154 static void fat12_ent_put(struct fat_entry
*fatent
, int new)
156 u8
**ent12_p
= fatent
->u
.ent12_p
;
158 if (new == FAT_ENT_EOF
)
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;
166 *ent12_p
[0] = new & 0xff;
167 *ent12_p
[1] = (*ent12_p
[1] & 0xf0) | (new >> 8);
169 spin_unlock(&fat12_entry_lock
);
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
);
176 static void fat16_ent_put(struct fat_entry
*fatent
, int new)
178 if (new == FAT_ENT_EOF
)
181 *fatent
->u
.ent16_p
= cpu_to_le16(new);
182 mark_buffer_dirty_inode(fatent
->bhs
[0], fatent
->fat_inode
);
185 static void fat32_ent_put(struct fat_entry
*fatent
, int new)
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
);
193 static int fat12_ent_next(struct fat_entry
*fatent
)
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);
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;
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;
226 static int fat16_ent_next(struct fat_entry
*fatent
)
228 const struct buffer_head
*bh
= fatent
->bhs
[0];
230 if (fatent
->u
.ent16_p
< (__le16
*)(bh
->b_data
+ (bh
->b_size
- 2))) {
234 fatent
->u
.ent16_p
= NULL
;
238 static int fat32_ent_next(struct fat_entry
*fatent
)
240 const struct buffer_head
*bh
= fatent
->bhs
[0];
242 if (fatent
->u
.ent32_p
< (__le32
*)(bh
->b_data
+ (bh
->b_size
- 4))) {
246 fatent
->u
.ent32_p
= NULL
;
250 static 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
,
259 static 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
,
268 static 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
,
277 static inline void lock_fat(struct msdos_sb_info
*sbi
)
279 mutex_lock(&sbi
->fat_lock
);
282 static inline void unlock_fat(struct msdos_sb_info
*sbi
)
284 mutex_unlock(&sbi
->fat_lock
);
287 void fat_ent_access_init(struct super_block
*sb
)
289 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
291 mutex_init(&sbi
->fat_lock
);
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
;
303 fat_fs_error(sb
, "invalid FAT variant, %u bits", sbi
->fat_bits
);
307 static void mark_fsinfo_dirty(struct super_block
*sb
)
309 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
311 if (sb_rdonly(sb
) || !is_fat32(sbi
))
314 __mark_inode_dirty(sbi
->fsinfo_inode
, I_DIRTY_SYNC
);
317 static inline int fat_ent_update_ptr(struct super_block
*sb
,
318 struct fat_entry
*fatent
,
319 int offset
, sector_t blocknr
)
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
;
325 /* Is this fatent's blocks including this entry? */
326 if (!fatent
->nr_bhs
|| bhs
[0]->b_blocknr
!= blocknr
)
329 if ((offset
+ 1) < sb
->s_blocksize
) {
330 /* This entry is on bhs[0]. */
331 if (fatent
->nr_bhs
== 2) {
336 /* This entry needs the next block. */
337 if (fatent
->nr_bhs
!= 2)
339 if (bhs
[1]->b_blocknr
!= (blocknr
+ 1))
343 ops
->ent_set_ptr(fatent
, offset
);
347 int fat_ent_read(struct inode
*inode
, struct fat_entry
*fatent
, int entry
)
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
;
355 if (!fat_valid_entry(sbi
, entry
)) {
356 fatent_brelse(fatent
);
357 fat_fs_error(sb
, "invalid access to FAT (entry 0x%08x)", entry
);
361 fatent_set_entry(fatent
, entry
);
362 ops
->ent_blocknr(sb
, entry
, &offset
, &blocknr
);
364 if (!fat_ent_update_ptr(sb
, fatent
, offset
, blocknr
)) {
365 fatent_brelse(fatent
);
366 err
= ops
->ent_bread(sb
, fatent
, offset
, blocknr
);
370 return ops
->ent_get(fatent
);
373 /* FIXME: We can write the blocks as more big chunk. */
374 static int fat_mirror_bhs(struct super_block
*sb
, struct buffer_head
**bhs
,
377 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
378 struct buffer_head
*c_bh
;
382 for (copy
= 1; copy
< sbi
->fats
; copy
++) {
383 sector_t backup_fat
= sbi
->fat_length
* copy
;
385 for (n
= 0; n
< nr_bhs
; n
++) {
386 c_bh
= sb_getblk(sb
, backup_fat
+ bhs
[n
]->b_blocknr
);
391 /* Avoid race with userspace read via bdev */
393 memcpy(c_bh
->b_data
, bhs
[n
]->b_data
, sb
->s_blocksize
);
394 set_buffer_uptodate(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
);
408 int fat_ent_write(struct inode
*inode
, struct fat_entry
*fatent
,
411 struct super_block
*sb
= inode
->i_sb
;
412 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
415 ops
->ent_put(fatent
, new);
417 err
= fat_sync_bhs(fatent
->bhs
, fatent
->nr_bhs
);
421 return fat_mirror_bhs(sb
, fatent
->bhs
, fatent
->nr_bhs
);
424 static inline int fat_ent_next(struct msdos_sb_info
*sbi
,
425 struct fat_entry
*fatent
)
427 if (sbi
->fatent_ops
->ent_next(fatent
)) {
428 if (fatent
->entry
< sbi
->max_cluster
)
434 static inline int fat_ent_read_block(struct super_block
*sb
,
435 struct fat_entry
*fatent
)
437 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
441 fatent_brelse(fatent
);
442 ops
->ent_blocknr(sb
, fatent
->entry
, &offset
, &blocknr
);
443 return ops
->ent_bread(sb
, fatent
, offset
, blocknr
);
446 static void fat_collect_bhs(struct buffer_head
**bhs
, int *nr_bhs
,
447 struct fat_entry
*fatent
)
451 for (n
= 0; n
< fatent
->nr_bhs
; n
++) {
452 for (i
= 0; i
< *nr_bhs
; i
++) {
453 if (fatent
->bhs
[n
] == bhs
[i
])
457 get_bh(fatent
->bhs
[n
]);
458 bhs
[i
] = fatent
->bhs
[n
];
464 int fat_alloc_clusters(struct inode
*inode
, int *cluster
, int nr_cluster
)
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
;
473 BUG_ON(nr_cluster
> (MAX_BUF_PER_PAGE
/ 2)); /* fixed limit */
476 if (sbi
->free_clusters
!= -1 && sbi
->free_clus_valid
&&
477 sbi
->free_clusters
< nr_cluster
) {
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
);
495 /* Find the free entries in a block */
497 if (ops
->ent_get(&fatent
) == FAT_ENT_FREE
) {
498 int entry
= fatent
.entry
;
500 /* make the cluster chain */
501 ops
->ent_put(&fatent
, FAT_ENT_EOF
);
503 ops
->ent_put(&prev_ent
, entry
);
505 fat_collect_bhs(bhs
, &nr_bhs
, &fatent
);
507 sbi
->prev_free
= entry
;
508 if (sbi
->free_clusters
!= -1)
509 sbi
->free_clusters
--;
511 cluster
[idx_clus
] = entry
;
513 if (idx_clus
== nr_cluster
)
517 * fat_collect_bhs() gets ref-count of bhs,
518 * so we can still use the prev_ent.
523 if (count
== sbi
->max_cluster
)
525 } while (fat_ent_next(sbi
, &fatent
));
528 /* Couldn't allocate the free entries */
529 sbi
->free_clusters
= 0;
530 sbi
->free_clus_valid
= 1;
535 mark_fsinfo_dirty(sb
);
536 fatent_brelse(&fatent
);
538 if (inode_needs_sync(inode
))
539 err
= fat_sync_bhs(bhs
, nr_bhs
);
541 err
= fat_mirror_bhs(sb
, bhs
, nr_bhs
);
543 for (i
= 0; i
< nr_bhs
; i
++)
547 fat_free_clusters(inode
, cluster
[0]);
552 int fat_free_clusters(struct inode
*inode
, int cluster
)
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
];
560 int first_cl
= cluster
, dirty_fsinfo
= 0;
563 fatent_init(&fatent
);
566 cluster
= fat_ent_read(inode
, &fatent
, cluster
);
570 } else if (cluster
== FAT_ENT_FREE
) {
571 fat_fs_error(sb
, "%s: deleting FAT entry beyond EOF",
577 if (sbi
->options
.discard
) {
579 * Issue discard for the sectors we no longer
580 * care about, batching contiguous clusters
583 if (cluster
!= fatent
.entry
+ 1) {
584 int nr_clus
= fatent
.entry
- first_cl
+ 1;
587 fat_clus_to_blknr(sbi
, first_cl
),
588 nr_clus
* sbi
->sec_per_clus
,
595 ops
->ent_put(&fatent
, FAT_ENT_FREE
);
596 if (sbi
->free_clusters
!= -1) {
597 sbi
->free_clusters
++;
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
);
607 err
= fat_mirror_bhs(sb
, bhs
, nr_bhs
);
610 for (i
= 0; i
< nr_bhs
; i
++)
614 fat_collect_bhs(bhs
, &nr_bhs
, &fatent
);
615 } while (cluster
!= FAT_ENT_EOF
);
617 if (sb
->s_flags
& SB_SYNCHRONOUS
) {
618 err
= fat_sync_bhs(bhs
, nr_bhs
);
622 err
= fat_mirror_bhs(sb
, bhs
, nr_bhs
);
624 fatent_brelse(&fatent
);
625 for (i
= 0; i
< nr_bhs
; i
++)
629 mark_fsinfo_dirty(sb
);
633 EXPORT_SYMBOL_GPL(fat_free_clusters
);
635 /* 128kb is the whole sectors for FAT12 and FAT16 */
636 #define FAT_READA_SIZE (128 * 1024)
638 static void fat_ent_reada(struct super_block
*sb
, struct fat_entry
*fatent
,
639 unsigned long reada_blocks
)
641 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
645 ops
->ent_blocknr(sb
, fatent
->entry
, &offset
, &blocknr
);
647 for (i
= 0; i
< reada_blocks
; i
++)
648 sb_breadahead(sb
, blocknr
+ i
);
651 int fat_count_free_clusters(struct super_block
*sb
)
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
;
660 if (sbi
->free_clusters
!= -1 && sbi
->free_clus_valid
)
663 reada_blocks
= FAT_READA_SIZE
>> sb
->s_blocksize_bits
;
664 reada_mask
= reada_blocks
- 1;
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
));
678 err
= fat_ent_read_block(sb
, &fatent
);
683 if (ops
->ent_get(&fatent
) == FAT_ENT_FREE
)
685 } while (fat_ent_next(sbi
, &fatent
));
688 sbi
->free_clusters
= free
;
689 sbi
->free_clus_valid
= 1;
690 mark_fsinfo_dirty(sb
);
691 fatent_brelse(&fatent
);
697 static int fat_trim_clusters(struct super_block
*sb
, u32 clus
, u32 nr_clus
)
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);
704 int fat_trim_fs(struct inode
*inode
, struct fstrim_range
*range
)
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;
712 unsigned long reada_blocks
, reada_mask
, cur_block
= 0;
716 * FAT data is organized as clusters, trim at the granulary of cluster.
718 * fstrim_range is in byte, convert vaules to cluster index.
719 * Treat sectors before data region as all used, not to trim them.
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
;
725 if (ent_start
>= sbi
->max_cluster
|| range
->len
< sbi
->cluster_size
)
727 if (ent_end
>= sbi
->max_cluster
)
728 ent_end
= sbi
->max_cluster
- 1;
730 reada_blocks
= FAT_READA_SIZE
>> sb
->s_blocksize_bits
;
731 reada_mask
= reada_blocks
- 1;
733 fatent_init(&fatent
);
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
));
744 err
= fat_ent_read_block(sb
, &fatent
);
748 if (ops
->ent_get(&fatent
) == FAT_ENT_FREE
) {
751 if (free
>= minlen
) {
752 u32 clus
= fatent
.entry
- free
;
754 err
= fat_trim_clusters(sb
, clus
, free
);
755 if (err
&& err
!= -EOPNOTSUPP
)
763 } while (fat_ent_next(sbi
, &fatent
) && fatent
.entry
<= ent_end
);
765 if (fatal_signal_pending(current
)) {
770 if (need_resched()) {
771 fatent_brelse(&fatent
);
777 /* handle scenario when tail entries are all free */
778 if (free
&& free
>= minlen
) {
779 u32 clus
= fatent
.entry
- free
;
781 err
= fat_trim_clusters(sb
, clus
, free
);
782 if (err
&& err
!= -EOPNOTSUPP
)
790 fatent_brelse(&fatent
);
793 range
->len
= trimmed
<< sbi
->cluster_bits
;