1

vhost_task: Handle SIGKILL by flushing work and exiting

Instead of lingering until the device is closed, this has us handle
SIGKILL by:

1. marking the worker as killed so we no longer try to use it with
   new virtqueues and new flush operations.
2. setting the virtqueue to worker mapping so no new works are queued.
3. running all the exiting works.

Suggested-by: Edward Adam Davis <eadavis@qq.com>
Reported-and-tested-by: syzbot+98edc2df894917b3431f@syzkaller.appspotmail.com
Message-Id: <tencent_546DA49414E876EEBECF2C78D26D242EE50A@qq.com>
Signed-off-by: Mike Christie <michael.christie@oracle.com>
Message-Id: <20240316004707.45557-9-michael.christie@oracle.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Mike Christie 2024-03-15 19:47:06 -05:00 committed by Michael S. Tsirkin
parent ba704ff4e1
commit db5247d9bf
4 changed files with 88 additions and 24 deletions

View File

@ -273,7 +273,7 @@ static void __vhost_worker_flush(struct vhost_worker *worker)
{ {
struct vhost_flush_struct flush; struct vhost_flush_struct flush;
if (!worker->attachment_cnt) if (!worker->attachment_cnt || worker->killed)
return; return;
init_completion(&flush.wait_event); init_completion(&flush.wait_event);
@ -388,7 +388,7 @@ static void vhost_vq_reset(struct vhost_dev *dev,
__vhost_vq_meta_reset(vq); __vhost_vq_meta_reset(vq);
} }
static bool vhost_worker(void *data) static bool vhost_run_work_list(void *data)
{ {
struct vhost_worker *worker = data; struct vhost_worker *worker = data;
struct vhost_work *work, *work_next; struct vhost_work *work, *work_next;
@ -413,6 +413,40 @@ static bool vhost_worker(void *data)
return !!node; return !!node;
} }
static void vhost_worker_killed(void *data)
{
struct vhost_worker *worker = data;
struct vhost_dev *dev = worker->dev;
struct vhost_virtqueue *vq;
int i, attach_cnt = 0;
mutex_lock(&worker->mutex);
worker->killed = true;
for (i = 0; i < dev->nvqs; i++) {
vq = dev->vqs[i];
mutex_lock(&vq->mutex);
if (worker ==
rcu_dereference_check(vq->worker,
lockdep_is_held(&vq->mutex))) {
rcu_assign_pointer(vq->worker, NULL);
attach_cnt++;
}
mutex_unlock(&vq->mutex);
}
worker->attachment_cnt -= attach_cnt;
if (attach_cnt)
synchronize_rcu();
/*
* Finish vhost_worker_flush calls and any other works that snuck in
* before the synchronize_rcu.
*/
vhost_run_work_list(worker);
mutex_unlock(&worker->mutex);
}
static void vhost_vq_free_iovecs(struct vhost_virtqueue *vq) static void vhost_vq_free_iovecs(struct vhost_virtqueue *vq)
{ {
kfree(vq->indirect); kfree(vq->indirect);
@ -627,9 +661,11 @@ static struct vhost_worker *vhost_worker_create(struct vhost_dev *dev)
if (!worker) if (!worker)
return NULL; return NULL;
worker->dev = dev;
snprintf(name, sizeof(name), "vhost-%d", current->pid); snprintf(name, sizeof(name), "vhost-%d", current->pid);
vtsk = vhost_task_create(vhost_worker, worker, name); vtsk = vhost_task_create(vhost_run_work_list, vhost_worker_killed,
worker, name);
if (!vtsk) if (!vtsk)
goto free_worker; goto free_worker;
@ -661,6 +697,11 @@ static void __vhost_vq_attach_worker(struct vhost_virtqueue *vq,
struct vhost_worker *old_worker; struct vhost_worker *old_worker;
mutex_lock(&worker->mutex); mutex_lock(&worker->mutex);
if (worker->killed) {
mutex_unlock(&worker->mutex);
return;
}
mutex_lock(&vq->mutex); mutex_lock(&vq->mutex);
old_worker = rcu_dereference_check(vq->worker, old_worker = rcu_dereference_check(vq->worker,
@ -681,6 +722,11 @@ static void __vhost_vq_attach_worker(struct vhost_virtqueue *vq,
* device wide flushes which doesn't use RCU for execution. * device wide flushes which doesn't use RCU for execution.
*/ */
mutex_lock(&old_worker->mutex); mutex_lock(&old_worker->mutex);
if (old_worker->killed) {
mutex_unlock(&old_worker->mutex);
return;
}
/* /*
* We don't want to call synchronize_rcu for every vq during setup * We don't want to call synchronize_rcu for every vq during setup
* because it will slow down VM startup. If we haven't done * because it will slow down VM startup. If we haven't done
@ -758,7 +804,7 @@ static int vhost_free_worker(struct vhost_dev *dev,
return -ENODEV; return -ENODEV;
mutex_lock(&worker->mutex); mutex_lock(&worker->mutex);
if (worker->attachment_cnt) { if (worker->attachment_cnt || worker->killed) {
mutex_unlock(&worker->mutex); mutex_unlock(&worker->mutex);
return -EBUSY; return -EBUSY;
} }

View File

@ -28,12 +28,14 @@ struct vhost_work {
struct vhost_worker { struct vhost_worker {
struct vhost_task *vtsk; struct vhost_task *vtsk;
struct vhost_dev *dev;
/* Used to serialize device wide flushing with worker swapping. */ /* Used to serialize device wide flushing with worker swapping. */
struct mutex mutex; struct mutex mutex;
struct llist_head work_list; struct llist_head work_list;
u64 kcov_handle; u64 kcov_handle;
u32 id; u32 id;
int attachment_cnt; int attachment_cnt;
bool killed;
}; };
/* Poll a file (eventfd or socket) */ /* Poll a file (eventfd or socket) */

View File

@ -4,7 +4,8 @@
struct vhost_task; struct vhost_task;
struct vhost_task *vhost_task_create(bool (*fn)(void *), void *arg, struct vhost_task *vhost_task_create(bool (*fn)(void *),
void (*handle_kill)(void *), void *arg,
const char *name); const char *name);
void vhost_task_start(struct vhost_task *vtsk); void vhost_task_start(struct vhost_task *vtsk);
void vhost_task_stop(struct vhost_task *vtsk); void vhost_task_stop(struct vhost_task *vtsk);

View File

@ -10,38 +10,32 @@
enum vhost_task_flags { enum vhost_task_flags {
VHOST_TASK_FLAGS_STOP, VHOST_TASK_FLAGS_STOP,
VHOST_TASK_FLAGS_KILLED,
}; };
struct vhost_task { struct vhost_task {
bool (*fn)(void *data); bool (*fn)(void *data);
void (*handle_sigkill)(void *data);
void *data; void *data;
struct completion exited; struct completion exited;
unsigned long flags; unsigned long flags;
struct task_struct *task; struct task_struct *task;
/* serialize SIGKILL and vhost_task_stop calls */
struct mutex exit_mutex;
}; };
static int vhost_task_fn(void *data) static int vhost_task_fn(void *data)
{ {
struct vhost_task *vtsk = data; struct vhost_task *vtsk = data;
bool dead = false;
for (;;) { for (;;) {
bool did_work; bool did_work;
if (!dead && signal_pending(current)) { if (signal_pending(current)) {
struct ksignal ksig; struct ksignal ksig;
/*
* Calling get_signal will block in SIGSTOP, if (get_signal(&ksig))
* or clear fatal_signal_pending, but remember break;
* what was set.
*
* This thread won't actually exit until all
* of the file descriptors are closed, and
* the release function is called.
*/
dead = get_signal(&ksig);
if (dead)
clear_thread_flag(TIF_SIGPENDING);
} }
/* mb paired w/ vhost_task_stop */ /* mb paired w/ vhost_task_stop */
@ -57,7 +51,19 @@ static int vhost_task_fn(void *data)
schedule(); schedule();
} }
mutex_lock(&vtsk->exit_mutex);
/*
* If a vhost_task_stop and SIGKILL race, we can ignore the SIGKILL.
* When the vhost layer has called vhost_task_stop it's already stopped
* new work and flushed.
*/
if (!test_bit(VHOST_TASK_FLAGS_STOP, &vtsk->flags)) {
set_bit(VHOST_TASK_FLAGS_KILLED, &vtsk->flags);
vtsk->handle_sigkill(vtsk->data);
}
mutex_unlock(&vtsk->exit_mutex);
complete(&vtsk->exited); complete(&vtsk->exited);
do_exit(0); do_exit(0);
} }
@ -78,12 +84,17 @@ EXPORT_SYMBOL_GPL(vhost_task_wake);
* @vtsk: vhost_task to stop * @vtsk: vhost_task to stop
* *
* vhost_task_fn ensures the worker thread exits after * vhost_task_fn ensures the worker thread exits after
* VHOST_TASK_FLAGS_SOP becomes true. * VHOST_TASK_FLAGS_STOP becomes true.
*/ */
void vhost_task_stop(struct vhost_task *vtsk) void vhost_task_stop(struct vhost_task *vtsk)
{ {
set_bit(VHOST_TASK_FLAGS_STOP, &vtsk->flags); mutex_lock(&vtsk->exit_mutex);
vhost_task_wake(vtsk); if (!test_bit(VHOST_TASK_FLAGS_KILLED, &vtsk->flags)) {
set_bit(VHOST_TASK_FLAGS_STOP, &vtsk->flags);
vhost_task_wake(vtsk);
}
mutex_unlock(&vtsk->exit_mutex);
/* /*
* Make sure vhost_task_fn is no longer accessing the vhost_task before * Make sure vhost_task_fn is no longer accessing the vhost_task before
* freeing it below. * freeing it below.
@ -96,14 +107,16 @@ EXPORT_SYMBOL_GPL(vhost_task_stop);
/** /**
* vhost_task_create - create a copy of a task to be used by the kernel * vhost_task_create - create a copy of a task to be used by the kernel
* @fn: vhost worker function * @fn: vhost worker function
* @arg: data to be passed to fn * @handle_sigkill: vhost function to handle when we are killed
* @arg: data to be passed to fn and handled_kill
* @name: the thread's name * @name: the thread's name
* *
* This returns a specialized task for use by the vhost layer or NULL on * This returns a specialized task for use by the vhost layer or NULL on
* failure. The returned task is inactive, and the caller must fire it up * failure. The returned task is inactive, and the caller must fire it up
* through vhost_task_start(). * through vhost_task_start().
*/ */
struct vhost_task *vhost_task_create(bool (*fn)(void *), void *arg, struct vhost_task *vhost_task_create(bool (*fn)(void *),
void (*handle_sigkill)(void *), void *arg,
const char *name) const char *name)
{ {
struct kernel_clone_args args = { struct kernel_clone_args args = {
@ -122,8 +135,10 @@ struct vhost_task *vhost_task_create(bool (*fn)(void *), void *arg,
if (!vtsk) if (!vtsk)
return NULL; return NULL;
init_completion(&vtsk->exited); init_completion(&vtsk->exited);
mutex_init(&vtsk->exit_mutex);
vtsk->data = arg; vtsk->data = arg;
vtsk->fn = fn; vtsk->fn = fn;
vtsk->handle_sigkill = handle_sigkill;
args.fn_arg = vtsk; args.fn_arg = vtsk;