Lines Matching defs:fatent
43 static void fat12_ent_set_ptr(struct fat_entry *fatent, int offset)
45 struct buffer_head **bhs = fatent->bhs;
46 if (fatent->nr_bhs == 1) {
48 fatent->u.ent12_p[0] = bhs[0]->b_data + offset;
49 fatent->u.ent12_p[1] = bhs[0]->b_data + (offset + 1);
52 fatent->u.ent12_p[0] = bhs[0]->b_data + offset;
53 fatent->u.ent12_p[1] = bhs[1]->b_data;
57 static void fat16_ent_set_ptr(struct fat_entry *fatent, int offset)
60 fatent->u.ent16_p = (__le16 *)(fatent->bhs[0]->b_data + offset);
63 static void fat32_ent_set_ptr(struct fat_entry *fatent, int offset)
66 fatent->u.ent32_p = (__le32 *)(fatent->bhs[0]->b_data + offset);
69 static int fat12_ent_bread(struct super_block *sb, struct fat_entry *fatent,
72 struct buffer_head **bhs = fatent->bhs;
75 fatent->fat_inode = MSDOS_SB(sb)->fat_inode;
82 fatent->nr_bhs = 1;
89 fatent->nr_bhs = 2;
91 fat12_ent_set_ptr(fatent, offset);
102 static int fat_ent_bread(struct super_block *sb, struct fat_entry *fatent,
108 fatent->fat_inode = MSDOS_SB(sb)->fat_inode;
109 fatent->bhs[0] = sb_bread(sb, blocknr);
110 if (!fatent->bhs[0]) {
115 fatent->nr_bhs = 1;
116 ops->ent_set_ptr(fatent, offset);
120 static int fat12_ent_get(struct fat_entry *fatent)
122 u8 **ent12_p = fatent->u.ent12_p;
126 if (fatent->entry & 1)
138 static int fat16_ent_get(struct fat_entry *fatent)
140 int next = le16_to_cpu(*fatent->u.ent16_p);
141 WARN_ON((unsigned long)fatent->u.ent16_p & (2 - 1));
147 static int fat32_ent_get(struct fat_entry *fatent)
149 int next = le32_to_cpu(*fatent->u.ent32_p) & 0x0fffffff;
150 WARN_ON((unsigned long)fatent->u.ent32_p & (4 - 1));
156 static void fat12_ent_put(struct fat_entry *fatent, int new)
158 u8 **ent12_p = fatent->u.ent12_p;
164 if (fatent->entry & 1) {
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);
178 static void fat16_ent_put(struct fat_entry *fatent, int new)
183 *fatent->u.ent16_p = cpu_to_le16(new);
184 mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
187 static void fat32_ent_put(struct fat_entry *fatent, int new)
190 new |= le32_to_cpu(*fatent->u.ent32_p) & ~0x0fffffff;
191 *fatent->u.ent32_p = cpu_to_le32(new);
192 mark_buffer_dirty_inode(fatent->bhs[0], fatent->fat_inode);
195 static int fat12_ent_next(struct fat_entry *fatent)
197 u8 **ent12_p = fatent->u.ent12_p;
198 struct buffer_head **bhs = fatent->bhs;
199 u8 *nextp = ent12_p[1] + 1 + (fatent->entry & 1);
201 fatent->entry++;
202 if (fatent->nr_bhs == 1) {
220 fatent->nr_bhs = 1;
228 static int fat16_ent_next(struct fat_entry *fatent)
230 const struct buffer_head *bh = fatent->bhs[0];
231 fatent->entry++;
232 if (fatent->u.ent16_p < (__le16 *)(bh->b_data + (bh->b_size - 2))) {
233 fatent->u.ent16_p++;
236 fatent->u.ent16_p = NULL;
240 static int fat32_ent_next(struct fat_entry *fatent)
242 const struct buffer_head *bh = fatent->bhs[0];
243 fatent->entry++;
244 if (fatent->u.ent32_p < (__le32 *)(bh->b_data + (bh->b_size - 4))) {
245 fatent->u.ent32_p++;
248 fatent->u.ent32_p = NULL;
320 struct fat_entry *fatent,
325 struct buffer_head **bhs = fatent->bhs;
327 /* Is this fatent's blocks including this entry? */
328 if (!fatent->nr_bhs || bhs[0]->b_blocknr != blocknr)
333 if (fatent->nr_bhs == 2) {
335 fatent->nr_bhs = 1;
339 if (fatent->nr_bhs != 2)
345 ops->ent_set_ptr(fatent, offset);
349 int fat_ent_read(struct inode *inode, struct fat_entry *fatent, int entry)
358 fatent_brelse(fatent);
363 fatent_set_entry(fatent, entry);
366 if (!fat_ent_update_ptr(sb, fatent, offset, blocknr)) {
367 fatent_brelse(fatent);
368 err = ops->ent_bread(sb, fatent, offset, blocknr);
372 return ops->ent_get(fatent);
410 int fat_ent_write(struct inode *inode, struct fat_entry *fatent,
417 ops->ent_put(fatent, new);
419 err = fat_sync_bhs(fatent->bhs, fatent->nr_bhs);
423 return fat_mirror_bhs(sb, fatent->bhs, fatent->nr_bhs);
427 struct fat_entry *fatent)
429 if (sbi->fatent_ops->ent_next(fatent)) {
430 if (fatent->entry < sbi->max_cluster)
437 struct fat_entry *fatent)
443 fatent_brelse(fatent);
444 ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
445 return ops->ent_bread(sb, fatent, offset, blocknr);
449 struct fat_entry *fatent)
453 for (n = 0; n < fatent->nr_bhs; n++) {
455 if (fatent->bhs[n] == bhs[i])
459 get_bh(fatent->bhs[n]);
460 bhs[i] = fatent->bhs[n];
471 struct fat_entry fatent, prev_ent;
487 fatent_init(&fatent);
488 fatent_set_entry(&fatent, sbi->prev_free + 1);
490 if (fatent.entry >= sbi->max_cluster)
491 fatent.entry = FAT_START_ENT;
492 fatent_set_entry(&fatent, fatent.entry);
493 err = fat_ent_read_block(sb, &fatent);
499 if (ops->ent_get(&fatent) == FAT_ENT_FREE) {
500 int entry = fatent.entry;
503 ops->ent_put(&fatent, FAT_ENT_EOF);
507 fat_collect_bhs(bhs, &nr_bhs, &fatent);
522 prev_ent = fatent;
527 } while (fat_ent_next(sbi, &fatent));
538 fatent_brelse(&fatent);
559 struct fat_entry fatent;
565 fatent_init(&fatent);
568 cluster = fat_ent_read(inode, &fatent, cluster);
585 if (cluster != fatent.entry + 1) {
586 int nr_clus = fatent.entry - first_cl + 1;
597 ops->ent_put(&fatent, FAT_ENT_FREE);
603 if (nr_bhs + fatent.nr_bhs > MAX_BUF_PER_PAGE) {
616 fat_collect_bhs(bhs, &nr_bhs, &fatent);
626 fatent_brelse(&fatent);
648 struct fat_entry *fatent, int ent_limit)
662 if (fatent->entry >= ent_limit)
670 ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
684 struct fat_entry *fatent)
696 ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
720 struct fat_entry fatent;
729 fatent_init(&fatent);
730 fatent_set_entry(&fatent, FAT_START_ENT);
731 fat_ra_init(sb, &fatent_ra, &fatent, sbi->max_cluster);
732 while (fatent.entry < sbi->max_cluster) {
734 fat_ent_reada(sb, &fatent_ra, &fatent);
736 err = fat_ent_read_block(sb, &fatent);
741 if (ops->ent_get(&fatent) == FAT_ENT_FREE)
743 } while (fat_ent_next(sbi, &fatent));
749 fatent_brelse(&fatent);
767 struct fat_entry fatent;
788 fatent_init(&fatent);
790 fatent_set_entry(&fatent, ent_start);
791 fat_ra_init(sb, &fatent_ra, &fatent, ent_end + 1);
792 while (fatent.entry <= ent_end) {
794 fat_ent_reada(sb, &fatent_ra, &fatent);
796 err = fat_ent_read_block(sb, &fatent);
800 if (ops->ent_get(&fatent) == FAT_ENT_FREE) {
804 u32 clus = fatent.entry - free;
815 } while (fat_ent_next(sbi, &fatent) && fatent.entry <= ent_end);
823 fatent_brelse(&fatent);
831 u32 clus = fatent.entry - free;
842 fatent_brelse(&fatent);