This is an automated email from the git hooks/post-receive script. sthibault pushed a commit to branch master in repository gnumach.
commit c980e15a44fd71c5376f3fe87b9d70d22fd05c2c Author: Samuel Thibault <[email protected]> Date: Tue Jun 7 13:57:45 2016 +0000 New upstream snapshot patches/99_RB.patch: Drop, fixed upstream. --- debian/changelog | 7 + debian/patches/99_RB.patch | 741 --------------------------------------------- debian/patches/series | 1 - 3 files changed, 7 insertions(+), 742 deletions(-) diff --git a/debian/changelog b/debian/changelog index 0f8549f..fed0c38 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,10 @@ +gnumach (2:1.7+git20160607-1) unstable; urgency=medium + + * New upstream snapshot. + * patches/99_RB.patch: Drop, fixed upstream. + + -- Samuel Thibault <[email protected]> Tue, 07 Jun 2016 13:57:41 +0000 + gnumach (2:1.7+git20160522-2) unstable; urgency=medium * Bump mig build-dep to fix stdint use in headers. diff --git a/debian/patches/99_RB.patch b/debian/patches/99_RB.patch deleted file mode 100644 index 2372977..0000000 --- a/debian/patches/99_RB.patch +++ /dev/null @@ -1,741 +0,0 @@ -Revert of - -commit 1db202eb8406785500f1bc3ceef7868566e416a1 -Author: Richard Braun <[email protected]> -Date: Fri May 20 20:10:52 2016 +0200 - - vm_map: back allocations with a red-black tree - - This change augments VM maps with a gap tree, sorted by gap size, to - use for non-fixed allocations. - - * vm/vm_map.c: Include kern/list.h. - (vm_map_entry_gap_cmp_lookup, vm_map_entry_gap_cmp_insert, - vm_map_gap_valid, vm_map_gap_compute, vm_map_gap_insert_single, - vm_map_gap_remove_single, vm_map_gap_update, vm_map_gap_insert, - vm_map_gap_remove, vm_map_find_entry_anywhere): New functions. - (vm_map_setup): Initialize gap tree. - (_vm_map_entry_link): Call vm_map_gap_insert. - (_vm_map_entry_unlink): Call vm_map_gap_remove. - (vm_map_find_entry, vm_map_enter, vm_map_copyout, - vm_map_copyout_page_list, vm_map_copyin): Replace look up loop with - a call to vm_map_find_entry_anywhere. Call vm_map_gap_update and - initialize gap tree where relevant. - (vm_map_copy_insert): Turn macro into an inline function and rewrite. - (vm_map_simplify): Reorder call to vm_map_entry_unlink so that previous - entry is suitable for use with gap management functions. - * vm/vm_map.h: Include kern/list.h. - (struct vm_map_entry): New members `gap_node`, `gap_list`, - `gap_size` and `in_gap_tree`. - (struct vm_map_header): New member `gap_tree`. - -diff --git b/vm/vm_map.c a/vm/vm_map.c -index 7a90551..89a2b38 100644 ---- b/vm/vm_map.c -+++ a/vm/vm_map.c -@@ -42,7 +42,6 @@ - #include <kern/assert.h> - #include <kern/debug.h> - #include <kern/kalloc.h> --#include <kern/list.h> - #include <kern/rbtree.h> - #include <kern/slab.h> - #include <vm/pmap.h> -@@ -183,7 +182,6 @@ void vm_map_setup( - map->hdr.nentries = 0; - map->hdr.entries_pageable = pageable; - rbtree_init(&map->hdr.tree); -- rbtree_init(&map->hdr.gap_tree); - - map->size = 0; - map->user_wired = 0; -@@ -296,141 +294,6 @@ static inline int vm_map_entry_cmp_insert(const struct rbtree_node *a, - } - - /* -- * Gap management functions -- */ --static inline int vm_map_entry_gap_cmp_lookup(vm_size_t gap_size, -- const struct rbtree_node *node) --{ -- struct vm_map_entry *entry; -- -- entry = rbtree_entry(node, struct vm_map_entry, gap_node); -- -- if (gap_size < entry->gap_size) -- return -1; -- else if (gap_size == entry->gap_size) -- return 0; -- else -- return 1; --} -- --static inline int vm_map_entry_gap_cmp_insert(const struct rbtree_node *a, -- const struct rbtree_node *b) --{ -- struct vm_map_entry *entry; -- -- entry = rbtree_entry(a, struct vm_map_entry, gap_node); -- return vm_map_entry_gap_cmp_lookup(entry->gap_size, b); --} -- --static int --vm_map_gap_valid(struct vm_map_header *hdr, struct vm_map_entry *entry) --{ -- return entry != (struct vm_map_entry *)&hdr->links; --} -- --static void --vm_map_gap_compute(struct vm_map_header *hdr, struct vm_map_entry *entry) --{ -- struct vm_map_entry *next; -- -- next = entry->vme_next; -- -- if (vm_map_gap_valid(hdr, next)) { -- entry->gap_size = next->vme_start - entry->vme_end; -- } else { -- entry->gap_size = hdr->vme_end - entry->vme_end; -- } --} -- --static void --vm_map_gap_insert_single(struct vm_map_header *hdr, struct vm_map_entry *entry) --{ -- struct vm_map_entry *tmp; -- struct rbtree_node *node; -- unsigned long slot; -- -- if (!vm_map_gap_valid(hdr, entry)) { -- return; -- } -- -- vm_map_gap_compute(hdr, entry); -- -- if (entry->gap_size == 0) { -- return; -- } -- -- node = rbtree_lookup_slot(&hdr->gap_tree, entry->gap_size, -- vm_map_entry_gap_cmp_lookup, slot); -- -- if (node == NULL) { -- rbtree_insert_slot(&hdr->gap_tree, slot, &entry->gap_node); -- list_init(&entry->gap_list); -- entry->in_gap_tree = 1; -- } else { -- tmp = rbtree_entry(node, struct vm_map_entry, gap_node); -- list_insert_tail(&tmp->gap_list, &entry->gap_list); -- entry->in_gap_tree = 0; -- } --} -- --static void --vm_map_gap_remove_single(struct vm_map_header *hdr, struct vm_map_entry *entry) --{ -- struct vm_map_entry *tmp; -- -- if (!vm_map_gap_valid(hdr, entry)) { -- return; -- } -- -- if (entry->gap_size == 0) { -- return; -- } -- -- if (!entry->in_gap_tree) { -- list_remove(&entry->gap_list); -- return; -- } -- -- rbtree_remove(&hdr->gap_tree, &entry->gap_node); -- -- if (list_empty(&entry->gap_list)) { -- return; -- } -- -- tmp = list_first_entry(&entry->gap_list, struct vm_map_entry, gap_list); -- assert(tmp->gap_size == entry->gap_size); -- list_remove(&tmp->gap_list); -- list_set_head(&tmp->gap_list, &entry->gap_list); -- assert(!tmp->in_gap_tree); -- rbtree_insert(&hdr->gap_tree, &tmp->gap_node, -- vm_map_entry_gap_cmp_insert); -- tmp->in_gap_tree = 1; --} -- --static void --vm_map_gap_update(struct vm_map_header *hdr, struct vm_map_entry *entry) --{ -- vm_map_gap_remove_single(hdr, entry); -- vm_map_gap_insert_single(hdr, entry); --} -- --static void --vm_map_gap_insert(struct vm_map_header *hdr, struct vm_map_entry *entry) --{ -- vm_map_gap_remove_single(hdr, entry->vme_prev); -- vm_map_gap_insert_single(hdr, entry->vme_prev); -- vm_map_gap_insert_single(hdr, entry); --} -- --static void --vm_map_gap_remove(struct vm_map_header *hdr, struct vm_map_entry *entry) --{ -- vm_map_gap_remove_single(hdr, entry); -- vm_map_gap_remove_single(hdr, entry->vme_prev); -- vm_map_gap_insert_single(hdr, entry->vme_prev); --} -- --/* - * vm_map_entry_{un,}link: - * - * Insert/remove entries from maps (or map copies). -@@ -453,7 +316,6 @@ vm_map_gap_remove(struct vm_map_header *hdr, struct vm_map_entry *entry) - (entry)->vme_next->vme_prev = (entry); \ - rbtree_insert(&(hdr)->tree, &(entry)->tree_node, \ - vm_map_entry_cmp_insert); \ -- vm_map_gap_insert((hdr), (entry)); \ - MACRO_END - - #define vm_map_entry_unlink(map, entry) \ -@@ -468,7 +330,6 @@ vm_map_gap_remove(struct vm_map_header *hdr, struct vm_map_entry *entry) - (entry)->vme_next->vme_prev = (entry)->vme_prev; \ - (entry)->vme_prev->vme_next = (entry)->vme_next; \ - rbtree_remove(&(hdr)->tree, &(entry)->tree_node); \ -- vm_map_gap_remove((hdr), (entry)); \ - MACRO_END - - /* -@@ -609,104 +470,6 @@ invalid_user_access( - (prot & ~(entry->protection))); - } - --/* -- * Find a range of available space from the specified map. -- * -- * If successful, this function returns the map entry immediately preceding -- * the range, and writes the range address in startp. If the map contains -- * no entry, the entry returned points to the map header. -- * Otherwise, NULL is returned. -- * -- * If map_locked is true, this function will not wait for more space in case -- * of failure. Otherwise, the map is locked. -- */ --static struct vm_map_entry * --vm_map_find_entry_anywhere(struct vm_map *map, -- vm_size_t size, -- vm_offset_t mask, -- boolean_t map_locked, -- vm_offset_t *startp) --{ -- struct vm_map_entry *entry; -- struct rbtree_node *node; -- vm_size_t max_size; -- vm_offset_t start, end; -- -- assert(size != 0); -- -- if (!map_locked) { -- vm_map_lock(map); -- } -- --restart: -- if (map->hdr.nentries == 0) { -- entry = vm_map_to_entry(map); -- start = (map->min_offset + mask) & ~mask; -- end = start + size; -- -- if ((end <= start) || (end > map->max_offset)) { -- goto error; -- } -- -- *startp = start; -- return entry; -- } -- -- entry = map->first_free; -- -- if (entry != vm_map_to_entry(map)) { -- start = (entry->vme_end + mask) & ~mask; -- end = start + size; -- -- if ((end > start) -- && (end <= map->max_offset) -- && (end <= (entry->vme_end + entry->gap_size))) { -- *startp = start; -- return entry; -- } -- } -- -- max_size = size + mask; -- -- if (max_size < size) { -- goto error; -- } -- -- node = rbtree_lookup_nearest(&map->hdr.gap_tree, max_size, -- vm_map_entry_gap_cmp_lookup, RBTREE_RIGHT); -- -- if (node == NULL) { -- if (map_locked || !map->wait_for_space) { -- goto error; -- } -- -- assert_wait((event_t)map, TRUE); -- vm_map_unlock(map); -- thread_block(NULL); -- vm_map_lock(map); -- goto restart; -- } -- -- entry = rbtree_entry(node, struct vm_map_entry, gap_node); -- assert(entry->in_gap_tree); -- -- if (!list_empty(&entry->gap_list)) { -- entry = list_last_entry(&entry->gap_list, -- struct vm_map_entry, gap_list); -- } -- -- assert(entry->gap_size >= max_size); -- start = (entry->vme_end + mask) & ~mask; -- end = start + size; -- assert(end > start); -- assert(end <= (entry->vme_end + entry->gap_size)); -- *startp = start; -- return entry; -- --error: -- printf("no more room in %p\n", map); -- return NULL; --} - - /* - * Routine: vm_map_find_entry -@@ -733,13 +496,66 @@ kern_return_t vm_map_find_entry( - vm_offset_t start; - vm_offset_t end; - -- entry = vm_map_find_entry_anywhere(map, size, mask, TRUE, &start); -+ /* -+ * Look for the first possible address; -+ * if there's already something at this -+ * address, we have to start after it. -+ */ - -- if (entry == NULL) { -- return KERN_NO_SPACE; -- } -+ if ((entry = map->first_free) == vm_map_to_entry(map)) -+ start = map->min_offset; -+ else -+ start = entry->vme_end; - -- end = start + size; -+ /* -+ * In any case, the "entry" always precedes -+ * the proposed new region throughout the loop: -+ */ -+ -+ while (TRUE) { -+ vm_map_entry_t next; -+ -+ /* -+ * Find the end of the proposed new region. -+ * Be sure we didn't go beyond the end, or -+ * wrap around the address. -+ */ -+ -+ if (((start + mask) & ~mask) < start) { -+ printf_once("no more room for vm_map_find_entry in %p\n", map); -+ return(KERN_NO_SPACE); -+ } -+ start = ((start + mask) & ~mask); -+ end = start + size; -+ -+ if ((end > map->max_offset) || (end < start)) { -+ printf_once("no more room for vm_map_find_entry in %p\n", map); -+ return(KERN_NO_SPACE); -+ } -+ -+ /* -+ * If there are no more entries, we must win. -+ */ -+ -+ next = entry->vme_next; -+ if (next == vm_map_to_entry(map)) -+ break; -+ -+ /* -+ * If there is another entry, it must be -+ * after the end of the potential new region. -+ */ -+ -+ if (next->vme_start >= end) -+ break; -+ -+ /* -+ * Didn't fit -- move to the next entry. -+ */ -+ -+ entry = next; -+ start = entry->vme_end; -+ } - - /* - * At this point, -@@ -778,7 +594,6 @@ kern_return_t vm_map_find_entry( - */ - - entry->vme_end = end; -- vm_map_gap_update(&map->hdr, entry); - new_entry = entry; - } else { - new_entry = vm_map_entry_create(map); -@@ -921,16 +736,98 @@ kern_return_t vm_map_enter( - if (size == 0) - return KERN_INVALID_ARGUMENT; - -+ StartAgain: ; -+ - start = *address; - - if (anywhere) { -- entry = vm_map_find_entry_anywhere(map, size, mask, FALSE, &start); -+ vm_map_lock(map); -+ -+ /* -+ * Calculate the first possible address. -+ */ - -- if (entry == NULL) { -+ if (start < map->min_offset) -+ start = map->min_offset; -+ if (start > map->max_offset) - RETURN(KERN_NO_SPACE); -+ -+ /* -+ * Look for the first possible address; -+ * if there's already something at this -+ * address, we have to start after it. -+ */ -+ -+ if (start == map->min_offset) { -+ if ((entry = map->first_free) != vm_map_to_entry(map)) -+ start = entry->vme_end; -+ } else { -+ vm_map_entry_t tmp_entry; -+ if (vm_map_lookup_entry(map, start, &tmp_entry)) -+ start = tmp_entry->vme_end; -+ entry = tmp_entry; - } - -- end = start + size; -+ /* -+ * In any case, the "entry" always precedes -+ * the proposed new region throughout the -+ * loop: -+ */ -+ -+ while (TRUE) { -+ vm_map_entry_t next; -+ -+ /* -+ * Find the end of the proposed new region. -+ * Be sure we didn't go beyond the end, or -+ * wrap around the address. -+ */ -+ -+ if (((start + mask) & ~mask) < start) { -+ printf_once("no more room for vm_map_enter in %p\n", map); -+ RETURN(KERN_NO_SPACE); -+ } -+ start = ((start + mask) & ~mask); -+ end = start + size; -+ -+ if ((end > map->max_offset) || (end < start)) { -+ if (map->wait_for_space) { -+ if (size <= (map->max_offset - -+ map->min_offset)) { -+ assert_wait((event_t) map, TRUE); -+ vm_map_unlock(map); -+ thread_block((void (*)()) 0); -+ goto StartAgain; -+ } -+ } -+ -+ printf_once("no more room for vm_map_enter in %p\n", map); -+ RETURN(KERN_NO_SPACE); -+ } -+ -+ /* -+ * If there are no more entries, we must win. -+ */ -+ -+ next = entry->vme_next; -+ if (next == vm_map_to_entry(map)) -+ break; -+ -+ /* -+ * If there is another entry, it must be -+ * after the end of the potential new region. -+ */ -+ -+ if (next->vme_start >= end) -+ break; -+ -+ /* -+ * Didn't fit -- move to the next entry. -+ */ -+ -+ entry = next; -+ start = entry->vme_end; -+ } - *address = start; - } else { - vm_map_entry_t temp_entry; -@@ -1017,7 +914,6 @@ kern_return_t vm_map_enter( - */ - map->size += (end - entry->vme_end); - entry->vme_end = end; -- vm_map_gap_update(&map->hdr, entry); - RETURN(KERN_SUCCESS); - } - } -@@ -2477,40 +2373,29 @@ start_pass_1: - } - - /* -- * Routine: vm_map_copy_insert -+ * Macro: vm_map_copy_insert - * - * Description: - * Link a copy chain ("copy") into a map at the - * specified location (after "where"). - * Side effects: - * The copy chain is destroyed. -+ * Warning: -+ * The arguments are evaluated multiple times. - */ --static void --vm_map_copy_insert(struct vm_map *map, struct vm_map_entry *where, -- struct vm_map_copy *copy) --{ -- struct vm_map_entry *entry; -- -- assert(copy->type == VM_MAP_COPY_ENTRY_LIST); -- -- for (;;) { -- entry = vm_map_copy_first_entry(copy); -- -- if (entry == vm_map_copy_to_entry(copy)) { -- break; -- } -- -- /* -- * TODO Turn copy maps into their own type so they don't -- * use any of the tree operations. -- */ -- vm_map_copy_entry_unlink(copy, entry); -- vm_map_entry_link(map, where, entry); -- where = entry; -- } -- -- kmem_cache_free(&vm_map_copy_cache, (vm_offset_t)copy); --} -+#define vm_map_copy_insert(map, where, copy) \ -+ MACRO_BEGIN \ -+ struct rbtree_node *node, *tmp; \ -+ rbtree_for_each_remove(&(copy)->cpy_hdr.tree, node, tmp) \ -+ rbtree_insert(&(map)->hdr.tree, node, \ -+ vm_map_entry_cmp_insert); \ -+ (((where)->vme_next)->vme_prev = vm_map_copy_last_entry(copy)) \ -+ ->vme_next = ((where)->vme_next); \ -+ ((where)->vme_next = vm_map_copy_first_entry(copy)) \ -+ ->vme_prev = (where); \ -+ (map)->hdr.nentries += (copy)->cpy_hdr.nentries; \ -+ kmem_cache_free(&vm_map_copy_cache, (vm_offset_t) copy); \ -+ MACRO_END - - /* - * Routine: vm_map_copyout -@@ -2575,11 +2460,37 @@ kern_return_t vm_map_copyout( - - vm_copy_start = trunc_page(copy->offset); - size = round_page(copy->offset + copy->size) - vm_copy_start; -- last = vm_map_find_entry_anywhere(dst_map, size, 0, FALSE, &start); - -- if (last == NULL) { -- vm_map_unlock(dst_map); -- return KERN_NO_SPACE; -+ StartAgain: ; -+ -+ vm_map_lock(dst_map); -+ start = ((last = dst_map->first_free) == vm_map_to_entry(dst_map)) ? -+ vm_map_min(dst_map) : last->vme_end; -+ -+ while (TRUE) { -+ vm_map_entry_t next = last->vme_next; -+ vm_offset_t end = start + size; -+ -+ if ((end > dst_map->max_offset) || (end < start)) { -+ if (dst_map->wait_for_space) { -+ if (size <= (dst_map->max_offset - dst_map->min_offset)) { -+ assert_wait((event_t) dst_map, TRUE); -+ vm_map_unlock(dst_map); -+ thread_block((void (*)()) 0); -+ goto StartAgain; -+ } -+ } -+ vm_map_unlock(dst_map); -+ printf_once("no more room for vm_map_copyout in %p\n", dst_map); -+ return(KERN_NO_SPACE); -+ } -+ -+ if ((next == vm_map_to_entry(dst_map)) || -+ (next->vme_start >= end)) -+ break; -+ -+ last = next; -+ start = last->vme_end; - } - - /* -@@ -2604,7 +2515,6 @@ kern_return_t vm_map_copyout( - copy->cpy_hdr.nentries = 0; - copy->cpy_hdr.entries_pageable = dst_map->hdr.entries_pageable; - rbtree_init(©->cpy_hdr.tree); -- rbtree_init(©->cpy_hdr.gap_tree); - vm_map_copy_first_entry(copy) = - vm_map_copy_last_entry(copy) = - vm_map_copy_to_entry(copy); -@@ -2636,11 +2546,6 @@ kern_return_t vm_map_copyout( - entry->vme_start += adjustment; - entry->vme_end += adjustment; - -- /* -- * XXX There is no need to update the gap tree here. -- * See vm_map_copy_insert. -- */ -- - entry->inheritance = VM_INHERIT_DEFAULT; - entry->protection = VM_PROT_DEFAULT; - entry->max_protection = VM_PROT_ALL; -@@ -2786,19 +2691,44 @@ kern_return_t vm_map_copyout_page_list( - - size = round_page(copy->offset + copy->size) - - trunc_page(copy->offset); -- -+StartAgain: - vm_map_lock(dst_map); -+ must_wire = dst_map->wiring_required; - -- last = vm_map_find_entry_anywhere(dst_map, size, 0, FALSE, &start); -- -- if (last == NULL) { -- vm_map_unlock(dst_map); -- return KERN_NO_SPACE; -+ last = dst_map->first_free; -+ if (last == vm_map_to_entry(dst_map)) { -+ start = vm_map_min(dst_map); -+ } else { -+ start = last->vme_end; - } - -- end = start + size; -+ while (TRUE) { -+ vm_map_entry_t next = last->vme_next; -+ end = start + size; - -- must_wire = dst_map->wiring_required; -+ if ((end > dst_map->max_offset) || (end < start)) { -+ if (dst_map->wait_for_space) { -+ if (size <= (dst_map->max_offset - -+ dst_map->min_offset)) { -+ assert_wait((event_t) dst_map, TRUE); -+ vm_map_unlock(dst_map); -+ thread_block((void (*)()) 0); -+ goto StartAgain; -+ } -+ } -+ vm_map_unlock(dst_map); -+ printf_once("no more room for vm_map_copyout_page_list in %p\n", dst_map); -+ return(KERN_NO_SPACE); -+ } -+ -+ if ((next == vm_map_to_entry(dst_map)) || -+ (next->vme_start >= end)) { -+ break; -+ } -+ -+ last = next; -+ start = last->vme_end; -+ } - - /* - * See whether we can avoid creating a new entry (and object) by -@@ -2885,7 +2815,6 @@ kern_return_t vm_map_copyout_page_list( - */ - dst_map->size += size; - last->vme_end = end; -- vm_map_gap_update(&dst_map->hdr, last); - - SAVE_HINT(dst_map, last); - -@@ -3173,7 +3102,6 @@ kern_return_t vm_map_copyin( - copy->cpy_hdr.nentries = 0; - copy->cpy_hdr.entries_pageable = TRUE; - rbtree_init(©->cpy_hdr.tree); -- rbtree_init(©->cpy_hdr.gap_tree); - - copy->offset = src_addr; - copy->size = len; -@@ -4696,8 +4624,8 @@ void vm_map_simplify( - map->first_free = prev_entry; - - SAVE_HINT(map, prev_entry); -- prev_entry->vme_end = this_entry->vme_end; - vm_map_entry_unlink(map, this_entry); -+ prev_entry->vme_end = this_entry->vme_end; - vm_object_deallocate(this_entry->object.vm_object); - vm_map_entry_dispose(map, this_entry); - } -diff --git b/vm/vm_map.h a/vm/vm_map.h -index 74c86a7..b4ba7c7 100644 ---- b/vm/vm_map.h -+++ a/vm/vm_map.h -@@ -50,7 +50,6 @@ - #include <vm/vm_object.h> - #include <vm/vm_page.h> - #include <vm/vm_types.h> --#include <kern/list.h> - #include <kern/lock.h> - #include <kern/rbtree.h> - #include <kern/macros.h> -@@ -106,17 +105,9 @@ struct vm_map_entry { - #define vme_start links.start - #define vme_end links.end - struct rbtree_node tree_node; /* links to other entries in tree */ -- struct rbtree_node gap_node; /* links to other entries in gap tree */ -- struct list gap_list; /* links to other entries with -- the same gap size */ -- vm_size_t gap_size; /* size of available memory -- following this entry */ - union vm_map_object object; /* object I point to */ - vm_offset_t offset; /* offset into object */ - unsigned int -- /* boolean_t */ in_gap_tree:1, /* entry is in the gap tree if true, -- or linked to other entries with -- the same gap size if false */ - /* boolean_t */ is_shared:1, /* region is shared */ - /* boolean_t */ is_sub_map:1, /* Is "object" a submap? */ - /* boolean_t */ in_transition:1, /* Entry being changed */ -@@ -150,8 +141,6 @@ typedef struct vm_map_entry *vm_map_entry_t; - struct vm_map_header { - struct vm_map_links links; /* first, last, min, max */ - struct rbtree tree; /* Sorted tree of entries */ -- struct rbtree gap_tree; /* Sorted tree of gap lists -- for allocations */ - int nentries; /* Number of entries */ - boolean_t entries_pageable; - /* are map entries pageable? */ diff --git a/debian/patches/series b/debian/patches/series index d15664c..b804345 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -4,4 +4,3 @@ 50_initrd.patch 60_bigmem.patch 70_dde.patch -99_RB.patch -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-hurd/gnumach.git
