D41787.id141843.diff
No OneTemporary
Actions

Size

20 KB

Referenced Files

None

Subscribers

None

D41787.id141843.diff
View Options

	diff --git a/sys/kern/kern_rangelock.c b/sys/kern/kern_rangelock.c
	--- a/sys/kern/kern_rangelock.c
	+++ b/sys/kern/kern_rangelock.c
	@@ -27,304 +27,335 @@
	*/

	#include <sys/param.h>
	+#include <sys/kassert.h>
	#include <sys/kernel.h>
	#include <sys/lock.h>
	#include <sys/mutex.h>
	#include <sys/proc.h>
	#include <sys/rangelock.h>
	-#include <sys/systm.h>
	+#include <sys/sleepqueue.h>
	+#include <sys/smr.h>

	#include <vm/uma.h>

	+/*
	+ * Implementation of range locks based on the paper
	+ * https://doi.org/10.1145/3342195.3387533
	+ * arXiv:2006.12144v1 [cs.OS] 22 Jun 2020
	+ * Scalable Range Locks for Scalable Address Spaces and Beyond
	+ * by Alex Kogan, Dave Dice, and Shady Issa
	+ */
	+
	+static struct rl_q_entry rl_e_unmark(const struct rl_q_entry e);
	+
	+/*
	+ * rl_q_next links all granted ranges in the lock. We cannot free an
	+ * rl_q_entry while in the smr section, and cannot reuse rl_q_next
	+ * linkage since other threads might follow it even after CAS removed
	+ * the range. Use rl_q_free for local list of ranges to remove after
	+ * the smr section is dropped.
	+ */
	struct rl_q_entry {
	- TAILQ_ENTRY(rl_q_entry) rl_q_link;
	+ struct rl_q_entry *rl_q_next;
	+ struct rl_q_entry *rl_q_free;
	off_t rl_q_start, rl_q_end;
	int rl_q_flags;
	+#ifdef INVARIANTS
	+ struct thread *rl_q_owner;
	+#endif
	};

	static uma_zone_t rl_entry_zone;
	+static smr_t rl_smr;

	static void
	rangelock_sys_init(void)
	{
	-
	rl_entry_zone = uma_zcreate("rl_entry", sizeof(struct rl_q_entry),
	- NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
	+ NULL, NULL, NULL, NULL, UMA_ALIGNOF(struct rl_q_entry),
	+ UMA_ZONE_SMR);
	+ rl_smr = uma_zone_get_smr(rl_entry_zone);
	}
	-SYSINIT(vfs, SI_SUB_LOCK, SI_ORDER_ANY, rangelock_sys_init, NULL);
	+SYSINIT(rl, SI_SUB_LOCK, SI_ORDER_ANY, rangelock_sys_init, NULL);

	static struct rl_q_entry *
	-rlqentry_alloc(void)
	+rlqentry_alloc(vm_ooffset_t start, vm_ooffset_t end, int flags)
	{
	+ struct rl_q_entry *e;
	+
	+ e = uma_zalloc_smr(rl_entry_zone, M_WAITOK);
	+ e->rl_q_next = NULL;
	+ e->rl_q_free = NULL;
	+ e->rl_q_start = start;
	+ e->rl_q_end = end;
	+ e->rl_q_flags = flags;
	+#ifdef INVARIANTS
	+ e->rl_q_owner = curthread;
	+#endif
	+ return (e);
	+}

	- return (uma_zalloc(rl_entry_zone, M_WAITOK));
	+void
	+rangelock_init(struct rangelock *lock)
	+{
	+ lock->sleepers = false;
	+ atomic_store_ptr(&lock->head, NULL);
	}

	void
	-rlqentry_free(struct rl_q_entry *rleq)
	+rangelock_destroy(struct rangelock *lock)
	{
	+ struct rl_q_entry e, ep;

	- uma_zfree(rl_entry_zone, rleq);
	+ MPASS(!lock->sleepers);
	+ for (e = (struct rl_q_entry *)atomic_load_ptr(&lock->head);
	+ e != NULL; e = rl_e_unmark(ep)) {
	+ ep = atomic_load_ptr(&e->rl_q_next);
	+ uma_zfree_smr(rl_entry_zone, e);
	+ }
	}

	-void
	-rangelock_init(struct rangelock *lock)
	+static bool
	+rl_e_is_marked(const struct rl_q_entry *e)
	{
	+ return (((uintptr_t)e & 1) != 0);
	+}

	- TAILQ_INIT(&lock->rl_waiters);
	- lock->rl_currdep = NULL;
	+static struct rl_q_entry *
	+rl_e_unmark(const struct rl_q_entry *e)
	+{
	+ MPASS(rl_e_is_marked(e));
	+ return ((struct rl_q_entry *)((uintptr_t)e & ~1));
	}

	-void
	-rangelock_destroy(struct rangelock *lock)
	+static struct rl_q_entry *
	+rl_q_load(struct rl_q_entry **p)
	{
	+ return ((struct rl_q_entry )atomic_load_acq_ptr((uintptr_t )p));
	+}

	- KASSERT(TAILQ_EMPTY(&lock->rl_waiters), ("Dangling waiters"));
	+void
	+rangelock_unlock(struct rangelock lock, void cookie)
	+{
	+ struct rl_q_entry *e;
	+
	+ e = cookie;
	+ MPASS(lock != NULL && e != NULL);
	+ MPASS(!rl_e_is_marked(rl_q_load(&e->rl_q_next)));
	+ MPASS(e->rl_q_owner == curthread);
	+
	+ sleepq_lock(&lock->sleepers);
	+#ifdef INVARIANTS
	+ int r = atomic_testandset_long((uintptr_t *)&e->rl_q_next, 0);
	+ MPASS(r == 0);
	+#else
	+ atomic_set_ptr((uintptr_t *)&e->rl_q_next, 1);
	+#endif
	+ lock->sleepers = false;
	+ sleepq_broadcast(&lock->sleepers, SLEEPQ_SLEEP, 0, 0);
	+ sleepq_release(&lock->sleepers);
	}

	/*
	- * Two entries are compatible if their ranges do not overlap, or both
	- * entries are for read.
	+ * result: -1 if e1 before e2
	+ * 1 if e1 after e2
	+ * 0 if e1 and e2 overlap
	*/
	static int
	-ranges_overlap(const struct rl_q_entry *e1,
	- const struct rl_q_entry *e2)
	+rl_e_compare(const struct rl_q_entry e1, const struct rl_q_entry e2)
	{
	-
	- if (e1->rl_q_start < e2->rl_q_end && e1->rl_q_end > e2->rl_q_start)
	+ if (e1 == NULL)
	return (1);
	+ if (e1->rl_q_start >= e2->rl_q_end)
	+ return (1);
	+ if (e2->rl_q_start >= e1->rl_q_end)
	+ return (-1);
	return (0);
	}

	-/*
	- * Recalculate the lock->rl_currdep after an unlock.
	- */
	static void
	-rangelock_calc_block(struct rangelock *lock)
	+rl_insert_sleep(struct rangelock *lock)
	{
	- struct rl_q_entry entry, nextentry, *entry1;
	-
	- for (entry = lock->rl_currdep; entry != NULL; entry = nextentry) {
	- nextentry = TAILQ_NEXT(entry, rl_q_link);
	- if (entry->rl_q_flags & RL_LOCK_READ) {
	- /* Reads must not overlap with granted writes. */
	- for (entry1 = TAILQ_FIRST(&lock->rl_waiters);
	- !(entry1->rl_q_flags & RL_LOCK_READ);
	- entry1 = TAILQ_NEXT(entry1, rl_q_link)) {
	- if (ranges_overlap(entry, entry1))
	- goto out;
	- }
	- } else {
	- /* Write must not overlap with any granted locks. */
	- for (entry1 = TAILQ_FIRST(&lock->rl_waiters);
	- entry1 != entry;
	- entry1 = TAILQ_NEXT(entry1, rl_q_link)) {
	- if (ranges_overlap(entry, entry1))
	- goto out;
	- }
	-
	- /* Move grantable write locks to the front. */
	- TAILQ_REMOVE(&lock->rl_waiters, entry, rl_q_link);
	- TAILQ_INSERT_HEAD(&lock->rl_waiters, entry, rl_q_link);
	- }
	-
	- /* Grant this lock. */
	- entry->rl_q_flags \|= RL_LOCK_GRANTED;
	- wakeup(entry);
	- }
	-out:
	- lock->rl_currdep = entry;
	+ smr_exit(rl_smr);
	+ DROP_GIANT();
	+ lock->sleepers = true;
	+ sleepq_add(&lock->sleepers, NULL, "rangelk", 0, 0);
	+ sleepq_wait(&lock->sleepers, PRI_USER);
	+ PICKUP_GIANT();
	+ smr_enter(rl_smr);
	}

	-static void
	-rangelock_unlock_locked(struct rangelock lock, struct rl_q_entry entry,
	- struct mtx *ilk, bool do_calc_block)
	+static bool
	+rl_q_cas(struct rl_q_entry *prev, struct rl_q_entry old,
	+ struct rl_q_entry *new)
	{
	-
	- MPASS(lock != NULL && entry != NULL && ilk != NULL);
	- mtx_assert(ilk, MA_OWNED);
	-
	- if (!do_calc_block) {
	- /*
	- * This is the case where rangelock_enqueue() has been called
	- * with trylock == true and just inserted this entry in the
	- * queue.
	- * If rl_currdep is this entry, rl_currdep needs to
	- * be set to the next entry in the rl_waiters list.
	- * However, since this entry is the last entry in the
	- * list, the next entry is NULL.
	- */
	- if (lock->rl_currdep == entry) {
	- KASSERT(TAILQ_NEXT(lock->rl_currdep, rl_q_link) == NULL,
	- ("rangelock_enqueue: next entry not NULL"));
	- lock->rl_currdep = NULL;
	- }
	- } else
	- KASSERT(entry != lock->rl_currdep, ("stuck currdep"));
	-
	- TAILQ_REMOVE(&lock->rl_waiters, entry, rl_q_link);
	- if (do_calc_block)
	- rangelock_calc_block(lock);
	- mtx_unlock(ilk);
	- if (curthread->td_rlqe == NULL)
	- curthread->td_rlqe = entry;
	- else
	- rlqentry_free(entry);
	+ return (atomic_cmpset_rel_ptr((uintptr_t *)prev, (uintptr_t)old,
	+ (uintptr_t)new) != 0);
	}

	-void
	-rangelock_unlock(struct rangelock lock, void cookie, struct mtx *ilk)
	+static bool
	+rl_insert(struct rangelock lock, struct rl_q_entry e, bool trylock,
	+ struct rl_q_entry **free)
	{
	+ struct rl_q_entry cur, next, **prev;
	+ int r;
	+
	+again:
	+ prev = &lock->head;
	+ if (rl_q_load(prev) == NULL && rl_q_cas(prev, NULL, e))
	+ return (true);
	+
	+ for (cur = rl_q_load(prev);;) {
	+ if (rl_e_is_marked(cur))
	+ goto again;
	+
	+ if (cur != NULL) {
	+ next = rl_q_load(&cur->rl_q_next);
	+ if (rl_e_is_marked(next)) {
	+ next = rl_e_unmark(next);
	+ if (rl_q_cas(prev, cur, next)) {
	+#ifdef INVARIANTS
	+ cur->rl_q_owner = NULL;
	+#endif
	+ cur->rl_q_free = *free;
	+ *free = cur;
	+ }
	+ cur = next;
	+ continue;
	+ }
	+ }

	- MPASS(lock != NULL && cookie != NULL && ilk != NULL);
	-
	- mtx_lock(ilk);
	- rangelock_unlock_locked(lock, cookie, ilk, true);
	-}
	-
	-/*
	- * Unlock the sub-range of granted lock.
	- */
	-void *
	-rangelock_unlock_range(struct rangelock lock, void cookie, off_t start,
	- off_t end, struct mtx *ilk)
	-{
	- struct rl_q_entry *entry;
	-
	- MPASS(lock != NULL && cookie != NULL && ilk != NULL);
	- entry = cookie;
	- KASSERT(entry->rl_q_flags & RL_LOCK_GRANTED,
	- ("Unlocking non-granted lock"));
	- KASSERT(entry->rl_q_start == start, ("wrong start"));
	- KASSERT(entry->rl_q_end >= end, ("wrong end"));
	-
	- mtx_lock(ilk);
	- if (entry->rl_q_end == end) {
	- rangelock_unlock_locked(lock, cookie, ilk, true);
	- return (NULL);
	+ r = rl_e_compare(cur, e);
	+ if (r == -1) {
	+ prev = &cur->rl_q_next;
	+ cur = rl_q_load(prev);
	+ } else if (r == 0) {
	+ sleepq_lock(&lock->sleepers);
	+ if (__predict_false(rl_e_is_marked(rl_q_load(
	+ &cur->rl_q_next)))) {
	+ sleepq_release(&lock->sleepers);
	+ continue;
	+ }
	+ if (trylock) {
	+ sleepq_release(&lock->sleepers);
	+ return (false);
	+ }
	+ rl_insert_sleep(lock);
	+ /* e is still valid */
	+ goto again;
	+ } else /* r == 1 */ {
	+ e->rl_q_next = cur;
	+ if (rl_q_cas(prev, cur, e)) {
	+ atomic_thread_fence_acq();
	+ return (true);
	+ }
	+ /* Reset rl_q_next in case we hit fast path. */
	+ e->rl_q_next = NULL;
	+ cur = rl_q_load(prev);
	+ }
	}
	- entry->rl_q_end = end;
	- rangelock_calc_block(lock);
	- mtx_unlock(ilk);
	- return (cookie);
	}

	-/*
	- * Add the lock request to the queue of the pending requests for
	- * rangelock. Sleep until the request can be granted unless trylock == true.
	- */
	-static void *
	-rangelock_enqueue(struct rangelock *lock, off_t start, off_t end, int mode,
	- struct mtx *ilk, bool trylock)
	+static struct rl_q_entry *
	+rangelock_lock_int(struct rangelock lock, struct rl_q_entry e,
	+ bool trylock)
	{
	- struct rl_q_entry *entry;
	- struct thread *td;
	-
	- MPASS(lock != NULL && ilk != NULL);
	-
	- td = curthread;
	- if (td->td_rlqe != NULL) {
	- entry = td->td_rlqe;
	- td->td_rlqe = NULL;
	- } else
	- entry = rlqentry_alloc();
	- MPASS(entry != NULL);
	- entry->rl_q_flags = mode;
	- entry->rl_q_start = start;
	- entry->rl_q_end = end;
	-
	- mtx_lock(ilk);
	- /*
	- * XXXKIB TODO. Check that a thread does not try to enqueue a
	- * lock that is incompatible with another request from the same
	- * thread.
	- */
	-
	- TAILQ_INSERT_TAIL(&lock->rl_waiters, entry, rl_q_link);
	- /*
	- * If rl_currdep == NULL, there is no entry waiting for a conflicting
	- * range to be resolved, so set rl_currdep to this entry. If there is
	- * no conflicting entry for this entry, rl_currdep will be set back to
	- * NULL by rangelock_calc_block().
	- */
	- if (lock->rl_currdep == NULL)
	- lock->rl_currdep = entry;
	- rangelock_calc_block(lock);
	- while (!(entry->rl_q_flags & RL_LOCK_GRANTED)) {
	- if (trylock) {
	- /*
	- * For this case, the range is not actually locked
	- * yet, but removal from the list requires the same
	- * steps, except for not doing a rangelock_calc_block()
	- * call, since rangelock_calc_block() was called above.
	- */
	- rangelock_unlock_locked(lock, entry, ilk, false);
	- return (NULL);
	- }
	- msleep(entry, ilk, 0, "range", 0);
	+ struct rl_q_entry free, x, *xp;
	+ bool res;
	+
	+ free = NULL;
	+ smr_enter(rl_smr);
	+ res = rl_insert(lock, e, trylock, &free);
	+ smr_exit(rl_smr);
	+ MPASS(trylock \|\| res);
	+ if (!res) {
	+ e->rl_q_free = free;
	+ free = e;
	+ e = NULL;
	+ }
	+ for (x = free; x != NULL; x = xp) {
	+ MPASS(!rl_e_is_marked(x));
	+ xp = x->rl_q_free;
	+ MPASS(!rl_e_is_marked(xp));
	+ uma_zfree_smr(rl_entry_zone, x);
	}
	- mtx_unlock(ilk);
	- return (entry);
	+ return (e);
	}

	void *
	-rangelock_rlock(struct rangelock lock, off_t start, off_t end, struct mtx ilk)
	+rangelock_rlock(struct rangelock *lock, vm_ooffset_t start, vm_ooffset_t end)
	{
	+ struct rl_q_entry *e;

	- return (rangelock_enqueue(lock, start, end, RL_LOCK_READ, ilk, false));
	+ e = rlqentry_alloc(start, end, RL_LOCK_READ);
	+ return (rangelock_lock_int(lock, e, false));
	}

	void *
	-rangelock_tryrlock(struct rangelock *lock, off_t start, off_t end,
	- struct mtx *ilk)
	+rangelock_tryrlock(struct rangelock *lock, vm_ooffset_t start, vm_ooffset_t end)
	{
	+ struct rl_q_entry *e;

	- return (rangelock_enqueue(lock, start, end, RL_LOCK_READ, ilk, true));
	+ e = rlqentry_alloc(start, end, RL_LOCK_READ);
	+ return (rangelock_lock_int(lock, e, true));
	}

	void *
	-rangelock_wlock(struct rangelock lock, off_t start, off_t end, struct mtx ilk)
	+rangelock_wlock(struct rangelock *lock, vm_ooffset_t start, vm_ooffset_t end)
	{
	+ struct rl_q_entry *e;

	- return (rangelock_enqueue(lock, start, end, RL_LOCK_WRITE, ilk, false));
	+ e = rlqentry_alloc(start, end, RL_LOCK_WRITE);
	+ return (rangelock_lock_int(lock, e, true));
	}

	void *
	-rangelock_trywlock(struct rangelock *lock, off_t start, off_t end,
	- struct mtx *ilk)
	+rangelock_trywlock(struct rangelock *lock, vm_ooffset_t start, vm_ooffset_t end)
	{
	+ struct rl_q_entry *e;

	- return (rangelock_enqueue(lock, start, end, RL_LOCK_WRITE, ilk, true));
	+ e = rlqentry_alloc(start, end, RL_LOCK_WRITE);
	+ return (rangelock_lock_int(lock, e, true));
	}

	#ifdef INVARIANT_SUPPORT
	void
	_rangelock_cookie_assert(void cookie, int what, const char file, int line)
	{
	- struct rl_q_entry *entry;
	- int flags;
	-
	- MPASS(cookie != NULL);
	- entry = cookie;
	- flags = entry->rl_q_flags;
	- switch (what) {
	- case RCA_LOCKED:
	- if ((flags & RL_LOCK_GRANTED) == 0)
	- panic("rangelock not held @ %s:%d\n", file, line);
	- break;
	- case RCA_RLOCKED:
	- if ((flags & (RL_LOCK_GRANTED \| RL_LOCK_READ)) !=
	- (RL_LOCK_GRANTED \| RL_LOCK_READ))
	- panic("rangelock not rlocked @ %s:%d\n", file, line);
	- break;
	- case RCA_WLOCKED:
	- if ((flags & (RL_LOCK_GRANTED \| RL_LOCK_WRITE)) !=
	- (RL_LOCK_GRANTED \| RL_LOCK_WRITE))
	- panic("rangelock not wlocked @ %s:%d\n", file, line);
	- break;
	- default:
	- panic("Unknown rangelock assertion: %d @ %s:%d", what, file,
	- line);
	- }
	}
	#endif /* INVARIANT_SUPPORT */
	+
	+#include "opt_ddb.h"
	+#ifdef DDB
	+#include <ddb/ddb.h>
	+
	+DB_SHOW_COMMAND(rangelock, db_show_rangelock)
	+{
	+ struct rangelock *lock;
	+ struct rl_q_entry e, x;
	+
	+ if (!have_addr) {
	+ db_printf("show rangelock addr\n");
	+ return;
	+ }
	+
	+ lock = (struct rangelock *)addr;
	+ db_printf("rangelock %p sleepers %d\n", lock, lock->sleepers);
	+ for (e = lock->head;;) {
	+ x = rl_e_is_marked(e) ? rl_e_unmark(e) : e;
	+ if (x == NULL)
	+ break;
	+ db_printf(" entry %p marked %d %d start %#jx end %#jx "
	+ "flags %x next %p",
	+ e, rl_e_is_marked(e), rl_e_is_marked(x->rl_q_next),
	+ x->rl_q_start, x->rl_q_end, x->rl_q_flags, x->rl_q_next);
	+#ifdef INVARIANTS
	+ db_printf(" owner %p (%d)", x->rl_q_owner,
	+ x->rl_q_owner != NULL ? x->rl_q_owner->td_tid : -1);
	+#endif
	+ db_printf("\n");
	+ e = x->rl_q_next;
	+ }
	+}
	+
	+#endif /* DDB */
	diff --git a/sys/kern/kern_thread.c b/sys/kern/kern_thread.c
	--- a/sys/kern/kern_thread.c
	+++ b/sys/kern/kern_thread.c
	@@ -478,7 +478,6 @@

	td = (struct thread *)mem;
	EVENTHANDLER_DIRECT_INVOKE(thread_fini, td);
	- rlqentry_free(td->td_rlqe);
	turnstile_free(td->td_turnstile);
	sleepq_free(td->td_sleepqueue);
	umtx_thread_fini(td);
	diff --git a/sys/kern/uipc_shm.c b/sys/kern/uipc_shm.c
	--- a/sys/kern/uipc_shm.c
	+++ b/sys/kern/uipc_shm.c
	@@ -184,13 +184,13 @@
	"Number of contig reclaims before giving up for default alloc policy");

	#define shm_rangelock_unlock(shmfd, cookie) \
	- rangelock_unlock(&(shmfd)->shm_rl, (cookie), &(shmfd)->shm_mtx)
	+ rangelock_unlock(&(shmfd)->shm_rl, (cookie))
	#define shm_rangelock_rlock(shmfd, start, end) \
	- rangelock_rlock(&(shmfd)->shm_rl, (start), (end), &(shmfd)->shm_mtx)
	+ rangelock_rlock(&(shmfd)->shm_rl, (start), (end))
	#define shm_rangelock_tryrlock(shmfd, start, end) \
	- rangelock_tryrlock(&(shmfd)->shm_rl, (start), (end), &(shmfd)->shm_mtx)
	+ rangelock_tryrlock(&(shmfd)->shm_rl, (start), (end))
	#define shm_rangelock_wlock(shmfd, start, end) \
	- rangelock_wlock(&(shmfd)->shm_rl, (start), (end), &(shmfd)->shm_mtx)
	+ rangelock_wlock(&(shmfd)->shm_rl, (start), (end))

	static int
	uiomove_object_page(vm_object_t obj, size_t len, struct uio *uio)
	diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c
	--- a/sys/kern/vfs_subr.c
	+++ b/sys/kern/vfs_subr.c
	@@ -2180,8 +2180,6 @@
	VNASSERT(bo->bo_dirty.bv_cnt == 0, vp, ("dirtybufcnt not 0"));
	VNASSERT(pctrie_is_empty(&bo->bo_dirty.bv_root), vp,
	("dirty blk trie not empty"));
	- VNASSERT(TAILQ_EMPTY(&vp->v_rl.rl_waiters), vp,
	- ("Dangling rangelock waiters"));
	VNASSERT((vp->v_iflag & (VI_DOINGINACT \| VI_OWEINACT)) == 0, vp,
	("Leaked inactivation"));
	VI_UNLOCK(vp);
	diff --git a/sys/sys/rangelock.h b/sys/sys/rangelock.h
	--- a/sys/sys/rangelock.h
	+++ b/sys/sys/rangelock.h
	@@ -29,12 +29,14 @@
	#ifndef _SYS_RANGELOCK_H
	#define _SYS_RANGELOCK_H

	-#include <sys/queue.h>
	+#include <sys/types.h>
	+#ifndef _KERNEL
	+#include <stdbool.h>
	+#endif

	#define RL_LOCK_READ 0x0001
	#define RL_LOCK_WRITE 0x0002
	#define RL_LOCK_TYPE_MASK 0x0003
	-#define RL_LOCK_GRANTED 0x0004

	struct rl_q_entry;

	@@ -44,42 +46,25 @@
	* all existing lock owners are compatible with the request. Two lock
	* owners are compatible if their ranges do not overlap, or both
	* owners are for read.
	- *
	- * Access to the structure itself is synchronized with the externally
	- * supplied mutex.
	- *
	- * rl_waiters is the queue containing in order (a) granted write lock
	- * requests, (b) granted read lock requests, and (c) in order of arrival,
	- * lock requests which cannot be granted yet.
	- *
	- * rl_currdep is the first lock request that cannot be granted now due
	- * to the preceding requests conflicting with it (i.e., it points to
	- * position (c) in the list above).
	*/
	struct rangelock {
	- TAILQ_HEAD(, rl_q_entry) rl_waiters;
	- struct rl_q_entry *rl_currdep;
	+ struct rl_q_entry *head;
	+ bool sleepers;
	};

	#ifdef _KERNEL

	-struct mtx;
	-
	void rangelock_init(struct rangelock *lock);
	void rangelock_destroy(struct rangelock *lock);
	-void rangelock_unlock(struct rangelock lock, void cookie,
	- struct mtx *ilk);
	-void rangelock_unlock_range(struct rangelock lock, void *cookie,
	- off_t start, off_t end, struct mtx *ilk);
	-void rangelock_rlock(struct rangelock lock, off_t start, off_t end,
	- struct mtx *ilk);
	-void rangelock_tryrlock(struct rangelock lock, off_t start, off_t end,
	- struct mtx *ilk);
	-void rangelock_wlock(struct rangelock lock, off_t start, off_t end,
	- struct mtx *ilk);
	-void rangelock_trywlock(struct rangelock lock, off_t start, off_t end,
	- struct mtx *ilk);
	-void rlqentry_free(struct rl_q_entry *rlqe);
	+void rangelock_unlock(struct rangelock lock, void cookie);
	+void rangelock_rlock(struct rangelock lock, vm_ooffset_t start,
	+ vm_ooffset_t end);
	+void rangelock_tryrlock(struct rangelock lock, vm_ooffset_t start,
	+ vm_ooffset_t end);
	+void rangelock_wlock(struct rangelock lock, vm_ooffset_t start,
	+ vm_ooffset_t end);
	+void rangelock_trywlock(struct rangelock lock, vm_ooffset_t start,
	+ vm_ooffset_t end);
	#if defined(INVARIANTS) \|\| defined(INVARIANT_SUPPORT)
	void _rangelock_cookie_assert(void cookie, int what, const char file,
	int line);
	diff --git a/sys/sys/vnode.h b/sys/sys/vnode.h
	--- a/sys/sys/vnode.h
	+++ b/sys/sys/vnode.h
	@@ -833,18 +833,15 @@
	#define vn_seqc_consistent(vp, seq) seqc_consistent(&(vp)->v_seqc, seq)

	#define vn_rangelock_unlock(vp, cookie) \
	- rangelock_unlock(&(vp)->v_rl, (cookie), VI_MTX(vp))
	-#define vn_rangelock_unlock_range(vp, cookie, start, end) \
	- rangelock_unlock_range(&(vp)->v_rl, (cookie), (start), (end), \
	- VI_MTX(vp))
	+ rangelock_unlock(&(vp)->v_rl, (cookie))
	#define vn_rangelock_rlock(vp, start, end) \
	- rangelock_rlock(&(vp)->v_rl, (start), (end), VI_MTX(vp))
	+ rangelock_rlock(&(vp)->v_rl, (start), (end))
	#define vn_rangelock_tryrlock(vp, start, end) \
	- rangelock_tryrlock(&(vp)->v_rl, (start), (end), VI_MTX(vp))
	+ rangelock_tryrlock(&(vp)->v_rl, (start), (end))
	#define vn_rangelock_wlock(vp, start, end) \
	- rangelock_wlock(&(vp)->v_rl, (start), (end), VI_MTX(vp))
	+ rangelock_wlock(&(vp)->v_rl, (start), (end))
	#define vn_rangelock_trywlock(vp, start, end) \
	- rangelock_trywlock(&(vp)->v_rl, (start), (end), VI_MTX(vp))
	+ rangelock_trywlock(&(vp)->v_rl, (start), (end))

	#define vn_irflag_read(vp) atomic_load_short(&(vp)->v_irflag)
	void vn_irflag_set_locked(struct vnode *vp, short toset);

File Metadata

Mime Type: text/plain
Expires: Tue, Nov 19, 9:40 PM (17 h, 6 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 14723951
Default Alt Text: D41787.id141843.diff (20 KB)

D41787.id141843.diffNo OneTemporaryActions

D41787.id141843.diffView Options

File Metadata

Event Timeline

D41787.id141843.diff
No OneTemporary
Actions

D41787.id141843.diff
View Options