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 static __u8 num_of_fats;
103 /*
104 * Write fat buffer into block device
105 */
flush_dirty_fat_buffer(fsdata * mydata)106 static int flush_dirty_fat_buffer(fsdata *mydata)
107 {
108 int getsize = FATBUFBLOCKS;
109 __u32 fatlength = mydata->fatlength;
110 __u8 *bufptr = mydata->fatbuf;
111 __u32 startblock = mydata->fatbufnum * FATBUFBLOCKS;
112
113 debug("debug: evicting %d, dirty: %d\n", mydata->fatbufnum,
114 (int)mydata->fat_dirty);
115
116 if ((!mydata->fat_dirty) || (mydata->fatbufnum == -1))
117 return 0;
118
119 /* Cap length if fatlength is not a multiple of FATBUFBLOCKS */
120 if (startblock + getsize > fatlength)
121 getsize = fatlength - startblock;
122
123 startblock += mydata->fat_sect;
124
125 /* Write FAT buf */
126 if (disk_write(startblock, getsize, bufptr) < 0) {
127 debug("error: writing FAT blocks\n");
128 return -1;
129 }
130
131 if (num_of_fats == 2) {
132 /* Update corresponding second FAT blocks */
133 startblock += mydata->fatlength;
134 if (disk_write(startblock, getsize, bufptr) < 0) {
135 debug("error: writing second FAT blocks\n");
136 return -1;
137 }
138 }
139 mydata->fat_dirty = 0;
140
141 return 0;
142 }
143
144 /*
145 * Set the file name information from 'name' into 'slotptr',
146 */
str2slot(dir_slot * slotptr,const char * name,int * idx)147 static int str2slot(dir_slot *slotptr, const char *name, int *idx)
148 {
149 int j, end_idx = 0;
150
151 for (j = 0; j <= 8; j += 2) {
152 if (name[*idx] == 0x00) {
153 slotptr->name0_4[j] = 0;
154 slotptr->name0_4[j + 1] = 0;
155 end_idx++;
156 goto name0_4;
157 }
158 slotptr->name0_4[j] = name[*idx];
159 (*idx)++;
160 end_idx++;
161 }
162 for (j = 0; j <= 10; j += 2) {
163 if (name[*idx] == 0x00) {
164 slotptr->name5_10[j] = 0;
165 slotptr->name5_10[j + 1] = 0;
166 end_idx++;
167 goto name5_10;
168 }
169 slotptr->name5_10[j] = name[*idx];
170 (*idx)++;
171 end_idx++;
172 }
173 for (j = 0; j <= 2; j += 2) {
174 if (name[*idx] == 0x00) {
175 slotptr->name11_12[j] = 0;
176 slotptr->name11_12[j + 1] = 0;
177 end_idx++;
178 goto name11_12;
179 }
180 slotptr->name11_12[j] = name[*idx];
181 (*idx)++;
182 end_idx++;
183 }
184
185 if (name[*idx] == 0x00)
186 return 1;
187
188 return 0;
189 /* Not used characters are filled with 0xff 0xff */
190 name0_4:
191 for (; end_idx < 5; end_idx++) {
192 slotptr->name0_4[end_idx * 2] = 0xff;
193 slotptr->name0_4[end_idx * 2 + 1] = 0xff;
194 }
195 end_idx = 5;
196 name5_10:
197 end_idx -= 5;
198 for (; end_idx < 6; end_idx++) {
199 slotptr->name5_10[end_idx * 2] = 0xff;
200 slotptr->name5_10[end_idx * 2 + 1] = 0xff;
201 }
202 end_idx = 11;
203 name11_12:
204 end_idx -= 11;
205 for (; end_idx < 2; end_idx++) {
206 slotptr->name11_12[end_idx * 2] = 0xff;
207 slotptr->name11_12[end_idx * 2 + 1] = 0xff;
208 }
209
210 return 1;
211 }
212
213 static int is_next_clust(fsdata *mydata, dir_entry *dentptr);
214 static void flush_dir_table(fsdata *mydata, dir_entry **dentptr);
215
216 /*
217 * Fill dir_slot entries with appropriate name, id, and attr
218 * The real directory entry is returned by 'dentptr'
219 */
220 static void
fill_dir_slot(fsdata * mydata,dir_entry ** dentptr,const char * l_name)221 fill_dir_slot(fsdata *mydata, dir_entry **dentptr, const char *l_name)
222 {
223 __u8 temp_dir_slot_buffer[MAX_LFN_SLOT * sizeof(dir_slot)];
224 dir_slot *slotptr = (dir_slot *)temp_dir_slot_buffer;
225 __u8 counter = 0, checksum;
226 int idx = 0, ret;
227
228 /* Get short file name checksum value */
229 checksum = mkcksum((*dentptr)->name, (*dentptr)->ext);
230
231 do {
232 memset(slotptr, 0x00, sizeof(dir_slot));
233 ret = str2slot(slotptr, l_name, &idx);
234 slotptr->id = ++counter;
235 slotptr->attr = ATTR_VFAT;
236 slotptr->alias_checksum = checksum;
237 slotptr++;
238 } while (ret == 0);
239
240 slotptr--;
241 slotptr->id |= LAST_LONG_ENTRY_MASK;
242
243 while (counter >= 1) {
244 if (is_next_clust(mydata, *dentptr)) {
245 /* A new cluster is allocated for directory table */
246 flush_dir_table(mydata, dentptr);
247 }
248 memcpy(*dentptr, slotptr, sizeof(dir_slot));
249 (*dentptr)++;
250 slotptr--;
251 counter--;
252 }
253
254 if (is_next_clust(mydata, *dentptr)) {
255 /* A new cluster is allocated for directory table */
256 flush_dir_table(mydata, dentptr);
257 }
258 }
259
260 static __u32 dir_curclust;
261
262 /*
263 * Extract the full long filename starting at 'retdent' (which is really
264 * a slot) into 'l_name'. If successful also copy the real directory entry
265 * into 'retdent'
266 * If additional adjacent cluster for directory entries is read into memory,
267 * then 'get_contents_vfatname_block' is copied into 'get_dentfromdir_block' and
268 * the location of the real directory entry is returned by 'retdent'
269 * Return 0 on success, -1 otherwise.
270 */
271 static int
get_long_file_name(fsdata * mydata,int curclust,__u8 * cluster,dir_entry ** retdent,char * l_name)272 get_long_file_name(fsdata *mydata, int curclust, __u8 *cluster,
273 dir_entry **retdent, char *l_name)
274 {
275 dir_entry *realdent;
276 dir_slot *slotptr = (dir_slot *)(*retdent);
277 dir_slot *slotptr2 = NULL;
278 __u8 *buflimit = cluster + mydata->sect_size * ((curclust == 0) ?
279 PREFETCH_BLOCKS :
280 mydata->clust_size);
281 __u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff;
282 int idx = 0, cur_position = 0;
283
284 if (counter > VFAT_MAXSEQ) {
285 debug("Error: VFAT name is too long\n");
286 return -1;
287 }
288
289 while ((__u8 *)slotptr < buflimit) {
290 if (counter == 0)
291 break;
292 if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)
293 return -1;
294 slotptr++;
295 counter--;
296 }
297
298 if ((__u8 *)slotptr >= buflimit) {
299 if (curclust == 0)
300 return -1;
301 curclust = get_fatent(mydata, dir_curclust);
302 if (CHECK_CLUST(curclust, mydata->fatsize)) {
303 debug("curclust: 0x%x\n", curclust);
304 printf("Invalid FAT entry\n");
305 return -1;
306 }
307
308 dir_curclust = curclust;
309
310 if (get_cluster(mydata, curclust, get_contents_vfatname_block,
311 mydata->clust_size * mydata->sect_size) != 0) {
312 debug("Error: reading directory block\n");
313 return -1;
314 }
315
316 slotptr2 = (dir_slot *)get_contents_vfatname_block;
317 while (counter > 0) {
318 if (((slotptr2->id & ~LAST_LONG_ENTRY_MASK)
319 & 0xff) != counter)
320 return -1;
321 slotptr2++;
322 counter--;
323 }
324
325 /* Save the real directory entry */
326 realdent = (dir_entry *)slotptr2;
327 while ((__u8 *)slotptr2 > get_contents_vfatname_block) {
328 slotptr2--;
329 slot2str(slotptr2, l_name, &idx);
330 }
331 } else {
332 /* Save the real directory entry */
333 realdent = (dir_entry *)slotptr;
334 }
335
336 do {
337 slotptr--;
338 if (slot2str(slotptr, l_name, &idx))
339 break;
340 } while (!(slotptr->id & LAST_LONG_ENTRY_MASK));
341
342 l_name[idx] = '\0';
343 if (*l_name == DELETED_FLAG)
344 *l_name = '\0';
345 else if (*l_name == aRING)
346 *l_name = DELETED_FLAG;
347 downcase(l_name, INT_MAX);
348
349 /* Return the real directory entry */
350 *retdent = realdent;
351
352 if (slotptr2) {
353 memcpy(get_dentfromdir_block, get_contents_vfatname_block,
354 mydata->clust_size * mydata->sect_size);
355 cur_position = (__u8 *)realdent - get_contents_vfatname_block;
356 *retdent = (dir_entry *) &get_dentfromdir_block[cur_position];
357 }
358
359 return 0;
360 }
361
362 /*
363 * Set the entry at index 'entry' in a FAT (12/16/32) table.
364 */
set_fatent_value(fsdata * mydata,__u32 entry,__u32 entry_value)365 static int set_fatent_value(fsdata *mydata, __u32 entry, __u32 entry_value)
366 {
367 __u32 bufnum, offset, off16;
368 __u16 val1, val2;
369
370 switch (mydata->fatsize) {
371 case 32:
372 bufnum = entry / FAT32BUFSIZE;
373 offset = entry - bufnum * FAT32BUFSIZE;
374 break;
375 case 16:
376 bufnum = entry / FAT16BUFSIZE;
377 offset = entry - bufnum * FAT16BUFSIZE;
378 break;
379 case 12:
380 bufnum = entry / FAT12BUFSIZE;
381 offset = entry - bufnum * FAT12BUFSIZE;
382 break;
383 default:
384 /* Unsupported FAT size */
385 return -1;
386 }
387
388 /* Read a new block of FAT entries into the cache. */
389 if (bufnum != mydata->fatbufnum) {
390 int getsize = FATBUFBLOCKS;
391 __u8 *bufptr = mydata->fatbuf;
392 __u32 fatlength = mydata->fatlength;
393 __u32 startblock = bufnum * FATBUFBLOCKS;
394
395 /* Cap length if fatlength is not a multiple of FATBUFBLOCKS */
396 if (startblock + getsize > fatlength)
397 getsize = fatlength - startblock;
398
399 if (flush_dirty_fat_buffer(mydata) < 0)
400 return -1;
401
402 startblock += mydata->fat_sect;
403
404 if (disk_read(startblock, getsize, bufptr) < 0) {
405 debug("Error reading FAT blocks\n");
406 return -1;
407 }
408 mydata->fatbufnum = bufnum;
409 }
410
411 /* Mark as dirty */
412 mydata->fat_dirty = 1;
413
414 /* Set the actual entry */
415 switch (mydata->fatsize) {
416 case 32:
417 ((__u32 *) mydata->fatbuf)[offset] = cpu_to_le32(entry_value);
418 break;
419 case 16:
420 ((__u16 *) mydata->fatbuf)[offset] = cpu_to_le16(entry_value);
421 break;
422 case 12:
423 off16 = (offset * 3) / 4;
424
425 switch (offset & 0x3) {
426 case 0:
427 val1 = cpu_to_le16(entry_value) & 0xfff;
428 ((__u16 *)mydata->fatbuf)[off16] &= ~0xfff;
429 ((__u16 *)mydata->fatbuf)[off16] |= val1;
430 break;
431 case 1:
432 val1 = cpu_to_le16(entry_value) & 0xf;
433 val2 = (cpu_to_le16(entry_value) >> 4) & 0xff;
434
435 ((__u16 *)mydata->fatbuf)[off16] &= ~0xf000;
436 ((__u16 *)mydata->fatbuf)[off16] |= (val1 << 12);
437
438 ((__u16 *)mydata->fatbuf)[off16 + 1] &= ~0xff;
439 ((__u16 *)mydata->fatbuf)[off16 + 1] |= val2;
440 break;
441 case 2:
442 val1 = cpu_to_le16(entry_value) & 0xff;
443 val2 = (cpu_to_le16(entry_value) >> 8) & 0xf;
444
445 ((__u16 *)mydata->fatbuf)[off16] &= ~0xff00;
446 ((__u16 *)mydata->fatbuf)[off16] |= (val1 << 8);
447
448 ((__u16 *)mydata->fatbuf)[off16 + 1] &= ~0xf;
449 ((__u16 *)mydata->fatbuf)[off16 + 1] |= val2;
450 break;
451 case 3:
452 val1 = cpu_to_le16(entry_value) & 0xfff;
453 ((__u16 *)mydata->fatbuf)[off16] &= ~0xfff0;
454 ((__u16 *)mydata->fatbuf)[off16] |= (val1 << 4);
455 break;
456 default:
457 break;
458 }
459
460 break;
461 default:
462 return -1;
463 }
464
465 return 0;
466 }
467
468 /*
469 * Determine the next free cluster after 'entry' in a FAT (12/16/32) table
470 * and link it to 'entry'. EOC marker is not set on returned entry.
471 */
determine_fatent(fsdata * mydata,__u32 entry)472 static __u32 determine_fatent(fsdata *mydata, __u32 entry)
473 {
474 __u32 next_fat, next_entry = entry + 1;
475
476 while (1) {
477 next_fat = get_fatent(mydata, next_entry);
478 if (next_fat == 0) {
479 /* found free entry, link to entry */
480 set_fatent_value(mydata, entry, next_entry);
481 break;
482 }
483 next_entry++;
484 }
485 debug("FAT%d: entry: %08x, entry_value: %04x\n",
486 mydata->fatsize, entry, next_entry);
487
488 return next_entry;
489 }
490
491 /*
492 * Write at most 'size' bytes from 'buffer' into the specified cluster.
493 * Return 0 on success, -1 otherwise.
494 */
495 static int
set_cluster(fsdata * mydata,__u32 clustnum,__u8 * buffer,unsigned long size)496 set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
497 unsigned long size)
498 {
499 __u32 idx = 0;
500 __u32 startsect;
501 int ret;
502
503 if (clustnum > 0)
504 startsect = clust_to_sect(mydata, clustnum);
505 else
506 startsect = mydata->rootdir_sect;
507
508 debug("clustnum: %d, startsect: %d\n", clustnum, startsect);
509
510 if ((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1)) {
511 ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
512
513 printf("FAT: Misaligned buffer address (%p)\n", buffer);
514
515 while (size >= mydata->sect_size) {
516 memcpy(tmpbuf, buffer, mydata->sect_size);
517 ret = disk_write(startsect++, 1, tmpbuf);
518 if (ret != 1) {
519 debug("Error writing data (got %d)\n", ret);
520 return -1;
521 }
522
523 buffer += mydata->sect_size;
524 size -= mydata->sect_size;
525 }
526 } else if (size >= mydata->sect_size) {
527 idx = size / mydata->sect_size;
528 ret = disk_write(startsect, idx, buffer);
529 if (ret != idx) {
530 debug("Error writing data (got %d)\n", ret);
531 return -1;
532 }
533
534 startsect += idx;
535 idx *= mydata->sect_size;
536 buffer += idx;
537 size -= idx;
538 }
539
540 if (size) {
541 ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size);
542
543 memcpy(tmpbuf, buffer, size);
544 ret = disk_write(startsect, 1, tmpbuf);
545 if (ret != 1) {
546 debug("Error writing data (got %d)\n", ret);
547 return -1;
548 }
549 }
550
551 return 0;
552 }
553
554 /*
555 * Find the first empty cluster
556 */
find_empty_cluster(fsdata * mydata)557 static int find_empty_cluster(fsdata *mydata)
558 {
559 __u32 fat_val, entry = 3;
560
561 while (1) {
562 fat_val = get_fatent(mydata, entry);
563 if (fat_val == 0)
564 break;
565 entry++;
566 }
567
568 return entry;
569 }
570
571 /*
572 * Write directory entries in 'get_dentfromdir_block' to block device
573 */
flush_dir_table(fsdata * mydata,dir_entry ** dentptr)574 static void flush_dir_table(fsdata *mydata, dir_entry **dentptr)
575 {
576 int dir_newclust = 0;
577
578 if (set_cluster(mydata, dir_curclust,
579 get_dentfromdir_block,
580 mydata->clust_size * mydata->sect_size) != 0) {
581 printf("error: wrinting directory entry\n");
582 return;
583 }
584 dir_newclust = find_empty_cluster(mydata);
585 set_fatent_value(mydata, dir_curclust, dir_newclust);
586 if (mydata->fatsize == 32)
587 set_fatent_value(mydata, dir_newclust, 0xffffff8);
588 else if (mydata->fatsize == 16)
589 set_fatent_value(mydata, dir_newclust, 0xfff8);
590 else if (mydata->fatsize == 12)
591 set_fatent_value(mydata, dir_newclust, 0xff8);
592
593 dir_curclust = dir_newclust;
594
595 if (flush_dirty_fat_buffer(mydata) < 0)
596 return;
597
598 memset(get_dentfromdir_block, 0x00,
599 mydata->clust_size * mydata->sect_size);
600
601 *dentptr = (dir_entry *) get_dentfromdir_block;
602 }
603
604 /*
605 * Set empty cluster from 'entry' to the end of a file
606 */
clear_fatent(fsdata * mydata,__u32 entry)607 static int clear_fatent(fsdata *mydata, __u32 entry)
608 {
609 __u32 fat_val;
610
611 while (!CHECK_CLUST(entry, mydata->fatsize)) {
612 fat_val = get_fatent(mydata, entry);
613 if (fat_val != 0)
614 set_fatent_value(mydata, entry, 0);
615 else
616 break;
617
618 entry = fat_val;
619 }
620
621 /* Flush fat buffer */
622 if (flush_dirty_fat_buffer(mydata) < 0)
623 return -1;
624
625 return 0;
626 }
627
628 /*
629 * Write at most 'maxsize' bytes from 'buffer' into
630 * the file associated with 'dentptr'
631 * Update the number of bytes written in *gotsize and return 0
632 * or return -1 on fatal errors.
633 */
634 static int
set_contents(fsdata * mydata,dir_entry * dentptr,__u8 * buffer,loff_t maxsize,loff_t * gotsize)635 set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
636 loff_t maxsize, loff_t *gotsize)
637 {
638 loff_t filesize = FAT2CPU32(dentptr->size);
639 unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
640 __u32 curclust = START(dentptr);
641 __u32 endclust = 0, newclust = 0;
642 loff_t actsize;
643
644 *gotsize = 0;
645 debug("Filesize: %llu bytes\n", filesize);
646
647 if (maxsize > 0 && filesize > maxsize)
648 filesize = maxsize;
649
650 debug("%llu bytes\n", filesize);
651
652 if (!curclust) {
653 if (filesize) {
654 debug("error: nonempty clusterless file!\n");
655 return -1;
656 }
657 return 0;
658 }
659
660 actsize = bytesperclust;
661 endclust = curclust;
662 do {
663 /* search for consecutive clusters */
664 while (actsize < filesize) {
665 newclust = determine_fatent(mydata, endclust);
666
667 if ((newclust - 1) != endclust)
668 goto getit;
669
670 if (CHECK_CLUST(newclust, mydata->fatsize)) {
671 debug("newclust: 0x%x\n", newclust);
672 debug("Invalid FAT entry\n");
673 return 0;
674 }
675 endclust = newclust;
676 actsize += bytesperclust;
677 }
678
679 /* set remaining bytes */
680 actsize = filesize;
681 if (set_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
682 debug("error: writing cluster\n");
683 return -1;
684 }
685 *gotsize += actsize;
686
687 /* Mark end of file in FAT */
688 if (mydata->fatsize == 12)
689 newclust = 0xfff;
690 else if (mydata->fatsize == 16)
691 newclust = 0xffff;
692 else if (mydata->fatsize == 32)
693 newclust = 0xfffffff;
694 set_fatent_value(mydata, endclust, newclust);
695
696 return 0;
697 getit:
698 if (set_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
699 debug("error: writing cluster\n");
700 return -1;
701 }
702 *gotsize += actsize;
703 filesize -= actsize;
704 buffer += actsize;
705
706 if (CHECK_CLUST(newclust, mydata->fatsize)) {
707 debug("newclust: 0x%x\n", newclust);
708 debug("Invalid FAT entry\n");
709 return 0;
710 }
711 actsize = bytesperclust;
712 curclust = endclust = newclust;
713 } while (1);
714 }
715
716 /*
717 * Set start cluster in directory entry
718 */
set_start_cluster(const fsdata * mydata,dir_entry * dentptr,__u32 start_cluster)719 static void set_start_cluster(const fsdata *mydata, dir_entry *dentptr,
720 __u32 start_cluster)
721 {
722 if (mydata->fatsize == 32)
723 dentptr->starthi =
724 cpu_to_le16((start_cluster & 0xffff0000) >> 16);
725 dentptr->start = cpu_to_le16(start_cluster & 0xffff);
726 }
727
728 /*
729 * Fill dir_entry
730 */
fill_dentry(fsdata * mydata,dir_entry * dentptr,const char * filename,__u32 start_cluster,__u32 size,__u8 attr)731 static void fill_dentry(fsdata *mydata, dir_entry *dentptr,
732 const char *filename, __u32 start_cluster, __u32 size, __u8 attr)
733 {
734 set_start_cluster(mydata, dentptr, start_cluster);
735 dentptr->size = cpu_to_le32(size);
736
737 dentptr->attr = attr;
738
739 set_name(dentptr, filename);
740 }
741
742 /*
743 * Check whether adding a file makes the file system to
744 * exceed the size of the block device
745 * Return -1 when overflow occurs, otherwise return 0
746 */
check_overflow(fsdata * mydata,__u32 clustnum,loff_t size)747 static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
748 {
749 __u32 startsect, sect_num, offset;
750
751 if (clustnum > 0) {
752 startsect = clust_to_sect(mydata, clustnum);
753 } else {
754 startsect = mydata->rootdir_sect;
755 }
756
757 sect_num = div_u64_rem(size, mydata->sect_size, &offset);
758
759 if (offset != 0)
760 sect_num++;
761
762 if (startsect + sect_num > total_sector)
763 return -1;
764 return 0;
765 }
766
767 /*
768 * Check if adding several entries exceed one cluster boundary
769 */
is_next_clust(fsdata * mydata,dir_entry * dentptr)770 static int is_next_clust(fsdata *mydata, dir_entry *dentptr)
771 {
772 int cur_position;
773
774 cur_position = (__u8 *)dentptr - get_dentfromdir_block;
775
776 if (cur_position >= mydata->clust_size * mydata->sect_size)
777 return 1;
778 else
779 return 0;
780 }
781
782 static dir_entry *empty_dentptr;
783 /*
784 * Find a directory entry based on filename or start cluster number
785 * If the directory entry is not found,
786 * the new position for writing a directory entry will be returned
787 */
find_directory_entry(fsdata * mydata,int startsect,char * filename,dir_entry * retdent,__u32 start)788 static dir_entry *find_directory_entry(fsdata *mydata, int startsect,
789 char *filename, dir_entry *retdent, __u32 start)
790 {
791 __u32 curclust = sect_to_clust(mydata, startsect);
792
793 debug("get_dentfromdir: %s\n", filename);
794
795 while (1) {
796 dir_entry *dentptr;
797
798 int i;
799
800 if (get_cluster(mydata, curclust, get_dentfromdir_block,
801 mydata->clust_size * mydata->sect_size) != 0) {
802 printf("Error: reading directory block\n");
803 return NULL;
804 }
805
806 dentptr = (dir_entry *)get_dentfromdir_block;
807
808 dir_curclust = curclust;
809
810 for (i = 0; i < DIRENTSPERCLUST; i++) {
811 char s_name[14], l_name[VFAT_MAXLEN_BYTES];
812
813 l_name[0] = '\0';
814 if (dentptr->name[0] == DELETED_FLAG) {
815 dentptr++;
816 if (is_next_clust(mydata, dentptr))
817 break;
818 continue;
819 }
820 if ((dentptr->attr & ATTR_VOLUME)) {
821 if ((dentptr->attr & ATTR_VFAT) &&
822 (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
823 get_long_file_name(mydata, curclust,
824 get_dentfromdir_block,
825 &dentptr, l_name);
826 debug("vfatname: |%s|\n", l_name);
827 } else {
828 /* Volume label or VFAT entry */
829 dentptr++;
830 if (is_next_clust(mydata, dentptr))
831 break;
832 continue;
833 }
834 }
835 if (dentptr->name[0] == 0) {
836 debug("Dentname == NULL - %d\n", i);
837 empty_dentptr = dentptr;
838 return NULL;
839 }
840
841 get_name(dentptr, s_name);
842
843 if (strncasecmp(filename, s_name, sizeof(s_name)) &&
844 strncasecmp(filename, l_name, sizeof(l_name))) {
845 debug("Mismatch: |%s|%s|\n",
846 s_name, l_name);
847 dentptr++;
848 if (is_next_clust(mydata, dentptr))
849 break;
850 continue;
851 }
852
853 memcpy(retdent, dentptr, sizeof(dir_entry));
854
855 debug("DentName: %s", s_name);
856 debug(", start: 0x%x", START(dentptr));
857 debug(", size: 0x%x %s\n",
858 FAT2CPU32(dentptr->size),
859 (dentptr->attr & ATTR_DIR) ?
860 "(DIR)" : "");
861
862 return dentptr;
863 }
864
865 /*
866 * In FAT16/12, the root dir is locate before data area, shows
867 * in following:
868 * -------------------------------------------------------------
869 * | Boot | FAT1 & 2 | Root dir | Data (start from cluster #2) |
870 * -------------------------------------------------------------
871 *
872 * As a result if curclust is in Root dir, it is a negative
873 * number or 0, 1.
874 *
875 */
876 if (mydata->fatsize != 32 && (int)curclust <= 1) {
877 /* Current clust is in root dir, set to next clust */
878 curclust++;
879 if ((int)curclust <= 1)
880 continue; /* continue to find */
881
882 /* Reach the end of root dir */
883 empty_dentptr = dentptr;
884 return NULL;
885 }
886
887 curclust = get_fatent(mydata, dir_curclust);
888 if (IS_LAST_CLUST(curclust, mydata->fatsize)) {
889 empty_dentptr = dentptr;
890 return NULL;
891 }
892 if (CHECK_CLUST(curclust, mydata->fatsize)) {
893 debug("curclust: 0x%x\n", curclust);
894 debug("Invalid FAT entry\n");
895 return NULL;
896 }
897 }
898
899 return NULL;
900 }
901
do_fat_write(const char * filename,void * buffer,loff_t size,loff_t * actwrite)902 static int do_fat_write(const char *filename, void *buffer, loff_t size,
903 loff_t *actwrite)
904 {
905 dir_entry *dentptr, *retdent;
906 __u32 startsect;
907 __u32 start_cluster;
908 boot_sector bs;
909 volume_info volinfo;
910 fsdata datablock;
911 fsdata *mydata = &datablock;
912 int cursect;
913 int ret = -1, name_len;
914 char l_filename[VFAT_MAXLEN_BYTES];
915
916 *actwrite = size;
917 dir_curclust = 0;
918
919 if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
920 debug("error: reading boot sector\n");
921 return -1;
922 }
923
924 total_sector = bs.total_sect;
925 if (total_sector == 0)
926 total_sector = (int)cur_part_info.size; /* cast of lbaint_t */
927
928 if (mydata->fatsize == 32)
929 mydata->fatlength = bs.fat32_length;
930 else
931 mydata->fatlength = bs.fat_length;
932
933 mydata->fat_sect = bs.reserved;
934
935 cursect = mydata->rootdir_sect
936 = mydata->fat_sect + mydata->fatlength * bs.fats;
937 num_of_fats = bs.fats;
938
939 mydata->sect_size = (bs.sector_size[1] << 8) + bs.sector_size[0];
940 mydata->clust_size = bs.cluster_size;
941
942 if (mydata->fatsize == 32) {
943 mydata->data_begin = mydata->rootdir_sect -
944 (mydata->clust_size * 2);
945 } else {
946 int rootdir_size;
947
948 rootdir_size = ((bs.dir_entries[1] * (int)256 +
949 bs.dir_entries[0]) *
950 sizeof(dir_entry)) /
951 mydata->sect_size;
952 mydata->data_begin = mydata->rootdir_sect +
953 rootdir_size -
954 (mydata->clust_size * 2);
955 }
956
957 mydata->fatbufnum = -1;
958 mydata->fat_dirty = 0;
959 mydata->fatbuf = memalign(ARCH_DMA_MINALIGN, FATBUFSIZE);
960 if (mydata->fatbuf == NULL) {
961 debug("Error: allocating memory\n");
962 return -1;
963 }
964
965 if (disk_read(cursect,
966 (mydata->fatsize == 32) ?
967 (mydata->clust_size) :
968 PREFETCH_BLOCKS, do_fat_read_at_block) < 0) {
969 debug("Error: reading rootdir block\n");
970 goto exit;
971 }
972 dentptr = (dir_entry *) do_fat_read_at_block;
973
974 name_len = strlen(filename);
975 if (name_len >= VFAT_MAXLEN_BYTES)
976 name_len = VFAT_MAXLEN_BYTES - 1;
977
978 memcpy(l_filename, filename, name_len);
979 l_filename[name_len] = 0; /* terminate the string */
980 downcase(l_filename, INT_MAX);
981
982 startsect = mydata->rootdir_sect;
983 retdent = find_directory_entry(mydata, startsect,
984 l_filename, dentptr, 0);
985 if (retdent) {
986 /* Update file size and start_cluster in a directory entry */
987 retdent->size = cpu_to_le32(size);
988 start_cluster = START(retdent);
989
990 if (start_cluster) {
991 if (size) {
992 ret = check_overflow(mydata, start_cluster,
993 size);
994 if (ret) {
995 printf("Error: %llu overflow\n", size);
996 goto exit;
997 }
998 }
999
1000 ret = clear_fatent(mydata, start_cluster);
1001 if (ret) {
1002 printf("Error: clearing FAT entries\n");
1003 goto exit;
1004 }
1005
1006 if (!size)
1007 set_start_cluster(mydata, retdent, 0);
1008 } else if (size) {
1009 ret = start_cluster = find_empty_cluster(mydata);
1010 if (ret < 0) {
1011 printf("Error: finding empty cluster\n");
1012 goto exit;
1013 }
1014
1015 ret = check_overflow(mydata, start_cluster, size);
1016 if (ret) {
1017 printf("Error: %llu overflow\n", size);
1018 goto exit;
1019 }
1020
1021 set_start_cluster(mydata, retdent, start_cluster);
1022 }
1023 } else {
1024 /* Set short name to set alias checksum field in dir_slot */
1025 set_name(empty_dentptr, filename);
1026 fill_dir_slot(mydata, &empty_dentptr, filename);
1027
1028 if (size) {
1029 ret = start_cluster = find_empty_cluster(mydata);
1030 if (ret < 0) {
1031 printf("Error: finding empty cluster\n");
1032 goto exit;
1033 }
1034
1035 ret = check_overflow(mydata, start_cluster, size);
1036 if (ret) {
1037 printf("Error: %llu overflow\n", size);
1038 goto exit;
1039 }
1040 } else {
1041 start_cluster = 0;
1042 }
1043
1044 /* Set attribute as archieve for regular file */
1045 fill_dentry(mydata, empty_dentptr, filename,
1046 start_cluster, size, 0x20);
1047
1048 retdent = empty_dentptr;
1049 }
1050
1051 ret = set_contents(mydata, retdent, buffer, size, actwrite);
1052 if (ret < 0) {
1053 printf("Error: writing contents\n");
1054 goto exit;
1055 }
1056 debug("attempt to write 0x%llx bytes\n", *actwrite);
1057
1058 /* Flush fat buffer */
1059 ret = flush_dirty_fat_buffer(mydata);
1060 if (ret) {
1061 printf("Error: flush fat buffer\n");
1062 goto exit;
1063 }
1064
1065 /* Write directory table to device */
1066 ret = set_cluster(mydata, dir_curclust, get_dentfromdir_block,
1067 mydata->clust_size * mydata->sect_size);
1068 if (ret)
1069 printf("Error: writing directory entry\n");
1070
1071 exit:
1072 free(mydata->fatbuf);
1073 return ret;
1074 }
1075
file_fat_write(const char * filename,void * buffer,loff_t offset,loff_t maxsize,loff_t * actwrite)1076 int file_fat_write(const char *filename, void *buffer, loff_t offset,
1077 loff_t maxsize, loff_t *actwrite)
1078 {
1079 if (offset != 0) {
1080 printf("Error: non zero offset is currently not supported.\n");
1081 return -1;
1082 }
1083
1084 printf("writing %s\n", filename);
1085 return do_fat_write(filename, buffer, maxsize, actwrite);
1086 }
1087