new lockless refcount patches, disable the old ones

5 files changed, 765 insertions, 3 deletions

diff --git a/debian/patches/0001-include-add-lock-less-reference-counting-primitives.patch b/debian/patches/0001-include-add-lock-less-reference-counting-primitives.patch
new file mode 100644
index 00000000..426813a7
--- /dev/null
+++ b/debian/patches/0001-include-add-lock-less-reference-counting-primitives.patch
@@ -0,0 +1,152 @@
+From 2fdfbfae579a84a00bcca2f4888e716ef0bb7578 Mon Sep 17 00:00:00 2001
+From: Justus Winter <4winter@informatik.uni-hamburg.de>
+Date: Tue, 6 May 2014 19:52:04 +0200
+Subject: [PATCH 1/4] include: add lock-less reference counting primitives
+
+* include/refcount.h: New file.
+---
+ include/refcount.h | 132 +++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 132 insertions(+)
+ create mode 100644 include/refcount.h
+
+diff --git a/include/refcount.h b/include/refcount.h
+new file mode 100644
+index 0000000..6e20342
+--- /dev/null
++++ b/include/refcount.h
+@@ -0,0 +1,132 @@
++/* Lock-less reference counting primitives
++
++   Copyright (C) 2014 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_REFCOUNT_H_
++#define _HURD_REFCOUNT_H_
++
++#include <stdint.h>
++
++/* Simple reference counting.  */
++
++/* An opaque type.  You must not access these values directly.  */
++typedef uint32_t refcount_t;
++
++/* Initialize REF with REFERENCES.  */
++extern inline void
++refcount_init (refcount_t *ref, uint32_t references)
++{
++  *ref = references;
++}
++
++/* Increment REF.  Return the result of the operation.  */
++extern inline uint32_t
++refcount_ref (refcount_t *ref)
++{
++  return __atomic_add_fetch (ref, 1, __ATOMIC_RELAXED);
++}
++
++/* Decrement REF.  Return the result of the operation.  */
++extern inline uint32_t
++refcount_deref (refcount_t *ref)
++{
++  return __atomic_sub_fetch (ref, 1, __ATOMIC_RELAXED);
++}
++
++/* Return REF.  */
++extern inline uint32_t
++refcount_references (refcount_t *ref)
++{
++  return __atomic_load_n (ref, __ATOMIC_RELAXED);
++}
++
++
++typedef uint64_t refcounts_t;
++
++struct references {
++  uint32_t hard;
++  uint32_t weak;
++};
++
++union _references {
++  struct references refs;
++  refcounts_t rc;
++};
++
++extern inline void
++refcounts_init (refcounts_t *ref, uint32_t hard, uint32_t weak)
++{
++  ((union _references *) ref)->refs =
++    (struct references) { .hard = hard, .weak = weak };
++}
++
++extern inline void
++refcounts_ref (refcounts_t *ref, struct references *result)
++{
++  const union _references op = { .refs = { .hard = 1 } };
++  refcounts_t r = __atomic_add_fetch (ref, op.rc, __ATOMIC_RELAXED);
++  if (result)
++    ((union _references *) result)->rc = r;
++}
++
++extern inline void
++refcounts_deref (refcounts_t *ref, struct references *result)
++{
++  const union _references op = { .refs = { .hard = 1 } };
++  refcounts_t r = __atomic_sub_fetch (ref, op.rc, __ATOMIC_RELAXED);
++  if (result)
++    ((union _references *) result)->rc = r;
++}
++
++extern inline void
++refcounts_ref_weak (refcounts_t *ref, struct references *result)
++{
++  const union _references op = { .refs = { .weak = 1 } };
++  refcounts_t r = __atomic_add_fetch (ref, op.rc, __ATOMIC_RELAXED);
++  if (result)
++    ((union _references *) result)->rc = r;
++}
++
++extern inline void
++refcounts_deref_weak (refcounts_t *ref, struct references *result)
++{
++  const union _references op = { .refs = { .weak = 1 } };
++  refcounts_t r = __atomic_sub_fetch (ref, op.rc, __ATOMIC_RELAXED);
++  if (result)
++    ((union _references *) result)->rc = r;
++}
++
++extern inline uint32_t
++refcounts_hard_references (refcounts_t *ref)
++{
++  union _references result;
++  result.rc = __atomic_load_n (ref, __ATOMIC_RELAXED);
++  return result.refs.hard;
++}
++
++extern inline uint32_t
++refcounts_weak_references (refcounts_t *ref)
++{
++  union _references result;
++  result.rc = __atomic_load_n (ref, __ATOMIC_RELAXED);
++  return result.refs.weak;
++}
++
++#endif /* _HURD_REFCOUNT_H_ */
+-- 
+2.0.0.rc0
+
diff --git a/debian/patches/0002-libports-lock-less-reference-counting-for-port_info-.patch b/debian/patches/0002-libports-lock-less-reference-counting-for-port_info-.patch
new file mode 100644
index 00000000..e5afb5cf
--- /dev/null
+++ b/debian/patches/0002-libports-lock-less-reference-counting-for-port_info-.patch
@@ -0,0 +1,296 @@
+From c19e3afec65c9d36d1ed2cad8495dc8dc1799b4b Mon Sep 17 00:00:00 2001
+From: Justus Winter <4winter@informatik.uni-hamburg.de>
+Date: Sat, 3 May 2014 01:02:35 +0200
+Subject: [PATCH 2/4] libports: lock-less reference counting for port_info
+ objects
+
+* libports/refcount.h: New file with reference counting primitives.
+* libports/ports.h (struct port_info): Use the new type.
+* libports/bucket-iterate.c: Adjust accordingly.
+* libports/complete-deallocate.c: Likewise.
+* libports/create-internal.c: Likewise.
+* libports/get-right.c: Likewise.
+* libports/import-port.c: Likewise.
+* libports/lookup-port.c: Likewise.
+* libports/port-deref-weak.c: Likewise.
+* libports/port-deref.c: Likewise.
+* libports/port-ref-weak.c: Likewise.
+* libports/port-ref.c: Likewise.
+* libports/reallocate-from-external.c: Likewise.
+* libports/transfer-right.c: Likewise.
+* utils/rpctrace.c: Likewise.
+---
+ libports/bucket-iterate.c           |  2 +-
+ libports/complete-deallocate.c      |  2 ++
+ libports/create-internal.c          |  3 +--
+ libports/get-right.c                |  2 +-
+ libports/import-port.c              |  3 +--
+ libports/lookup-port.c              |  2 +-
+ libports/port-deref-weak.c          | 10 +++-------
+ libports/port-deref.c               | 31 +++++++++++++++----------------
+ libports/port-ref-weak.c            |  8 +++-----
+ libports/port-ref.c                 |  8 +++-----
+ libports/ports.h                    |  4 ++--
+ libports/reallocate-from-external.c |  2 +-
+ libports/transfer-right.c           |  2 +-
+ utils/rpctrace.c                    | 10 ++++++++--
+ 14 files changed, 43 insertions(+), 46 deletions(-)
+
+diff --git a/libports/bucket-iterate.c b/libports/bucket-iterate.c
+index babc204..9230b1f 100644
+--- a/libports/bucket-iterate.c
++++ b/libports/bucket-iterate.c
+@@ -58,7 +58,7 @@ _ports_bucket_class_iterate (struct port_bucket *bucket,
+ 
+       if (class == 0 || pi->class == class)
+ 	{
+-	  pi->refcnt++;
++	  ports_port_ref (pi);
+ 	  p[n] = pi;
+ 	  n++;
+ 	}
+diff --git a/libports/complete-deallocate.c b/libports/complete-deallocate.c
+index 8ce095b..7e7d467 100644
+--- a/libports/complete-deallocate.c
++++ b/libports/complete-deallocate.c
+@@ -35,6 +35,8 @@ _ports_complete_deallocate (struct port_info *pi)
+       pi->port_right = MACH_PORT_NULL;
+     }
+ 
++  pthread_mutex_lock (&_ports_lock);
++
+   *pi->prevp = pi->next;
+   if (pi->next)
+     pi->next->prevp = pi->prevp;
+diff --git a/libports/create-internal.c b/libports/create-internal.c
+index 8551297..9b1a5db 100644
+--- a/libports/create-internal.c
++++ b/libports/create-internal.c
+@@ -54,8 +54,7 @@ _ports_create_port_internal (struct port_class *class,
+     }
+ 
+   pi->class = class;
+-  pi->refcnt = 1;
+-  pi->weakrefcnt = 0;
++  refcounts_init (&pi->refcounts, 1, 0);
+   pi->cancel_threshold = 0;
+   pi->mscount = 0;
+   pi->flags = 0;
+diff --git a/libports/get-right.c b/libports/get-right.c
+index 89050c6..42bfa2b 100644
+--- a/libports/get-right.c
++++ b/libports/get-right.c
+@@ -41,7 +41,7 @@ ports_get_right (void *port)
+   if ((pi->flags & PORT_HAS_SENDRIGHTS) == 0)
+     {
+       pi->flags |= PORT_HAS_SENDRIGHTS;
+-      pi->refcnt++;
++      ports_port_ref (pi);
+       err = mach_port_request_notification (mach_task_self (),
+ 					    pi->port_right,
+ 					    MACH_NOTIFY_NO_SENDERS,
+diff --git a/libports/import-port.c b/libports/import-port.c
+index 226f47e..dd4a2f2 100644
+--- a/libports/import-port.c
++++ b/libports/import-port.c
+@@ -48,8 +48,7 @@ ports_import_port (struct port_class *class, struct port_bucket *bucket,
+     return ENOMEM;
+   
+   pi->class = class;
+-  pi->refcnt = 1 + !!stat.mps_srights;
+-  pi->weakrefcnt = 0;
++  refcounts_init (&pi->refcounts, 1 + !!stat.mps_srights, 0);
+   pi->cancel_threshold = 0;
+   pi->mscount = stat.mps_mscount;
+   pi->flags = stat.mps_srights ? PORT_HAS_SENDRIGHTS : 0;
+diff --git a/libports/lookup-port.c b/libports/lookup-port.c
+index f79f6f0..289369f 100644
+--- a/libports/lookup-port.c
++++ b/libports/lookup-port.c
+@@ -44,7 +44,7 @@ ports_lookup_port (struct port_bucket *bucket,
+     pi = 0;
+ 
+   if (pi)
+-    pi->refcnt++;
++    ports_port_ref (pi);
+ 
+   pthread_mutex_unlock (&_ports_lock);
+   
+diff --git a/libports/port-deref-weak.c b/libports/port-deref-weak.c
+index beb4842..8432660 100644
+--- a/libports/port-deref-weak.c
++++ b/libports/port-deref-weak.c
+@@ -25,12 +25,8 @@ void
+ ports_port_deref_weak (void *portstruct)
+ {
+   struct port_info *pi = portstruct;
+-  
+-  pthread_mutex_lock (&_ports_lock);
+-  assert (pi->weakrefcnt);
+-  pi->weakrefcnt--;
+-  if (pi->refcnt == 0 && pi->weakrefcnt == 0)
++  struct references result;
++  refcounts_deref_weak (&pi->refcounts, &result);
++  if (result.hard == 0 && result.weak == 0)
+     _ports_complete_deallocate (pi);
+-  else
+-    pthread_mutex_unlock (&_ports_lock);
+ }
+diff --git a/libports/port-deref.c b/libports/port-deref.c
+index cf9b238..06451a2 100644
+--- a/libports/port-deref.c
++++ b/libports/port-deref.c
+@@ -26,25 +26,24 @@ ports_port_deref (void *portstruct)
+ {
+   struct port_info *pi = portstruct;
+   int trieddroppingweakrefs = 0;
++  struct references result;
+ 
+- retry:
+-  
+-  pthread_mutex_lock (&_ports_lock);
+-  
+-  if (pi->refcnt == 1 && pi->weakrefcnt
+-      && pi->class->dropweak_routine && !trieddroppingweakrefs)
++  /* If we need to call the dropweak routine, we need to hold one
++     reference while doing so.  We use a weak reference for this
++     purpose, which we acquire before we release our hard reference.
++     The order is important here to prevent a race.  */
++  if (pi->class->dropweak_routine)
++    refcounts_ref_weak (&pi->refcounts, NULL);
++
++  refcounts_deref (&pi->refcounts, &result);
++
++  if (pi->class->dropweak_routine)
+     {
+-      pthread_mutex_unlock (&_ports_lock);
+-      (*pi->class->dropweak_routine) (pi);
+-      trieddroppingweakrefs = 1;
+-      goto retry;
++      if (result.hard == 0 && result.weak > 1)
++        (*pi->class->dropweak_routine) (pi);
++      refcounts_deref_weak (&pi->refcounts, &result);
+     }
+-  
+-  assert (pi->refcnt);
+ 
+-  pi->refcnt--;
+-  if (pi->refcnt == 0 && pi->weakrefcnt == 0)
++  if (result.hard == 0 && result.weak == 0)
+     _ports_complete_deallocate (pi);
+-  else
+-    pthread_mutex_unlock (&_ports_lock);
+ }
+diff --git a/libports/port-ref-weak.c b/libports/port-ref-weak.c
+index c7d3c69..e4b7fc8 100644
+--- a/libports/port-ref-weak.c
++++ b/libports/port-ref-weak.c
+@@ -25,9 +25,7 @@ void
+ ports_port_ref_weak (void *portstruct)
+ {
+   struct port_info *pi = portstruct;
+-  
+-  pthread_mutex_lock (&_ports_lock);
+-  assert (pi->refcnt || pi->weakrefcnt);
+-  pi->weakrefcnt++;
+-  pthread_mutex_unlock (&_ports_lock);
++  struct references result;
++  refcounts_ref_weak (&pi->refcounts, &result);
++  assert (result.hard > 0 || result.weak > 1);
+ }
+diff --git a/libports/port-ref.c b/libports/port-ref.c
+index 92b7118..761c50f 100644
+--- a/libports/port-ref.c
++++ b/libports/port-ref.c
+@@ -25,9 +25,7 @@ void
+ ports_port_ref (void *portstruct)
+ {
+   struct port_info *pi = portstruct;
+-  
+-  pthread_mutex_lock (&_ports_lock);
+-  assert (pi->refcnt || pi->weakrefcnt);
+-  pi->refcnt++;
+-  pthread_mutex_unlock (&_ports_lock);
++  struct references result;
++  refcounts_ref (&pi->refcounts, &result);
++  assert (result.hard > 1 || result.weak > 0);
+ }
+diff --git a/libports/ports.h b/libports/ports.h
+index 7f13124..957ee32 100644
+--- a/libports/ports.h
++++ b/libports/ports.h
+@@ -27,6 +27,7 @@
+ #include <hurd/ihash.h>
+ #include <mach/notify.h>
+ #include <pthread.h>
++#include <refcount.h>
+ 
+ /* These are global values for common flags used in the various structures.
+    Not all of these are meaningful in all flag fields.  */
+@@ -39,8 +40,7 @@
+ struct port_info
+ {
+   struct port_class *class;
+-  int refcnt;
+-  int weakrefcnt;
++  refcounts_t refcounts;
+   mach_port_mscount_t mscount;
+   mach_msg_seqno_t cancel_threshold;
+   int flags;
+diff --git a/libports/reallocate-from-external.c b/libports/reallocate-from-external.c
+index 8cccb2a..4dfc59c 100644
+--- a/libports/reallocate-from-external.c
++++ b/libports/reallocate-from-external.c
+@@ -53,7 +53,7 @@ ports_reallocate_from_external (void *portstruct, mach_port_t receive)
+   else if (((pi->flags & PORT_HAS_SENDRIGHTS) == 0) && stat.mps_srights)
+     {
+       pi->flags |= PORT_HAS_SENDRIGHTS;
+-      pi->refcnt++;
++      ports_port_ref (pi);
+     }
+   
+   pi->port_right = receive;
+diff --git a/libports/transfer-right.c b/libports/transfer-right.c
+index 72488a9..f4e0c86 100644
+--- a/libports/transfer-right.c
++++ b/libports/transfer-right.c
+@@ -66,7 +66,7 @@ ports_transfer_right (void *tostruct,
+       else if (((topi->flags & PORT_HAS_SENDRIGHTS) == 0) && hassendrights)
+ 	{
+ 	  topi->flags |= PORT_HAS_SENDRIGHTS;
+-	  topi->refcnt++;
++	  ports_port_ref (topi);
+ 	}
+     }
+   
+diff --git a/utils/rpctrace.c b/utils/rpctrace.c
+index fc913e3..b11fea4 100644
+--- a/utils/rpctrace.c
++++ b/utils/rpctrace.c
+@@ -431,7 +431,9 @@ destroy_receiver_info (struct receiver_info *info)
+   while (send_wrapper)
+     {
+       struct sender_info *next = send_wrapper->next;
+-      assert (TRACED_INFO (send_wrapper)->pi.refcnt == 1);
++      assert (
++	refcounts_hard_references (&TRACED_INFO (send_wrapper)->pi.refcounts)
++	== 1);
+       /* Reset the receive_right of the send wrapper in advance to avoid
+        * destroy_receiver_info is called when the port info is destroyed. */
+       send_wrapper->receive_right = NULL;
+@@ -848,7 +850,11 @@ rewrite_right (mach_port_t *right, mach_msg_type_name_t *type,
+ 	    hurd_ihash_locp_remove (&traced_names, receiver_info->locp);
+ 
+ 	    send_wrapper2 = get_send_wrapper (receiver_info, dest, &rr);
+-	    assert (TRACED_INFO (send_wrapper2)->pi.refcnt == 1);
++	    assert (
++	      refcounts_hard_references (
++		&TRACED_INFO (send_wrapper2)->pi.refcounts)
++	      == 1);
++
+ 	    name = TRACED_INFO (send_wrapper2)->name;
+ 	    TRACED_INFO (send_wrapper2)->name = NULL;
+ 	    /* send_wrapper2 isn't destroyed normally, so we need to unlink
+-- 
+2.0.0.rc0
+
diff --git a/debian/patches/0003-libdiskfs-lock-less-reference-counting-for-peropen-o.patch b/debian/patches/0003-libdiskfs-lock-less-reference-counting-for-peropen-o.patch
new file mode 100644
index 00000000..04a9210c
--- /dev/null
+++ b/debian/patches/0003-libdiskfs-lock-less-reference-counting-for-peropen-o.patch
@@ -0,0 +1,133 @@
+From 124fef363dfd2326799dc884e4960a14f20b1e09 Mon Sep 17 00:00:00 2001
+From: Justus Winter <4winter@informatik.uni-hamburg.de>
+Date: Tue, 6 May 2014 18:58:10 +0200
+Subject: [PATCH 3/4] libdiskfs: lock-less reference counting for peropen
+ objects
+
+* libdiskfs/diskfs.h (struct peropen): Use refcount_t for field refcnt.
+* libdiskfs/peropen-make.c (diskfs_make_peropen): Initialize refcnt.
+* libdiskfs/peropen-rele.c (diskfs_release_peropen): Adjust accordingly.
+* libdiskfs/protid-make.c (diskfs_start_protid): Likewise.  Also, the
+node must no longer be locked, adjust comment accordingly.
+(diskfs_create_protid): Likewise.
+---
+ libdiskfs/diskfs.h       |  7 ++++---
+ libdiskfs/peropen-make.c |  2 +-
+ libdiskfs/peropen-rele.c | 11 +++--------
+ libdiskfs/protid-make.c  |  8 ++++----
+ 4 files changed, 12 insertions(+), 16 deletions(-)
+
+diff --git a/libdiskfs/diskfs.h b/libdiskfs/diskfs.h
+index 8151ddc..ae1a150 100644
+--- a/libdiskfs/diskfs.h
++++ b/libdiskfs/diskfs.h
+@@ -28,6 +28,7 @@
+ #include <hurd/iohelp.h>
+ #include <idvec.h>
+ #include <features.h>
++#include <refcount.h>
+ 
+ #ifdef DISKFS_DEFINE_EXTERN_INLINE
+ #define DISKFS_EXTERN_INLINE
+@@ -57,7 +58,7 @@ struct peropen
+ {
+   int filepointer;
+   int lock_status;
+-  int refcnt;
++  refcount_t refcnt;
+   int openstat;
+ 
+   struct node *np;
+@@ -792,12 +793,12 @@ diskfs_create_node (struct node *dir, const char *name, mode_t mode,
+ 		    struct dirstat *ds);
+ 
+ /* Create and return a protid for an existing peropen PO in CRED,
+-   referring to user USER.  The node PO->np must be locked. */
++   referring to user USER.  */
+ error_t diskfs_create_protid (struct peropen *po, struct iouser *user,
+ 			      struct protid **cred);
+ 
+ /* Build and return in CRED a protid which has no user identification, for
+-   peropen PO.  The node PO->np must be locked.  */
++   peropen PO.  */
+ error_t diskfs_start_protid (struct peropen *po, struct protid **cred);
+ 
+ /* Finish building protid CRED started with diskfs_start_protid;
+diff --git a/libdiskfs/peropen-make.c b/libdiskfs/peropen-make.c
+index eba037f..6d5ca01 100644
+--- a/libdiskfs/peropen-make.c
++++ b/libdiskfs/peropen-make.c
+@@ -31,7 +31,7 @@ diskfs_make_peropen (struct node *np, int flags, struct peropen *context,
+ 
+   po->filepointer = 0;
+   po->lock_status = LOCK_UN;
+-  po->refcnt = 0;
++  refcount_init (&po->refcnt, 0);
+   po->openstat = flags;
+   po->np = np;
+   po->path = NULL;
+diff --git a/libdiskfs/peropen-rele.c b/libdiskfs/peropen-rele.c
+index d3f7492..64cea18 100644
+--- a/libdiskfs/peropen-rele.c
++++ b/libdiskfs/peropen-rele.c
+@@ -22,13 +22,8 @@
+ void
+ diskfs_release_peropen (struct peropen *po)
+ {
+-  pthread_mutex_lock (&po->np->lock);
+-
+-  if (--po->refcnt)
+-    {
+-      pthread_mutex_unlock (&po->np->lock);
+-      return;
+-    }
++  if (refcount_deref (&po->refcnt) > 0)
++    return;
+ 
+   if (po->root_parent)
+     mach_port_deallocate (mach_task_self (), po->root_parent);
+@@ -43,7 +38,7 @@ diskfs_release_peropen (struct peropen *po)
+     fshelp_acquire_lock (&po->np->userlock, &po->lock_status,
+ 			 &po->np->lock, LOCK_UN);
+ 
+-  diskfs_nput (po->np);
++  diskfs_nrele (po->np);
+ 
+   free (po->path);
+   free (po);
+diff --git a/libdiskfs/protid-make.c b/libdiskfs/protid-make.c
+index b39b92a..22aaa2e 100644
+--- a/libdiskfs/protid-make.c
++++ b/libdiskfs/protid-make.c
+@@ -20,7 +20,7 @@
+ #include <assert.h>
+ 
+ /* Build and return in CRED a protid which has no user identification, for
+-   peropen PO.  The node PO->np must be locked.  */
++   peropen PO.  */
+ error_t
+ diskfs_start_protid (struct peropen *po, struct protid **cred)
+ {
+@@ -29,7 +29,7 @@ diskfs_start_protid (struct peropen *po, struct protid **cred)
+ 				 sizeof (struct protid), cred);
+   if (! err)
+     {
+-      po->refcnt++;
++      refcount_ref (&po->refcnt);
+       (*cred)->po = po;
+       (*cred)->shared_object = MACH_PORT_NULL;
+       (*cred)->mapped = 0;
+@@ -55,8 +55,8 @@ diskfs_finish_protid (struct protid *cred, struct iouser *user)
+   assert_perror (err);
+ }
+ 
+-/* Create and return a protid for an existing peropen PO in CRED for USER.
+-   The node PO->np must be locked. */
++/* Create and return a protid for an existing peropen PO in CRED for
++   USER.  */
+ error_t
+ diskfs_create_protid (struct peropen *po, struct iouser *user,
+ 		      struct protid **cred)
+-- 
+2.0.0.rc0
+
diff --git a/debian/patches/0004-libtrivfs-lock-less-reference-counting-for-trivfs_pr.patch b/debian/patches/0004-libtrivfs-lock-less-reference-counting-for-trivfs_pr.patch
new file mode 100644
index 00000000..3e76520a
--- /dev/null
+++ b/debian/patches/0004-libtrivfs-lock-less-reference-counting-for-trivfs_pr.patch
@@ -0,0 +1,177 @@
+From fdfa3c69dd5fe5c5be89fa5e70a51dbfc6d61a88 Mon Sep 17 00:00:00 2001
+From: Justus Winter <4winter@informatik.uni-hamburg.de>
+Date: Tue, 6 May 2014 19:07:13 +0200
+Subject: [PATCH 4/4] libtrivfs: lock-less reference counting for trivfs_protid
+ objects
+
+* libtrivfs/trivfs.h (struct trivfs_protid): Use refcount_t for field
+refcnt.
+(struct trivfs_control): Remove unused field lock.
+* libtrivfs/open.c (trivfs_open): Initialize refcnt.
+* libtrivfs/io-reauthenticate.c (trivfs_S_io_reauthenticate): Adjust
+accordingly.
+* libtrivfs/io-restrict-auth.c (trivfs_S_io_restrict_auth): Likewise.
+* libtrivfs/protid-clean.c (trivfs_clean_protid): Likewise.
+* libtrivfs/protid-dup.c (trivfs_protid_dup): Likewise.
+* libtrivfs/cntl-create.c (trivfs_create_control): Drop the mutex
+initialization.
+
+* libtrivfs/peropen-make.c (trivfs_make_peropen): Initialize refcnt.
+* libtrivfs/peropen-rele.c (trivfs_release_peropen): Adjust accordingly.
+* libtrivfs/protid-make.c (trivfs_start_protid): Likewise.  Also, the
+node must no longer be locked, adjust comment accordingly.
+(trivfs_create_protid): Likewise.
+---
+ libtrivfs/cntl-create.c       |  1 -
+ libtrivfs/io-reauthenticate.c |  5 +----
+ libtrivfs/io-restrict-auth.c  |  4 +---
+ libtrivfs/open.c              |  2 +-
+ libtrivfs/protid-clean.c      | 25 ++++++++++++++-----------
+ libtrivfs/protid-dup.c        |  5 +----
+ libtrivfs/trivfs.h            |  4 ++--
+ 7 files changed, 20 insertions(+), 26 deletions(-)
+
+diff --git a/libtrivfs/cntl-create.c b/libtrivfs/cntl-create.c
+index 910daf3..eb9a834 100644
+--- a/libtrivfs/cntl-create.c
++++ b/libtrivfs/cntl-create.c
+@@ -85,7 +85,6 @@ trivfs_create_control (mach_port_t underlying,
+ 	}
+ 
+       (*control)->hook = 0;
+-      pthread_mutex_init (&(*control)->lock, NULL);
+     }
+ 
+ out:
+diff --git a/libtrivfs/io-reauthenticate.c b/libtrivfs/io-reauthenticate.c
+index 7677697..df0ed2e 100644
+--- a/libtrivfs/io-reauthenticate.c
++++ b/libtrivfs/io-reauthenticate.c
+@@ -62,11 +62,8 @@ trivfs_S_io_reauthenticate (struct trivfs_protid *cred,
+     newcred->isroot = 1;
+ 
+   newcred->hook = cred->hook;
+-
+-  pthread_mutex_lock (&cred->po->cntl->lock);
+   newcred->po = cred->po;
+-  newcred->po->refcnt++;
+-  pthread_mutex_unlock (&cred->po->cntl->lock);
++  refcount_ref (&newcred->po->refcnt);
+ 
+   do
+     err = io_restrict_auth (newcred->po->cntl->underlying, &newcred->realnode,
+diff --git a/libtrivfs/io-restrict-auth.c b/libtrivfs/io-restrict-auth.c
+index 65b4fd6..39670fe 100644
+--- a/libtrivfs/io-restrict-auth.c
++++ b/libtrivfs/io-restrict-auth.c
+@@ -110,10 +110,8 @@ trivfs_S_io_restrict_auth (struct trivfs_protid *cred,
+     }
+ 
+   newcred->isroot = 0;
+-  pthread_mutex_lock (&cred->po->cntl->lock);
+   newcred->po = cred->po;
+-  newcred->po->refcnt++;
+-  pthread_mutex_unlock (&cred->po->cntl->lock);
++  refcount_ref (&newcred->po->refcnt);
+   if (cred->isroot && idvec_contains (user->uids, 0))
+     newcred->isroot = 1;
+   newcred->user = user;
+diff --git a/libtrivfs/open.c b/libtrivfs/open.c
+index f64d2ff..97e70a1 100644
+--- a/libtrivfs/open.c
++++ b/libtrivfs/open.c
+@@ -40,7 +40,7 @@ trivfs_open (struct trivfs_control *cntl,
+ 
+   ports_port_ref (cntl);
+ 
+-  po->refcnt = 1;
++  refcount_init (&po->refcnt, 1);
+   po->cntl = cntl;
+   po->openmodes = flags;
+   po->hook = 0;
+diff --git a/libtrivfs/protid-clean.c b/libtrivfs/protid-clean.c
+index f98da6a..815e731 100644
+--- a/libtrivfs/protid-clean.c
++++ b/libtrivfs/protid-clean.c
+@@ -31,19 +31,22 @@ trivfs_clean_protid (void *arg)
+     (*trivfs_protid_destroy_hook) (cred);
+ 
+   /* If we hold the only reference to the peropen, try to get rid of it. */
+-  pthread_mutex_lock (&cntl->lock);
+-  if (cred->po->refcnt == 1 && trivfs_peropen_destroy_hook)
++  if (refcount_deref (&cred->po->refcnt) == 0)
+     {
+-      pthread_mutex_unlock (&cntl->lock);
+-      (*trivfs_peropen_destroy_hook) (cred->po);
+-      pthread_mutex_lock (&cntl->lock);
++      if (trivfs_protid_destroy_hook)
++        {
++          refcount_ref (&cred->po->refcnt);
++          (*trivfs_peropen_destroy_hook) (cred->po);
++          if (refcount_deref (&cred->po->refcnt) == 0)
++            goto free_po;
++        }
++      else
++        {
++        free_po:
++          ports_port_deref (cntl);
++          free (cred->po);
++        }
+     }
+-  if (--cred->po->refcnt == 0)
+-    {
+-      ports_port_deref (cntl);
+-      free (cred->po);
+-    }
+-  pthread_mutex_unlock (&cntl->lock);
+ 
+   iohelp_free_iouser (cred->user);
+ 
+diff --git a/libtrivfs/protid-dup.c b/libtrivfs/protid-dup.c
+index 6169603..75f3ca8 100644
+--- a/libtrivfs/protid-dup.c
++++ b/libtrivfs/protid-dup.c
+@@ -35,11 +35,8 @@ trivfs_protid_dup (struct trivfs_protid *cred, struct trivfs_protid **dup)
+ 
+   if (! err)
+     {
+-      pthread_mutex_lock (&cred->po->cntl->lock);
+       new->po = cred->po;
+-      new->po->refcnt++;
+-      pthread_mutex_unlock (&cred->po->cntl->lock);
+-
++      refcount_ref (&new->po->refcnt);
+       new->isroot = cred->isroot;
+ 
+       err = iohelp_dup_iouser (&new->user, cred->user);
+diff --git a/libtrivfs/trivfs.h b/libtrivfs/trivfs.h
+index bb456ff..8902338 100644
+--- a/libtrivfs/trivfs.h
++++ b/libtrivfs/trivfs.h
+@@ -24,6 +24,7 @@
+ #include <mach/mach.h>
+ #include <hurd/ports.h>
+ #include <hurd/iohelp.h>
++#include <refcount.h>
+ 
+ struct trivfs_protid
+ {
+@@ -41,14 +42,13 @@ struct trivfs_peropen
+ {
+   void *hook;			/* for user use */
+   int openmodes;
+-  int refcnt;
++  refcount_t refcnt;
+   struct trivfs_control *cntl;
+ };
+ 
+ struct trivfs_control
+ {
+   struct port_info pi;
+-  pthread_mutex_t lock;
+   struct port_class *protid_class;
+   struct port_bucket *protid_bucket;
+   mach_port_t filesys_id;
+-- 
+2.0.0.rc0
+
diff --git a/debian/patches/series b/debian/patches/series
index ed566bde..700ef9c2 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -41,9 +41,13 @@ xkb-compat.patch
 mach-defpager-protected-payload.patch
 
 #ext2fs-cache-superblock.patch
-libports-lockless-refcounting.patch
-libports-per-bucket-hashtable.patch
-libports-a-single-hashtable.patch
+#libports-lockless-refcounting.patch
+#libports-per-bucket-hashtable.patch
+#libports-a-single-hashtable.patch
 #libports-current_rpcs_lock.patch
 #libpager-singlethreaded.patch
 #libpager-drop-seqnos.patch
+0001-include-add-lock-less-reference-counting-primitives.patch
+0002-libports-lock-less-reference-counting-for-port_info-.patch
+0003-libdiskfs-lock-less-reference-counting-for-peropen-o.patch
+0004-libtrivfs-lock-less-reference-counting-for-trivfs_pr.patch