• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * fat.c
4  *
5  * R/O (V)FAT 12/16/32 filesystem implementation by Marcus Sundberg
6  *
7  * 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6
8  * 2003-03-10 - kharris@nexus-tech.net - ported to uboot
9  */
10 
11 #include <common.h>
12 #include <blk.h>
13 #include <config.h>
14 #include <exports.h>
15 #include <fat.h>
16 #include <fs.h>
17 #include <asm/byteorder.h>
18 #include <part.h>
19 #include <malloc.h>
20 #include <memalign.h>
21 #include <linux/compiler.h>
22 #include <linux/ctype.h>
23 
24 /*
25  * Convert a string to lowercase.  Converts at most 'len' characters,
26  * 'len' may be larger than the length of 'str' if 'str' is NULL
27  * terminated.
28  */
downcase(char * str,size_t len)29 static void downcase(char *str, size_t len)
30 {
31 	while (*str != '\0' && len--) {
32 		*str = tolower(*str);
33 		str++;
34 	}
35 }
36 
37 static struct blk_desc *cur_dev;
38 static disk_partition_t cur_part_info;
39 
40 #define DOS_BOOT_MAGIC_OFFSET	0x1fe
41 #define DOS_FS_TYPE_OFFSET	0x36
42 #define DOS_FS32_TYPE_OFFSET	0x52
43 
disk_read(__u32 block,__u32 nr_blocks,void * buf)44 static int disk_read(__u32 block, __u32 nr_blocks, void *buf)
45 {
46 	ulong ret;
47 
48 	if (!cur_dev)
49 		return -1;
50 
51 	ret = blk_dread(cur_dev, cur_part_info.start + block, nr_blocks, buf);
52 
53 	if (ret != nr_blocks)
54 		return -1;
55 
56 	return ret;
57 }
58 
fat_set_blk_dev(struct blk_desc * dev_desc,disk_partition_t * info)59 int fat_set_blk_dev(struct blk_desc *dev_desc, disk_partition_t *info)
60 {
61 	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);
62 
63 	cur_dev = dev_desc;
64 	cur_part_info = *info;
65 
66 	/* Make sure it has a valid FAT header */
67 	if (disk_read(0, 1, buffer) != 1) {
68 		cur_dev = NULL;
69 		return -1;
70 	}
71 
72 	/* Check if it's actually a DOS volume */
73 	if (memcmp(buffer + DOS_BOOT_MAGIC_OFFSET, "\x55\xAA", 2)) {
74 		cur_dev = NULL;
75 		return -1;
76 	}
77 
78 	/* Check for FAT12/FAT16/FAT32 filesystem */
79 	if (!memcmp(buffer + DOS_FS_TYPE_OFFSET, "FAT", 3))
80 		return 0;
81 	if (!memcmp(buffer + DOS_FS32_TYPE_OFFSET, "FAT32", 5))
82 		return 0;
83 
84 	cur_dev = NULL;
85 	return -1;
86 }
87 
fat_register_device(struct blk_desc * dev_desc,int part_no)88 int fat_register_device(struct blk_desc *dev_desc, int part_no)
89 {
90 	disk_partition_t info;
91 
92 	/* First close any currently found FAT filesystem */
93 	cur_dev = NULL;
94 
95 	/* Read the partition table, if present */
96 	if (part_get_info(dev_desc, part_no, &info)) {
97 		if (part_no != 0) {
98 			printf("** Partition %d not valid on device %d **\n",
99 					part_no, dev_desc->devnum);
100 			return -1;
101 		}
102 
103 		info.start = 0;
104 		info.size = dev_desc->lba;
105 		info.blksz = dev_desc->blksz;
106 		info.name[0] = 0;
107 		info.type[0] = 0;
108 		info.bootable = 0;
109 #if CONFIG_IS_ENABLED(PARTITION_UUIDS)
110 		info.uuid[0] = 0;
111 #endif
112 	}
113 
114 	return fat_set_blk_dev(dev_desc, &info);
115 }
116 
117 /*
118  * Extract zero terminated short name from a directory entry.
119  */
get_name(dir_entry * dirent,char * s_name)120 static void get_name(dir_entry *dirent, char *s_name)
121 {
122 	char *ptr;
123 
124 	memcpy(s_name, dirent->name, 8);
125 	s_name[8] = '\0';
126 	ptr = s_name;
127 	while (*ptr && *ptr != ' ')
128 		ptr++;
129 	if (dirent->lcase & CASE_LOWER_BASE)
130 		downcase(s_name, (unsigned)(ptr - s_name));
131 	if (dirent->ext[0] && dirent->ext[0] != ' ') {
132 		*ptr++ = '.';
133 		memcpy(ptr, dirent->ext, 3);
134 		if (dirent->lcase & CASE_LOWER_EXT)
135 			downcase(ptr, 3);
136 		ptr[3] = '\0';
137 		while (*ptr && *ptr != ' ')
138 			ptr++;
139 	}
140 	*ptr = '\0';
141 	if (*s_name == DELETED_FLAG)
142 		*s_name = '\0';
143 	else if (*s_name == aRING)
144 		*s_name = DELETED_FLAG;
145 }
146 
147 static int flush_dirty_fat_buffer(fsdata *mydata);
148 #if !defined(CONFIG_FAT_WRITE)
149 /* Stub for read only operation */
flush_dirty_fat_buffer(fsdata * mydata)150 int flush_dirty_fat_buffer(fsdata *mydata)
151 {
152 	(void)(mydata);
153 	return 0;
154 }
155 #endif
156 
157 /*
158  * Get the entry at index 'entry' in a FAT (12/16/32) table.
159  * On failure 0x00 is returned.
160  */
get_fatent(fsdata * mydata,__u32 entry)161 static __u32 get_fatent(fsdata *mydata, __u32 entry)
162 {
163 	__u32 bufnum;
164 	__u32 offset, off8;
165 	__u32 ret = 0x00;
166 
167 	if (CHECK_CLUST(entry, mydata->fatsize)) {
168 		printf("Error: Invalid FAT entry: 0x%08x\n", entry);
169 		return ret;
170 	}
171 
172 	switch (mydata->fatsize) {
173 	case 32:
174 		bufnum = entry / FAT32BUFSIZE;
175 		offset = entry - bufnum * FAT32BUFSIZE;
176 		break;
177 	case 16:
178 		bufnum = entry / FAT16BUFSIZE;
179 		offset = entry - bufnum * FAT16BUFSIZE;
180 		break;
181 	case 12:
182 		bufnum = entry / FAT12BUFSIZE;
183 		offset = entry - bufnum * FAT12BUFSIZE;
184 		break;
185 
186 	default:
187 		/* Unsupported FAT size */
188 		return ret;
189 	}
190 
191 	debug("FAT%d: entry: 0x%08x = %d, offset: 0x%04x = %d\n",
192 	       mydata->fatsize, entry, entry, offset, offset);
193 
194 	/* Read a new block of FAT entries into the cache. */
195 	if (bufnum != mydata->fatbufnum) {
196 		__u32 getsize = FATBUFBLOCKS;
197 		__u8 *bufptr = mydata->fatbuf;
198 		__u32 fatlength = mydata->fatlength;
199 		__u32 startblock = bufnum * FATBUFBLOCKS;
200 
201 		/* Cap length if fatlength is not a multiple of FATBUFBLOCKS */
202 		if (startblock + getsize > fatlength)
203 			getsize = fatlength - startblock;
204 
205 		startblock += mydata->fat_sect;	/* Offset from start of disk */
206 
207 		/* Write back the fatbuf to the disk */
208 		if (flush_dirty_fat_buffer(mydata) < 0)
209 			return -1;
210 
211 		if (disk_read(startblock, getsize, bufptr) < 0) {
212 			debug("Error reading FAT blocks\n");
213 			return ret;
214 		}
215 		mydata->fatbufnum = bufnum;
216 	}
217 
218 	/* Get the actual entry from the table */
219 	switch (mydata->fatsize) {
220 	case 32:
221 		ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]);
222 		break;
223 	case 16:
224 		ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]);
225 		break;
226 	case 12:
227 		off8 = (offset * 3) / 2;
228 		/* fatbut + off8 may be unaligned, read in byte granularity */
229 		ret = mydata->fatbuf[off8] + (mydata->fatbuf[off8 + 1] << 8);
230 
231 		if (offset & 0x1)
232 			ret >>= 4;
233 		ret &= 0xfff;
234 	}
235 	debug("FAT%d: ret: 0x%08x, entry: 0x%08x, offset: 0x%04x\n",
236 	       mydata->fatsize, ret, entry, offset);
237 
238 	return ret;
239 }
240 
241 /*
242  * Read at most 'size' bytes from the specified cluster into 'buffer'.
243  * Return 0 on success, -1 otherwise.
244  */
245 static int
get_cluster(fsdata * mydata,__u32 clustnum,__u8 * buffer,unsigned long size)246 get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size)
247 {
248 	__u32 idx = 0;
249 	__u32 startsect;
250 	int ret;
251 
252 	if (clustnum > 0) {
253 		startsect = clust_to_sect(mydata, clustnum);
254 	} else {
255 		startsect = mydata->rootdir_sect;
256 	}
257 
258 	debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect);
259 
260 	if ((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1)) {
261 		ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
262 
263 		printf("FAT: Misaligned buffer address (%p)\n", buffer);
264 
265 		while (size >= mydata->sect_size) {
266 			ret = disk_read(startsect++, 1, tmpbuf);
267 			if (ret != 1) {
268 				debug("Error reading data (got %d)\n", ret);
269 				return -1;
270 			}
271 
272 			memcpy(buffer, tmpbuf, mydata->sect_size);
273 			buffer += mydata->sect_size;
274 			size -= mydata->sect_size;
275 		}
276 	} else {
277 		idx = size / mydata->sect_size;
278 		ret = disk_read(startsect, idx, buffer);
279 		if (ret != idx) {
280 			debug("Error reading data (got %d)\n", ret);
281 			return -1;
282 		}
283 		startsect += idx;
284 		idx *= mydata->sect_size;
285 		buffer += idx;
286 		size -= idx;
287 	}
288 	if (size) {
289 		ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
290 
291 		ret = disk_read(startsect, 1, tmpbuf);
292 		if (ret != 1) {
293 			debug("Error reading data (got %d)\n", ret);
294 			return -1;
295 		}
296 
297 		memcpy(buffer, tmpbuf, size);
298 	}
299 
300 	return 0;
301 }
302 
303 /*
304  * Read at most 'maxsize' bytes from 'pos' in the file associated with 'dentptr'
305  * into 'buffer'.
306  * Update the number of bytes read in *gotsize or return -1 on fatal errors.
307  */
308 __u8 get_contents_vfatname_block[MAX_CLUSTSIZE]
309 	__aligned(ARCH_DMA_MINALIGN);
310 
get_contents(fsdata * mydata,dir_entry * dentptr,loff_t pos,__u8 * buffer,loff_t maxsize,loff_t * gotsize)311 static int get_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos,
312 			__u8 *buffer, loff_t maxsize, loff_t *gotsize)
313 {
314 	loff_t filesize = FAT2CPU32(dentptr->size);
315 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
316 	__u32 curclust = START(dentptr);
317 	__u32 endclust, newclust;
318 	loff_t actsize;
319 
320 	*gotsize = 0;
321 	debug("Filesize: %llu bytes\n", filesize);
322 
323 	if (pos >= filesize) {
324 		debug("Read position past EOF: %llu\n", pos);
325 		return 0;
326 	}
327 
328 	if (maxsize > 0 && filesize > pos + maxsize)
329 		filesize = pos + maxsize;
330 
331 	debug("%llu bytes\n", filesize);
332 
333 	actsize = bytesperclust;
334 
335 	/* go to cluster at pos */
336 	while (actsize <= pos) {
337 		curclust = get_fatent(mydata, curclust);
338 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
339 			debug("curclust: 0x%x\n", curclust);
340 			debug("Invalid FAT entry\n");
341 			return 0;
342 		}
343 		actsize += bytesperclust;
344 	}
345 
346 	/* actsize > pos */
347 	actsize -= bytesperclust;
348 	filesize -= actsize;
349 	pos -= actsize;
350 
351 	/* align to beginning of next cluster if any */
352 	if (pos) {
353 		actsize = min(filesize, (loff_t)bytesperclust);
354 		if (get_cluster(mydata, curclust, get_contents_vfatname_block,
355 				(int)actsize) != 0) {
356 			printf("Error reading cluster\n");
357 			return -1;
358 		}
359 		filesize -= actsize;
360 		actsize -= pos;
361 		memcpy(buffer, get_contents_vfatname_block + pos, actsize);
362 		*gotsize += actsize;
363 		if (!filesize)
364 			return 0;
365 		buffer += actsize;
366 
367 		curclust = get_fatent(mydata, curclust);
368 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
369 			debug("curclust: 0x%x\n", curclust);
370 			debug("Invalid FAT entry\n");
371 			return 0;
372 		}
373 	}
374 
375 	actsize = bytesperclust;
376 	endclust = curclust;
377 
378 	do {
379 		/* search for consecutive clusters */
380 		while (actsize < filesize) {
381 			newclust = get_fatent(mydata, endclust);
382 			if ((newclust - 1) != endclust)
383 				goto getit;
384 			if (CHECK_CLUST(newclust, mydata->fatsize)) {
385 				debug("curclust: 0x%x\n", newclust);
386 				debug("Invalid FAT entry\n");
387 				return 0;
388 			}
389 			endclust = newclust;
390 			actsize += bytesperclust;
391 		}
392 
393 		/* get remaining bytes */
394 		actsize = filesize;
395 		if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
396 			printf("Error reading cluster\n");
397 			return -1;
398 		}
399 		*gotsize += actsize;
400 		return 0;
401 getit:
402 		if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
403 			printf("Error reading cluster\n");
404 			return -1;
405 		}
406 		*gotsize += (int)actsize;
407 		filesize -= actsize;
408 		buffer += actsize;
409 
410 		curclust = get_fatent(mydata, endclust);
411 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
412 			debug("curclust: 0x%x\n", curclust);
413 			printf("Invalid FAT entry\n");
414 			return 0;
415 		}
416 		actsize = bytesperclust;
417 		endclust = curclust;
418 	} while (1);
419 }
420 
421 /*
422  * Extract the file name information from 'slotptr' into 'l_name',
423  * starting at l_name[*idx].
424  * Return 1 if terminator (zero byte) is found, 0 otherwise.
425  */
slot2str(dir_slot * slotptr,char * l_name,int * idx)426 static int slot2str(dir_slot *slotptr, char *l_name, int *idx)
427 {
428 	int j;
429 
430 	for (j = 0; j <= 8; j += 2) {
431 		l_name[*idx] = slotptr->name0_4[j];
432 		if (l_name[*idx] == 0x00)
433 			return 1;
434 		(*idx)++;
435 	}
436 	for (j = 0; j <= 10; j += 2) {
437 		l_name[*idx] = slotptr->name5_10[j];
438 		if (l_name[*idx] == 0x00)
439 			return 1;
440 		(*idx)++;
441 	}
442 	for (j = 0; j <= 2; j += 2) {
443 		l_name[*idx] = slotptr->name11_12[j];
444 		if (l_name[*idx] == 0x00)
445 			return 1;
446 		(*idx)++;
447 	}
448 
449 	return 0;
450 }
451 
452 /* Calculate short name checksum */
mkcksum(const char name[8],const char ext[3])453 static __u8 mkcksum(const char name[8], const char ext[3])
454 {
455 	int i;
456 
457 	__u8 ret = 0;
458 
459 	for (i = 0; i < 8; i++)
460 		ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + name[i];
461 	for (i = 0; i < 3; i++)
462 		ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + ext[i];
463 
464 	return ret;
465 }
466 
467 /*
468  * TODO these should go away once fat_write is reworked to use the
469  * directory iterator
470  */
471 __u8 get_dentfromdir_block[MAX_CLUSTSIZE]
472 	__aligned(ARCH_DMA_MINALIGN);
473 __u8 do_fat_read_at_block[MAX_CLUSTSIZE]
474 	__aligned(ARCH_DMA_MINALIGN);
475 
476 /*
477  * Read boot sector and volume info from a FAT filesystem
478  */
479 static int
read_bootsectandvi(boot_sector * bs,volume_info * volinfo,int * fatsize)480 read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize)
481 {
482 	__u8 *block;
483 	volume_info *vistart;
484 	int ret = 0;
485 
486 	if (cur_dev == NULL) {
487 		debug("Error: no device selected\n");
488 		return -1;
489 	}
490 
491 	block = malloc_cache_aligned(cur_dev->blksz);
492 	if (block == NULL) {
493 		debug("Error: allocating block\n");
494 		return -1;
495 	}
496 
497 	if (disk_read(0, 1, block) < 0) {
498 		debug("Error: reading block\n");
499 		goto fail;
500 	}
501 
502 	memcpy(bs, block, sizeof(boot_sector));
503 	bs->reserved = FAT2CPU16(bs->reserved);
504 	bs->fat_length = FAT2CPU16(bs->fat_length);
505 	bs->secs_track = FAT2CPU16(bs->secs_track);
506 	bs->heads = FAT2CPU16(bs->heads);
507 	bs->total_sect = FAT2CPU32(bs->total_sect);
508 
509 	/* FAT32 entries */
510 	if (bs->fat_length == 0) {
511 		/* Assume FAT32 */
512 		bs->fat32_length = FAT2CPU32(bs->fat32_length);
513 		bs->flags = FAT2CPU16(bs->flags);
514 		bs->root_cluster = FAT2CPU32(bs->root_cluster);
515 		bs->info_sector = FAT2CPU16(bs->info_sector);
516 		bs->backup_boot = FAT2CPU16(bs->backup_boot);
517 		vistart = (volume_info *)(block + sizeof(boot_sector));
518 		*fatsize = 32;
519 	} else {
520 		vistart = (volume_info *)&(bs->fat32_length);
521 		*fatsize = 0;
522 	}
523 	memcpy(volinfo, vistart, sizeof(volume_info));
524 
525 	if (*fatsize == 32) {
526 		if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0)
527 			goto exit;
528 	} else {
529 		if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) {
530 			*fatsize = 12;
531 			goto exit;
532 		}
533 		if (strncmp(FAT16_SIGN, vistart->fs_type, SIGNLEN) == 0) {
534 			*fatsize = 16;
535 			goto exit;
536 		}
537 	}
538 
539 	debug("Error: broken fs_type sign\n");
540 fail:
541 	ret = -1;
542 exit:
543 	free(block);
544 	return ret;
545 }
546 
get_fs_info(fsdata * mydata)547 static int get_fs_info(fsdata *mydata)
548 {
549 	boot_sector bs;
550 	volume_info volinfo;
551 	int ret;
552 
553 	ret = read_bootsectandvi(&bs, &volinfo, &mydata->fatsize);
554 	if (ret) {
555 		debug("Error: reading boot sector\n");
556 		return ret;
557 	}
558 
559 	if (mydata->fatsize == 32) {
560 		mydata->fatlength = bs.fat32_length;
561 	} else {
562 		mydata->fatlength = bs.fat_length;
563 	}
564 
565 	mydata->fat_sect = bs.reserved;
566 
567 	mydata->rootdir_sect = mydata->fat_sect + mydata->fatlength * bs.fats;
568 
569 	mydata->sect_size = (bs.sector_size[1] << 8) + bs.sector_size[0];
570 	mydata->clust_size = bs.cluster_size;
571 	if (mydata->sect_size != cur_part_info.blksz) {
572 		printf("Error: FAT sector size mismatch (fs=%hu, dev=%lu)\n",
573 				mydata->sect_size, cur_part_info.blksz);
574 		return -1;
575 	}
576 
577 	if (mydata->fatsize == 32) {
578 		mydata->data_begin = mydata->rootdir_sect -
579 					(mydata->clust_size * 2);
580 		mydata->root_cluster = bs.root_cluster;
581 	} else {
582 		mydata->rootdir_size = ((bs.dir_entries[1]  * (int)256 +
583 					 bs.dir_entries[0]) *
584 					 sizeof(dir_entry)) /
585 					 mydata->sect_size;
586 		mydata->data_begin = mydata->rootdir_sect +
587 					mydata->rootdir_size -
588 					(mydata->clust_size * 2);
589 		mydata->root_cluster =
590 			sect_to_clust(mydata, mydata->rootdir_sect);
591 	}
592 
593 	mydata->fatbufnum = -1;
594 	mydata->fat_dirty = 0;
595 	mydata->fatbuf = malloc_cache_aligned(FATBUFSIZE);
596 	if (mydata->fatbuf == NULL) {
597 		debug("Error: allocating memory\n");
598 		return -1;
599 	}
600 
601 	debug("FAT%d, fat_sect: %d, fatlength: %d\n",
602 	       mydata->fatsize, mydata->fat_sect, mydata->fatlength);
603 	debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n"
604 	       "Data begins at: %d\n",
605 	       mydata->root_cluster,
606 	       mydata->rootdir_sect,
607 	       mydata->rootdir_sect * mydata->sect_size, mydata->data_begin);
608 	debug("Sector size: %d, cluster size: %d\n", mydata->sect_size,
609 	      mydata->clust_size);
610 
611 	return 0;
612 }
613 
614 
615 /*
616  * Directory iterator, to simplify filesystem traversal
617  *
618  * Implements an iterator pattern to traverse directory tables,
619  * transparently handling directory tables split across multiple
620  * clusters, and the difference between FAT12/FAT16 root directory
621  * (contiguous) and subdirectories + FAT32 root (chained).
622  *
623  * Rough usage:
624  *
625  *   for (fat_itr_root(&itr, fsdata); fat_itr_next(&itr); ) {
626  *      // to traverse down to a subdirectory pointed to by
627  *      // current iterator position:
628  *      fat_itr_child(&itr, &itr);
629  *   }
630  *
631  * For more complete example, see fat_itr_resolve()
632  */
633 
634 typedef struct {
635 	fsdata    *fsdata;        /* filesystem parameters */
636 	unsigned   clust;         /* current cluster */
637 	int        last_cluster;  /* set once we've read last cluster */
638 	int        is_root;       /* is iterator at root directory */
639 	int        remaining;     /* remaining dent's in current cluster */
640 
641 	/* current iterator position values: */
642 	dir_entry *dent;          /* current directory entry */
643 	char       l_name[VFAT_MAXLEN_BYTES];    /* long (vfat) name */
644 	char       s_name[14];    /* short 8.3 name */
645 	char      *name;          /* l_name if there is one, else s_name */
646 
647 	/* storage for current cluster in memory: */
648 	u8         block[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);
649 } fat_itr;
650 
651 static int fat_itr_isdir(fat_itr *itr);
652 
653 /**
654  * fat_itr_root() - initialize an iterator to start at the root
655  * directory
656  *
657  * @itr: iterator to initialize
658  * @fsdata: filesystem data for the partition
659  * @return 0 on success, else -errno
660  */
fat_itr_root(fat_itr * itr,fsdata * fsdata)661 static int fat_itr_root(fat_itr *itr, fsdata *fsdata)
662 {
663 	if (get_fs_info(fsdata))
664 		return -ENXIO;
665 
666 	itr->fsdata = fsdata;
667 	itr->clust = fsdata->root_cluster;
668 	itr->dent = NULL;
669 	itr->remaining = 0;
670 	itr->last_cluster = 0;
671 	itr->is_root = 1;
672 
673 	return 0;
674 }
675 
676 /**
677  * fat_itr_child() - initialize an iterator to descend into a sub-
678  * directory
679  *
680  * Initializes 'itr' to iterate the contents of the directory at
681  * the current cursor position of 'parent'.  It is an error to
682  * call this if the current cursor of 'parent' is pointing at a
683  * regular file.
684  *
685  * Note that 'itr' and 'parent' can be the same pointer if you do
686  * not need to preserve 'parent' after this call, which is useful
687  * for traversing directory structure to resolve a file/directory.
688  *
689  * @itr: iterator to initialize
690  * @parent: the iterator pointing at a directory entry in the
691  *    parent directory of the directory to iterate
692  */
fat_itr_child(fat_itr * itr,fat_itr * parent)693 static void fat_itr_child(fat_itr *itr, fat_itr *parent)
694 {
695 	fsdata *mydata = parent->fsdata;  /* for silly macros */
696 	unsigned clustnum = START(parent->dent);
697 
698 	assert(fat_itr_isdir(parent));
699 
700 	itr->fsdata = parent->fsdata;
701 	if (clustnum > 0) {
702 		itr->clust = clustnum;
703 		itr->is_root = 0;
704 	} else {
705 		itr->clust = parent->fsdata->root_cluster;
706 		itr->is_root = 1;
707 	}
708 	itr->dent = NULL;
709 	itr->remaining = 0;
710 	itr->last_cluster = 0;
711 }
712 
next_cluster(fat_itr * itr)713 static void *next_cluster(fat_itr *itr)
714 {
715 	fsdata *mydata = itr->fsdata;  /* for silly macros */
716 	int ret;
717 	u32 sect;
718 
719 	/* have we reached the end? */
720 	if (itr->last_cluster)
721 		return NULL;
722 
723 	sect = clust_to_sect(itr->fsdata, itr->clust);
724 
725 	debug("FAT read(sect=%d), clust_size=%d, DIRENTSPERBLOCK=%zd\n",
726 	      sect, itr->fsdata->clust_size, DIRENTSPERBLOCK);
727 
728 	/*
729 	 * NOTE: do_fat_read_at() had complicated logic to deal w/
730 	 * vfat names that span multiple clusters in the fat16 case,
731 	 * which get_dentfromdir() probably also needed (and was
732 	 * missing).  And not entirely sure what fat32 didn't have
733 	 * the same issue..  We solve that by only caring about one
734 	 * dent at a time and iteratively constructing the vfat long
735 	 * name.
736 	 */
737 	ret = disk_read(sect, itr->fsdata->clust_size,
738 			itr->block);
739 	if (ret < 0) {
740 		debug("Error: reading block\n");
741 		return NULL;
742 	}
743 
744 	if (itr->is_root && itr->fsdata->fatsize != 32) {
745 		itr->clust++;
746 		sect = clust_to_sect(itr->fsdata, itr->clust);
747 		if (sect - itr->fsdata->rootdir_sect >=
748 		    itr->fsdata->rootdir_size) {
749 			debug("cursect: 0x%x\n", itr->clust);
750 			itr->last_cluster = 1;
751 		}
752 	} else {
753 		itr->clust = get_fatent(itr->fsdata, itr->clust);
754 		if (CHECK_CLUST(itr->clust, itr->fsdata->fatsize)) {
755 			debug("cursect: 0x%x\n", itr->clust);
756 			itr->last_cluster = 1;
757 		}
758 	}
759 
760 	return itr->block;
761 }
762 
next_dent(fat_itr * itr)763 static dir_entry *next_dent(fat_itr *itr)
764 {
765 	if (itr->remaining == 0) {
766 		struct dir_entry *dent = next_cluster(itr);
767 		unsigned nbytes = itr->fsdata->sect_size *
768 			itr->fsdata->clust_size;
769 
770 		/* have we reached the last cluster? */
771 		if (!dent)
772 			return NULL;
773 
774 		itr->remaining = nbytes / sizeof(dir_entry) - 1;
775 		itr->dent = dent;
776 	} else {
777 		itr->remaining--;
778 		itr->dent++;
779 	}
780 
781 	/* have we reached the last valid entry? */
782 	if (itr->dent->name[0] == 0)
783 		return NULL;
784 
785 	return itr->dent;
786 }
787 
extract_vfat_name(fat_itr * itr)788 static dir_entry *extract_vfat_name(fat_itr *itr)
789 {
790 	struct dir_entry *dent = itr->dent;
791 	int seqn = itr->dent->name[0] & ~LAST_LONG_ENTRY_MASK;
792 	u8 chksum, alias_checksum = ((dir_slot *)dent)->alias_checksum;
793 	int n = 0;
794 
795 	while (seqn--) {
796 		char buf[13];
797 		int idx = 0;
798 
799 		slot2str((dir_slot *)dent, buf, &idx);
800 
801 		/* shift accumulated long-name up and copy new part in: */
802 		memmove(itr->l_name + idx, itr->l_name, n);
803 		memcpy(itr->l_name, buf, idx);
804 		n += idx;
805 
806 		dent = next_dent(itr);
807 		if (!dent)
808 			return NULL;
809 	}
810 
811 	itr->l_name[n] = '\0';
812 
813 	chksum = mkcksum(dent->name, dent->ext);
814 
815 	/* checksum mismatch could mean deleted file, etc.. skip it: */
816 	if (chksum != alias_checksum) {
817 		debug("** chksum=%x, alias_checksum=%x, l_name=%s, s_name=%8s.%3s\n",
818 		      chksum, alias_checksum, itr->l_name, dent->name, dent->ext);
819 		return NULL;
820 	}
821 
822 	return dent;
823 }
824 
825 /**
826  * fat_itr_next() - step to the next entry in a directory
827  *
828  * Must be called once on a new iterator before the cursor is valid.
829  *
830  * @itr: the iterator to iterate
831  * @return boolean, 1 if success or 0 if no more entries in the
832  *    current directory
833  */
fat_itr_next(fat_itr * itr)834 static int fat_itr_next(fat_itr *itr)
835 {
836 	dir_entry *dent;
837 
838 	itr->name = NULL;
839 
840 	while (1) {
841 		dent = next_dent(itr);
842 		if (!dent)
843 			return 0;
844 
845 		if (dent->name[0] == DELETED_FLAG ||
846 		    dent->name[0] == aRING)
847 			continue;
848 
849 		if (dent->attr & ATTR_VOLUME) {
850 			if ((dent->attr & ATTR_VFAT) == ATTR_VFAT &&
851 			    (dent->name[0] & LAST_LONG_ENTRY_MASK)) {
852 				dent = extract_vfat_name(itr);
853 				if (!dent)
854 					continue;
855 				itr->name = itr->l_name;
856 				break;
857 			} else {
858 				/* Volume label or VFAT entry, skip */
859 				continue;
860 			}
861 		}
862 
863 		break;
864 	}
865 
866 	get_name(dent, itr->s_name);
867 	if (!itr->name)
868 		itr->name = itr->s_name;
869 
870 	return 1;
871 }
872 
873 /**
874  * fat_itr_isdir() - is current cursor position pointing to a directory
875  *
876  * @itr: the iterator
877  * @return true if cursor is at a directory
878  */
fat_itr_isdir(fat_itr * itr)879 static int fat_itr_isdir(fat_itr *itr)
880 {
881 	return !!(itr->dent->attr & ATTR_DIR);
882 }
883 
884 /*
885  * Helpers:
886  */
887 
888 #define TYPE_FILE 0x1
889 #define TYPE_DIR  0x2
890 #define TYPE_ANY  (TYPE_FILE | TYPE_DIR)
891 
892 /**
893  * fat_itr_resolve() - traverse directory structure to resolve the
894  * requested path.
895  *
896  * Traverse directory structure to the requested path.  If the specified
897  * path is to a directory, this will descend into the directory and
898  * leave it iterator at the start of the directory.  If the path is to a
899  * file, it will leave the iterator in the parent directory with current
900  * cursor at file's entry in the directory.
901  *
902  * @itr: iterator initialized to root
903  * @path: the requested path
904  * @type: bitmask of allowable file types
905  * @return 0 on success or -errno
906  */
fat_itr_resolve(fat_itr * itr,const char * path,unsigned type)907 static int fat_itr_resolve(fat_itr *itr, const char *path, unsigned type)
908 {
909 	const char *next;
910 
911 	/* chomp any extra leading slashes: */
912 	while (path[0] && ISDIRDELIM(path[0]))
913 		path++;
914 
915 	/* are we at the end? */
916 	if (strlen(path) == 0) {
917 		if (!(type & TYPE_DIR))
918 			return -ENOENT;
919 		return 0;
920 	}
921 
922 	/* find length of next path entry: */
923 	next = path;
924 	while (next[0] && !ISDIRDELIM(next[0]))
925 		next++;
926 
927 	while (fat_itr_next(itr)) {
928 		int match = 0;
929 		unsigned n = max(strlen(itr->name), (size_t)(next - path));
930 
931 		/* check both long and short name: */
932 		if (!strncasecmp(path, itr->name, n))
933 			match = 1;
934 		else if (itr->name != itr->s_name &&
935 			 !strncasecmp(path, itr->s_name, n))
936 			match = 1;
937 
938 		if (!match)
939 			continue;
940 
941 		if (fat_itr_isdir(itr)) {
942 			/* recurse into directory: */
943 			fat_itr_child(itr, itr);
944 			return fat_itr_resolve(itr, next, type);
945 		} else if (next[0]) {
946 			/*
947 			 * If next is not empty then we have a case
948 			 * like: /path/to/realfile/nonsense
949 			 */
950 			debug("bad trailing path: %s\n", next);
951 			return -ENOENT;
952 		} else if (!(type & TYPE_FILE)) {
953 			return -ENOTDIR;
954 		} else {
955 			return 0;
956 		}
957 	}
958 
959 	return -ENOENT;
960 }
961 
file_fat_detectfs(void)962 int file_fat_detectfs(void)
963 {
964 	boot_sector bs;
965 	volume_info volinfo;
966 	int fatsize;
967 	char vol_label[12];
968 
969 	if (cur_dev == NULL) {
970 		printf("No current device\n");
971 		return 1;
972 	}
973 
974 #if defined(CONFIG_IDE) || \
975     defined(CONFIG_SATA) || \
976     defined(CONFIG_SCSI) || \
977     defined(CONFIG_CMD_USB) || \
978     defined(CONFIG_MMC)
979 	printf("Interface:  ");
980 	switch (cur_dev->if_type) {
981 	case IF_TYPE_IDE:
982 		printf("IDE");
983 		break;
984 	case IF_TYPE_SATA:
985 		printf("SATA");
986 		break;
987 	case IF_TYPE_SCSI:
988 		printf("SCSI");
989 		break;
990 	case IF_TYPE_ATAPI:
991 		printf("ATAPI");
992 		break;
993 	case IF_TYPE_USB:
994 		printf("USB");
995 		break;
996 	case IF_TYPE_DOC:
997 		printf("DOC");
998 		break;
999 	case IF_TYPE_MMC:
1000 		printf("MMC");
1001 		break;
1002 	default:
1003 		printf("Unknown");
1004 	}
1005 
1006 	printf("\n  Device %d: ", cur_dev->devnum);
1007 	dev_print(cur_dev);
1008 #endif
1009 
1010 	if (read_bootsectandvi(&bs, &volinfo, &fatsize)) {
1011 		printf("\nNo valid FAT fs found\n");
1012 		return 1;
1013 	}
1014 
1015 	memcpy(vol_label, volinfo.volume_label, 11);
1016 	vol_label[11] = '\0';
1017 	volinfo.fs_type[5] = '\0';
1018 
1019 	printf("Filesystem: %s \"%s\"\n", volinfo.fs_type, vol_label);
1020 
1021 	return 0;
1022 }
1023 
fat_exists(const char * filename)1024 int fat_exists(const char *filename)
1025 {
1026 	fsdata fsdata;
1027 	fat_itr *itr;
1028 	int ret;
1029 
1030 	itr = malloc_cache_aligned(sizeof(fat_itr));
1031 	if (!itr)
1032 		return 0;
1033 	ret = fat_itr_root(itr, &fsdata);
1034 	if (ret)
1035 		goto out;
1036 
1037 	ret = fat_itr_resolve(itr, filename, TYPE_ANY);
1038 	free(fsdata.fatbuf);
1039 out:
1040 	free(itr);
1041 	return ret == 0;
1042 }
1043 
fat_size(const char * filename,loff_t * size)1044 int fat_size(const char *filename, loff_t *size)
1045 {
1046 	fsdata fsdata;
1047 	fat_itr *itr;
1048 	int ret;
1049 
1050 	itr = malloc_cache_aligned(sizeof(fat_itr));
1051 	if (!itr)
1052 		return -ENOMEM;
1053 	ret = fat_itr_root(itr, &fsdata);
1054 	if (ret)
1055 		goto out_free_itr;
1056 
1057 	ret = fat_itr_resolve(itr, filename, TYPE_FILE);
1058 	if (ret) {
1059 		/*
1060 		 * Directories don't have size, but fs_size() is not
1061 		 * expected to fail if passed a directory path:
1062 		 */
1063 		free(fsdata.fatbuf);
1064 		fat_itr_root(itr, &fsdata);
1065 		if (!fat_itr_resolve(itr, filename, TYPE_DIR)) {
1066 			*size = 0;
1067 			ret = 0;
1068 		}
1069 		goto out_free_both;
1070 	}
1071 
1072 	*size = FAT2CPU32(itr->dent->size);
1073 out_free_both:
1074 	free(fsdata.fatbuf);
1075 out_free_itr:
1076 	free(itr);
1077 	return ret;
1078 }
1079 
file_fat_read_at(const char * filename,loff_t pos,void * buffer,loff_t maxsize,loff_t * actread)1080 int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
1081 		     loff_t maxsize, loff_t *actread)
1082 {
1083 	fsdata fsdata;
1084 	fat_itr *itr;
1085 	int ret;
1086 
1087 	itr = malloc_cache_aligned(sizeof(fat_itr));
1088 	if (!itr)
1089 		return -ENOMEM;
1090 	ret = fat_itr_root(itr, &fsdata);
1091 	if (ret)
1092 		goto out_free_itr;
1093 
1094 	ret = fat_itr_resolve(itr, filename, TYPE_FILE);
1095 	if (ret)
1096 		goto out_free_both;
1097 
1098 	debug("reading %s\n", filename);
1099 	ret = get_contents(&fsdata, itr->dent, pos, buffer, maxsize, actread);
1100 
1101 out_free_both:
1102 	free(fsdata.fatbuf);
1103 out_free_itr:
1104 	free(itr);
1105 	return ret;
1106 }
1107 
file_fat_read(const char * filename,void * buffer,int maxsize)1108 int file_fat_read(const char *filename, void *buffer, int maxsize)
1109 {
1110 	loff_t actread;
1111 	int ret;
1112 
1113 	ret =  file_fat_read_at(filename, 0, buffer, maxsize, &actread);
1114 	if (ret)
1115 		return ret;
1116 	else
1117 		return actread;
1118 }
1119 
fat_read_file(const char * filename,void * buf,loff_t offset,loff_t len,loff_t * actread)1120 int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
1121 		  loff_t *actread)
1122 {
1123 	int ret;
1124 
1125 	ret = file_fat_read_at(filename, offset, buf, len, actread);
1126 	if (ret)
1127 		printf("** Unable to read file %s **\n", filename);
1128 
1129 	return ret;
1130 }
1131 
1132 typedef struct {
1133 	struct fs_dir_stream parent;
1134 	struct fs_dirent dirent;
1135 	fsdata fsdata;
1136 	fat_itr itr;
1137 } fat_dir;
1138 
fat_opendir(const char * filename,struct fs_dir_stream ** dirsp)1139 int fat_opendir(const char *filename, struct fs_dir_stream **dirsp)
1140 {
1141 	fat_dir *dir;
1142 	int ret;
1143 
1144 	dir = malloc_cache_aligned(sizeof(*dir));
1145 	if (!dir)
1146 		return -ENOMEM;
1147 	memset(dir, 0, sizeof(*dir));
1148 
1149 	ret = fat_itr_root(&dir->itr, &dir->fsdata);
1150 	if (ret)
1151 		goto fail_free_dir;
1152 
1153 	ret = fat_itr_resolve(&dir->itr, filename, TYPE_DIR);
1154 	if (ret)
1155 		goto fail_free_both;
1156 
1157 	*dirsp = (struct fs_dir_stream *)dir;
1158 	return 0;
1159 
1160 fail_free_both:
1161 	free(dir->fsdata.fatbuf);
1162 fail_free_dir:
1163 	free(dir);
1164 	return ret;
1165 }
1166 
fat_readdir(struct fs_dir_stream * dirs,struct fs_dirent ** dentp)1167 int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp)
1168 {
1169 	fat_dir *dir = (fat_dir *)dirs;
1170 	struct fs_dirent *dent = &dir->dirent;
1171 
1172 	if (!fat_itr_next(&dir->itr))
1173 		return -ENOENT;
1174 
1175 	memset(dent, 0, sizeof(*dent));
1176 	strcpy(dent->name, dir->itr.name);
1177 
1178 	if (fat_itr_isdir(&dir->itr)) {
1179 		dent->type = FS_DT_DIR;
1180 	} else {
1181 		dent->type = FS_DT_REG;
1182 		dent->size = FAT2CPU32(dir->itr.dent->size);
1183 	}
1184 
1185 	*dentp = dent;
1186 
1187 	return 0;
1188 }
1189 
fat_closedir(struct fs_dir_stream * dirs)1190 void fat_closedir(struct fs_dir_stream *dirs)
1191 {
1192 	fat_dir *dir = (fat_dir *)dirs;
1193 	free(dir->fsdata.fatbuf);
1194 	free(dir);
1195 }
1196 
fat_close(void)1197 void fat_close(void)
1198 {
1199 }
1200