diff --git a/sys/compat/linuxkpi/common/include/linux/rwsem.h b/sys/compat/linuxkpi/common/include/linux/rwsem.h index fc3580bc186e..a08668ed6e1e 100644 --- a/sys/compat/linuxkpi/common/include/linux/rwsem.h +++ b/sys/compat/linuxkpi/common/include/linux/rwsem.h @@ -1,85 +1,87 @@ /*- * Copyright (c) 2010 Isilon Systems, Inc. * Copyright (c) 2010 iX Systems, Inc. * Copyright (c) 2010 Panasas, Inc. * Copyright (c) 2013-2017 Mellanox Technologies, Ltd. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice unmodified, this list of conditions, and the following * disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _LINUXKPI_LINUX_RWSEM_H_ #define _LINUXKPI_LINUX_RWSEM_H_ #include #include #include #include #include struct rw_semaphore { struct sx sx; }; #define down_write(_rw) sx_xlock(&(_rw)->sx) #define up_write(_rw) sx_xunlock(&(_rw)->sx) #define down_read(_rw) sx_slock(&(_rw)->sx) #define up_read(_rw) sx_sunlock(&(_rw)->sx) #define down_read_trylock(_rw) !!sx_try_slock(&(_rw)->sx) +#define down_read_killable(_rw) linux_down_read_killable(_rw) #define down_write_trylock(_rw) !!sx_try_xlock(&(_rw)->sx) #define down_write_killable(_rw) linux_down_write_killable(_rw) #define downgrade_write(_rw) sx_downgrade(&(_rw)->sx) #define down_read_nested(_rw, _sc) down_read(_rw) #define init_rwsem(_rw) linux_init_rwsem(_rw, rwsem_name("lnxrwsem")) #define down_write_nest_lock(sem, _rw) down_write(_rw) #ifdef WITNESS_ALL /* NOTE: the maximum WITNESS name is 64 chars */ #define __rwsem_name(name, file, line) \ (((const char *){file ":" #line "-" name}) + \ (sizeof(file) > 16 ? sizeof(file) - 16 : 0)) #else #define __rwsem_name(name, file, line) name #endif #define _rwsem_name(...) __rwsem_name(__VA_ARGS__) #define rwsem_name(name) _rwsem_name(name, __FILE__, __LINE__) #define DECLARE_RWSEM(name) \ struct rw_semaphore name; \ static void name##_rwsem_init(void *arg) \ { \ linux_init_rwsem(&name, rwsem_name(#name)); \ } \ SYSINIT(name, SI_SUB_LOCK, SI_ORDER_SECOND, name##_rwsem_init, NULL) static inline void linux_init_rwsem(struct rw_semaphore *rw, const char *name) { memset(rw, 0, sizeof(*rw)); sx_init_flags(&rw->sx, name, SX_NOWITNESS); } +extern int linux_down_read_killable(struct rw_semaphore *); extern int linux_down_write_killable(struct rw_semaphore *); #endif /* _LINUXKPI_LINUX_RWSEM_H_ */ diff --git a/sys/compat/linuxkpi/common/src/linux_lock.c b/sys/compat/linuxkpi/common/src/linux_lock.c index b04a7738d036..0e9a2fecaf7d 100644 --- a/sys/compat/linuxkpi/common/src/linux_lock.c +++ b/sys/compat/linuxkpi/common/src/linux_lock.c @@ -1,173 +1,186 @@ /*- * Copyright (c) 2017 Mellanox Technologies, Ltd. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice unmodified, this list of conditions, and the following * disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include struct ww_mutex_thread { TAILQ_ENTRY(ww_mutex_thread) entry; struct thread *thread; struct ww_mutex *lock; }; static TAILQ_HEAD(, ww_mutex_thread) ww_mutex_head; static struct mtx ww_mutex_global; static void linux_ww_init(void *arg) { TAILQ_INIT(&ww_mutex_head); mtx_init(&ww_mutex_global, "lkpi-ww-mtx", NULL, MTX_DEF); } SYSINIT(ww_init, SI_SUB_LOCK, SI_ORDER_SECOND, linux_ww_init, NULL); static void linux_ww_uninit(void *arg) { mtx_destroy(&ww_mutex_global); } SYSUNINIT(ww_uninit, SI_SUB_LOCK, SI_ORDER_SECOND, linux_ww_uninit, NULL); static inline void linux_ww_lock(void) { mtx_lock(&ww_mutex_global); } static inline void linux_ww_unlock(void) { mtx_unlock(&ww_mutex_global); } /* lock a mutex with deadlock avoidance */ int linux_ww_mutex_lock_sub(struct ww_mutex *lock, struct ww_acquire_ctx *ctx, int catch_signal) { struct task_struct *task; struct ww_mutex_thread entry; struct ww_mutex_thread *other; int retval = 0; task = current; linux_ww_lock(); if (unlikely(sx_try_xlock(&lock->base.sx) == 0)) { entry.thread = curthread; entry.lock = lock; TAILQ_INSERT_TAIL(&ww_mutex_head, &entry, entry); do { struct thread *owner = (struct thread *) SX_OWNER(lock->base.sx.sx_lock); /* scan for deadlock */ TAILQ_FOREACH(other, &ww_mutex_head, entry) { /* skip own thread */ if (other == &entry) continue; /* * If another thread is owning our * lock and is at the same time trying * to acquire a lock this thread owns, * that means deadlock. */ if (other->thread == owner && (struct thread *)SX_OWNER( other->lock->base.sx.sx_lock) == curthread) { retval = -EDEADLK; goto done; } } if (catch_signal) { retval = -cv_wait_sig(&lock->condvar, &ww_mutex_global); if (retval != 0) { linux_schedule_save_interrupt_value(task, retval); retval = -EINTR; goto done; } } else { cv_wait(&lock->condvar, &ww_mutex_global); } } while (sx_try_xlock(&lock->base.sx) == 0); done: TAILQ_REMOVE(&ww_mutex_head, &entry, entry); /* if the lock is free, wakeup next lock waiter, if any */ if ((struct thread *)SX_OWNER(lock->base.sx.sx_lock) == NULL) cv_signal(&lock->condvar); } if (retval == 0) lock->ctx = ctx; linux_ww_unlock(); return (retval); } void linux_ww_mutex_unlock_sub(struct ww_mutex *lock) { /* protect ww_mutex ownership change */ linux_ww_lock(); lock->ctx = NULL; sx_xunlock(&lock->base.sx); /* wakeup a lock waiter, if any */ cv_signal(&lock->condvar); linux_ww_unlock(); } int linux_mutex_lock_interruptible(mutex_t *m) { int error; error = -sx_xlock_sig(&m->sx); if (error != 0) { linux_schedule_save_interrupt_value(current, error); error = -EINTR; } return (error); } +int +linux_down_read_killable(struct rw_semaphore *rw) +{ + int error; + + error = -sx_slock_sig(&rw->sx); + if (error != 0) { + linux_schedule_save_interrupt_value(current, error); + error = -EINTR; + } + return (error); +} + int linux_down_write_killable(struct rw_semaphore *rw) { int error; error = -sx_xlock_sig(&rw->sx); if (error != 0) { linux_schedule_save_interrupt_value(current, error); error = -EINTR; } return (error); }