yaffs_allocator.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2010 Aleph One Ltd.
   5  *   for Toby Churchill Ltd and Brightstar Engineering
   6  *
   7  * Created by Charles Manning <charles@aleph1.co.uk>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14
  15
  16 #include "yaffs_allocator.h"
  17 #include "yaffs_guts.h"
  18 #include "yaffs_trace.h"
  19 #include "yportenv.h"
  20
  21 #ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR
  22
  23 void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
  24 {
  25         dev = dev;
  26 }
  27
  28 void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
  29 {
  30         dev = dev;
  31 }
  32
  33 struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
  34 {
  35         return (struct yaffs_tnode *)YMALLOC(dev->tnode_size);
  36 }
  37
  38 void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
  39 {
  40         dev = dev;
  41         YFREE(tn);
  42 }
  43
  44 void yaffs_init_raw_objs(struct yaffs_dev *dev)
  45 {
  46         dev = dev;
  47 }
  48
  49 void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
  50 {
  51         dev = dev;
  52 }
  53
  54 struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
  55 {
  56         dev = dev;
  57         return (struct yaffs_obj *) YMALLOC(sizeof(struct yaffs_obj));
  58 }
  59
  60
  61 void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
  62 {
  63
  64         dev = dev;
  65         YFREE(obj);
  66 }
  67
  68 #else
  69
  70 struct yaffs_tnode_list {
  71         struct yaffs_tnode_list *next;
  72         struct yaffs_tnode *tnodes;
  73 };
  74
  75
  76 struct yaffs_obj_list {
  77         struct yaffs_obj_list *next;
  78         struct yaffs_obj *objects;
  79 };
  80
  81
  82 struct yaffs_allocator {
  83         int n_tnodes_created;
  84         struct yaffs_tnode *free_tnodes;
  85         int n_free_tnodes;
  86         struct yaffs_tnode_list *alloc_tnode_list;
  87
  88         int n_obj_created;
  89         struct yaffs_obj *free_objs;
  90         int n_free_objects;
  91
  92         struct yaffs_obj_list *allocated_obj_list;
  93 };
  94
  95
  96 static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev)
  97 {
  98
  99         struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
 100
 101         struct yaffs_tnode_list *tmp;
 102
 103         if(!allocator){
 104                 YBUG();
 105                 return;
 106         }
 107
 108         while (allocator->alloc_tnode_list) {
 109                 tmp = allocator->alloc_tnode_list->next;
 110
 111                 YFREE(allocator->alloc_tnode_list->tnodes);
 112                 YFREE(allocator->alloc_tnode_list);
 113                 allocator->alloc_tnode_list = tmp;
 114
 115         }
 116
 117         allocator->free_tnodes = NULL;
 118         allocator->n_free_tnodes = 0;
 119         allocator->n_tnodes_created = 0;
 120 }
 121
 122 static void yaffs_init_raw_tnodes(struct yaffs_dev *dev)
 123 {
 124         struct yaffs_allocator *allocator = dev->allocator;
 125
 126         if(allocator){
 127                 allocator->alloc_tnode_list = NULL;
 128                 allocator->free_tnodes = NULL;
 129                 allocator->n_free_tnodes = 0;
 130                 allocator->n_tnodes_created = 0;
 131         } else
 132                 YBUG();
 133 }
 134
 135 static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
 136 {
 137         struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
 138         int i;
 139         struct yaffs_tnode *new_tnodes;
 140         u8 *mem;
 141         struct yaffs_tnode *curr;
 142         struct yaffs_tnode *next;
 143         struct yaffs_tnode_list *tnl;
 144
 145         if(!allocator){
 146                 YBUG();
 147                 return YAFFS_FAIL;
 148         }
 149
 150         if (n_tnodes < 1)
 151                 return YAFFS_OK;
 152
 153
 154         /* make these things */
 155
 156         new_tnodes = YMALLOC(n_tnodes * dev->tnode_size);
 157         mem = (u8 *)new_tnodes;
 158
 159         if (!new_tnodes) {
 160                 T(YAFFS_TRACE_ERROR,
 161                         (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
 162                 return YAFFS_FAIL;
 163         }
 164
 165         /* New hookup for wide tnodes */
 166         for (i = 0; i < n_tnodes - 1; i++) {
 167                 curr = (struct yaffs_tnode *) &mem[i * dev->tnode_size];
 168                 next = (struct yaffs_tnode *) &mem[(i+1) * dev->tnode_size];
 169                 curr->internal[0] = next;
 170         }
 171
 172         curr = (struct yaffs_tnode *) &mem[(n_tnodes - 1) * dev->tnode_size];
 173         curr->internal[0] = allocator->free_tnodes;
 174         allocator->free_tnodes = (struct yaffs_tnode *)mem;
 175
 176         allocator->n_free_tnodes += n_tnodes;
 177         allocator->n_tnodes_created += n_tnodes;
 178
 179         /* Now add this bunch of tnodes to a list for freeing up.
 180          * NB If we can't add this to the management list it isn't fatal
 181          * but it just means we can't free this bunch of tnodes later.
 182          */
 183
 184         tnl = YMALLOC(sizeof(struct yaffs_tnode_list));
 185         if (!tnl) {
 186                 T(YAFFS_TRACE_ERROR,
 187                   (TSTR
 188                    ("yaffs: Could not add tnodes to management list" TENDSTR)));
 189                    return YAFFS_FAIL;
 190         } else {
 191                 tnl->tnodes = new_tnodes;
 192                 tnl->next = allocator->alloc_tnode_list;
 193                 allocator->alloc_tnode_list = tnl;
 194         }
 195
 196         T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR)));
 197
 198         return YAFFS_OK;
 199 }
 200
 201
 202 struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 203 {
 204         struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
 205         struct yaffs_tnode *tn = NULL;
 206
 207         if(!allocator){
 208                 YBUG();
 209                 return NULL;
 210         }
 211
 212         /* If there are none left make more */
 213         if (!allocator->free_tnodes)
 214                 yaffs_create_tnodes(dev, YAFFS_ALLOCATION_NTNODES);
 215
 216         if (allocator->free_tnodes) {
 217                 tn = allocator->free_tnodes;
 218                 allocator->free_tnodes = allocator->free_tnodes->internal[0];
 219                 allocator->n_free_tnodes--;
 220         }
 221
 222         return tn;
 223 }
 224
 225 /* FreeTnode frees up a tnode and puts it back on the free list */
 226 void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
 227 {
 228         struct yaffs_allocator *allocator = dev->allocator;
 229
 230         if(!allocator){
 231                 YBUG();
 232                 return;
 233         }
 234
 235         if (tn) {
 236                 tn->internal[0] = allocator->free_tnodes;
 237                 allocator->free_tnodes = tn;
 238                 allocator->n_free_tnodes++;
 239         }
 240         dev->checkpoint_blocks_required = 0; /* force recalculation*/
 241 }
 242
 243
 244
 245 static void yaffs_init_raw_objs(struct yaffs_dev *dev)
 246 {
 247         struct yaffs_allocator *allocator = dev->allocator;
 248
 249         if(allocator) {
 250                 allocator->allocated_obj_list = NULL;
 251                 allocator->free_objs = NULL;
 252                 allocator->n_free_objects = 0;
 253         } else
 254                 YBUG();
 255 }
 256
 257 static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 258 {
 259         struct yaffs_allocator *allocator = dev->allocator;
 260         struct yaffs_obj_list *tmp;
 261
 262         if(!allocator){
 263                 YBUG();
 264                 return;
 265         }
 266
 267         while (allocator->allocated_obj_list) {
 268                 tmp = allocator->allocated_obj_list->next;
 269                 YFREE(allocator->allocated_obj_list->objects);
 270                 YFREE(allocator->allocated_obj_list);
 271
 272                 allocator->allocated_obj_list = tmp;
 273         }
 274
 275         allocator->free_objs = NULL;
 276         allocator->n_free_objects = 0;
 277         allocator->n_obj_created = 0;
 278 }
 279
 280
 281 static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
 282 {
 283         struct yaffs_allocator *allocator = dev->allocator;
 284
 285         int i;
 286         struct yaffs_obj *new_objs;
 287         struct yaffs_obj_list *list;
 288
 289         if(!allocator){
 290                 YBUG();
 291                 return YAFFS_FAIL;
 292         }
 293
 294         if (n_obj < 1)
 295                 return YAFFS_OK;
 296
 297         /* make these things */
 298         new_objs = YMALLOC(n_obj * sizeof(struct yaffs_obj));
 299         list = YMALLOC(sizeof(struct yaffs_obj_list));
 300
 301         if (!new_objs || !list) {
 302                 if (new_objs){
 303                         YFREE(new_objs);
 304                         new_objs = NULL;
 305                 }
 306                 if (list){
 307                         YFREE(list);
 308                         list = NULL;
 309                 }
 310                 T(YAFFS_TRACE_ALLOCATE,
 311                   (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
 312                 return YAFFS_FAIL;
 313         }
 314
 315         /* Hook them into the free list */
 316         for (i = 0; i < n_obj - 1; i++) {
 317                 new_objs[i].siblings.next =
 318                                 (struct list_head *)(&new_objs[i + 1]);
 319         }
 320
 321         new_objs[n_obj - 1].siblings.next = (void *)allocator->free_objs;
 322         allocator->free_objs = new_objs;
 323         allocator->n_free_objects += n_obj;
 324         allocator->n_obj_created += n_obj;
 325
 326         /* Now add this bunch of Objects to a list for freeing up. */
 327
 328         list->objects = new_objs;
 329         list->next = allocator->allocated_obj_list;
 330         allocator->allocated_obj_list = list;
 331
 332         return YAFFS_OK;
 333 }
 334
 335 struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
 336 {
 337         struct yaffs_obj *obj = NULL;
 338         struct yaffs_allocator *allocator = dev->allocator;
 339
 340         if(!allocator) {
 341                 YBUG();
 342                 return obj;
 343         }
 344
 345         /* If there are none left make more */
 346         if (!allocator->free_objs)
 347                 yaffs_create_free_objs(dev, YAFFS_ALLOCATION_NOBJECTS);
 348
 349         if (allocator->free_objs) {
 350                 obj = allocator->free_objs;
 351                 allocator->free_objs =
 352                         (struct yaffs_obj *) (allocator->free_objs->siblings.next);
 353                 allocator->n_free_objects--;
 354         }
 355
 356         return obj;
 357 }
 358
 359
 360 void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 361 {
 362
 363         struct yaffs_allocator *allocator = dev->allocator;
 364
 365         if(!allocator)
 366                 YBUG();
 367         else {
 368                 /* Link into the free list. */
 369                 obj->siblings.next = (struct list_head *)(allocator->free_objs);
 370                 allocator->free_objs = obj;
 371                 allocator->n_free_objects++;
 372         }
 373 }
 374
 375 void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 376 {
 377         if(dev->allocator){
 378                 yaffs_deinit_raw_tnodes(dev);
 379                 yaffs_deinit_raw_objs(dev);
 380
 381                 YFREE(dev->allocator);
 382                 dev->allocator=NULL;
 383         } else
 384                 YBUG();
 385 }
 386
 387 void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 388 {
 389         struct yaffs_allocator *allocator;
 390
 391         if(!dev->allocator){
 392                 allocator = YMALLOC(sizeof(struct yaffs_allocator));
 393                 if(allocator){
 394                         dev->allocator = allocator;
 395                         yaffs_init_raw_tnodes(dev);
 396                         yaffs_init_raw_objs(dev);
 397                 }
 398         } else
 399                 YBUG();
 400 }
 401
 402
 403 #endif