Annotation of embedaddon/bird2/lib/resource.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD Resource Manager
! 3: *
! 4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
! 5: *
! 6: * Can be freely distributed and used under the terms of the GNU GPL.
! 7: */
! 8:
! 9: #include <stdio.h>
! 10: #include <stdlib.h>
! 11: #include <stdint.h>
! 12:
! 13: #include "nest/bird.h"
! 14: #include "lib/resource.h"
! 15: #include "lib/string.h"
! 16:
! 17: /**
! 18: * DOC: Resource pools
! 19: *
! 20: * Resource pools (&pool) are just containers holding a list of
! 21: * other resources. Freeing a pool causes all the listed resources
! 22: * to be freed as well. Each existing &resource is linked to some pool
! 23: * except for a root pool which isn't linked anywhere, so all the
! 24: * resources form a tree structure with internal nodes corresponding
! 25: * to pools and leaves being the other resources.
! 26: *
! 27: * Example: Almost all modules of BIRD have their private pool which
! 28: * is freed upon shutdown of the module.
! 29: */
! 30:
! 31: struct pool {
! 32: resource r;
! 33: list inside;
! 34: const char *name;
! 35: };
! 36:
! 37: static void pool_dump(resource *);
! 38: static void pool_free(resource *);
! 39: static resource *pool_lookup(resource *, unsigned long);
! 40: static size_t pool_memsize(resource *P);
! 41:
! 42: static struct resclass pool_class = {
! 43: "Pool",
! 44: sizeof(pool),
! 45: pool_free,
! 46: pool_dump,
! 47: pool_lookup,
! 48: pool_memsize
! 49: };
! 50:
! 51: pool root_pool;
! 52:
! 53: static int indent;
! 54:
! 55: /**
! 56: * rp_new - create a resource pool
! 57: * @p: parent pool
! 58: * @name: pool name (to be included in debugging dumps)
! 59: *
! 60: * rp_new() creates a new resource pool inside the specified
! 61: * parent pool.
! 62: */
! 63: pool *
! 64: rp_new(pool *p, const char *name)
! 65: {
! 66: pool *z = ralloc(p, &pool_class);
! 67: z->name = name;
! 68: init_list(&z->inside);
! 69: return z;
! 70: }
! 71:
! 72: static void
! 73: pool_free(resource *P)
! 74: {
! 75: pool *p = (pool *) P;
! 76: resource *r, *rr;
! 77:
! 78: r = HEAD(p->inside);
! 79: while (rr = (resource *) r->n.next)
! 80: {
! 81: r->class->free(r);
! 82: xfree(r);
! 83: r = rr;
! 84: }
! 85: }
! 86:
! 87: static void
! 88: pool_dump(resource *P)
! 89: {
! 90: pool *p = (pool *) P;
! 91: resource *r;
! 92:
! 93: debug("%s\n", p->name);
! 94: indent += 3;
! 95: WALK_LIST(r, p->inside)
! 96: rdump(r);
! 97: indent -= 3;
! 98: }
! 99:
! 100: static size_t
! 101: pool_memsize(resource *P)
! 102: {
! 103: pool *p = (pool *) P;
! 104: resource *r;
! 105: size_t sum = sizeof(pool) + ALLOC_OVERHEAD;
! 106:
! 107: WALK_LIST(r, p->inside)
! 108: sum += rmemsize(r);
! 109:
! 110: return sum;
! 111: }
! 112:
! 113: static resource *
! 114: pool_lookup(resource *P, unsigned long a)
! 115: {
! 116: pool *p = (pool *) P;
! 117: resource *r, *q;
! 118:
! 119: WALK_LIST(r, p->inside)
! 120: if (r->class->lookup && (q = r->class->lookup(r, a)))
! 121: return q;
! 122: return NULL;
! 123: }
! 124:
! 125: /**
! 126: * rmove - move a resource
! 127: * @res: resource
! 128: * @p: pool to move the resource to
! 129: *
! 130: * rmove() moves a resource from one pool to another.
! 131: */
! 132:
! 133: void rmove(void *res, pool *p)
! 134: {
! 135: resource *r = res;
! 136:
! 137: if (r)
! 138: {
! 139: if (r->n.next)
! 140: rem_node(&r->n);
! 141: add_tail(&p->inside, &r->n);
! 142: }
! 143: }
! 144:
! 145: /**
! 146: * rfree - free a resource
! 147: * @res: resource
! 148: *
! 149: * rfree() frees the given resource and all information associated
! 150: * with it. In case it's a resource pool, it also frees all the objects
! 151: * living inside the pool.
! 152: *
! 153: * It works by calling a class-specific freeing function.
! 154: */
! 155: void
! 156: rfree(void *res)
! 157: {
! 158: resource *r = res;
! 159:
! 160: if (!r)
! 161: return;
! 162:
! 163: if (r->n.next)
! 164: rem_node(&r->n);
! 165: r->class->free(r);
! 166: r->class = NULL;
! 167: xfree(r);
! 168: }
! 169:
! 170: /**
! 171: * rdump - dump a resource
! 172: * @res: resource
! 173: *
! 174: * This function prints out all available information about the given
! 175: * resource to the debugging output.
! 176: *
! 177: * It works by calling a class-specific dump function.
! 178: */
! 179: void
! 180: rdump(void *res)
! 181: {
! 182: char x[16];
! 183: resource *r = res;
! 184:
! 185: bsprintf(x, "%%%ds%%p ", indent);
! 186: debug(x, "", r);
! 187: if (r)
! 188: {
! 189: debug("%s ", r->class->name);
! 190: r->class->dump(r);
! 191: }
! 192: else
! 193: debug("NULL\n");
! 194: }
! 195:
! 196: size_t
! 197: rmemsize(void *res)
! 198: {
! 199: resource *r = res;
! 200: if (!r)
! 201: return 0;
! 202: if (!r->class->memsize)
! 203: return r->class->size + ALLOC_OVERHEAD;
! 204: return r->class->memsize(r);
! 205: }
! 206:
! 207: /**
! 208: * ralloc - create a resource
! 209: * @p: pool to create the resource in
! 210: * @c: class of the new resource
! 211: *
! 212: * This function is called by the resource classes to create a new
! 213: * resource of the specified class and link it to the given pool.
! 214: * Allocated memory is zeroed. Size of the resource structure is taken
! 215: * from the @size field of the &resclass.
! 216: */
! 217: void *
! 218: ralloc(pool *p, struct resclass *c)
! 219: {
! 220: resource *r = xmalloc(c->size);
! 221: bzero(r, c->size);
! 222:
! 223: r->class = c;
! 224: if (p)
! 225: add_tail(&p->inside, &r->n);
! 226: return r;
! 227: }
! 228:
! 229: /**
! 230: * rlookup - look up a memory location
! 231: * @a: memory address
! 232: *
! 233: * This function examines all existing resources to see whether
! 234: * the address @a is inside any resource. It's used for debugging
! 235: * purposes only.
! 236: *
! 237: * It works by calling a class-specific lookup function for each
! 238: * resource.
! 239: */
! 240: void
! 241: rlookup(unsigned long a)
! 242: {
! 243: resource *r;
! 244:
! 245: debug("Looking up %08lx\n", a);
! 246: if (r = pool_lookup(&root_pool.r, a))
! 247: rdump(r);
! 248: else
! 249: debug("Not found.\n");
! 250: }
! 251:
! 252: /**
! 253: * resource_init - initialize the resource manager
! 254: *
! 255: * This function is called during BIRD startup. It initializes
! 256: * all data structures of the resource manager and creates the
! 257: * root pool.
! 258: */
! 259: void
! 260: resource_init(void)
! 261: {
! 262: root_pool.r.class = &pool_class;
! 263: root_pool.name = "Root";
! 264: init_list(&root_pool.inside);
! 265: }
! 266:
! 267: /**
! 268: * DOC: Memory blocks
! 269: *
! 270: * Memory blocks are pieces of contiguous allocated memory.
! 271: * They are a bit non-standard since they are represented not by a pointer
! 272: * to &resource, but by a void pointer to the start of data of the
! 273: * memory block. All memory block functions know how to locate the header
! 274: * given the data pointer.
! 275: *
! 276: * Example: All "unique" data structures such as hash tables are allocated
! 277: * as memory blocks.
! 278: */
! 279:
! 280: struct mblock {
! 281: resource r;
! 282: unsigned size;
! 283: uintptr_t data_align[0];
! 284: byte data[0];
! 285: };
! 286:
! 287: static void mbl_free(resource *r UNUSED)
! 288: {
! 289: }
! 290:
! 291: static void mbl_debug(resource *r)
! 292: {
! 293: struct mblock *m = (struct mblock *) r;
! 294:
! 295: debug("(size=%d)\n", m->size);
! 296: }
! 297:
! 298: static resource *
! 299: mbl_lookup(resource *r, unsigned long a)
! 300: {
! 301: struct mblock *m = (struct mblock *) r;
! 302:
! 303: if ((unsigned long) m->data <= a && (unsigned long) m->data + m->size > a)
! 304: return r;
! 305: return NULL;
! 306: }
! 307:
! 308: static size_t
! 309: mbl_memsize(resource *r)
! 310: {
! 311: struct mblock *m = (struct mblock *) r;
! 312: return ALLOC_OVERHEAD + sizeof(struct mblock) + m->size;
! 313: }
! 314:
! 315: static struct resclass mb_class = {
! 316: "Memory",
! 317: 0,
! 318: mbl_free,
! 319: mbl_debug,
! 320: mbl_lookup,
! 321: mbl_memsize
! 322: };
! 323:
! 324: /**
! 325: * mb_alloc - allocate a memory block
! 326: * @p: pool
! 327: * @size: size of the block
! 328: *
! 329: * mb_alloc() allocates memory of a given size and creates
! 330: * a memory block resource representing this memory chunk
! 331: * in the pool @p.
! 332: *
! 333: * Please note that mb_alloc() returns a pointer to the memory
! 334: * chunk, not to the resource, hence you have to free it using
! 335: * mb_free(), not rfree().
! 336: */
! 337: void *
! 338: mb_alloc(pool *p, unsigned size)
! 339: {
! 340: struct mblock *b = xmalloc(sizeof(struct mblock) + size);
! 341:
! 342: b->r.class = &mb_class;
! 343: add_tail(&p->inside, &b->r.n);
! 344: b->size = size;
! 345: return b->data;
! 346: }
! 347:
! 348: /**
! 349: * mb_allocz - allocate and clear a memory block
! 350: * @p: pool
! 351: * @size: size of the block
! 352: *
! 353: * mb_allocz() allocates memory of a given size, initializes it to
! 354: * zeroes and creates a memory block resource representing this memory
! 355: * chunk in the pool @p.
! 356: *
! 357: * Please note that mb_allocz() returns a pointer to the memory
! 358: * chunk, not to the resource, hence you have to free it using
! 359: * mb_free(), not rfree().
! 360: */
! 361: void *
! 362: mb_allocz(pool *p, unsigned size)
! 363: {
! 364: void *x = mb_alloc(p, size);
! 365: bzero(x, size);
! 366: return x;
! 367: }
! 368:
! 369: /**
! 370: * mb_realloc - reallocate a memory block
! 371: * @m: memory block
! 372: * @size: new size of the block
! 373: *
! 374: * mb_realloc() changes the size of the memory block @m to a given size.
! 375: * The contents will be unchanged to the minimum of the old and new sizes;
! 376: * newly allocated memory will be uninitialized. Contrary to realloc()
! 377: * behavior, @m must be non-NULL, because the resource pool is inherited
! 378: * from it.
! 379: *
! 380: * Like mb_alloc(), mb_realloc() also returns a pointer to the memory
! 381: * chunk, not to the resource, hence you have to free it using
! 382: * mb_free(), not rfree().
! 383: */
! 384: void *
! 385: mb_realloc(void *m, unsigned size)
! 386: {
! 387: struct mblock *b = SKIP_BACK(struct mblock, data, m);
! 388:
! 389: b = xrealloc(b, sizeof(struct mblock) + size);
! 390: replace_node(&b->r.n, &b->r.n);
! 391: b->size = size;
! 392: return b->data;
! 393: }
! 394:
! 395:
! 396: /**
! 397: * mb_free - free a memory block
! 398: * @m: memory block
! 399: *
! 400: * mb_free() frees all memory associated with the block @m.
! 401: */
! 402: void
! 403: mb_free(void *m)
! 404: {
! 405: if (!m)
! 406: return;
! 407:
! 408: struct mblock *b = SKIP_BACK(struct mblock, data, m);
! 409: rfree(b);
! 410: }
! 411:
! 412:
! 413:
! 414: #define STEP_UP(x) ((x) + (x)/2 + 4)
! 415:
! 416: void
! 417: buffer_realloc(void **buf, unsigned *size, unsigned need, unsigned item_size)
! 418: {
! 419: unsigned nsize = MIN(*size, need);
! 420:
! 421: while (nsize < need)
! 422: nsize = STEP_UP(nsize);
! 423:
! 424: *buf = mb_realloc(*buf, nsize * item_size);
! 425: *size = nsize;
! 426: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to resource.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib