-
-
Notifications
You must be signed in to change notification settings - Fork 754
/
Copy pathjsflash.c
1525 lines (1424 loc) · 59.7 KB
/
jsflash.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* This file is part of Espruino, a JavaScript interpreter for Microcontrollers
*
* Copyright (C) 2018 Gordon Williams <gw@pur3.co.uk>
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* ----------------------------------------------------------------------------
* JavaScript Flash IO functions
* ----------------------------------------------------------------------------
*/
#include "jsflash.h"
#include "jshardware.h"
#include "jsvariterator.h"
#include "jsinteractive.h"
#include "jswrap_string.h" //jswrap_string_match
#include "jswrap_espruino.h" //jswrap_espruino_CRC
#define SAVED_CODE_BOOTCODE_RESET ".bootrst" // bootcode that runs even after reset
#define SAVED_CODE_BOOTCODE ".bootcde" // bootcode that doesn't run after reset
#ifndef ESPR_NO_VARIMAGE
#define SAVED_CODE_VARIMAGE ".varimg" // Image of all JsVars written to flash
#endif
#define JSF_START_ADDRESS FLASH_SAVED_CODE_START
#define JSF_END_ADDRESS (FLASH_SAVED_CODE_START+FLASH_SAVED_CODE_LENGTH)
#ifdef FLASH_SAVED_CODE2_START // if there's a second bank of flash to use..
#define JSF_BANK2_START_ADDRESS FLASH_SAVED_CODE2_START
#define JSF_BANK2_END_ADDRESS (FLASH_SAVED_CODE2_START+FLASH_SAVED_CODE2_LENGTH)
#define JSF_DEFAULT_START_ADDRESS JSF_BANK2_START_ADDRESS
#define JSF_DEFAULT_END_ADDRESS JSF_BANK2_END_ADDRESS
#else
#define JSF_DEFAULT_START_ADDRESS JSF_START_ADDRESS
#define JSF_DEFAULT_END_ADDRESS JSF_END_ADDRESS
#endif
#ifdef USE_HEATSHRINK
#include "compress_heatshrink.h"
#define COMPRESS heatshrink_encode
#define DECOMPRESS heatshrink_decode
#else
#include "compress_rle.h"
#define COMPRESS rle_encode
#define DECOMPRESS rle_decode
#endif
#define JSF_CACHE_NOT_FOUND 0xFFFFFFFF
#define JSF_MAX_FILES 10000 // 10k files max - we use this for sanity checking our data
#define JSF_FILENAME_TABLE_NAME "[FILENAME_TABLE]"
#ifdef ESPR_STORAGE_FILENAME_TABLE
uint32_t jsfFilenameTableBank1Addr = 0; // address of DATA in the table, NOT THE HEADER (or 0 if no table)
uint32_t jsfFilenameTableBank1Size = 0; // size of table in bytes
#endif
#if ESPR_USE_STORAGE_CACHE
/* Filename lookups can take over 1ms per file even on a reasonably empty SPI Flash memory,
so we can have a cache of the most used file *addresses* in RAM. The data is still in
flash but not having to do the search really helps us.
To use this, add '-DESPR_USE_STORAGE_CACHE=32' or some other number to the BOARD.py file
TODO: we could potentially have some scoring system such that the most used files
like settings.js are never ever taken out of the cache. Right now reading
ESPR_USE_STORAGE_CACHE different files will flush out the cache.
*/
typedef struct {
uint32_t addr; ///< Address as returned by jsfFindFile
JsfFileHeader header; ///< The file header
} JsfCacheEntry;
JsfCacheEntry jsfCache[ESPR_USE_STORAGE_CACHE];
uint8_t jsfCacheEntries = 0;
static void jsfCacheClear() {
jsfCacheEntries = 0;
}
static void jsfCacheClearFile(JsfFileName name) {
for (int i=0;i<jsfCacheEntries;i++) {
if (!jsfIsNameEqual(jsfCache[i].header.name, name))
continue;
// if found, shift subsequent files forward over this one
for (;i<jsfCacheEntries-1;i++)
jsfCache[i] = jsfCache[i+1];
// reduce amount of entries
jsfCacheEntries--;
return;
}
}
// Find an item in the cache - returns JSF_CACHE_NOT_FOUND on failure as it's handy to know about files that don't exist too
static uint32_t jsfCacheFind(JsfFileName name, JsfFileHeader *returnedHeader) {
for (int i=0;i<jsfCacheEntries;i++)
if (jsfIsNameEqual(jsfCache[i].header.name, name)) {
JsfCacheEntry curr = jsfCache[i];
if (i) { // if not at front, put to front
// shift others forward
for (int j=i-1;j>=0;j--)
jsfCache[j+1] = jsfCache[j];
// put at front
jsfCache[0].header = curr.header;
jsfCache[0].addr = curr.addr;
}
if (returnedHeader)
*returnedHeader = curr.header;
return curr.addr;
}
return JSF_CACHE_NOT_FOUND;
}
static void jsfCachePut(JsfFileHeader *header, uint32_t addr) {
// TODO: ListFiles could lazily fill the list with all
// files it finds at the end...
if (jsfCacheEntries<ESPR_USE_STORAGE_CACHE)
jsfCacheEntries++;
for (int i=jsfCacheEntries-2;i>=0;i--)
jsfCache[i+1] = jsfCache[i];
jsfCache[0].header = *header;
jsfCache[0].addr = addr;
}
#else // no cache, just stub with code that does nothing
static void jsfCacheClear() {}
static void jsfCacheClearFile(JsfFileName name) {}
static uint32_t jsfCacheFind(JsfFileName name, JsfFileHeader *header) { return JSF_CACHE_NOT_FOUND; }
static void jsfCachePut(JsfFileHeader *header, uint32_t addr) { }
#endif
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------ Flash Storage Functionality
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
static uint32_t jsfCreateFile(JsfFileName name, uint32_t size, JsfFileFlags flags, JsfFileHeader *returnedHeader);
#ifdef ESPR_STORAGE_FILENAME_TABLE
static uint32_t jsfBankCreateFileTable(uint32_t startAddr);
#endif
/// Aligns a block, pushing it along in memory until it reaches the required alignment
static uint32_t jsfAlignAddress(uint32_t addr) {
return (addr + (JSF_ALIGNMENT-1)) & (uint32_t)~(JSF_ALIGNMENT-1);
}
JsfFileName jsfNameFromString(const char *name) {
assert(strlen(name)<=sizeof(JsfFileName));
char nameBuf[sizeof(JsfFileName)+1];
memset(nameBuf,0,sizeof(nameBuf));
strcpy(nameBuf,name);
return *(JsfFileName*)nameBuf;
}
JsfFileName jsfNameFromVar(JsVar *name) {
char nameBuf[sizeof(JsfFileName)+1];
memset(nameBuf,0,sizeof(nameBuf));
jsvGetString(name, nameBuf, sizeof(nameBuf));
return *(JsfFileName*)nameBuf;
}
JsfFileName jsfNameFromVarAndUnLock(JsVar *name) {
JsfFileName n = jsfNameFromVar(name);
jsvUnLock(name);
return n;
}
JsVar *jsfVarFromName(JsfFileName name) {
char nameBuf[sizeof(JsfFileName)+1];
nameBuf[sizeof(JsfFileName)] = 0;
memcpy(nameBuf, &name, sizeof(JsfFileName));
return jsvNewFromString(nameBuf);
}
/// Are two filenames equal?
bool jsfIsNameEqual(JsfFileName a, JsfFileName b) {
return memcmp(a.c, b.c, sizeof(a.c))==0;
}
/// Return the size in bytes of a file based on the header
uint32_t jsfGetFileSize(JsfFileHeader *header) {
return (uint32_t)(header->size & 0x00FFFFFF);
}
/// Return the flags for this file based on the header
JsfFileFlags jsfGetFileFlags(JsfFileHeader *header) {
return (JsfFileFlags)((uint32_t)header->size >> 24);
}
/** returns true if this file isn't deleted, or some internal
type of file like FILENAME_TABLE that shouldn't be listed
or kept when compacting */
static bool jsfIsRealFile(JsfFileHeader *header) {
return (header->name.firstChars != 0) // if not replaced
#ifdef ESPR_STORAGE_FILENAME_TABLE
&& !(jsfGetFileFlags(header) & JSFF_FILENAME_TABLE)
#endif
;
}
/// Return the flags for this file based on the header
static uint32_t jsfGetBankEndAddress(uint32_t addr) {
#ifdef JSF_BANK2_START_ADDRESS
if (addr>=JSF_BANK2_START_ADDRESS && addr<=JSF_BANK2_END_ADDRESS)
return JSF_BANK2_END_ADDRESS;
#endif
return JSF_END_ADDRESS;
}
/** Load a file header from flash, return true if it is valid.
* If readFullName==false, only the first 4 bytes of the name are loaded */
static bool jsfGetFileHeader(uint32_t addr, JsfFileHeader *header, bool readFullName) {
assert(header);
if (!addr) return false;
jshFlashRead(header, addr, readFullName ? sizeof(JsfFileHeader) : 8/* size + name.firstChars */);
uint32_t endAddress = addr + (uint32_t)sizeof(JsfFileHeader) + jsfGetFileSize(header);
return (header->size != JSF_WORD_UNSET) && (header->size != 0) &&
(endAddress <= jsfGetBankEndAddress(addr));
}
/// Is an area of flash completely erased?
static bool jsfIsErased(uint32_t addr, uint32_t len) {
/* Read whole blocks at the alignment size and check
* everything (even slightly past the length) */
unsigned char buf[128];
assert((sizeof(buf)&(JSF_ALIGNMENT-1))==0);
int watchdogCtr = 0;
while (len) {
uint32_t l = len;
if (l>sizeof(buf)) l=sizeof(buf);
jshFlashRead(&buf, addr, l);
for (uint32_t i=0;i<l;i++)
if (buf[i]!=0xFF) return false;
addr += l;
len -= l;
if (watchdogCtr++ > 500) {
// stop watchdog reboots when checking large areas
// we don't kick all the time so that in *normal* work
// we don't end up calling jshKickWatchDog, so it's harder
// to get in a state where things lock up.
jshKickWatchDog();
jshKickSoftWatchDog();
watchdogCtr = 0;
}
}
return true;
}
/// Is an area of flash equal to something that's in RAM?
static bool jsfIsEqual(uint32_t addr, const unsigned char *data, uint32_t len) {
unsigned char buf[128];
assert((sizeof(buf)&(JSF_ALIGNMENT-1))==0);
uint32_t x=0;
while (len) {
uint32_t l = len;
if (l>sizeof(buf)) l=sizeof(buf);
jshFlashRead(&buf, addr+x, l);
if (memcmp(buf, &data[x], l)) return false;
x += l;
len -= l;
}
return true;
}
/// Erase the entire contents of the memory store
bool jsfEraseAll() {
jsDebug(DBG_INFO,"EraseAll\n");
jsfCacheClear();
#ifdef ESPR_STORAGE_FILENAME_TABLE
jsfFilenameTableBank1Addr = 0;
jsfFilenameTableBank1Size = 0;
#endif
#ifdef JSF_BANK2_START_ADDRESS
if (!jshFlashErasePages(JSF_BANK2_START_ADDRESS, JSF_BANK2_END_ADDRESS-JSF_BANK2_START_ADDRESS)) return false;
#endif
return jshFlashErasePages(JSF_START_ADDRESS, JSF_END_ADDRESS-JSF_START_ADDRESS);
}
/// When a file is found in memory, erase it (by setting first bytes of name to 0). addr=ptr to data, NOT header
static void jsfEraseFileInternal(uint32_t addr, JsfFileHeader *header, bool createFilenameTable) {
jsDebug(DBG_INFO,"EraseFile 0x%08x\n", addr);
addr -= (uint32_t)sizeof(JsfFileHeader);
addr += (uint32_t)((char*)&header->name.firstChars - (char*)header);
header->name.firstChars = 0;
jshFlashWrite(&header->name.firstChars,addr,(uint32_t)sizeof(header->name.firstChars));
#ifdef ESPR_STORAGE_FILENAME_TABLE
if (createFilenameTable && addr>=JSF_START_ADDRESS && addr<JSF_END_ADDRESS) { // if was erasing in Bank 1
// do a scan from the last FILENAME_TABLE to see how many files there are
uint32_t scanAddr = 0;
if (jsfFilenameTableBank1Addr)
scanAddr = jsfFilenameTableBank1Addr + jsfFilenameTableBank1Size;
JsfStorageStats stats = jsfGetStorageStats(scanAddr, true);
/* if more than 200 files were added/deleted since the last
FILENAME_TABLE, try and make a new one. 100 files seems to add
around 5ms to each Storage.list call, or 2ms to a file read. */
if ((stats.trashCount+stats.fileCount)>200)
jsfBankCreateFileTable(JSF_START_ADDRESS);
}
#endif
}
bool jsfEraseFile(JsfFileName name) {
JsfFileHeader header;
uint32_t addr = jsfFindFile(name, &header);
if (!addr) return false;
jsfCacheClearFile(name);
jsfEraseFileInternal(addr, &header, true);
return true;
}
// Get the address of the page after the current one, or 0. THE NEXT PAGE MAY HAVE A PREVIOUS PAGE'S DATA SPANNING OVER IT
static uint32_t jsfGetAddressOfNextPage(uint32_t addr) {
uint32_t pageAddr,pageLen;
if (!jshFlashGetPage(addr, &pageAddr, &pageLen))
return 0;
uint32_t endAddr = jsfGetBankEndAddress(addr);
addr = pageAddr+pageLen;
if (addr>=endAddr) {
return 0; // no pages in range
}
return addr;
}
/* Get the space left for a file (including header) between the address and the next page.
* If the next page is empty, return the space in that as well (and so on) */
static uint32_t jsfGetSpaceLeftInPage(uint32_t addr) {
uint32_t pageAddr,pageLen;
if (!jshFlashGetPage(addr, &pageAddr, &pageLen))
return 0;
uint32_t endAddr = jsfGetBankEndAddress(addr);
uint32_t nextPageStart = pageAddr+pageLen;
// if the next page is empty, assume it's empty until the end of flash
JsfFileHeader header;
if (nextPageStart<endAddr &&
!jsfGetFileHeader(nextPageStart, &header, false)) {
nextPageStart = endAddr;
}
return nextPageStart - addr;
}
typedef enum {
GNFH_GET_EMPTY = 0, ///< stop on an empty header even if there are pages after
GNFH_GET_ALL = 1, ///< get all headers
GNFH_READ_ONLY_FILENAME_START = 2 ///< Get size and the first 4 chars of the filename
} jsfGetNextFileHeaderType;
/** Given the address and a header, work out where the next one should be and load it.
Both addr and header are updated. Returns true if the header is valid, false if not.
If skipPages==true, if a header isn't valid but there's another page, jump to that.
*/
static bool jsfGetNextFileHeader(uint32_t *addr, JsfFileHeader *header, jsfGetNextFileHeaderType type) {
assert(addr && header);
uint32_t oldAddr = *addr;
*addr = 0;
// Work out roughly where the start is
uint32_t newAddr = oldAddr + jsfGetFileSize(header) + (uint32_t)sizeof(JsfFileHeader);
// pad out to flash write boundaries
newAddr = jsfAlignAddress(newAddr);
// sanity check for bad data
if (newAddr<oldAddr) return 0; // corrupt!
if (newAddr+sizeof(JsfFileHeader) > jsfGetBankEndAddress(oldAddr)) return 0; // not enough space
*addr = newAddr;
bool valid = jsfGetFileHeader(newAddr, header, !(type&GNFH_READ_ONLY_FILENAME_START));
if ((type&GNFH_GET_ALL) && !valid) {
// there wasn't another header in this page - check the next page
newAddr = jsfGetAddressOfNextPage(newAddr);
*addr = newAddr;
if (!newAddr) return false; // no valid address
valid = jsfGetFileHeader(newAddr, header, !(type&GNFH_READ_ONLY_FILENAME_START));
// we can't have a blank page and then a header, so stop our search
}
return valid;
}
// Get the address of the page that starts with a header (or is clear) after the current one, or 0
static uint32_t jsfGetAddressOfNextStartPage(uint32_t addr) {
uint32_t next = jsfGetAddressOfNextPage(addr);
if (next==0) return 0; // no next page
JsfFileHeader header;
if (jsfGetFileHeader(addr, &header, false)) do {
if (addr>next) {
next = jsfGetAddressOfNextPage(addr);
if (next==0) return 0;
}
if (addr==next) return addr; // we stumbled on a header that was right on the boundary
} while (jsfGetNextFileHeader(&addr, &header, GNFH_GET_EMPTY|GNFH_READ_ONLY_FILENAME_START));
return next;
}
/// Get info about the current filesystem
JsfStorageStats jsfGetStorageStats(uint32_t addr, bool allPages) {
if (!addr) addr=JSF_DEFAULT_START_ADDRESS;
uint32_t startAddr = addr;
JsfStorageStats stats;
memset(&stats, 0, sizeof(JsfStorageStats));
JsfFileHeader header;
memset(&header,0,sizeof(JsfFileHeader));
uint32_t lastAddr = addr;
#ifndef SAVE_ON_FLASH
uint32_t lastUnbrokenPageStart = addr; // address of last page that doesn't have a file straddling the start
#endif
if (jsfGetFileHeader(addr, &header, false)) do {
uint32_t pageAddr,pageLen;
#ifndef SAVE_ON_FLASH
// check if this header sits right at the start of a page
if (jshFlashGetPage(addr, &pageAddr, &pageLen) && pageAddr==addr)
lastUnbrokenPageStart = pageAddr;
#endif
// now look at the file...
uint32_t fileSize = jsfAlignAddress(jsfGetFileSize(&header)) + (uint32_t)sizeof(JsfFileHeader);
lastAddr = addr + fileSize;
if (header.name.firstChars != 0) { // if not replaced
stats.fileBytes += fileSize;
stats.fileCount++;
} else { // replaced
stats.trashBytes += fileSize;
stats.trashCount++;
#ifndef SAVE_ON_FLASH
if (!stats.firstPageWithErasedFiles)
stats.firstPageWithErasedFiles = lastUnbrokenPageStart;
#endif
}
} while (jsfGetNextFileHeader(&addr, &header, (allPages ? GNFH_GET_ALL : GNFH_GET_EMPTY)|GNFH_READ_ONLY_FILENAME_START));
uint32_t pageEndAddr = allPages ? jsfGetBankEndAddress(startAddr) : jsfGetAddressOfNextPage(startAddr);
stats.total = pageEndAddr - startAddr;
stats.free = pageEndAddr - lastAddr;
return stats;
}
#ifndef SAVE_ON_FLASH
// Copy one memory buffer to another *circular buffer*
static void memcpy_circular(char *dst, uint32_t *dstIndex, uint32_t dstSize, char *src, size_t len) {
while (len--) {
dst[*dstIndex] = *(src++);
*dstIndex = (*dstIndex+1) % dstSize;
}
}
static void jsfCompactWriteBuffer(uint32_t *writeAddress, uint32_t readAddress, char *swapBuffer, uint32_t swapBufferSize, uint32_t *swapBufferUsed, uint32_t *swapBufferTail) {
uint32_t endAddr = jsfGetBankEndAddress(*writeAddress);
uint32_t nextFlashPage = jsfGetAddressOfNextPage(*writeAddress);
if (nextFlashPage==0) nextFlashPage=endAddr;
// write any data between swapBufferTail and the end of the buffer
while (*swapBufferUsed) {
uint32_t s = *swapBufferUsed;
// don't read past end - it's circular
if (s+*swapBufferTail > swapBufferSize)
s = swapBufferSize - *swapBufferTail;
// don't write into a new page
if (s+*writeAddress > nextFlashPage)
s = nextFlashPage-*writeAddress;
if (readAddress < nextFlashPage) {
jsDebug(DBG_INFO,"compact> skip write (0x%08x) as we're still reading from the page (0x%08x)\n", &writeAddress, readAddress);
return;
}
jsDebug(DBG_INFO,"compact> write %d from buf[%d] => 0x%08x\n", s, *swapBufferTail, *writeAddress);
// if on a new page, erase it
uint32_t pAddr, pLen;
if (jshFlashGetPage(*writeAddress, &pAddr, &pLen) && (pAddr == *writeAddress)) {
jsDebug(DBG_INFO,"compact> erase page 0x%08x\n", *writeAddress);
jshFlashErasePage(*writeAddress);
}
assert(jsfIsErased(*writeAddress, s));
//if (!jsfIsErased(*writeAddress, s)) jsiConsolePrintf("ERROR: AREA NOT ERASED 0x%08x => 0x%08x\n", *writeAddress, *writeAddress + s);
jsDebug(DBG_INFO,"compact> write 0x%08x => 0x%08x\n", *writeAddress, *writeAddress + s);
jshFlashWrite(&swapBuffer[*swapBufferTail], *writeAddress, s);
*writeAddress += s;
nextFlashPage = jsfGetAddressOfNextPage(*writeAddress);
if (nextFlashPage==0) nextFlashPage=endAddr;
*swapBufferTail = (*swapBufferTail+s) % swapBufferSize;
*swapBufferUsed -= s;
// ensure we don't reboot here if it takes a long time
jshKickWatchDog();
jshKickSoftWatchDog();
}
}
/* Try and compact saved data so it'll fit in Flash again.
*/
static bool jsfCompactInternal(uint32_t startAddress, char *swapBuffer, uint32_t swapBufferSize) {
uint32_t writeAddress = startAddress;
jsDebug(DBG_INFO,"Compacting from 0x%08x (%d byte buffer)\n", startAddress, swapBufferSize);
#ifdef JSF_BANK2_START_ADDRESS
jsiConsolePrintf("Compacting Bank %d... ", (startAddress>=JSF_BANK2_START_ADDRESS && startAddress<JSF_BANK2_END_ADDRESS)?2:1);
#else
jsiConsolePrintf("Compacting... ");
#endif
uint32_t swapBufferHead = 0;
uint32_t swapBufferTail = 0;
uint32_t swapBufferUsed = 0;
JsfFileHeader header;
memset(&header,0,sizeof(JsfFileHeader));
uint32_t addr = startAddress;
uint32_t lastProgress = 0;
if (jsfGetFileHeader(addr, &header, true)) do {
if (jsfIsRealFile(&header)) { // if not replaced or system file
jsDebug(DBG_INFO,"compact> copying file at 0x%08x\n", addr);
// Rewrite file position for any JsVars that used this file *if* the file changed position
uint32_t newAddress = writeAddress+swapBufferUsed;
if (addr != newAddress)
jsvUpdateMemoryAddress(addr, sizeof(JsfFileHeader) + jsfGetFileSize(&header), newAddress);
// Copy the file into the circular buffer, one bit at a time.
// Write the header
memcpy_circular(swapBuffer, &swapBufferHead, swapBufferSize, (char*)&header, sizeof(JsfFileHeader));
swapBufferUsed += (uint32_t)sizeof(JsfFileHeader);
// Write the contents
uint32_t alignedSize = jsfAlignAddress(jsfGetFileSize(&header));
uint32_t alignedPtr = addr+(uint32_t)sizeof(JsfFileHeader);
jsfCompactWriteBuffer(&writeAddress, alignedPtr, swapBuffer, swapBufferSize, &swapBufferUsed, &swapBufferTail);
while (alignedSize) {
// How much space do we have available in our swapBuffer
uint32_t s = swapBufferSize-swapBufferUsed;
if (s > swapBufferSize-swapBufferHead)
s = swapBufferSize-swapBufferHead;
if ((swapBufferTail>swapBufferHead) && (s > (swapBufferTail-swapBufferHead)))
s = swapBufferTail-swapBufferHead;
if (s==0) {
jsDebug(DBG_INFO,"compact> error - no space left!\n");
return false;
}
if (s>alignedSize) s=alignedSize;
jsDebug(DBG_INFO,"compact> read %d from 0x%08x => buf[%d]\n", s, alignedPtr, swapBufferHead);
jshFlashRead(&swapBuffer[swapBufferHead], alignedPtr, s);
alignedSize -= s;
alignedPtr += s;
swapBufferUsed += s;
swapBufferHead = (swapBufferHead+s) % swapBufferSize;
// Is the buffer big enough to write?
jsfCompactWriteBuffer(&writeAddress, alignedPtr, swapBuffer, swapBufferSize, &swapBufferUsed, &swapBufferTail);
}
uint32_t progress = (addr-startAddress)>>14; // every 16k
if (progress!=lastProgress) {
jsiConsolePrintf("\x08%c", "/-\\|"[progress&3]);
lastProgress = progress;
}
}
// kick watchdog to ensure we don't reboot
jshKickWatchDog();
jshKickSoftWatchDog();
} while (jsfGetNextFileHeader(&addr, &header, GNFH_GET_ALL));
jsDebug(DBG_INFO,"compact> finished reading...\n");
// try and write the remaining
jsfCompactWriteBuffer(&writeAddress, jsfGetBankEndAddress(writeAddress), swapBuffer, swapBufferSize, &swapBufferUsed, &swapBufferTail);
// Finished - erase remaining
jsDebug(DBG_INFO,"compact> almost there - erase remaining pages\n");
if (writeAddress!=startAddress)
writeAddress = jsfGetAddressOfNextPage(writeAddress-1);
if (writeAddress) {
// addr can be zero if last file was right at the end of storage. If so, set to end of storage area
if (!addr) addr=jsfGetBankEndAddress(writeAddress);
jsDebug(DBG_INFO,"compact> erase 0x%08x => 0x%08x\n", writeAddress, addr);
// addr is the address of the last area in flash
jshFlashErasePages(writeAddress, addr-writeAddress);
}
jsiConsolePrintf("\n");
jsDebug(DBG_INFO,"Compaction Complete\n");
return true;
}
#endif
// Compacts one bank - return true if some free space was created
bool jsfBankCompact(uint32_t startAddress, bool showMessage) {
#ifndef SAVE_ON_FLASH
jsDebug(DBG_INFO,"Compacting\n");
uint32_t pageAddr,pageSize;
if (!jshFlashGetPage(startAddress, &pageAddr, &pageSize))
return 0;
uint32_t maxRequired = pageSize + (uint32_t)sizeof(JsfFileHeader);
// TODO: We could skip forward pages if we think they are already fully compacted?
JsfStorageStats stats = jsfGetStorageStats(startAddress, true);
if (!stats.trashBytes) {
jsDebug(DBG_INFO,"Already fully compacted\n");
return false;
}
if (showMessage) {
// On watches that support overlays, show a message over the screen warning that we're compacting and it may take some time
#ifdef BANGLEJS_Q3
jsvUnLock(jspEvaluate("Bangle.setLCDOverlay(Graphics.createArrayBuffer(160,44,1,{msb:true}).drawRect(0,0,159,43).drawRect(1,1,158,42).setFont('12x20').setFontAlign(0,0).drawString('Please Wait',80,14).setColor('#888').setFont('6x8').drawString('STORAGE COMPACTION\\nIN PROGRESS...',80,32),8,66);g.flip();",true));
#endif
#ifdef DICKENS
jsvUnLock(jspEvaluate("Bangle.setLCDOverlay(Graphics.createArrayBuffer(160,40,16,{msb:true}).drawRect(0,0,159,39).drawRect(1,1,158,38).setFontArchitekt12().setFontAlign(0,0).drawString('PLEASE WAIT',80,8).setColor('#888').setFontArchitekt10().drawString('STORAGE COMPACTION\\nIN PROGRESS...',80,27),40,100);g.flip();",true));
#endif
}
uint32_t swapBufferSize = stats.fileBytes;
if (swapBufferSize > maxRequired) swapBufferSize=maxRequired;
// See if we have enough memory...
bool freedMemory = false;
if (swapBufferSize+256 < jsuGetFreeStack()) {
jsDebug(DBG_INFO,"Enough stack for %d byte buffer\n", swapBufferSize);
char *swapBuffer = alloca(swapBufferSize);
freedMemory = jsfCompactInternal(stats.firstPageWithErasedFiles, swapBuffer, swapBufferSize);
} else {
jsDebug(DBG_INFO,"Not enough stack for (%d bytes)\n", swapBufferSize);
JsVar *buf = jsvNewFlatStringOfLength(swapBufferSize);
if (buf) {
jsDebug(DBG_INFO,"Allocated data in JsVars\n");
char *swapBuffer = jsvGetFlatStringPointer(buf);
freedMemory = jsfCompactInternal(stats.firstPageWithErasedFiles, swapBuffer, swapBufferSize);
jsvUnLock(buf);
} else
jsDebug(DBG_INFO,"Not enough memory to compact anything\n");
}
#if defined(BANGLEJS_Q3) || defined(DICKENS)
// if we added the compact message, take it off
jsvUnLock(jspEvaluate("Bangle.setLCDOverlay();g.flip();",true));
#endif
return freedMemory;
#else // SAVE_ON_FLASH
/* If a low flash uC assume we only have a tiny bit of flash. Chances
* are there'll only be one file so just erasing flash will do it. */
bool allocated = jsvGetBoolAndUnLock(jsfListFiles(NULL,0,0));
if (!allocated) {
jsfEraseAll();
return true;
}
#endif // SAVE_ON_FLASH
return false;
}
// Try and compact saved data so it'll fit in Flash again - return true if some free space was created
bool jsfCompact(bool showMessage) {
#ifdef BANGLEJS
JsVarInt jswrap_banglejs_getBattery();
if (jswrap_banglejs_getBattery() < 10) {
jsiConsolePrintf("Less than 10 percent battery remaining - cannot compact\n");
return false;
}
#endif
jsfCacheClear();
#ifdef ESPR_STORAGE_FILENAME_TABLE
jsfFilenameTableBank1Addr = 0;
jsfFilenameTableBank1Size = 0;
#endif
bool compacted = jsfBankCompact(JSF_START_ADDRESS, showMessage);
#ifdef JSF_BANK2_START_ADDRESS
compacted |= jsfBankCompact(JSF_BANK2_START_ADDRESS, showMessage);
#endif
return compacted;
}
/* If we have a filename like "C:foo", take the 'C:' bit
* off it and return the drive. If explicitOnly==false,
* we also return the drive name if we think a file should
* go somewhere (eg it's *.js or .boot0 it should go in internal flash)
*/
char jsfStripDriveFromName(JsfFileName *name, bool explicitOnly){
#ifndef SAVE_ON_FLASH
if (name->c[1]==':') { // if a 'drive' is specified like "C:foobar.js"
char drive = name->c[0];
memmove(name->c, name->c+2, sizeof(JsfFileName)-2); // shift back and clear the rest
name->c[sizeof(JsfFileName)-2]=0;name->c[sizeof(JsfFileName)-1]=0;
return drive;
}
#ifdef JSF_BANK2_START_ADDRESS
if (explicitOnly) return 0; // if explicitOnly==false, ensure *.js .boot0 .bootcde and library files (with no dots) go in C:
int l = 0;
while (name->c[l] && l<sizeof(JsfFileName)) l++;
if (strcmp(name,".boot0")==0 || strcmp(name,".bootcde")==0 || strchr(name,'.')==0 ||
(name->c[l-3]=='.' && name->c[l-2]=='j' && name->c[l-1]=='s')) {
return 'C';
}
#endif
#endif
return 0;
}
void jsfGetDriveBankAddress(char drive, uint32_t *bankStartAddr, uint32_t *bankEndAddr){
#ifdef JSF_BANK2_START_ADDRESS
if (drive){
if ((drive&(~0x20)) == 'C'){ // make drive case insensitive
*bankStartAddr=JSF_START_ADDRESS;
*bankEndAddr=JSF_END_ADDRESS;
} else {
*bankStartAddr=JSF_BANK2_START_ADDRESS;
*bankEndAddr=JSF_BANK2_END_ADDRESS;
}
return;
}
#endif
*bankStartAddr=JSF_DEFAULT_START_ADDRESS;
*bankEndAddr=JSF_DEFAULT_END_ADDRESS;
}
/// Create a new 'file' in the memory store - DOES NOT remove existing files with same name. Return the address of data start, or 0 on error
static uint32_t jsfCreateFile(JsfFileName name, uint32_t size, JsfFileFlags flags, JsfFileHeader *returnedHeader) {
jsDebug(DBG_INFO,"CreateFile (%d bytes)\n", size);
char drive = jsfStripDriveFromName(&name, false/* ensure .js/etc go in C */);
jsfCacheClearFile(name);
uint32_t bankStartAddress,bankEndAddress;
jsfGetDriveBankAddress(drive,&bankStartAddress,&bankEndAddress);
/* TODO: do we want to start our scan from jsfFilenameTableBank1Addr to
* make writing files faster? */
uint32_t requiredSize = jsfAlignAddress(size)+(uint32_t)sizeof(JsfFileHeader);
bool compacted = false;
uint32_t addr = 0;
JsfFileHeader header;
uint32_t freeAddr = 0;
while (!freeAddr) {
addr = bankStartAddress;
freeAddr = 0;
// Find a hole that's big enough for our file
do {
if (jsfGetFileHeader(addr, &header, false)) do {
} while (jsfGetNextFileHeader(&addr, &header, GNFH_GET_EMPTY));
// If not enough space, skip to next page
if (jsfGetSpaceLeftInPage(addr)<requiredSize) {
addr = jsfGetAddressOfNextPage(addr);
} else { // if enough space, we can write a file!
freeAddr = addr;
}
} while (addr && !freeAddr);
// If we don't have space, compact
if (!freeAddr) {
// check this for sanity - in future we might compact forward into other pages, and don't compact if so
if (!compacted) {
compacted = true;
if (!jsfCompact(true)) {
jsDebug(DBG_INFO,"CreateFile - Compact failed\n");
return 0;
}
addr = bankStartAddress; // addr->startAddr = restart
} else {
// FIXME: if we have 2 banks and there is no room in this one, what about the other bank?
jsDebug(DBG_INFO,"CreateFile - Not enough space\n");
return 0;
}
}
};
/* We used to push files forward to the nearest page boundary but now there's very little point
doing this. While we still have to cope with it when reading storage, we now don't try and align
new files - see https://github.com/espruino/Espruino/issues/2232 */
addr = freeAddr;
// write out the header
jsDebug(DBG_INFO,"CreateFile new 0x%08x\n", addr+(uint32_t)sizeof(JsfFileHeader));
header.size = size | (flags<<24);
header.name = name;
jsDebug(DBG_INFO,"CreateFile write header\n");
jshFlashWrite(&header,addr,(uint32_t)sizeof(JsfFileHeader));
jsDebug(DBG_INFO,"CreateFile written header\n");
if (returnedHeader) *returnedHeader = header;
addr += (uint32_t)sizeof(JsfFileHeader); // address of actual file data
jsfCachePut(&header, addr);
return addr;
}
static uint32_t jsfBankFindFile(uint32_t bankAddress, uint32_t bankEndAddress, JsfFileName name, JsfFileHeader *returnedHeader) {
uint32_t addr = bankAddress;
JsfFileHeader header;
#ifdef ESPR_STORAGE_FILENAME_TABLE
if (jsfFilenameTableBank1Addr && addr==JSF_START_ADDRESS) {
#define FILENAME_TABLE_CHUNKS 8 // how many file headers do we read at once?
JsfFileHeader tableHeaders[FILENAME_TABLE_CHUNKS];
uint32_t baseAddr = addr;
uint32_t tableAddr = jsfFilenameTableBank1Addr;
uint32_t tableEnd = tableAddr + jsfFilenameTableBank1Size;
int tableEntries = (tableEnd-tableAddr) / sizeof(JsfFileHeader);
// Now scan the table and call back for each item
while (tableEntries) {
int readEntries = tableEntries;
if (readEntries > FILENAME_TABLE_CHUNKS)
readEntries = FILENAME_TABLE_CHUNKS;
// read the address and name...
jshFlashRead(&tableHeaders, tableAddr, readEntries*sizeof(JsfFileHeader));
tableAddr += readEntries*(uint32_t)sizeof(JsfFileHeader);
tableEntries -= readEntries;
for (int i=0;i<readEntries;i++) {
if (jsfIsNameEqual(tableHeaders[i].name, name)) { // name matches
uint32_t fileAddr = baseAddr + tableHeaders[i].size;
if (jsfGetFileHeader(fileAddr, &tableHeaders[i], true) && // read the real header
(tableHeaders[i].name.firstChars != 0)) { // check the file was not replaced
if (returnedHeader)
*returnedHeader = tableHeaders[i];
return fileAddr+(uint32_t)sizeof(JsfFileHeader);
}
/* Or... the file was in our table but it's been replaced. In this case
stop scanning our table and instead just do a normal scan for files
added after the table... */
}
}
}
// We didn't find the file in our table...
// Now point 'addr' to the start of this table and fill in the header.
// the normal code will see this, skip over it like a normal file
// and carry on regardless.
addr = jsfFilenameTableBank1Addr - sizeof(JsfFileHeader); // address of jsfFilenameTable's header
header.name.firstChars = 0;
header.size = jsfFilenameTableBank1Size;
} else
#endif
if (!jsfGetFileHeader(addr, &header, false)) return 0;
// Now search through files in storage
do {
// check for something with the same first 4 chars of name that hasn't been replaced.
if (header.name.firstChars == name.firstChars) {
// Now load the whole header (with name) and check properly
if (jsfGetFileHeader(addr, &header, true) && // get file (checks file length is ok)
jsfIsNameEqual(header.name, name)) {
if (returnedHeader)
*returnedHeader = header;
return addr+(uint32_t)sizeof(JsfFileHeader);
}
}
} while (jsfGetNextFileHeader(&addr, &header, GNFH_GET_ALL|GNFH_READ_ONLY_FILENAME_START)); // still only get first 4 chars of name
return 0;
}
/// Find a 'file' in the memory store. Return the address of data start (and header if returnedHeader!=0). Returns 0 if not found
uint32_t jsfFindFile(JsfFileName name, JsfFileHeader *returnedHeader) {
#ifdef JSF_BANK2_START_ADDRESS
char drive =
#endif
jsfStripDriveFromName(&name, true/* ensure we search both drive if not explicitly requested */);
uint32_t a = jsfCacheFind(name, returnedHeader);
if (a!=JSF_CACHE_NOT_FOUND) return a;
JsfFileHeader header;
#ifdef JSF_BANK2_START_ADDRESS
if (drive) {
// if more banks defined search only in one determined from drive letter
uint32_t startAddress,endAddress;
jsfGetDriveBankAddress(drive,&startAddress,&endAddress);
a = jsfBankFindFile(startAddress, endAddress, name, &header);
} else {
// if no drive letter specified, search in both
a = jsfBankFindFile(JSF_START_ADDRESS, JSF_END_ADDRESS, name, &header);
if (!a) a = jsfBankFindFile(JSF_BANK2_START_ADDRESS, JSF_BANK2_END_ADDRESS, name, &header);
}
#else
a = jsfBankFindFile(JSF_START_ADDRESS, JSF_END_ADDRESS, name, &header);
#endif
if (!a) header.name = name;
jsfCachePut(&header, a); // we put the file in even if it's not found, as that's handy too
if (returnedHeader) *returnedHeader = header;
return a;
}
static uint32_t jsfBankFindFileFromAddr(uint32_t bankAddress, uint32_t bankEndAddress, uint32_t containsAddr, JsfFileHeader *returnedHeader) {
uint32_t addr = bankAddress;
JsfFileHeader header;
memset(&header,0,sizeof(JsfFileHeader));
if (jsfGetFileHeader(addr, &header, false)) do {
uint32_t endOfFile = addr + (uint32_t)sizeof(JsfFileHeader) + jsfGetFileSize(&header);
if ((header.name.firstChars != 0) && // not been replaced
(addr<=containsAddr && containsAddr<=endOfFile)) {
// Now load the whole header (with name) and check properly
jsfGetFileHeader(addr, &header, true);
if (returnedHeader)
*returnedHeader = header;
return addr+(uint32_t)sizeof(JsfFileHeader);
}
} while (jsfGetNextFileHeader(&addr, &header, GNFH_GET_ALL|GNFH_READ_ONLY_FILENAME_START)); // still only get first 4 chars of name
return 0;
}
uint32_t jsfFindFileFromAddr(uint32_t containsAddr, JsfFileHeader *returnedHeader) {
if (containsAddr>=JSF_START_ADDRESS && containsAddr<=JSF_END_ADDRESS) {
uint32_t a = jsfBankFindFileFromAddr(JSF_START_ADDRESS, JSF_END_ADDRESS, containsAddr, returnedHeader);
if (a) return a;
}
#ifdef JSF_BANK2_START_ADDRESS
if (containsAddr>=JSF_BANK2_START_ADDRESS && containsAddr<=JSF_BANK2_END_ADDRESS) {
uint32_t a = jsfBankFindFileFromAddr(JSF_BANK2_START_ADDRESS, JSF_BANK2_END_ADDRESS, containsAddr, returnedHeader);
if (a) return a;
}
#endif
return 0;
}
static void jsfBankDebugFiles(uint32_t addr) {
uint32_t pageAddr = 0, pageLen = 0, pageEndAddr = 0;
JsfStorageStats stats = jsfGetStorageStats(addr,true);
jsiConsolePrintf("DEBUG FILES (0x%08x)\n %db (%d files) live\n %db (%d files) trash\n", addr, stats.fileBytes, stats.fileCount, stats.trashBytes, stats.trashCount);
JsfFileHeader header;
memset(&header,0,sizeof(JsfFileHeader));
if (jsfGetFileHeader(addr, &header, true)) do {
if (addr>=pageEndAddr) {
if (!jshFlashGetPage(addr, &pageAddr, &pageLen)) {
jsiConsolePrintf("Page not found!\n");
return;
}
pageEndAddr = pageAddr+pageLen;
uint32_t nextStartPage = jsfGetAddressOfNextStartPage(addr);
JsfStorageStats stats = jsfGetStorageStats(pageAddr,false);
if (nextStartPage==pageEndAddr) {
jsiConsolePrintf("PAGE 0x%08x (%d bytes) - %d live %d free\n",
pageAddr,pageLen,stats.fileBytes,pageLen - stats.fileBytes);
} else {
pageLen = nextStartPage-pageAddr;
jsiConsolePrintf("PAGES 0x%08x -> 0x%08x (%d bytes) - %d live %d free\n",
pageAddr,nextStartPage,pageLen,
stats.fileBytes,pageLen-stats.fileBytes);
}
}
char nameBuf[sizeof(JsfFileName)+1];
memset(nameBuf,0,sizeof(nameBuf));
memcpy(nameBuf,&header.name,sizeof(JsfFileName));
jsiConsolePrintf("0x%08x\t%s\t(%d bytes)\n", addr+(uint32_t)sizeof(JsfFileHeader), nameBuf[0]?nameBuf:"DELETED", jsfGetFileSize(&header));
// TODO: print page boundaries
} while (jsfGetNextFileHeader(&addr, &header, GNFH_GET_ALL));
}
/// Output debug info for files stored in flash storage
void jsfDebugFiles() {
jsfBankDebugFiles(JSF_START_ADDRESS);
#ifdef JSF_BANK2_START_ADDRESS
jsfBankDebugFiles(JSF_BANK2_START_ADDRESS);
#endif
}
static bool jsfIsBankStorageValid(uint32_t startAddr, JsfStorageTestType testFlags) {
JsfStorageTestType testType = testFlags&JSFSTT_TYPE_MASK;
uint32_t addr = startAddr;
uint32_t endAddr = jsfGetBankEndAddress(addr);
uint32_t oldAddr = addr;
JsfFileHeader header;
unsigned char *headerPtr = (unsigned char *)&header;
bool valid = jsfGetFileHeader(addr, &header, true);
if (valid) {
while (jsfGetNextFileHeader(&addr, &header, GNFH_GET_ALL)) {
#ifdef ESPR_STORAGE_FILENAME_TABLE
if ((testFlags & JSFSTT_FIND_FILENAME_TABLE) &&
(startAddr==JSF_START_ADDRESS) &&
(jsfGetFileFlags(&header) & JSFF_FILENAME_TABLE)) {
jsfGetFileHeader(addr, &header, true); // get all data from header
if (jsfIsNameEqual(header.name, jsfNameFromString(JSF_FILENAME_TABLE_NAME)) &&
(jsfGetFileSize(&header) < JSF_MAX_FILES)) {
// Only set the table if we're sure it's ok (sensible size, correct filename)
jsfFilenameTableBank1Addr = addr + (uint32_t)sizeof(JsfFileHeader);
jsfFilenameTableBank1Size = jsfGetFileSize(&header);
}
}
#endif
oldAddr = addr;
jshKickWatchDog(); // stop watchdog reboots
}
if (!addr) { // may have returned 0 just because storage is full
// Work out roughly where the start is
uint32_t newAddr = jsfAlignAddress(oldAddr + jsfGetFileSize(&header) + (uint32_t)sizeof(JsfFileHeader));
if (newAddr<oldAddr) return false; // definitely corrupt!
if (newAddr <= endAddr &&
newAddr+sizeof(JsfFileHeader)>endAddr) return true; // not enough space - this is fine
}
}
bool allFF = true;
for (size_t i=0;i<sizeof(JsfFileHeader);i++)
if (headerPtr[i]!=0xFF) allFF=false;
if (allFF && ((addr && testType==JSFSTT_ALL) || // FULL: always search the remaining area
(addr==startAddr && testType==JSFSTT_NORMAL))) { // NORMAL: if no files, only search everything if storage is empty
return jsfIsErased(addr, endAddr-addr);
}
return allFF;
}
/** Return false if the current storage is not valid
* or is corrupt somehow. Basically that means if
* jsfGet[Next]FileHeader returns false but the header isn't all FF
*
* If fullTest is true, all of storage is scanned.
* For instance the first page may be blank but other pages
* may contain info (which is invalid)...
*/
bool jsfIsStorageValid(JsfStorageTestType testFlags) {
if (!jsfIsBankStorageValid(JSF_START_ADDRESS, testFlags))
return false;
#ifdef JSF_BANK2_START_ADDRESS
if (!jsfIsBankStorageValid(JSF_BANK2_START_ADDRESS, testFlags))
return false;
#endif
return true;
}
/** Return true if there is nothing at all in Storage (first header on first page is all 0xFF) */
bool jsfIsBankStorageEmpty(uint32_t addr) {
JsfFileHeader header;
unsigned char *headerPtr = (unsigned char *)&header;
jsfGetFileHeader(addr, &header, true);
bool allFF = true;
for (size_t i=0;i<sizeof(JsfFileHeader);i++)
if (headerPtr[i]!=0xFF) allFF=false;
return allFF;
}
/** Return true if there is nothing at all in Storage (first header on first page is all 0xFF) */
bool jsfIsStorageEmpty() {
if (!jsfIsBankStorageEmpty(JSF_START_ADDRESS))