v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / fs / jffs2 / nodemgmt.c
1 /*
2  * JFFS2 -- Journalling Flash File System, Version 2.
3  *
4  * Copyright (C) 2001 Red Hat, Inc.
5  *
6  * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
7  *
8  * The original JFFS, from which the design for JFFS2 was derived,
9  * was designed and implemented by Axis Communications AB.
10  *
11  * The contents of this file are subject to the Red Hat eCos Public
12  * License Version 1.1 (the "Licence"); you may not use this file
13  * except in compliance with the Licence.  You may obtain a copy of
14  * the Licence at http://www.redhat.com/
15  *
16  * Software distributed under the Licence is distributed on an "AS IS"
17  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
18  * See the Licence for the specific language governing rights and
19  * limitations under the Licence.
20  *
21  * The Original Code is JFFS2 - Journalling Flash File System, version 2
22  *
23  * Alternatively, the contents of this file may be used under the
24  * terms of the GNU General Public License version 2 (the "GPL"), in
25  * which case the provisions of the GPL are applicable instead of the
26  * above.  If you wish to allow the use of your version of this file
27  * only under the terms of the GPL and not to allow others to use your
28  * version of this file under the RHEPL, indicate your decision by
29  * deleting the provisions above and replace them with the notice and
30  * other provisions required by the GPL.  If you do not delete the
31  * provisions above, a recipient may use your version of this file
32  * under either the RHEPL or the GPL.
33  *
34  * $Id: nodemgmt.c,v 1.39 2001/04/11 22:20:26 dwmw2 Exp $
35  *
36  */
37
38 #include <linux/kernel.h>
39 #include <linux/slab.h>
40 #include <linux/jffs2.h>
41 #include <linux/mtd/mtd.h>
42 #include <linux/interrupt.h>
43 #include "nodelist.h"
44
45 /**
46  *      jffs2_reserve_space - request physical space to write nodes to flash
47  *      @c: superblock info
48  *      @minsize: Minimum acceptable size of allocation
49  *      @ofs: Returned value of node offset
50  *      @len: Returned value of allocation length
51  *      @prio: Allocation type - ALLOC_{NORMAL,DELETION}
52  *
53  *      Requests a block of physical space on the flash. Returns zero for success
54  *      and puts 'ofs' and 'len' into the appriopriate place, or returns -ENOSPC
55  *      or other error if appropriate.
56  *
57  *      If it returns zero, jffs2_reserve_space() also downs the per-filesystem
58  *      allocation semaphore, to prevent more than one allocation from being
59  *      active at any time. The semaphore is later released by jffs2_commit_allocation()
60  *
61  *      jffs2_reserve_space() may trigger garbage collection in order to make room
62  *      for the requested allocation.
63  */
64
65 static int jffs2_do_reserve_space(struct jffs2_sb_info *c,  __u32 minsize, __u32 *ofs, __u32 *len);
66
67 int jffs2_reserve_space(struct jffs2_sb_info *c, __u32 minsize, __u32 *ofs, __u32 *len, int prio)
68 {
69         int ret = -EAGAIN;
70         int blocksneeded = JFFS2_RESERVED_BLOCKS_WRITE;
71         /* align it */
72         minsize = PAD(minsize);
73
74         if (prio == ALLOC_DELETION)
75                 blocksneeded = JFFS2_RESERVED_BLOCKS_DELETION;
76
77         D1(printk(KERN_DEBUG "jffs2_reserve_space(): Requested 0x%x bytes\n", minsize));
78         down(&c->alloc_sem);
79
80         D1(printk(KERN_DEBUG "jffs2_reserve_space(): alloc sem got\n"));
81
82         spin_lock_bh(&c->erase_completion_lock);
83
84         /* this needs a little more thought */
85         while(ret == -EAGAIN) {
86                 while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
87                         int ret;
88
89                         up(&c->alloc_sem);
90                         if (c->dirty_size < c->sector_size) {
91                                 D1(printk(KERN_DEBUG "Short on space, but total dirty size 0x%08x < sector size 0x%08x, so -ENOSPC\n", c->dirty_size, c->sector_size));
92                                 spin_unlock_bh(&c->erase_completion_lock);
93                                 return -ENOSPC;
94                         }
95                         D1(printk(KERN_DEBUG "Triggering GC pass. nr_free_blocks %d, nr_erasing_blocks %d, free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x, erasing_size 0x%08x, bad_size 0x%08x (total 0x%08x of 0x%08x)\n",
96                                   c->nr_free_blocks, c->nr_erasing_blocks, c->free_size, c->dirty_size, c->used_size, c->erasing_size, c->bad_size,
97                                   c->free_size + c->dirty_size + c->used_size + c->erasing_size + c->bad_size, c->flash_size));
98                         spin_unlock_bh(&c->erase_completion_lock);
99                         
100                         ret = jffs2_garbage_collect_pass(c);
101                         if (ret)
102                                 return ret;
103                         if (signal_pending(current)) {
104                                 return -EINTR;
105                         }
106                         if(current->need_resched) {
107                                 schedule();
108                         }
109                         down(&c->alloc_sem);
110                         spin_lock_bh(&c->erase_completion_lock);
111                 }
112
113                 ret = jffs2_do_reserve_space(c, minsize, ofs, len);
114                 if (ret) {
115                         D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret));
116                 }
117         }
118         spin_unlock_bh(&c->erase_completion_lock);
119         if (ret)
120                 up(&c->alloc_sem);
121         return ret;
122 }
123
124 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, __u32 minsize, __u32 *ofs, __u32 *len)
125 {
126         int ret = -EAGAIN;
127         minsize = PAD(minsize);
128
129         D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize));
130
131         spin_lock_bh(&c->erase_completion_lock);
132         while(ret == -EAGAIN) {
133                 ret = jffs2_do_reserve_space(c, minsize, ofs, len);
134                 if (ret) {
135                         D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
136                 }
137         }
138         spin_unlock_bh(&c->erase_completion_lock);
139         return ret;
140 }
141
142 /* Called with alloc sem _and_ erase_completion_lock */
143 static int jffs2_do_reserve_space(struct jffs2_sb_info *c,  __u32 minsize, __u32 *ofs, __u32 *len)
144 {
145         struct jffs2_eraseblock *jeb = c->nextblock;
146         
147  restart:
148         if (jeb && minsize > jeb->free_size) {
149                 /* Skip the end of this block and file it as having some dirty space */
150                 c->dirty_size += jeb->free_size;
151                 c->free_size -= jeb->free_size;
152                 jeb->dirty_size += jeb->free_size;
153                 jeb->free_size = 0;
154                 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
155                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
156                 list_add_tail(&jeb->list, &c->dirty_list);
157                 c->nextblock = jeb = NULL;
158         }
159         
160         if (!jeb) {
161                 struct list_head *next;
162                 /* Take the next block off the 'free' list */
163
164                 if (list_empty(&c->free_list)) {
165
166                         DECLARE_WAITQUEUE(wait, current);
167                         
168                         if (!c->nr_erasing_blocks) {
169 //                      if (list_empty(&c->erasing_list) && list_empty(&c->erase_pending_list) && list_empty(c->erase_complete_list)) {
170                                 /* Ouch. We're in GC, or we wouldn't have got here.
171                                    And there's no space left. At all. */
172                                 printk(KERN_CRIT "Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasingempty: %s, erasependingempty: %s)\n", 
173                                        c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no");
174                                 return -ENOSPC;
175                         }
176                         /* Make sure this can't deadlock. Someone has to start the erases
177                            of erase_pending blocks */
178                         set_current_state(TASK_INTERRUPTIBLE);
179                         add_wait_queue(&c->erase_wait, &wait);
180                         D1(printk(KERN_DEBUG "Waiting for erases to complete. erasing_blocks is %d. (erasingempty: %s, erasependingempty: %s)\n", 
181                                   c->nr_erasing_blocks, list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no"));
182                         if (!list_empty(&c->erase_pending_list)) {
183                                 D1(printk(KERN_DEBUG "Triggering pending erases\n"));
184                                 jffs2_erase_pending_trigger(c);
185                         }
186                         spin_unlock_bh(&c->erase_completion_lock);
187                         schedule();
188                         remove_wait_queue(&c->erase_wait, &wait);
189                         spin_lock_bh(&c->erase_completion_lock);
190                         if (signal_pending(current)) {
191                                 return -EINTR;
192                         }
193                         /* An erase may have failed, decreasing the
194                            amount of free space available. So we must
195                            restart from the beginning */
196                         return -EAGAIN;
197                 }
198
199                 next = c->free_list.next;
200                 list_del(next);
201                 c->nextblock = jeb = list_entry(next, struct jffs2_eraseblock, list);
202                 c->nr_free_blocks--;
203                 if (jeb->free_size != c->sector_size - sizeof(struct jffs2_unknown_node)) {
204                         printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size);
205                         goto restart;
206                 }
207         }
208         /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
209            enough space */
210         *ofs = jeb->offset + (c->sector_size - jeb->free_size);
211         *len = jeb->free_size;
212         D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n", *len, *ofs));
213         return 0;
214 }
215
216 /**
217  *      jffs2_add_physical_node_ref - add a physical node reference to the list
218  *      @c: superblock info
219  *      @ofs: physical location of this physical node
220  *      @len: length of this physical node
221  *      @ino: inode number with which this physical node is associated
222  *
223  *      Should only be used to report nodes for which space has been allocated 
224  *      by jffs2_reserve_space.
225  *
226  *      Must be called with the alloc_sem held.
227  */
228  
229 int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *new, __u32 len, int dirty)
230 {
231         struct jffs2_eraseblock *jeb;
232
233         len = PAD(len);
234         jeb = &c->blocks[(new->flash_offset & ~3) / c->sector_size];
235         D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x, size 0x%x\n", new->flash_offset & ~3, len));
236 #if 1
237         if (jeb != c->nextblock || (new->flash_offset & ~3) != jeb->offset + (c->sector_size - jeb->free_size)) {
238                 printk(KERN_WARNING "argh. node added in wrong place\n");
239                 jffs2_free_raw_node_ref(new);
240                 return -EINVAL;
241         }
242 #endif
243         if (!jeb->first_node)
244                 jeb->first_node = new;
245         if (jeb->last_node)
246                 jeb->last_node->next_phys = new;
247         jeb->last_node = new;
248
249         spin_lock_bh(&c->erase_completion_lock);
250         jeb->free_size -= len;
251         c->free_size -= len;
252         if (dirty) {
253                 new->flash_offset |= 1;
254                 jeb->dirty_size += len;
255                 c->dirty_size += len;
256         } else {
257                 jeb->used_size += len;
258                 c->used_size += len;
259         }
260         spin_unlock_bh(&c->erase_completion_lock);
261         if (!jeb->free_size && !jeb->dirty_size) {
262                 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
263                 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
264                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
265                 list_add_tail(&jeb->list, &c->clean_list);
266                 c->nextblock = NULL;
267         }
268         ACCT_SANITY_CHECK(c,jeb);
269         ACCT_PARANOIA_CHECK(jeb);
270
271         return 0;
272 }
273
274
275 void jffs2_complete_reservation(struct jffs2_sb_info *c)
276 {
277         D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n"));
278         jffs2_garbage_collect_trigger(c);
279         up(&c->alloc_sem);
280 }
281
282 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
283 {
284         struct jffs2_eraseblock *jeb;
285         int blocknr;
286         struct jffs2_unknown_node n;
287         int ret;
288         ssize_t retlen;
289
290         if(!ref) {
291                 printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
292                 return;
293         }
294         if (ref->flash_offset & 1) {
295                 D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref->flash_offset &~3));
296                 return;
297         }
298         blocknr = ref->flash_offset / c->sector_size;
299         if (blocknr >= c->nr_blocks) {
300                 printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset);
301                 BUG();
302         }
303         jeb = &c->blocks[blocknr];
304         if (jeb->used_size < ref->totlen) {
305                 printk(KERN_NOTICE "raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n",
306                        ref->totlen, blocknr, ref->flash_offset, jeb->used_size);
307                 BUG();
308         }
309
310         spin_lock_bh(&c->erase_completion_lock);
311         jeb->used_size -= ref->totlen;
312         jeb->dirty_size += ref->totlen;
313         c->used_size -= ref->totlen;
314         c->dirty_size += ref->totlen;
315         ref->flash_offset |= 1;
316         
317         ACCT_SANITY_CHECK(c, jeb);
318
319         ACCT_PARANOIA_CHECK(jeb);
320
321         if (jeb == c->nextblock) {
322                 D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset));
323         } else if (jeb == c->gcblock) {
324                 D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty/erase_pending list\n", jeb->offset));
325 #if 0 /* We no longer do this here. It can screw the wear levelling. If you have a lot of static
326          data and a few blocks free, and you just create new files and keep deleting/overwriting
327          them, then you'd keep erasing and reusing those blocks without ever moving stuff around.
328          So we leave completely obsoleted blocks on the dirty_list and let the GC delete them 
329          when it finds them there. That way, we still get the 'once in a while, take a clean block'
330          to spread out the flash usage */
331         } else if (!jeb->used_size) {
332                 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset));
333                 list_del(&jeb->list);
334                 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
335                 list_add_tail(&jeb->list, &c->erase_pending_list);
336                 c->nr_erasing_blocks++;
337                 jffs2_erase_pending_trigger(c);
338                 //              OFNI_BS_2SFFJ(c)->s_dirt = 1;
339                 D1(printk(KERN_DEBUG "Done OK\n"));
340 #endif
341         } else if (jeb->dirty_size == ref->totlen) {
342                 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset));
343                 list_del(&jeb->list);
344                 D1(printk(KERN_DEBUG "...and adding to dirty_list\n"));
345                 list_add_tail(&jeb->list, &c->dirty_list);
346         }
347         spin_unlock_bh(&c->erase_completion_lock);
348
349         if (c->mtd->type != MTD_NORFLASH && c->mtd->type != MTD_RAM)
350                 return;
351
352         D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref->flash_offset &~3));
353         ret = c->mtd->read(c->mtd, ref->flash_offset &~3, sizeof(n), &retlen, (char *)&n);
354         if (ret) {
355                 printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, ret);
356                 return;
357         }
358         if (retlen != sizeof(n)) {
359                 printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, retlen);
360                 return;
361         }
362         if (PAD(n.totlen) != PAD(ref->totlen)) {
363                 printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen in node ref (0x%08x)\n", n.totlen, ref->totlen);
364                 return;
365         }
366         if (!(n.nodetype & JFFS2_NODE_ACCURATE)) {
367                 D1(printk(KERN_DEBUG "Node at 0x%08x was already marked obsolete (nodetype 0x%04x\n", ref->flash_offset &~3, n.nodetype));
368                 return;
369         }
370         n.nodetype &= ~JFFS2_NODE_ACCURATE;
371         ret = c->mtd->write(c->mtd, ref->flash_offset&~3, sizeof(n), &retlen, (char *)&n);
372         if (ret) {
373                 printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, ret);
374                 return;
375         }
376         if (retlen != sizeof(n)) {
377                 printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, retlen);
378                 return;
379         }
380 }