diff options
| -rw-r--r-- | debian/patches/0001-procfs-fix-argument-parsing.patch | 36 | ||||
| -rw-r--r-- | debian/patches/0002-libports-use-protected-payloads-to-optimize-the-obje.patch | 689 | ||||
| -rw-r--r-- | debian/patches/series | 2 |
3 files changed, 727 insertions, 0 deletions
diff --git a/debian/patches/0001-procfs-fix-argument-parsing.patch b/debian/patches/0001-procfs-fix-argument-parsing.patch new file mode 100644 index 00000000..668a852c --- /dev/null +++ b/debian/patches/0001-procfs-fix-argument-parsing.patch @@ -0,0 +1,36 @@ +From 785f4aea18b5705e63609001d2aa12871a774804 Mon Sep 17 00:00:00 2001 +From: Justus Winter <4winter@informatik.uni-hamburg.de> +Date: Tue, 7 Apr 2015 12:53:03 +0200 +Subject: [PATCH hurd 1/2] procfs: fix argument parsing + +* procfs/main.c (argp_parser): Fix argument parsing. +--- + procfs/main.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/procfs/main.c b/procfs/main.c +index d07dea8..d775b32 100644 +--- a/procfs/main.c ++++ b/procfs/main.c +@@ -120,15 +120,15 @@ argp_parser (int key, char *arg, struct argp_state *state) + + case NODEV_KEY: + /* Ignored for compatibility with Linux' procfs. */ +- ;; ++ break; + + case NOEXEC_KEY: + /* Ignored for compatibility with Linux' procfs. */ +- ;; ++ break; + + case NOSUID_KEY: + /* Ignored for compatibility with Linux' procfs. */ +- ;; ++ break; + + default: + return ARGP_ERR_UNKNOWN; +-- +2.1.4 + diff --git a/debian/patches/0002-libports-use-protected-payloads-to-optimize-the-obje.patch b/debian/patches/0002-libports-use-protected-payloads-to-optimize-the-obje.patch new file mode 100644 index 00000000..25b7079c --- /dev/null +++ b/debian/patches/0002-libports-use-protected-payloads-to-optimize-the-obje.patch @@ -0,0 +1,689 @@ +From e1e1748f92e4315c3b5864bce60ee60553c50aa5 Mon Sep 17 00:00:00 2001 +From: Justus Winter <4winter@informatik.uni-hamburg.de> +Date: Sat, 23 Nov 2013 16:12:55 +0100 +Subject: [PATCH hurd 2/2] libports: use protected payloads to optimize the + object lookup + +* NEWS: Mention protected payloads. +* libports/Makefile (SRCS): Add `port-deref-deferred.c'. +* libports/create-internal.c (_ports_create_port_internal): Set the +protected payload to the objects address. +* libports/import-port.c (ports_import_port): Likewise. +* libports/reallocate-from-external.c (ports_reallocate_from_external): +Likewise. +* libports/reallocate-port.c (ports_reallocate_port): Likewise. +* libports/transfer-right.c (ports_transfer_right): Likewise. +* libports/manage-multithread.c (ports_manage_port_operations_multithread): +Use the protected payload for the object lookup if provided. Add +thread pool management calls. +* libports/manage-one-thread.c (ports_manage_port_operations_one_thread): +Likewise. +* libports/destroy-right.c (ports_destroy_right): Defer the +dereferencing of outstanding send rights to avoid a port_info +use-after-free. +* libports/port-deref-deferred.c: New file. +* libports/port-deref-deferred.h: Likewise. +* libports/ports.h (struct port_bucket): New field `threadpool'. +(ports_lookup_payload): Check `port_right'. +--- + NEWS | 2 + + libports/Makefile | 2 +- + libports/complete-deallocate.c | 5 +- + libports/create-bucket.c | 1 + + libports/create-internal.c | 6 +- + libports/destroy-right.c | 56 ++++++++++--- + libports/import-port.c | 6 +- + libports/manage-multithread.c | 31 ++++++- + libports/manage-one-thread.c | 20 ++++- + libports/port-deref-deferred.c | 162 ++++++++++++++++++++++++++++++++++++ + libports/port-deref-deferred.h | 87 +++++++++++++++++++ + libports/ports.h | 6 ++ + libports/reallocate-from-external.c | 4 + + libports/reallocate-port.c | 4 + + libports/transfer-right.c | 3 + + 15 files changed, 375 insertions(+), 20 deletions(-) + create mode 100644 libports/port-deref-deferred.c + create mode 100644 libports/port-deref-deferred.h + +diff --git a/NEWS b/NEWS +index b047aed..18e1489 100644 +--- a/NEWS ++++ b/NEWS +@@ -6,6 +6,8 @@ problems have been identified using static analysis and exercising + tools, and have subsequently been fixed. + + The message dispatching code in the Hurd servers has been improved. ++Among other things, we now make use of the protected payloads ++introduced in GNU Mach 1.5. + + The embedded gz and bz2 decompressor code has been removed, libz and + libbz2 is used instead. +diff --git a/libports/Makefile b/libports/Makefile +index f49cb9f..b8b82ee 100644 +--- a/libports/Makefile ++++ b/libports/Makefile +@@ -36,7 +36,7 @@ SRCS = create-bucket.c create-class.c \ + interrupt-operation.c interrupt-on-notify.c interrupt-notified-rpcs.c \ + dead-name.c create-port.c import-port.c default-uninhibitable-rpcs.c \ + claim-right.c transfer-right.c create-port-noinstall.c create-internal.c \ +- interrupted.c extern-inline.c ++ interrupted.c extern-inline.c port-deref-deferred.c + + installhdrs = ports.h + +diff --git a/libports/complete-deallocate.c b/libports/complete-deallocate.c +index 0d852f5..c81425e 100644 +--- a/libports/complete-deallocate.c ++++ b/libports/complete-deallocate.c +@@ -27,7 +27,7 @@ _ports_complete_deallocate (struct port_info *pi) + { + assert ((pi->flags & PORT_HAS_SENDRIGHTS) == 0); + +- if (pi->port_right) ++ if (MACH_PORT_VALID (pi->port_right)) + { + struct references result; + +@@ -37,7 +37,8 @@ _ports_complete_deallocate (struct port_info *pi) + { + /* A reference was reacquired through a hash table lookup. + It's fine, we didn't touch anything yet. */ +- pthread_mutex_unlock (&_ports_htable_lock); ++ assert (! "reacquired reference w/o send rights"); ++ pthread_rwlock_unlock (&_ports_htable_lock); + return; + } + +diff --git a/libports/create-bucket.c b/libports/create-bucket.c +index 2c5f1b6..82c00a4 100644 +--- a/libports/create-bucket.c ++++ b/libports/create-bucket.c +@@ -48,5 +48,6 @@ ports_create_bucket () + + hurd_ihash_init (&ret->htable, offsetof (struct port_info, hentry)); + ret->rpcs = ret->flags = ret->count = 0; ++ _ports_threadpool_init (&ret->threadpool); + return ret; + } +diff --git a/libports/create-internal.c b/libports/create-internal.c +index 2d85931..d79dc78 100644 +--- a/libports/create-internal.c ++++ b/libports/create-internal.c +@@ -99,7 +99,11 @@ _ports_create_port_internal (struct port_class *class, + bucket->count++; + class->count++; + pthread_mutex_unlock (&_ports_lock); +- ++ ++ /* This is an optimization. It may fail. */ ++ mach_port_set_protected_payload (mach_task_self (), port, ++ (unsigned long) pi); ++ + if (install) + { + err = mach_port_move_member (mach_task_self (), pi->port_right, +diff --git a/libports/destroy-right.c b/libports/destroy-right.c +index 448b379..276255f 100644 +--- a/libports/destroy-right.c ++++ b/libports/destroy-right.c +@@ -1,5 +1,5 @@ + /* +- Copyright (C) 1995, 1996, 1999 Free Software Foundation, Inc. ++ Copyright (C) 1995, 1996, 1999, 2014 Free Software Foundation, Inc. + Written by Michael I. Bushnell. + + This file is part of the GNU Hurd. +@@ -22,30 +22,62 @@ + #include <hurd/ihash.h> + #include <assert.h> + ++#include <pthread.h> ++#include <error.h> ++#include <time.h> ++#include <unistd.h> ++ + error_t + ports_destroy_right (void *portstruct) + { + struct port_info *pi = portstruct; ++ mach_port_t port_right; ++ int defer = 0; + error_t err; + +- if (pi->port_right != MACH_PORT_NULL) ++ pthread_mutex_lock (&_ports_lock); ++ port_right = pi->port_right; ++ pi->port_right = MACH_PORT_DEAD; ++ ++ if (pi->flags & PORT_HAS_SENDRIGHTS) ++ { ++ pi->flags &= ~PORT_HAS_SENDRIGHTS; ++ ++ /* There are outstanding send rights, so we might get more ++ messages. Attached to the messages is a reference to the ++ port_info object. Of course we destroyed the receive right ++ these were send to above, but the message could already have ++ been dequeued to userspace. ++ ++ Previously, those messages would have carried an stale name, ++ which would have caused a hash table lookup failure. ++ However, stale payloads results in port_info use-after-free. ++ Therefore, we cannot release the reference here, but defer ++ that instead until all currently running threads have gone ++ through a quiescent state. */ ++ defer = 1; ++ } ++ ++ if (MACH_PORT_VALID (port_right)) + { ++ mach_port_clear_protected_payload (mach_task_self (), port_right); ++ + pthread_rwlock_wrlock (&_ports_htable_lock); + hurd_ihash_locp_remove (&_ports_htable, pi->ports_htable_entry); + hurd_ihash_locp_remove (&pi->bucket->htable, pi->hentry); + pthread_rwlock_unlock (&_ports_htable_lock); +- err = mach_port_mod_refs (mach_task_self (), pi->port_right, +- MACH_PORT_RIGHT_RECEIVE, -1); +- assert_perror (err); +- +- pi->port_right = MACH_PORT_NULL; ++ } ++ pthread_mutex_unlock (&_ports_lock); + +- if (pi->flags & PORT_HAS_SENDRIGHTS) +- { +- pi->flags &= ~PORT_HAS_SENDRIGHTS; +- ports_port_deref (pi); +- } ++ if (MACH_PORT_VALID (port_right)) ++ { ++ err = mach_port_mod_refs (mach_task_self (), port_right, ++ MACH_PORT_RIGHT_RECEIVE, -1); ++ assert_perror (err); + } + ++ if (defer) ++ _ports_port_deref_deferred (pi); ++ + return 0; + } +diff --git a/libports/import-port.c b/libports/import-port.c +index c337c85..2c638e1 100644 +--- a/libports/import-port.c ++++ b/libports/import-port.c +@@ -93,7 +93,11 @@ ports_import_port (struct port_class *class, struct port_bucket *bucket, + bucket->count++; + class->count++; + pthread_mutex_unlock (&_ports_lock); +- ++ ++ /* This is an optimization. It may fail. */ ++ mach_port_set_protected_payload (mach_task_self (), port, ++ (unsigned long) pi); ++ + mach_port_move_member (mach_task_self (), port, bucket->portset); + + if (stat.mps_srights) +diff --git a/libports/manage-multithread.c b/libports/manage-multithread.c +index 58814d2..dcb6905 100644 +--- a/libports/manage-multithread.c ++++ b/libports/manage-multithread.c +@@ -167,7 +167,21 @@ ports_manage_port_operations_multithread (struct port_bucket *bucket, + outp->RetCodeType = RetCodeType; + outp->RetCode = MIG_BAD_ID; + +- pi = ports_lookup_port (bucket, inp->msgh_local_port, 0); ++ if (MACH_MSGH_BITS_LOCAL (inp->msgh_bits) == ++ MACH_MSG_TYPE_PROTECTED_PAYLOAD) ++ pi = ports_lookup_payload (bucket, inp->msgh_protected_payload, NULL); ++ else ++ { ++ pi = ports_lookup_port (bucket, inp->msgh_local_port, 0); ++ if (pi) ++ { ++ inp->msgh_bits = MACH_MSGH_BITS ( ++ MACH_MSGH_BITS_REMOTE (inp->msgh_bits), ++ MACH_MSG_TYPE_PROTECTED_PAYLOAD); ++ inp->msgh_protected_payload = (unsigned long) pi; ++ } ++ } ++ + if (pi) + { + error_t err = ports_begin_rpc (pi, inp->msgh_id, &link); +@@ -203,10 +217,19 @@ ports_manage_port_operations_multithread (struct port_bucket *bucket, + void * + thread_function (void *arg) + { ++ struct ports_thread thread; + int master = (int) arg; + int timeout; + error_t err; + ++ int synchronized_demuxer (mach_msg_header_t *inp, ++ mach_msg_header_t *outheadp) ++ { ++ int r = internal_demuxer (inp, outheadp); ++ _ports_thread_quiescent (&bucket->threadpool, &thread); ++ return r; ++ } ++ + adjust_priority (__atomic_load_n (&totalthreads, __ATOMIC_RELAXED)); + + if (hook) +@@ -217,10 +240,13 @@ ports_manage_port_operations_multithread (struct port_bucket *bucket, + else + timeout = thread_timeout; + ++ _ports_thread_online (&bucket->threadpool, &thread); ++ + startover: + + do +- err = mach_msg_server_timeout (internal_demuxer, 0, bucket->portset, ++ err = mach_msg_server_timeout (synchronized_demuxer, ++ 0, bucket->portset, + timeout ? MACH_RCV_TIMEOUT : 0, + timeout); + while (err != MACH_RCV_TIMED_OUT); +@@ -240,6 +266,7 @@ ports_manage_port_operations_multithread (struct port_bucket *bucket, + } + __atomic_sub_fetch (&totalthreads, 1, __ATOMIC_RELAXED); + } ++ _ports_thread_offline (&bucket->threadpool, &thread); + return NULL; + } + +diff --git a/libports/manage-one-thread.c b/libports/manage-one-thread.c +index cbd2df7..192907a 100644 +--- a/libports/manage-one-thread.c ++++ b/libports/manage-one-thread.c +@@ -25,6 +25,7 @@ ports_manage_port_operations_one_thread (struct port_bucket *bucket, + ports_demuxer_type demuxer, + int timeout) + { ++ struct ports_thread thread; + error_t err; + + int +@@ -57,7 +58,21 @@ ports_manage_port_operations_one_thread (struct port_bucket *bucket, + outp->RetCodeType = RetCodeType; + outp->RetCode = MIG_BAD_ID; + +- pi = ports_lookup_port (bucket, inp->msgh_local_port, 0); ++ if (MACH_MSGH_BITS_LOCAL (inp->msgh_bits) == ++ MACH_MSG_TYPE_PROTECTED_PAYLOAD) ++ pi = ports_lookup_payload (bucket, inp->msgh_protected_payload, NULL); ++ else ++ { ++ pi = ports_lookup_port (bucket, inp->msgh_local_port, 0); ++ if (pi) ++ { ++ inp->msgh_bits = MACH_MSGH_BITS ( ++ MACH_MSGH_BITS_REMOTE (inp->msgh_bits), ++ MACH_MSG_TYPE_PROTECTED_PAYLOAD); ++ inp->msgh_protected_payload = (unsigned long) pi; ++ } ++ } ++ + if (pi) + { + err = ports_begin_rpc (pi, inp->msgh_id, &link); +@@ -83,6 +98,7 @@ ports_manage_port_operations_one_thread (struct port_bucket *bucket, + status = 1; + } + ++ _ports_thread_quiescent (&bucket->threadpool, &thread); + return status; + } + +@@ -93,8 +109,10 @@ ports_manage_port_operations_one_thread (struct port_bucket *bucket, + zero. */ + timeout = 0; + ++ _ports_thread_online (&bucket->threadpool, &thread); + do + err = mach_msg_server_timeout (internal_demuxer, 0, bucket->portset, + timeout ? MACH_RCV_TIMEOUT : 0, timeout); + while (err != MACH_RCV_TIMED_OUT); ++ _ports_thread_offline (&bucket->threadpool, &thread); + } +diff --git a/libports/port-deref-deferred.c b/libports/port-deref-deferred.c +new file mode 100644 +index 0000000..f5b3fda +--- /dev/null ++++ b/libports/port-deref-deferred.c +@@ -0,0 +1,162 @@ ++/* Delayed deallocation of port_info objects. ++ ++ Copyright (C) 2015 Free Software Foundation, Inc. ++ ++ Written by Justus Winter <4winter@informatik.uni-hamburg.de> ++ ++ This file is part of the GNU Hurd. ++ ++ The GNU Hurd is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 2, or (at ++ your option) any later version. ++ ++ The GNU Hurd is distributed in the hope that it will be useful, but ++ WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the GNU Hurd. If not, see <http://www.gnu.org/licenses/>. */ ++ ++#include "ports.h" ++#include <assert.h> ++ ++#include <pthread.h> ++ ++/* ++ * A threadpool has a color indicating which threads belong to the old ++ * generation. ++ */ ++#define COLOR_BLACK 0 ++#define COLOR_WHITE 1 ++#define COLOR_INVALID ~0U ++ ++static inline int ++valid_color (unsigned int c) ++{ ++ return c == COLOR_BLACK || c == COLOR_WHITE; ++} ++ ++static inline unsigned int ++flip_color (unsigned int c) ++{ ++ assert (valid_color (c)); ++ return ! c; ++} ++ ++/* Initialize the thread pool. */ ++void ++_ports_threadpool_init (struct ports_threadpool *pool) ++{ ++ pthread_spin_init (&pool->lock, PTHREAD_PROCESS_PRIVATE); ++ pool->color = COLOR_BLACK; ++ pool->old_threads = 0; ++ pool->old_objects = NULL; ++ pool->young_threads = 0; ++ pool->young_objects = NULL; ++} ++ ++/* Turn all young objects and threads into old ones. */ ++static inline void ++flip_generations (struct ports_threadpool *pool) ++{ ++ assert (pool->old_threads == 0); ++ pool->old_threads = pool->young_threads; ++ pool->old_objects = pool->young_objects; ++ pool->young_threads = 0; ++ pool->young_objects = NULL; ++ pool->color = flip_color (pool->color); ++} ++ ++/* Called by a thread to join a thread pool. */ ++void ++_ports_thread_online (struct ports_threadpool *pool, ++ struct ports_thread *thread) ++{ ++ pthread_spin_lock (&pool->lock); ++ thread->color = flip_color (pool->color); ++ pool->young_threads += 1; ++ pthread_spin_unlock (&pool->lock); ++} ++ ++struct pi_list ++{ ++ struct pi_list *next; ++ struct port_info *pi; ++}; ++ ++/* Called by a thread that enters its quiescent period. */ ++void ++_ports_thread_quiescent (struct ports_threadpool *pool, ++ struct ports_thread *thread) ++{ ++ struct pi_list *free_list = NULL, *p; ++ assert (valid_color (thread->color)); ++ ++ pthread_spin_lock (&pool->lock); ++ if (thread->color == pool->color) ++ { ++ pool->old_threads -= 1; ++ pool->young_threads += 1; ++ thread->color = flip_color (thread->color); ++ ++ if (pool->old_threads == 0) ++ { ++ free_list = pool->old_objects; ++ flip_generations (pool); ++ } ++ } ++ pthread_spin_unlock (&pool->lock); ++ ++ for (p = free_list; p;) ++ { ++ struct pi_list *old = p; ++ p = p->next; ++ ++ ports_port_deref (old->pi); ++ free (old); ++ } ++} ++ ++/* Called by a thread to leave a thread pool. */ ++void ++_ports_thread_offline (struct ports_threadpool *pool, ++ struct ports_thread *thread) ++{ ++ assert (valid_color (thread->color)); ++ ++ retry: ++ pthread_spin_lock (&pool->lock); ++ if (thread->color == pool->color) ++ { ++ pthread_spin_unlock (&pool->lock); ++ _ports_thread_quiescent (pool, thread); ++ goto retry; ++ } ++ thread->color = COLOR_INVALID; ++ pool->young_threads -= 1; ++ pthread_spin_unlock (&pool->lock); ++} ++ ++/* Schedule an object for deallocation. */ ++void ++_ports_port_deref_deferred (struct port_info *pi) ++{ ++ struct ports_threadpool *pool = &pi->bucket->threadpool; ++ ++ struct pi_list *pl = malloc (sizeof *pl); ++ if (pl == NULL) ++ return; ++ pl->pi = pi; ++ ++ pthread_spin_lock (&pool->lock); ++ pl->next = pool->young_objects; ++ pool->young_objects = pl; ++ if (pool->old_threads == 0) ++ { ++ assert (pool->old_objects == NULL); ++ flip_generations (pool); ++ } ++ pthread_spin_unlock (&pool->lock); ++} +diff --git a/libports/port-deref-deferred.h b/libports/port-deref-deferred.h +new file mode 100644 +index 0000000..ec1dd27 +--- /dev/null ++++ b/libports/port-deref-deferred.h +@@ -0,0 +1,87 @@ ++/* Delayed deallocation of port_info objects. ++ ++ Copyright (C) 2015 Free Software Foundation, Inc. ++ ++ Written by Justus Winter <4winter@informatik.uni-hamburg.de> ++ ++ This file is part of the GNU Hurd. ++ ++ The GNU Hurd is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 2, or (at ++ your option) any later version. ++ ++ The GNU Hurd is distributed in the hope that it will be useful, but ++ WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with the GNU Hurd. If not, see <http://www.gnu.org/licenses/>. */ ++ ++#ifndef _HURD_PORTS_DEREF_DEFERRED_ ++#define _HURD_PORTS_DEREF_DEFERRED_ ++ ++/* A list of port_info objects. */ ++struct pi_list; ++ ++/* We use protected payloads to look up objects without taking a lock. ++ A complication arises if we destroy an object using ++ ports_destroy_right. To avoid payloads from becoming stale (and ++ resulting in invalid memory accesses when being interpreted as ++ pointer), we delay the deallocation of those object until all ++ threads running at the time of the objects destruction are done ++ with whatever they were doing and entered a quiescent period. */ ++struct ports_threadpool ++{ ++ /* Access to the threadpool object is serialized by this lock. */ ++ pthread_spinlock_t lock; ++ ++ /* We maintain two sets of objects and threads. Each thread and the ++ threadpool itself has a color. If a thread has the same color as ++ the thread pool, it belongs to the old generation. */ ++ unsigned int color; ++ ++ /* The number of old threads. When an old thread enters its ++ quiescent period, it decrements OLD_THREADS and flips its color ++ (hence becoming a young thread). */ ++ size_t old_threads; ++ ++ /* A list of old objects. Once OLD_THREADS drops to zero, they are ++ deallocated, and all young threads and objects become old threads ++ and objects. */ ++ struct pi_list *old_objects; ++ ++ /* The number of young threads. Any thread joining or leaving the ++ thread group must be a young thread. */ ++ size_t young_threads; ++ ++ /* The list of young objects. Any object being marked for delayed ++ deallocation is added to this list. */ ++ struct pi_list *young_objects; ++}; ++ ++/* Per-thread state. */ ++struct ports_thread ++{ ++ unsigned int color; ++}; ++ ++/* Initialize the thread pool. */ ++void _ports_threadpool_init (struct ports_threadpool *); ++ ++/* Called by a thread to join a thread pool. */ ++void _ports_thread_online (struct ports_threadpool *, struct ports_thread *); ++ ++/* Called by a thread that enters its quiescent period. */ ++void _ports_thread_quiescent (struct ports_threadpool *, struct ports_thread *); ++ ++/* Called by a thread to leave a thread pool. */ ++void _ports_thread_offline (struct ports_threadpool *, struct ports_thread *); ++ ++struct port_info; ++ ++/* Schedule an object for deallocation. */ ++void _ports_port_deref_deferred (struct port_info *); ++ ++#endif /* _HURD_PORTS_DEREF_DEFERRED_ */ +diff --git a/libports/ports.h b/libports/ports.h +index f02edb4..9299bc4 100644 +--- a/libports/ports.h ++++ b/libports/ports.h +@@ -29,6 +29,8 @@ + #include <pthread.h> + #include <refcount.h> + ++#include "port-deref-deferred.h" ++ + #ifdef PORTS_DEFINE_EI + #define PORTS_EI + #else +@@ -73,6 +75,7 @@ struct port_bucket + int rpcs; + int flags; + int count; ++ struct ports_threadpool threadpool; + }; + /* FLAGS above are the following: */ + #define PORT_BUCKET_INHIBITED PORTS_INHIBITED +@@ -262,6 +265,9 @@ ports_lookup_payload (struct port_bucket *bucket, + { + struct port_info *pi = (struct port_info *) payload; + ++ if (pi && ! MACH_PORT_VALID (pi->port_right)) ++ pi = NULL; ++ + if (pi && bucket && pi->bucket != bucket) + pi = NULL; + +diff --git a/libports/reallocate-from-external.c b/libports/reallocate-from-external.c +index 7205bd9..d0fae1a 100644 +--- a/libports/reallocate-from-external.c ++++ b/libports/reallocate-from-external.c +@@ -71,6 +71,10 @@ ports_reallocate_from_external (void *portstruct, mach_port_t receive) + pthread_mutex_unlock (&_ports_lock); + assert_perror (err); + ++ /* This is an optimization. It may fail. */ ++ mach_port_set_protected_payload (mach_task_self (), pi->port_right, ++ (unsigned long) pi); ++ + mach_port_move_member (mach_task_self (), receive, pi->bucket->portset); + + if (stat.mps_srights) +diff --git a/libports/reallocate-port.c b/libports/reallocate-port.c +index cc534eb..4e859a1 100644 +--- a/libports/reallocate-port.c ++++ b/libports/reallocate-port.c +@@ -59,6 +59,10 @@ ports_reallocate_port (void *portstruct) + pthread_mutex_unlock (&_ports_lock); + assert_perror (err); + ++ /* This is an optimization. It may fail. */ ++ mach_port_set_protected_payload (mach_task_self (), pi->port_right, ++ (unsigned long) pi); ++ + err = mach_port_move_member (mach_task_self (), pi->port_right, + pi->bucket->portset); + assert_perror (err); +diff --git a/libports/transfer-right.c b/libports/transfer-right.c +index 776a8d2..64de7f7 100644 +--- a/libports/transfer-right.c ++++ b/libports/transfer-right.c +@@ -91,6 +91,9 @@ ports_transfer_right (void *tostruct, + err = hurd_ihash_add (&topi->bucket->htable, port, topi); + pthread_rwlock_unlock (&_ports_htable_lock); + assert_perror (err); ++ /* This is an optimization. It may fail. */ ++ mach_port_set_protected_payload (mach_task_self (), port, ++ (unsigned long) topi); + if (topi->bucket != frompi->bucket) + { + err = mach_port_move_member (mach_task_self (), port, +-- +2.1.4 + diff --git a/debian/patches/series b/debian/patches/series index 49de301c..f6e0cfc2 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -46,3 +46,5 @@ merge-me-0002-startup-faster-reboots.patch thomas_term.patch ajoin.patch proc_disable_new_task_notifications.patch +0001-procfs-fix-argument-parsing.patch +0002-libports-use-protected-payloads-to-optimize-the-obje.patch |