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.45.2.1 2002/02/23 14:13:34 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
 104                         if (current->need_resched)
 105                                 schedule();
 106
 107                         if (signal_pending(current))
 108                                 return -EINTR;
 109
 110                         down(&c->alloc_sem);
 111                         spin_lock_bh(&c->erase_completion_lock);
 112                 }
 113
 114                 ret = jffs2_do_reserve_space(c, minsize, ofs, len);
 115                 if (ret) {
 116                         D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret));
 117                 }
 118         }
 119         spin_unlock_bh(&c->erase_completion_lock);
 120         if (ret)
 121                 up(&c->alloc_sem);
 122         return ret;
 123 }
 124
 125 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, __u32 minsize, __u32 *ofs, __u32 *len)
 126 {
 127         int ret = -EAGAIN;
 128         minsize = PAD(minsize);
 129
 130         D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize));
 131
 132         spin_lock_bh(&c->erase_completion_lock);
 133         while(ret == -EAGAIN) {
 134                 ret = jffs2_do_reserve_space(c, minsize, ofs, len);
 135                 if (ret) {
 136                         D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
 137                 }
 138         }
 139         spin_unlock_bh(&c->erase_completion_lock);
 140         return ret;
 141 }
 142
 143 /* Called with alloc sem _and_ erase_completion_lock */
 144 static int jffs2_do_reserve_space(struct jffs2_sb_info *c,  __u32 minsize, __u32 *ofs, __u32 *len)
 145 {
 146         struct jffs2_eraseblock *jeb = c->nextblock;
 147
 148  restart:
 149         if (jeb && minsize > jeb->free_size) {
 150                 /* Skip the end of this block and file it as having some dirty space */
 151                 c->dirty_size += jeb->free_size;
 152                 c->free_size -= jeb->free_size;
 153                 jeb->dirty_size += jeb->free_size;
 154                 jeb->free_size = 0;
 155                 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
 156                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
 157                 list_add_tail(&jeb->list, &c->dirty_list);
 158                 c->nextblock = jeb = NULL;
 159         }
 160
 161         if (!jeb) {
 162                 struct list_head *next;
 163                 /* Take the next block off the 'free' list */
 164
 165                 if (list_empty(&c->free_list)) {
 166
 167                         DECLARE_WAITQUEUE(wait, current);
 168
 169                         if (!c->nr_erasing_blocks) {
 170 //                      if (list_empty(&c->erasing_list) && list_empty(&c->erase_pending_list) && list_empty(c->erase_complete_list)) {
 171                                 /* Ouch. We're in GC, or we wouldn't have got here.
 172                                    And there's no space left. At all. */
 173                                 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",
 174                                        c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no");
 175                                 return -ENOSPC;
 176                         }
 177                         /* Make sure this can't deadlock. Someone has to start the erases
 178                            of erase_pending blocks */
 179                         set_current_state(TASK_INTERRUPTIBLE);
 180                         add_wait_queue(&c->erase_wait, &wait);
 181                         D1(printk(KERN_DEBUG "Waiting for erases to complete. erasing_blocks is %d. (erasingempty: %s, erasependingempty: %s)\n",
 182                                   c->nr_erasing_blocks, list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no"));
 183                         if (!list_empty(&c->erase_pending_list)) {
 184                                 D1(printk(KERN_DEBUG "Triggering pending erases\n"));
 185                                 jffs2_erase_pending_trigger(c);
 186                         }
 187                         spin_unlock_bh(&c->erase_completion_lock);
 188                         schedule();
 189                         remove_wait_queue(&c->erase_wait, &wait);
 190                         spin_lock_bh(&c->erase_completion_lock);
 191                         if (signal_pending(current)) {
 192                                 return -EINTR;
 193                         }
 194                         /* An erase may have failed, decreasing the
 195                            amount of free space available. So we must
 196                            restart from the beginning */
 197                         return -EAGAIN;
 198                 }
 199
 200                 next = c->free_list.next;
 201                 list_del(next);
 202                 c->nextblock = jeb = list_entry(next, struct jffs2_eraseblock, list);
 203                 c->nr_free_blocks--;
 204                 if (jeb->free_size != c->sector_size - sizeof(struct jffs2_unknown_node)) {
 205                         printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size);
 206                         goto restart;
 207                 }
 208         }
 209         /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
 210            enough space */
 211         *ofs = jeb->offset + (c->sector_size - jeb->free_size);
 212         *len = jeb->free_size;
 213         D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n", *len, *ofs));
 214         return 0;
 215 }
 216
 217 /**
 218  *      jffs2_add_physical_node_ref - add a physical node reference to the list
 219  *      @c: superblock info
 220  *      @ofs: physical location of this physical node
 221  *      @len: length of this physical node
 222  *      @ino: inode number with which this physical node is associated
 223  *
 224  *      Should only be used to report nodes for which space has been allocated
 225  *      by jffs2_reserve_space.
 226  *
 227  *      Must be called with the alloc_sem held.
 228  */
 229
 230 int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *new, __u32 len, int dirty)
 231 {
 232         struct jffs2_eraseblock *jeb;
 233
 234         len = PAD(len);
 235         jeb = &c->blocks[(new->flash_offset & ~3) / c->sector_size];
 236         D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x, size 0x%x\n", new->flash_offset & ~3, len));
 237 #if 1
 238         if (jeb != c->nextblock || (new->flash_offset & ~3) != jeb->offset + (c->sector_size - jeb->free_size)) {
 239                 printk(KERN_WARNING "argh. node added in wrong place\n");
 240                 jffs2_free_raw_node_ref(new);
 241                 return -EINVAL;
 242         }
 243 #endif
 244         if (!jeb->first_node)
 245                 jeb->first_node = new;
 246         if (jeb->last_node)
 247                 jeb->last_node->next_phys = new;
 248         jeb->last_node = new;
 249
 250         spin_lock_bh(&c->erase_completion_lock);
 251         jeb->free_size -= len;
 252         c->free_size -= len;
 253         if (dirty) {
 254                 new->flash_offset |= 1;
 255                 jeb->dirty_size += len;
 256                 c->dirty_size += len;
 257         } else {
 258                 jeb->used_size += len;
 259                 c->used_size += len;
 260         }
 261         spin_unlock_bh(&c->erase_completion_lock);
 262         if (!jeb->free_size && !jeb->dirty_size) {
 263                 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
 264                 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
 265                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
 266                 list_add_tail(&jeb->list, &c->clean_list);
 267                 c->nextblock = NULL;
 268         }
 269         ACCT_SANITY_CHECK(c,jeb);
 270         ACCT_PARANOIA_CHECK(jeb);
 271
 272         return 0;
 273 }
 274
 275
 276 void jffs2_complete_reservation(struct jffs2_sb_info *c)
 277 {
 278         D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n"));
 279         jffs2_garbage_collect_trigger(c);
 280         up(&c->alloc_sem);
 281 }
 282
 283 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
 284 {
 285         struct jffs2_eraseblock *jeb;
 286         int blocknr;
 287         struct jffs2_unknown_node n;
 288         int ret;
 289         ssize_t retlen;
 290
 291         if(!ref) {
 292                 printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
 293                 return;
 294         }
 295         if (ref->flash_offset & 1) {
 296                 D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref->flash_offset &~3));
 297                 return;
 298         }
 299         blocknr = ref->flash_offset / c->sector_size;
 300         if (blocknr >= c->nr_blocks) {
 301                 printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset);
 302                 BUG();
 303         }
 304         jeb = &c->blocks[blocknr];
 305         if (jeb->used_size < ref->totlen) {
 306                 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",
 307                        ref->totlen, blocknr, ref->flash_offset, jeb->used_size);
 308                 BUG();
 309         }
 310
 311         spin_lock_bh(&c->erase_completion_lock);
 312         jeb->used_size -= ref->totlen;
 313         jeb->dirty_size += ref->totlen;
 314         c->used_size -= ref->totlen;
 315         c->dirty_size += ref->totlen;
 316         ref->flash_offset |= 1;
 317
 318         ACCT_SANITY_CHECK(c, jeb);
 319
 320         ACCT_PARANOIA_CHECK(jeb);
 321
 322         if (c->flags & JFFS2_SB_FLAG_MOUNTING) {
 323                 /* Mount in progress. Don't muck about with the block
 324                    lists because they're not ready yet, and don't actually
 325                    obliterate nodes that look obsolete. If they weren't
 326                    marked obsolete on the flash at the time they _became_
 327                    obsolete, there was probably a reason for that. */
 328                 spin_unlock_bh(&c->erase_completion_lock);
 329                 return;
 330         }
 331         if (jeb == c->nextblock) {
 332                 D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset));
 333         } else if (jeb == c->gcblock) {
 334                 D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty/erase_pending list\n", jeb->offset));
 335 #if 0 /* We no longer do this here. It can screw the wear levelling. If you have a lot of static
 336          data and a few blocks free, and you just create new files and keep deleting/overwriting
 337          them, then you'd keep erasing and reusing those blocks without ever moving stuff around.
 338          So we leave completely obsoleted blocks on the dirty_list and let the GC delete them
 339          when it finds them there. That way, we still get the 'once in a while, take a clean block'
 340          to spread out the flash usage */
 341         } else if (!jeb->used_size) {
 342                 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset));
 343                 list_del(&jeb->list);
 344                 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
 345                 list_add_tail(&jeb->list, &c->erase_pending_list);
 346                 c->nr_erasing_blocks++;
 347                 jffs2_erase_pending_trigger(c);
 348                 //              OFNI_BS_2SFFJ(c)->s_dirt = 1;
 349                 D1(printk(KERN_DEBUG "Done OK\n"));
 350 #endif
 351         } else if (jeb->dirty_size == ref->totlen) {
 352                 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset));
 353                 list_del(&jeb->list);
 354                 D1(printk(KERN_DEBUG "...and adding to dirty_list\n"));
 355                 list_add_tail(&jeb->list, &c->dirty_list);
 356         }
 357         spin_unlock_bh(&c->erase_completion_lock);
 358
 359         if (c->mtd->type != MTD_NORFLASH && c->mtd->type != MTD_RAM)
 360                 return;
 361         if (OFNI_BS_2SFFJ(c)->s_flags & MS_RDONLY)
 362                 return;
 363
 364         D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref->flash_offset &~3));
 365         ret = c->mtd->read(c->mtd, ref->flash_offset &~3, sizeof(n), &retlen, (char *)&n);
 366         if (ret) {
 367                 printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, ret);
 368                 return;
 369         }
 370         if (retlen != sizeof(n)) {
 371                 printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, retlen);
 372                 return;
 373         }
 374         if (PAD(n.totlen) != PAD(ref->totlen)) {
 375                 printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen in node ref (0x%08x)\n", n.totlen, ref->totlen);
 376                 return;
 377         }
 378         if (!(n.nodetype & JFFS2_NODE_ACCURATE)) {
 379                 D1(printk(KERN_DEBUG "Node at 0x%08x was already marked obsolete (nodetype 0x%04x\n", ref->flash_offset &~3, n.nodetype));
 380                 return;
 381         }
 382         n.nodetype &= ~JFFS2_NODE_ACCURATE;
 383         ret = c->mtd->write(c->mtd, ref->flash_offset&~3, sizeof(n), &retlen, (char *)&n);
 384         if (ret) {
 385                 printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, ret);
 386                 return;
 387         }
 388         if (retlen != sizeof(n)) {
 389                 printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %d\n", ref->flash_offset &~3, retlen);
 390                 return;
 391         }
 392 }