1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/fs/lockd/svc.c 4 * 5 * This is the central lockd service. 6 * 7 * FIXME: Separate the lockd NFS server functionality from the lockd NFS 8 * client functionality. Oh why didn't Sun create two separate 9 * services in the first place? 10 * 11 * Authors: Olaf Kirch (okir@monad.swb.de) 12 * 13 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 14 */ 15 16 #include <linux/module.h> 17 #include <linux/init.h> 18 #include <linux/sysctl.h> 19 #include <linux/moduleparam.h> 20 21 #include <linux/sched/signal.h> 22 #include <linux/errno.h> 23 #include <linux/in.h> 24 #include <linux/uio.h> 25 #include <linux/smp.h> 26 #include <linux/mutex.h> 27 #include <linux/freezer.h> 28 #include <linux/inetdevice.h> 29 30 #include <linux/sunrpc/types.h> 31 #include <linux/sunrpc/stats.h> 32 #include <linux/sunrpc/clnt.h> 33 #include <linux/sunrpc/svc.h> 34 #include <linux/sunrpc/svcsock.h> 35 #include <linux/sunrpc/svc_xprt.h> 36 #include <net/ip.h> 37 #include <net/addrconf.h> 38 #include <net/ipv6.h> 39 #include <linux/lockd/lockd.h> 40 #include <linux/nfs.h> 41 42 #include "netns.h" 43 #include "procfs.h" 44 #include "netlink.h" 45 46 #define NLMDBG_FACILITY NLMDBG_SVC 47 #define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE) 48 49 static struct svc_program nlmsvc_program; 50 51 const struct nlmsvc_binding *nlmsvc_ops; 52 EXPORT_SYMBOL_GPL(nlmsvc_ops); 53 54 static DEFINE_MUTEX(nlmsvc_mutex); 55 static unsigned int nlmsvc_users; 56 static struct svc_serv *nlmsvc_serv; 57 58 static void nlmsvc_request_retry(struct timer_list *tl) 59 { 60 svc_wake_up(nlmsvc_serv); 61 } 62 DEFINE_TIMER(nlmsvc_retry, nlmsvc_request_retry); 63 64 unsigned int lockd_net_id; 65 66 /* 67 * These can be set at insmod time (useful for NFS as root filesystem), 68 * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003 69 */ 70 static unsigned long nlm_grace_period; 71 unsigned long nlm_timeout = LOCKD_DFLT_TIMEO; 72 static int nlm_udpport, nlm_tcpport; 73 74 /* 75 * Constants needed for the sysctl interface. 76 */ 77 static const unsigned long nlm_grace_period_min = 0; 78 static const unsigned long nlm_grace_period_max = 240; 79 static const unsigned long nlm_timeout_min = 3; 80 static const unsigned long nlm_timeout_max = 20; 81 82 #ifdef CONFIG_SYSCTL 83 static const int nlm_port_min = 0, nlm_port_max = 65535; 84 static struct ctl_table_header * nlm_sysctl_table; 85 #endif 86 87 static unsigned long get_lockd_grace_period(struct net *net) 88 { 89 struct lockd_net *ln = net_generic(net, lockd_net_id); 90 91 /* Return the net-ns specific grace period, if there is one */ 92 if (ln->gracetime) 93 return ln->gracetime * HZ; 94 95 /* Note: nlm_timeout should always be nonzero */ 96 if (nlm_grace_period) 97 return roundup(nlm_grace_period, nlm_timeout) * HZ; 98 else 99 return nlm_timeout * 5 * HZ; 100 } 101 102 static void grace_ender(struct work_struct *grace) 103 { 104 struct delayed_work *dwork = to_delayed_work(grace); 105 struct lockd_net *ln = container_of(dwork, struct lockd_net, 106 grace_period_end); 107 108 locks_end_grace(&ln->lockd_manager); 109 } 110 111 static void set_grace_period(struct net *net) 112 { 113 unsigned long grace_period = get_lockd_grace_period(net); 114 struct lockd_net *ln = net_generic(net, lockd_net_id); 115 116 locks_start_grace(net, &ln->lockd_manager); 117 cancel_delayed_work_sync(&ln->grace_period_end); 118 schedule_delayed_work(&ln->grace_period_end, grace_period); 119 } 120 121 /* 122 * This is the lockd kernel thread 123 */ 124 static int 125 lockd(void *vrqstp) 126 { 127 struct svc_rqst *rqstp = vrqstp; 128 struct net *net = &init_net; 129 struct lockd_net *ln = net_generic(net, lockd_net_id); 130 131 svc_thread_init_status(rqstp, 0); 132 133 /* try_to_freeze() is called from svc_recv() */ 134 set_freezable(); 135 136 dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n"); 137 138 /* 139 * The main request loop. We don't terminate until the last 140 * NFS mount or NFS daemon has gone away. 141 */ 142 while (!svc_thread_should_stop(rqstp)) { 143 nlmsvc_retry_blocked(rqstp); 144 svc_recv(rqstp); 145 } 146 if (nlmsvc_ops) 147 nlmsvc_invalidate_all(); 148 nlm_shutdown_hosts(); 149 cancel_delayed_work_sync(&ln->grace_period_end); 150 locks_end_grace(&ln->lockd_manager); 151 152 dprintk("lockd_down: service stopped\n"); 153 154 svc_exit_thread(rqstp); 155 return 0; 156 } 157 158 static int create_lockd_listener(struct svc_serv *serv, const char *name, 159 struct net *net, const int family, 160 const unsigned short port, 161 const struct cred *cred) 162 { 163 struct svc_xprt *xprt; 164 165 xprt = svc_find_xprt(serv, name, net, family, 0); 166 if (xprt == NULL) 167 return svc_xprt_create(serv, name, net, family, port, 168 SVC_SOCK_DEFAULTS, cred); 169 svc_xprt_put(xprt); 170 return 0; 171 } 172 173 static int create_lockd_family(struct svc_serv *serv, struct net *net, 174 const int family, const struct cred *cred) 175 { 176 struct lockd_net *ln = net_generic(net, lockd_net_id); 177 int err; 178 179 err = create_lockd_listener(serv, "udp", net, family, 180 ln->udp_port ? ln->udp_port : nlm_udpport, cred); 181 if (err < 0) 182 return err; 183 184 return create_lockd_listener(serv, "tcp", net, family, 185 ln->tcp_port ? ln->tcp_port : nlm_tcpport, cred); 186 } 187 188 /* 189 * Ensure there are active UDP and TCP listeners for lockd. 190 * 191 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some 192 * local services (such as rpc.statd) still require UDP, and 193 * some NFS servers do not yet support NLM over TCP. 194 * 195 * Returns zero if all listeners are available; otherwise a 196 * negative errno value is returned. 197 */ 198 static int make_socks(struct svc_serv *serv, struct net *net, 199 const struct cred *cred) 200 { 201 static int warned; 202 int err; 203 204 err = create_lockd_family(serv, net, PF_INET, cred); 205 if (err < 0) 206 goto out_err; 207 208 err = create_lockd_family(serv, net, PF_INET6, cred); 209 if (err < 0 && err != -EAFNOSUPPORT) 210 goto out_err; 211 212 warned = 0; 213 return 0; 214 215 out_err: 216 if (warned++ == 0) 217 printk(KERN_WARNING 218 "lockd_up: makesock failed, error=%d\n", err); 219 svc_xprt_destroy_all(serv, net); 220 svc_rpcb_cleanup(serv, net); 221 return err; 222 } 223 224 static int lockd_up_net(struct svc_serv *serv, struct net *net, 225 const struct cred *cred) 226 { 227 struct lockd_net *ln = net_generic(net, lockd_net_id); 228 int error; 229 230 if (ln->nlmsvc_users++) 231 return 0; 232 233 error = svc_bind(serv, net); 234 if (error) 235 goto err_bind; 236 237 error = make_socks(serv, net, cred); 238 if (error < 0) 239 goto err_bind; 240 set_grace_period(net); 241 dprintk("%s: per-net data created; net=%x\n", __func__, net->ns.inum); 242 return 0; 243 244 err_bind: 245 ln->nlmsvc_users--; 246 return error; 247 } 248 249 static void lockd_down_net(struct svc_serv *serv, struct net *net) 250 { 251 struct lockd_net *ln = net_generic(net, lockd_net_id); 252 253 if (ln->nlmsvc_users) { 254 if (--ln->nlmsvc_users == 0) { 255 nlm_shutdown_hosts_net(net); 256 cancel_delayed_work_sync(&ln->grace_period_end); 257 locks_end_grace(&ln->lockd_manager); 258 svc_xprt_destroy_all(serv, net); 259 svc_rpcb_cleanup(serv, net); 260 } 261 } else { 262 pr_err("%s: no users! net=%x\n", 263 __func__, net->ns.inum); 264 BUG(); 265 } 266 } 267 268 static int lockd_inetaddr_event(struct notifier_block *this, 269 unsigned long event, void *ptr) 270 { 271 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 272 struct sockaddr_in sin; 273 274 if (event != NETDEV_DOWN) 275 goto out; 276 277 if (nlmsvc_serv) { 278 dprintk("lockd_inetaddr_event: removed %pI4\n", 279 &ifa->ifa_local); 280 sin.sin_family = AF_INET; 281 sin.sin_addr.s_addr = ifa->ifa_local; 282 svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin); 283 } 284 285 out: 286 return NOTIFY_DONE; 287 } 288 289 static struct notifier_block lockd_inetaddr_notifier = { 290 .notifier_call = lockd_inetaddr_event, 291 }; 292 293 #if IS_ENABLED(CONFIG_IPV6) 294 static int lockd_inet6addr_event(struct notifier_block *this, 295 unsigned long event, void *ptr) 296 { 297 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr; 298 struct sockaddr_in6 sin6; 299 300 if (event != NETDEV_DOWN) 301 goto out; 302 303 if (nlmsvc_serv) { 304 dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr); 305 sin6.sin6_family = AF_INET6; 306 sin6.sin6_addr = ifa->addr; 307 if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL) 308 sin6.sin6_scope_id = ifa->idev->dev->ifindex; 309 svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin6); 310 } 311 312 out: 313 return NOTIFY_DONE; 314 } 315 316 static struct notifier_block lockd_inet6addr_notifier = { 317 .notifier_call = lockd_inet6addr_event, 318 }; 319 #endif 320 321 static int lockd_get(void) 322 { 323 struct svc_serv *serv; 324 int error; 325 326 if (nlmsvc_serv) { 327 nlmsvc_users++; 328 return 0; 329 } 330 331 /* 332 * Sanity check: if there's no pid, 333 * we should be the first user ... 334 */ 335 if (nlmsvc_users) 336 printk(KERN_WARNING 337 "lockd_up: no pid, %d users??\n", nlmsvc_users); 338 339 serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, lockd); 340 if (!serv) { 341 printk(KERN_WARNING "lockd_up: create service failed\n"); 342 return -ENOMEM; 343 } 344 345 error = svc_set_num_threads(serv, NULL, 1); 346 if (error < 0) { 347 svc_destroy(&serv); 348 return error; 349 } 350 351 nlmsvc_serv = serv; 352 register_inetaddr_notifier(&lockd_inetaddr_notifier); 353 #if IS_ENABLED(CONFIG_IPV6) 354 register_inet6addr_notifier(&lockd_inet6addr_notifier); 355 #endif 356 dprintk("lockd_up: service created\n"); 357 nlmsvc_users++; 358 return 0; 359 } 360 361 static void lockd_put(void) 362 { 363 if (WARN(nlmsvc_users <= 0, "lockd_down: no users!\n")) 364 return; 365 if (--nlmsvc_users) 366 return; 367 368 unregister_inetaddr_notifier(&lockd_inetaddr_notifier); 369 #if IS_ENABLED(CONFIG_IPV6) 370 unregister_inet6addr_notifier(&lockd_inet6addr_notifier); 371 #endif 372 373 svc_set_num_threads(nlmsvc_serv, NULL, 0); 374 timer_delete_sync(&nlmsvc_retry); 375 svc_destroy(&nlmsvc_serv); 376 dprintk("lockd_down: service destroyed\n"); 377 } 378 379 /* 380 * Bring up the lockd process if it's not already up. 381 */ 382 int lockd_up(struct net *net, const struct cred *cred) 383 { 384 int error; 385 386 mutex_lock(&nlmsvc_mutex); 387 388 error = lockd_get(); 389 if (error) 390 goto err; 391 392 error = lockd_up_net(nlmsvc_serv, net, cred); 393 if (error < 0) { 394 lockd_put(); 395 goto err; 396 } 397 398 err: 399 mutex_unlock(&nlmsvc_mutex); 400 return error; 401 } 402 EXPORT_SYMBOL_GPL(lockd_up); 403 404 /* 405 * Decrement the user count and bring down lockd if we're the last. 406 */ 407 void 408 lockd_down(struct net *net) 409 { 410 mutex_lock(&nlmsvc_mutex); 411 lockd_down_net(nlmsvc_serv, net); 412 lockd_put(); 413 mutex_unlock(&nlmsvc_mutex); 414 } 415 EXPORT_SYMBOL_GPL(lockd_down); 416 417 #ifdef CONFIG_SYSCTL 418 419 /* 420 * Sysctl parameters (same as module parameters, different interface). 421 */ 422 423 static const struct ctl_table nlm_sysctls[] = { 424 { 425 .procname = "nlm_grace_period", 426 .data = &nlm_grace_period, 427 .maxlen = sizeof(unsigned long), 428 .mode = 0644, 429 .proc_handler = proc_doulongvec_minmax, 430 .extra1 = (unsigned long *) &nlm_grace_period_min, 431 .extra2 = (unsigned long *) &nlm_grace_period_max, 432 }, 433 { 434 .procname = "nlm_timeout", 435 .data = &nlm_timeout, 436 .maxlen = sizeof(unsigned long), 437 .mode = 0644, 438 .proc_handler = proc_doulongvec_minmax, 439 .extra1 = (unsigned long *) &nlm_timeout_min, 440 .extra2 = (unsigned long *) &nlm_timeout_max, 441 }, 442 { 443 .procname = "nlm_udpport", 444 .data = &nlm_udpport, 445 .maxlen = sizeof(int), 446 .mode = 0644, 447 .proc_handler = proc_dointvec_minmax, 448 .extra1 = (int *) &nlm_port_min, 449 .extra2 = (int *) &nlm_port_max, 450 }, 451 { 452 .procname = "nlm_tcpport", 453 .data = &nlm_tcpport, 454 .maxlen = sizeof(int), 455 .mode = 0644, 456 .proc_handler = proc_dointvec_minmax, 457 .extra1 = (int *) &nlm_port_min, 458 .extra2 = (int *) &nlm_port_max, 459 }, 460 { 461 .procname = "nsm_use_hostnames", 462 .data = &nsm_use_hostnames, 463 .maxlen = sizeof(bool), 464 .mode = 0644, 465 .proc_handler = proc_dobool, 466 }, 467 { 468 .procname = "nsm_local_state", 469 .data = &nsm_local_state, 470 .maxlen = sizeof(nsm_local_state), 471 .mode = 0644, 472 .proc_handler = proc_douintvec, 473 .extra1 = SYSCTL_ZERO, 474 }, 475 }; 476 477 #endif /* CONFIG_SYSCTL */ 478 479 /* 480 * Module (and sysfs) parameters. 481 */ 482 483 #define param_set_min_max(name, type, which_strtol, min, max) \ 484 static int param_set_##name(const char *val, const struct kernel_param *kp) \ 485 { \ 486 char *endp; \ 487 __typeof__(type) num = which_strtol(val, &endp, 0); \ 488 if (endp == val || *endp || num < (min) || num > (max)) \ 489 return -EINVAL; \ 490 *((type *) kp->arg) = num; \ 491 return 0; \ 492 } 493 494 static inline int is_callback(u32 proc) 495 { 496 return proc == NLMPROC_GRANTED 497 || proc == NLMPROC_GRANTED_MSG 498 || proc == NLMPROC_TEST_RES 499 || proc == NLMPROC_LOCK_RES 500 || proc == NLMPROC_CANCEL_RES 501 || proc == NLMPROC_UNLOCK_RES 502 || proc == NLMPROC_NSM_NOTIFY; 503 } 504 505 506 static enum svc_auth_status lockd_authenticate(struct svc_rqst *rqstp) 507 { 508 rqstp->rq_client = NULL; 509 switch (rqstp->rq_authop->flavour) { 510 case RPC_AUTH_NULL: 511 case RPC_AUTH_UNIX: 512 rqstp->rq_auth_stat = rpc_auth_ok; 513 if (rqstp->rq_proc == 0) 514 return SVC_OK; 515 if (is_callback(rqstp->rq_proc)) { 516 /* Leave it to individual procedures to 517 * call nlmsvc_lookup_host(rqstp) 518 */ 519 return SVC_OK; 520 } 521 return svc_set_client(rqstp); 522 } 523 rqstp->rq_auth_stat = rpc_autherr_badcred; 524 return SVC_DENIED; 525 } 526 527 528 param_set_min_max(port, int, simple_strtol, 0, 65535) 529 param_set_min_max(grace_period, unsigned long, simple_strtoul, 530 nlm_grace_period_min, nlm_grace_period_max) 531 param_set_min_max(timeout, unsigned long, simple_strtoul, 532 nlm_timeout_min, nlm_timeout_max) 533 534 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 535 MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION "."); 536 MODULE_LICENSE("GPL"); 537 538 module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong, 539 &nlm_grace_period, 0644); 540 module_param_call(nlm_timeout, param_set_timeout, param_get_ulong, 541 &nlm_timeout, 0644); 542 module_param_call(nlm_udpport, param_set_port, param_get_int, 543 &nlm_udpport, 0644); 544 module_param_call(nlm_tcpport, param_set_port, param_get_int, 545 &nlm_tcpport, 0644); 546 module_param(nsm_use_hostnames, bool, 0644); 547 548 static int lockd_init_net(struct net *net) 549 { 550 struct lockd_net *ln = net_generic(net, lockd_net_id); 551 552 INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender); 553 INIT_LIST_HEAD(&ln->lockd_manager.list); 554 ln->lockd_manager.block_opens = false; 555 INIT_LIST_HEAD(&ln->nsm_handles); 556 return 0; 557 } 558 559 static void lockd_exit_net(struct net *net) 560 { 561 struct lockd_net *ln = net_generic(net, lockd_net_id); 562 563 WARN_ONCE(!list_empty(&ln->lockd_manager.list), 564 "net %x %s: lockd_manager.list is not empty\n", 565 net->ns.inum, __func__); 566 WARN_ONCE(!list_empty(&ln->nsm_handles), 567 "net %x %s: nsm_handles list is not empty\n", 568 net->ns.inum, __func__); 569 WARN_ONCE(delayed_work_pending(&ln->grace_period_end), 570 "net %x %s: grace_period_end was not cancelled\n", 571 net->ns.inum, __func__); 572 } 573 574 static struct pernet_operations lockd_net_ops = { 575 .init = lockd_init_net, 576 .exit = lockd_exit_net, 577 .id = &lockd_net_id, 578 .size = sizeof(struct lockd_net), 579 }; 580 581 582 /* 583 * Initialising and terminating the module. 584 */ 585 586 static int __init init_nlm(void) 587 { 588 int err; 589 590 #ifdef CONFIG_SYSCTL 591 err = -ENOMEM; 592 nlm_sysctl_table = register_sysctl("fs/nfs", nlm_sysctls); 593 if (nlm_sysctl_table == NULL) 594 goto err_sysctl; 595 #endif 596 err = register_pernet_subsys(&lockd_net_ops); 597 if (err) 598 goto err_pernet; 599 600 err = genl_register_family(&lockd_nl_family); 601 if (err) 602 goto err_netlink; 603 604 err = lockd_create_procfs(); 605 if (err) 606 goto err_procfs; 607 608 return 0; 609 610 err_procfs: 611 genl_unregister_family(&lockd_nl_family); 612 err_netlink: 613 unregister_pernet_subsys(&lockd_net_ops); 614 err_pernet: 615 #ifdef CONFIG_SYSCTL 616 unregister_sysctl_table(nlm_sysctl_table); 617 err_sysctl: 618 #endif 619 return err; 620 } 621 622 static void __exit exit_nlm(void) 623 { 624 /* FIXME: delete all NLM clients */ 625 nlm_shutdown_hosts(); 626 genl_unregister_family(&lockd_nl_family); 627 lockd_remove_procfs(); 628 unregister_pernet_subsys(&lockd_net_ops); 629 #ifdef CONFIG_SYSCTL 630 unregister_sysctl_table(nlm_sysctl_table); 631 #endif 632 } 633 634 module_init(init_nlm); 635 module_exit(exit_nlm); 636 637 /** 638 * nlmsvc_dispatch - Process an NLM Request 639 * @rqstp: incoming request 640 * 641 * Return values: 642 * %0: Processing complete; do not send a Reply 643 * %1: Processing complete; send Reply in rqstp->rq_res 644 */ 645 static int nlmsvc_dispatch(struct svc_rqst *rqstp) 646 { 647 const struct svc_procedure *procp = rqstp->rq_procinfo; 648 __be32 *statp = rqstp->rq_accept_statp; 649 650 if (!procp->pc_decode(rqstp, &rqstp->rq_arg_stream)) 651 goto out_decode_err; 652 653 *statp = procp->pc_func(rqstp); 654 if (*statp == rpc_drop_reply) 655 return 0; 656 if (*statp != rpc_success) 657 return 1; 658 659 if (!procp->pc_encode(rqstp, &rqstp->rq_res_stream)) 660 goto out_encode_err; 661 662 return 1; 663 664 out_decode_err: 665 *statp = rpc_garbage_args; 666 return 1; 667 668 out_encode_err: 669 *statp = rpc_system_err; 670 return 1; 671 } 672 673 /* 674 * Define NLM program and procedures 675 */ 676 static DEFINE_PER_CPU_ALIGNED(unsigned long, nlmsvc_version1_count[17]); 677 static const struct svc_version nlmsvc_version1 = { 678 .vs_vers = 1, 679 .vs_nproc = 17, 680 .vs_proc = nlmsvc_procedures, 681 .vs_count = nlmsvc_version1_count, 682 .vs_dispatch = nlmsvc_dispatch, 683 .vs_xdrsize = NLMSVC_XDRSIZE, 684 }; 685 686 static DEFINE_PER_CPU_ALIGNED(unsigned long, 687 nlmsvc_version3_count[ARRAY_SIZE(nlmsvc_procedures)]); 688 static const struct svc_version nlmsvc_version3 = { 689 .vs_vers = 3, 690 .vs_nproc = ARRAY_SIZE(nlmsvc_procedures), 691 .vs_proc = nlmsvc_procedures, 692 .vs_count = nlmsvc_version3_count, 693 .vs_dispatch = nlmsvc_dispatch, 694 .vs_xdrsize = NLMSVC_XDRSIZE, 695 }; 696 697 #ifdef CONFIG_LOCKD_V4 698 static DEFINE_PER_CPU_ALIGNED(unsigned long, 699 nlmsvc_version4_count[ARRAY_SIZE(nlmsvc_procedures4)]); 700 static const struct svc_version nlmsvc_version4 = { 701 .vs_vers = 4, 702 .vs_nproc = ARRAY_SIZE(nlmsvc_procedures4), 703 .vs_proc = nlmsvc_procedures4, 704 .vs_count = nlmsvc_version4_count, 705 .vs_dispatch = nlmsvc_dispatch, 706 .vs_xdrsize = NLMSVC_XDRSIZE, 707 }; 708 #endif 709 710 static const struct svc_version *nlmsvc_version[] = { 711 [1] = &nlmsvc_version1, 712 [3] = &nlmsvc_version3, 713 #ifdef CONFIG_LOCKD_V4 714 [4] = &nlmsvc_version4, 715 #endif 716 }; 717 718 #define NLM_NRVERS ARRAY_SIZE(nlmsvc_version) 719 static struct svc_program nlmsvc_program = { 720 .pg_prog = NLM_PROGRAM, /* program number */ 721 .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */ 722 .pg_vers = nlmsvc_version, /* version table */ 723 .pg_name = "lockd", /* service name */ 724 .pg_class = "nfsd", /* share authentication with nfsd */ 725 .pg_authenticate = &lockd_authenticate, /* export authentication */ 726 .pg_init_request = svc_generic_init_request, 727 .pg_rpcbind_set = svc_generic_rpcbind_set, 728 }; 729 730 /** 731 * lockd_nl_server_set_doit - set the lockd server parameters via netlink 732 * @skb: reply buffer 733 * @info: netlink metadata and command arguments 734 * 735 * This updates the per-net values. When updating the values in the init_net 736 * namespace, also update the "legacy" global values. 737 * 738 * Return 0 on success or a negative errno. 739 */ 740 int lockd_nl_server_set_doit(struct sk_buff *skb, struct genl_info *info) 741 { 742 struct net *net = genl_info_net(info); 743 struct lockd_net *ln = net_generic(net, lockd_net_id); 744 const struct nlattr *attr; 745 746 if (GENL_REQ_ATTR_CHECK(info, LOCKD_A_SERVER_GRACETIME)) 747 return -EINVAL; 748 749 if (info->attrs[LOCKD_A_SERVER_GRACETIME] || 750 info->attrs[LOCKD_A_SERVER_TCP_PORT] || 751 info->attrs[LOCKD_A_SERVER_UDP_PORT]) { 752 attr = info->attrs[LOCKD_A_SERVER_GRACETIME]; 753 if (attr) { 754 u32 gracetime = nla_get_u32(attr); 755 756 if (gracetime > nlm_grace_period_max) 757 return -EINVAL; 758 759 ln->gracetime = gracetime; 760 761 if (net == &init_net) 762 nlm_grace_period = gracetime; 763 } 764 765 attr = info->attrs[LOCKD_A_SERVER_TCP_PORT]; 766 if (attr) { 767 ln->tcp_port = nla_get_u16(attr); 768 if (net == &init_net) 769 nlm_tcpport = ln->tcp_port; 770 } 771 772 attr = info->attrs[LOCKD_A_SERVER_UDP_PORT]; 773 if (attr) { 774 ln->udp_port = nla_get_u16(attr); 775 if (net == &init_net) 776 nlm_udpport = ln->udp_port; 777 } 778 } 779 return 0; 780 } 781 782 /** 783 * lockd_nl_server_get_doit - get lockd server parameters via netlink 784 * @skb: reply buffer 785 * @info: netlink metadata and command arguments 786 * 787 * Return 0 on success or a negative errno. 788 */ 789 int lockd_nl_server_get_doit(struct sk_buff *skb, struct genl_info *info) 790 { 791 struct net *net = genl_info_net(info); 792 struct lockd_net *ln = net_generic(net, lockd_net_id); 793 void *hdr; 794 int err; 795 796 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 797 if (!skb) 798 return -ENOMEM; 799 800 hdr = genlmsg_iput(skb, info); 801 if (!hdr) { 802 err = -EMSGSIZE; 803 goto err_free_msg; 804 } 805 806 err = nla_put_u32(skb, LOCKD_A_SERVER_GRACETIME, ln->gracetime) || 807 nla_put_u16(skb, LOCKD_A_SERVER_TCP_PORT, ln->tcp_port) || 808 nla_put_u16(skb, LOCKD_A_SERVER_UDP_PORT, ln->udp_port); 809 if (err) 810 goto err_free_msg; 811 812 genlmsg_end(skb, hdr); 813 814 return genlmsg_reply(skb, info); 815 err_free_msg: 816 nlmsg_free(skb); 817 818 return err; 819 } 820