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
main(int argc,char * argv[])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
umountall(char ** typelist)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
checkname(char * mntname,char ** typelist)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
umountfs(struct statfs * sfs)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 *
getmntentry(const char * fromname,const char * onname,fsid_t * fsid,dowhat what)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
sacmp(void * sa1,void * sa2)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
namematch(struct addrinfo * ai)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 *
checkmntlist(char * mntname)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
mntinfo(struct statfs ** mntbuf)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
parsehexfsid(const char * hex,fsid_t * fsid)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
xdr_dir(XDR * xdrsp,char * dirp)653 xdr_dir(XDR *xdrsp, char *dirp)
654 {
655
656 return (xdr_string(xdrsp, &dirp, MNTPATHLEN));
657 }
658
659 void
usage(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
md_detach(const char * device)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