1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved. 4 */ 5 6 #include <linux/fs.h> 7 #include <linux/miscdevice.h> 8 #include <linux/poll.h> 9 #include <linux/dlm.h> 10 #include <linux/dlm_plock.h> 11 #include <linux/slab.h> 12 13 #include "dlm_internal.h" 14 #include "lockspace.h" 15 16 static spinlock_t ops_lock; 17 static struct list_head send_list; 18 static struct list_head recv_list; 19 static wait_queue_head_t send_wq; 20 static wait_queue_head_t recv_wq; 21 22 struct plock_op { 23 struct list_head list; 24 int done; 25 struct dlm_plock_info info; 26 }; 27 28 struct plock_xop { 29 struct plock_op xop; 30 int (*callback)(struct file_lock *fl, int result); 31 void *fl; 32 void *file; 33 struct file_lock flc; 34 }; 35 36 37 static inline void set_version(struct dlm_plock_info *info) 38 { 39 info->version[0] = DLM_PLOCK_VERSION_MAJOR; 40 info->version[1] = DLM_PLOCK_VERSION_MINOR; 41 info->version[2] = DLM_PLOCK_VERSION_PATCH; 42 } 43 44 static int check_version(struct dlm_plock_info *info) 45 { 46 if ((DLM_PLOCK_VERSION_MAJOR != info->version[0]) || 47 (DLM_PLOCK_VERSION_MINOR < info->version[1])) { 48 log_print("plock device version mismatch: " 49 "kernel (%u.%u.%u), user (%u.%u.%u)", 50 DLM_PLOCK_VERSION_MAJOR, 51 DLM_PLOCK_VERSION_MINOR, 52 DLM_PLOCK_VERSION_PATCH, 53 info->version[0], 54 info->version[1], 55 info->version[2]); 56 return -EINVAL; 57 } 58 return 0; 59 } 60 61 static void send_op(struct plock_op *op) 62 { 63 set_version(&op->info); 64 INIT_LIST_HEAD(&op->list); 65 spin_lock(&ops_lock); 66 list_add_tail(&op->list, &send_list); 67 spin_unlock(&ops_lock); 68 wake_up(&send_wq); 69 } 70 71 /* If a process was killed while waiting for the only plock on a file, 72 locks_remove_posix will not see any lock on the file so it won't 73 send an unlock-close to us to pass on to userspace to clean up the 74 abandoned waiter. So, we have to insert the unlock-close when the 75 lock call is interrupted. */ 76 77 static void do_unlock_close(struct dlm_ls *ls, u64 number, 78 struct file *file, struct file_lock *fl) 79 { 80 struct plock_op *op; 81 82 op = kzalloc(sizeof(*op), GFP_NOFS); 83 if (!op) 84 return; 85 86 op->info.optype = DLM_PLOCK_OP_UNLOCK; 87 op->info.pid = fl->fl_pid; 88 op->info.fsid = ls->ls_global_id; 89 op->info.number = number; 90 op->info.start = 0; 91 op->info.end = OFFSET_MAX; 92 if (fl->fl_lmops && fl->fl_lmops->lm_grant) 93 op->info.owner = (__u64) fl->fl_pid; 94 else 95 op->info.owner = (__u64)(long) fl->fl_owner; 96 97 op->info.flags |= DLM_PLOCK_FL_CLOSE; 98 send_op(op); 99 } 100 101 int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file, 102 int cmd, struct file_lock *fl) 103 { 104 struct dlm_ls *ls; 105 struct plock_op *op; 106 struct plock_xop *xop; 107 int rv; 108 109 ls = dlm_find_lockspace_local(lockspace); 110 if (!ls) 111 return -EINVAL; 112 113 xop = kzalloc(sizeof(*xop), GFP_NOFS); 114 if (!xop) { 115 rv = -ENOMEM; 116 goto out; 117 } 118 119 op = &xop->xop; 120 op->info.optype = DLM_PLOCK_OP_LOCK; 121 op->info.pid = fl->fl_pid; 122 op->info.ex = (fl->fl_type == F_WRLCK); 123 op->info.wait = IS_SETLKW(cmd); 124 op->info.fsid = ls->ls_global_id; 125 op->info.number = number; 126 op->info.start = fl->fl_start; 127 op->info.end = fl->fl_end; 128 if (fl->fl_lmops && fl->fl_lmops->lm_grant) { 129 /* fl_owner is lockd which doesn't distinguish 130 processes on the nfs client */ 131 op->info.owner = (__u64) fl->fl_pid; 132 xop->callback = fl->fl_lmops->lm_grant; 133 locks_init_lock(&xop->flc); 134 locks_copy_lock(&xop->flc, fl); 135 xop->fl = fl; 136 xop->file = file; 137 } else { 138 op->info.owner = (__u64)(long) fl->fl_owner; 139 xop->callback = NULL; 140 } 141 142 send_op(op); 143 144 if (xop->callback == NULL) { 145 rv = wait_event_interruptible(recv_wq, (op->done != 0)); 146 if (rv == -ERESTARTSYS) { 147 log_debug(ls, "dlm_posix_lock: wait killed %llx", 148 (unsigned long long)number); 149 spin_lock(&ops_lock); 150 list_del(&op->list); 151 spin_unlock(&ops_lock); 152 kfree(xop); 153 do_unlock_close(ls, number, file, fl); 154 goto out; 155 } 156 } else { 157 rv = FILE_LOCK_DEFERRED; 158 goto out; 159 } 160 161 spin_lock(&ops_lock); 162 if (!list_empty(&op->list)) { 163 log_error(ls, "dlm_posix_lock: op on list %llx", 164 (unsigned long long)number); 165 list_del(&op->list); 166 } 167 spin_unlock(&ops_lock); 168 169 rv = op->info.rv; 170 171 if (!rv) { 172 if (locks_lock_file_wait(file, fl) < 0) 173 log_error(ls, "dlm_posix_lock: vfs lock error %llx", 174 (unsigned long long)number); 175 } 176 177 kfree(xop); 178 out: 179 dlm_put_lockspace(ls); 180 return rv; 181 } 182 EXPORT_SYMBOL_GPL(dlm_posix_lock); 183 184 /* Returns failure iff a successful lock operation should be canceled */ 185 static int dlm_plock_callback(struct plock_op *op) 186 { 187 struct file *file; 188 struct file_lock *fl; 189 struct file_lock *flc; 190 int (*notify)(struct file_lock *fl, int result) = NULL; 191 struct plock_xop *xop = (struct plock_xop *)op; 192 int rv = 0; 193 194 spin_lock(&ops_lock); 195 if (!list_empty(&op->list)) { 196 log_print("dlm_plock_callback: op on list %llx", 197 (unsigned long long)op->info.number); 198 list_del(&op->list); 199 } 200 spin_unlock(&ops_lock); 201 202 /* check if the following 2 are still valid or make a copy */ 203 file = xop->file; 204 flc = &xop->flc; 205 fl = xop->fl; 206 notify = xop->callback; 207 208 if (op->info.rv) { 209 notify(fl, op->info.rv); 210 goto out; 211 } 212 213 /* got fs lock; bookkeep locally as well: */ 214 flc->fl_flags &= ~FL_SLEEP; 215 if (posix_lock_file(file, flc, NULL)) { 216 /* 217 * This can only happen in the case of kmalloc() failure. 218 * The filesystem's own lock is the authoritative lock, 219 * so a failure to get the lock locally is not a disaster. 220 * As long as the fs cannot reliably cancel locks (especially 221 * in a low-memory situation), we're better off ignoring 222 * this failure than trying to recover. 223 */ 224 log_print("dlm_plock_callback: vfs lock error %llx file %p fl %p", 225 (unsigned long long)op->info.number, file, fl); 226 } 227 228 rv = notify(fl, 0); 229 if (rv) { 230 /* XXX: We need to cancel the fs lock here: */ 231 log_print("dlm_plock_callback: lock granted after lock request " 232 "failed; dangling lock!\n"); 233 goto out; 234 } 235 236 out: 237 kfree(xop); 238 return rv; 239 } 240 241 int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file, 242 struct file_lock *fl) 243 { 244 struct dlm_ls *ls; 245 struct plock_op *op; 246 int rv; 247 unsigned char fl_flags = fl->fl_flags; 248 249 ls = dlm_find_lockspace_local(lockspace); 250 if (!ls) 251 return -EINVAL; 252 253 op = kzalloc(sizeof(*op), GFP_NOFS); 254 if (!op) { 255 rv = -ENOMEM; 256 goto out; 257 } 258 259 /* cause the vfs unlock to return ENOENT if lock is not found */ 260 fl->fl_flags |= FL_EXISTS; 261 262 rv = locks_lock_file_wait(file, fl); 263 if (rv == -ENOENT) { 264 rv = 0; 265 goto out_free; 266 } 267 if (rv < 0) { 268 log_error(ls, "dlm_posix_unlock: vfs unlock error %d %llx", 269 rv, (unsigned long long)number); 270 } 271 272 op->info.optype = DLM_PLOCK_OP_UNLOCK; 273 op->info.pid = fl->fl_pid; 274 op->info.fsid = ls->ls_global_id; 275 op->info.number = number; 276 op->info.start = fl->fl_start; 277 op->info.end = fl->fl_end; 278 if (fl->fl_lmops && fl->fl_lmops->lm_grant) 279 op->info.owner = (__u64) fl->fl_pid; 280 else 281 op->info.owner = (__u64)(long) fl->fl_owner; 282 283 if (fl->fl_flags & FL_CLOSE) { 284 op->info.flags |= DLM_PLOCK_FL_CLOSE; 285 send_op(op); 286 rv = 0; 287 goto out; 288 } 289 290 send_op(op); 291 wait_event(recv_wq, (op->done != 0)); 292 293 spin_lock(&ops_lock); 294 if (!list_empty(&op->list)) { 295 log_error(ls, "dlm_posix_unlock: op on list %llx", 296 (unsigned long long)number); 297 list_del(&op->list); 298 } 299 spin_unlock(&ops_lock); 300 301 rv = op->info.rv; 302 303 if (rv == -ENOENT) 304 rv = 0; 305 306 out_free: 307 kfree(op); 308 out: 309 dlm_put_lockspace(ls); 310 fl->fl_flags = fl_flags; 311 return rv; 312 } 313 EXPORT_SYMBOL_GPL(dlm_posix_unlock); 314 315 int dlm_posix_get(dlm_lockspace_t *lockspace, u64 number, struct file *file, 316 struct file_lock *fl) 317 { 318 struct dlm_ls *ls; 319 struct plock_op *op; 320 int rv; 321 322 ls = dlm_find_lockspace_local(lockspace); 323 if (!ls) 324 return -EINVAL; 325 326 op = kzalloc(sizeof(*op), GFP_NOFS); 327 if (!op) { 328 rv = -ENOMEM; 329 goto out; 330 } 331 332 op->info.optype = DLM_PLOCK_OP_GET; 333 op->info.pid = fl->fl_pid; 334 op->info.ex = (fl->fl_type == F_WRLCK); 335 op->info.fsid = ls->ls_global_id; 336 op->info.number = number; 337 op->info.start = fl->fl_start; 338 op->info.end = fl->fl_end; 339 if (fl->fl_lmops && fl->fl_lmops->lm_grant) 340 op->info.owner = (__u64) fl->fl_pid; 341 else 342 op->info.owner = (__u64)(long) fl->fl_owner; 343 344 send_op(op); 345 wait_event(recv_wq, (op->done != 0)); 346 347 spin_lock(&ops_lock); 348 if (!list_empty(&op->list)) { 349 log_error(ls, "dlm_posix_get: op on list %llx", 350 (unsigned long long)number); 351 list_del(&op->list); 352 } 353 spin_unlock(&ops_lock); 354 355 /* info.rv from userspace is 1 for conflict, 0 for no-conflict, 356 -ENOENT if there are no locks on the file */ 357 358 rv = op->info.rv; 359 360 fl->fl_type = F_UNLCK; 361 if (rv == -ENOENT) 362 rv = 0; 363 else if (rv > 0) { 364 locks_init_lock(fl); 365 fl->fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK; 366 fl->fl_flags = FL_POSIX; 367 fl->fl_pid = -op->info.pid; 368 fl->fl_start = op->info.start; 369 fl->fl_end = op->info.end; 370 rv = 0; 371 } 372 373 kfree(op); 374 out: 375 dlm_put_lockspace(ls); 376 return rv; 377 } 378 EXPORT_SYMBOL_GPL(dlm_posix_get); 379 380 /* a read copies out one plock request from the send list */ 381 static ssize_t dev_read(struct file *file, char __user *u, size_t count, 382 loff_t *ppos) 383 { 384 struct dlm_plock_info info; 385 struct plock_op *op = NULL; 386 387 if (count < sizeof(info)) 388 return -EINVAL; 389 390 spin_lock(&ops_lock); 391 if (!list_empty(&send_list)) { 392 op = list_entry(send_list.next, struct plock_op, list); 393 if (op->info.flags & DLM_PLOCK_FL_CLOSE) 394 list_del(&op->list); 395 else 396 list_move(&op->list, &recv_list); 397 memcpy(&info, &op->info, sizeof(info)); 398 } 399 spin_unlock(&ops_lock); 400 401 if (!op) 402 return -EAGAIN; 403 404 /* there is no need to get a reply from userspace for unlocks 405 that were generated by the vfs cleaning up for a close 406 (the process did not make an unlock call). */ 407 408 if (op->info.flags & DLM_PLOCK_FL_CLOSE) 409 kfree(op); 410 411 if (copy_to_user(u, &info, sizeof(info))) 412 return -EFAULT; 413 return sizeof(info); 414 } 415 416 /* a write copies in one plock result that should match a plock_op 417 on the recv list */ 418 static ssize_t dev_write(struct file *file, const char __user *u, size_t count, 419 loff_t *ppos) 420 { 421 struct dlm_plock_info info; 422 struct plock_op *op; 423 int found = 0, do_callback = 0; 424 425 if (count != sizeof(info)) 426 return -EINVAL; 427 428 if (copy_from_user(&info, u, sizeof(info))) 429 return -EFAULT; 430 431 if (check_version(&info)) 432 return -EINVAL; 433 434 spin_lock(&ops_lock); 435 list_for_each_entry(op, &recv_list, list) { 436 if (op->info.fsid == info.fsid && 437 op->info.number == info.number && 438 op->info.owner == info.owner) { 439 struct plock_xop *xop = (struct plock_xop *)op; 440 list_del_init(&op->list); 441 memcpy(&op->info, &info, sizeof(info)); 442 if (xop->callback) 443 do_callback = 1; 444 else 445 op->done = 1; 446 found = 1; 447 break; 448 } 449 } 450 spin_unlock(&ops_lock); 451 452 if (found) { 453 if (do_callback) 454 dlm_plock_callback(op); 455 else 456 wake_up(&recv_wq); 457 } else 458 log_print("dev_write no op %x %llx", info.fsid, 459 (unsigned long long)info.number); 460 return count; 461 } 462 463 static __poll_t dev_poll(struct file *file, poll_table *wait) 464 { 465 __poll_t mask = 0; 466 467 poll_wait(file, &send_wq, wait); 468 469 spin_lock(&ops_lock); 470 if (!list_empty(&send_list)) 471 mask = EPOLLIN | EPOLLRDNORM; 472 spin_unlock(&ops_lock); 473 474 return mask; 475 } 476 477 static const struct file_operations dev_fops = { 478 .read = dev_read, 479 .write = dev_write, 480 .poll = dev_poll, 481 .owner = THIS_MODULE, 482 .llseek = noop_llseek, 483 }; 484 485 static struct miscdevice plock_dev_misc = { 486 .minor = MISC_DYNAMIC_MINOR, 487 .name = DLM_PLOCK_MISC_NAME, 488 .fops = &dev_fops 489 }; 490 491 int dlm_plock_init(void) 492 { 493 int rv; 494 495 spin_lock_init(&ops_lock); 496 INIT_LIST_HEAD(&send_list); 497 INIT_LIST_HEAD(&recv_list); 498 init_waitqueue_head(&send_wq); 499 init_waitqueue_head(&recv_wq); 500 501 rv = misc_register(&plock_dev_misc); 502 if (rv) 503 log_print("dlm_plock_init: misc_register failed %d", rv); 504 return rv; 505 } 506 507 void dlm_plock_exit(void) 508 { 509 misc_deregister(&plock_dev_misc); 510 } 511 512