diff options
Diffstat (limited to 'debian/patches/0001-libshouldbeinlibc-move-the-reference-counting-primit.patch')
| -rw-r--r-- | debian/patches/0001-libshouldbeinlibc-move-the-reference-counting-primit.patch | 733 |
1 files changed, 0 insertions, 733 deletions
diff --git a/debian/patches/0001-libshouldbeinlibc-move-the-reference-counting-primit.patch b/debian/patches/0001-libshouldbeinlibc-move-the-reference-counting-primit.patch deleted file mode 100644 index da210e9b..00000000 --- a/debian/patches/0001-libshouldbeinlibc-move-the-reference-counting-primit.patch +++ /dev/null @@ -1,733 +0,0 @@ -From 0d3b80f04a1caee51b9995c9626838f85295bb06 Mon Sep 17 00:00:00 2001 -From: Justus Winter <4winter@informatik.uni-hamburg.de> -Date: Sun, 23 Nov 2014 19:09:51 +0100 -Subject: [PATCH hurd 01/28] libshouldbeinlibc: move the reference counting - primitives here - -Declare all functions `extern inline' instead of `static inline'. -This allows us to use them in functions declared as `extern inline'. - -* libshouldbeinlibc/refcount.h: Move here, and declare all functions -`extern inline'. -* libshouldbeinlibc/refcount.c: And define the functions here. -* libshouldbeinlibc/Makefile: Add `refcount.{c,h}'. ---- - include/refcount.h | 320 ------------------------------------------ - libshouldbeinlibc/Makefile | 8 +- - libshouldbeinlibc/refcount.c | 23 +++ - libshouldbeinlibc/refcount.h | 326 +++++++++++++++++++++++++++++++++++++++++++ - 4 files changed, 355 insertions(+), 322 deletions(-) - delete mode 100644 include/refcount.h - create mode 100644 libshouldbeinlibc/refcount.c - create mode 100644 libshouldbeinlibc/refcount.h - -diff --git a/include/refcount.h b/include/refcount.h -deleted file mode 100644 -index ebde42d..0000000 ---- a/include/refcount.h -+++ /dev/null -@@ -1,320 +0,0 @@ --/* 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 <assert.h> --#include <limits.h> --#include <stdint.h> -- --/* Simple reference counting. */ -- --/* An opaque type. You must not access these values directly. */ --typedef unsigned int refcount_t; -- --/* Initialize REF with REFERENCES. REFERENCES must not be zero. */ --static inline void --refcount_init (refcount_t *ref, unsigned int references) --{ -- assert (references > 0 || !"references must not be zero!"); -- *ref = references; --} -- --/* Increment REF. Return the result of the operation. This function -- uses atomic operations. It is not required to serialize calls to -- this function. -- -- This is the unsafe version of refcount_ref. refcount_ref also -- checks for use-after-free errors. When in doubt, use that one -- instead. */ --static inline unsigned int --refcount_unsafe_ref (refcount_t *ref) --{ -- unsigned int r; -- r = __atomic_add_fetch (ref, 1, __ATOMIC_RELAXED); -- assert (r != UINT_MAX || !"refcount overflowed!"); -- return r; --} -- --/* Increment REF. Return the result of the operation. This function -- uses atomic operations. It is not required to serialize calls to -- this function. */ --static inline unsigned int --refcount_ref (refcount_t *ref) --{ -- unsigned int r; -- r = refcount_unsafe_ref (ref); -- assert (r != 1 || !"refcount detected use-after-free!"); -- return r; --} -- --/* Decrement REF. Return the result of the operation. This function -- uses atomic operations. It is not required to serialize calls to -- this function. */ --static inline unsigned int --refcount_deref (refcount_t *ref) --{ -- unsigned int r; -- r = __atomic_sub_fetch (ref, 1, __ATOMIC_RELAXED); -- assert (r != UINT_MAX || !"refcount underflowed!"); -- return r; --} -- --/* Return REF. This function uses atomic operations. It is not -- required to serialize calls to this function. */ --static inline unsigned int --refcount_references (refcount_t *ref) --{ -- return __atomic_load_n (ref, __ATOMIC_RELAXED); --} -- --/* Reference counting with weak references. */ -- --/* An opaque type. You must not access these values directly. */ --typedef union _references refcounts_t; -- --/* Instead, the functions manipulating refcounts_t values write the -- results into this kind of objects. */ --struct references { -- /* We chose the layout of this struct so that when it is used in the -- union _references, the hard reference counts occupy the least -- significant bits. We rely on this layout for atomic promotion -- and demotion of references. See refcounts_promote and -- refcounts_demote for details. */ --#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -- uint32_t hard; -- uint32_t weak; --#else -- uint32_t weak; -- uint32_t hard; --#endif --}; -- --/* We use a union to convert struct reference values to uint64_t which -- we can manipulate atomically. While this behavior is not -- guaranteed by the C standard, it is supported by all major -- compilers. */ --union _references { -- struct references references; -- uint64_t value; --}; -- --/* Initialize REF with HARD and WEAK references. HARD and WEAK must -- not both be zero. */ --static inline void --refcounts_init (refcounts_t *ref, uint32_t hard, uint32_t weak) --{ -- assert ((hard != 0 || weak != 0) || !"references must not both be zero!"); -- ref->references = (struct references) { .hard = hard, .weak = weak }; --} -- --/* Increment the hard reference count of REF. If RESULT is not NULL, -- the result of the operation is written there. This function uses -- atomic operations. It is not required to serialize calls to this -- function. -- -- This is the unsafe version of refcounts_ref. refcounts_ref also -- checks for use-after-free errors. When in doubt, use that one -- instead. */ --static inline void --refcounts_unsafe_ref (refcounts_t *ref, struct references *result) --{ -- const union _references op = { .references = { .hard = 1 } }; -- union _references r; -- r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -- assert (r.references.hard != UINT32_MAX || !"refcount overflowed!"); -- if (result) -- *result = r.references; --} -- --/* Increment the hard reference count of REF. If RESULT is not NULL, -- the result of the operation is written there. This function uses -- atomic operations. It is not required to serialize calls to this -- function. */ --static inline void --refcounts_ref (refcounts_t *ref, struct references *result) --{ -- struct references r; -- refcounts_unsafe_ref (ref, &r); -- assert (! (r.hard == 1 && r.weak == 0) -- || !"refcount detected use-after-free!"); -- if (result) -- *result = r; --} -- --/* Decrement the hard reference count of REF. If RESULT is not NULL, -- the result of the operation is written there. This function uses -- atomic operations. It is not required to serialize calls to this -- function. */ --static inline void --refcounts_deref (refcounts_t *ref, struct references *result) --{ -- const union _references op = { .references = { .hard = 1 } }; -- union _references r; -- r.value = __atomic_sub_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -- assert (r.references.hard != UINT32_MAX || !"refcount underflowed!"); -- if (result) -- *result = r.references; --} -- --/* Promote a weak reference to a hard reference. If RESULT is not -- NULL, the result of the operation is written there. This function -- uses atomic operations. It is not required to serialize calls to -- this function. */ --static inline void --refcounts_promote (refcounts_t *ref, struct references *result) --{ -- /* To promote a weak reference, we need to atomically subtract 1 -- from the weak reference count, and add 1 to the hard reference -- count. -- -- We can subtract by 1 by adding the two's complement of 1 = ~0 to -- a fixed-width value, discarding the overflow. -- -- We do the same in our uint64_t value, but we have chosen the -- layout of struct references so that when it is used in the union -- _references, the weak reference counts occupy the most -- significant bits. When we add ~0 to the weak references, the -- overflow will be discarded as unsigned arithmetic is modulo 2^n. -- So we just add a hard reference. In combination, this is the -- desired operation. */ -- const union _references op = -- { .references = { .weak = ~0U, .hard = 1} }; -- union _references r; -- r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -- assert (r.references.hard != UINT32_MAX || !"refcount overflowed!"); -- assert (r.references.weak != UINT32_MAX || !"refcount underflowed!"); -- if (result) -- *result = r.references; --} -- --/* Demote a hard reference to a weak reference. If RESULT is not -- NULL, the result of the operation is written there. This function -- uses atomic operations. It is not required to serialize calls to -- this function. */ --static inline void --refcounts_demote (refcounts_t *ref, struct references *result) --{ -- /* To demote a hard reference, we need to atomically subtract 1 from -- the hard reference count, and add 1 to the weak reference count. -- -- We can subtract by 1 by adding the two's complement of 1 = ~0 to -- a fixed-width value, discarding the overflow. -- -- We do the same in our uint64_t value, but we have chosen the -- layout of struct references so that when it is used in the union -- _references, the hard reference counts occupy the least -- significant bits. When we add ~0 to the hard references, it will -- overflow into the weak references. This is the desired -- operation. */ -- const union _references op = { .references = { .hard = ~0U } }; -- union _references r; -- r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -- assert (r.references.hard != UINT32_MAX || !"refcount underflowed!"); -- assert (r.references.weak != UINT32_MAX || !"refcount overflowed!"); -- if (result) -- *result = r.references; --} -- --/* Increment the weak reference count of REF. If RESULT is not NULL, -- the result of the operation is written there. This function uses -- atomic operations. It is not required to serialize calls to this -- function. -- -- This is the unsafe version of refcounts_ref_weak. -- refcounts_ref_weak also checks for use-after-free errors. When in -- doubt, use that one instead. */ --static inline void --refcounts_unsafe_ref_weak (refcounts_t *ref, struct references *result) --{ -- const union _references op = { .references = { .weak = 1 } }; -- union _references r; -- r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -- assert (r.references.weak != UINT32_MAX || !"refcount overflowed!"); -- if (result) -- *result = r.references; --} -- --/* Increment the weak reference count of REF. If RESULT is not NULL, -- the result of the operation is written there. This function uses -- atomic operations. It is not required to serialize calls to this -- function. */ --static inline void --refcounts_ref_weak (refcounts_t *ref, struct references *result) --{ -- struct references r; -- refcounts_unsafe_ref_weak (ref, &r); -- assert (! (r.hard == 0 && r.weak == 1) -- || !"refcount detected use-after-free!"); -- if (result) -- *result = r; --} -- --/* Decrement the weak reference count of REF. If RESULT is not NULL, -- the result of the operation is written there. This function uses -- atomic operations. It is not required to serialize calls to this -- function. */ --static inline void --refcounts_deref_weak (refcounts_t *ref, struct references *result) --{ -- const union _references op = { .references = { .weak = 1 } }; -- union _references r; -- r.value = __atomic_sub_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -- assert (r.references.weak != UINT32_MAX || !"refcount underflowed!"); -- if (result) -- *result = r.references; --} -- --/* Store the current reference counts of REF in RESULT. This function -- uses atomic operations. It is not required to serialize calls to -- this function. */ --static inline void --refcounts_references (refcounts_t *ref, struct references *result) --{ -- union _references r; -- r.value =__atomic_load_n (&ref->value, __ATOMIC_RELAXED); -- *result = r.references; --} -- --/* Return the hard reference count of REF. This function uses atomic -- operations. It is not required to serialize calls to this -- function. */ --static inline uint32_t --refcounts_hard_references (refcounts_t *ref) --{ -- struct references result; -- refcounts_references (ref, &result); -- return result.hard; --} -- --/* Return the weak reference count of REF. This function uses atomic -- operations. It is not required to serialize calls to this -- function. */ --static inline uint32_t --refcounts_weak_references (refcounts_t *ref) --{ -- struct references result; -- refcounts_references (ref, &result); -- return result.weak; --} -- --#endif /* _HURD_REFCOUNT_H_ */ -diff --git a/libshouldbeinlibc/Makefile b/libshouldbeinlibc/Makefile -index 14a7939..633d60e 100644 ---- a/libshouldbeinlibc/Makefile -+++ b/libshouldbeinlibc/Makefile -@@ -27,9 +27,13 @@ SRCS = termsize.c timefmt.c exec-reauth.c maptime-funcs.c \ - idvec-impgids.c idvec-verify.c idvec-rep.c \ - ugids.c ugids-argp.c ugids-rep.c ugids-verify.c ugids-subtract.c \ - ugids-auth.c ugids-xinl.c ugids-merge.c ugids-imply.c ugids-posix.c \ -- ugids-verify-auth.c nullauth.c -+ ugids-verify-auth.c nullauth.c \ -+ refcount.c \ -+ - installhdrs = idvec.h timefmt.h maptime.h \ -- wire.h portinfo.h portxlate.h cacheq.h ugids.h nullauth.h -+ wire.h portinfo.h portxlate.h cacheq.h ugids.h nullauth.h \ -+ refcount.h \ -+ - installhdrsubdir = . - - OBJS = $(SRCS:.c=.o) -diff --git a/libshouldbeinlibc/refcount.c b/libshouldbeinlibc/refcount.c -new file mode 100644 -index 0000000..17e01c5 ---- /dev/null -+++ b/libshouldbeinlibc/refcount.c -@@ -0,0 +1,23 @@ -+/* 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/>. */ -+ -+#define REFCOUNT_DEFINE_EI -+#include "refcount.h" -diff --git a/libshouldbeinlibc/refcount.h b/libshouldbeinlibc/refcount.h -new file mode 100644 -index 0000000..e8b0f5b ---- /dev/null -+++ b/libshouldbeinlibc/refcount.h -@@ -0,0 +1,326 @@ -+/* 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_ -+ -+#ifdef REFCOUNT_DEFINE_EI -+#define REFCOUNT_EI -+#else -+#define REFCOUNT_EI __extern_inline -+#endif -+ -+#include <assert.h> -+#include <limits.h> -+#include <stdint.h> -+ -+/* Simple reference counting. */ -+ -+/* An opaque type. You must not access these values directly. */ -+typedef unsigned int refcount_t; -+ -+/* Initialize REF with REFERENCES. REFERENCES must not be zero. */ -+REFCOUNT_EI void -+refcount_init (refcount_t *ref, unsigned int references) -+{ -+ assert (references > 0 || !"references must not be zero!"); -+ *ref = references; -+} -+ -+/* Increment REF. Return the result of the operation. This function -+ uses atomic operations. It is not required to serialize calls to -+ this function. -+ -+ This is the unsafe version of refcount_ref. refcount_ref also -+ checks for use-after-free errors. When in doubt, use that one -+ instead. */ -+REFCOUNT_EI unsigned int -+refcount_unsafe_ref (refcount_t *ref) -+{ -+ unsigned int r; -+ r = __atomic_add_fetch (ref, 1, __ATOMIC_RELAXED); -+ assert (r != UINT_MAX || !"refcount overflowed!"); -+ return r; -+} -+ -+/* Increment REF. Return the result of the operation. This function -+ uses atomic operations. It is not required to serialize calls to -+ this function. */ -+REFCOUNT_EI unsigned int -+refcount_ref (refcount_t *ref) -+{ -+ unsigned int r; -+ r = refcount_unsafe_ref (ref); -+ assert (r != 1 || !"refcount detected use-after-free!"); -+ return r; -+} -+ -+/* Decrement REF. Return the result of the operation. This function -+ uses atomic operations. It is not required to serialize calls to -+ this function. */ -+REFCOUNT_EI unsigned int -+refcount_deref (refcount_t *ref) -+{ -+ unsigned int r; -+ r = __atomic_sub_fetch (ref, 1, __ATOMIC_RELAXED); -+ assert (r != UINT_MAX || !"refcount underflowed!"); -+ return r; -+} -+ -+/* Return REF. This function uses atomic operations. It is not -+ required to serialize calls to this function. */ -+REFCOUNT_EI unsigned int -+refcount_references (refcount_t *ref) -+{ -+ return __atomic_load_n (ref, __ATOMIC_RELAXED); -+} -+ -+/* Reference counting with weak references. */ -+ -+/* An opaque type. You must not access these values directly. */ -+typedef union _references refcounts_t; -+ -+/* Instead, the functions manipulating refcounts_t values write the -+ results into this kind of objects. */ -+struct references { -+ /* We chose the layout of this struct so that when it is used in the -+ union _references, the hard reference counts occupy the least -+ significant bits. We rely on this layout for atomic promotion -+ and demotion of references. See refcounts_promote and -+ refcounts_demote for details. */ -+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -+ uint32_t hard; -+ uint32_t weak; -+#else -+ uint32_t weak; -+ uint32_t hard; -+#endif -+}; -+ -+/* We use a union to convert struct reference values to uint64_t which -+ we can manipulate atomically. While this behavior is not -+ guaranteed by the C standard, it is supported by all major -+ compilers. */ -+union _references { -+ struct references references; -+ uint64_t value; -+}; -+ -+/* Initialize REF with HARD and WEAK references. HARD and WEAK must -+ not both be zero. */ -+REFCOUNT_EI void -+refcounts_init (refcounts_t *ref, uint32_t hard, uint32_t weak) -+{ -+ assert ((hard != 0 || weak != 0) || !"references must not both be zero!"); -+ ref->references = (struct references) { .hard = hard, .weak = weak }; -+} -+ -+/* Increment the hard reference count of REF. If RESULT is not NULL, -+ the result of the operation is written there. This function uses -+ atomic operations. It is not required to serialize calls to this -+ function. -+ -+ This is the unsafe version of refcounts_ref. refcounts_ref also -+ checks for use-after-free errors. When in doubt, use that one -+ instead. */ -+REFCOUNT_EI void -+refcounts_unsafe_ref (refcounts_t *ref, struct references *result) -+{ -+ const union _references op = { .references = { .hard = 1 } }; -+ union _references r; -+ r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -+ assert (r.references.hard != UINT32_MAX || !"refcount overflowed!"); -+ if (result) -+ *result = r.references; -+} -+ -+/* Increment the hard reference count of REF. If RESULT is not NULL, -+ the result of the operation is written there. This function uses -+ atomic operations. It is not required to serialize calls to this -+ function. */ -+REFCOUNT_EI void -+refcounts_ref (refcounts_t *ref, struct references *result) -+{ -+ struct references r; -+ refcounts_unsafe_ref (ref, &r); -+ assert (! (r.hard == 1 && r.weak == 0) -+ || !"refcount detected use-after-free!"); -+ if (result) -+ *result = r; -+} -+ -+/* Decrement the hard reference count of REF. If RESULT is not NULL, -+ the result of the operation is written there. This function uses -+ atomic operations. It is not required to serialize calls to this -+ function. */ -+REFCOUNT_EI void -+refcounts_deref (refcounts_t *ref, struct references *result) -+{ -+ const union _references op = { .references = { .hard = 1 } }; -+ union _references r; -+ r.value = __atomic_sub_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -+ assert (r.references.hard != UINT32_MAX || !"refcount underflowed!"); -+ if (result) -+ *result = r.references; -+} -+ -+/* Promote a weak reference to a hard reference. If RESULT is not -+ NULL, the result of the operation is written there. This function -+ uses atomic operations. It is not required to serialize calls to -+ this function. */ -+REFCOUNT_EI void -+refcounts_promote (refcounts_t *ref, struct references *result) -+{ -+ /* To promote a weak reference, we need to atomically subtract 1 -+ from the weak reference count, and add 1 to the hard reference -+ count. -+ -+ We can subtract by 1 by adding the two's complement of 1 = ~0 to -+ a fixed-width value, discarding the overflow. -+ -+ We do the same in our uint64_t value, but we have chosen the -+ layout of struct references so that when it is used in the union -+ _references, the weak reference counts occupy the most -+ significant bits. When we add ~0 to the weak references, the -+ overflow will be discarded as unsigned arithmetic is modulo 2^n. -+ So we just add a hard reference. In combination, this is the -+ desired operation. */ -+ const union _references op = -+ { .references = { .weak = ~0U, .hard = 1} }; -+ union _references r; -+ r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -+ assert (r.references.hard != UINT32_MAX || !"refcount overflowed!"); -+ assert (r.references.weak != UINT32_MAX || !"refcount underflowed!"); -+ if (result) -+ *result = r.references; -+} -+ -+/* Demote a hard reference to a weak reference. If RESULT is not -+ NULL, the result of the operation is written there. This function -+ uses atomic operations. It is not required to serialize calls to -+ this function. */ -+REFCOUNT_EI void -+refcounts_demote (refcounts_t *ref, struct references *result) -+{ -+ /* To demote a hard reference, we need to atomically subtract 1 from -+ the hard reference count, and add 1 to the weak reference count. -+ -+ We can subtract by 1 by adding the two's complement of 1 = ~0 to -+ a fixed-width value, discarding the overflow. -+ -+ We do the same in our uint64_t value, but we have chosen the -+ layout of struct references so that when it is used in the union -+ _references, the hard reference counts occupy the least -+ significant bits. When we add ~0 to the hard references, it will -+ overflow into the weak references. This is the desired -+ operation. */ -+ const union _references op = { .references = { .hard = ~0U } }; -+ union _references r; -+ r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -+ assert (r.references.hard != UINT32_MAX || !"refcount underflowed!"); -+ assert (r.references.weak != UINT32_MAX || !"refcount overflowed!"); -+ if (result) -+ *result = r.references; -+} -+ -+/* Increment the weak reference count of REF. If RESULT is not NULL, -+ the result of the operation is written there. This function uses -+ atomic operations. It is not required to serialize calls to this -+ function. -+ -+ This is the unsafe version of refcounts_ref_weak. -+ refcounts_ref_weak also checks for use-after-free errors. When in -+ doubt, use that one instead. */ -+REFCOUNT_EI void -+refcounts_unsafe_ref_weak (refcounts_t *ref, struct references *result) -+{ -+ const union _references op = { .references = { .weak = 1 } }; -+ union _references r; -+ r.value = __atomic_add_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -+ assert (r.references.weak != UINT32_MAX || !"refcount overflowed!"); -+ if (result) -+ *result = r.references; -+} -+ -+/* Increment the weak reference count of REF. If RESULT is not NULL, -+ the result of the operation is written there. This function uses -+ atomic operations. It is not required to serialize calls to this -+ function. */ -+REFCOUNT_EI void -+refcounts_ref_weak (refcounts_t *ref, struct references *result) -+{ -+ struct references r; -+ refcounts_unsafe_ref_weak (ref, &r); -+ assert (! (r.hard == 0 && r.weak == 1) -+ || !"refcount detected use-after-free!"); -+ if (result) -+ *result = r; -+} -+ -+/* Decrement the weak reference count of REF. If RESULT is not NULL, -+ the result of the operation is written there. This function uses -+ atomic operations. It is not required to serialize calls to this -+ function. */ -+REFCOUNT_EI void -+refcounts_deref_weak (refcounts_t *ref, struct references *result) -+{ -+ const union _references op = { .references = { .weak = 1 } }; -+ union _references r; -+ r.value = __atomic_sub_fetch (&ref->value, op.value, __ATOMIC_RELAXED); -+ assert (r.references.weak != UINT32_MAX || !"refcount underflowed!"); -+ if (result) -+ *result = r.references; -+} -+ -+/* Store the current reference counts of REF in RESULT. This function -+ uses atomic operations. It is not required to serialize calls to -+ this function. */ -+REFCOUNT_EI void -+refcounts_references (refcounts_t *ref, struct references *result) -+{ -+ union _references r; -+ r.value =__atomic_load_n (&ref->value, __ATOMIC_RELAXED); -+ *result = r.references; -+} -+ -+/* Return the hard reference count of REF. This function uses atomic -+ operations. It is not required to serialize calls to this -+ function. */ -+REFCOUNT_EI uint32_t -+refcounts_hard_references (refcounts_t *ref) -+{ -+ struct references result; -+ refcounts_references (ref, &result); -+ return result.hard; -+} -+ -+/* Return the weak reference count of REF. This function uses atomic -+ operations. It is not required to serialize calls to this -+ function. */ -+REFCOUNT_EI uint32_t -+refcounts_weak_references (refcounts_t *ref) -+{ -+ struct references result; -+ refcounts_references (ref, &result); -+ return result.weak; -+} -+ -+#endif /* _HURD_REFCOUNT_H_ */ --- -2.1.3 - |