631 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved.4 */5 6#include <linux/fs.h>7#include <linux/filelock.h>8#include <linux/miscdevice.h>9#include <linux/poll.h>10#include <linux/dlm.h>11#include <linux/dlm_plock.h>12#include <linux/slab.h>13 14#include <trace/events/dlm.h>15 16#include "dlm_internal.h"17#include "lockspace.h"18 19static DEFINE_SPINLOCK(ops_lock);20static LIST_HEAD(send_list);21static LIST_HEAD(recv_list);22static DECLARE_WAIT_QUEUE_HEAD(send_wq);23static DECLARE_WAIT_QUEUE_HEAD(recv_wq);24 25struct plock_async_data {26 void *fl;27 void *file;28 struct file_lock flc;29 int (*callback)(struct file_lock *fl, int result);30};31 32struct plock_op {33 struct list_head list;34 int done;35 struct dlm_plock_info info;36 /* if set indicates async handling */37 struct plock_async_data *data;38};39 40static inline void set_version(struct dlm_plock_info *info)41{42 info->version[0] = DLM_PLOCK_VERSION_MAJOR;43 info->version[1] = DLM_PLOCK_VERSION_MINOR;44 info->version[2] = DLM_PLOCK_VERSION_PATCH;45}46 47static struct plock_op *plock_lookup_waiter(const struct dlm_plock_info *info)48{49 struct plock_op *op = NULL, *iter;50 51 list_for_each_entry(iter, &recv_list, list) {52 if (iter->info.fsid == info->fsid &&53 iter->info.number == info->number &&54 iter->info.owner == info->owner &&55 iter->info.pid == info->pid &&56 iter->info.start == info->start &&57 iter->info.end == info->end &&58 iter->info.ex == info->ex &&59 iter->info.wait) {60 op = iter;61 break;62 }63 }64 65 return op;66}67 68static int check_version(struct dlm_plock_info *info)69{70 if ((DLM_PLOCK_VERSION_MAJOR != info->version[0]) ||71 (DLM_PLOCK_VERSION_MINOR < info->version[1])) {72 log_print("plock device version mismatch: "73 "kernel (%u.%u.%u), user (%u.%u.%u)",74 DLM_PLOCK_VERSION_MAJOR,75 DLM_PLOCK_VERSION_MINOR,76 DLM_PLOCK_VERSION_PATCH,77 info->version[0],78 info->version[1],79 info->version[2]);80 return -EINVAL;81 }82 return 0;83}84 85static void dlm_release_plock_op(struct plock_op *op)86{87 kfree(op->data);88 kfree(op);89}90 91static void send_op(struct plock_op *op)92{93 set_version(&op->info);94 spin_lock(&ops_lock);95 list_add_tail(&op->list, &send_list);96 spin_unlock(&ops_lock);97 wake_up(&send_wq);98}99 100static int do_lock_cancel(const struct dlm_plock_info *orig_info)101{102 struct plock_op *op;103 int rv;104 105 op = kzalloc(sizeof(*op), GFP_NOFS);106 if (!op)107 return -ENOMEM;108 109 op->info = *orig_info;110 op->info.optype = DLM_PLOCK_OP_CANCEL;111 op->info.wait = 0;112 113 send_op(op);114 wait_event(recv_wq, (op->done != 0));115 116 rv = op->info.rv;117 118 dlm_release_plock_op(op);119 return rv;120}121 122int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file,123 int cmd, struct file_lock *fl)124{125 struct plock_async_data *op_data;126 struct dlm_ls *ls;127 struct plock_op *op;128 int rv;129 130 ls = dlm_find_lockspace_local(lockspace);131 if (!ls)132 return -EINVAL;133 134 op = kzalloc(sizeof(*op), GFP_NOFS);135 if (!op) {136 rv = -ENOMEM;137 goto out;138 }139 140 op->info.optype = DLM_PLOCK_OP_LOCK;141 op->info.pid = fl->c.flc_pid;142 op->info.ex = lock_is_write(fl);143 op->info.wait = !!(fl->c.flc_flags & FL_SLEEP);144 op->info.fsid = ls->ls_global_id;145 op->info.number = number;146 op->info.start = fl->fl_start;147 op->info.end = fl->fl_end;148 op->info.owner = (__u64)(long) fl->c.flc_owner;149 /* async handling */150 if (fl->fl_lmops && fl->fl_lmops->lm_grant) {151 op_data = kzalloc(sizeof(*op_data), GFP_NOFS);152 if (!op_data) {153 dlm_release_plock_op(op);154 rv = -ENOMEM;155 goto out;156 }157 158 op_data->callback = fl->fl_lmops->lm_grant;159 locks_init_lock(&op_data->flc);160 locks_copy_lock(&op_data->flc, fl);161 op_data->fl = fl;162 op_data->file = file;163 164 op->data = op_data;165 166 send_op(op);167 rv = FILE_LOCK_DEFERRED;168 goto out;169 }170 171 send_op(op);172 173 if (op->info.wait) {174 rv = wait_event_interruptible(recv_wq, (op->done != 0));175 if (rv == -ERESTARTSYS) {176 spin_lock(&ops_lock);177 /* recheck under ops_lock if we got a done != 0,178 * if so this interrupt case should be ignored179 */180 if (op->done != 0) {181 spin_unlock(&ops_lock);182 goto do_lock_wait;183 }184 spin_unlock(&ops_lock);185 186 rv = do_lock_cancel(&op->info);187 switch (rv) {188 case 0:189 /* waiter was deleted in user space, answer will never come190 * remove original request. The original request must be191 * on recv_list because the answer of do_lock_cancel()192 * synchronized it.193 */194 spin_lock(&ops_lock);195 list_del(&op->list);196 spin_unlock(&ops_lock);197 rv = -EINTR;198 break;199 case -ENOENT:200 /* cancellation wasn't successful but op should be done */201 fallthrough;202 default:203 /* internal error doing cancel we need to wait */204 goto wait;205 }206 207 log_debug(ls, "%s: wait interrupted %x %llx pid %d",208 __func__, ls->ls_global_id,209 (unsigned long long)number, op->info.pid);210 dlm_release_plock_op(op);211 goto out;212 }213 } else {214wait:215 wait_event(recv_wq, (op->done != 0));216 }217 218do_lock_wait:219 220 WARN_ON(!list_empty(&op->list));221 222 rv = op->info.rv;223 224 if (!rv) {225 if (locks_lock_file_wait(file, fl) < 0)226 log_error(ls, "dlm_posix_lock: vfs lock error %llx",227 (unsigned long long)number);228 }229 230 dlm_release_plock_op(op);231out:232 dlm_put_lockspace(ls);233 return rv;234}235EXPORT_SYMBOL_GPL(dlm_posix_lock);236 237/* Returns failure iff a successful lock operation should be canceled */238static int dlm_plock_callback(struct plock_op *op)239{240 struct plock_async_data *op_data = op->data;241 struct file *file;242 struct file_lock *fl;243 struct file_lock *flc;244 int (*notify)(struct file_lock *fl, int result) = NULL;245 int rv = 0;246 247 WARN_ON(!list_empty(&op->list));248 249 /* check if the following 2 are still valid or make a copy */250 file = op_data->file;251 flc = &op_data->flc;252 fl = op_data->fl;253 notify = op_data->callback;254 255 if (op->info.rv) {256 notify(fl, op->info.rv);257 goto out;258 }259 260 /* got fs lock; bookkeep locally as well: */261 flc->c.flc_flags &= ~FL_SLEEP;262 if (posix_lock_file(file, flc, NULL)) {263 /*264 * This can only happen in the case of kmalloc() failure.265 * The filesystem's own lock is the authoritative lock,266 * so a failure to get the lock locally is not a disaster.267 * As long as the fs cannot reliably cancel locks (especially268 * in a low-memory situation), we're better off ignoring269 * this failure than trying to recover.270 */271 log_print("dlm_plock_callback: vfs lock error %llx file %p fl %p",272 (unsigned long long)op->info.number, file, fl);273 }274 275 rv = notify(fl, 0);276 if (rv) {277 /* XXX: We need to cancel the fs lock here: */278 log_print("%s: lock granted after lock request failed; dangling lock!",279 __func__);280 goto out;281 }282 283out:284 dlm_release_plock_op(op);285 return rv;286}287 288int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file,289 struct file_lock *fl)290{291 struct dlm_ls *ls;292 struct plock_op *op;293 int rv;294 unsigned char saved_flags = fl->c.flc_flags;295 296 ls = dlm_find_lockspace_local(lockspace);297 if (!ls)298 return -EINVAL;299 300 op = kzalloc(sizeof(*op), GFP_NOFS);301 if (!op) {302 rv = -ENOMEM;303 goto out;304 }305 306 /* cause the vfs unlock to return ENOENT if lock is not found */307 fl->c.flc_flags |= FL_EXISTS;308 309 rv = locks_lock_file_wait(file, fl);310 if (rv == -ENOENT) {311 rv = 0;312 goto out_free;313 }314 if (rv < 0) {315 log_error(ls, "dlm_posix_unlock: vfs unlock error %d %llx",316 rv, (unsigned long long)number);317 }318 319 op->info.optype = DLM_PLOCK_OP_UNLOCK;320 op->info.pid = fl->c.flc_pid;321 op->info.fsid = ls->ls_global_id;322 op->info.number = number;323 op->info.start = fl->fl_start;324 op->info.end = fl->fl_end;325 op->info.owner = (__u64)(long) fl->c.flc_owner;326 327 if (fl->c.flc_flags & FL_CLOSE) {328 op->info.flags |= DLM_PLOCK_FL_CLOSE;329 send_op(op);330 rv = 0;331 goto out;332 }333 334 send_op(op);335 wait_event(recv_wq, (op->done != 0));336 337 WARN_ON(!list_empty(&op->list));338 339 rv = op->info.rv;340 341 if (rv == -ENOENT)342 rv = 0;343 344out_free:345 dlm_release_plock_op(op);346out:347 dlm_put_lockspace(ls);348 fl->c.flc_flags = saved_flags;349 return rv;350}351EXPORT_SYMBOL_GPL(dlm_posix_unlock);352 353/*354 * NOTE: This implementation can only handle async lock requests as nfs355 * do it. It cannot handle cancellation of a pending lock request sitting356 * in wait_event(), but for now only nfs is the only user local kernel357 * user.358 */359int dlm_posix_cancel(dlm_lockspace_t *lockspace, u64 number, struct file *file,360 struct file_lock *fl)361{362 struct dlm_plock_info info;363 struct plock_op *op;364 struct dlm_ls *ls;365 int rv;366 367 /* this only works for async request for now and nfs is the only368 * kernel user right now.369 */370 if (WARN_ON_ONCE(!fl->fl_lmops || !fl->fl_lmops->lm_grant))371 return -EOPNOTSUPP;372 373 ls = dlm_find_lockspace_local(lockspace);374 if (!ls)375 return -EINVAL;376 377 memset(&info, 0, sizeof(info));378 info.pid = fl->c.flc_pid;379 info.ex = lock_is_write(fl);380 info.fsid = ls->ls_global_id;381 dlm_put_lockspace(ls);382 info.number = number;383 info.start = fl->fl_start;384 info.end = fl->fl_end;385 info.owner = (__u64)(long) fl->c.flc_owner;386 387 rv = do_lock_cancel(&info);388 switch (rv) {389 case 0:390 spin_lock(&ops_lock);391 /* lock request to cancel must be on recv_list because392 * do_lock_cancel() synchronizes it.393 */394 op = plock_lookup_waiter(&info);395 if (WARN_ON_ONCE(!op)) {396 spin_unlock(&ops_lock);397 rv = -ENOLCK;398 break;399 }400 401 list_del(&op->list);402 spin_unlock(&ops_lock);403 WARN_ON(op->info.optype != DLM_PLOCK_OP_LOCK);404 op->data->callback(op->data->fl, -EINTR);405 dlm_release_plock_op(op);406 rv = -EINTR;407 break;408 case -ENOENT:409 /* if cancel wasn't successful we probably were to late410 * or it was a non-blocking lock request, so just unlock it.411 */412 rv = dlm_posix_unlock(lockspace, number, file, fl);413 break;414 default:415 break;416 }417 418 return rv;419}420EXPORT_SYMBOL_GPL(dlm_posix_cancel);421 422int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file,423 struct file_lock *fl)424{425 struct dlm_ls *ls;426 struct plock_op *op;427 int rv;428 429 ls = dlm_find_lockspace_local(lockspace);430 if (!ls)431 return -EINVAL;432 433 op = kzalloc(sizeof(*op), GFP_NOFS);434 if (!op) {435 rv = -ENOMEM;436 goto out;437 }438 439 op->info.optype = DLM_PLOCK_OP_GET;440 op->info.pid = fl->c.flc_pid;441 op->info.ex = lock_is_write(fl);442 op->info.fsid = ls->ls_global_id;443 op->info.number = number;444 op->info.start = fl->fl_start;445 op->info.end = fl->fl_end;446 op->info.owner = (__u64)(long) fl->c.flc_owner;447 448 send_op(op);449 wait_event(recv_wq, (op->done != 0));450 451 WARN_ON(!list_empty(&op->list));452 453 /* info.rv from userspace is 1 for conflict, 0 for no-conflict,454 -ENOENT if there are no locks on the file */455 456 rv = op->info.rv;457 458 fl->c.flc_type = F_UNLCK;459 if (rv == -ENOENT)460 rv = 0;461 else if (rv > 0) {462 locks_init_lock(fl);463 fl->c.flc_type = (op->info.ex) ? F_WRLCK : F_RDLCK;464 fl->c.flc_flags = FL_POSIX;465 fl->c.flc_pid = op->info.pid;466 if (op->info.nodeid != dlm_our_nodeid())467 fl->c.flc_pid = -fl->c.flc_pid;468 fl->fl_start = op->info.start;469 fl->fl_end = op->info.end;470 rv = 0;471 }472 473 dlm_release_plock_op(op);474out:475 dlm_put_lockspace(ls);476 return rv;477}478EXPORT_SYMBOL_GPL(dlm_posix_get);479 480/* a read copies out one plock request from the send list */481static ssize_t dev_read(struct file *file, char __user *u, size_t count,482 loff_t *ppos)483{484 struct dlm_plock_info info;485 struct plock_op *op = NULL;486 487 if (count < sizeof(info))488 return -EINVAL;489 490 spin_lock(&ops_lock);491 if (!list_empty(&send_list)) {492 op = list_first_entry(&send_list, struct plock_op, list);493 if (op->info.flags & DLM_PLOCK_FL_CLOSE)494 list_del(&op->list);495 else496 list_move_tail(&op->list, &recv_list);497 memcpy(&info, &op->info, sizeof(info));498 }499 spin_unlock(&ops_lock);500 501 if (!op)502 return -EAGAIN;503 504 trace_dlm_plock_read(&info);505 506 /* there is no need to get a reply from userspace for unlocks507 that were generated by the vfs cleaning up for a close508 (the process did not make an unlock call). */509 510 if (op->info.flags & DLM_PLOCK_FL_CLOSE)511 dlm_release_plock_op(op);512 513 if (copy_to_user(u, &info, sizeof(info)))514 return -EFAULT;515 return sizeof(info);516}517 518/* a write copies in one plock result that should match a plock_op519 on the recv list */520static ssize_t dev_write(struct file *file, const char __user *u, size_t count,521 loff_t *ppos)522{523 struct plock_op *op = NULL, *iter;524 struct dlm_plock_info info;525 int do_callback = 0;526 527 if (count != sizeof(info))528 return -EINVAL;529 530 if (copy_from_user(&info, u, sizeof(info)))531 return -EFAULT;532 533 trace_dlm_plock_write(&info);534 535 if (check_version(&info))536 return -EINVAL;537 538 /*539 * The results for waiting ops (SETLKW) can be returned in any540 * order, so match all fields to find the op. The results for541 * non-waiting ops are returned in the order that they were sent542 * to userspace, so match the result with the first non-waiting op.543 */544 spin_lock(&ops_lock);545 if (info.wait) {546 op = plock_lookup_waiter(&info);547 } else {548 list_for_each_entry(iter, &recv_list, list) {549 if (!iter->info.wait &&550 iter->info.fsid == info.fsid) {551 op = iter;552 break;553 }554 }555 }556 557 if (op) {558 /* Sanity check that op and info match. */559 if (info.wait)560 WARN_ON(op->info.optype != DLM_PLOCK_OP_LOCK);561 else562 WARN_ON(op->info.number != info.number ||563 op->info.owner != info.owner ||564 op->info.optype != info.optype);565 566 list_del_init(&op->list);567 memcpy(&op->info, &info, sizeof(info));568 if (op->data)569 do_callback = 1;570 else571 op->done = 1;572 }573 spin_unlock(&ops_lock);574 575 if (op) {576 if (do_callback)577 dlm_plock_callback(op);578 else579 wake_up(&recv_wq);580 } else581 pr_debug("%s: no op %x %llx", __func__,582 info.fsid, (unsigned long long)info.number);583 return count;584}585 586static __poll_t dev_poll(struct file *file, poll_table *wait)587{588 __poll_t mask = 0;589 590 poll_wait(file, &send_wq, wait);591 592 spin_lock(&ops_lock);593 if (!list_empty(&send_list))594 mask = EPOLLIN | EPOLLRDNORM;595 spin_unlock(&ops_lock);596 597 return mask;598}599 600static const struct file_operations dev_fops = {601 .read = dev_read,602 .write = dev_write,603 .poll = dev_poll,604 .owner = THIS_MODULE,605 .llseek = noop_llseek,606};607 608static struct miscdevice plock_dev_misc = {609 .minor = MISC_DYNAMIC_MINOR,610 .name = DLM_PLOCK_MISC_NAME,611 .fops = &dev_fops612};613 614int dlm_plock_init(void)615{616 int rv;617 618 rv = misc_register(&plock_dev_misc);619 if (rv)620 log_print("dlm_plock_init: misc_register failed %d", rv);621 return rv;622}623 624void dlm_plock_exit(void)625{626 misc_deregister(&plock_dev_misc);627 WARN_ON(!list_empty(&send_list));628 WARN_ON(!list_empty(&recv_list));629}630 631