litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Linus Torvalds <torvalds@linux-foundation.org>	2008-01-28 16:50:42 -0500
committer	Linus Torvalds <torvalds@linux-foundation.org>	2008-01-28 16:50:42 -0500
commit	d4928196fe9ec07d18139ba2735876b0c8aa738f (patch)
tree	a999ee3f18b0d724b2adb15ec72854e7ade164fa /include/linux/istallion.h
parent	bb04af0e2e5bcd8d1a5d7f7d5c704f7eb328f241 (diff)
parent	febffd61816ef6d4f84189468c1d47f1df55921e (diff)

Merge branch 'cfq-ioc-share' of git://git.kernel.dk/linux-2.6-block

* 'cfq-ioc-share' of git://git.kernel.dk/linux-2.6-block: cfq-iosched: kill some big inlines cfq-iosched: relax IOPRIO_CLASS_IDLE restrictions kernel: add CLONE_IO to specifically request sharing of IO contexts io_context sharing - anticipatory changes block: cfq: make the io contect sharing lockless io_context sharing - cfq changes io context sharing: preliminary support ioprio: move io priority from task_struct to io_context

Diffstat (limited to 'include/linux/istallion.h')

0 files changed, 0 insertions, 0 deletions

/* * SLOB Allocator: Simple List Of Blocks * * Matt Mackall <mpm@selenic.com> 12/30/03 * * NUMA support by Paul Mundt, 2007. * * How SLOB works: * * The core of SLOB is a traditional K&R style heap allocator, with * support for returning aligned objects. The granularity of this * allocator is as little as 2 bytes, however typically most architectures * will require 4 bytes on 32-bit and 8 bytes on 64-bit. * * The slob heap is a linked list of pages from alloc_pages(), and * within each page, there is a singly-linked list of free blocks (slob_t). * The heap is grown on demand and allocation from the heap is currently * first-fit. * * Above this is an implementation of kmalloc/kfree. Blocks returned * from kmalloc are prepended with a 4-byte header with the kmalloc size. * If kmalloc is asked for objects of PAGE_SIZE or larger, it calls * alloc_pages() directly, allocating compound pages so the page order * does not have to be separately tracked, and also stores the exact * allocation size in page->private so that it can be used to accurately * provide ksize(). These objects are detected in kfree() because slob_page() * is false for them. * * SLAB is emulated on top of SLOB by simply calling constructors and * destructors for every SLAB allocation. Objects are returned with the * 4-byte alignment unless the SLAB_HWCACHE_ALIGN flag is set, in which * case the low-level allocator will fragment blocks to create the proper * alignment. Again, objects of page-size or greater are allocated by * calling alloc_pages(). As SLAB objects know their size, no separate * size bookkeeping is necessary and there is essentially no allocation * space overhead, and compound pages aren't needed for multi-page * allocations. * * NUMA support in SLOB is fairly simplistic, pushing most of the real * logic down to the page allocator, and simply doing the node accounting * on the upper levels. In the event that a node id is explicitly * provided, alloc_pages_node() with the specified node id is used * instead. The common case (or when the node id isn't explicitly provided) * will default to the current node, as per numa_node_id(). * * Node aware pages are still inserted in to the global freelist, and * these are scanned for by matching against the node id encoded in the * page flags. As a result, block allocations that can be satisfied from * the freelist will only be done so on pages residing on the same node, * in order to prevent random node placement. */ #include <linux/kernel.h> #include <linux/slab.h> #include <linux/mm.h> #include <linux/cache.h> #include <linux/init.h> #include <linux/module.h> #include <linux/rcupdate.h> #include <linux/list.h> #include <asm/atomic.h> /* * slob_block has a field 'units', which indicates size of block if +ve, * or offset of next block if -ve (in SLOB_UNITs). * * Free blocks of size 1 unit simply contain the offset of the next block. * Those with larger size contain their size in the first SLOB_UNIT of * memory, and the offset of the next free block in the second SLOB_UNIT. */ #if PAGE_SIZE <= (32767 * 2) typedef s16 slobidx_t; #else typedef s32 slobidx_t; #endif struct slob_block { slobidx_t units; }; typedef struct slob_block slob_t; /* * We use struct page fields to manage some slob allocation aspects, * however to avoid the horrible mess in include/linux/mm_types.h, we'll * just define our own struct page type variant here. */ struct slob_page { union { struct { unsigned long flags; /* mandatory */ atomic_t _count; /* mandatory */ slobidx_t units; /* free units left in page */ unsigned long pad[2]; slob_t *free; /* first free slob_t in page */ struct list_head list; /* linked list of free pages */ }; struct page page; }; }; static inline void struct_slob_page_wrong_size(void) { BUILD_BUG_ON(sizeof(struct slob_page) != sizeof(struct page)); } /* * free_slob_page: call before a slob_page is returned to the page allocator. */ static inline void free_slob_page(struct slob_page *sp) { reset_page_mapcount(&sp->page); sp->page.mapping = NULL; } /* * All (partially) free slob pages go on this list. */ static LIST_HEAD(free_slob_pages); /* * slob_page: True for all slob pages (false for bigblock pages) */ static inline int slob_page(struct slob_page *sp) { return test_bit(PG_active, &sp->flags); } static inline void set_slob_page(struct slob_page *sp) { __set_bit(PG_active, &sp->flags); } static inline void clear_slob_page(struct slob_page *sp) { __clear_bit(PG_active, &sp->flags); } /* * slob_page_free: true for pages on free_slob_pages list. */ static inline int slob_page_free(struct slob_page *sp) { return test_bit(PG_private, &sp->flags); } static inline void set_slob_page_free(struct slob_page *sp) { list_add(&sp->list, &free_slob_pages); __set_bit(PG_private, &sp->flags); } static inline void clear_slob_page_free(struct slob_page *sp) { list_del(&sp->list); __clear_bit(PG_private, &sp->flags); } #define SLOB_UNIT sizeof(slob_t) #define SLOB_UNITS(size) (((size) + SLOB_UNIT - 1)/SLOB_UNIT) #define SLOB_ALIGN L1_CACHE_BYTES /* * struct slob_rcu is inserted at the tail of allocated slob blocks, which * were created with a SLAB_DESTROY_BY_RCU slab. slob_rcu is used to free * the block using call_rcu. */ struct slob_rcu { struct rcu_head head; int size; }; /* * slob_lock protects all slob allocator structures. */ static DEFINE_SPINLOCK(slob_lock); /* * Encode the given size and next info into a free slob block s. */ static void set_slob(slob_t *s, slobidx_t size, slob_t *next) { slob_t *base = (slob_t *)((unsigned long)s & PAGE_MASK); slobidx_t offset = next - base; if (size > 1) { s[0].units = size; s[1].units = offset; } else s[0].units = -offset; } /* * Return the size of a slob block. */


context:
space:
mode: