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