1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * fat_write.c
4 *
5 * R/W (V)FAT 12/16/32 filesystem implementation by Donggeun Kim
6 */
7
8 #include <common.h>
9 #include <command.h>
10 #include <config.h>
11 #include <fat.h>
12 #include <asm/byteorder.h>
13 #include <part.h>
14 #include <linux/ctype.h>
15 #include <div64.h>
16 #include <linux/math64.h>
17 #include "fat.c"
18
uppercase(char * str,int len)19 static void uppercase(char *str, int len)
20 {
21 int i;
22
23 for (i = 0; i < len; i++) {
24 *str = toupper(*str);
25 str++;
26 }
27 }
28
29 static int total_sector;
disk_write(__u32 block,__u32 nr_blocks,void * buf)30 static int disk_write(__u32 block, __u32 nr_blocks, void *buf)
31 {
32 ulong ret;
33
34 if (!cur_dev)
35 return -1;
36
37 if (cur_part_info.start + block + nr_blocks >
38 cur_part_info.start + total_sector) {
39 printf("error: overflow occurs\n");
40 return -1;
41 }
42
43 ret = blk_dwrite(cur_dev, cur_part_info.start + block, nr_blocks, buf);
44 if (nr_blocks && ret == 0)
45 return -1;
46
47 return ret;
48 }
49
50 /*
51 * Set short name in directory entry
52 */
set_name(dir_entry * dirent,const char * filename)53 static void set_name(dir_entry *dirent, const char *filename)
54 {
55 char s_name[VFAT_MAXLEN_BYTES];
56 char *period;
57 int period_location, len, i, ext_num;
58
59 if (filename == NULL)
60 return;
61
62 len = strlen(filename);
63 if (len == 0)
64 return;
65
66 strcpy(s_name, filename);
67 uppercase(s_name, len);
68
69 period = strchr(s_name, '.');
70 if (period == NULL) {
71 period_location = len;
72 ext_num = 0;
73 } else {
74 period_location = period - s_name;
75 ext_num = len - period_location - 1;
76 }
77
78 /* Pad spaces when the length of file name is shorter than eight */
79 if (period_location < 8) {
80 memcpy(dirent->name, s_name, period_location);
81 for (i = period_location; i < 8; i++)
82 dirent->name[i] = ' ';
83 } else if (period_location == 8) {
84 memcpy(dirent->name, s_name, period_location);
85 } else {
86 memcpy(dirent->name, s_name, 6);
87 dirent->name[6] = '~';
88 dirent->name[7] = '1';
89 }
90
91 if (ext_num < 3) {
92 memcpy(dirent->ext, s_name + period_location + 1, ext_num);
93 for (i = ext_num; i < 3; i++)
94 dirent->ext[i] = ' ';
95 } else
96 memcpy(dirent->ext, s_name + period_location + 1, 3);
97
98 debug("name : %s\n", dirent->name);
99 debug("ext : %s\n", dirent->ext);
100 }
101
102 /*
103 * Write fat buffer into block device
104 */
flush_dirty_fat_buffer(fsdata * mydata)105 static int flush_dirty_fat_buffer(fsdata *mydata)
106 {
107 int getsize = FATBUFBLOCKS;
108 __u32 fatlength = mydata->fatlength;
109 __u8 *bufptr = mydata->fatbuf;
110 __u32 startblock = mydata->fatbufnum * FATBUFBLOCKS;
111
112 debug("debug: evicting %d, dirty: %d\n", mydata->fatbufnum,
113 (int)mydata->fat_dirty);
114
115 if ((!mydata->fat_dirty) || (mydata->fatbufnum == -1))
116 return 0;
117
118 /* Cap length if fatlength is not a multiple of FATBUFBLOCKS */
119 if (startblock + getsize > fatlength)
120 getsize = fatlength - startblock;
121
122 startblock += mydata->fat_sect;
123
124 /* Write FAT buf */
125 if (disk_write(startblock, getsize, bufptr) < 0) {
126 debug("error: writing FAT blocks\n");
127 return -1;
128 }
129
130 if (mydata->fats == 2) {
131 /* Update corresponding second FAT blocks */
132 startblock += mydata->fatlength;
133 if (disk_write(startblock, getsize, bufptr) < 0) {
134 debug("error: writing second FAT blocks\n");
135 return -1;
136 }
137 }
138 mydata->fat_dirty = 0;
139
140 return 0;
141 }
142
143 /*
144 * Set the file name information from 'name' into 'slotptr',
145 */
str2slot(dir_slot * slotptr,const char * name,int * idx)146 static int str2slot(dir_slot *slotptr, const char *name, int *idx)
147 {
148 int j, end_idx = 0;
149
150 for (j = 0; j <= 8; j += 2) {
151 if (name[*idx] == 0x00) {
152 slotptr->name0_4[j] = 0;
153 slotptr->name0_4[j + 1] = 0;
154 end_idx++;
155 goto name0_4;
156 }
157 slotptr->name0_4[j] = name[*idx];
158 (*idx)++;
159 end_idx++;
160 }
161 for (j = 0; j <= 10; j += 2) {
162 if (name[*idx] == 0x00) {
163 slotptr->name5_10[j] = 0;
164 slotptr->name5_10[j + 1] = 0;
165 end_idx++;
166 goto name5_10;
167 }
168 slotptr->name5_10[j] = name[*idx];
169 (*idx)++;
170 end_idx++;
171 }
172 for (j = 0; j <= 2; j += 2) {
173 if (name[*idx] == 0x00) {
174 slotptr->name11_12[j] = 0;
175 slotptr->name11_12[j + 1] = 0;
176 end_idx++;
177 goto name11_12;
178 }
179 slotptr->name11_12[j] = name[*idx];
180 (*idx)++;
181 end_idx++;
182 }
183
184 if (name[*idx] == 0x00)
185 return 1;
186
187 return 0;
188 /* Not used characters are filled with 0xff 0xff */
189 name0_4:
190 for (; end_idx < 5; end_idx++) {
191 slotptr->name0_4[end_idx * 2] = 0xff;
192 slotptr->name0_4[end_idx * 2 + 1] = 0xff;
193 }
194 end_idx = 5;
195 name5_10:
196 end_idx -= 5;
197 for (; end_idx < 6; end_idx++) {
198 slotptr->name5_10[end_idx * 2] = 0xff;
199 slotptr->name5_10[end_idx * 2 + 1] = 0xff;
200 }
201 end_idx = 11;
202 name11_12:
203 end_idx -= 11;
204 for (; end_idx < 2; end_idx++) {
205 slotptr->name11_12[end_idx * 2] = 0xff;
206 slotptr->name11_12[end_idx * 2 + 1] = 0xff;
207 }
208
209 return 1;
210 }
211
212 static int flush_dir_table(fat_itr *itr);
213
214 /*
215 * Fill dir_slot entries with appropriate name, id, and attr
216 * 'itr' will point to a next entry
217 */
218 static int
fill_dir_slot(fat_itr * itr,const char * l_name)219 fill_dir_slot(fat_itr *itr, const char *l_name)
220 {
221 __u8 temp_dir_slot_buffer[MAX_LFN_SLOT * sizeof(dir_slot)];
222 dir_slot *slotptr = (dir_slot *)temp_dir_slot_buffer;
223 __u8 counter = 0, checksum;
224 int idx = 0, ret;
225
226 /* Get short file name checksum value */
227 checksum = mkcksum(itr->dent->name, itr->dent->ext);
228
229 do {
230 memset(slotptr, 0x00, sizeof(dir_slot));
231 ret = str2slot(slotptr, l_name, &idx);
232 slotptr->id = ++counter;
233 slotptr->attr = ATTR_VFAT;
234 slotptr->alias_checksum = checksum;
235 slotptr++;
236 } while (ret == 0);
237
238 slotptr--;
239 slotptr->id |= LAST_LONG_ENTRY_MASK;
240
241 while (counter >= 1) {
242 memcpy(itr->dent, slotptr, sizeof(dir_slot));
243 slotptr--;
244 counter--;
245 if (!fat_itr_next(itr))
246 if (!itr->dent && !itr->is_root && flush_dir_table(itr))
247 return -1;
248 }
249
250 if (!itr->dent && !itr->is_root)
251 /*
252 * don't care return value here because we have already
253 * finished completing an entry with name, only ending up
254 * no more entry left
255 */
256 flush_dir_table(itr);
257
258 return 0;
259 }
260
261 /*
262 * Set the entry at index 'entry' in a FAT (12/16/32) table.
263 */
set_fatent_value(fsdata * mydata,__u32 entry,__u32 entry_value)264 static int set_fatent_value(fsdata *mydata, __u32 entry, __u32 entry_value)
265 {
266 __u32 bufnum, offset, off16;
267 __u16 val1, val2;
268
269 switch (mydata->fatsize) {
270 case 32:
271 bufnum = entry / FAT32BUFSIZE;
272 offset = entry - bufnum * FAT32BUFSIZE;
273 break;
274 case 16:
275 bufnum = entry / FAT16BUFSIZE;
276 offset = entry - bufnum * FAT16BUFSIZE;
277 break;
278 case 12:
279 bufnum = entry / FAT12BUFSIZE;
280 offset = entry - bufnum * FAT12BUFSIZE;
281 break;
282 default:
283 /* Unsupported FAT size */
284 return -1;
285 }
286
287 /* Read a new block of FAT entries into the cache. */
288 if (bufnum != mydata->fatbufnum) {
289 int getsize = FATBUFBLOCKS;
290 __u8 *bufptr = mydata->fatbuf;
291 __u32 fatlength = mydata->fatlength;
292 __u32 startblock = bufnum * FATBUFBLOCKS;
293
294 /* Cap length if fatlength is not a multiple of FATBUFBLOCKS */
295 if (startblock + getsize > fatlength)
296 getsize = fatlength - startblock;
297
298 if (flush_dirty_fat_buffer(mydata) < 0)
299 return -1;
300
301 startblock += mydata->fat_sect;
302
303 if (disk_read(startblock, getsize, bufptr) < 0) {
304 debug("Error reading FAT blocks\n");
305 return -1;
306 }
307 mydata->fatbufnum = bufnum;
308 }
309
310 /* Mark as dirty */
311 mydata->fat_dirty = 1;
312
313 /* Set the actual entry */
314 switch (mydata->fatsize) {
315 case 32:
316 ((__u32 *) mydata->fatbuf)[offset] = cpu_to_le32(entry_value);
317 break;
318 case 16:
319 ((__u16 *) mydata->fatbuf)[offset] = cpu_to_le16(entry_value);
320 break;
321 case 12:
322 off16 = (offset * 3) / 4;
323
324 switch (offset & 0x3) {
325 case 0:
326 val1 = cpu_to_le16(entry_value) & 0xfff;
327 ((__u16 *)mydata->fatbuf)[off16] &= ~0xfff;
328 ((__u16 *)mydata->fatbuf)[off16] |= val1;
329 break;
330 case 1:
331 val1 = cpu_to_le16(entry_value) & 0xf;
332 val2 = (cpu_to_le16(entry_value) >> 4) & 0xff;
333
334 ((__u16 *)mydata->fatbuf)[off16] &= ~0xf000;
335 ((__u16 *)mydata->fatbuf)[off16] |= (val1 << 12);
336
337 ((__u16 *)mydata->fatbuf)[off16 + 1] &= ~0xff;
338 ((__u16 *)mydata->fatbuf)[off16 + 1] |= val2;
339 break;
340 case 2:
341 val1 = cpu_to_le16(entry_value) & 0xff;
342 val2 = (cpu_to_le16(entry_value) >> 8) & 0xf;
343
344 ((__u16 *)mydata->fatbuf)[off16] &= ~0xff00;
345 ((__u16 *)mydata->fatbuf)[off16] |= (val1 << 8);
346
347 ((__u16 *)mydata->fatbuf)[off16 + 1] &= ~0xf;
348 ((__u16 *)mydata->fatbuf)[off16 + 1] |= val2;
349 break;
350 case 3:
351 val1 = cpu_to_le16(entry_value) & 0xfff;
352 ((__u16 *)mydata->fatbuf)[off16] &= ~0xfff0;
353 ((__u16 *)mydata->fatbuf)[off16] |= (val1 << 4);
354 break;
355 default:
356 break;
357 }
358
359 break;
360 default:
361 return -1;
362 }
363
364 return 0;
365 }
366
367 /*
368 * Determine the next free cluster after 'entry' in a FAT (12/16/32) table
369 * and link it to 'entry'. EOC marker is not set on returned entry.
370 */
determine_fatent(fsdata * mydata,__u32 entry)371 static __u32 determine_fatent(fsdata *mydata, __u32 entry)
372 {
373 __u32 next_fat, next_entry = entry + 1;
374
375 while (1) {
376 next_fat = get_fatent(mydata, next_entry);
377 if (next_fat == 0) {
378 /* found free entry, link to entry */
379 set_fatent_value(mydata, entry, next_entry);
380 break;
381 }
382 next_entry++;
383 }
384 debug("FAT%d: entry: %08x, entry_value: %04x\n",
385 mydata->fatsize, entry, next_entry);
386
387 return next_entry;
388 }
389
390 /**
391 * set_cluster() - write data to cluster
392 *
393 * Write 'size' bytes from 'buffer' into the specified cluster.
394 *
395 * @mydata: data to be written
396 * @clustnum: cluster to be written to
397 * @buffer: data to be written
398 * @size: bytes to be written (but not more than the size of a cluster)
399 * Return: 0 on success, -1 otherwise
400 */
401 static int
set_cluster(fsdata * mydata,u32 clustnum,u8 * buffer,u32 size)402 set_cluster(fsdata *mydata, u32 clustnum, u8 *buffer, u32 size)
403 {
404 u32 idx = 0;
405 u32 startsect;
406 int ret;
407
408 if (clustnum > 0)
409 startsect = clust_to_sect(mydata, clustnum);
410 else
411 startsect = mydata->rootdir_sect;
412
413 debug("clustnum: %d, startsect: %d\n", clustnum, startsect);
414
415 if ((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1)) {
416 ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
417
418 debug("FAT: Misaligned buffer address (%p)\n", buffer);
419
420 while (size >= mydata->sect_size) {
421 memcpy(tmpbuf, buffer, mydata->sect_size);
422 ret = disk_write(startsect++, 1, tmpbuf);
423 if (ret != 1) {
424 debug("Error writing data (got %d)\n", ret);
425 return -1;
426 }
427
428 buffer += mydata->sect_size;
429 size -= mydata->sect_size;
430 }
431 } else if (size >= mydata->sect_size) {
432 idx = size / mydata->sect_size;
433 ret = disk_write(startsect, idx, buffer);
434 if (ret != idx) {
435 debug("Error writing data (got %d)\n", ret);
436 return -1;
437 }
438
439 startsect += idx;
440 idx *= mydata->sect_size;
441 buffer += idx;
442 size -= idx;
443 }
444
445 if (size) {
446 ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
447 /* Do not leak content of stack */
448 memset(tmpbuf, 0, mydata->sect_size);
449 memcpy(tmpbuf, buffer, size);
450 ret = disk_write(startsect, 1, tmpbuf);
451 if (ret != 1) {
452 debug("Error writing data (got %d)\n", ret);
453 return -1;
454 }
455 }
456
457 return 0;
458 }
459
460 static __u8 tmpbuf_cluster[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);
461
462 /*
463 * Read and modify data on existing and consecutive cluster blocks
464 */
465 static int
get_set_cluster(fsdata * mydata,__u32 clustnum,loff_t pos,__u8 * buffer,loff_t size,loff_t * gotsize)466 get_set_cluster(fsdata *mydata, __u32 clustnum, loff_t pos, __u8 *buffer,
467 loff_t size, loff_t *gotsize)
468 {
469 unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
470 __u32 startsect;
471 loff_t wsize;
472 int clustcount, i, ret;
473
474 *gotsize = 0;
475 if (!size)
476 return 0;
477
478 assert(pos < bytesperclust);
479 startsect = clust_to_sect(mydata, clustnum);
480
481 debug("clustnum: %d, startsect: %d, pos: %lld\n",
482 clustnum, startsect, pos);
483
484 /* partial write at beginning */
485 if (pos) {
486 wsize = min(bytesperclust - pos, size);
487 ret = disk_read(startsect, mydata->clust_size, tmpbuf_cluster);
488 if (ret != mydata->clust_size) {
489 debug("Error reading data (got %d)\n", ret);
490 return -1;
491 }
492
493 memcpy(tmpbuf_cluster + pos, buffer, wsize);
494 ret = disk_write(startsect, mydata->clust_size, tmpbuf_cluster);
495 if (ret != mydata->clust_size) {
496 debug("Error writing data (got %d)\n", ret);
497 return -1;
498 }
499
500 size -= wsize;
501 buffer += wsize;
502 *gotsize += wsize;
503
504 startsect += mydata->clust_size;
505
506 if (!size)
507 return 0;
508 }
509
510 /* full-cluster write */
511 if (size >= bytesperclust) {
512 clustcount = lldiv(size, bytesperclust);
513
514 if (!((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1))) {
515 wsize = clustcount * bytesperclust;
516 ret = disk_write(startsect,
517 clustcount * mydata->clust_size,
518 buffer);
519 if (ret != clustcount * mydata->clust_size) {
520 debug("Error writing data (got %d)\n", ret);
521 return -1;
522 }
523
524 size -= wsize;
525 buffer += wsize;
526 *gotsize += wsize;
527
528 startsect += clustcount * mydata->clust_size;
529 } else {
530 for (i = 0; i < clustcount; i++) {
531 memcpy(tmpbuf_cluster, buffer, bytesperclust);
532 ret = disk_write(startsect,
533 mydata->clust_size,
534 tmpbuf_cluster);
535 if (ret != mydata->clust_size) {
536 debug("Error writing data (got %d)\n",
537 ret);
538 return -1;
539 }
540
541 size -= bytesperclust;
542 buffer += bytesperclust;
543 *gotsize += bytesperclust;
544
545 startsect += mydata->clust_size;
546 }
547 }
548 }
549
550 /* partial write at end */
551 if (size) {
552 wsize = size;
553 ret = disk_read(startsect, mydata->clust_size, tmpbuf_cluster);
554 if (ret != mydata->clust_size) {
555 debug("Error reading data (got %d)\n", ret);
556 return -1;
557 }
558 memcpy(tmpbuf_cluster, buffer, wsize);
559 ret = disk_write(startsect, mydata->clust_size, tmpbuf_cluster);
560 if (ret != mydata->clust_size) {
561 debug("Error writing data (got %d)\n", ret);
562 return -1;
563 }
564
565 size -= wsize;
566 buffer += wsize;
567 *gotsize += wsize;
568 }
569
570 assert(!size);
571
572 return 0;
573 }
574
575 /*
576 * Find the first empty cluster
577 */
find_empty_cluster(fsdata * mydata)578 static int find_empty_cluster(fsdata *mydata)
579 {
580 __u32 fat_val, entry = 3;
581
582 while (1) {
583 fat_val = get_fatent(mydata, entry);
584 if (fat_val == 0)
585 break;
586 entry++;
587 }
588
589 return entry;
590 }
591
592 /*
593 * Write directory entries in itr's buffer to block device
594 */
flush_dir_table(fat_itr * itr)595 static int flush_dir_table(fat_itr *itr)
596 {
597 fsdata *mydata = itr->fsdata;
598 int dir_newclust = 0;
599 unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
600
601 if (set_cluster(mydata, itr->clust, itr->block, bytesperclust) != 0) {
602 printf("error: writing directory entry\n");
603 return -1;
604 }
605 dir_newclust = find_empty_cluster(mydata);
606 set_fatent_value(mydata, itr->clust, dir_newclust);
607 if (mydata->fatsize == 32)
608 set_fatent_value(mydata, dir_newclust, 0xffffff8);
609 else if (mydata->fatsize == 16)
610 set_fatent_value(mydata, dir_newclust, 0xfff8);
611 else if (mydata->fatsize == 12)
612 set_fatent_value(mydata, dir_newclust, 0xff8);
613
614 itr->clust = dir_newclust;
615 itr->next_clust = dir_newclust;
616
617 if (flush_dirty_fat_buffer(mydata) < 0)
618 return -1;
619
620 memset(itr->block, 0x00, bytesperclust);
621
622 itr->dent = (dir_entry *)itr->block;
623 itr->last_cluster = 1;
624 itr->remaining = bytesperclust / sizeof(dir_entry) - 1;
625
626 return 0;
627 }
628
629 /*
630 * Set empty cluster from 'entry' to the end of a file
631 */
clear_fatent(fsdata * mydata,__u32 entry)632 static int clear_fatent(fsdata *mydata, __u32 entry)
633 {
634 __u32 fat_val;
635
636 while (!CHECK_CLUST(entry, mydata->fatsize)) {
637 fat_val = get_fatent(mydata, entry);
638 if (fat_val != 0)
639 set_fatent_value(mydata, entry, 0);
640 else
641 break;
642
643 entry = fat_val;
644 }
645
646 /* Flush fat buffer */
647 if (flush_dirty_fat_buffer(mydata) < 0)
648 return -1;
649
650 return 0;
651 }
652
653 /*
654 * Set start cluster in directory entry
655 */
set_start_cluster(const fsdata * mydata,dir_entry * dentptr,__u32 start_cluster)656 static void set_start_cluster(const fsdata *mydata, dir_entry *dentptr,
657 __u32 start_cluster)
658 {
659 if (mydata->fatsize == 32)
660 dentptr->starthi =
661 cpu_to_le16((start_cluster & 0xffff0000) >> 16);
662 dentptr->start = cpu_to_le16(start_cluster & 0xffff);
663 }
664
665 /*
666 * Check whether adding a file makes the file system to
667 * exceed the size of the block device
668 * Return -1 when overflow occurs, otherwise return 0
669 */
check_overflow(fsdata * mydata,__u32 clustnum,loff_t size)670 static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
671 {
672 __u32 startsect, sect_num, offset;
673
674 if (clustnum > 0)
675 startsect = clust_to_sect(mydata, clustnum);
676 else
677 startsect = mydata->rootdir_sect;
678
679 sect_num = div_u64_rem(size, mydata->sect_size, &offset);
680
681 if (offset != 0)
682 sect_num++;
683
684 if (startsect + sect_num > total_sector)
685 return -1;
686 return 0;
687 }
688
689 /*
690 * Write at most 'maxsize' bytes from 'buffer' into
691 * the file associated with 'dentptr'
692 * Update the number of bytes written in *gotsize and return 0
693 * or return -1 on fatal errors.
694 */
695 static int
set_contents(fsdata * mydata,dir_entry * dentptr,loff_t pos,__u8 * buffer,loff_t maxsize,loff_t * gotsize)696 set_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos, __u8 *buffer,
697 loff_t maxsize, loff_t *gotsize)
698 {
699 unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
700 __u32 curclust = START(dentptr);
701 __u32 endclust = 0, newclust = 0;
702 u64 cur_pos, filesize;
703 loff_t offset, actsize, wsize;
704
705 *gotsize = 0;
706 filesize = pos + maxsize;
707
708 debug("%llu bytes\n", filesize);
709
710 if (!filesize) {
711 if (!curclust)
712 return 0;
713 if (!CHECK_CLUST(curclust, mydata->fatsize) ||
714 IS_LAST_CLUST(curclust, mydata->fatsize)) {
715 clear_fatent(mydata, curclust);
716 set_start_cluster(mydata, dentptr, 0);
717 return 0;
718 }
719 debug("curclust: 0x%x\n", curclust);
720 debug("Invalid FAT entry\n");
721 return -1;
722 }
723
724 if (!curclust) {
725 assert(pos == 0);
726 goto set_clusters;
727 }
728
729 /* go to cluster at pos */
730 cur_pos = bytesperclust;
731 while (1) {
732 if (pos <= cur_pos)
733 break;
734 if (IS_LAST_CLUST(curclust, mydata->fatsize))
735 break;
736
737 newclust = get_fatent(mydata, curclust);
738 if (!IS_LAST_CLUST(newclust, mydata->fatsize) &&
739 CHECK_CLUST(newclust, mydata->fatsize)) {
740 debug("curclust: 0x%x\n", curclust);
741 debug("Invalid FAT entry\n");
742 return -1;
743 }
744
745 cur_pos += bytesperclust;
746 curclust = newclust;
747 }
748 if (IS_LAST_CLUST(curclust, mydata->fatsize)) {
749 assert(pos == cur_pos);
750 goto set_clusters;
751 }
752
753 assert(pos < cur_pos);
754 cur_pos -= bytesperclust;
755
756 /* overwrite */
757 assert(IS_LAST_CLUST(curclust, mydata->fatsize) ||
758 !CHECK_CLUST(curclust, mydata->fatsize));
759
760 while (1) {
761 /* search for allocated consecutive clusters */
762 actsize = bytesperclust;
763 endclust = curclust;
764 while (1) {
765 if (filesize <= (cur_pos + actsize))
766 break;
767
768 newclust = get_fatent(mydata, endclust);
769
770 if (IS_LAST_CLUST(newclust, mydata->fatsize))
771 break;
772 if (CHECK_CLUST(newclust, mydata->fatsize)) {
773 debug("curclust: 0x%x\n", curclust);
774 debug("Invalid FAT entry\n");
775 return -1;
776 }
777
778 actsize += bytesperclust;
779 endclust = newclust;
780 }
781
782 /* overwrite to <curclust..endclust> */
783 if (pos < cur_pos)
784 offset = 0;
785 else
786 offset = pos - cur_pos;
787 wsize = min(cur_pos + actsize, filesize) - pos;
788 if (get_set_cluster(mydata, curclust, offset,
789 buffer, wsize, &actsize)) {
790 printf("Error get-and-setting cluster\n");
791 return -1;
792 }
793 buffer += wsize;
794 *gotsize += wsize;
795 cur_pos += offset + wsize;
796
797 if (filesize <= cur_pos)
798 break;
799
800 /* CHECK: newclust = get_fatent(mydata, endclust); */
801
802 if (IS_LAST_CLUST(newclust, mydata->fatsize))
803 /* no more clusters */
804 break;
805
806 curclust = newclust;
807 }
808
809 if (filesize <= cur_pos) {
810 /* no more write */
811 newclust = get_fatent(mydata, endclust);
812 if (!IS_LAST_CLUST(newclust, mydata->fatsize)) {
813 /* truncate the rest */
814 clear_fatent(mydata, newclust);
815
816 /* Mark end of file in FAT */
817 if (mydata->fatsize == 12)
818 newclust = 0xfff;
819 else if (mydata->fatsize == 16)
820 newclust = 0xffff;
821 else if (mydata->fatsize == 32)
822 newclust = 0xfffffff;
823 set_fatent_value(mydata, endclust, newclust);
824 }
825
826 return 0;
827 }
828
829 curclust = endclust;
830 filesize -= cur_pos;
831 assert(!do_div(cur_pos, bytesperclust));
832
833 set_clusters:
834 /* allocate and write */
835 assert(!pos);
836
837 /* Assure that curclust is valid */
838 if (!curclust) {
839 curclust = find_empty_cluster(mydata);
840 set_start_cluster(mydata, dentptr, curclust);
841 } else {
842 newclust = get_fatent(mydata, curclust);
843
844 if (IS_LAST_CLUST(newclust, mydata->fatsize)) {
845 newclust = determine_fatent(mydata, curclust);
846 set_fatent_value(mydata, curclust, newclust);
847 curclust = newclust;
848 } else {
849 debug("error: something wrong\n");
850 return -1;
851 }
852 }
853
854 /* TODO: already partially written */
855 if (check_overflow(mydata, curclust, filesize)) {
856 printf("Error: no space left: %llu\n", filesize);
857 return -1;
858 }
859
860 actsize = bytesperclust;
861 endclust = curclust;
862 do {
863 /* search for consecutive clusters */
864 while (actsize < filesize) {
865 newclust = determine_fatent(mydata, endclust);
866
867 if ((newclust - 1) != endclust)
868 /* write to <curclust..endclust> */
869 goto getit;
870
871 if (CHECK_CLUST(newclust, mydata->fatsize)) {
872 debug("newclust: 0x%x\n", newclust);
873 debug("Invalid FAT entry\n");
874 return 0;
875 }
876 endclust = newclust;
877 actsize += bytesperclust;
878 }
879
880 /* set remaining bytes */
881 actsize = filesize;
882 if (set_cluster(mydata, curclust, buffer, (u32)actsize) != 0) {
883 debug("error: writing cluster\n");
884 return -1;
885 }
886 *gotsize += actsize;
887
888 /* Mark end of file in FAT */
889 if (mydata->fatsize == 12)
890 newclust = 0xfff;
891 else if (mydata->fatsize == 16)
892 newclust = 0xffff;
893 else if (mydata->fatsize == 32)
894 newclust = 0xfffffff;
895 set_fatent_value(mydata, endclust, newclust);
896
897 return 0;
898 getit:
899 if (set_cluster(mydata, curclust, buffer, (u32)actsize) != 0) {
900 debug("error: writing cluster\n");
901 return -1;
902 }
903 *gotsize += actsize;
904 filesize -= actsize;
905 buffer += actsize;
906
907 if (CHECK_CLUST(newclust, mydata->fatsize)) {
908 debug("newclust: 0x%x\n", newclust);
909 debug("Invalid FAT entry\n");
910 return 0;
911 }
912 actsize = bytesperclust;
913 curclust = endclust = newclust;
914 } while (1);
915
916 return 0;
917 }
918
919 /*
920 * Fill dir_entry
921 */
fill_dentry(fsdata * mydata,dir_entry * dentptr,const char * filename,__u32 start_cluster,__u32 size,__u8 attr)922 static void fill_dentry(fsdata *mydata, dir_entry *dentptr,
923 const char *filename, __u32 start_cluster, __u32 size, __u8 attr)
924 {
925 set_start_cluster(mydata, dentptr, start_cluster);
926 dentptr->size = cpu_to_le32(size);
927
928 dentptr->attr = attr;
929
930 set_name(dentptr, filename);
931 }
932
933 /*
934 * Find a directory entry based on filename or start cluster number
935 * If the directory entry is not found,
936 * the new position for writing a directory entry will be returned
937 */
find_directory_entry(fat_itr * itr,char * filename)938 static dir_entry *find_directory_entry(fat_itr *itr, char *filename)
939 {
940 int match = 0;
941
942 while (fat_itr_next(itr)) {
943 /* check both long and short name: */
944 if (!strcasecmp(filename, itr->name))
945 match = 1;
946 else if (itr->name != itr->s_name &&
947 !strcasecmp(filename, itr->s_name))
948 match = 1;
949
950 if (!match)
951 continue;
952
953 if (itr->dent->name[0] == '\0')
954 return NULL;
955 else
956 return itr->dent;
957 }
958
959 if (!itr->dent && !itr->is_root && flush_dir_table(itr))
960 /* indicate that allocating dent failed */
961 itr->dent = NULL;
962
963 return NULL;
964 }
965
split_filename(char * filename,char ** dirname,char ** basename)966 static int split_filename(char *filename, char **dirname, char **basename)
967 {
968 char *p, *last_slash, *last_slash_cont;
969
970 again:
971 p = filename;
972 last_slash = NULL;
973 last_slash_cont = NULL;
974 while (*p) {
975 if (ISDIRDELIM(*p)) {
976 last_slash = p;
977 last_slash_cont = p;
978 /* continuous slashes */
979 while (ISDIRDELIM(*p))
980 last_slash_cont = p++;
981 if (!*p)
982 break;
983 }
984 p++;
985 }
986
987 if (last_slash) {
988 if (last_slash_cont == (filename + strlen(filename) - 1)) {
989 /* remove trailing slashes */
990 *last_slash = '\0';
991 goto again;
992 }
993
994 if (last_slash == filename) {
995 /* avoid ""(null) directory */
996 *dirname = "/";
997 } else {
998 *last_slash = '\0';
999 *dirname = filename;
1000 }
1001
1002 *last_slash_cont = '\0';
1003 *basename = last_slash_cont + 1;
1004 } else {
1005 *dirname = "/"; /* root by default */
1006 *basename = filename;
1007 }
1008
1009 return 0;
1010 }
1011
normalize_longname(char * l_filename,const char * filename)1012 static int normalize_longname(char *l_filename, const char *filename)
1013 {
1014 const char *p, legal[] = "!#$%&\'()-.@^`_{}~";
1015 unsigned char c;
1016 int name_len;
1017
1018 /* Check that the filename is valid */
1019 for (p = filename; p < filename + strlen(filename); p++) {
1020 c = *p;
1021
1022 if (('0' <= c) && (c <= '9'))
1023 continue;
1024 if (('A' <= c) && (c <= 'Z'))
1025 continue;
1026 if (('a' <= c) && (c <= 'z'))
1027 continue;
1028 if (strchr(legal, c))
1029 continue;
1030 /* extended code */
1031 if ((0x80 <= c) && (c <= 0xff))
1032 continue;
1033
1034 return -1;
1035 }
1036
1037 /* Normalize it */
1038 name_len = strlen(filename);
1039 if (name_len >= VFAT_MAXLEN_BYTES)
1040 /* should return an error? */
1041 name_len = VFAT_MAXLEN_BYTES - 1;
1042
1043 memcpy(l_filename, filename, name_len);
1044 l_filename[name_len] = 0; /* terminate the string */
1045 downcase(l_filename, INT_MAX);
1046
1047 return 0;
1048 }
1049
file_fat_write_at(const char * filename,loff_t pos,void * buffer,loff_t size,loff_t * actwrite)1050 int file_fat_write_at(const char *filename, loff_t pos, void *buffer,
1051 loff_t size, loff_t *actwrite)
1052 {
1053 dir_entry *retdent;
1054 fsdata datablock = { .fatbuf = NULL, };
1055 fsdata *mydata = &datablock;
1056 fat_itr *itr = NULL;
1057 int ret = -1;
1058 char *filename_copy, *parent, *basename;
1059 char l_filename[VFAT_MAXLEN_BYTES];
1060
1061 debug("writing %s\n", filename);
1062
1063 filename_copy = strdup(filename);
1064 if (!filename_copy)
1065 return -ENOMEM;
1066
1067 split_filename(filename_copy, &parent, &basename);
1068 if (!strlen(basename)) {
1069 ret = -EINVAL;
1070 goto exit;
1071 }
1072
1073 filename = basename;
1074 if (normalize_longname(l_filename, filename)) {
1075 printf("FAT: illegal filename (%s)\n", filename);
1076 ret = -EINVAL;
1077 goto exit;
1078 }
1079
1080 itr = malloc_cache_aligned(sizeof(fat_itr));
1081 if (!itr) {
1082 ret = -ENOMEM;
1083 goto exit;
1084 }
1085
1086 ret = fat_itr_root(itr, &datablock);
1087 if (ret)
1088 goto exit;
1089
1090 total_sector = datablock.total_sect;
1091
1092 ret = fat_itr_resolve(itr, parent, TYPE_DIR);
1093 if (ret) {
1094 printf("%s: doesn't exist (%d)\n", parent, ret);
1095 goto exit;
1096 }
1097
1098 retdent = find_directory_entry(itr, l_filename);
1099
1100 if (retdent) {
1101 if (fat_itr_isdir(itr)) {
1102 ret = -EISDIR;
1103 goto exit;
1104 }
1105
1106 /* A file exists */
1107 if (pos == -1)
1108 /* Append to the end */
1109 pos = FAT2CPU32(retdent->size);
1110 if (pos > retdent->size) {
1111 /* No hole allowed */
1112 ret = -EINVAL;
1113 goto exit;
1114 }
1115
1116 /* Update file size in a directory entry */
1117 retdent->size = cpu_to_le32(pos + size);
1118 } else {
1119 /* Create a new file */
1120
1121 if (itr->is_root) {
1122 /* root dir cannot have "." or ".." */
1123 if (!strcmp(l_filename, ".") ||
1124 !strcmp(l_filename, "..")) {
1125 ret = -EINVAL;
1126 goto exit;
1127 }
1128 }
1129
1130 if (!itr->dent) {
1131 printf("Error: allocating new dir entry\n");
1132 ret = -EIO;
1133 goto exit;
1134 }
1135
1136 if (pos) {
1137 /* No hole allowed */
1138 ret = -EINVAL;
1139 goto exit;
1140 }
1141
1142 memset(itr->dent, 0, sizeof(*itr->dent));
1143
1144 /* Set short name to set alias checksum field in dir_slot */
1145 set_name(itr->dent, filename);
1146 if (fill_dir_slot(itr, filename)) {
1147 ret = -EIO;
1148 goto exit;
1149 }
1150
1151 /* Set attribute as archive for regular file */
1152 fill_dentry(itr->fsdata, itr->dent, filename, 0, size, 0x20);
1153
1154 retdent = itr->dent;
1155 }
1156
1157 ret = set_contents(mydata, retdent, pos, buffer, size, actwrite);
1158 if (ret < 0) {
1159 printf("Error: writing contents\n");
1160 ret = -EIO;
1161 goto exit;
1162 }
1163 debug("attempt to write 0x%llx bytes\n", *actwrite);
1164
1165 /* Flush fat buffer */
1166 ret = flush_dirty_fat_buffer(mydata);
1167 if (ret) {
1168 printf("Error: flush fat buffer\n");
1169 ret = -EIO;
1170 goto exit;
1171 }
1172
1173 /* Write directory table to device */
1174 ret = set_cluster(mydata, itr->clust, itr->block,
1175 mydata->clust_size * mydata->sect_size);
1176 if (ret) {
1177 printf("Error: writing directory entry\n");
1178 ret = -EIO;
1179 }
1180
1181 exit:
1182 free(filename_copy);
1183 free(mydata->fatbuf);
1184 free(itr);
1185 return ret;
1186 }
1187
file_fat_write(const char * filename,void * buffer,loff_t offset,loff_t maxsize,loff_t * actwrite)1188 int file_fat_write(const char *filename, void *buffer, loff_t offset,
1189 loff_t maxsize, loff_t *actwrite)
1190 {
1191 return file_fat_write_at(filename, offset, buffer, maxsize, actwrite);
1192 }
1193
fat_dir_entries(fat_itr * itr)1194 static int fat_dir_entries(fat_itr *itr)
1195 {
1196 fat_itr *dirs;
1197 fsdata fsdata = { .fatbuf = NULL, }, *mydata = &fsdata;
1198 /* for FATBUFSIZE */
1199 int count;
1200
1201 dirs = malloc_cache_aligned(sizeof(fat_itr));
1202 if (!dirs) {
1203 debug("Error: allocating memory\n");
1204 count = -ENOMEM;
1205 goto exit;
1206 }
1207
1208 /* duplicate fsdata */
1209 fat_itr_child(dirs, itr);
1210 fsdata = *dirs->fsdata;
1211
1212 /* allocate local fat buffer */
1213 fsdata.fatbuf = malloc_cache_aligned(FATBUFSIZE);
1214 if (!fsdata.fatbuf) {
1215 debug("Error: allocating memory\n");
1216 count = -ENOMEM;
1217 goto exit;
1218 }
1219 fsdata.fatbufnum = -1;
1220 dirs->fsdata = &fsdata;
1221
1222 for (count = 0; fat_itr_next(dirs); count++)
1223 ;
1224
1225 exit:
1226 free(fsdata.fatbuf);
1227 free(dirs);
1228 return count;
1229 }
1230
delete_dentry(fat_itr * itr)1231 static int delete_dentry(fat_itr *itr)
1232 {
1233 fsdata *mydata = itr->fsdata;
1234 dir_entry *dentptr = itr->dent;
1235
1236 /* free cluster blocks */
1237 clear_fatent(mydata, START(dentptr));
1238 if (flush_dirty_fat_buffer(mydata) < 0) {
1239 printf("Error: flush fat buffer\n");
1240 return -EIO;
1241 }
1242
1243 /*
1244 * update a directory entry
1245 * TODO:
1246 * - long file name support
1247 * - find and mark the "new" first invalid entry as name[0]=0x00
1248 */
1249 memset(dentptr, 0, sizeof(*dentptr));
1250 dentptr->name[0] = 0xe5;
1251
1252 if (set_cluster(mydata, itr->clust, itr->block,
1253 mydata->clust_size * mydata->sect_size) != 0) {
1254 printf("error: writing directory entry\n");
1255 return -EIO;
1256 }
1257
1258 return 0;
1259 }
1260
fat_unlink(const char * filename)1261 int fat_unlink(const char *filename)
1262 {
1263 fsdata fsdata = { .fatbuf = NULL, };
1264 fat_itr *itr = NULL;
1265 int n_entries, ret;
1266 char *filename_copy, *dirname, *basename;
1267
1268 filename_copy = strdup(filename);
1269 if (!filename_copy) {
1270 printf("Error: allocating memory\n");
1271 ret = -ENOMEM;
1272 goto exit;
1273 }
1274 split_filename(filename_copy, &dirname, &basename);
1275
1276 if (!strcmp(dirname, "/") && !strcmp(basename, "")) {
1277 printf("Error: cannot remove root\n");
1278 ret = -EINVAL;
1279 goto exit;
1280 }
1281
1282 itr = malloc_cache_aligned(sizeof(fat_itr));
1283 if (!itr) {
1284 printf("Error: allocating memory\n");
1285 ret = -ENOMEM;
1286 goto exit;
1287 }
1288
1289 ret = fat_itr_root(itr, &fsdata);
1290 if (ret)
1291 goto exit;
1292
1293 total_sector = fsdata.total_sect;
1294
1295 ret = fat_itr_resolve(itr, dirname, TYPE_DIR);
1296 if (ret) {
1297 printf("%s: doesn't exist (%d)\n", dirname, ret);
1298 ret = -ENOENT;
1299 goto exit;
1300 }
1301
1302 if (!find_directory_entry(itr, basename)) {
1303 printf("%s: doesn't exist\n", basename);
1304 ret = -ENOENT;
1305 goto exit;
1306 }
1307
1308 if (fat_itr_isdir(itr)) {
1309 n_entries = fat_dir_entries(itr);
1310 if (n_entries < 0) {
1311 ret = n_entries;
1312 goto exit;
1313 }
1314 if (n_entries > 2) {
1315 printf("Error: directory is not empty: %d\n",
1316 n_entries);
1317 ret = -EINVAL;
1318 goto exit;
1319 }
1320 }
1321
1322 ret = delete_dentry(itr);
1323
1324 exit:
1325 free(fsdata.fatbuf);
1326 free(itr);
1327 free(filename_copy);
1328
1329 return ret;
1330 }
1331
fat_mkdir(const char * new_dirname)1332 int fat_mkdir(const char *new_dirname)
1333 {
1334 dir_entry *retdent;
1335 fsdata datablock = { .fatbuf = NULL, };
1336 fsdata *mydata = &datablock;
1337 fat_itr *itr = NULL;
1338 char *dirname_copy, *parent, *dirname;
1339 char l_dirname[VFAT_MAXLEN_BYTES];
1340 int ret = -1;
1341 loff_t actwrite;
1342 unsigned int bytesperclust;
1343 dir_entry *dotdent = NULL;
1344
1345 dirname_copy = strdup(new_dirname);
1346 if (!dirname_copy)
1347 goto exit;
1348
1349 split_filename(dirname_copy, &parent, &dirname);
1350 if (!strlen(dirname)) {
1351 ret = -EINVAL;
1352 goto exit;
1353 }
1354
1355 if (normalize_longname(l_dirname, dirname)) {
1356 printf("FAT: illegal filename (%s)\n", dirname);
1357 ret = -EINVAL;
1358 goto exit;
1359 }
1360
1361 itr = malloc_cache_aligned(sizeof(fat_itr));
1362 if (!itr) {
1363 ret = -ENOMEM;
1364 goto exit;
1365 }
1366
1367 ret = fat_itr_root(itr, &datablock);
1368 if (ret)
1369 goto exit;
1370
1371 total_sector = datablock.total_sect;
1372
1373 ret = fat_itr_resolve(itr, parent, TYPE_DIR);
1374 if (ret) {
1375 printf("%s: doesn't exist (%d)\n", parent, ret);
1376 goto exit;
1377 }
1378
1379 retdent = find_directory_entry(itr, l_dirname);
1380
1381 if (retdent) {
1382 printf("%s: already exists\n", l_dirname);
1383 ret = -EEXIST;
1384 goto exit;
1385 } else {
1386 if (itr->is_root) {
1387 /* root dir cannot have "." or ".." */
1388 if (!strcmp(l_dirname, ".") ||
1389 !strcmp(l_dirname, "..")) {
1390 ret = -EINVAL;
1391 goto exit;
1392 }
1393 }
1394
1395 if (!itr->dent) {
1396 printf("Error: allocating new dir entry\n");
1397 ret = -EIO;
1398 goto exit;
1399 }
1400
1401 memset(itr->dent, 0, sizeof(*itr->dent));
1402
1403 /* Set short name to set alias checksum field in dir_slot */
1404 set_name(itr->dent, dirname);
1405 fill_dir_slot(itr, dirname);
1406
1407 /* Set attribute as archive for regular file */
1408 fill_dentry(itr->fsdata, itr->dent, dirname, 0, 0,
1409 ATTR_DIR | ATTR_ARCH);
1410
1411 retdent = itr->dent;
1412 }
1413
1414 /* Default entries */
1415 bytesperclust = mydata->clust_size * mydata->sect_size;
1416 dotdent = malloc_cache_aligned(bytesperclust);
1417 if (!dotdent) {
1418 ret = -ENOMEM;
1419 goto exit;
1420 }
1421 memset(dotdent, 0, bytesperclust);
1422
1423 memcpy(dotdent[0].name, ". ", 8);
1424 memcpy(dotdent[0].ext, " ", 3);
1425 dotdent[0].attr = ATTR_DIR | ATTR_ARCH;
1426
1427 memcpy(dotdent[1].name, ".. ", 8);
1428 memcpy(dotdent[1].ext, " ", 3);
1429 dotdent[1].attr = ATTR_DIR | ATTR_ARCH;
1430 set_start_cluster(mydata, &dotdent[1], itr->start_clust);
1431
1432 ret = set_contents(mydata, retdent, 0, (__u8 *)dotdent,
1433 bytesperclust, &actwrite);
1434 if (ret < 0) {
1435 printf("Error: writing contents\n");
1436 goto exit;
1437 }
1438 /* Write twice for "." */
1439 set_start_cluster(mydata, &dotdent[0], START(retdent));
1440 ret = set_contents(mydata, retdent, 0, (__u8 *)dotdent,
1441 bytesperclust, &actwrite);
1442 if (ret < 0) {
1443 printf("Error: writing contents\n");
1444 goto exit;
1445 }
1446
1447 /* Flush fat buffer */
1448 ret = flush_dirty_fat_buffer(mydata);
1449 if (ret) {
1450 printf("Error: flush fat buffer\n");
1451 goto exit;
1452 }
1453
1454 /* Write directory table to device */
1455 ret = set_cluster(mydata, itr->clust, itr->block,
1456 mydata->clust_size * mydata->sect_size);
1457 if (ret)
1458 printf("Error: writing directory entry\n");
1459
1460 exit:
1461 free(dirname_copy);
1462 free(mydata->fatbuf);
1463 free(itr);
1464 free(dotdent);
1465 return ret;
1466 }
1467