1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1980, 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/param.h> 33 #include <sys/mount.h> 34 #include <sys/socket.h> 35 #include <sys/stat.h> 36 37 #include <netdb.h> 38 #include <rpc/rpc.h> 39 #include <rpcsvc/mount.h> 40 #include <nfs/nfssvc.h> 41 42 #include <ctype.h> 43 #include <err.h> 44 #include <errno.h> 45 #include <fstab.h> 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <unistd.h> 50 51 #include "mounttab.h" 52 53 /* used by md_detach() */ 54 #include <sys/ioctl.h> 55 #include <sys/mdioctl.h> 56 #include <fcntl.h> 57 #include <paths.h> 58 59 #define DEV_MD _PATH_DEV MD_NAME 60 #define DEV_MDCTL _PATH_DEV MDCTL_NAME 61 62 typedef enum { FIND, REMOVE, CHECKUNIQUE } dowhat; 63 64 static struct addrinfo *nfshost_ai = NULL; 65 static int dflag, fflag, vflag; 66 static int all; 67 static char *nfshost; 68 69 struct statfs *checkmntlist(char *); 70 int checkvfsname (const char *, char **); 71 struct statfs *getmntentry(const char *fromname, const char *onname, 72 fsid_t *fsid, dowhat what); 73 char **makevfslist (const char *); 74 size_t mntinfo (struct statfs **); 75 int namematch (struct addrinfo *); 76 int parsehexfsid(const char *hex, fsid_t *fsid); 77 int sacmp (void *, void *); 78 int umountall (char **); 79 int checkname (char *, char **); 80 int umountfs(struct statfs *sfs); 81 void usage (void); 82 int xdr_dir (XDR *, char *); 83 int md_detach(const char *); 84 85 int 86 main(int argc, char *argv[]) 87 { 88 int errs, ch, mntsize, error, nfsforce, ret; 89 char **typelist = NULL; 90 struct statfs *mntbuf, *sfs; 91 struct addrinfo hints; 92 93 nfsforce = all = errs = 0; 94 while ((ch = getopt(argc, argv, "AadF:fh:Nnt:v")) != -1) 95 switch (ch) { 96 case 'A': 97 all = 2; 98 break; 99 case 'a': 100 all = 1; 101 break; 102 case 'd': 103 dflag = 1; 104 break; 105 case 'F': 106 setfstab(optarg); 107 break; 108 case 'f': 109 fflag |= MNT_FORCE; 110 break; 111 case 'h': /* -h implies -A. */ 112 all = 2; 113 nfshost = optarg; 114 break; 115 case 'N': 116 nfsforce = 1; 117 break; 118 case 'n': 119 fflag |= MNT_NONBUSY; 120 break; 121 case 't': 122 if (typelist != NULL) 123 err(1, "only one -t option may be specified"); 124 typelist = makevfslist(optarg); 125 break; 126 case 'v': 127 vflag = 1; 128 break; 129 default: 130 usage(); 131 /* NOTREACHED */ 132 } 133 argc -= optind; 134 argv += optind; 135 136 if ((fflag & MNT_FORCE) != 0 && (fflag & MNT_NONBUSY) != 0) 137 err(1, "-f and -n are mutually exclusive"); 138 139 if ((argc == 0 && !all) || (argc != 0 && all)) 140 usage(); 141 142 if (nfsforce != 0 && (argc == 0 || nfshost != NULL || typelist != NULL)) 143 usage(); 144 145 /* -h implies "-t nfs" if no -t flag. */ 146 if ((nfshost != NULL) && (typelist == NULL)) 147 typelist = makevfslist("nfs"); 148 149 if (nfshost != NULL) { 150 memset(&hints, 0, sizeof hints); 151 error = getaddrinfo(nfshost, NULL, &hints, &nfshost_ai); 152 if (error) 153 errx(1, "%s: %s", nfshost, gai_strerror(error)); 154 } 155 156 switch (all) { 157 case 2: 158 if ((mntsize = mntinfo(&mntbuf)) <= 0) 159 break; 160 /* 161 * We unmount the nfs-mounts in the reverse order 162 * that they were mounted. 163 */ 164 for (errs = 0, mntsize--; mntsize > 0; mntsize--) { 165 sfs = &mntbuf[mntsize]; 166 if (checkvfsname(sfs->f_fstypename, typelist)) 167 continue; 168 if (strcmp(sfs->f_mntonname, "/dev") == 0) 169 continue; 170 if (umountfs(sfs) != 0) 171 errs = 1; 172 } 173 free(mntbuf); 174 break; 175 case 1: 176 if (setfsent() == 0) 177 err(1, "%s", getfstab()); 178 errs = umountall(typelist); 179 break; 180 case 0: 181 for (errs = 0; *argv != NULL; ++argv) 182 if (nfsforce != 0) { 183 /* 184 * First do the nfssvc() syscall to shut down 185 * the mount point and then do the forced 186 * dismount. 187 */ 188 ret = nfssvc(NFSSVC_FORCEDISM, *argv); 189 if (ret >= 0) 190 ret = unmount(*argv, MNT_FORCE); 191 if (ret < 0) { 192 warn("%s", *argv); 193 errs = 1; 194 } 195 } else if (checkname(*argv, typelist) != 0) 196 errs = 1; 197 break; 198 } 199 exit(errs); 200 } 201 202 int 203 umountall(char **typelist) 204 { 205 struct xvfsconf vfc; 206 struct fstab *fs; 207 int rval; 208 char *cp; 209 static int firstcall = 1; 210 211 if ((fs = getfsent()) != NULL) 212 firstcall = 0; 213 else if (firstcall) 214 errx(1, "fstab reading failure"); 215 else 216 return (0); 217 do { 218 /* Ignore the root. */ 219 if (strcmp(fs->fs_file, "/") == 0) 220 continue; 221 /* 222 * !!! 223 * Historic practice: ignore unknown FSTAB_* fields. 224 */ 225 if (strcmp(fs->fs_type, FSTAB_RW) && 226 strcmp(fs->fs_type, FSTAB_RO) && 227 strcmp(fs->fs_type, FSTAB_RQ)) 228 continue; 229 /* Ignore unknown file system types. */ 230 if (getvfsbyname(fs->fs_vfstype, &vfc) == -1) 231 continue; 232 if (checkvfsname(fs->fs_vfstype, typelist)) 233 continue; 234 235 /* 236 * We want to unmount the file systems in the reverse order 237 * that they were mounted. So, we save off the file name 238 * in some allocated memory, and then call recursively. 239 */ 240 if ((cp = malloc((size_t)strlen(fs->fs_file) + 1)) == NULL) 241 err(1, "malloc failed"); 242 (void)strcpy(cp, fs->fs_file); 243 rval = umountall(typelist); 244 rval = checkname(cp, typelist) || rval; 245 free(cp); 246 return (rval); 247 } while ((fs = getfsent()) != NULL); 248 return (0); 249 } 250 251 /* 252 * Do magic checks on mountpoint/device/fsid, and then call unmount(2). 253 */ 254 int 255 checkname(char *mntname, char **typelist) 256 { 257 char buf[MAXPATHLEN]; 258 struct statfs sfsbuf; 259 struct stat sb; 260 struct statfs *sfs; 261 char *delimp; 262 dev_t dev; 263 int len; 264 265 /* 266 * 1. Check if the name exists in the mounttable. 267 */ 268 sfs = checkmntlist(mntname); 269 /* 270 * 2. Remove trailing slashes if there are any. After that 271 * we look up the name in the mounttable again. 272 */ 273 if (sfs == NULL) { 274 len = strlen(mntname); 275 while (len > 1 && mntname[len - 1] == '/') 276 mntname[--len] = '\0'; 277 sfs = checkmntlist(mntname); 278 } 279 /* 280 * 3. Check if the deprecated NFS syntax with an '@' has been used 281 * and translate it to the ':' syntax. Look up the name in the 282 * mount table again. 283 */ 284 if (sfs == NULL && (delimp = strrchr(mntname, '@')) != NULL) { 285 snprintf(buf, sizeof(buf), "%s:%.*s", delimp + 1, 286 (int)(delimp - mntname), mntname); 287 len = strlen(buf); 288 while (len > 1 && buf[len - 1] == '/') 289 buf[--len] = '\0'; 290 sfs = checkmntlist(buf); 291 } 292 /* 293 * 4. Resort to a statfs(2) call. This is the last check so that 294 * hung NFS filesystems for example can be unmounted without 295 * potentially blocking forever in statfs() as long as the 296 * filesystem is specified unambiguously. This covers all the 297 * hard cases such as symlinks and mismatches between the 298 * mount list and reality. 299 * We also do this if an ambiguous mount point was specified. 300 */ 301 if (sfs == NULL || (getmntentry(NULL, mntname, NULL, FIND) != NULL && 302 getmntentry(NULL, mntname, NULL, CHECKUNIQUE) == NULL)) { 303 if (statfs(mntname, &sfsbuf) != 0) { 304 warn("%s: statfs", mntname); 305 } else if (stat(mntname, &sb) != 0) { 306 warn("%s: stat", mntname); 307 } else if (S_ISDIR(sb.st_mode)) { 308 /* Check that `mntname' is the root directory. */ 309 dev = sb.st_dev; 310 snprintf(buf, sizeof(buf), "%s/..", mntname); 311 if (stat(buf, &sb) != 0) { 312 warn("%s: stat", buf); 313 } else if (sb.st_dev == dev) { 314 warnx("%s: not a file system root directory", 315 mntname); 316 return (1); 317 } else 318 sfs = &sfsbuf; 319 } 320 } 321 if (sfs == NULL) { 322 warnx("%s: unknown file system", mntname); 323 return (1); 324 } 325 if (checkvfsname(sfs->f_fstypename, typelist)) 326 return (1); 327 return (umountfs(sfs)); 328 } 329 330 /* 331 * NFS stuff and unmount(2) call 332 */ 333 int 334 umountfs(struct statfs *sfs) 335 { 336 char fsidbuf[64]; 337 enum clnt_stat clnt_stat; 338 struct timeval try; 339 struct addrinfo *ai, hints; 340 int do_rpc; 341 CLIENT *clp; 342 char *nfsdirname, *orignfsdirname; 343 char *hostp, *delimp; 344 char buf[1024]; 345 struct nfscl_dumpmntopts dumpmntopts; 346 const char *proto_ptr = NULL; 347 348 ai = NULL; 349 do_rpc = 0; 350 hostp = NULL; 351 nfsdirname = delimp = orignfsdirname = NULL; 352 memset(&hints, 0, sizeof hints); 353 354 if (strcmp(sfs->f_fstypename, "nfs") == 0) { 355 if ((nfsdirname = strdup(sfs->f_mntfromname)) == NULL) 356 err(1, "strdup"); 357 orignfsdirname = nfsdirname; 358 if (*nfsdirname == '[' && 359 (delimp = strchr(nfsdirname + 1, ']')) != NULL && 360 *(delimp + 1) == ':') { 361 hostp = nfsdirname + 1; 362 nfsdirname = delimp + 2; 363 } else if ((delimp = strrchr(nfsdirname, ':')) != NULL) { 364 hostp = nfsdirname; 365 nfsdirname = delimp + 1; 366 } 367 if (hostp != NULL) { 368 *delimp = '\0'; 369 getaddrinfo(hostp, NULL, &hints, &ai); 370 if (ai == NULL) { 371 warnx("can't get net id for host"); 372 } 373 } 374 375 /* 376 * Check if we have to start the rpc-call later. 377 * If there are still identical nfs-names mounted, 378 * we skip the rpc-call. Obviously this has to 379 * happen before unmount(2), but it should happen 380 * after the previous namecheck. 381 * A non-NULL return means that this is the last 382 * mount from mntfromname that is still mounted. 383 */ 384 if (getmntentry(sfs->f_mntfromname, NULL, NULL, 385 CHECKUNIQUE) != NULL) { 386 do_rpc = 1; 387 proto_ptr = "udp"; 388 /* 389 * Try and find out whether this NFS mount is NFSv4 and 390 * what protocol is being used. If this fails, the 391 * default is NFSv2,3 and use UDP for the Unmount RPC. 392 */ 393 dumpmntopts.ndmnt_fname = sfs->f_mntonname; 394 dumpmntopts.ndmnt_buf = buf; 395 dumpmntopts.ndmnt_blen = sizeof(buf); 396 if (nfssvc(NFSSVC_DUMPMNTOPTS, &dumpmntopts) >= 0) { 397 if (strstr(buf, "nfsv4,") != NULL) 398 do_rpc = 0; 399 else if (strstr(buf, ",tcp,") != NULL) 400 proto_ptr = "tcp"; 401 } 402 } 403 } 404 405 if (!namematch(ai)) { 406 free(orignfsdirname); 407 return (1); 408 } 409 /* First try to unmount using the file system ID. */ 410 snprintf(fsidbuf, sizeof(fsidbuf), "FSID:%d:%d", sfs->f_fsid.val[0], 411 sfs->f_fsid.val[1]); 412 if (unmount(fsidbuf, fflag | MNT_BYFSID) != 0) { 413 /* XXX, non-root users get a zero fsid, so don't warn. */ 414 if (errno != ENOENT || sfs->f_fsid.val[0] != 0 || 415 sfs->f_fsid.val[1] != 0) 416 warn("unmount of %s failed", sfs->f_mntonname); 417 if (errno != ENOENT) { 418 free(orignfsdirname); 419 return (1); 420 } 421 /* Compatibility for old kernels. */ 422 if (sfs->f_fsid.val[0] != 0 || sfs->f_fsid.val[1] != 0) 423 warnx("retrying using path instead of file system ID"); 424 if (unmount(sfs->f_mntonname, fflag) != 0) { 425 warn("unmount of %s failed", sfs->f_mntonname); 426 free(orignfsdirname); 427 return (1); 428 } 429 } 430 /* Mark this file system as unmounted. */ 431 getmntentry(NULL, NULL, &sfs->f_fsid, REMOVE); 432 if (vflag) 433 (void)printf("%s: unmount from %s\n", sfs->f_mntfromname, 434 sfs->f_mntonname); 435 /* 436 * Report to mountd-server which nfsname 437 * has been unmounted. 438 */ 439 if (ai != NULL && !(fflag & MNT_FORCE) && do_rpc) { 440 clp = clnt_create(hostp, MOUNTPROG, MOUNTVERS3, proto_ptr); 441 if (clp == NULL) { 442 warnx("%s: %s", hostp, 443 clnt_spcreateerror("MOUNTPROG")); 444 free(orignfsdirname); 445 return (1); 446 } 447 clp->cl_auth = authsys_create_default(); 448 try.tv_sec = 20; 449 try.tv_usec = 0; 450 clnt_stat = clnt_call(clp, MOUNTPROC_UMNT, (xdrproc_t)xdr_dir, 451 nfsdirname, (xdrproc_t)xdr_void, (caddr_t)0, try); 452 if (clnt_stat != RPC_SUCCESS) { 453 warnx("%s: %s", hostp, 454 clnt_sperror(clp, "RPCMNT_UMOUNT")); 455 free(orignfsdirname); 456 return (1); 457 } 458 /* 459 * Remove the unmounted entry from /var/db/mounttab. 460 */ 461 if (read_mtab()) { 462 clean_mtab(hostp, nfsdirname, vflag); 463 if(!write_mtab(vflag)) 464 warnx("cannot remove mounttab entry %s:%s", 465 hostp, nfsdirname); 466 free_mtab(); 467 } 468 auth_destroy(clp->cl_auth); 469 clnt_destroy(clp); 470 } 471 free(orignfsdirname); 472 473 if (dflag) { 474 if (md_detach(sfs->f_mntfromname) == 0) { 475 if (vflag) 476 (void)printf("%s: detached\n", 477 sfs->f_mntfromname); 478 } else if (!all) 479 return (-1); 480 } 481 482 return (0); 483 } 484 485 struct statfs * 486 getmntentry(const char *fromname, const char *onname, fsid_t *fsid, dowhat what) 487 { 488 static struct statfs *mntbuf; 489 static size_t mntsize = 0; 490 static int *mntcheck = NULL; 491 struct statfs *sfs, *foundsfs; 492 int i, count; 493 494 if (mntsize <= 0) { 495 if ((mntsize = mntinfo(&mntbuf)) <= 0) 496 return (NULL); 497 } 498 if (mntcheck == NULL) { 499 if ((mntcheck = calloc(mntsize + 1, sizeof(int))) == NULL) 500 err(1, "calloc"); 501 } 502 /* 503 * We want to get the file systems in the reverse order 504 * that they were mounted. Unmounted file systems are marked 505 * in a table called 'mntcheck'. 506 */ 507 count = 0; 508 foundsfs = NULL; 509 for (i = mntsize - 1; i >= 0; i--) { 510 if (mntcheck[i]) 511 continue; 512 sfs = &mntbuf[i]; 513 if (fromname != NULL && strcmp(sfs->f_mntfromname, 514 fromname) != 0) 515 continue; 516 if (onname != NULL && strcmp(sfs->f_mntonname, onname) != 0) 517 continue; 518 if (fsid != NULL && fsidcmp(&sfs->f_fsid, fsid) != 0) 519 continue; 520 521 switch (what) { 522 case CHECKUNIQUE: 523 foundsfs = sfs; 524 count++; 525 continue; 526 case REMOVE: 527 mntcheck[i] = 1; 528 break; 529 default: 530 break; 531 } 532 return (sfs); 533 } 534 535 if (what == CHECKUNIQUE && count == 1) 536 return (foundsfs); 537 return (NULL); 538 } 539 540 int 541 sacmp(void *sa1, void *sa2) 542 { 543 void *p1, *p2; 544 int len; 545 546 if (((struct sockaddr *)sa1)->sa_family != 547 ((struct sockaddr *)sa2)->sa_family) 548 return (1); 549 550 switch (((struct sockaddr *)sa1)->sa_family) { 551 case AF_INET: 552 p1 = &((struct sockaddr_in *)sa1)->sin_addr; 553 p2 = &((struct sockaddr_in *)sa2)->sin_addr; 554 len = 4; 555 break; 556 case AF_INET6: 557 p1 = &((struct sockaddr_in6 *)sa1)->sin6_addr; 558 p2 = &((struct sockaddr_in6 *)sa2)->sin6_addr; 559 len = 16; 560 if (((struct sockaddr_in6 *)sa1)->sin6_scope_id != 561 ((struct sockaddr_in6 *)sa2)->sin6_scope_id) 562 return (1); 563 break; 564 default: 565 return (1); 566 } 567 568 return memcmp(p1, p2, len); 569 } 570 571 int 572 namematch(struct addrinfo *ai) 573 { 574 struct addrinfo *aip; 575 576 if (nfshost == NULL || nfshost_ai == NULL) 577 return (1); 578 579 while (ai != NULL) { 580 aip = nfshost_ai; 581 while (aip != NULL) { 582 if (sacmp(ai->ai_addr, aip->ai_addr) == 0) 583 return (1); 584 aip = aip->ai_next; 585 } 586 ai = ai->ai_next; 587 } 588 589 return (0); 590 } 591 592 struct statfs * 593 checkmntlist(char *mntname) 594 { 595 struct statfs *sfs; 596 fsid_t fsid; 597 598 sfs = NULL; 599 if (parsehexfsid(mntname, &fsid) == 0) 600 sfs = getmntentry(NULL, NULL, &fsid, FIND); 601 if (sfs == NULL) 602 sfs = getmntentry(NULL, mntname, NULL, FIND); 603 if (sfs == NULL) 604 sfs = getmntentry(mntname, NULL, NULL, FIND); 605 return (sfs); 606 } 607 608 size_t 609 mntinfo(struct statfs **mntbuf) 610 { 611 static struct statfs *origbuf; 612 size_t bufsize; 613 int mntsize; 614 615 mntsize = getfsstat(NULL, 0, MNT_NOWAIT); 616 if (mntsize <= 0) 617 return (0); 618 bufsize = (mntsize + 1) * sizeof(struct statfs); 619 if ((origbuf = malloc(bufsize)) == NULL) 620 err(1, "malloc"); 621 mntsize = getfsstat(origbuf, (long)bufsize, MNT_NOWAIT); 622 *mntbuf = origbuf; 623 return (mntsize); 624 } 625 626 /* 627 * Convert a hexadecimal filesystem ID to an fsid_t. 628 * Returns 0 on success. 629 */ 630 int 631 parsehexfsid(const char *hex, fsid_t *fsid) 632 { 633 char hexbuf[3]; 634 int i; 635 636 if (strlen(hex) != sizeof(*fsid) * 2) 637 return (-1); 638 hexbuf[2] = '\0'; 639 for (i = 0; i < (int)sizeof(*fsid); i++) { 640 hexbuf[0] = hex[i * 2]; 641 hexbuf[1] = hex[i * 2 + 1]; 642 if (!isxdigit(hexbuf[0]) || !isxdigit(hexbuf[1])) 643 return (-1); 644 ((u_char *)fsid)[i] = strtol(hexbuf, NULL, 16); 645 } 646 return (0); 647 } 648 649 /* 650 * xdr routines for mount rpc's 651 */ 652 int 653 xdr_dir(XDR *xdrsp, char *dirp) 654 { 655 656 return (xdr_string(xdrsp, &dirp, MNTPATHLEN)); 657 } 658 659 void 660 usage(void) 661 { 662 663 (void)fprintf(stderr, "%s\n%s\n", 664 "usage: umount [-dfNnv] special ... | node ... | fsid ...", 665 " umount -a | -A [-F fstab] [-dfnv] [-h host] [-t type]"); 666 exit(1); 667 } 668 669 int 670 md_detach(const char *device) 671 { 672 struct md_ioctl mdio; 673 char *eptr; 674 int fd; 675 676 if (strncmp(device, DEV_MD, sizeof(DEV_MD) - 1)) { 677 if (!all) 678 warnx("invalid md device: %s", device); 679 return (-1); 680 } 681 682 memset(&mdio, 0, sizeof(mdio)); 683 mdio.md_version = MDIOVERSION; 684 mdio.md_options = fflag ? MD_FORCE : 0; 685 mdio.md_unit = strtoul(device + sizeof(DEV_MD) - 1, &eptr, 0); 686 if (mdio.md_unit == (unsigned)ULONG_MAX || eptr - device == sizeof(DEV_MD) - 1) { 687 warnx("invalid md device: %s", device); 688 return (-1); 689 } 690 691 fd = open(DEV_MDCTL, O_RDWR, 0); 692 if (fd < 0) { 693 warn("%s", DEV_MDCTL); 694 return (-1); 695 } 696 697 if (ioctl(fd, MDIOCDETACH, &mdio) < 0) { 698 warn("%s", DEV_MD); 699 close(fd); 700 return (-1); 701 } 702 703 close(fd); 704 return (0); 705 } 706