]>
Commit | Line | Data |
---|---|---|
932394ac WD |
1 | #include <common.h> |
2 | ||
dd60d122 | 3 | #if !defined(CFG_NAND_LEGACY) && defined(CONFIG_CMD_JFFS2) |
932394ac WD |
4 | |
5 | #include <malloc.h> | |
6 | #include <linux/stat.h> | |
7 | #include <linux/time.h> | |
8 | ||
9 | #include <jffs2/jffs2.h> | |
10 | #include <jffs2/jffs2_1pass.h> | |
11 | #include <nand.h> | |
12 | ||
13 | #include "jffs2_nand_private.h" | |
14 | ||
ac7eb8a3 | 15 | #define NODE_CHUNK 1024 /* size of memory allocation chunk in b_nodes */ |
932394ac WD |
16 | |
17 | /* Debugging switches */ | |
18 | #undef DEBUG_DIRENTS /* print directory entry list after scan */ | |
19 | #undef DEBUG_FRAGMENTS /* print fragment list after scan */ | |
ac7eb8a3 | 20 | #undef DEBUG /* enable debugging messages */ |
932394ac WD |
21 | |
22 | #ifdef DEBUG | |
23 | # define DEBUGF(fmt,args...) printf(fmt ,##args) | |
24 | #else | |
25 | # define DEBUGF(fmt,args...) | |
26 | #endif | |
27 | ||
932394ac WD |
28 | static nand_info_t *nand; |
29 | ||
30 | /* Compression names */ | |
31 | static char *compr_names[] = { | |
32 | "NONE", | |
33 | "ZERO", | |
34 | "RTIME", | |
35 | "RUBINMIPS", | |
36 | "COPY", | |
37 | "DYNRUBIN", | |
38 | "ZLIB", | |
39 | #if defined(CONFIG_JFFS2_LZO_LZARI) | |
40 | "LZO", | |
41 | "LZARI", | |
42 | #endif | |
43 | }; | |
44 | ||
45 | /* Spinning wheel */ | |
46 | static char spinner[] = { '|', '/', '-', '\\' }; | |
47 | ||
48 | /* Memory management */ | |
49 | struct mem_block { | |
50 | unsigned index; | |
51 | struct mem_block *next; | |
52 | char nodes[0]; | |
53 | }; | |
54 | ||
55 | static void | |
56 | free_nodes(struct b_list *list) | |
57 | { | |
58 | while (list->listMemBase != NULL) { | |
59 | struct mem_block *next = list->listMemBase->next; | |
60 | free(list->listMemBase); | |
61 | list->listMemBase = next; | |
62 | } | |
63 | } | |
64 | ||
65 | static struct b_node * | |
66 | add_node(struct b_list *list, int size) | |
67 | { | |
68 | u32 index = 0; | |
69 | struct mem_block *memBase; | |
70 | struct b_node *b; | |
71 | ||
72 | memBase = list->listMemBase; | |
73 | if (memBase != NULL) | |
74 | index = memBase->index; | |
75 | ||
76 | if (memBase == NULL || index >= NODE_CHUNK) { | |
77 | /* we need more space before we continue */ | |
78 | memBase = mmalloc(sizeof(struct mem_block) + NODE_CHUNK * size); | |
79 | if (memBase == NULL) { | |
80 | putstr("add_node: malloc failed\n"); | |
81 | return NULL; | |
82 | } | |
83 | memBase->next = list->listMemBase; | |
84 | index = 0; | |
85 | } | |
86 | /* now we have room to add it. */ | |
87 | b = (struct b_node *)&memBase->nodes[size * index]; | |
88 | index ++; | |
89 | ||
90 | memBase->index = index; | |
91 | list->listMemBase = memBase; | |
92 | list->listCount++; | |
93 | return b; | |
94 | } | |
95 | ||
96 | static struct b_node * | |
97 | insert_node(struct b_list *list, struct b_node *new) | |
98 | { | |
99 | #ifdef CFG_JFFS2_SORT_FRAGMENTS | |
100 | struct b_node *b, *prev; | |
101 | ||
102 | if (list->listTail != NULL && list->listCompare(new, list->listTail)) | |
103 | prev = list->listTail; | |
104 | else if (list->listLast != NULL && list->listCompare(new, list->listLast)) | |
105 | prev = list->listLast; | |
106 | else | |
107 | prev = NULL; | |
108 | ||
109 | for (b = (prev ? prev->next : list->listHead); | |
110 | b != NULL && list->listCompare(new, b); | |
111 | prev = b, b = b->next) { | |
112 | list->listLoops++; | |
113 | } | |
114 | if (b != NULL) | |
115 | list->listLast = prev; | |
116 | ||
117 | if (b != NULL) { | |
118 | new->next = b; | |
119 | if (prev != NULL) | |
120 | prev->next = new; | |
121 | else | |
122 | list->listHead = new; | |
123 | } else | |
124 | #endif | |
125 | { | |
126 | new->next = (struct b_node *) NULL; | |
127 | if (list->listTail != NULL) { | |
128 | list->listTail->next = new; | |
129 | list->listTail = new; | |
130 | } else { | |
131 | list->listTail = list->listHead = new; | |
132 | } | |
133 | } | |
134 | ||
135 | return new; | |
136 | } | |
137 | ||
138 | static struct b_node * | |
139 | insert_inode(struct b_list *list, struct jffs2_raw_inode *node, u32 offset) | |
140 | { | |
141 | struct b_inode *new; | |
142 | ||
143 | if (!(new = (struct b_inode *)add_node(list, sizeof(struct b_inode)))) { | |
144 | putstr("add_node failed!\r\n"); | |
145 | return NULL; | |
146 | } | |
147 | new->offset = offset; | |
148 | new->version = node->version; | |
149 | new->ino = node->ino; | |
150 | new->isize = node->isize; | |
151 | new->csize = node->csize; | |
152 | ||
153 | return insert_node(list, (struct b_node *)new); | |
154 | } | |
155 | ||
156 | static struct b_node * | |
157 | insert_dirent(struct b_list *list, struct jffs2_raw_dirent *node, u32 offset) | |
158 | { | |
159 | struct b_dirent *new; | |
160 | ||
161 | if (!(new = (struct b_dirent *)add_node(list, sizeof(struct b_dirent)))) { | |
162 | putstr("add_node failed!\r\n"); | |
163 | return NULL; | |
164 | } | |
165 | new->offset = offset; | |
166 | new->version = node->version; | |
167 | new->pino = node->pino; | |
168 | new->ino = node->ino; | |
169 | new->nhash = full_name_hash(node->name, node->nsize); | |
170 | new->nsize = node->nsize; | |
171 | new->type = node->type; | |
172 | ||
173 | return insert_node(list, (struct b_node *)new); | |
174 | } | |
175 | ||
176 | #ifdef CFG_JFFS2_SORT_FRAGMENTS | |
177 | /* Sort data entries with the latest version last, so that if there | |
178 | * is overlapping data the latest version will be used. | |
179 | */ | |
180 | static int compare_inodes(struct b_node *new, struct b_node *old) | |
181 | { | |
182 | struct jffs2_raw_inode ojNew; | |
183 | struct jffs2_raw_inode ojOld; | |
184 | struct jffs2_raw_inode *jNew = | |
185 | (struct jffs2_raw_inode *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); | |
186 | struct jffs2_raw_inode *jOld = | |
187 | (struct jffs2_raw_inode *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); | |
188 | ||
189 | return jNew->version > jOld->version; | |
190 | } | |
191 | ||
192 | /* Sort directory entries so all entries in the same directory | |
193 | * with the same name are grouped together, with the latest version | |
194 | * last. This makes it easy to eliminate all but the latest version | |
195 | * by marking the previous version dead by setting the inode to 0. | |
196 | */ | |
197 | static int compare_dirents(struct b_node *new, struct b_node *old) | |
198 | { | |
199 | struct jffs2_raw_dirent ojNew; | |
200 | struct jffs2_raw_dirent ojOld; | |
201 | struct jffs2_raw_dirent *jNew = | |
202 | (struct jffs2_raw_dirent *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); | |
203 | struct jffs2_raw_dirent *jOld = | |
204 | (struct jffs2_raw_dirent *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); | |
205 | int cmp; | |
206 | ||
207 | /* ascending sort by pino */ | |
208 | if (jNew->pino != jOld->pino) | |
209 | return jNew->pino > jOld->pino; | |
210 | ||
211 | /* pino is the same, so use ascending sort by nsize, so | |
212 | * we don't do strncmp unless we really must. | |
213 | */ | |
214 | if (jNew->nsize != jOld->nsize) | |
215 | return jNew->nsize > jOld->nsize; | |
216 | ||
217 | /* length is also the same, so use ascending sort by name | |
218 | */ | |
219 | cmp = strncmp(jNew->name, jOld->name, jNew->nsize); | |
220 | if (cmp != 0) | |
221 | return cmp > 0; | |
222 | ||
223 | /* we have duplicate names in this directory, so use ascending | |
224 | * sort by version | |
225 | */ | |
226 | if (jNew->version > jOld->version) { | |
227 | /* since jNew is newer, we know jOld is not valid, so | |
228 | * mark it with inode 0 and it will not be used | |
229 | */ | |
230 | jOld->ino = 0; | |
231 | return 1; | |
232 | } | |
233 | ||
234 | return 0; | |
235 | } | |
236 | #endif | |
237 | ||
238 | static u32 | |
239 | jffs_init_1pass_list(struct part_info *part) | |
240 | { | |
241 | struct b_lists *pL; | |
242 | ||
243 | if (part->jffs2_priv != NULL) { | |
244 | pL = (struct b_lists *)part->jffs2_priv; | |
245 | free_nodes(&pL->frag); | |
246 | free_nodes(&pL->dir); | |
247 | free(pL); | |
248 | } | |
249 | if (NULL != (part->jffs2_priv = malloc(sizeof(struct b_lists)))) { | |
250 | pL = (struct b_lists *)part->jffs2_priv; | |
251 | ||
252 | memset(pL, 0, sizeof(*pL)); | |
253 | #ifdef CFG_JFFS2_SORT_FRAGMENTS | |
254 | pL->dir.listCompare = compare_dirents; | |
255 | pL->frag.listCompare = compare_inodes; | |
256 | #endif | |
257 | } | |
258 | return 0; | |
259 | } | |
260 | ||
261 | /* find the inode from the slashless name given a parent */ | |
262 | static long | |
263 | jffs2_1pass_read_inode(struct b_lists *pL, u32 ino, char *dest, | |
264 | struct stat *stat) | |
265 | { | |
266 | struct b_inode *jNode; | |
267 | u32 totalSize = 0; | |
268 | u32 latestVersion = 0; | |
269 | long ret; | |
270 | ||
271 | #ifdef CFG_JFFS2_SORT_FRAGMENTS | |
272 | /* Find file size before loading any data, so fragments that | |
273 | * start past the end of file can be ignored. A fragment | |
274 | * that is partially in the file is loaded, so extra data may | |
275 | * be loaded up to the next 4K boundary above the file size. | |
276 | * This shouldn't cause trouble when loading kernel images, so | |
277 | * we will live with it. | |
278 | */ | |
279 | for (jNode = (struct b_inode *)pL->frag.listHead; jNode; jNode = jNode->next) { | |
280 | if ((ino == jNode->ino)) { | |
281 | /* get actual file length from the newest node */ | |
282 | if (jNode->version >= latestVersion) { | |
283 | totalSize = jNode->isize; | |
284 | latestVersion = jNode->version; | |
285 | } | |
286 | } | |
287 | } | |
288 | #endif | |
289 | ||
290 | for (jNode = (struct b_inode *)pL->frag.listHead; jNode; jNode = jNode->next) { | |
291 | if ((ino != jNode->ino)) | |
292 | continue; | |
293 | #ifndef CFG_JFFS2_SORT_FRAGMENTS | |
294 | /* get actual file length from the newest node */ | |
295 | if (jNode->version >= latestVersion) { | |
296 | totalSize = jNode->isize; | |
297 | latestVersion = jNode->version; | |
298 | } | |
299 | #endif | |
300 | if (dest || stat) { | |
301 | char *src, *dst; | |
302 | char data[4096 + sizeof(struct jffs2_raw_inode)]; | |
303 | struct jffs2_raw_inode *inode; | |
304 | size_t len; | |
305 | ||
306 | inode = (struct jffs2_raw_inode *)&data; | |
307 | len = sizeof(struct jffs2_raw_inode); | |
308 | if (dest) | |
309 | len += jNode->csize; | |
310 | nand_read(nand, jNode->offset, &len, inode); | |
311 | /* ignore data behind latest known EOF */ | |
312 | if (inode->offset > totalSize) | |
313 | continue; | |
314 | ||
315 | if (stat) { | |
316 | stat->st_mtime = inode->mtime; | |
317 | stat->st_mode = inode->mode; | |
318 | stat->st_ino = inode->ino; | |
319 | stat->st_size = totalSize; | |
320 | } | |
321 | ||
322 | if (!dest) | |
323 | continue; | |
324 | ||
325 | src = ((char *) inode) + sizeof(struct jffs2_raw_inode); | |
326 | dst = (char *) (dest + inode->offset); | |
327 | ||
328 | switch (inode->compr) { | |
329 | case JFFS2_COMPR_NONE: | |
330 | ret = 0; | |
331 | memcpy(dst, src, inode->dsize); | |
332 | break; | |
333 | case JFFS2_COMPR_ZERO: | |
334 | ret = 0; | |
335 | memset(dst, 0, inode->dsize); | |
336 | break; | |
337 | case JFFS2_COMPR_RTIME: | |
338 | ret = 0; | |
339 | rtime_decompress(src, dst, inode->csize, inode->dsize); | |
340 | break; | |
341 | case JFFS2_COMPR_DYNRUBIN: | |
342 | /* this is slow but it works */ | |
343 | ret = 0; | |
344 | dynrubin_decompress(src, dst, inode->csize, inode->dsize); | |
345 | break; | |
346 | case JFFS2_COMPR_ZLIB: | |
347 | ret = zlib_decompress(src, dst, inode->csize, inode->dsize); | |
348 | break; | |
349 | #if defined(CONFIG_JFFS2_LZO_LZARI) | |
350 | case JFFS2_COMPR_LZO: | |
351 | ret = lzo_decompress(src, dst, inode->csize, inode->dsize); | |
352 | break; | |
353 | case JFFS2_COMPR_LZARI: | |
354 | ret = lzari_decompress(src, dst, inode->csize, inode->dsize); | |
355 | break; | |
356 | #endif | |
357 | default: | |
358 | /* unknown */ | |
359 | putLabeledWord("UNKOWN COMPRESSION METHOD = ", inode->compr); | |
360 | return -1; | |
361 | } | |
362 | } | |
363 | } | |
364 | ||
365 | return totalSize; | |
366 | } | |
367 | ||
368 | /* find the inode from the slashless name given a parent */ | |
369 | static u32 | |
370 | jffs2_1pass_find_inode(struct b_lists * pL, const char *name, u32 pino) | |
371 | { | |
372 | struct b_dirent *jDir; | |
373 | int len = strlen(name); /* name is assumed slash free */ | |
374 | unsigned int nhash = full_name_hash(name, len); | |
375 | u32 version = 0; | |
376 | u32 inode = 0; | |
377 | ||
378 | /* we need to search all and return the inode with the highest version */ | |
379 | for (jDir = (struct b_dirent *)pL->dir.listHead; jDir; jDir = jDir->next) { | |
380 | if ((pino == jDir->pino) && (jDir->ino) && /* 0 for unlink */ | |
381 | (len == jDir->nsize) && (nhash == jDir->nhash)) { | |
382 | /* TODO: compare name */ | |
383 | if (jDir->version < version) | |
384 | continue; | |
385 | ||
386 | if (jDir->version == version && inode != 0) { | |
ac7eb8a3 | 387 | /* I'm pretty sure this isn't legal */ |
932394ac | 388 | putstr(" ** ERROR ** "); |
ac7eb8a3 WD |
389 | /* putnstr(jDir->name, jDir->nsize); */ |
390 | /* putLabeledWord(" has dup version =", version); */ | |
932394ac WD |
391 | } |
392 | inode = jDir->ino; | |
393 | version = jDir->version; | |
394 | } | |
395 | } | |
396 | return inode; | |
397 | } | |
398 | ||
399 | char *mkmodestr(unsigned long mode, char *str) | |
400 | { | |
401 | static const char *l = "xwr"; | |
402 | int mask = 1, i; | |
403 | char c; | |
404 | ||
405 | switch (mode & S_IFMT) { | |
406 | case S_IFDIR: str[0] = 'd'; break; | |
407 | case S_IFBLK: str[0] = 'b'; break; | |
408 | case S_IFCHR: str[0] = 'c'; break; | |
409 | case S_IFIFO: str[0] = 'f'; break; | |
410 | case S_IFLNK: str[0] = 'l'; break; | |
411 | case S_IFSOCK: str[0] = 's'; break; | |
412 | case S_IFREG: str[0] = '-'; break; | |
413 | default: str[0] = '?'; | |
414 | } | |
415 | ||
416 | for(i = 0; i < 9; i++) { | |
417 | c = l[i%3]; | |
418 | str[9-i] = (mode & mask)?c:'-'; | |
419 | mask = mask<<1; | |
420 | } | |
421 | ||
422 | if(mode & S_ISUID) str[3] = (mode & S_IXUSR)?'s':'S'; | |
423 | if(mode & S_ISGID) str[6] = (mode & S_IXGRP)?'s':'S'; | |
424 | if(mode & S_ISVTX) str[9] = (mode & S_IXOTH)?'t':'T'; | |
425 | str[10] = '\0'; | |
426 | return str; | |
427 | } | |
428 | ||
429 | static inline void dump_stat(struct stat *st, const char *name) | |
430 | { | |
431 | char str[20]; | |
432 | char s[64], *p; | |
433 | ||
434 | if (st->st_mtime == (time_t)(-1)) /* some ctimes really hate -1 */ | |
435 | st->st_mtime = 1; | |
436 | ||
437 | ctime_r(&st->st_mtime, s/*,64*/); /* newlib ctime doesn't have buflen */ | |
438 | ||
439 | if ((p = strchr(s,'\n')) != NULL) *p = '\0'; | |
440 | if ((p = strchr(s,'\r')) != NULL) *p = '\0'; | |
441 | ||
442 | /* | |
443 | printf("%6lo %s %8ld %s %s\n", st->st_mode, mkmodestr(st->st_mode, str), | |
444 | st->st_size, s, name); | |
445 | */ | |
446 | ||
447 | printf(" %s %8ld %s %s", mkmodestr(st->st_mode,str), st->st_size, s, name); | |
448 | } | |
449 | ||
450 | static inline int | |
451 | dump_inode(struct b_lists *pL, struct b_dirent *d, struct b_inode *i) | |
452 | { | |
453 | char fname[JFFS2_MAX_NAME_LEN + 1]; | |
454 | struct stat st; | |
455 | size_t len; | |
456 | ||
457 | if(!d || !i) return -1; | |
458 | len = d->nsize; | |
459 | nand_read(nand, d->offset + sizeof(struct jffs2_raw_dirent), | |
460 | &len, &fname); | |
461 | fname[d->nsize] = '\0'; | |
462 | ||
463 | memset(&st, 0, sizeof(st)); | |
464 | ||
465 | jffs2_1pass_read_inode(pL, i->ino, NULL, &st); | |
466 | ||
467 | dump_stat(&st, fname); | |
468 | /* FIXME | |
469 | if (d->type == DT_LNK) { | |
470 | unsigned char *src = (unsigned char *) (&i[1]); | |
471 | putstr(" -> "); | |
472 | putnstr(src, (int)i->dsize); | |
473 | } | |
474 | */ | |
475 | putstr("\r\n"); | |
476 | ||
477 | return 0; | |
478 | } | |
479 | ||
480 | /* list inodes with the given pino */ | |
481 | static u32 | |
482 | jffs2_1pass_list_inodes(struct b_lists * pL, u32 pino) | |
483 | { | |
484 | struct b_dirent *jDir; | |
485 | u32 i_version = 0; | |
486 | ||
487 | for (jDir = (struct b_dirent *)pL->dir.listHead; jDir; jDir = jDir->next) { | |
488 | if ((pino == jDir->pino) && (jDir->ino)) { /* ino=0 -> unlink */ | |
489 | struct b_inode *jNode = (struct b_inode *)pL->frag.listHead; | |
490 | struct b_inode *i = NULL; | |
491 | ||
492 | while (jNode) { | |
493 | if (jNode->ino == jDir->ino && jNode->version >= i_version) { | |
494 | i_version = jNode->version; | |
495 | i = jNode; | |
496 | } | |
497 | jNode = jNode->next; | |
498 | } | |
499 | dump_inode(pL, jDir, i); | |
500 | } | |
501 | } | |
502 | return pino; | |
503 | } | |
504 | ||
505 | static u32 | |
506 | jffs2_1pass_search_inode(struct b_lists * pL, const char *fname, u32 pino) | |
507 | { | |
508 | int i; | |
509 | char tmp[256]; | |
510 | char working_tmp[256]; | |
511 | char *c; | |
512 | ||
513 | /* discard any leading slash */ | |
514 | i = 0; | |
515 | while (fname[i] == '/') | |
516 | i++; | |
517 | strcpy(tmp, &fname[i]); | |
518 | ||
519 | while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ | |
520 | { | |
521 | strncpy(working_tmp, tmp, c - tmp); | |
522 | working_tmp[c - tmp] = '\0'; | |
523 | #if 0 | |
524 | putstr("search_inode: tmp = "); | |
525 | putstr(tmp); | |
526 | putstr("\r\n"); | |
527 | putstr("search_inode: wtmp = "); | |
528 | putstr(working_tmp); | |
529 | putstr("\r\n"); | |
530 | putstr("search_inode: c = "); | |
531 | putstr(c); | |
532 | putstr("\r\n"); | |
533 | #endif | |
534 | for (i = 0; i < strlen(c) - 1; i++) | |
535 | tmp[i] = c[i + 1]; | |
536 | tmp[i] = '\0'; | |
537 | #if 0 | |
538 | putstr("search_inode: post tmp = "); | |
539 | putstr(tmp); | |
540 | putstr("\r\n"); | |
541 | #endif | |
542 | ||
543 | if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino))) { | |
544 | putstr("find_inode failed for name="); | |
545 | putstr(working_tmp); | |
546 | putstr("\r\n"); | |
547 | return 0; | |
548 | } | |
549 | } | |
550 | /* this is for the bare filename, directories have already been mapped */ | |
551 | if (!(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { | |
552 | putstr("find_inode failed for name="); | |
553 | putstr(tmp); | |
554 | putstr("\r\n"); | |
555 | return 0; | |
556 | } | |
557 | return pino; | |
558 | ||
559 | } | |
560 | ||
561 | static u32 | |
562 | jffs2_1pass_resolve_inode(struct b_lists * pL, u32 ino) | |
563 | { | |
564 | struct b_dirent *jDir; | |
565 | struct b_inode *jNode; | |
566 | u8 jDirFoundType = 0; | |
567 | u32 jDirFoundIno = 0; | |
568 | u32 jDirFoundPino = 0; | |
569 | char tmp[JFFS2_MAX_NAME_LEN + 1]; | |
570 | u32 version = 0; | |
571 | u32 pino; | |
572 | ||
573 | /* we need to search all and return the inode with the highest version */ | |
574 | for (jDir = (struct b_dirent *)pL->dir.listHead; jDir; jDir = jDir->next) { | |
575 | if (ino == jDir->ino) { | |
ac7eb8a3 | 576 | if (jDir->version < version) |
932394ac WD |
577 | continue; |
578 | ||
579 | if (jDir->version == version && jDirFoundType) { | |
ac7eb8a3 | 580 | /* I'm pretty sure this isn't legal */ |
932394ac | 581 | putstr(" ** ERROR ** "); |
ac7eb8a3 WD |
582 | /* putnstr(jDir->name, jDir->nsize); */ |
583 | /* putLabeledWord(" has dup version (resolve) = ", */ | |
584 | /* version); */ | |
932394ac WD |
585 | } |
586 | ||
587 | jDirFoundType = jDir->type; | |
588 | jDirFoundIno = jDir->ino; | |
589 | jDirFoundPino = jDir->pino; | |
590 | version = jDir->version; | |
591 | } | |
592 | } | |
593 | /* now we found the right entry again. (shoulda returned inode*) */ | |
594 | if (jDirFoundType != DT_LNK) | |
595 | return jDirFoundIno; | |
596 | ||
597 | /* it's a soft link so we follow it again. */ | |
598 | for (jNode = (struct b_inode *)pL->frag.listHead; jNode; jNode = jNode->next) { | |
599 | if (jNode->ino == jDirFoundIno) { | |
600 | size_t len = jNode->csize; | |
601 | nand_read(nand, jNode->offset + sizeof(struct jffs2_raw_inode), &len, &tmp); | |
602 | tmp[jNode->csize] = '\0'; | |
603 | break; | |
604 | } | |
605 | } | |
606 | /* ok so the name of the new file to find is in tmp */ | |
607 | /* if it starts with a slash it is root based else shared dirs */ | |
608 | if (tmp[0] == '/') | |
609 | pino = 1; | |
610 | else | |
611 | pino = jDirFoundPino; | |
612 | ||
613 | return jffs2_1pass_search_inode(pL, tmp, pino); | |
614 | } | |
615 | ||
616 | static u32 | |
617 | jffs2_1pass_search_list_inodes(struct b_lists * pL, const char *fname, u32 pino) | |
618 | { | |
619 | int i; | |
620 | char tmp[256]; | |
621 | char working_tmp[256]; | |
622 | char *c; | |
623 | ||
624 | /* discard any leading slash */ | |
625 | i = 0; | |
626 | while (fname[i] == '/') | |
627 | i++; | |
628 | strcpy(tmp, &fname[i]); | |
629 | working_tmp[0] = '\0'; | |
630 | while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ | |
631 | { | |
632 | strncpy(working_tmp, tmp, c - tmp); | |
633 | working_tmp[c - tmp] = '\0'; | |
634 | for (i = 0; i < strlen(c) - 1; i++) | |
635 | tmp[i] = c[i + 1]; | |
636 | tmp[i] = '\0'; | |
637 | /* only a failure if we arent looking at top level */ | |
638 | if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino)) && | |
639 | (working_tmp[0])) { | |
640 | putstr("find_inode failed for name="); | |
641 | putstr(working_tmp); | |
642 | putstr("\r\n"); | |
643 | return 0; | |
644 | } | |
645 | } | |
646 | ||
647 | if (tmp[0] && !(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { | |
648 | putstr("find_inode failed for name="); | |
649 | putstr(tmp); | |
650 | putstr("\r\n"); | |
651 | return 0; | |
652 | } | |
653 | /* this is for the bare filename, directories have already been mapped */ | |
654 | if (!(pino = jffs2_1pass_list_inodes(pL, pino))) { | |
655 | putstr("find_inode failed for name="); | |
656 | putstr(tmp); | |
657 | putstr("\r\n"); | |
658 | return 0; | |
659 | } | |
660 | return pino; | |
661 | ||
662 | } | |
663 | ||
664 | unsigned char | |
665 | jffs2_1pass_rescan_needed(struct part_info *part) | |
666 | { | |
667 | struct b_node *b; | |
668 | struct jffs2_unknown_node onode; | |
669 | struct jffs2_unknown_node *node; | |
670 | struct b_lists *pL = (struct b_lists *)part->jffs2_priv; | |
671 | ||
672 | if (part->jffs2_priv == 0){ | |
673 | DEBUGF ("rescan: First time in use\n"); | |
674 | return 1; | |
675 | } | |
676 | /* if we have no list, we need to rescan */ | |
677 | if (pL->frag.listCount == 0) { | |
678 | DEBUGF ("rescan: fraglist zero\n"); | |
679 | return 1; | |
680 | } | |
681 | ||
682 | /* or if we are scanning a new partition */ | |
683 | if (pL->partOffset != part->offset) { | |
684 | DEBUGF ("rescan: different partition\n"); | |
685 | return 1; | |
686 | } | |
687 | ||
932394ac WD |
688 | /* FIXME */ |
689 | #if 0 | |
690 | /* but suppose someone reflashed a partition at the same offset... */ | |
691 | b = pL->dir.listHead; | |
692 | while (b) { | |
693 | node = (struct jffs2_unknown_node *) get_fl_mem(b->offset, | |
694 | sizeof(onode), &onode); | |
695 | if (node->nodetype != JFFS2_NODETYPE_DIRENT) { | |
696 | DEBUGF ("rescan: fs changed beneath me? (%lx)\n", | |
697 | (unsigned long) b->offset); | |
698 | return 1; | |
699 | } | |
700 | b = b->next; | |
701 | } | |
702 | #endif | |
703 | return 0; | |
704 | } | |
705 | ||
706 | #ifdef DEBUG_FRAGMENTS | |
707 | static void | |
708 | dump_fragments(struct b_lists *pL) | |
709 | { | |
710 | struct b_node *b; | |
711 | struct jffs2_raw_inode ojNode; | |
712 | struct jffs2_raw_inode *jNode; | |
713 | ||
714 | putstr("\r\n\r\n******The fragment Entries******\r\n"); | |
715 | b = pL->frag.listHead; | |
716 | while (b) { | |
717 | jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, | |
718 | sizeof(ojNode), &ojNode); | |
719 | putLabeledWord("\r\n\tbuild_list: FLASH_OFFSET = ", b->offset); | |
720 | putLabeledWord("\tbuild_list: totlen = ", jNode->totlen); | |
721 | putLabeledWord("\tbuild_list: inode = ", jNode->ino); | |
722 | putLabeledWord("\tbuild_list: version = ", jNode->version); | |
723 | putLabeledWord("\tbuild_list: isize = ", jNode->isize); | |
724 | putLabeledWord("\tbuild_list: atime = ", jNode->atime); | |
725 | putLabeledWord("\tbuild_list: offset = ", jNode->offset); | |
726 | putLabeledWord("\tbuild_list: csize = ", jNode->csize); | |
727 | putLabeledWord("\tbuild_list: dsize = ", jNode->dsize); | |
728 | putLabeledWord("\tbuild_list: compr = ", jNode->compr); | |
729 | putLabeledWord("\tbuild_list: usercompr = ", jNode->usercompr); | |
730 | putLabeledWord("\tbuild_list: flags = ", jNode->flags); | |
731 | putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ | |
732 | b = b->next; | |
733 | } | |
734 | } | |
735 | #endif | |
736 | ||
737 | #ifdef DEBUG_DIRENTS | |
738 | static void | |
739 | dump_dirents(struct b_lists *pL) | |
740 | { | |
741 | struct b_node *b; | |
742 | struct jffs2_raw_dirent *jDir; | |
743 | ||
744 | putstr("\r\n\r\n******The directory Entries******\r\n"); | |
745 | b = pL->dir.listHead; | |
746 | while (b) { | |
747 | jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); | |
748 | putstr("\r\n"); | |
749 | putnstr(jDir->name, jDir->nsize); | |
750 | putLabeledWord("\r\n\tbuild_list: magic = ", jDir->magic); | |
751 | putLabeledWord("\tbuild_list: nodetype = ", jDir->nodetype); | |
752 | putLabeledWord("\tbuild_list: hdr_crc = ", jDir->hdr_crc); | |
753 | putLabeledWord("\tbuild_list: pino = ", jDir->pino); | |
754 | putLabeledWord("\tbuild_list: version = ", jDir->version); | |
755 | putLabeledWord("\tbuild_list: ino = ", jDir->ino); | |
756 | putLabeledWord("\tbuild_list: mctime = ", jDir->mctime); | |
757 | putLabeledWord("\tbuild_list: nsize = ", jDir->nsize); | |
758 | putLabeledWord("\tbuild_list: type = ", jDir->type); | |
759 | putLabeledWord("\tbuild_list: node_crc = ", jDir->node_crc); | |
760 | putLabeledWord("\tbuild_list: name_crc = ", jDir->name_crc); | |
761 | putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ | |
762 | b = b->next; | |
763 | put_fl_mem(jDir); | |
764 | } | |
765 | } | |
766 | #endif | |
767 | ||
768 | static int | |
769 | jffs2_fill_scan_buf(nand_info_t *nand, unsigned char *buf, | |
770 | unsigned ofs, unsigned len) | |
771 | { | |
772 | int ret; | |
773 | unsigned olen; | |
774 | ||
775 | olen = len; | |
776 | ret = nand_read(nand, ofs, &olen, buf); | |
777 | if (ret) { | |
778 | printf("nand_read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret); | |
779 | return ret; | |
780 | } | |
781 | if (olen < len) { | |
782 | printf("Read at 0x%x gave only 0x%x bytes\n", ofs, olen); | |
783 | return -1; | |
784 | } | |
785 | return 0; | |
786 | } | |
787 | ||
788 | #define EMPTY_SCAN_SIZE 1024 | |
789 | static u32 | |
790 | jffs2_1pass_build_lists(struct part_info * part) | |
791 | { | |
792 | struct b_lists *pL; | |
793 | struct jffs2_unknown_node *node; | |
794 | unsigned nr_blocks, sectorsize, ofs, offset; | |
795 | char *buf; | |
796 | int i; | |
797 | u32 counter = 0; | |
798 | u32 counter4 = 0; | |
799 | u32 counterF = 0; | |
800 | u32 counterN = 0; | |
801 | ||
ac7eb8a3 WD |
802 | struct mtdids *id = part->dev->id; |
803 | nand = nand_info + id->num; | |
932394ac WD |
804 | |
805 | /* if we are building a list we need to refresh the cache. */ | |
806 | jffs_init_1pass_list(part); | |
807 | pL = (struct b_lists *)part->jffs2_priv; | |
808 | pL->partOffset = part->offset; | |
809 | puts ("Scanning JFFS2 FS: "); | |
810 | ||
811 | sectorsize = nand->erasesize; | |
812 | nr_blocks = part->size / sectorsize; | |
813 | buf = malloc(sectorsize); | |
814 | if (!buf) | |
815 | return 0; | |
816 | ||
817 | for (i = 0; i < nr_blocks; i++) { | |
818 | printf("\b\b%c ", spinner[counter++ % sizeof(spinner)]); | |
819 | ||
820 | offset = part->offset + i * sectorsize; | |
821 | ||
822 | if (nand_block_isbad(nand, offset)) | |
823 | continue; | |
824 | ||
825 | if (jffs2_fill_scan_buf(nand, buf, offset, EMPTY_SCAN_SIZE)) | |
826 | return 0; | |
827 | ||
828 | ofs = 0; | |
829 | /* Scan only 4KiB of 0xFF before declaring it's empty */ | |
830 | while (ofs < EMPTY_SCAN_SIZE && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF) | |
831 | ofs += 4; | |
832 | if (ofs == EMPTY_SCAN_SIZE) | |
833 | continue; | |
834 | ||
835 | if (jffs2_fill_scan_buf(nand, buf + EMPTY_SCAN_SIZE, offset + EMPTY_SCAN_SIZE, sectorsize - EMPTY_SCAN_SIZE)) | |
836 | return 0; | |
837 | offset += ofs; | |
838 | ||
839 | while (ofs < sectorsize - sizeof(struct jffs2_unknown_node)) { | |
840 | node = (struct jffs2_unknown_node *)&buf[ofs]; | |
841 | if (node->magic != JFFS2_MAGIC_BITMASK || !hdr_crc(node)) { | |
842 | offset += 4; | |
843 | ofs += 4; | |
844 | counter4++; | |
845 | continue; | |
846 | } | |
847 | /* if its a fragment add it */ | |
848 | if (node->nodetype == JFFS2_NODETYPE_INODE && | |
849 | inode_crc((struct jffs2_raw_inode *) node)) { | |
850 | if (insert_inode(&pL->frag, (struct jffs2_raw_inode *) node, | |
851 | offset) == NULL) { | |
852 | return 0; | |
853 | } | |
854 | } else if (node->nodetype == JFFS2_NODETYPE_DIRENT && | |
855 | dirent_crc((struct jffs2_raw_dirent *) node) && | |
856 | dirent_name_crc((struct jffs2_raw_dirent *) node)) { | |
857 | if (! (counterN%100)) | |
858 | puts ("\b\b. "); | |
859 | if (insert_dirent(&pL->dir, (struct jffs2_raw_dirent *) node, | |
860 | offset) == NULL) { | |
861 | return 0; | |
862 | } | |
863 | counterN++; | |
864 | } else if (node->nodetype == JFFS2_NODETYPE_CLEANMARKER) { | |
865 | if (node->totlen != sizeof(struct jffs2_unknown_node)) | |
866 | printf("OOPS Cleanmarker has bad size " | |
867 | "%d != %d\n", node->totlen, | |
868 | sizeof(struct jffs2_unknown_node)); | |
869 | } else if (node->nodetype == JFFS2_NODETYPE_PADDING) { | |
870 | if (node->totlen < sizeof(struct jffs2_unknown_node)) | |
871 | printf("OOPS Padding has bad size " | |
872 | "%d < %d\n", node->totlen, | |
873 | sizeof(struct jffs2_unknown_node)); | |
874 | } else { | |
875 | printf("Unknown node type: %x len %d " | |
876 | "offset 0x%x\n", node->nodetype, | |
877 | node->totlen, offset); | |
878 | } | |
879 | offset += ((node->totlen + 3) & ~3); | |
880 | ofs += ((node->totlen + 3) & ~3); | |
881 | counterF++; | |
882 | } | |
883 | } | |
884 | ||
885 | putstr("\b\b done.\r\n"); /* close off the dots */ | |
886 | ||
887 | #if 0 | |
888 | putLabeledWord("dir entries = ", pL->dir.listCount); | |
889 | putLabeledWord("frag entries = ", pL->frag.listCount); | |
890 | putLabeledWord("+4 increments = ", counter4); | |
891 | putLabeledWord("+file_offset increments = ", counterF); | |
892 | #endif | |
893 | ||
894 | #ifdef DEBUG_DIRENTS | |
895 | dump_dirents(pL); | |
896 | #endif | |
897 | ||
898 | #ifdef DEBUG_FRAGMENTS | |
899 | dump_fragments(pL); | |
900 | #endif | |
901 | ||
902 | /* give visual feedback that we are done scanning the flash */ | |
903 | led_blink(0x0, 0x0, 0x1, 0x1); /* off, forever, on 100ms, off 100ms */ | |
904 | free(buf); | |
905 | ||
906 | return 1; | |
907 | } | |
908 | ||
909 | ||
910 | static u32 | |
911 | jffs2_1pass_fill_info(struct b_lists * pL, struct b_jffs2_info * piL) | |
912 | { | |
913 | struct b_node *b; | |
914 | struct jffs2_raw_inode ojNode; | |
915 | struct jffs2_raw_inode *jNode; | |
916 | int i; | |
917 | ||
918 | for (i = 0; i < JFFS2_NUM_COMPR; i++) { | |
919 | piL->compr_info[i].num_frags = 0; | |
920 | piL->compr_info[i].compr_sum = 0; | |
921 | piL->compr_info[i].decompr_sum = 0; | |
922 | } | |
923 | /* FIXME | |
924 | b = pL->frag.listHead; | |
925 | while (b) { | |
926 | jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, | |
927 | sizeof(ojNode), &ojNode); | |
928 | if (jNode->compr < JFFS2_NUM_COMPR) { | |
929 | piL->compr_info[jNode->compr].num_frags++; | |
930 | piL->compr_info[jNode->compr].compr_sum += jNode->csize; | |
931 | piL->compr_info[jNode->compr].decompr_sum += jNode->dsize; | |
932 | } | |
933 | b = b->next; | |
934 | } | |
935 | */ | |
936 | return 0; | |
937 | } | |
938 | ||
939 | ||
940 | static struct b_lists * | |
941 | jffs2_get_list(struct part_info * part, const char *who) | |
942 | { | |
943 | if (jffs2_1pass_rescan_needed(part)) { | |
944 | if (!jffs2_1pass_build_lists(part)) { | |
945 | printf("%s: Failed to scan JFFSv2 file structure\n", who); | |
946 | return NULL; | |
947 | } | |
948 | } | |
949 | return (struct b_lists *)part->jffs2_priv; | |
950 | } | |
951 | ||
952 | ||
953 | /* Print directory / file contents */ | |
954 | u32 | |
955 | jffs2_1pass_ls(struct part_info * part, const char *fname) | |
956 | { | |
957 | struct b_lists *pl; | |
958 | long ret = 0; | |
959 | u32 inode; | |
960 | ||
961 | if (! (pl = jffs2_get_list(part, "ls"))) | |
962 | return 0; | |
963 | ||
964 | if (! (inode = jffs2_1pass_search_list_inodes(pl, fname, 1))) { | |
965 | putstr("ls: Failed to scan jffs2 file structure\r\n"); | |
966 | return 0; | |
967 | } | |
968 | ||
969 | #if 0 | |
970 | putLabeledWord("found file at inode = ", inode); | |
971 | putLabeledWord("read_inode returns = ", ret); | |
972 | #endif | |
973 | ||
974 | return ret; | |
975 | } | |
976 | ||
977 | ||
978 | /* Load a file from flash into memory. fname can be a full path */ | |
979 | u32 | |
980 | jffs2_1pass_load(char *dest, struct part_info * part, const char *fname) | |
981 | { | |
982 | ||
983 | struct b_lists *pl; | |
984 | long ret = 0; | |
985 | u32 inode; | |
986 | ||
ac7eb8a3 | 987 | if (! (pl = jffs2_get_list(part, "load"))) |
932394ac WD |
988 | return 0; |
989 | ||
990 | if (! (inode = jffs2_1pass_search_inode(pl, fname, 1))) { | |
991 | putstr("load: Failed to find inode\r\n"); | |
992 | return 0; | |
993 | } | |
994 | ||
995 | /* Resolve symlinks */ | |
996 | if (! (inode = jffs2_1pass_resolve_inode(pl, inode))) { | |
997 | putstr("load: Failed to resolve inode structure\r\n"); | |
998 | return 0; | |
999 | } | |
1000 | ||
1001 | if ((ret = jffs2_1pass_read_inode(pl, inode, dest, NULL)) < 0) { | |
1002 | putstr("load: Failed to read inode\r\n"); | |
1003 | return 0; | |
1004 | } | |
1005 | ||
1006 | DEBUGF ("load: loaded '%s' to 0x%lx (%ld bytes)\n", fname, | |
1007 | (unsigned long) dest, ret); | |
1008 | return ret; | |
1009 | } | |
1010 | ||
1011 | /* Return information about the fs on this partition */ | |
1012 | u32 | |
1013 | jffs2_1pass_info(struct part_info * part) | |
1014 | { | |
1015 | struct b_jffs2_info info; | |
1016 | struct b_lists *pl; | |
1017 | int i; | |
1018 | ||
ac7eb8a3 | 1019 | if (! (pl = jffs2_get_list(part, "info"))) |
932394ac WD |
1020 | return 0; |
1021 | ||
1022 | jffs2_1pass_fill_info(pl, &info); | |
1023 | for (i = 0; i < JFFS2_NUM_COMPR; i++) { | |
1024 | printf ("Compression: %s\n" | |
1025 | "\tfrag count: %d\n" | |
1026 | "\tcompressed sum: %d\n" | |
1027 | "\tuncompressed sum: %d\n", | |
1028 | compr_names[i], | |
1029 | info.compr_info[i].num_frags, | |
1030 | info.compr_info[i].compr_sum, | |
1031 | info.compr_info[i].decompr_sum); | |
1032 | } | |
1033 | return 1; | |
1034 | } | |
1035 | ||
1036 | #endif /* CFG_CMD_JFFS2 */ |