fs/jffs2/malloc.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright © 2001-2007 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@infradead.org>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/kernel.h>
  15 #include <linux/slab.h>
  16 #include <linux/init.h>
  17 #include <linux/jffs2.h>
  18 #include "nodelist.h"
  19
  20 /* These are initialised to NULL in the kernel startup code.
  21    If you're porting to other operating systems, beware */
  22 static struct kmem_cache *full_dnode_slab;
  23 static struct kmem_cache *raw_dirent_slab;
  24 static struct kmem_cache *raw_inode_slab;
  25 static struct kmem_cache *tmp_dnode_info_slab;
  26 static struct kmem_cache *raw_node_ref_slab;
  27 static struct kmem_cache *node_frag_slab;
  28 static struct kmem_cache *inode_cache_slab;
  29 #ifdef CONFIG_JFFS2_FS_XATTR
  30 static struct kmem_cache *xattr_datum_cache;
  31 static struct kmem_cache *xattr_ref_cache;
  32 #endif
  33
  34 int __init jffs2_create_slab_caches(void)
  35 {
  36         full_dnode_slab = kmem_cache_create("jffs2_full_dnode",
  37                                             sizeof(struct jffs2_full_dnode),
  38                                             0, 0, NULL);
  39         if (!full_dnode_slab)
  40                 goto err;
  41
  42         raw_dirent_slab = kmem_cache_create("jffs2_raw_dirent",
  43                                             sizeof(struct jffs2_raw_dirent),
  44                                             0, SLAB_HWCACHE_ALIGN, NULL);
  45         if (!raw_dirent_slab)
  46                 goto err;
  47
  48         raw_inode_slab = kmem_cache_create("jffs2_raw_inode",
  49                                            sizeof(struct jffs2_raw_inode),
  50                                            0, SLAB_HWCACHE_ALIGN, NULL);
  51         if (!raw_inode_slab)
  52                 goto err;
  53
  54         tmp_dnode_info_slab = kmem_cache_create("jffs2_tmp_dnode",
  55                                                 sizeof(struct jffs2_tmp_dnode_info),
  56                                                 0, 0, NULL);
  57         if (!tmp_dnode_info_slab)
  58                 goto err;
  59
  60         raw_node_ref_slab = kmem_cache_create("jffs2_refblock",
  61                                               sizeof(struct jffs2_raw_node_ref) * (REFS_PER_BLOCK + 1),
  62                                               0, 0, NULL);
  63         if (!raw_node_ref_slab)
  64                 goto err;
  65
  66         node_frag_slab = kmem_cache_create("jffs2_node_frag",
  67                                            sizeof(struct jffs2_node_frag),
  68                                            0, 0, NULL);
  69         if (!node_frag_slab)
  70                 goto err;
  71
  72         inode_cache_slab = kmem_cache_create("jffs2_inode_cache",
  73                                              sizeof(struct jffs2_inode_cache),
  74                                              0, 0, NULL);
  75         if (!inode_cache_slab)
  76                 goto err;
  77
  78 #ifdef CONFIG_JFFS2_FS_XATTR
  79         xattr_datum_cache = kmem_cache_create("jffs2_xattr_datum",
  80                                              sizeof(struct jffs2_xattr_datum),
  81                                              0, 0, NULL);
  82         if (!xattr_datum_cache)
  83                 goto err;
  84
  85         xattr_ref_cache = kmem_cache_create("jffs2_xattr_ref",
  86                                            sizeof(struct jffs2_xattr_ref),
  87                                            0, 0, NULL);
  88         if (!xattr_ref_cache)
  89                 goto err;
  90 #endif
  91
  92         return 0;
  93  err:
  94         jffs2_destroy_slab_caches();
  95         return -ENOMEM;
  96 }
  97
  98 void jffs2_destroy_slab_caches(void)
  99 {
 100         kmem_cache_destroy(full_dnode_slab);
 101         kmem_cache_destroy(raw_dirent_slab);
 102         kmem_cache_destroy(raw_inode_slab);
 103         kmem_cache_destroy(tmp_dnode_info_slab);
 104         kmem_cache_destroy(raw_node_ref_slab);
 105         kmem_cache_destroy(node_frag_slab);
 106         kmem_cache_destroy(inode_cache_slab);
 107 #ifdef CONFIG_JFFS2_FS_XATTR
 108         kmem_cache_destroy(xattr_datum_cache);
 109         kmem_cache_destroy(xattr_ref_cache);
 110 #endif
 111 }
 112
 113 struct jffs2_full_dirent *jffs2_alloc_full_dirent(int namesize)
 114 {
 115         struct jffs2_full_dirent *ret;
 116         ret = kmalloc(sizeof(struct jffs2_full_dirent) + namesize, GFP_KERNEL);
 117         dbg_memalloc("%p\n", ret);
 118         return ret;
 119 }
 120
 121 void jffs2_free_full_dirent(struct jffs2_full_dirent *x)
 122 {
 123         dbg_memalloc("%p\n", x);
 124         kfree(x);
 125 }
 126
 127 struct jffs2_full_dnode *jffs2_alloc_full_dnode(void)
 128 {
 129         struct jffs2_full_dnode *ret;
 130         ret = kmem_cache_alloc(full_dnode_slab, GFP_KERNEL);
 131         dbg_memalloc("%p\n", ret);
 132         return ret;
 133 }
 134
 135 void jffs2_free_full_dnode(struct jffs2_full_dnode *x)
 136 {
 137         dbg_memalloc("%p\n", x);
 138         kmem_cache_free(full_dnode_slab, x);
 139 }
 140
 141 struct jffs2_raw_dirent *jffs2_alloc_raw_dirent(void)
 142 {
 143         struct jffs2_raw_dirent *ret;
 144         ret = kmem_cache_alloc(raw_dirent_slab, GFP_KERNEL);
 145         dbg_memalloc("%p\n", ret);
 146         return ret;
 147 }
 148
 149 void jffs2_free_raw_dirent(struct jffs2_raw_dirent *x)
 150 {
 151         dbg_memalloc("%p\n", x);
 152         kmem_cache_free(raw_dirent_slab, x);
 153 }
 154
 155 struct jffs2_raw_inode *jffs2_alloc_raw_inode(void)
 156 {
 157         struct jffs2_raw_inode *ret;
 158         ret = kmem_cache_alloc(raw_inode_slab, GFP_KERNEL);
 159         dbg_memalloc("%p\n", ret);
 160         return ret;
 161 }
 162
 163 void jffs2_free_raw_inode(struct jffs2_raw_inode *x)
 164 {
 165         dbg_memalloc("%p\n", x);
 166         kmem_cache_free(raw_inode_slab, x);
 167 }
 168
 169 struct jffs2_tmp_dnode_info *jffs2_alloc_tmp_dnode_info(void)
 170 {
 171         struct jffs2_tmp_dnode_info *ret;
 172         ret = kmem_cache_alloc(tmp_dnode_info_slab, GFP_KERNEL);
 173         dbg_memalloc("%p\n",
 174                 ret);
 175         return ret;
 176 }
 177
 178 void jffs2_free_tmp_dnode_info(struct jffs2_tmp_dnode_info *x)
 179 {
 180         dbg_memalloc("%p\n", x);
 181         kmem_cache_free(tmp_dnode_info_slab, x);
 182 }
 183
 184 static struct jffs2_raw_node_ref *jffs2_alloc_refblock(void)
 185 {
 186         struct jffs2_raw_node_ref *ret;
 187
 188         ret = kmem_cache_alloc(raw_node_ref_slab, GFP_KERNEL);
 189         if (ret) {
 190                 int i = 0;
 191                 for (i=0; i < REFS_PER_BLOCK; i++) {
 192                         ret[i].flash_offset = REF_EMPTY_NODE;
 193                         ret[i].next_in_ino = NULL;
 194                 }
 195                 ret[i].flash_offset = REF_LINK_NODE;
 196                 ret[i].next_in_ino = NULL;
 197         }
 198         return ret;
 199 }
 200
 201 int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
 202                                  struct jffs2_eraseblock *jeb, int nr)
 203 {
 204         struct jffs2_raw_node_ref **p, *ref;
 205         int i = nr;
 206
 207         dbg_memalloc("%d\n", nr);
 208
 209         p = &jeb->last_node;
 210         ref = *p;
 211
 212         dbg_memalloc("Reserving %d refs for block @0x%08x\n", nr, jeb->offset);
 213
 214         /* If jeb->last_node is really a valid node then skip over it */
 215         if (ref && ref->flash_offset != REF_EMPTY_NODE)
 216                 ref++;
 217
 218         while (i) {
 219                 if (!ref) {
 220                         dbg_memalloc("Allocating new refblock linked from %p\n", p);
 221                         ref = *p = jffs2_alloc_refblock();
 222                         if (!ref)
 223                                 return -ENOMEM;
 224                 }
 225                 if (ref->flash_offset == REF_LINK_NODE) {
 226                         p = &ref->next_in_ino;
 227                         ref = *p;
 228                         continue;
 229                 }
 230                 i--;
 231                 ref++;
 232         }
 233         jeb->allocated_refs = nr;
 234
 235         dbg_memalloc("Reserved %d refs for block @0x%08x, last_node is %p (%08x,%p)\n",
 236                   nr, jeb->offset, jeb->last_node, jeb->last_node->flash_offset,
 237                   jeb->last_node->next_in_ino);
 238
 239         return 0;
 240 }
 241
 242 void jffs2_free_refblock(struct jffs2_raw_node_ref *x)
 243 {
 244         dbg_memalloc("%p\n", x);
 245         kmem_cache_free(raw_node_ref_slab, x);
 246 }
 247
 248 struct jffs2_node_frag *jffs2_alloc_node_frag(void)
 249 {
 250         struct jffs2_node_frag *ret;
 251         ret = kmem_cache_alloc(node_frag_slab, GFP_KERNEL);
 252         dbg_memalloc("%p\n", ret);
 253         return ret;
 254 }
 255
 256 void jffs2_free_node_frag(struct jffs2_node_frag *x)
 257 {
 258         dbg_memalloc("%p\n", x);
 259         kmem_cache_free(node_frag_slab, x);
 260 }
 261
 262 struct jffs2_inode_cache *jffs2_alloc_inode_cache(void)
 263 {
 264         struct jffs2_inode_cache *ret;
 265         ret = kmem_cache_alloc(inode_cache_slab, GFP_KERNEL);
 266         dbg_memalloc("%p\n", ret);
 267         return ret;
 268 }
 269
 270 void jffs2_free_inode_cache(struct jffs2_inode_cache *x)
 271 {
 272         dbg_memalloc("%p\n", x);
 273         kmem_cache_free(inode_cache_slab, x);
 274 }
 275
 276 #ifdef CONFIG_JFFS2_FS_XATTR
 277 struct jffs2_xattr_datum *jffs2_alloc_xattr_datum(void)
 278 {
 279         struct jffs2_xattr_datum *xd;
 280         xd = kmem_cache_zalloc(xattr_datum_cache, GFP_KERNEL);
 281         dbg_memalloc("%p\n", xd);
 282         if (!xd)
 283                 return NULL;
 284
 285         xd->class = RAWNODE_CLASS_XATTR_DATUM;
 286         xd->node = (void *)xd;
 287         INIT_LIST_HEAD(&xd->xindex);
 288         return xd;
 289 }
 290
 291 void jffs2_free_xattr_datum(struct jffs2_xattr_datum *xd)
 292 {
 293         dbg_memalloc("%p\n", xd);
 294         kmem_cache_free(xattr_datum_cache, xd);
 295 }
 296
 297 struct jffs2_xattr_ref *jffs2_alloc_xattr_ref(void)
 298 {
 299         struct jffs2_xattr_ref *ref;
 300         ref = kmem_cache_zalloc(xattr_ref_cache, GFP_KERNEL);
 301         dbg_memalloc("%p\n", ref);
 302         if (!ref)
 303                 return NULL;
 304
 305         ref->class = RAWNODE_CLASS_XATTR_REF;
 306         ref->node = (void *)ref;
 307         return ref;
 308 }
 309
 310 void jffs2_free_xattr_ref(struct jffs2_xattr_ref *ref)
 311 {
 312         dbg_memalloc("%p\n", ref);
 313         kmem_cache_free(xattr_ref_cache, ref);
 314 }
 315 #endif