projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] fs/jffs/intrep.c: 255 is unsigned char
[deliverable/linux.git] / fs / jffs / intrep.c
1 /*
2 * JFFS -- Journaling Flash File System, Linux implementation.
3 *
4 * Copyright (C) 1999, 2000 Axis Communications, Inc.
5 *
6 * Created by Finn Hakansson <finn@axis.com>.
7 *
8 * This is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * $Id: intrep.c,v 1.102 2001/09/23 23:28:36 dwmw2 Exp $
14 *
15 * Ported to Linux 2.3.x and MTD:
16 * Copyright (C) 2000 Alexander Larsson (alex@cendio.se), Cendio Systems AB
17 *
18 */
19
20 /* This file contains the code for the internal structure of the
21 Journaling Flash File System, JFFS. */
22
23 /*
24 * Todo list:
25 *
26 * memcpy_to_flash() and memcpy_from_flash() functions.
27 *
28 * Implementation of hard links.
29 *
30 * Organize the source code in a better way. Against the VFS we could
31 * have jffs_ext.c, and against the block device jffs_int.c.
32 * A better file-internal organization too.
33 *
34 * A better checksum algorithm.
35 *
36 * Consider endianness stuff. ntohl() etc.
37 *
38 * Are we handling the atime, mtime, ctime members of the inode right?
39 *
40 * Remove some duplicated code. Take a look at jffs_write_node() and
41 * jffs_rewrite_data() for instance.
42 *
43 * Implement more meaning of the nlink member in various data structures.
44 * nlink could be used in conjunction with hard links for instance.
45 *
46 * Better memory management. Allocate data structures in larger chunks
47 * if possible.
48 *
49 * If too much meta data is stored, a garbage collect should be issued.
50 * We have experienced problems with too much meta data with for instance
51 * log files.
52 *
53 * Improve the calls to jffs_ioctl(). We would like to retrieve more
54 * information to be able to debug (or to supervise) JFFS during run-time.
55 *
56 */
57
58 #include <linux/config.h>
59 #include <linux/types.h>
60 #include <linux/slab.h>
61 #include <linux/jffs.h>
62 #include <linux/fs.h>
63 #include <linux/stat.h>
64 #include <linux/pagemap.h>
65 #include <asm/semaphore.h>
66 #include <asm/byteorder.h>
67 #include <linux/smp_lock.h>
68 #include <linux/time.h>
69 #include <linux/ctype.h>
70
71 #include "intrep.h"
72 #include "jffs_fm.h"
73
74 long no_jffs_node = 0;
75 static long no_jffs_file = 0;
76 #if defined(JFFS_MEMORY_DEBUG) && JFFS_MEMORY_DEBUG
77 long no_jffs_control = 0;
78 long no_jffs_raw_inode = 0;
79 long no_jffs_node_ref = 0;
80 long no_jffs_fm = 0;
81 long no_jffs_fmcontrol = 0;
82 long no_hash = 0;
83 long no_name = 0;
84 #endif
85
86 static int jffs_scan_flash(struct jffs_control *c);
87 static int jffs_update_file(struct jffs_file *f, struct jffs_node *node);
88 static int jffs_build_file(struct jffs_file *f);
89 static int jffs_free_file(struct jffs_file *f);
90 static int jffs_free_node_list(struct jffs_file *f);
91 static int jffs_garbage_collect_now(struct jffs_control *c);
92 static int jffs_insert_file_into_hash(struct jffs_file *f);
93 static int jffs_remove_redundant_nodes(struct jffs_file *f);
94
95 /* Is there enough space on the flash? */
96 static inline int JFFS_ENOUGH_SPACE(struct jffs_control *c, __u32 space)
97 {
98 struct jffs_fmcontrol *fmc = c->fmc;
99
100 while (1) {
101 if ((fmc->flash_size - (fmc->used_size + fmc->dirty_size))
102 >= fmc->min_free_size + space) {
103 return 1;
104 }
105 if (fmc->dirty_size < fmc->sector_size)
106 return 0;
107
108 if (jffs_garbage_collect_now(c)) {
109 D1(printk("JFFS_ENOUGH_SPACE: jffs_garbage_collect_now() failed.\n"));
110 return 0;
111 }
112 }
113 }
114
115 #if CONFIG_JFFS_FS_VERBOSE > 0
116 static __u8
117 flash_read_u8(struct mtd_info *mtd, loff_t from)
118 {
119 size_t retlen;
120 __u8 ret;
121 int res;
122
123 res = MTD_READ(mtd, from, 1, &retlen, &ret);
124 if (retlen != 1) {
125 printk("Didn't read a byte in flash_read_u8(). Returned %d\n", res);
126 return 0;
127 }
128
129 return ret;
130 }
131
132 static void
133 jffs_hexdump(struct mtd_info *mtd, loff_t pos, int size)
134 {
135 char line[16];
136 int j = 0;
137
138 while (size > 0) {
139 int i;
140
141 printk("%ld:", (long) pos);
142 for (j = 0; j < 16; j++) {
143 line[j] = flash_read_u8(mtd, pos++);
144 }
145 for (i = 0; i < j; i++) {
146 if (!(i & 1)) {
147 printk(" %.2x", line[i] & 0xff);
148 }
149 else {
150 printk("%.2x", line[i] & 0xff);
151 }
152 }
153
154 /* Print empty space */
155 for (; i < 16; i++) {
156 if (!(i & 1)) {
157 printk(" ");
158 }
159 else {
160 printk(" ");
161 }
162 }
163 printk(" ");
164
165 for (i = 0; i < j; i++) {
166 if (isgraph(line[i])) {
167 printk("%c", line[i]);
168 }
169 else {
170 printk(".");
171 }
172 }
173 printk("\n");
174 size -= 16;
175 }
176 }
177
178 /* Print the contents of a node. */
179 static void
180 jffs_print_node(struct jffs_node *n)
181 {
182 D(printk("jffs_node: 0x%p\n", n));
183 D(printk("{\n"));
184 D(printk(" 0x%08x, /* version */\n", n->version));
185 D(printk(" 0x%08x, /* data_offset */\n", n->data_offset));
186 D(printk(" 0x%08x, /* data_size */\n", n->data_size));
187 D(printk(" 0x%08x, /* removed_size */\n", n->removed_size));
188 D(printk(" 0x%08x, /* fm_offset */\n", n->fm_offset));
189 D(printk(" 0x%02x, /* name_size */\n", n->name_size));
190 D(printk(" 0x%p, /* fm, fm->offset: %u */\n",
191 n->fm, (n->fm ? n->fm->offset : 0)));
192 D(printk(" 0x%p, /* version_prev */\n", n->version_prev));
193 D(printk(" 0x%p, /* version_next */\n", n->version_next));
194 D(printk(" 0x%p, /* range_prev */\n", n->range_prev));
195 D(printk(" 0x%p, /* range_next */\n", n->range_next));
196 D(printk("}\n"));
197 }
198
199 #endif
200
201 /* Print the contents of a raw inode. */
202 static void
203 jffs_print_raw_inode(struct jffs_raw_inode *raw_inode)
204 {
205 D(printk("jffs_raw_inode: inode number: %u\n", raw_inode->ino));
206 D(printk("{\n"));
207 D(printk(" 0x%08x, /* magic */\n", raw_inode->magic));
208 D(printk(" 0x%08x, /* ino */\n", raw_inode->ino));
209 D(printk(" 0x%08x, /* pino */\n", raw_inode->pino));
210 D(printk(" 0x%08x, /* version */\n", raw_inode->version));
211 D(printk(" 0x%08x, /* mode */\n", raw_inode->mode));
212 D(printk(" 0x%04x, /* uid */\n", raw_inode->uid));
213 D(printk(" 0x%04x, /* gid */\n", raw_inode->gid));
214 D(printk(" 0x%08x, /* atime */\n", raw_inode->atime));
215 D(printk(" 0x%08x, /* mtime */\n", raw_inode->mtime));
216 D(printk(" 0x%08x, /* ctime */\n", raw_inode->ctime));
217 D(printk(" 0x%08x, /* offset */\n", raw_inode->offset));
218 D(printk(" 0x%08x, /* dsize */\n", raw_inode->dsize));
219 D(printk(" 0x%08x, /* rsize */\n", raw_inode->rsize));
220 D(printk(" 0x%02x, /* nsize */\n", raw_inode->nsize));
221 D(printk(" 0x%02x, /* nlink */\n", raw_inode->nlink));
222 D(printk(" 0x%02x, /* spare */\n",
223 raw_inode->spare));
224 D(printk(" %u, /* rename */\n",
225 raw_inode->rename));
226 D(printk(" %u, /* deleted */\n",
227 raw_inode->deleted));
228 D(printk(" 0x%02x, /* accurate */\n",
229 raw_inode->accurate));
230 D(printk(" 0x%08x, /* dchksum */\n", raw_inode->dchksum));
231 D(printk(" 0x%04x, /* nchksum */\n", raw_inode->nchksum));
232 D(printk(" 0x%04x, /* chksum */\n", raw_inode->chksum));
233 D(printk("}\n"));
234 }
235
236 #define flash_safe_acquire(arg)
237 #define flash_safe_release(arg)
238
239
240 static int
241 flash_safe_read(struct mtd_info *mtd, loff_t from,
242 u_char *buf, size_t count)
243 {
244 size_t retlen;
245 int res;
246
247 D3(printk(KERN_NOTICE "flash_safe_read(%p, %08x, %p, %08x)\n",
248 mtd, (unsigned int) from, buf, count));
249
250 res = MTD_READ(mtd, from, count, &retlen, buf);
251 if (retlen != count) {
252 panic("Didn't read all bytes in flash_safe_read(). Returned %d\n", res);
253 }
254 return res?res:retlen;
255 }
256
257
258 static __u32
259 flash_read_u32(struct mtd_info *mtd, loff_t from)
260 {
261 size_t retlen;
262 __u32 ret;
263 int res;
264
265 res = MTD_READ(mtd, from, 4, &retlen, (unsigned char *)&ret);
266 if (retlen != 4) {
267 printk("Didn't read all bytes in flash_read_u32(). Returned %d\n", res);
268 return 0;
269 }
270
271 return ret;
272 }
273
274
275 static int
276 flash_safe_write(struct mtd_info *mtd, loff_t to,
277 const u_char *buf, size_t count)
278 {
279 size_t retlen;
280 int res;
281
282 D3(printk(KERN_NOTICE "flash_safe_write(%p, %08x, %p, %08x)\n",
283 mtd, (unsigned int) to, buf, count));
284
285 res = MTD_WRITE(mtd, to, count, &retlen, buf);
286 if (retlen != count) {
287 printk("Didn't write all bytes in flash_safe_write(). Returned %d\n", res);
288 }
289 return res?res:retlen;
290 }
291
292
293 static int
294 flash_safe_writev(struct mtd_info *mtd, const struct kvec *vecs,
295 unsigned long iovec_cnt, loff_t to)
296 {
297 size_t retlen, retlen_a;
298 int i;
299 int res;
300
301 D3(printk(KERN_NOTICE "flash_safe_writev(%p, %08x, %p)\n",
302 mtd, (unsigned int) to, vecs));
303
304 if (mtd->writev) {
305 res = MTD_WRITEV(mtd, vecs, iovec_cnt, to, &retlen);
306 return res ? res : retlen;
307 }
308 /* Not implemented writev. Repeatedly use write - on the not so
309 unreasonable assumption that the mtd driver doesn't care how
310 many write cycles we use. */
311 res=0;
312 retlen=0;
313
314 for (i=0; !res && i<iovec_cnt; i++) {
315 res = MTD_WRITE(mtd, to, vecs[i].iov_len, &retlen_a, vecs[i].iov_base);
316 if (retlen_a != vecs[i].iov_len) {
317 printk("Didn't write all bytes in flash_safe_writev(). Returned %d\n", res);
318 if (i != iovec_cnt-1)
319 return -EIO;
320 }
321 /* If res is non-zero, retlen_a is undefined, but we don't
322 care because in that case it's not going to be
323 returned anyway.
324 */
325 to += retlen_a;
326 retlen += retlen_a;
327 }
328 return res?res:retlen;
329 }
330
331
332 static int
333 flash_memset(struct mtd_info *mtd, loff_t to,
334 const u_char c, size_t size)
335 {
336 static unsigned char pattern[64];
337 int i;
338
339 /* fill up pattern */
340
341 for(i = 0; i < 64; i++)
342 pattern[i] = c;
343
344 /* write as many 64-byte chunks as we can */
345
346 while (size >= 64) {
347 flash_safe_write(mtd, to, pattern, 64);
348 size -= 64;
349 to += 64;
350 }
351
352 /* and the rest */
353
354 if(size)
355 flash_safe_write(mtd, to, pattern, size);
356
357 return size;
358 }
359
360
361 static void
362 intrep_erase_callback(struct erase_info *done)
363 {
364 wait_queue_head_t *wait_q;
365
366 wait_q = (wait_queue_head_t *)done->priv;
367
368 wake_up(wait_q);
369 }
370
371
372 static int
373 flash_erase_region(struct mtd_info *mtd, loff_t start,
374 size_t size)
375 {
376 struct erase_info *erase;
377 DECLARE_WAITQUEUE(wait, current);
378 wait_queue_head_t wait_q;
379
380 erase = kmalloc(sizeof(struct erase_info), GFP_KERNEL);
381 if (!erase)
382 return -ENOMEM;
383
384 init_waitqueue_head(&wait_q);
385
386 erase->mtd = mtd;
387 erase->callback = intrep_erase_callback;
388 erase->addr = start;
389 erase->len = size;
390 erase->priv = (u_long)&wait_q;
391
392 /* FIXME: Use TASK_INTERRUPTIBLE and deal with being interrupted */
393 set_current_state(TASK_UNINTERRUPTIBLE);
394 add_wait_queue(&wait_q, &wait);
395
396 if (MTD_ERASE(mtd, erase) < 0) {
397 set_current_state(TASK_RUNNING);
398 remove_wait_queue(&wait_q, &wait);
399 kfree(erase);
400
401 printk(KERN_WARNING "flash: erase of region [0x%lx, 0x%lx] "
402 "totally failed\n", (long)start, (long)start + size);
403
404 return -1;
405 }
406
407 schedule(); /* Wait for flash to finish. */
408 remove_wait_queue(&wait_q, &wait);
409
410 kfree(erase);
411
412 return 0;
413 }
414
415 /* This routine calculates checksums in JFFS. */
416 static __u32
417 jffs_checksum(const void *data, int size)
418 {
419 __u32 sum = 0;
420 __u8 *ptr = (__u8 *)data;
421 while (size-- > 0) {
422 sum += *ptr++;
423 }
424 D3(printk(", result: 0x%08x\n", sum));
425 return sum;
426 }
427
428
429 static int
430 jffs_checksum_flash(struct mtd_info *mtd, loff_t start, int size, __u32 *result)
431 {
432 __u32 sum = 0;
433 loff_t ptr = start;
434 __u8 *read_buf;
435 int i, length;
436
437 /* Allocate read buffer */
438 read_buf = (__u8 *) kmalloc (sizeof(__u8) * 4096, GFP_KERNEL);
439 if (!read_buf) {
440 printk(KERN_NOTICE "kmalloc failed in jffs_checksum_flash()\n");
441 return -ENOMEM;
442 }
443 /* Loop until checksum done */
444 while (size) {
445 /* Get amount of data to read */
446 if (size < 4096)
447 length = size;
448 else
449 length = 4096;
450
451 /* Perform flash read */
452 D3(printk(KERN_NOTICE "jffs_checksum_flash\n"));
453 flash_safe_read(mtd, ptr, &read_buf[0], length);
454
455 /* Compute checksum */
456 for (i=0; i < length ; i++)
457 sum += read_buf[i];
458
459 /* Update pointer and size */
460 size -= length;
461 ptr += length;
462 }
463
464 /* Free read buffer */
465 kfree(read_buf);
466
467 /* Return result */
468 D3(printk("checksum result: 0x%08x\n", sum));
469 *result = sum;
470 return 0;
471 }
472
473 static __inline__ void jffs_fm_write_lock(struct jffs_fmcontrol *fmc)
474 {
475 // down(&fmc->wlock);
476 }
477
478 static __inline__ void jffs_fm_write_unlock(struct jffs_fmcontrol *fmc)
479 {
480 // up(&fmc->wlock);
481 }
482
483
484 /* Create and initialize a new struct jffs_file. */
485 static struct jffs_file *
486 jffs_create_file(struct jffs_control *c,
487 const struct jffs_raw_inode *raw_inode)
488 {
489 struct jffs_file *f;
490
491 if (!(f = (struct jffs_file *)kmalloc(sizeof(struct jffs_file),
492 GFP_KERNEL))) {
493 D(printk("jffs_create_file(): Failed!\n"));
494 return NULL;
495 }
496 no_jffs_file++;
497 memset(f, 0, sizeof(struct jffs_file));
498 f->ino = raw_inode->ino;
499 f->pino = raw_inode->pino;
500 f->nlink = raw_inode->nlink;
501 f->deleted = raw_inode->deleted;
502 f->c = c;
503
504 return f;
505 }
506
507
508 /* Build a control block for the file system. */
509 static struct jffs_control *
510 jffs_create_control(struct super_block *sb)
511 {
512 struct jffs_control *c;
513 register int s = sizeof(struct jffs_control);
514 int i;
515 D(char *t = 0);
516
517 D2(printk("jffs_create_control()\n"));
518
519 if (!(c = (struct jffs_control *)kmalloc(s, GFP_KERNEL))) {
520 goto fail_control;
521 }
522 DJM(no_jffs_control++);
523 c->root = NULL;
524 c->gc_task = NULL;
525 c->hash_len = JFFS_HASH_SIZE;
526 s = sizeof(struct list_head) * c->hash_len;
527 if (!(c->hash = (struct list_head *)kmalloc(s, GFP_KERNEL))) {
528 goto fail_hash;
529 }
530 DJM(no_hash++);
531 for (i = 0; i < c->hash_len; i++)
532 INIT_LIST_HEAD(&c->hash[i]);
533 if (!(c->fmc = jffs_build_begin(c, MINOR(sb->s_dev)))) {
534 goto fail_fminit;
535 }
536 c->next_ino = JFFS_MIN_INO + 1;
537 c->delete_list = (struct jffs_delete_list *) 0;
538 return c;
539
540 fail_fminit:
541 D(t = "c->fmc");
542 fail_hash:
543 kfree(c);
544 DJM(no_jffs_control--);
545 D(t = t ? t : "c->hash");
546 fail_control:
547 D(t = t ? t : "control");
548 D(printk("jffs_create_control(): Allocation failed: (%s)\n", t));
549 return (struct jffs_control *)0;
550 }
551
552
553 /* Clean up all data structures associated with the file system. */
554 void
555 jffs_cleanup_control(struct jffs_control *c)
556 {
557 D2(printk("jffs_cleanup_control()\n"));
558
559 if (!c) {
560 D(printk("jffs_cleanup_control(): c == NULL !!!\n"));
561 return;
562 }
563
564 while (c->delete_list) {
565 struct jffs_delete_list *delete_list_element;
566 delete_list_element = c->delete_list;
567 c->delete_list = c->delete_list->next;
568 kfree(delete_list_element);
569 }
570
571 /* Free all files and nodes. */
572 if (c->hash) {
573 jffs_foreach_file(c, jffs_free_node_list);
574 jffs_foreach_file(c, jffs_free_file);
575 kfree(c->hash);
576 DJM(no_hash--);
577 }
578 jffs_cleanup_fmcontrol(c->fmc);
579 kfree(c);
580 DJM(no_jffs_control--);
581 D3(printk("jffs_cleanup_control(): Leaving...\n"));
582 }
583
584
585 /* This function adds a virtual root node to the in-RAM representation.
586 Called by jffs_build_fs(). */
587 static int
588 jffs_add_virtual_root(struct jffs_control *c)
589 {
590 struct jffs_file *root;
591 struct jffs_node *node;
592
593 D2(printk("jffs_add_virtual_root(): "
594 "Creating a virtual root directory.\n"));
595
596 if (!(root = (struct jffs_file *)kmalloc(sizeof(struct jffs_file),
597 GFP_KERNEL))) {
598 return -ENOMEM;
599 }
600 no_jffs_file++;
601 if (!(node = jffs_alloc_node())) {
602 kfree(root);
603 no_jffs_file--;
604 return -ENOMEM;
605 }
606 DJM(no_jffs_node++);
607 memset(node, 0, sizeof(struct jffs_node));
608 node->ino = JFFS_MIN_INO;
609 memset(root, 0, sizeof(struct jffs_file));
610 root->ino = JFFS_MIN_INO;
611 root->mode = S_IFDIR | S_IRWXU | S_IRGRP
612 | S_IXGRP | S_IROTH | S_IXOTH;
613 root->atime = root->mtime = root->ctime = get_seconds();
614 root->nlink = 1;
615 root->c = c;
616 root->version_head = root->version_tail = node;
617 jffs_insert_file_into_hash(root);
618 return 0;
619 }
620
621
622 /* This is where the file system is built and initialized. */
623 int
624 jffs_build_fs(struct super_block *sb)
625 {
626 struct jffs_control *c;
627 int err = 0;
628
629 D2(printk("jffs_build_fs()\n"));
630
631 if (!(c = jffs_create_control(sb))) {
632 return -ENOMEM;
633 }
634 c->building_fs = 1;
635 c->sb = sb;
636 if ((err = jffs_scan_flash(c)) < 0) {
637 if(err == -EAGAIN){
638 /* scan_flash() wants us to try once more. A flipping
639 bits sector was detect in the middle of the scan flash.
640 Clean up old allocated memory before going in.
641 */
642 D1(printk("jffs_build_fs: Cleaning up all control structures,"
643 " reallocating them and trying mount again.\n"));
644 jffs_cleanup_control(c);
645 if (!(c = jffs_create_control(sb))) {
646 return -ENOMEM;
647 }
648 c->building_fs = 1;
649 c->sb = sb;
650
651 if ((err = jffs_scan_flash(c)) < 0) {
652 goto jffs_build_fs_fail;
653 }
654 }else{
655 goto jffs_build_fs_fail;
656 }
657 }
658
659 /* Add a virtual root node if no one exists. */
660 if (!jffs_find_file(c, JFFS_MIN_INO)) {
661 if ((err = jffs_add_virtual_root(c)) < 0) {
662 goto jffs_build_fs_fail;
663 }
664 }
665
666 while (c->delete_list) {
667 struct jffs_file *f;
668 struct jffs_delete_list *delete_list_element;
669
670 if ((f = jffs_find_file(c, c->delete_list->ino))) {
671 f->deleted = 1;
672 }
673 delete_list_element = c->delete_list;
674 c->delete_list = c->delete_list->next;
675 kfree(delete_list_element);
676 }
677
678 /* Remove deleted nodes. */
679 if ((err = jffs_foreach_file(c, jffs_possibly_delete_file)) < 0) {
680 printk(KERN_ERR "JFFS: Failed to remove deleted nodes.\n");
681 goto jffs_build_fs_fail;
682 }
683 /* Remove redundant nodes. (We are not interested in the
684 return value in this case.) */
685 jffs_foreach_file(c, jffs_remove_redundant_nodes);
686 /* Try to build a tree from all the nodes. */
687 if ((err = jffs_foreach_file(c, jffs_insert_file_into_tree)) < 0) {
688 printk("JFFS: Failed to build tree.\n");
689 goto jffs_build_fs_fail;
690 }
691 /* Compute the sizes of all files in the filesystem. Adjust if
692 necessary. */
693 if ((err = jffs_foreach_file(c, jffs_build_file)) < 0) {
694 printk("JFFS: Failed to build file system.\n");
695 goto jffs_build_fs_fail;
696 }
697 sb->s_fs_info = (void *)c;
698 c->building_fs = 0;
699
700 D1(jffs_print_hash_table(c));
701 D1(jffs_print_tree(c->root, 0));
702
703 return 0;
704
705 jffs_build_fs_fail:
706 jffs_cleanup_control(c);
707 return err;
708 } /* jffs_build_fs() */
709
710
711 /*
712 This checks for sectors that were being erased in their previous
713 lifetimes and for some reason or the other (power fail etc.),
714 the erase cycles never completed.
715 As the flash array would have reverted back to read status,
716 these sectors are detected by the symptom of the "flipping bits",
717 i.e. bits being read back differently from the same location in
718 flash if read multiple times.
719 The only solution to this is to re-erase the entire
720 sector.
721 Unfortunately detecting "flipping bits" is not a simple exercise
722 as a bit may be read back at 1 or 0 depending on the alignment
723 of the stars in the universe.
724 The level of confidence is in direct proportion to the number of
725 scans done. By power fail testing I (Vipin) have been able to
726 proove that reading twice is not enough.
727 Maybe 4 times? Change NUM_REREADS to a higher number if you want
728 a (even) higher degree of confidence in your mount process.
729 A higher number would of course slow down your mount.
730 */
731 static int check_partly_erased_sectors(struct jffs_fmcontrol *fmc){
732
733 #define NUM_REREADS 4 /* see note above */
734 #define READ_AHEAD_BYTES 4096 /* must be a multiple of 4,
735 usually set to kernel page size */
736
737 __u8 *read_buf1;
738 __u8 *read_buf2;
739
740 int err = 0;
741 int retlen;
742 int i;
743 int cnt;
744 __u32 offset;
745 loff_t pos = 0;
746 loff_t end = fmc->flash_size;
747
748
749 /* Allocate read buffers */
750 read_buf1 = (__u8 *) kmalloc (sizeof(__u8) * READ_AHEAD_BYTES, GFP_KERNEL);
751 if (!read_buf1)
752 return -ENOMEM;
753
754 read_buf2 = (__u8 *) kmalloc (sizeof(__u8) * READ_AHEAD_BYTES, GFP_KERNEL);
755 if (!read_buf2) {
756 kfree(read_buf1);
757 return -ENOMEM;
758 }
759
760 CHECK_NEXT:
761 while(pos < end){
762
763 D1(printk("check_partly_erased_sector():checking sector which contains"
764 " offset 0x%x for flipping bits..\n", (__u32)pos));
765
766 retlen = flash_safe_read(fmc->mtd, pos,
767 &read_buf1[0], READ_AHEAD_BYTES);
768 retlen &= ~3;
769
770 for(cnt = 0; cnt < NUM_REREADS; cnt++){
771 (void)flash_safe_read(fmc->mtd, pos,
772 &read_buf2[0], READ_AHEAD_BYTES);
773
774 for (i=0 ; i < retlen ; i+=4) {
775 /* buffers MUST match, double word for word! */
776 if(*((__u32 *) &read_buf1[i]) !=
777 *((__u32 *) &read_buf2[i])
778 ){
779 /* flipping bits detected, time to erase sector */
780 /* This will help us log some statistics etc. */
781 D1(printk("Flipping bits detected in re-read round:%i of %i\n",
782 cnt, NUM_REREADS));
783 D1(printk("check_partly_erased_sectors:flipping bits detected"
784 " @offset:0x%x(0x%x!=0x%x)\n",
785 (__u32)pos+i, *((__u32 *) &read_buf1[i]),
786 *((__u32 *) &read_buf2[i])));
787
788 /* calculate start of present sector */
789 offset = (((__u32)pos+i)/(__u32)fmc->sector_size) * (__u32)fmc->sector_size;
790
791 D1(printk("check_partly_erased_sector():erasing sector starting 0x%x.\n",
792 offset));
793
794 if (flash_erase_region(fmc->mtd,
795 offset, fmc->sector_size) < 0) {
796 printk(KERN_ERR "JFFS: Erase of flash failed. "
797 "offset = %u, erase_size = %d\n",
798 offset , fmc->sector_size);
799
800 err = -EIO;
801 goto returnBack;
802
803 }else{
804 D1(printk("JFFS: Erase of flash sector @0x%x successful.\n",
805 offset));
806 /* skip ahead to the next sector */
807 pos = (((__u32)pos+i)/(__u32)fmc->sector_size) * (__u32)fmc->sector_size;
808 pos += fmc->sector_size;
809 goto CHECK_NEXT;
810 }
811 }
812 }
813 }
814 pos += READ_AHEAD_BYTES;
815 }
816
817 returnBack:
818 kfree(read_buf1);
819 kfree(read_buf2);
820
821 D2(printk("check_partly_erased_sector():Done checking all sectors till offset 0x%x for flipping bits.\n",
822 (__u32)pos));
823
824 return err;
825
826 }/* end check_partly_erased_sectors() */
827
828
829
830 /* Scan the whole flash memory in order to find all nodes in the
831 file systems. */
832 static int
833 jffs_scan_flash(struct jffs_control *c)
834 {
835 char name[JFFS_MAX_NAME_LEN + 2];
836 struct jffs_raw_inode raw_inode;
837 struct jffs_node *node = NULL;
838 struct jffs_fmcontrol *fmc = c->fmc;
839 __u32 checksum;
840 __u8 tmp_accurate;
841 __u16 tmp_chksum;
842 __u32 deleted_file;
843 loff_t pos = 0;
844 loff_t start;
845 loff_t test_start;
846 loff_t end = fmc->flash_size;
847 __u8 *read_buf;
848 int i, len, retlen;
849 __u32 offset;
850
851 __u32 free_chunk_size1;
852 __u32 free_chunk_size2;
853
854
855 #define NUMFREEALLOWED 2 /* 2 chunks of at least erase size space allowed */
856 int num_free_space = 0; /* Flag err if more than TWO
857 free blocks found. This is NOT allowed
858 by the current jffs design.
859 */
860 int num_free_spc_not_accp = 0; /* For debugging purposed keep count
861 of how much free space was rejected and
862 marked dirty
863 */
864
865 D1(printk("jffs_scan_flash(): start pos = 0x%lx, end = 0x%lx\n",
866 (long)pos, (long)end));
867
868 flash_safe_acquire(fmc->mtd);
869
870 /*
871 check and make sure that any sector does not suffer
872 from the "partly erased, bit flipping syndrome" (TM Vipin :)
873 If so, offending sectors will be erased.
874 */
875 if(check_partly_erased_sectors(fmc) < 0){
876
877 flash_safe_release(fmc->mtd);
878 return -EIO; /* bad, bad, bad error. Cannot continue.*/
879 }
880
881 /* Allocate read buffer */
882 read_buf = (__u8 *) kmalloc (sizeof(__u8) * 4096, GFP_KERNEL);
883 if (!read_buf) {
884 flash_safe_release(fmc->mtd);
885 return -ENOMEM;
886 }
887
888 /* Start the scan. */
889 while (pos < end) {
890 deleted_file = 0;
891
892 /* Remember the position from where we started this scan. */
893 start = pos;
894
895 switch (flash_read_u32(fmc->mtd, pos)) {
896 case JFFS_EMPTY_BITMASK:
897 /* We have found 0xffffffff at this position. We have to
898 scan the rest of the flash till the end or till
899 something else than 0xffffffff is found.
900 Keep going till we do not find JFFS_EMPTY_BITMASK
901 anymore */
902
903 D1(printk("jffs_scan_flash(): 0xffffffff at pos 0x%lx.\n",
904 (long)pos));
905
906 while(pos < end){
907
908 len = end - pos < 4096 ? end - pos : 4096;
909
910 retlen = flash_safe_read(fmc->mtd, pos,
911 &read_buf[0], len);
912
913 retlen &= ~3;
914
915 for (i=0 ; i < retlen ; i+=4, pos += 4) {
916 if(*((__u32 *) &read_buf[i]) !=
917 JFFS_EMPTY_BITMASK)
918 break;
919 }
920 if (i == retlen)
921 continue;
922 else
923 break;
924 }
925
926 D1(printk("jffs_scan_flash():0xffffffff ended at pos 0x%lx.\n",
927 (long)pos));
928
929 /* If some free space ends in the middle of a sector,
930 treat it as dirty rather than clean.
931 This is to handle the case where one thread
932 allocated space for a node, but didn't get to
933 actually _write_ it before power was lost, leaving
934 a gap in the log. Shifting all node writes into
935 a single kernel thread will fix the original problem.
936 */
937 if ((__u32) pos % fmc->sector_size) {
938 /* If there was free space in previous
939 sectors, don't mark that dirty too -
940 only from the beginning of this sector
941 (or from start)
942 */
943
944 test_start = pos & ~(fmc->sector_size-1); /* end of last sector */
945
946 if (start < test_start) {
947
948 /* free space started in the previous sector! */
949
950 if((num_free_space < NUMFREEALLOWED) &&
951 ((unsigned int)(test_start - start) >= fmc->sector_size)){
952
953 /*
954 Count it in if we are still under NUMFREEALLOWED *and* it is
955 at least 1 erase sector in length. This will keep us from
956 picking any little ole' space as "free".
957 */
958
959 D1(printk("Reducing end of free space to 0x%x from 0x%x\n",
960 (unsigned int)test_start, (unsigned int)pos));
961
962 D1(printk("Free space accepted: Starting 0x%x for 0x%x bytes\n",
963 (unsigned int) start,
964 (unsigned int)(test_start - start)));
965
966 /* below, space from "start" to "pos" will be marked dirty. */
967 start = test_start;
968
969 /* Being in here means that we have found at least an entire
970 erase sector size of free space ending on a sector boundary.
971 Keep track of free spaces accepted.
972 */
973 num_free_space++;
974 }else{
975 num_free_spc_not_accp++;
976 D1(printk("Free space (#%i) found but *Not* accepted: Starting"
977 " 0x%x for 0x%x bytes\n",
978 num_free_spc_not_accp, (unsigned int)start,
979 (unsigned int)((unsigned int)(pos & ~(fmc->sector_size-1)) - (unsigned int)start)));
980
981 }
982
983 }
984 if((((__u32)(pos - start)) != 0)){
985
986 D1(printk("Dirty space: Starting 0x%x for 0x%x bytes\n",
987 (unsigned int) start, (unsigned int) (pos - start)));
988 jffs_fmalloced(fmc, (__u32) start,
989 (__u32) (pos - start), NULL);
990 }else{
991 /* "Flipping bits" detected. This means that our scan for them
992 did not catch this offset. See check_partly_erased_sectors() for
993 more info.
994 */
995
996 D1(printk("jffs_scan_flash():wants to allocate dirty flash "
997 "space for 0 bytes.\n"));
998 D1(printk("jffs_scan_flash(): Flipping bits! We will free "
999 "all allocated memory, erase this sector and remount\n"));
1000
1001 /* calculate start of present sector */
1002 offset = (((__u32)pos)/(__u32)fmc->sector_size) * (__u32)fmc->sector_size;
1003
1004 D1(printk("jffs_scan_flash():erasing sector starting 0x%x.\n",
1005 offset));
1006
1007 if (flash_erase_region(fmc->mtd,
1008 offset, fmc->sector_size) < 0) {
1009 printk(KERN_ERR "JFFS: Erase of flash failed. "
1010 "offset = %u, erase_size = %d\n",
1011 offset , fmc->sector_size);
1012
1013 flash_safe_release(fmc->mtd);
1014 kfree(read_buf);
1015 return -1; /* bad, bad, bad! */
1016
1017 }
1018 flash_safe_release(fmc->mtd);
1019 kfree(read_buf);
1020
1021 return -EAGAIN; /* erased offending sector. Try mount one more time please. */
1022 }
1023 }else{
1024 /* Being in here means that we have found free space that ends on an erase sector
1025 boundary.
1026 Count it in if we are still under NUMFREEALLOWED *and* it is at least 1 erase
1027 sector in length. This will keep us from picking any little ole' space as "free".
1028 */
1029 if((num_free_space < NUMFREEALLOWED) &&
1030 ((unsigned int)(pos - start) >= fmc->sector_size)){
1031 /* We really don't do anything to mark space as free, except *not*
1032 mark it dirty and just advance the "pos" location pointer.
1033 It will automatically be picked up as free space.
1034 */
1035 num_free_space++;
1036 D1(printk("Free space accepted: Starting 0x%x for 0x%x bytes\n",
1037 (unsigned int) start, (unsigned int) (pos - start)));
1038 }else{
1039 num_free_spc_not_accp++;
1040 D1(printk("Free space (#%i) found but *Not* accepted: Starting "
1041 "0x%x for 0x%x bytes\n", num_free_spc_not_accp,
1042 (unsigned int) start,
1043 (unsigned int) (pos - start)));
1044
1045 /* Mark this space as dirty. We already have our free space. */
1046 D1(printk("Dirty space: Starting 0x%x for 0x%x bytes\n",
1047 (unsigned int) start, (unsigned int) (pos - start)));
1048 jffs_fmalloced(fmc, (__u32) start,
1049 (__u32) (pos - start), NULL);
1050 }
1051
1052 }
1053 if(num_free_space > NUMFREEALLOWED){
1054 printk(KERN_WARNING "jffs_scan_flash(): Found free space "
1055 "number %i. Only %i free space is allowed.\n",
1056 num_free_space, NUMFREEALLOWED);
1057 }
1058 continue;
1059
1060 case JFFS_DIRTY_BITMASK:
1061 /* We have found 0x00000000 at this position. Scan as far
1062 as possible to find out how much is dirty. */
1063 D1(printk("jffs_scan_flash(): 0x00000000 at pos 0x%lx.\n",
1064 (long)pos));
1065 for (; pos < end
1066 && JFFS_DIRTY_BITMASK == flash_read_u32(fmc->mtd, pos);
1067 pos += 4);
1068 D1(printk("jffs_scan_flash(): 0x00 ended at "
1069 "pos 0x%lx.\n", (long)pos));
1070 jffs_fmalloced(fmc, (__u32) start,
1071 (__u32) (pos - start), NULL);
1072 continue;
1073
1074 case JFFS_MAGIC_BITMASK:
1075 /* We have probably found a new raw inode. */
1076 break;
1077
1078 default:
1079 bad_inode:
1080 /* We're f*cked. This is not solved yet. We have
1081 to scan for the magic pattern. */
1082 D1(printk("*************** Dirty flash memory or "
1083 "bad inode: "
1084 "hexdump(pos = 0x%lx, len = 128):\n",
1085 (long)pos));
1086 D1(jffs_hexdump(fmc->mtd, pos, 128));
1087
1088 for (pos += 4; pos < end; pos += 4) {
1089 switch (flash_read_u32(fmc->mtd, pos)) {
1090 case JFFS_MAGIC_BITMASK:
1091 case JFFS_EMPTY_BITMASK:
1092 /* handle these in the main switch() loop */
1093 goto cont_scan;
1094
1095 default:
1096 break;
1097 }
1098 }
1099
1100 cont_scan:
1101 /* First, mark as dirty the region
1102 which really does contain crap. */
1103 jffs_fmalloced(fmc, (__u32) start,
1104 (__u32) (pos - start),
1105 NULL);
1106
1107 continue;
1108 }/* switch */
1109
1110 /* We have found the beginning of an inode. Create a
1111 node for it unless there already is one available. */
1112 if (!node) {
1113 if (!(node = jffs_alloc_node())) {
1114 /* Free read buffer */
1115 kfree(read_buf);
1116
1117 /* Release the flash device */
1118 flash_safe_release(fmc->mtd);
1119
1120 return -ENOMEM;
1121 }
1122 DJM(no_jffs_node++);
1123 }
1124
1125 /* Read the next raw inode. */
1126
1127 flash_safe_read(fmc->mtd, pos, (u_char *) &raw_inode,
1128 sizeof(struct jffs_raw_inode));
1129
1130 /* When we compute the checksum for the inode, we never
1131 count the 'accurate' or the 'checksum' fields. */
1132 tmp_accurate = raw_inode.accurate;
1133 tmp_chksum = raw_inode.chksum;
1134 raw_inode.accurate = 0;
1135 raw_inode.chksum = 0;
1136 checksum = jffs_checksum(&raw_inode,
1137 sizeof(struct jffs_raw_inode));
1138 raw_inode.accurate = tmp_accurate;
1139 raw_inode.chksum = tmp_chksum;
1140
1141 D3(printk("*** We have found this raw inode at pos 0x%lx "
1142 "on the flash:\n", (long)pos));
1143 D3(jffs_print_raw_inode(&raw_inode));
1144
1145 if (checksum != raw_inode.chksum) {
1146 D1(printk("jffs_scan_flash(): Bad checksum: "
1147 "checksum = %u, "
1148 "raw_inode.chksum = %u\n",
1149 checksum, raw_inode.chksum));
1150 pos += sizeof(struct jffs_raw_inode);
1151 jffs_fmalloced(fmc, (__u32) start,
1152 (__u32) (pos - start), NULL);
1153 /* Reuse this unused struct jffs_node. */
1154 continue;
1155 }
1156
1157 /* Check the raw inode read so far. Start with the
1158 maximum length of the filename. */
1159 if (raw_inode.nsize > JFFS_MAX_NAME_LEN) {
1160 printk(KERN_WARNING "jffs_scan_flash: Found a "
1161 "JFFS node with name too large\n");
1162 goto bad_inode;
1163 }
1164
1165 if (raw_inode.rename && raw_inode.dsize != sizeof(__u32)) {
1166 printk(KERN_WARNING "jffs_scan_flash: Found a "
1167 "rename node with dsize %u.\n",
1168 raw_inode.dsize);
1169 jffs_print_raw_inode(&raw_inode);
1170 goto bad_inode;
1171 }
1172
1173 /* The node's data segment should not exceed a
1174 certain length. */
1175 if (raw_inode.dsize > fmc->max_chunk_size) {
1176 printk(KERN_WARNING "jffs_scan_flash: Found a "
1177 "JFFS node with dsize (0x%x) > max_chunk_size (0x%x)\n",
1178 raw_inode.dsize, fmc->max_chunk_size);
1179 goto bad_inode;
1180 }
1181
1182 pos += sizeof(struct jffs_raw_inode);
1183
1184 /* This shouldn't be necessary because a node that
1185 violates the flash boundaries shouldn't be written
1186 in the first place. */
1187 if (pos >= end) {
1188 goto check_node;
1189 }
1190
1191 /* Read the name. */
1192 *name = 0;
1193 if (raw_inode.nsize) {
1194 flash_safe_read(fmc->mtd, pos, name, raw_inode.nsize);
1195 name[raw_inode.nsize] = '\0';
1196 pos += raw_inode.nsize
1197 + JFFS_GET_PAD_BYTES(raw_inode.nsize);
1198 D3(printk("name == \"%s\"\n", name));
1199 checksum = jffs_checksum(name, raw_inode.nsize);
1200 if (checksum != raw_inode.nchksum) {
1201 D1(printk("jffs_scan_flash(): Bad checksum: "
1202 "checksum = %u, "
1203 "raw_inode.nchksum = %u\n",
1204 checksum, raw_inode.nchksum));
1205 jffs_fmalloced(fmc, (__u32) start,
1206 (__u32) (pos - start), NULL);
1207 /* Reuse this unused struct jffs_node. */
1208 continue;
1209 }
1210 if (pos >= end) {
1211 goto check_node;
1212 }
1213 }
1214
1215 /* Read the data, if it exists, in order to be sure it
1216 matches the checksum. */
1217 if (raw_inode.dsize) {
1218 if (raw_inode.rename) {
1219 deleted_file = flash_read_u32(fmc->mtd, pos);
1220 }
1221 if (jffs_checksum_flash(fmc->mtd, pos, raw_inode.dsize, &checksum)) {
1222 printk("jffs_checksum_flash() failed to calculate a checksum\n");
1223 jffs_fmalloced(fmc, (__u32) start,
1224 (__u32) (pos - start), NULL);
1225 /* Reuse this unused struct jffs_node. */
1226 continue;
1227 }
1228 pos += raw_inode.dsize
1229 + JFFS_GET_PAD_BYTES(raw_inode.dsize);
1230
1231 if (checksum != raw_inode.dchksum) {
1232 D1(printk("jffs_scan_flash(): Bad checksum: "
1233 "checksum = %u, "
1234 "raw_inode.dchksum = %u\n",
1235 checksum, raw_inode.dchksum));
1236 jffs_fmalloced(fmc, (__u32) start,
1237 (__u32) (pos - start), NULL);
1238 /* Reuse this unused struct jffs_node. */
1239 continue;
1240 }
1241 }
1242
1243 check_node:
1244
1245 /* Remember the highest inode number in the whole file
1246 system. This information will be used when assigning
1247 new files new inode numbers. */
1248 if (c->next_ino <= raw_inode.ino) {
1249 c->next_ino = raw_inode.ino + 1;
1250 }
1251
1252 if (raw_inode.accurate) {
1253 int err;
1254 node->data_offset = raw_inode.offset;
1255 node->data_size = raw_inode.dsize;
1256 node->removed_size = raw_inode.rsize;
1257 /* Compute the offset to the actual data in the
1258 on-flash node. */
1259 node->fm_offset
1260 = sizeof(struct jffs_raw_inode)
1261 + raw_inode.nsize
1262 + JFFS_GET_PAD_BYTES(raw_inode.nsize);
1263 node->fm = jffs_fmalloced(fmc, (__u32) start,
1264 (__u32) (pos - start),
1265 node);
1266 if (!node->fm) {
1267 D(printk("jffs_scan_flash(): !node->fm\n"));
1268 jffs_free_node(node);
1269 DJM(no_jffs_node--);
1270
1271 /* Free read buffer */
1272 kfree(read_buf);
1273
1274 /* Release the flash device */
1275 flash_safe_release(fmc->mtd);
1276
1277 return -ENOMEM;
1278 }
1279 if ((err = jffs_insert_node(c, NULL, &raw_inode,
1280 name, node)) < 0) {
1281 printk("JFFS: Failed to handle raw inode. "
1282 "(err = %d)\n", err);
1283 break;
1284 }
1285 if (raw_inode.rename) {
1286 struct jffs_delete_list *dl
1287 = (struct jffs_delete_list *)
1288 kmalloc(sizeof(struct jffs_delete_list),
1289 GFP_KERNEL);
1290 if (!dl) {
1291 D(printk("jffs_scan_flash: !dl\n"));
1292 jffs_free_node(node);
1293 DJM(no_jffs_node--);
1294
1295 /* Release the flash device */
1296 flash_safe_release(fmc->flash_part);
1297
1298 /* Free read buffer */
1299 kfree(read_buf);
1300
1301 return -ENOMEM;
1302 }
1303 dl->ino = deleted_file;
1304 dl->next = c->delete_list;
1305 c->delete_list = dl;
1306 node->data_size = 0;
1307 }
1308 D3(jffs_print_node(node));
1309 node = NULL; /* Don't free the node! */
1310 }
1311 else {
1312 jffs_fmalloced(fmc, (__u32) start,
1313 (__u32) (pos - start), NULL);
1314 D3(printk("jffs_scan_flash(): Just found an obsolete "
1315 "raw_inode. Continuing the scan...\n"));
1316 /* Reuse this unused struct jffs_node. */
1317 }
1318 }
1319
1320 if (node) {
1321 jffs_free_node(node);
1322 DJM(no_jffs_node--);
1323 }
1324 jffs_build_end(fmc);
1325
1326 /* Free read buffer */
1327 kfree(read_buf);
1328
1329 if(!num_free_space){
1330 printk(KERN_WARNING "jffs_scan_flash(): Did not find even a single "
1331 "chunk of free space. This is BAD!\n");
1332 }
1333
1334 /* Return happy */
1335 D3(printk("jffs_scan_flash(): Leaving...\n"));
1336 flash_safe_release(fmc->mtd);
1337
1338 /* This is to trap the "free size accounting screwed error. */
1339 free_chunk_size1 = jffs_free_size1(fmc);
1340 free_chunk_size2 = jffs_free_size2(fmc);
1341
1342 if (free_chunk_size1 + free_chunk_size2 != fmc->free_size) {
1343
1344 printk(KERN_WARNING "jffs_scan_falsh():Free size accounting screwed\n");
1345 printk(KERN_WARNING "jfffs_scan_flash():free_chunk_size1 == 0x%x, "
1346 "free_chunk_size2 == 0x%x, fmc->free_size == 0x%x\n",
1347 free_chunk_size1, free_chunk_size2, fmc->free_size);
1348
1349 return -1; /* Do NOT mount f/s so that we can inspect what happened.
1350 Mounting this screwed up f/s will screw us up anyway.
1351 */
1352 }
1353
1354 return 0; /* as far as we are concerned, we are happy! */
1355 } /* jffs_scan_flash() */
1356
1357
1358 /* Insert any kind of node into the file system. Take care of data
1359 insertions and deletions. Also remove redundant information. The
1360 memory allocated for the `name' is regarded as "given away" in the
1361 caller's perspective. */
1362 int
1363 jffs_insert_node(struct jffs_control *c, struct jffs_file *f,
1364 const struct jffs_raw_inode *raw_inode,
1365 const char *name, struct jffs_node *node)
1366 {
1367 int update_name = 0;
1368 int insert_into_tree = 0;
1369
1370 D2(printk("jffs_insert_node(): ino = %u, version = %u, "
1371 "name = \"%s\", deleted = %d\n",
1372 raw_inode->ino, raw_inode->version,
1373 ((name && *name) ? name : ""), raw_inode->deleted));
1374
1375 /* If there doesn't exist an associated jffs_file, then
1376 create, initialize and insert one into the file system. */
1377 if (!f && !(f = jffs_find_file(c, raw_inode->ino))) {
1378 if (!(f = jffs_create_file(c, raw_inode))) {
1379 return -ENOMEM;
1380 }
1381 jffs_insert_file_into_hash(f);
1382 insert_into_tree = 1;
1383 }
1384 node->ino = raw_inode->ino;
1385 node->version = raw_inode->version;
1386 node->data_size = raw_inode->dsize;
1387 node->fm_offset = sizeof(struct jffs_raw_inode) + raw_inode->nsize
1388 + JFFS_GET_PAD_BYTES(raw_inode->nsize);
1389 node->name_size = raw_inode->nsize;
1390
1391 /* Now insert the node at the correct position into the file's
1392 version list. */
1393 if (!f->version_head) {
1394 /* This is the first node. */
1395 f->version_head = node;
1396 f->version_tail = node;
1397 node->version_prev = NULL;
1398 node->version_next = NULL;
1399 f->highest_version = node->version;
1400 update_name = 1;
1401 f->mode = raw_inode->mode;
1402 f->uid = raw_inode->uid;
1403 f->gid = raw_inode->gid;
1404 f->atime = raw_inode->atime;
1405 f->mtime = raw_inode->mtime;
1406 f->ctime = raw_inode->ctime;
1407 }
1408 else if ((f->highest_version < node->version)
1409 || (node->version == 0)) {
1410 /* Insert at the end of the list. I.e. this node is the
1411 newest one so far. */
1412 node->version_prev = f->version_tail;
1413 node->version_next = NULL;
1414 f->version_tail->version_next = node;
1415 f->version_tail = node;
1416 f->highest_version = node->version;
1417 update_name = 1;
1418 f->pino = raw_inode->pino;
1419 f->mode = raw_inode->mode;
1420 f->uid = raw_inode->uid;
1421 f->gid = raw_inode->gid;
1422 f->atime = raw_inode->atime;
1423 f->mtime = raw_inode->mtime;
1424 f->ctime = raw_inode->ctime;
1425 }
1426 else if (f->version_head->version > node->version) {
1427 /* Insert at the bottom of the list. */
1428 node->version_prev = NULL;
1429 node->version_next = f->version_head;
1430 f->version_head->version_prev = node;
1431 f->version_head = node;
1432 if (!f->name) {
1433 update_name = 1;
1434 }
1435 }
1436 else {
1437 struct jffs_node *n;
1438 int newer_name = 0;
1439 /* Search for the insertion position starting from
1440 the tail (newest node). */
1441 for (n = f->version_tail; n; n = n->version_prev) {
1442 if (n->version < node->version) {
1443 node->version_prev = n;
1444 node->version_next = n->version_next;
1445 node->version_next->version_prev = node;
1446 n->version_next = node;
1447 if (!newer_name) {
1448 update_name = 1;
1449 }
1450 break;
1451 }
1452 if (n->name_size) {
1453 newer_name = 1;
1454 }
1455 }
1456 }
1457
1458 /* Deletion is irreversible. If any 'deleted' node is ever
1459 written, the file is deleted */
1460 if (raw_inode->deleted)
1461 f->deleted = raw_inode->deleted;
1462
1463 /* Perhaps update the name. */
1464 if (raw_inode->nsize && update_name && name && *name && (name != f->name)) {
1465 if (f->name) {
1466 kfree(f->name);
1467 DJM(no_name--);
1468 }
1469 if (!(f->name = (char *) kmalloc(raw_inode->nsize + 1,
1470 GFP_KERNEL))) {
1471 return -ENOMEM;
1472 }
1473 DJM(no_name++);
1474 memcpy(f->name, name, raw_inode->nsize);
1475 f->name[raw_inode->nsize] = '\0';
1476 f->nsize = raw_inode->nsize;
1477 D3(printk("jffs_insert_node(): Updated the name of "
1478 "the file to \"%s\".\n", name));
1479 }
1480
1481 if (!c->building_fs) {
1482 D3(printk("jffs_insert_node(): ---------------------------"
1483 "------------------------------------------- 1\n"));
1484 if (insert_into_tree) {
1485 jffs_insert_file_into_tree(f);
1486 }
1487 /* Once upon a time, we would call jffs_possibly_delete_file()
1488 here. That causes an oops if someone's still got the file
1489 open, so now we only do it in jffs_delete_inode()
1490 -- dwmw2
1491 */
1492 if (node->data_size || node->removed_size) {
1493 jffs_update_file(f, node);
1494 }
1495 jffs_remove_redundant_nodes(f);
1496
1497 jffs_garbage_collect_trigger(c);
1498
1499 D3(printk("jffs_insert_node(): ---------------------------"
1500 "------------------------------------------- 2\n"));
1501 }
1502
1503 return 0;
1504 } /* jffs_insert_node() */
1505
1506
1507 /* Unlink a jffs_node from the version list it is in. */
1508 static inline void
1509 jffs_unlink_node_from_version_list(struct jffs_file *f,
1510 struct jffs_node *node)
1511 {
1512 if (node->version_prev) {
1513 node->version_prev->version_next = node->version_next;
1514 } else {
1515 f->version_head = node->version_next;
1516 }
1517 if (node->version_next) {
1518 node->version_next->version_prev = node->version_prev;
1519 } else {
1520 f->version_tail = node->version_prev;
1521 }
1522 }
1523
1524
1525 /* Unlink a jffs_node from the range list it is in. */
1526 static inline void
1527 jffs_unlink_node_from_range_list(struct jffs_file *f, struct jffs_node *node)
1528 {
1529 if (node->range_prev) {
1530 node->range_prev->range_next = node->range_next;
1531 }
1532 else {
1533 f->range_head = node->range_next;
1534 }
1535 if (node->range_next) {
1536 node->range_next->range_prev = node->range_prev;
1537 }
1538 else {
1539 f->range_tail = node->range_prev;
1540 }
1541 }
1542
1543
1544 /* Function used by jffs_remove_redundant_nodes() below. This function
1545 classifies what kind of information a node adds to a file. */
1546 static inline __u8
1547 jffs_classify_node(struct jffs_node *node)
1548 {
1549 __u8 mod_type = JFFS_MODIFY_INODE;
1550
1551 if (node->name_size) {
1552 mod_type |= JFFS_MODIFY_NAME;
1553 }
1554 if (node->data_size || node->removed_size) {
1555 mod_type |= JFFS_MODIFY_DATA;
1556 }
1557 return mod_type;
1558 }
1559
1560
1561 /* Remove redundant nodes from a file. Mark the on-flash memory
1562 as dirty. */
1563 static int
1564 jffs_remove_redundant_nodes(struct jffs_file *f)
1565 {
1566 struct jffs_node *newest_node;
1567 struct jffs_node *cur;
1568 struct jffs_node *prev;
1569 __u8 newest_type;
1570 __u8 mod_type;
1571 __u8 node_with_name_later = 0;
1572
1573 if (!(newest_node = f->version_tail)) {
1574 return 0;
1575 }
1576
1577 /* What does the `newest_node' modify? */
1578 newest_type = jffs_classify_node(newest_node);
1579 node_with_name_later = newest_type & JFFS_MODIFY_NAME;
1580
1581 D3(printk("jffs_remove_redundant_nodes(): ino: %u, name: \"%s\", "
1582 "newest_type: %u\n", f->ino, (f->name ? f->name : ""),
1583 newest_type));
1584
1585 /* Traverse the file's nodes and determine which of them that are
1586 superfluous. Yeah, this might look very complex at first
1587 glance but it is actually very simple. */
1588 for (cur = newest_node->version_prev; cur; cur = prev) {
1589 prev = cur->version_prev;
1590 mod_type = jffs_classify_node(cur);
1591 if ((mod_type <= JFFS_MODIFY_INODE)
1592 || ((newest_type & JFFS_MODIFY_NAME)
1593 && (mod_type
1594 <= (JFFS_MODIFY_INODE + JFFS_MODIFY_NAME)))
1595 || (cur->data_size == 0 && cur->removed_size
1596 && !cur->version_prev && node_with_name_later)) {
1597 /* Yes, this node is redundant. Remove it. */
1598 D2(printk("jffs_remove_redundant_nodes(): "
1599 "Removing node: ino: %u, version: %u, "
1600 "mod_type: %u\n", cur->ino, cur->version,
1601 mod_type));
1602 jffs_unlink_node_from_version_list(f, cur);
1603 jffs_fmfree(f->c->fmc, cur->fm, cur);
1604 jffs_free_node(cur);
1605 DJM(no_jffs_node--);
1606 }
1607 else {
1608 node_with_name_later |= (mod_type & JFFS_MODIFY_NAME);
1609 }
1610 }
1611
1612 return 0;
1613 }
1614
1615
1616 /* Insert a file into the hash table. */
1617 static int
1618 jffs_insert_file_into_hash(struct jffs_file *f)
1619 {
1620 int i = f->ino % f->c->hash_len;
1621
1622 D3(printk("jffs_insert_file_into_hash(): f->ino: %u\n", f->ino));
1623
1624 list_add(&f->hash, &f->c->hash[i]);
1625 return 0;
1626 }
1627
1628
1629 /* Insert a file into the file system tree. */
1630 int
1631 jffs_insert_file_into_tree(struct jffs_file *f)
1632 {
1633 struct jffs_file *parent;
1634
1635 D3(printk("jffs_insert_file_into_tree(): name: \"%s\"\n",
1636 (f->name ? f->name : "")));
1637
1638 if (!(parent = jffs_find_file(f->c, f->pino))) {
1639 if (f->pino == 0) {
1640 f->c->root = f;
1641 f->parent = NULL;
1642 f->sibling_prev = NULL;
1643 f->sibling_next = NULL;
1644 return 0;
1645 }
1646 else {
1647 D1(printk("jffs_insert_file_into_tree(): Found "
1648 "inode with no parent and pino == %u\n",
1649 f->pino));
1650 return -1;
1651 }
1652 }
1653 f->parent = parent;
1654 f->sibling_next = parent->children;
1655 if (f->sibling_next) {
1656 f->sibling_next->sibling_prev = f;
1657 }
1658 f->sibling_prev = NULL;
1659 parent->children = f;
1660 return 0;
1661 }
1662
1663
1664 /* Remove a file from the hash table. */
1665 static int
1666 jffs_unlink_file_from_hash(struct jffs_file *f)
1667 {
1668 D3(printk("jffs_unlink_file_from_hash(): f: 0x%p, "
1669 "ino %u\n", f, f->ino));
1670
1671 list_del(&f->hash);
1672 return 0;
1673 }
1674
1675
1676 /* Just remove the file from the parent's children. Don't free
1677 any memory. */
1678 int
1679 jffs_unlink_file_from_tree(struct jffs_file *f)
1680 {
1681 D3(printk("jffs_unlink_file_from_tree(): ino: %d, pino: %d, name: "
1682 "\"%s\"\n", f->ino, f->pino, (f->name ? f->name : "")));
1683
1684 if (f->sibling_prev) {
1685 f->sibling_prev->sibling_next = f->sibling_next;
1686 }
1687 else if (f->parent) {
1688 D3(printk("f->parent=%p\n", f->parent));
1689 f->parent->children = f->sibling_next;
1690 }
1691 if (f->sibling_next) {
1692 f->sibling_next->sibling_prev = f->sibling_prev;
1693 }
1694 return 0;
1695 }
1696
1697
1698 /* Find a file with its inode number. */
1699 struct jffs_file *
1700 jffs_find_file(struct jffs_control *c, __u32 ino)
1701 {
1702 struct jffs_file *f;
1703 int i = ino % c->hash_len;
1704
1705 D3(printk("jffs_find_file(): ino: %u\n", ino));
1706
1707 list_for_each_entry(f, &c->hash[i], hash) {
1708 if (ino != f->ino)
1709 continue;
1710 D3(printk("jffs_find_file(): Found file with ino "
1711 "%u. (name: \"%s\")\n",
1712 ino, (f->name ? f->name : ""));
1713 );
1714 return f;
1715 }
1716 D3(printk("jffs_find_file(): Didn't find file "
1717 "with ino %u.\n", ino);
1718 );
1719 return NULL;
1720 }
1721
1722
1723 /* Find a file in a directory. We are comparing the names. */
1724 struct jffs_file *
1725 jffs_find_child(struct jffs_file *dir, const char *name, int len)
1726 {
1727 struct jffs_file *f;
1728
1729 D3(printk("jffs_find_child()\n"));
1730
1731 for (f = dir->children; f; f = f->sibling_next) {
1732 if (!f->deleted && f->name
1733 && !strncmp(f->name, name, len)
1734 && f->name[len] == '\0') {
1735 break;
1736 }
1737 }
1738
1739 D3(if (f) {
1740 printk("jffs_find_child(): Found \"%s\".\n", f->name);
1741 }
1742 else {
1743 char *copy = (char *) kmalloc(len + 1, GFP_KERNEL);
1744 if (copy) {
1745 memcpy(copy, name, len);
1746 copy[len] = '\0';
1747 }
1748 printk("jffs_find_child(): Didn't find the file \"%s\".\n",
1749 (copy ? copy : ""));
1750 kfree(copy);
1751 });
1752
1753 return f;
1754 }
1755
1756
1757 /* Write a raw inode that takes up a certain amount of space in the flash
1758 memory. At the end of the flash device, there is often space that is
1759 impossible to use. At these times we want to mark this space as not
1760 used. In the cases when the amount of space is greater or equal than
1761 a struct jffs_raw_inode, we write a "dummy node" that takes up this
1762 space. The space after the raw inode, if it exists, is left as it is.
1763 Since this space after the raw inode contains JFFS_EMPTY_BITMASK bytes,
1764 we can compute the checksum of it; we don't have to manipulate it any
1765 further.
1766
1767 If the space left on the device is less than the size of a struct
1768 jffs_raw_inode, this space is filled with JFFS_DIRTY_BITMASK bytes.
1769 No raw inode is written this time. */
1770 static int
1771 jffs_write_dummy_node(struct jffs_control *c, struct jffs_fm *dirty_fm)
1772 {
1773 struct jffs_fmcontrol *fmc = c->fmc;
1774 int err;
1775
1776 D1(printk("jffs_write_dummy_node(): dirty_fm->offset = 0x%08x, "
1777 "dirty_fm->size = %u\n",
1778 dirty_fm->offset, dirty_fm->size));
1779
1780 if (dirty_fm->size >= sizeof(struct jffs_raw_inode)) {
1781 struct jffs_raw_inode raw_inode;
1782 memset(&raw_inode, 0, sizeof(struct jffs_raw_inode));
1783 raw_inode.magic = JFFS_MAGIC_BITMASK;
1784 raw_inode.dsize = dirty_fm->size
1785 - sizeof(struct jffs_raw_inode);
1786 raw_inode.dchksum = raw_inode.dsize * 0xff;
1787 raw_inode.chksum
1788 = jffs_checksum(&raw_inode, sizeof(struct jffs_raw_inode));
1789
1790 if ((err = flash_safe_write(fmc->mtd,
1791 dirty_fm->offset,
1792 (u_char *)&raw_inode,
1793 sizeof(struct jffs_raw_inode)))
1794 < 0) {
1795 printk(KERN_ERR "JFFS: jffs_write_dummy_node: "
1796 "flash_safe_write failed!\n");
1797 return err;
1798 }
1799 }
1800 else {
1801 flash_safe_acquire(fmc->mtd);
1802 flash_memset(fmc->mtd, dirty_fm->offset, 0, dirty_fm->size);
1803 flash_safe_release(fmc->mtd);
1804 }
1805
1806 D3(printk("jffs_write_dummy_node(): Leaving...\n"));
1807 return 0;
1808 }
1809
1810
1811 /* Write a raw inode, possibly its name and possibly some data. */
1812 int
1813 jffs_write_node(struct jffs_control *c, struct jffs_node *node,
1814 struct jffs_raw_inode *raw_inode,
1815 const char *name, const unsigned char *data,
1816 int recoverable,
1817 struct jffs_file *f)
1818 {
1819 struct jffs_fmcontrol *fmc = c->fmc;
1820 struct jffs_fm *fm;
1821 struct kvec node_iovec[4];
1822 unsigned long iovec_cnt;
1823
1824 __u32 pos;
1825 int err;
1826 __u32 slack = 0;
1827
1828 __u32 total_name_size = raw_inode->nsize
1829 + JFFS_GET_PAD_BYTES(raw_inode->nsize);
1830 __u32 total_data_size = raw_inode->dsize
1831 + JFFS_GET_PAD_BYTES(raw_inode->dsize);
1832 __u32 total_size = sizeof(struct jffs_raw_inode)
1833 + total_name_size + total_data_size;
1834
1835 /* If this node isn't something that will eventually let
1836 GC free even more space, then don't allow it unless
1837 there's at least max_chunk_size space still available
1838 */
1839 if (!recoverable)
1840 slack = fmc->max_chunk_size;
1841
1842
1843 /* Fire the retrorockets and shoot the fruiton torpedoes, sir! */
1844
1845 ASSERT(if (!node) {
1846 printk("jffs_write_node(): node == NULL\n");
1847 return -EINVAL;
1848 });
1849 ASSERT(if (raw_inode && raw_inode->nsize && !name) {
1850 printk("*** jffs_write_node(): nsize = %u but name == NULL\n",
1851 raw_inode->nsize);
1852 return -EINVAL;
1853 });
1854
1855 D1(printk("jffs_write_node(): filename = \"%s\", ino = %u, "
1856 "total_size = %u\n",
1857 (name ? name : ""), raw_inode->ino,
1858 total_size));
1859
1860 jffs_fm_write_lock(fmc);
1861
1862 retry:
1863 fm = NULL;
1864 err = 0;
1865 while (!fm) {
1866
1867 /* Deadlocks suck. */
1868 while(fmc->free_size < fmc->min_free_size + total_size + slack) {
1869 jffs_fm_write_unlock(fmc);
1870 if (!JFFS_ENOUGH_SPACE(c, total_size + slack))
1871 return -ENOSPC;
1872 jffs_fm_write_lock(fmc);
1873 }
1874
1875 /* First try to allocate some flash memory. */
1876 err = jffs_fmalloc(fmc, total_size, node, &fm);
1877
1878 if (err == -ENOSPC) {
1879 /* Just out of space. GC and try again */
1880 if (fmc->dirty_size < fmc->sector_size) {
1881 D(printk("jffs_write_node(): jffs_fmalloc(0x%p, %u) "
1882 "failed, no dirty space to GC\n", fmc,
1883 total_size));
1884 return err;
1885 }
1886
1887 D1(printk(KERN_INFO "jffs_write_node(): Calling jffs_garbage_collect_now()\n"));
1888 jffs_fm_write_unlock(fmc);
1889 if ((err = jffs_garbage_collect_now(c))) {
1890 D(printk("jffs_write_node(): jffs_garbage_collect_now() failed\n"));
1891 return err;
1892 }
1893 jffs_fm_write_lock(fmc);
1894 continue;
1895 }
1896
1897 if (err < 0) {
1898 jffs_fm_write_unlock(fmc);
1899
1900 D(printk("jffs_write_node(): jffs_fmalloc(0x%p, %u) "
1901 "failed!\n", fmc, total_size));
1902 return err;
1903 }
1904
1905 if (!fm->nodes) {
1906 /* The jffs_fm struct that we got is not good enough.
1907 Make that space dirty and try again */
1908 if ((err = jffs_write_dummy_node(c, fm)) < 0) {
1909 kfree(fm);
1910 DJM(no_jffs_fm--);
1911 jffs_fm_write_unlock(fmc);
1912 D(printk("jffs_write_node(): "
1913 "jffs_write_dummy_node(): Failed!\n"));
1914 return err;
1915 }
1916 fm = NULL;
1917 }
1918 } /* while(!fm) */
1919 node->fm = fm;
1920
1921 ASSERT(if (fm->nodes == 0) {
1922 printk(KERN_ERR "jffs_write_node(): fm->nodes == 0\n");
1923 });
1924
1925 pos = node->fm->offset;
1926
1927 /* Increment the version number here. We can't let the caller
1928 set it beforehand, because we might have had to do GC on a node
1929 of this file - and we'd end up reusing version numbers.
1930 */
1931 if (f) {
1932 raw_inode->version = f->highest_version + 1;
1933 D1(printk (KERN_NOTICE "jffs_write_node(): setting version of %s to %d\n", f->name, raw_inode->version));
1934
1935 /* if the file was deleted, set the deleted bit in the raw inode */
1936 if (f->deleted)
1937 raw_inode->deleted = 1;
1938 }
1939
1940 /* Compute the checksum for the data and name chunks. */
1941 raw_inode->dchksum = jffs_checksum(data, raw_inode->dsize);
1942 raw_inode->nchksum = jffs_checksum(name, raw_inode->nsize);
1943
1944 /* The checksum is calculated without the chksum and accurate
1945 fields so set them to zero first. */
1946 raw_inode->accurate = 0;
1947 raw_inode->chksum = 0;
1948 raw_inode->chksum = jffs_checksum(raw_inode,
1949 sizeof(struct jffs_raw_inode));
1950 raw_inode->accurate = 0xff;
1951
1952 D3(printk("jffs_write_node(): About to write this raw inode to the "
1953 "flash at pos 0x%lx:\n", (long)pos));
1954 D3(jffs_print_raw_inode(raw_inode));
1955
1956 /* The actual raw JFFS node */
1957 node_iovec[0].iov_base = (void *) raw_inode;
1958 node_iovec[0].iov_len = (size_t) sizeof(struct jffs_raw_inode);
1959 iovec_cnt = 1;
1960
1961 /* Get name and size if there is one */
1962 if (raw_inode->nsize) {
1963 node_iovec[iovec_cnt].iov_base = (void *) name;
1964 node_iovec[iovec_cnt].iov_len = (size_t) raw_inode->nsize;
1965 iovec_cnt++;
1966
1967 if (JFFS_GET_PAD_BYTES(raw_inode->nsize)) {
1968 static unsigned char allff[3]={255,255,255};
1969 /* Add some extra padding if necessary */
1970 node_iovec[iovec_cnt].iov_base = allff;
1971 node_iovec[iovec_cnt].iov_len =
1972 JFFS_GET_PAD_BYTES(raw_inode->nsize);
1973 iovec_cnt++;
1974 }
1975 }
1976
1977 /* Get data and size if there is any */
1978 if (raw_inode->dsize) {
1979 node_iovec[iovec_cnt].iov_base = (void *) data;
1980 node_iovec[iovec_cnt].iov_len = (size_t) raw_inode->dsize;
1981 iovec_cnt++;
1982 /* No need to pad this because we're not actually putting
1983 anything after it.
1984 */
1985 }
1986
1987 if ((err = flash_safe_writev(fmc->mtd, node_iovec, iovec_cnt,
1988 pos)) < 0) {
1989 jffs_fmfree_partly(fmc, fm, 0);
1990 jffs_fm_write_unlock(fmc);
1991 printk(KERN_ERR "JFFS: jffs_write_node: Failed to write, "
1992 "requested %i, wrote %i\n", total_size, err);
1993 goto retry;
1994 }
1995 if (raw_inode->deleted)
1996 f->deleted = 1;
1997
1998 jffs_fm_write_unlock(fmc);
1999 D3(printk("jffs_write_node(): Leaving...\n"));
2000 return raw_inode->dsize;
2001 } /* jffs_write_node() */
2002
2003
2004 /* Read data from the node and write it to the buffer. 'node_offset'
2005 is how much we have read from this particular node before and which
2006 shouldn't be read again. 'max_size' is how much space there is in
2007 the buffer. */
2008 static int
2009 jffs_get_node_data(struct jffs_file *f, struct jffs_node *node,
2010 unsigned char *buf,__u32 node_offset, __u32 max_size)
2011 {
2012 struct jffs_fmcontrol *fmc = f->c->fmc;
2013 __u32 pos = node->fm->offset + node->fm_offset + node_offset;
2014 __u32 avail = node->data_size - node_offset;
2015 __u32 r;
2016
2017 D2(printk(" jffs_get_node_data(): file: \"%s\", ino: %u, "
2018 "version: %u, node_offset: %u\n",
2019 f->name, node->ino, node->version, node_offset));
2020
2021 r = min(avail, max_size);
2022 D3(printk(KERN_NOTICE "jffs_get_node_data\n"));
2023 flash_safe_read(fmc->mtd, pos, buf, r);
2024
2025 D3(printk(" jffs_get_node_data(): Read %u byte%s.\n",
2026 r, (r == 1 ? "" : "s")));
2027
2028 return r;
2029 }
2030
2031
2032 /* Read data from the file's nodes. Write the data to the buffer
2033 'buf'. 'read_offset' tells how much data we should skip. */
2034 int
2035 jffs_read_data(struct jffs_file *f, unsigned char *buf, __u32 read_offset,
2036 __u32 size)
2037 {
2038 struct jffs_node *node;
2039 __u32 read_data = 0; /* Total amount of read data. */
2040 __u32 node_offset = 0;
2041 __u32 pos = 0; /* Number of bytes traversed. */
2042
2043 D2(printk("jffs_read_data(): file = \"%s\", read_offset = %d, "
2044 "size = %u\n",
2045 (f->name ? f->name : ""), read_offset, size));
2046
2047 if (read_offset >= f->size) {
2048 D(printk(" f->size: %d\n", f->size));
2049 return 0;
2050 }
2051
2052 /* First find the node to read data from. */
2053 node = f->range_head;
2054 while (pos <= read_offset) {
2055 node_offset = read_offset - pos;
2056 if (node_offset >= node->data_size) {
2057 pos += node->data_size;
2058 node = node->range_next;
2059 }
2060 else {
2061 break;
2062 }
2063 }
2064
2065 /* "Cats are living proof that not everything in nature
2066 has to be useful."
2067 - Garrison Keilor ('97) */
2068
2069 /* Fill the buffer. */
2070 while (node && (read_data < size)) {
2071 int r;
2072 if (!node->fm) {
2073 /* This node does not refer to real data. */
2074 r = min(size - read_data,
2075 node->data_size - node_offset);
2076 memset(&buf[read_data], 0, r);
2077 }
2078 else if ((r = jffs_get_node_data(f, node, &buf[read_data],
2079 node_offset,
2080 size - read_data)) < 0) {
2081 return r;
2082 }
2083 read_data += r;
2084 node_offset = 0;
2085 node = node->range_next;
2086 }
2087 D3(printk(" jffs_read_data(): Read %u bytes.\n", read_data));
2088 return read_data;
2089 }
2090
2091
2092 /* Used for traversing all nodes in the hash table. */
2093 int
2094 jffs_foreach_file(struct jffs_control *c, int (*func)(struct jffs_file *))
2095 {
2096 int pos;
2097 int r;
2098 int result = 0;
2099
2100 for (pos = 0; pos < c->hash_len; pos++) {
2101 struct jffs_file *f, *next;
2102
2103 /* We must do _safe, because 'func' might remove the
2104 current file 'f' from the list. */
2105 list_for_each_entry_safe(f, next, &c->hash[pos], hash) {
2106 r = func(f);
2107 if (r < 0)
2108 return r;
2109 result += r;
2110 }
2111 }
2112
2113 return result;
2114 }
2115
2116
2117 /* Free all nodes associated with a file. */
2118 static int
2119 jffs_free_node_list(struct jffs_file *f)
2120 {
2121 struct jffs_node *node;
2122 struct jffs_node *p;
2123
2124 D3(printk("jffs_free_node_list(): f #%u, \"%s\"\n",
2125 f->ino, (f->name ? f->name : "")));
2126 node = f->version_head;
2127 while (node) {
2128 p = node;
2129 node = node->version_next;
2130 jffs_free_node(p);
2131 DJM(no_jffs_node--);
2132 }
2133 return 0;
2134 }
2135
2136
2137 /* Free a file and its name. */
2138 static int
2139 jffs_free_file(struct jffs_file *f)
2140 {
2141 D3(printk("jffs_free_file: f #%u, \"%s\"\n",
2142 f->ino, (f->name ? f->name : "")));
2143
2144 if (f->name) {
2145 kfree(f->name);
2146 DJM(no_name--);
2147 }
2148 kfree(f);
2149 no_jffs_file--;
2150 return 0;
2151 }
2152
2153 static long
2154 jffs_get_file_count(void)
2155 {
2156 return no_jffs_file;
2157 }
2158
2159 /* See if a file is deleted. If so, mark that file's nodes as obsolete. */
2160 int
2161 jffs_possibly_delete_file(struct jffs_file *f)
2162 {
2163 struct jffs_node *n;
2164
2165 D3(printk("jffs_possibly_delete_file(): ino: %u\n",
2166 f->ino));
2167
2168 ASSERT(if (!f) {
2169 printk(KERN_ERR "jffs_possibly_delete_file(): f == NULL\n");
2170 return -1;
2171 });
2172
2173 if (f->deleted) {
2174 /* First try to remove all older versions. Commence with
2175 the oldest node. */
2176 for (n = f->version_head; n; n = n->version_next) {
2177 if (!n->fm) {
2178 continue;
2179 }
2180 if (jffs_fmfree(f->c->fmc, n->fm, n) < 0) {
2181 break;
2182 }
2183 }
2184 /* Unlink the file from the filesystem. */
2185 if (!f->c->building_fs) {
2186 jffs_unlink_file_from_tree(f);
2187 }
2188 jffs_unlink_file_from_hash(f);
2189 jffs_free_node_list(f);
2190 jffs_free_file(f);
2191 }
2192 return 0;
2193 }
2194
2195
2196 /* Used in conjunction with jffs_foreach_file() to count the number
2197 of files in the file system. */
2198 int
2199 jffs_file_count(struct jffs_file *f)
2200 {
2201 return 1;
2202 }
2203
2204
2205 /* Build up a file's range list from scratch by going through the
2206 version list. */
2207 static int
2208 jffs_build_file(struct jffs_file *f)
2209 {
2210 struct jffs_node *n;
2211
2212 D3(printk("jffs_build_file(): ino: %u, name: \"%s\"\n",
2213 f->ino, (f->name ? f->name : "")));
2214
2215 for (n = f->version_head; n; n = n->version_next) {
2216 jffs_update_file(f, n);
2217 }
2218 return 0;
2219 }
2220
2221
2222 /* Remove an amount of data from a file. If this amount of data is
2223 zero, that could mean that a node should be split in two parts.
2224 We remove or change the appropriate nodes in the lists.
2225
2226 Starting offset of area to be removed is node->data_offset,
2227 and the length of the area is in node->removed_size. */
2228 static int
2229 jffs_delete_data(struct jffs_file *f, struct jffs_node *node)
2230 {
2231 struct jffs_node *n;
2232 __u32 offset = node->data_offset;
2233 __u32 remove_size = node->removed_size;
2234
2235 D3(printk("jffs_delete_data(): offset = %u, remove_size = %u\n",
2236 offset, remove_size));
2237
2238 if (remove_size == 0
2239 && f->range_tail
2240 && f->range_tail->data_offset + f->range_tail->data_size
2241 == offset) {
2242 /* A simple append; nothing to remove or no node to split. */
2243 return 0;
2244 }
2245
2246 /* Find the node where we should begin the removal. */
2247 for (n = f->range_head; n; n = n->range_next) {
2248 if (n->data_offset + n->data_size > offset) {
2249 break;
2250 }
2251 }
2252 if (!n) {
2253 /* If there's no data in the file there's no data to
2254 remove either. */
2255 return 0;
2256 }
2257
2258 if (n->data_offset > offset) {
2259 /* XXX: Not implemented yet. */
2260 printk(KERN_WARNING "JFFS: An unexpected situation "
2261 "occurred in jffs_delete_data.\n");
2262 }
2263 else if (n->data_offset < offset) {
2264 /* See if the node has to be split into two parts. */
2265 if (n->data_offset + n->data_size > offset + remove_size) {
2266 /* Do the split. */
2267 struct jffs_node *new_node;
2268 D3(printk("jffs_delete_data(): Split node with "
2269 "version number %u.\n", n->version));
2270
2271 if (!(new_node = jffs_alloc_node())) {
2272 D(printk("jffs_delete_data(): -ENOMEM\n"));
2273 return -ENOMEM;
2274 }
2275 DJM(no_jffs_node++);
2276
2277 new_node->ino = n->ino;
2278 new_node->version = n->version;
2279 new_node->data_offset = offset;
2280 new_node->data_size = n->data_size - (remove_size + (offset - n->data_offset));
2281 new_node->fm_offset = n->fm_offset + (remove_size + (offset - n->data_offset));
2282 new_node->name_size = n->name_size;
2283 new_node->fm = n->fm;
2284 new_node->version_prev = n;
2285 new_node->version_next = n->version_next;
2286 if (new_node->version_next) {
2287 new_node->version_next->version_prev
2288 = new_node;
2289 }
2290 else {
2291 f->version_tail = new_node;
2292 }
2293 n->version_next = new_node;
2294 new_node->range_prev = n;
2295 new_node->range_next = n->range_next;
2296 if (new_node->range_next) {
2297 new_node->range_next->range_prev = new_node;
2298 }
2299 else {
2300 f->range_tail = new_node;
2301 }
2302 /* A very interesting can of worms. */
2303 n->range_next = new_node;
2304 n->data_size = offset - n->data_offset;
2305 if (new_node->fm)
2306 jffs_add_node(new_node);
2307 else {
2308 D1(printk(KERN_WARNING "jffs_delete_data(): Splitting an empty node (file hold).\n!"));
2309 D1(printk(KERN_WARNING "FIXME: Did dwmw2 do the right thing here?\n"));
2310 }
2311 n = new_node->range_next;
2312 remove_size = 0;
2313 }
2314 else {
2315 /* No. No need to split the node. Just remove
2316 the end of the node. */
2317 int r = min(n->data_offset + n->data_size
2318 - offset, remove_size);
2319 n->data_size -= r;
2320 remove_size -= r;
2321 n = n->range_next;
2322 }
2323 }
2324
2325 /* Remove as many nodes as necessary. */
2326 while (n && remove_size) {
2327 if (n->data_size <= remove_size) {
2328 struct jffs_node *p = n;
2329 remove_size -= n->data_size;
2330 n = n->range_next;
2331 D3(printk("jffs_delete_data(): Removing node: "
2332 "ino: %u, version: %u%s\n",
2333 p->ino, p->version,
2334 (p->fm ? "" : " (virtual)")));
2335 if (p->fm) {
2336 jffs_fmfree(f->c->fmc, p->fm, p);
2337 }
2338 jffs_unlink_node_from_range_list(f, p);
2339 jffs_unlink_node_from_version_list(f, p);
2340 jffs_free_node(p);
2341 DJM(no_jffs_node--);
2342 }
2343 else {
2344 n->data_size -= remove_size;
2345 n->fm_offset += remove_size;
2346 n->data_offset -= (node->removed_size - remove_size);
2347 n = n->range_next;
2348 break;
2349 }
2350 }
2351
2352 /* Adjust the following nodes' information about offsets etc. */
2353 while (n && node->removed_size) {
2354 n->data_offset -= node->removed_size;
2355 n = n->range_next;
2356 }
2357
2358 if (node->removed_size > (f->size - node->data_offset)) {
2359 /* It's possible that the removed_size is in fact
2360 * greater than the amount of data we actually thought
2361 * were present in the first place - some of the nodes
2362 * which this node originally obsoleted may already have
2363 * been deleted from the flash by subsequent garbage
2364 * collection.
2365 *
2366 * If this is the case, don't let f->size go negative.
2367 * Bad things would happen :)
2368 */
2369 f->size = node->data_offset;
2370 } else {
2371 f->size -= node->removed_size;
2372 }
2373 D3(printk("jffs_delete_data(): f->size = %d\n", f->size));
2374 return 0;
2375 } /* jffs_delete_data() */
2376
2377
2378 /* Insert some data into a file. Prior to the call to this function,
2379 jffs_delete_data should be called. */
2380 static int
2381 jffs_insert_data(struct jffs_file *f, struct jffs_node *node)
2382 {
2383 D3(printk("jffs_insert_data(): node->data_offset = %u, "
2384 "node->data_size = %u, f->size = %u\n",
2385 node->data_offset, node->data_size, f->size));
2386
2387 /* Find the position where we should insert data. */
2388 retry:
2389 if (node->data_offset == f->size) {
2390 /* A simple append. This is the most common operation. */
2391 node->range_next = NULL;
2392 node->range_prev = f->range_tail;
2393 if (node->range_prev) {
2394 node->range_prev->range_next = node;
2395 }
2396 f->range_tail = node;
2397 f->size += node->data_size;
2398 if (!f->range_head) {
2399 f->range_head = node;
2400 }
2401 }
2402 else if (node->data_offset < f->size) {
2403 /* Trying to insert data into the middle of the file. This
2404 means no problem because jffs_delete_data() has already
2405 prepared the range list for us. */
2406 struct jffs_node *n;
2407
2408 /* Find the correct place for the insertion and then insert
2409 the node. */
2410 for (n = f->range_head; n; n = n->range_next) {
2411 D2(printk("Cool stuff's happening!\n"));
2412
2413 if (n->data_offset == node->data_offset) {
2414 node->range_prev = n->range_prev;
2415 if (node->range_prev) {
2416 node->range_prev->range_next = node;
2417 }
2418 else {
2419 f->range_head = node;
2420 }
2421 node->range_next = n;
2422 n->range_prev = node;
2423 break;
2424 }
2425 ASSERT(else if (n->data_offset + n->data_size >
2426 node->data_offset) {
2427 printk(KERN_ERR "jffs_insert_data(): "
2428 "Couldn't find a place to insert "
2429 "the data!\n");
2430 return -1;
2431 });
2432 }
2433
2434 /* Adjust later nodes' offsets etc. */
2435 n = node->range_next;
2436 while (n) {
2437 n->data_offset += node->data_size;
2438 n = n->range_next;
2439 }
2440 f->size += node->data_size;
2441 }
2442 else if (node->data_offset > f->size) {
2443 /* Okay. This is tricky. This means that we want to insert
2444 data at a place that is beyond the limits of the file as
2445 it is constructed right now. This is actually a common
2446 event that for instance could occur during the mounting
2447 of the file system if a large file have been truncated,
2448 rewritten and then only partially garbage collected. */
2449
2450 struct jffs_node *n;
2451
2452 /* We need a place holder for the data that is missing in
2453 front of this insertion. This "virtual node" will not
2454 be associated with any space on the flash device. */
2455 struct jffs_node *virtual_node;
2456 if (!(virtual_node = jffs_alloc_node())) {
2457 return -ENOMEM;
2458 }
2459
2460 D(printk("jffs_insert_data: Inserting a virtual node.\n"));
2461 D(printk(" node->data_offset = %u\n", node->data_offset));
2462 D(printk(" f->size = %u\n", f->size));
2463
2464 virtual_node->ino = node->ino;
2465 virtual_node->version = node->version;
2466 virtual_node->removed_size = 0;
2467 virtual_node->fm_offset = 0;
2468 virtual_node->name_size = 0;
2469 virtual_node->fm = NULL; /* This is a virtual data holder. */
2470 virtual_node->version_prev = NULL;
2471 virtual_node->version_next = NULL;
2472 virtual_node->range_next = NULL;
2473
2474 /* Are there any data at all in the file yet? */
2475 if (f->range_head) {
2476 virtual_node->data_offset
2477 = f->range_tail->data_offset
2478 + f->range_tail->data_size;
2479 virtual_node->data_size
2480 = node->data_offset - virtual_node->data_offset;
2481 virtual_node->range_prev = f->range_tail;
2482 f->range_tail->range_next = virtual_node;
2483 }
2484 else {
2485 virtual_node->data_offset = 0;
2486 virtual_node->data_size = node->data_offset;
2487 virtual_node->range_prev = NULL;
2488 f->range_head = virtual_node;
2489 }
2490
2491 f->range_tail = virtual_node;
2492 f->size += virtual_node->data_size;
2493
2494 /* Insert this virtual node in the version list as well. */
2495 for (n = f->version_head; n ; n = n->version_next) {
2496 if (n->version == virtual_node->version) {
2497 virtual_node->version_prev = n->version_prev;
2498 n->version_prev = virtual_node;
2499 if (virtual_node->version_prev) {
2500 virtual_node->version_prev
2501 ->version_next = virtual_node;
2502 }
2503 else {
2504 f->version_head = virtual_node;
2505 }
2506 virtual_node->version_next = n;
2507 break;
2508 }
2509 }
2510
2511 D(jffs_print_node(virtual_node));
2512
2513 /* Make a new try to insert the node. */
2514 goto retry;
2515 }
2516
2517 D3(printk("jffs_insert_data(): f->size = %d\n", f->size));
2518 return 0;
2519 }
2520
2521
2522 /* A new node (with data) has been added to the file and now the range
2523 list has to be modified. */
2524 static int
2525 jffs_update_file(struct jffs_file *f, struct jffs_node *node)
2526 {
2527 int err;
2528
2529 D3(printk("jffs_update_file(): ino: %u, version: %u\n",
2530 f->ino, node->version));
2531
2532 if (node->data_size == 0) {
2533 if (node->removed_size == 0) {
2534 /* data_offset == X */
2535 /* data_size == 0 */
2536 /* remove_size == 0 */
2537 }
2538 else {
2539 /* data_offset == X */
2540 /* data_size == 0 */
2541 /* remove_size != 0 */
2542 if ((err = jffs_delete_data(f, node)) < 0) {
2543 return err;
2544 }
2545 }
2546 }
2547 else {
2548 /* data_offset == X */
2549 /* data_size != 0 */
2550 /* remove_size == Y */
2551 if ((err = jffs_delete_data(f, node)) < 0) {
2552 return err;
2553 }
2554 if ((err = jffs_insert_data(f, node)) < 0) {
2555 return err;
2556 }
2557 }
2558 return 0;
2559 }
2560
2561 /* Print the contents of a file. */
2562 #if 0
2563 int
2564 jffs_print_file(struct jffs_file *f)
2565 {
2566 D(int i);
2567 D(printk("jffs_file: 0x%p\n", f));
2568 D(printk("{\n"));
2569 D(printk(" 0x%08x, /* ino */\n", f->ino));
2570 D(printk(" 0x%08x, /* pino */\n", f->pino));
2571 D(printk(" 0x%08x, /* mode */\n", f->mode));
2572 D(printk(" 0x%04x, /* uid */\n", f->uid));
2573 D(printk(" 0x%04x, /* gid */\n", f->gid));
2574 D(printk(" 0x%08x, /* atime */\n", f->atime));
2575 D(printk(" 0x%08x, /* mtime */\n", f->mtime));
2576 D(printk(" 0x%08x, /* ctime */\n", f->ctime));
2577 D(printk(" 0x%02x, /* nsize */\n", f->nsize));
2578 D(printk(" 0x%02x, /* nlink */\n", f->nlink));
2579 D(printk(" 0x%02x, /* deleted */\n", f->deleted));
2580 D(printk(" \"%s\", ", (f->name ? f->name : "")));
2581 D(for (i = strlen(f->name ? f->name : ""); i < 8; ++i) {
2582 printk(" ");
2583 });
2584 D(printk("/* name */\n"));
2585 D(printk(" 0x%08x, /* size */\n", f->size));
2586 D(printk(" 0x%08x, /* highest_version */\n",
2587 f->highest_version));
2588 D(printk(" 0x%p, /* c */\n", f->c));
2589 D(printk(" 0x%p, /* parent */\n", f->parent));
2590 D(printk(" 0x%p, /* children */\n", f->children));
2591 D(printk(" 0x%p, /* sibling_prev */\n", f->sibling_prev));
2592 D(printk(" 0x%p, /* sibling_next */\n", f->sibling_next));
2593 D(printk(" 0x%p, /* hash_prev */\n", f->hash.prev));
2594 D(printk(" 0x%p, /* hash_next */\n", f->hash.next));
2595 D(printk(" 0x%p, /* range_head */\n", f->range_head));
2596 D(printk(" 0x%p, /* range_tail */\n", f->range_tail));
2597 D(printk(" 0x%p, /* version_head */\n", f->version_head));
2598 D(printk(" 0x%p, /* version_tail */\n", f->version_tail));
2599 D(printk("}\n"));
2600 return 0;
2601 }
2602 #endif /* 0 */
2603
2604 void
2605 jffs_print_hash_table(struct jffs_control *c)
2606 {
2607 int i;
2608
2609 printk("JFFS: Dumping the file system's hash table...\n");
2610 for (i = 0; i < c->hash_len; i++) {
2611 struct jffs_file *f;
2612 list_for_each_entry(f, &c->hash[i], hash) {
2613 printk("*** c->hash[%u]: \"%s\" "
2614 "(ino: %u, pino: %u)\n",
2615 i, (f->name ? f->name : ""),
2616 f->ino, f->pino);
2617 }
2618 }
2619 }
2620
2621
2622 void
2623 jffs_print_tree(struct jffs_file *first_file, int indent)
2624 {
2625 struct jffs_file *f;
2626 char *space;
2627 int dir;
2628
2629 if (!first_file) {
2630 return;
2631 }
2632
2633 if (!(space = (char *) kmalloc(indent + 1, GFP_KERNEL))) {
2634 printk("jffs_print_tree(): Out of memory!\n");
2635 return;
2636 }
2637
2638 memset(space, ' ', indent);
2639 space[indent] = '\0';
2640
2641 for (f = first_file; f; f = f->sibling_next) {
2642 dir = S_ISDIR(f->mode);
2643 printk("%s%s%s (ino: %u, highest_version: %u, size: %u)\n",
2644 space, (f->name ? f->name : ""), (dir ? "/" : ""),
2645 f->ino, f->highest_version, f->size);
2646 if (dir) {
2647 jffs_print_tree(f->children, indent + 2);
2648 }
2649 }
2650
2651 kfree(space);
2652 }
2653
2654
2655 #if defined(JFFS_MEMORY_DEBUG) && JFFS_MEMORY_DEBUG
2656 void
2657 jffs_print_memory_allocation_statistics(void)
2658 {
2659 static long printout;
2660 printk("________ Memory printout #%ld ________\n", ++printout);
2661 printk("no_jffs_file = %ld\n", no_jffs_file);
2662 printk("no_jffs_node = %ld\n", no_jffs_node);
2663 printk("no_jffs_control = %ld\n", no_jffs_control);
2664 printk("no_jffs_raw_inode = %ld\n", no_jffs_raw_inode);
2665 printk("no_jffs_node_ref = %ld\n", no_jffs_node_ref);
2666 printk("no_jffs_fm = %ld\n", no_jffs_fm);
2667 printk("no_jffs_fmcontrol = %ld\n", no_jffs_fmcontrol);
2668 printk("no_hash = %ld\n", no_hash);
2669 printk("no_name = %ld\n", no_name);
2670 printk("\n");
2671 }
2672 #endif
2673
2674
2675 /* Rewrite `size' bytes, and begin at `node'. */
2676 static int
2677 jffs_rewrite_data(struct jffs_file *f, struct jffs_node *node, __u32 size)
2678 {
2679 struct jffs_control *c = f->c;
2680 struct jffs_fmcontrol *fmc = c->fmc;
2681 struct jffs_raw_inode raw_inode;
2682 struct jffs_node *new_node;
2683 struct jffs_fm *fm;
2684 __u32 pos;
2685 __u32 pos_dchksum;
2686 __u32 total_name_size;
2687 __u32 total_data_size;
2688 __u32 total_size;
2689 int err;
2690
2691 D1(printk("***jffs_rewrite_data(): node: %u, name: \"%s\", size: %u\n",
2692 f->ino, (f->name ? f->name : "(null)"), size));
2693
2694 /* Create and initialize the new node. */
2695 if (!(new_node = jffs_alloc_node())) {
2696 D(printk("jffs_rewrite_data(): "
2697 "Failed to allocate node.\n"));
2698 return -ENOMEM;
2699 }
2700 DJM(no_jffs_node++);
2701 new_node->data_offset = node->data_offset;
2702 new_node->removed_size = size;
2703 total_name_size = JFFS_PAD(f->nsize);
2704 total_data_size = JFFS_PAD(size);
2705 total_size = sizeof(struct jffs_raw_inode)
2706 + total_name_size + total_data_size;
2707 new_node->fm_offset = sizeof(struct jffs_raw_inode)
2708 + total_name_size;
2709
2710 retry:
2711 jffs_fm_write_lock(fmc);
2712 err = 0;
2713
2714 if ((err = jffs_fmalloc(fmc, total_size, new_node, &fm)) < 0) {
2715 DJM(no_jffs_node--);
2716 jffs_fm_write_unlock(fmc);
2717 D(printk("jffs_rewrite_data(): Failed to allocate fm.\n"));
2718 jffs_free_node(new_node);
2719 return err;
2720 }
2721 else if (!fm->nodes) {
2722 /* The jffs_fm struct that we got is not big enough. */
2723 /* This should never happen, because we deal with this case
2724 in jffs_garbage_collect_next().*/
2725 printk(KERN_WARNING "jffs_rewrite_data(): Allocated node is too small (%d bytes of %d)\n", fm->size, total_size);
2726 if ((err = jffs_write_dummy_node(c, fm)) < 0) {
2727 D(printk("jffs_rewrite_data(): "
2728 "jffs_write_dummy_node() Failed!\n"));
2729 } else {
2730 err = -ENOSPC;
2731 }
2732 DJM(no_jffs_fm--);
2733 jffs_fm_write_unlock(fmc);
2734 kfree(fm);
2735
2736 return err;
2737 }
2738 new_node->fm = fm;
2739
2740 /* Initialize the raw inode. */
2741 raw_inode.magic = JFFS_MAGIC_BITMASK;
2742 raw_inode.ino = f->ino;
2743 raw_inode.pino = f->pino;
2744 raw_inode.version = f->highest_version + 1;
2745 raw_inode.mode = f->mode;
2746 raw_inode.uid = f->uid;
2747 raw_inode.gid = f->gid;
2748 raw_inode.atime = f->atime;
2749 raw_inode.mtime = f->mtime;
2750 raw_inode.ctime = f->ctime;
2751 raw_inode.offset = node->data_offset;
2752 raw_inode.dsize = size;
2753 raw_inode.rsize = size;
2754 raw_inode.nsize = f->nsize;
2755 raw_inode.nlink = f->nlink;
2756 raw_inode.spare = 0;
2757 raw_inode.rename = 0;
2758 raw_inode.deleted = f->deleted;
2759 raw_inode.accurate = 0xff;
2760 raw_inode.dchksum = 0;
2761 raw_inode.nchksum = 0;
2762
2763 pos = new_node->fm->offset;
2764 pos_dchksum = pos +JFFS_RAW_INODE_DCHKSUM_OFFSET;
2765
2766 D3(printk("jffs_rewrite_data(): Writing this raw inode "
2767 "to pos 0x%ul.\n", pos));
2768 D3(jffs_print_raw_inode(&raw_inode));
2769
2770 if ((err = flash_safe_write(fmc->mtd, pos,
2771 (u_char *) &raw_inode,
2772 sizeof(struct jffs_raw_inode)
2773 - sizeof(__u32)
2774 - sizeof(__u16) - sizeof(__u16))) < 0) {
2775 jffs_fmfree_partly(fmc, fm,
2776 total_name_size + total_data_size);
2777 jffs_fm_write_unlock(fmc);
2778 printk(KERN_ERR "JFFS: jffs_rewrite_data: Write error during "
2779 "rewrite. (raw inode)\n");
2780 printk(KERN_ERR "JFFS: jffs_rewrite_data: Now retrying "
2781 "rewrite. (raw inode)\n");
2782 goto retry;
2783 }
2784 pos += sizeof(struct jffs_raw_inode);
2785
2786 /* Write the name to the flash memory. */
2787 if (f->nsize) {
2788 D3(printk("jffs_rewrite_data(): Writing name \"%s\" to "
2789 "pos 0x%ul.\n", f->name, (unsigned int) pos));
2790 if ((err = flash_safe_write(fmc->mtd, pos,
2791 (u_char *)f->name,
2792 f->nsize)) < 0) {
2793 jffs_fmfree_partly(fmc, fm, total_data_size);
2794 jffs_fm_write_unlock(fmc);
2795 printk(KERN_ERR "JFFS: jffs_rewrite_data: Write "
2796 "error during rewrite. (name)\n");
2797 printk(KERN_ERR "JFFS: jffs_rewrite_data: Now retrying "
2798 "rewrite. (name)\n");
2799 goto retry;
2800 }
2801 pos += total_name_size;
2802 raw_inode.nchksum = jffs_checksum(f->name, f->nsize);
2803 }
2804
2805 /* Write the data. */
2806 if (size) {
2807 int r;
2808 unsigned char *page;
2809 __u32 offset = node->data_offset;
2810
2811 if (!(page = (unsigned char *)__get_free_page(GFP_KERNEL))) {
2812 jffs_fmfree_partly(fmc, fm, 0);
2813 return -1;
2814 }
2815
2816 while (size) {
2817 __u32 s = min(size, (__u32)PAGE_SIZE);
2818 if ((r = jffs_read_data(f, (char *)page,
2819 offset, s)) < s) {
2820 free_page((unsigned long)page);
2821 jffs_fmfree_partly(fmc, fm, 0);
2822 jffs_fm_write_unlock(fmc);
2823 printk(KERN_ERR "JFFS: jffs_rewrite_data: "
2824 "jffs_read_data() "
2825 "failed! (r = %d)\n", r);
2826 return -1;
2827 }
2828 if ((err = flash_safe_write(fmc->mtd,
2829 pos, page, r)) < 0) {
2830 free_page((unsigned long)page);
2831 jffs_fmfree_partly(fmc, fm, 0);
2832 jffs_fm_write_unlock(fmc);
2833 printk(KERN_ERR "JFFS: jffs_rewrite_data: "
2834 "Write error during rewrite. "
2835 "(data)\n");
2836 goto retry;
2837 }
2838 pos += r;
2839 size -= r;
2840 offset += r;
2841 raw_inode.dchksum += jffs_checksum(page, r);
2842 }
2843
2844 free_page((unsigned long)page);
2845 }
2846
2847 raw_inode.accurate = 0;
2848 raw_inode.chksum = jffs_checksum(&raw_inode,
2849 sizeof(struct jffs_raw_inode)
2850 - sizeof(__u16));
2851
2852 /* Add the checksum. */
2853 if ((err
2854 = flash_safe_write(fmc->mtd, pos_dchksum,
2855 &((u_char *)
2856 &raw_inode)[JFFS_RAW_INODE_DCHKSUM_OFFSET],
2857 sizeof(__u32) + sizeof(__u16)
2858 + sizeof(__u16))) < 0) {
2859 jffs_fmfree_partly(fmc, fm, 0);
2860 jffs_fm_write_unlock(fmc);
2861 printk(KERN_ERR "JFFS: jffs_rewrite_data: Write error during "
2862 "rewrite. (checksum)\n");
2863 goto retry;
2864 }
2865
2866 /* Now make the file system aware of the newly written node. */
2867 jffs_insert_node(c, f, &raw_inode, f->name, new_node);
2868 jffs_fm_write_unlock(fmc);
2869
2870 D3(printk("jffs_rewrite_data(): Leaving...\n"));
2871 return 0;
2872 } /* jffs_rewrite_data() */
2873
2874
2875 /* jffs_garbage_collect_next implements one step in the garbage collect
2876 process and is often called multiple times at each occasion of a
2877 garbage collect. */
2878
2879 static int
2880 jffs_garbage_collect_next(struct jffs_control *c)
2881 {
2882 struct jffs_fmcontrol *fmc = c->fmc;
2883 struct jffs_node *node;
2884 struct jffs_file *f;
2885 int err = 0;
2886 __u32 size;
2887 __u32 data_size;
2888 __u32 total_name_size;
2889 __u32 extra_available;
2890 __u32 space_needed;
2891 __u32 free_chunk_size1 = jffs_free_size1(fmc);
2892 D2(__u32 free_chunk_size2 = jffs_free_size2(fmc));
2893
2894 /* Get the oldest node in the flash. */
2895 node = jffs_get_oldest_node(fmc);
2896 ASSERT(if (!node) {
2897 printk(KERN_ERR "JFFS: jffs_garbage_collect_next: "
2898 "No oldest node found!\n");
2899 err = -1;
2900 goto jffs_garbage_collect_next_end;
2901
2902
2903 });
2904
2905 /* Find its corresponding file too. */
2906 f = jffs_find_file(c, node->ino);
2907
2908 if (!f) {
2909 printk (KERN_ERR "JFFS: jffs_garbage_collect_next: "
2910 "No file to garbage collect! "
2911 "(ino = 0x%08x)\n", node->ino);
2912 /* FIXME: Free the offending node and recover. */
2913 err = -1;
2914 goto jffs_garbage_collect_next_end;
2915 }
2916
2917 /* We always write out the name. Theoretically, we don't need
2918 to, but for now it's easier - because otherwise we'd have
2919 to keep track of how many times the current name exists on
2920 the flash and make sure it never reaches zero.
2921
2922 The current approach means that would be possible to cause
2923 the GC to end up eating its tail by writing lots of nodes
2924 with no name for it to garbage-collect. Hence the change in
2925 inode.c to write names with _every_ node.
2926
2927 It sucks, but it _should_ work.
2928 */
2929 total_name_size = JFFS_PAD(f->nsize);
2930
2931 D1(printk("jffs_garbage_collect_next(): \"%s\", "
2932 "ino: %u, version: %u, location 0x%x, dsize %u\n",
2933 (f->name ? f->name : ""), node->ino, node->version,
2934 node->fm->offset, node->data_size));
2935
2936 /* Compute how many data it's possible to rewrite at the moment. */
2937 data_size = f->size - node->data_offset;
2938
2939 /* And from that, the total size of the chunk we want to write */
2940 size = sizeof(struct jffs_raw_inode) + total_name_size
2941 + data_size + JFFS_GET_PAD_BYTES(data_size);
2942
2943 /* If that's more than max_chunk_size, reduce it accordingly */
2944 if (size > fmc->max_chunk_size) {
2945 size = fmc->max_chunk_size;
2946 data_size = size - sizeof(struct jffs_raw_inode)
2947 - total_name_size;
2948 }
2949
2950 /* If we're asking to take up more space than free_chunk_size1
2951 but we _could_ fit in it, shrink accordingly.
2952 */
2953 if (size > free_chunk_size1) {
2954
2955 if (free_chunk_size1 <
2956 (sizeof(struct jffs_raw_inode) + total_name_size + BLOCK_SIZE)){
2957 /* The space left is too small to be of any
2958 use really. */
2959 struct jffs_fm *dirty_fm
2960 = jffs_fmalloced(fmc,
2961 fmc->tail->offset + fmc->tail->size,
2962 free_chunk_size1, NULL);
2963 if (!dirty_fm) {
2964 printk(KERN_ERR "JFFS: "
2965 "jffs_garbage_collect_next: "
2966 "Failed to allocate `dirty' "
2967 "flash memory!\n");
2968 err = -1;
2969 goto jffs_garbage_collect_next_end;
2970 }
2971 D1(printk("Dirtying end of flash - too small\n"));
2972 jffs_write_dummy_node(c, dirty_fm);
2973 err = 0;
2974 goto jffs_garbage_collect_next_end;
2975 }
2976 D1(printk("Reducing size of new node from %d to %d to avoid "
2977 " exceeding free_chunk_size1\n",
2978 size, free_chunk_size1));
2979
2980 size = free_chunk_size1;
2981 data_size = size - sizeof(struct jffs_raw_inode)
2982 - total_name_size;
2983 }
2984
2985
2986 /* Calculate the amount of space needed to hold the nodes
2987 which are remaining in the tail */
2988 space_needed = fmc->min_free_size - (node->fm->offset % fmc->sector_size);
2989
2990 /* From that, calculate how much 'extra' space we can use to
2991 increase the size of the node we're writing from the size
2992 of the node we're obsoleting
2993 */
2994 if (space_needed > fmc->free_size) {
2995 /* If we've gone below min_free_size for some reason,
2996 don't fuck up. This is why we have
2997 min_free_size > sector_size. Whinge about it though,
2998 just so I can convince myself my maths is right.
2999 */
3000 D1(printk(KERN_WARNING "jffs_garbage_collect_next(): "
3001 "space_needed %d exceeded free_size %d\n",
3002 space_needed, fmc->free_size));
3003 extra_available = 0;
3004 } else {
3005 extra_available = fmc->free_size - space_needed;
3006 }
3007
3008 /* Check that we don't use up any more 'extra' space than
3009 what's available */
3010 if (size > JFFS_PAD(node->data_size) + total_name_size +
3011 sizeof(struct jffs_raw_inode) + extra_available) {
3012 D1(printk("Reducing size of new node from %d to %ld to avoid "
3013 "catching our tail\n", size,
3014 (long) (JFFS_PAD(node->data_size) + JFFS_PAD(node->name_size) +
3015 sizeof(struct jffs_raw_inode) + extra_available)));
3016 D1(printk("space_needed = %d, extra_available = %d\n",
3017 space_needed, extra_available));
3018
3019 size = JFFS_PAD(node->data_size) + total_name_size +
3020 sizeof(struct jffs_raw_inode) + extra_available;
3021 data_size = size - sizeof(struct jffs_raw_inode)
3022 - total_name_size;
3023 };
3024
3025 D2(printk(" total_name_size: %u\n", total_name_size));
3026 D2(printk(" data_size: %u\n", data_size));
3027 D2(printk(" size: %u\n", size));
3028 D2(printk(" f->nsize: %u\n", f->nsize));
3029 D2(printk(" f->size: %u\n", f->size));
3030 D2(printk(" node->data_offset: %u\n", node->data_offset));
3031 D2(printk(" free_chunk_size1: %u\n", free_chunk_size1));
3032 D2(printk(" free_chunk_size2: %u\n", free_chunk_size2));
3033 D2(printk(" node->fm->offset: 0x%08x\n", node->fm->offset));
3034
3035 if ((err = jffs_rewrite_data(f, node, data_size))) {
3036 printk(KERN_WARNING "jffs_rewrite_data() failed: %d\n", err);
3037 return err;
3038 }
3039
3040 jffs_garbage_collect_next_end:
3041 D3(printk("jffs_garbage_collect_next: Leaving...\n"));
3042 return err;
3043 } /* jffs_garbage_collect_next */
3044
3045
3046 /* If an obsolete node is partly going to be erased due to garbage
3047 collection, the part that isn't going to be erased must be filled
3048 with zeroes so that the scan of the flash will work smoothly next
3049 time. (The data in the file could for instance be a JFFS image
3050 which could cause enormous confusion during a scan of the flash
3051 device if we didn't do this.)
3052 There are two phases in this procedure: First, the clearing of
3053 the name and data parts of the node. Second, possibly also clearing
3054 a part of the raw inode as well. If the box is power cycled during
3055 the first phase, only the checksum of this node-to-be-cleared-at-
3056 the-end will be wrong. If the box is power cycled during, or after,
3057 the clearing of the raw inode, the information like the length of
3058 the name and data parts are zeroed. The next time the box is
3059 powered up, the scanning algorithm manages this faulty data too
3060 because:
3061
3062 - The checksum is invalid and thus the raw inode must be discarded
3063 in any case.
3064 - If the lengths of the data part or the name part are zeroed, the
3065 scanning just continues after the raw inode. But after the inode
3066 the scanning procedure just finds zeroes which is the same as
3067 dirt.
3068
3069 So, in the end, this could never fail. :-) Even if it does fail,
3070 the scanning algorithm should manage that too. */
3071
3072 static int
3073 jffs_clear_end_of_node(struct jffs_control *c, __u32 erase_size)
3074 {
3075 struct jffs_fm *fm;
3076 struct jffs_fmcontrol *fmc = c->fmc;
3077 __u32 zero_offset;
3078 __u32 zero_size;
3079 __u32 zero_offset_data;
3080 __u32 zero_size_data;
3081 __u32 cutting_raw_inode = 0;
3082
3083 if (!(fm = jffs_cut_node(fmc, erase_size))) {
3084 D3(printk("jffs_clear_end_of_node(): fm == NULL\n"));
3085 return 0;
3086 }
3087
3088 /* Where and how much shall we clear? */
3089 zero_offset = fmc->head->offset + erase_size;
3090 zero_size = fm->offset + fm->size - zero_offset;
3091
3092 /* Do we have to clear the raw_inode explicitly? */
3093 if (fm->size - zero_size < sizeof(struct jffs_raw_inode)) {
3094 cutting_raw_inode = sizeof(struct jffs_raw_inode)
3095 - (fm->size - zero_size);
3096 }
3097
3098 /* First, clear the name and data fields. */
3099 zero_offset_data = zero_offset + cutting_raw_inode;
3100 zero_size_data = zero_size - cutting_raw_inode;
3101 flash_safe_acquire(fmc->mtd);
3102 flash_memset(fmc->mtd, zero_offset_data, 0, zero_size_data);
3103 flash_safe_release(fmc->mtd);
3104
3105 /* Should we clear a part of the raw inode? */
3106 if (cutting_raw_inode) {
3107 /* I guess it is ok to clear the raw inode in this order. */
3108 flash_safe_acquire(fmc->mtd);
3109 flash_memset(fmc->mtd, zero_offset, 0,
3110 cutting_raw_inode);
3111 flash_safe_release(fmc->mtd);
3112 }
3113
3114 return 0;
3115 } /* jffs_clear_end_of_node() */
3116
3117 /* Try to erase as much as possible of the dirt in the flash memory. */
3118 static long
3119 jffs_try_to_erase(struct jffs_control *c)
3120 {
3121 struct jffs_fmcontrol *fmc = c->fmc;
3122 long erase_size;
3123 int err;
3124 __u32 offset;
3125
3126 D3(printk("jffs_try_to_erase()\n"));
3127
3128 erase_size = jffs_erasable_size(fmc);
3129
3130 D2(printk("jffs_try_to_erase(): erase_size = %ld\n", erase_size));
3131
3132 if (erase_size == 0) {
3133 return 0;
3134 }
3135 else if (erase_size < 0) {
3136 printk(KERN_ERR "JFFS: jffs_try_to_erase: "
3137 "jffs_erasable_size returned %ld.\n", erase_size);
3138 return erase_size;
3139 }
3140
3141 if ((err = jffs_clear_end_of_node(c, erase_size)) < 0) {
3142 printk(KERN_ERR "JFFS: jffs_try_to_erase: "
3143 "Clearing of node failed.\n");
3144 return err;
3145 }
3146
3147 offset = fmc->head->offset;
3148
3149 /* Now, let's try to do the erase. */
3150 if ((err = flash_erase_region(fmc->mtd,
3151 offset, erase_size)) < 0) {
3152 printk(KERN_ERR "JFFS: Erase of flash failed. "
3153 "offset = %u, erase_size = %ld\n",
3154 offset, erase_size);
3155 /* XXX: Here we should allocate this area as dirty
3156 with jffs_fmalloced or something similar. Now
3157 we just report the error. */
3158 return err;
3159 }
3160
3161 #if 0
3162 /* Check if the erased sectors really got erased. */
3163 {
3164 __u32 pos;
3165 __u32 end;
3166
3167 pos = (__u32)flash_get_direct_pointer(to_kdev_t(c->sb->s_dev), offset);
3168 end = pos + erase_size;
3169
3170 D2(printk("JFFS: Checking erased sector(s)...\n"));
3171
3172 flash_safe_acquire(fmc->mtd);
3173
3174 for (; pos < end; pos += 4) {
3175 if (*(__u32 *)pos != JFFS_EMPTY_BITMASK) {
3176 printk("JFFS: Erase failed! pos = 0x%lx\n",
3177 (long)pos);
3178 jffs_hexdump(fmc->mtd, pos,
3179 jffs_min(256, end - pos));
3180 err = -1;
3181 break;
3182 }
3183 }
3184
3185 flash_safe_release(fmc->mtd);
3186
3187 if (!err) {
3188 D2(printk("JFFS: Erase succeeded.\n"));
3189 }
3190 else {
3191 /* XXX: Here we should allocate the memory
3192 with jffs_fmalloced() in order to prevent
3193 JFFS from using this area accidentally. */
3194 return err;
3195 }
3196 }
3197 #endif
3198
3199 /* Update the flash memory data structures. */
3200 jffs_sync_erase(fmc, erase_size);
3201
3202 return erase_size;
3203 }
3204
3205
3206 /* There are different criteria that should trigger a garbage collect:
3207
3208 1. There is too much dirt in the memory.
3209 2. The free space is becoming small.
3210 3. There are many versions of a node.
3211
3212 The garbage collect should always be done in a manner that guarantees
3213 that future garbage collects cannot be locked. E.g. Rewritten chunks
3214 should not be too large (span more than one sector in the flash memory
3215 for exemple). Of course there is a limit on how intelligent this garbage
3216 collection can be. */
3217
3218
3219 static int
3220 jffs_garbage_collect_now(struct jffs_control *c)
3221 {
3222 struct jffs_fmcontrol *fmc = c->fmc;
3223 long erased = 0;
3224 int result = 0;
3225 D1(int i = 1);
3226 D2(printk("***jffs_garbage_collect_now(): fmc->dirty_size = %u, fmc->free_size = 0x%x\n, fcs1=0x%x, fcs2=0x%x",
3227 fmc->dirty_size, fmc->free_size, jffs_free_size1(fmc), jffs_free_size2(fmc)));
3228 D2(jffs_print_fmcontrol(fmc));
3229
3230 // down(&fmc->gclock);
3231
3232 /* If it is possible to garbage collect, do so. */
3233
3234 while (erased == 0) {
3235 D1(printk("***jffs_garbage_collect_now(): round #%u, "
3236 "fmc->dirty_size = %u\n", i++, fmc->dirty_size));
3237 D2(jffs_print_fmcontrol(fmc));
3238
3239 if ((erased = jffs_try_to_erase(c)) < 0) {
3240 printk(KERN_WARNING "JFFS: Error in "
3241 "garbage collector.\n");
3242 result = erased;
3243 goto gc_end;
3244 }
3245 if (erased)
3246 break;
3247
3248 if (fmc->free_size == 0) {
3249 /* Argh */
3250 printk(KERN_ERR "jffs_garbage_collect_now(): free_size == 0. This is BAD.\n");
3251 result = -ENOSPC;
3252 break;
3253 }
3254
3255 if (fmc->dirty_size < fmc->sector_size) {
3256 /* Actually, we _may_ have been able to free some,
3257 * if there are many overlapping nodes which aren't
3258 * actually marked dirty because they still have
3259 * some valid data in each.
3260 */
3261 result = -ENOSPC;
3262 break;
3263 }
3264
3265 /* Let's dare to make a garbage collect. */
3266 if ((result = jffs_garbage_collect_next(c)) < 0) {
3267 printk(KERN_ERR "JFFS: Something "
3268 "has gone seriously wrong "
3269 "with a garbage collect.\n");
3270 goto gc_end;
3271 }
3272
3273 D1(printk(" jffs_garbage_collect_now(): erased: %ld\n", erased));
3274 DJM(jffs_print_memory_allocation_statistics());
3275 }
3276
3277 gc_end:
3278 // up(&fmc->gclock);
3279
3280 D3(printk(" jffs_garbage_collect_now(): Leaving...\n"));
3281 D1(if (erased) {
3282 printk("jffs_g_c_now(): erased = %ld\n", erased);
3283 jffs_print_fmcontrol(fmc);
3284 });
3285
3286 if (!erased && !result)
3287 return -ENOSPC;
3288
3289 return result;
3290 } /* jffs_garbage_collect_now() */
3291
3292
3293 /* Determine if it is reasonable to start garbage collection.
3294 We start a gc pass if either:
3295 - The number of free bytes < MIN_FREE_BYTES && at least one
3296 block is dirty, OR
3297 - The number of dirty bytes > MAX_DIRTY_BYTES
3298 */
3299 static inline int thread_should_wake (struct jffs_control *c)
3300 {
3301 D1(printk (KERN_NOTICE "thread_should_wake(): free=%d, dirty=%d, blocksize=%d.\n",
3302 c->fmc->free_size, c->fmc->dirty_size, c->fmc->sector_size));
3303
3304 /* If there's not enough dirty space to free a block, there's no point. */
3305 if (c->fmc->dirty_size < c->fmc->sector_size) {
3306 D2(printk(KERN_NOTICE "thread_should_wake(): Not waking. Insufficient dirty space\n"));
3307 return 0;
3308 }
3309 #if 1
3310 /* If there is too much RAM used by the various structures, GC */
3311 if (jffs_get_node_inuse() > (c->fmc->used_size/c->fmc->max_chunk_size * 5 + jffs_get_file_count() * 2 + 50)) {
3312 /* FIXME: Provide proof that this test can be satisfied. We
3313 don't want a filesystem doing endless GC just because this
3314 condition cannot ever be false.
3315 */
3316 D2(printk(KERN_NOTICE "thread_should_wake(): Waking due to number of nodes\n"));
3317 return 1;
3318 }
3319 #endif
3320 /* If there are fewer free bytes than the threshold, GC */
3321 if (c->fmc->free_size < c->gc_minfree_threshold) {
3322 D2(printk(KERN_NOTICE "thread_should_wake(): Waking due to insufficent free space\n"));
3323 return 1;
3324 }
3325 /* If there are more dirty bytes than the threshold, GC */
3326 if (c->fmc->dirty_size > c->gc_maxdirty_threshold) {
3327 D2(printk(KERN_NOTICE "thread_should_wake(): Waking due to excessive dirty space\n"));
3328 return 1;
3329 }
3330 /* FIXME: What about the "There are many versions of a node" condition? */
3331
3332 return 0;
3333 }
3334
3335
3336 void jffs_garbage_collect_trigger(struct jffs_control *c)
3337 {
3338 /* NOTE: We rely on the fact that we have the BKL here.
3339 * Otherwise, the gc_task could go away between the check
3340 * and the wake_up_process()
3341 */
3342 if (c->gc_task && thread_should_wake(c))
3343 send_sig(SIGHUP, c->gc_task, 1);
3344 }
3345
3346
3347 /* Kernel threads take (void *) as arguments. Thus we pass
3348 the jffs_control data as a (void *) and then cast it. */
3349 int
3350 jffs_garbage_collect_thread(void *ptr)
3351 {
3352 struct jffs_control *c = (struct jffs_control *) ptr;
3353 struct jffs_fmcontrol *fmc = c->fmc;
3354 long erased;
3355 int result = 0;
3356 D1(int i = 1);
3357
3358 daemonize("jffs_gcd");
3359
3360 c->gc_task = current;
3361
3362 lock_kernel();
3363 init_completion(&c->gc_thread_comp); /* barrier */
3364 spin_lock_irq(&current->sighand->siglock);
3365 siginitsetinv (&current->blocked, sigmask(SIGHUP) | sigmask(SIGKILL) | sigmask(SIGSTOP) | sigmask(SIGCONT));
3366 recalc_sigpending();
3367 spin_unlock_irq(&current->sighand->siglock);
3368
3369 D1(printk (KERN_NOTICE "jffs_garbage_collect_thread(): Starting infinite loop.\n"));
3370
3371 for (;;) {
3372
3373 /* See if we need to start gc. If we don't, go to sleep.
3374
3375 Current implementation is a BAD THING(tm). If we try
3376 to unmount the FS, the unmount operation will sleep waiting
3377 for this thread to exit. We need to arrange to send it a
3378 sig before the umount process sleeps.
3379 */
3380
3381 if (!thread_should_wake(c))
3382 set_current_state (TASK_INTERRUPTIBLE);
3383
3384 schedule(); /* Yes, we do this even if we want to go
3385 on immediately - we're a low priority
3386 background task. */
3387
3388 /* Put_super will send a SIGKILL and then wait on the sem.
3389 */
3390 while (signal_pending(current)) {
3391 siginfo_t info;
3392 unsigned long signr = 0;
3393
3394 if (try_to_freeze())
3395 continue;
3396
3397 spin_lock_irq(&current->sighand->siglock);
3398 signr = dequeue_signal(current, &current->blocked, &info);
3399 spin_unlock_irq(&current->sighand->siglock);
3400
3401 switch(signr) {
3402 case SIGSTOP:
3403 D1(printk("jffs_garbage_collect_thread(): SIGSTOP received.\n"));
3404 set_current_state(TASK_STOPPED);
3405 schedule();
3406 break;
3407
3408 case SIGKILL:
3409 D1(printk("jffs_garbage_collect_thread(): SIGKILL received.\n"));
3410 c->gc_task = NULL;
3411 complete_and_exit(&c->gc_thread_comp, 0);
3412 }
3413 }
3414
3415
3416 D1(printk (KERN_NOTICE "jffs_garbage_collect_thread(): collecting.\n"));
3417
3418 D3(printk (KERN_NOTICE "g_c_thread(): down biglock\n"));
3419 down(&fmc->biglock);
3420
3421 D1(printk("***jffs_garbage_collect_thread(): round #%u, "
3422 "fmc->dirty_size = %u\n", i++, fmc->dirty_size));
3423 D2(jffs_print_fmcontrol(fmc));
3424
3425 if ((erased = jffs_try_to_erase(c)) < 0) {
3426 printk(KERN_WARNING "JFFS: Error in "
3427 "garbage collector: %ld.\n", erased);
3428 }
3429
3430 if (erased)
3431 goto gc_end;
3432
3433 if (fmc->free_size == 0) {
3434 /* Argh. Might as well commit suicide. */
3435 printk(KERN_ERR "jffs_garbage_collect_thread(): free_size == 0. This is BAD.\n");
3436 send_sig(SIGQUIT, c->gc_task, 1);
3437 // panic()
3438 goto gc_end;
3439 }
3440
3441 /* Let's dare to make a garbage collect. */
3442 if ((result = jffs_garbage_collect_next(c)) < 0) {
3443 printk(KERN_ERR "JFFS: Something "
3444 "has gone seriously wrong "
3445 "with a garbage collect: %d\n", result);
3446 }
3447
3448 gc_end:
3449 D3(printk (KERN_NOTICE "g_c_thread(): up biglock\n"));
3450 up(&fmc->biglock);
3451 } /* for (;;) */
3452 } /* jffs_garbage_collect_thread() */
Linux kernel - Deliverables
This page took 0.18141 seconds and 5 git commands to generate.