2 * Copyright (C) 2004, OGAWA Hirofumi
3 * Released under GPL v2.
6 #include <linux/blkdev.h>
9 struct fatent_operations
{
10 void (*ent_blocknr
)(struct super_block
*, int, int *, sector_t
*);
11 void (*ent_set_ptr
)(struct fat_entry
*, int);
12 int (*ent_bread
)(struct super_block
*, struct fat_entry
*,
14 int (*ent_get
)(struct fat_entry
*);
15 void (*ent_put
)(struct fat_entry
*, int);
16 int (*ent_next
)(struct fat_entry
*);
19 static DEFINE_SPINLOCK(fat12_entry_lock
);
21 static void fat12_ent_blocknr(struct super_block
*sb
, int entry
,
22 int *offset
, sector_t
*blocknr
)
24 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
25 int bytes
= entry
+ (entry
>> 1);
26 WARN_ON(entry
< FAT_START_ENT
|| sbi
->max_cluster
<= entry
);
27 *offset
= bytes
& (sb
->s_blocksize
- 1);
28 *blocknr
= sbi
->fat_start
+ (bytes
>> sb
->s_blocksize_bits
);
31 static void fat_ent_blocknr(struct super_block
*sb
, int entry
,
32 int *offset
, sector_t
*blocknr
)
34 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
35 int bytes
= (entry
<< sbi
->fatent_shift
);
36 WARN_ON(entry
< FAT_START_ENT
|| sbi
->max_cluster
<= entry
);
37 *offset
= bytes
& (sb
->s_blocksize
- 1);
38 *blocknr
= sbi
->fat_start
+ (bytes
>> sb
->s_blocksize_bits
);
41 static void fat12_ent_set_ptr(struct fat_entry
*fatent
, int offset
)
43 struct buffer_head
**bhs
= fatent
->bhs
;
44 if (fatent
->nr_bhs
== 1) {
45 WARN_ON(offset
>= (bhs
[0]->b_size
- 1));
46 fatent
->u
.ent12_p
[0] = bhs
[0]->b_data
+ offset
;
47 fatent
->u
.ent12_p
[1] = bhs
[0]->b_data
+ (offset
+ 1);
49 WARN_ON(offset
!= (bhs
[0]->b_size
- 1));
50 fatent
->u
.ent12_p
[0] = bhs
[0]->b_data
+ offset
;
51 fatent
->u
.ent12_p
[1] = bhs
[1]->b_data
;
55 static void fat16_ent_set_ptr(struct fat_entry
*fatent
, int offset
)
57 WARN_ON(offset
& (2 - 1));
58 fatent
->u
.ent16_p
= (__le16
*)(fatent
->bhs
[0]->b_data
+ offset
);
61 static void fat32_ent_set_ptr(struct fat_entry
*fatent
, int offset
)
63 WARN_ON(offset
& (4 - 1));
64 fatent
->u
.ent32_p
= (__le32
*)(fatent
->bhs
[0]->b_data
+ offset
);
67 static int fat12_ent_bread(struct super_block
*sb
, struct fat_entry
*fatent
,
68 int offset
, sector_t blocknr
)
70 struct buffer_head
**bhs
= fatent
->bhs
;
72 WARN_ON(blocknr
< MSDOS_SB(sb
)->fat_start
);
73 fatent
->fat_inode
= MSDOS_SB(sb
)->fat_inode
;
75 bhs
[0] = sb_bread(sb
, blocknr
);
79 if ((offset
+ 1) < sb
->s_blocksize
)
82 /* This entry is block boundary, it needs the next block */
84 bhs
[1] = sb_bread(sb
, blocknr
);
89 fat12_ent_set_ptr(fatent
, offset
);
95 fat_msg(sb
, KERN_ERR
, "FAT read failed (blocknr %llu)", (llu
)blocknr
);
99 static int fat_ent_bread(struct super_block
*sb
, struct fat_entry
*fatent
,
100 int offset
, sector_t blocknr
)
102 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
104 WARN_ON(blocknr
< MSDOS_SB(sb
)->fat_start
);
105 fatent
->fat_inode
= MSDOS_SB(sb
)->fat_inode
;
106 fatent
->bhs
[0] = sb_bread(sb
, blocknr
);
107 if (!fatent
->bhs
[0]) {
108 fat_msg(sb
, KERN_ERR
, "FAT read failed (blocknr %llu)",
113 ops
->ent_set_ptr(fatent
, offset
);
117 static int fat12_ent_get(struct fat_entry
*fatent
)
119 u8
**ent12_p
= fatent
->u
.ent12_p
;
122 spin_lock(&fat12_entry_lock
);
123 if (fatent
->entry
& 1)
124 next
= (*ent12_p
[0] >> 4) | (*ent12_p
[1] << 4);
126 next
= (*ent12_p
[1] << 8) | *ent12_p
[0];
127 spin_unlock(&fat12_entry_lock
);
130 if (next
>= BAD_FAT12
)
135 static int fat16_ent_get(struct fat_entry
*fatent
)
137 int next
= le16_to_cpu(*fatent
->u
.ent16_p
);
138 WARN_ON((unsigned long)fatent
->u
.ent16_p
& (2 - 1));
139 if (next
>= BAD_FAT16
)
144 static int fat32_ent_get(struct fat_entry
*fatent
)
146 int next
= le32_to_cpu(*fatent
->u
.ent32_p
) & 0x0fffffff;
147 WARN_ON((unsigned long)fatent
->u
.ent32_p
& (4 - 1));
148 if (next
>= BAD_FAT32
)
153 static void fat12_ent_put(struct fat_entry
*fatent
, int new)
155 u8
**ent12_p
= fatent
->u
.ent12_p
;
157 if (new == FAT_ENT_EOF
)
160 spin_lock(&fat12_entry_lock
);
161 if (fatent
->entry
& 1) {
162 *ent12_p
[0] = (new << 4) | (*ent12_p
[0] & 0x0f);
163 *ent12_p
[1] = new >> 4;
165 *ent12_p
[0] = new & 0xff;
166 *ent12_p
[1] = (*ent12_p
[1] & 0xf0) | (new >> 8);
168 spin_unlock(&fat12_entry_lock
);
170 mark_buffer_dirty_inode(fatent
->bhs
[0], fatent
->fat_inode
);
171 if (fatent
->nr_bhs
== 2)
172 mark_buffer_dirty_inode(fatent
->bhs
[1], fatent
->fat_inode
);
175 static void fat16_ent_put(struct fat_entry
*fatent
, int new)
177 if (new == FAT_ENT_EOF
)
180 *fatent
->u
.ent16_p
= cpu_to_le16(new);
181 mark_buffer_dirty_inode(fatent
->bhs
[0], fatent
->fat_inode
);
184 static void fat32_ent_put(struct fat_entry
*fatent
, int new)
186 WARN_ON(new & 0xf0000000);
187 new |= le32_to_cpu(*fatent
->u
.ent32_p
) & ~0x0fffffff;
188 *fatent
->u
.ent32_p
= cpu_to_le32(new);
189 mark_buffer_dirty_inode(fatent
->bhs
[0], fatent
->fat_inode
);
192 static int fat12_ent_next(struct fat_entry
*fatent
)
194 u8
**ent12_p
= fatent
->u
.ent12_p
;
195 struct buffer_head
**bhs
= fatent
->bhs
;
196 u8
*nextp
= ent12_p
[1] + 1 + (fatent
->entry
& 1);
199 if (fatent
->nr_bhs
== 1) {
200 WARN_ON(ent12_p
[0] > (u8
*)(bhs
[0]->b_data
+
201 (bhs
[0]->b_size
- 2)));
202 WARN_ON(ent12_p
[1] > (u8
*)(bhs
[0]->b_data
+
203 (bhs
[0]->b_size
- 1)));
204 if (nextp
< (u8
*)(bhs
[0]->b_data
+ (bhs
[0]->b_size
- 1))) {
205 ent12_p
[0] = nextp
- 1;
210 WARN_ON(ent12_p
[0] != (u8
*)(bhs
[0]->b_data
+
211 (bhs
[0]->b_size
- 1)));
212 WARN_ON(ent12_p
[1] != (u8
*)bhs
[1]->b_data
);
213 ent12_p
[0] = nextp
- 1;
225 static int fat16_ent_next(struct fat_entry
*fatent
)
227 const struct buffer_head
*bh
= fatent
->bhs
[0];
229 if (fatent
->u
.ent16_p
< (__le16
*)(bh
->b_data
+ (bh
->b_size
- 2))) {
233 fatent
->u
.ent16_p
= NULL
;
237 static int fat32_ent_next(struct fat_entry
*fatent
)
239 const struct buffer_head
*bh
= fatent
->bhs
[0];
241 if (fatent
->u
.ent32_p
< (__le32
*)(bh
->b_data
+ (bh
->b_size
- 4))) {
245 fatent
->u
.ent32_p
= NULL
;
249 static const struct fatent_operations fat12_ops
= {
250 .ent_blocknr
= fat12_ent_blocknr
,
251 .ent_set_ptr
= fat12_ent_set_ptr
,
252 .ent_bread
= fat12_ent_bread
,
253 .ent_get
= fat12_ent_get
,
254 .ent_put
= fat12_ent_put
,
255 .ent_next
= fat12_ent_next
,
258 static const struct fatent_operations fat16_ops
= {
259 .ent_blocknr
= fat_ent_blocknr
,
260 .ent_set_ptr
= fat16_ent_set_ptr
,
261 .ent_bread
= fat_ent_bread
,
262 .ent_get
= fat16_ent_get
,
263 .ent_put
= fat16_ent_put
,
264 .ent_next
= fat16_ent_next
,
267 static const struct fatent_operations fat32_ops
= {
268 .ent_blocknr
= fat_ent_blocknr
,
269 .ent_set_ptr
= fat32_ent_set_ptr
,
270 .ent_bread
= fat_ent_bread
,
271 .ent_get
= fat32_ent_get
,
272 .ent_put
= fat32_ent_put
,
273 .ent_next
= fat32_ent_next
,
276 static inline void lock_fat(struct msdos_sb_info
*sbi
)
278 mutex_lock(&sbi
->fat_lock
);
281 static inline void unlock_fat(struct msdos_sb_info
*sbi
)
283 mutex_unlock(&sbi
->fat_lock
);
286 void fat_ent_access_init(struct super_block
*sb
)
288 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
290 mutex_init(&sbi
->fat_lock
);
292 switch (sbi
->fat_bits
) {
294 sbi
->fatent_shift
= 2;
295 sbi
->fatent_ops
= &fat32_ops
;
298 sbi
->fatent_shift
= 1;
299 sbi
->fatent_ops
= &fat16_ops
;
302 sbi
->fatent_shift
= -1;
303 sbi
->fatent_ops
= &fat12_ops
;
308 static void mark_fsinfo_dirty(struct super_block
*sb
)
310 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
312 if (sb_rdonly(sb
) || sbi
->fat_bits
!= 32)
315 __mark_inode_dirty(sbi
->fsinfo_inode
, I_DIRTY_SYNC
);
318 static inline int fat_ent_update_ptr(struct super_block
*sb
,
319 struct fat_entry
*fatent
,
320 int offset
, sector_t blocknr
)
322 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
323 const struct fatent_operations
*ops
= sbi
->fatent_ops
;
324 struct buffer_head
**bhs
= fatent
->bhs
;
326 /* Is this fatent's blocks including this entry? */
327 if (!fatent
->nr_bhs
|| bhs
[0]->b_blocknr
!= blocknr
)
329 if (sbi
->fat_bits
== 12) {
330 if ((offset
+ 1) < sb
->s_blocksize
) {
331 /* This entry is on bhs[0]. */
332 if (fatent
->nr_bhs
== 2) {
337 /* This entry needs the next block. */
338 if (fatent
->nr_bhs
!= 2)
340 if (bhs
[1]->b_blocknr
!= (blocknr
+ 1))
344 ops
->ent_set_ptr(fatent
, offset
);
348 int fat_ent_read(struct inode
*inode
, struct fat_entry
*fatent
, int entry
)
350 struct super_block
*sb
= inode
->i_sb
;
351 struct msdos_sb_info
*sbi
= MSDOS_SB(inode
->i_sb
);
352 const struct fatent_operations
*ops
= sbi
->fatent_ops
;
356 if (entry
< FAT_START_ENT
|| sbi
->max_cluster
<= entry
) {
357 fatent_brelse(fatent
);
358 fat_fs_error(sb
, "invalid access to FAT (entry 0x%08x)", entry
);
362 fatent_set_entry(fatent
, entry
);
363 ops
->ent_blocknr(sb
, entry
, &offset
, &blocknr
);
365 if (!fat_ent_update_ptr(sb
, fatent
, offset
, blocknr
)) {
366 fatent_brelse(fatent
);
367 err
= ops
->ent_bread(sb
, fatent
, offset
, blocknr
);
371 return ops
->ent_get(fatent
);
374 /* FIXME: We can write the blocks as more big chunk. */
375 static int fat_mirror_bhs(struct super_block
*sb
, struct buffer_head
**bhs
,
378 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
379 struct buffer_head
*c_bh
;
383 for (copy
= 1; copy
< sbi
->fats
; copy
++) {
384 sector_t backup_fat
= sbi
->fat_length
* copy
;
386 for (n
= 0; n
< nr_bhs
; n
++) {
387 c_bh
= sb_getblk(sb
, backup_fat
+ bhs
[n
]->b_blocknr
);
392 memcpy(c_bh
->b_data
, bhs
[n
]->b_data
, sb
->s_blocksize
);
393 set_buffer_uptodate(c_bh
);
394 mark_buffer_dirty_inode(c_bh
, sbi
->fat_inode
);
395 if (sb
->s_flags
& MS_SYNCHRONOUS
)
396 err
= sync_dirty_buffer(c_bh
);
406 int fat_ent_write(struct inode
*inode
, struct fat_entry
*fatent
,
409 struct super_block
*sb
= inode
->i_sb
;
410 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
413 ops
->ent_put(fatent
, new);
415 err
= fat_sync_bhs(fatent
->bhs
, fatent
->nr_bhs
);
419 return fat_mirror_bhs(sb
, fatent
->bhs
, fatent
->nr_bhs
);
422 static inline int fat_ent_next(struct msdos_sb_info
*sbi
,
423 struct fat_entry
*fatent
)
425 if (sbi
->fatent_ops
->ent_next(fatent
)) {
426 if (fatent
->entry
< sbi
->max_cluster
)
432 static inline int fat_ent_read_block(struct super_block
*sb
,
433 struct fat_entry
*fatent
)
435 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
439 fatent_brelse(fatent
);
440 ops
->ent_blocknr(sb
, fatent
->entry
, &offset
, &blocknr
);
441 return ops
->ent_bread(sb
, fatent
, offset
, blocknr
);
444 static void fat_collect_bhs(struct buffer_head
**bhs
, int *nr_bhs
,
445 struct fat_entry
*fatent
)
449 for (n
= 0; n
< fatent
->nr_bhs
; n
++) {
450 for (i
= 0; i
< *nr_bhs
; i
++) {
451 if (fatent
->bhs
[n
] == bhs
[i
])
455 get_bh(fatent
->bhs
[n
]);
456 bhs
[i
] = fatent
->bhs
[n
];
462 int fat_alloc_clusters(struct inode
*inode
, int *cluster
, int nr_cluster
)
464 struct super_block
*sb
= inode
->i_sb
;
465 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
466 const struct fatent_operations
*ops
= sbi
->fatent_ops
;
467 struct fat_entry fatent
, prev_ent
;
468 struct buffer_head
*bhs
[MAX_BUF_PER_PAGE
];
469 int i
, count
, err
, nr_bhs
, idx_clus
;
471 BUG_ON(nr_cluster
> (MAX_BUF_PER_PAGE
/ 2)); /* fixed limit */
474 if (sbi
->free_clusters
!= -1 && sbi
->free_clus_valid
&&
475 sbi
->free_clusters
< nr_cluster
) {
480 err
= nr_bhs
= idx_clus
= 0;
481 count
= FAT_START_ENT
;
482 fatent_init(&prev_ent
);
483 fatent_init(&fatent
);
484 fatent_set_entry(&fatent
, sbi
->prev_free
+ 1);
485 while (count
< sbi
->max_cluster
) {
486 if (fatent
.entry
>= sbi
->max_cluster
)
487 fatent
.entry
= FAT_START_ENT
;
488 fatent_set_entry(&fatent
, fatent
.entry
);
489 err
= fat_ent_read_block(sb
, &fatent
);
493 /* Find the free entries in a block */
495 if (ops
->ent_get(&fatent
) == FAT_ENT_FREE
) {
496 int entry
= fatent
.entry
;
498 /* make the cluster chain */
499 ops
->ent_put(&fatent
, FAT_ENT_EOF
);
501 ops
->ent_put(&prev_ent
, entry
);
503 fat_collect_bhs(bhs
, &nr_bhs
, &fatent
);
505 sbi
->prev_free
= entry
;
506 if (sbi
->free_clusters
!= -1)
507 sbi
->free_clusters
--;
509 cluster
[idx_clus
] = entry
;
511 if (idx_clus
== nr_cluster
)
515 * fat_collect_bhs() gets ref-count of bhs,
516 * so we can still use the prev_ent.
521 if (count
== sbi
->max_cluster
)
523 } while (fat_ent_next(sbi
, &fatent
));
526 /* Couldn't allocate the free entries */
527 sbi
->free_clusters
= 0;
528 sbi
->free_clus_valid
= 1;
533 mark_fsinfo_dirty(sb
);
534 fatent_brelse(&fatent
);
536 if (inode_needs_sync(inode
))
537 err
= fat_sync_bhs(bhs
, nr_bhs
);
539 err
= fat_mirror_bhs(sb
, bhs
, nr_bhs
);
541 for (i
= 0; i
< nr_bhs
; i
++)
545 fat_free_clusters(inode
, cluster
[0]);
550 int fat_free_clusters(struct inode
*inode
, int cluster
)
552 struct super_block
*sb
= inode
->i_sb
;
553 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
554 const struct fatent_operations
*ops
= sbi
->fatent_ops
;
555 struct fat_entry fatent
;
556 struct buffer_head
*bhs
[MAX_BUF_PER_PAGE
];
558 int first_cl
= cluster
, dirty_fsinfo
= 0;
561 fatent_init(&fatent
);
564 cluster
= fat_ent_read(inode
, &fatent
, cluster
);
568 } else if (cluster
== FAT_ENT_FREE
) {
569 fat_fs_error(sb
, "%s: deleting FAT entry beyond EOF",
575 if (sbi
->options
.discard
) {
577 * Issue discard for the sectors we no longer
578 * care about, batching contiguous clusters
581 if (cluster
!= fatent
.entry
+ 1) {
582 int nr_clus
= fatent
.entry
- first_cl
+ 1;
585 fat_clus_to_blknr(sbi
, first_cl
),
586 nr_clus
* sbi
->sec_per_clus
,
593 ops
->ent_put(&fatent
, FAT_ENT_FREE
);
594 if (sbi
->free_clusters
!= -1) {
595 sbi
->free_clusters
++;
599 if (nr_bhs
+ fatent
.nr_bhs
> MAX_BUF_PER_PAGE
) {
600 if (sb
->s_flags
& MS_SYNCHRONOUS
) {
601 err
= fat_sync_bhs(bhs
, nr_bhs
);
605 err
= fat_mirror_bhs(sb
, bhs
, nr_bhs
);
608 for (i
= 0; i
< nr_bhs
; i
++)
612 fat_collect_bhs(bhs
, &nr_bhs
, &fatent
);
613 } while (cluster
!= FAT_ENT_EOF
);
615 if (sb
->s_flags
& MS_SYNCHRONOUS
) {
616 err
= fat_sync_bhs(bhs
, nr_bhs
);
620 err
= fat_mirror_bhs(sb
, bhs
, nr_bhs
);
622 fatent_brelse(&fatent
);
623 for (i
= 0; i
< nr_bhs
; i
++)
627 mark_fsinfo_dirty(sb
);
631 EXPORT_SYMBOL_GPL(fat_free_clusters
);
633 /* 128kb is the whole sectors for FAT12 and FAT16 */
634 #define FAT_READA_SIZE (128 * 1024)
636 static void fat_ent_reada(struct super_block
*sb
, struct fat_entry
*fatent
,
637 unsigned long reada_blocks
)
639 const struct fatent_operations
*ops
= MSDOS_SB(sb
)->fatent_ops
;
643 ops
->ent_blocknr(sb
, fatent
->entry
, &offset
, &blocknr
);
645 for (i
= 0; i
< reada_blocks
; i
++)
646 sb_breadahead(sb
, blocknr
+ i
);
649 int fat_count_free_clusters(struct super_block
*sb
)
651 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
652 const struct fatent_operations
*ops
= sbi
->fatent_ops
;
653 struct fat_entry fatent
;
654 unsigned long reada_blocks
, reada_mask
, cur_block
;
658 if (sbi
->free_clusters
!= -1 && sbi
->free_clus_valid
)
661 reada_blocks
= FAT_READA_SIZE
>> sb
->s_blocksize_bits
;
662 reada_mask
= reada_blocks
- 1;
666 fatent_init(&fatent
);
667 fatent_set_entry(&fatent
, FAT_START_ENT
);
668 while (fatent
.entry
< sbi
->max_cluster
) {
669 /* readahead of fat blocks */
670 if ((cur_block
& reada_mask
) == 0) {
671 unsigned long rest
= sbi
->fat_length
- cur_block
;
672 fat_ent_reada(sb
, &fatent
, min(reada_blocks
, rest
));
676 err
= fat_ent_read_block(sb
, &fatent
);
681 if (ops
->ent_get(&fatent
) == FAT_ENT_FREE
)
683 } while (fat_ent_next(sbi
, &fatent
));
685 sbi
->free_clusters
= free
;
686 sbi
->free_clus_valid
= 1;
687 mark_fsinfo_dirty(sb
);
688 fatent_brelse(&fatent
);