1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * Portions of this source code were derived from Berkeley 4.3 BSD
32 * under license from the Regents of the University of California.
33 */
34
35 #pragma ident "%Z%%M% %I% %E% SMI"
36
37 /*
38 *
39 * mount.c
40 *
41 * Cachefs mount program.
42 */
43
44 #include <locale.h>
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <strings.h>
49 #include <stdarg.h>
50 #include <unistd.h>
51 #include <limits.h>
52 #include <errno.h>
53 #include <wait.h>
54 #include <ctype.h>
55 #include <fcntl.h>
56 #include <fslib.h>
57 #include <sys/types.h>
58 #include <sys/time.h>
59 #include <sys/param.h>
60 #include <sys/stat.h>
61 #include <sys/fcntl.h>
62 #include <sys/mount.h>
63 #include <sys/mntent.h>
64 #include <sys/mnttab.h>
65 #include <sys/mntio.h>
66 #include <sys/fs/cachefs_fs.h>
67 #include <sys/utsname.h>
68 #include <rpc/rpc.h>
69 #include <kstat.h>
70 #undef MAX
71 #include <nfs/nfs.h>
72 #include <nfs/nfs_clnt.h>
73 #include <sys/mkdev.h>
74 #include "../common/subr.h"
75 #include "../common/cachefsd.h"
76
77 char *cfs_opts[] = {
78 #define CFSOPT_BACKFSTYPE 0
79 "backfstype",
80 #define CFSOPT_CACHEDIR 1
81 "cachedir",
82 #define CFSOPT_CACHEID 2
83 "cacheid",
84 #define CFSOPT_BACKPATH 3
85 "backpath",
86
87 #define CFSOPT_WRITEAROUND 4
88 "write-around",
89 #define CFSOPT_NONSHARED 5
90 "non-shared",
91
92 #define CFSOPT_DISCONNECTABLE 6
93 "disconnectable",
94 #define CFSOPT_SOFT 7
95 "soft",
96
97 #define CFSOPT_NOCONST 8
98 "noconst",
99 #define CFSOPT_CODCONST 9
100 "demandconst",
101
102 #define CFSOPT_LOCALACCESS 10
103 "local-access",
104 #define CFSOPT_LAZYMOUNT 11
105 "lazy-mount",
106
107 #define CFSOPT_RW 12
108 "rw",
109 #define CFSOPT_RO 13
110 "ro",
111 #define CFSOPT_SUID 14
112 "suid",
113 #define CFSOPT_NOSUID 15
114 "nosuid",
115 #define CFSOPT_REMOUNT 16
116 "remount",
117 #define CFSOPT_FGSIZE 17
118 "fgsize",
119 #define CFSOPT_POPSIZE 18
120 "popsize",
121 #define CFSOPT_ACREGMIN 19
122 "acregmin",
123 #define CFSOPT_ACREGMAX 20
124 "acregmax",
125 #define CFSOPT_ACDIRMIN 21
126 "acdirmin",
127 #define CFSOPT_ACDIRMAX 22
128 "acdirmax",
129 #define CFSOPT_ACTIMEO 23
130 "actimeo",
131 #define CFSOPT_SLIDE 24
132 "slide",
133 #define CFSOPT_NOSETSEC 25
134 "nosec", /* XXX should we use MNTOPT_NOTSETSEC? */
135 #define CFSOPT_LLOCK 26
136 "llock",
137 #define CFSOPT_NONOTIFY 27
138 "nonotify",
139 #define CFSOPT_SNR 28
140 "snr",
141 #define CFSOPT_NOFILL 29
142 "nofill",
143 #ifdef CFS_NFSV3_PASSTHROUGH
144 #define CFSOPT_NFSV3PASSTHROUGH 30
145 "nfsv3pass",
146 #endif /* CFS_NFSV3_PASSTHROUGH */
147 NULL
148 };
149
150 #define MNTTYPE_CFS "cachefs" /* XXX - to be added to mntent.h */
151 /* XXX - and should be cachefs */
152 #define CFS_DEF_DIR "/cache" /* XXX - should be added to cfs.h */
153
154 #define bad(val) (val == NULL || !isdigit(*val))
155
156 #define VFS_PATH "/usr/lib/fs"
157 #define ALT_PATH "/etc/fs"
158
159 /* forward references */
160 void usage(char *msgp);
161 void pr_err(char *fmt, ...);
162 int set_cfs_args(char *optionp, struct cachefs_mountargs *margsp, int *mflagp,
163 char **backfstypepp, char **reducepp, int *notifyp, int *nfsv3pass);
164 int get_mount_point(char *cachedirp, char *specp, char **pathpp);
165 int dobackmnt(struct cachefs_mountargs *margsp, char *reducep, char *specp,
166 char *backfstypep, char *mynamep, int readonly);
167 void doexec(char *fstype, char **newargv, char *myname);
168 char *get_back_fsid(char *specp);
169 char *get_cacheid(char *, char *);
170 void record_mount(char *mntp, char *specp, char *backfsp, char *backfstypep,
171 char *cachedirp, char *cacheidp, char *optionp, char *reducep);
172 int daemon_notify(char *cachedirp, char *cacheidp);
173 int pingserver(char *backmntp);
174 int check_cache(char *cachedirp);
175 uint32_t cachefs_get_back_nfsvers(char *cfs_backfs, int nomnttab);
176 int cfs_nfsv4_build_opts(char *optionp, char *cfs_nfsv4ops);
177
178 int nomnttab;
179 int quiet;
180 /*
181 *
182 * main
183 *
184 * Description:
185 * Main routine for the cachefs mount program.
186 * Arguments:
187 * argc number of command line arguments
188 * argv list of command line arguments
189 * Returns:
190 * Returns 0 for success, 1 an error was encountered.
191 * Preconditions:
192 */
193
194 int
195 main(int argc, char **argv)
196 {
197 char *myname;
198 char *optionp;
199 char *opigp;
200 int mflag;
201 int readonly;
202 struct cachefs_mountargs margs;
203 char *backfstypep;
204 char *reducep;
205 char *specp;
206 int xx;
207 int stat_loc;
208 char *newargv[20];
209 char *mntp;
210 pid_t pid;
211 int mounted;
212 int c;
213 int lockid;
214 int Oflg;
215 char *strp;
216 char servname[33];
217 int notify = 1;
218 struct stat64 statb;
219 struct mnttagdesc mtdesc;
220 char mops[MAX_MNTOPT_STR];
221 char cfs_nfsv4ops[MAX_MNTOPT_STR];
222 uint32_t nfsvers = 0;
223 uint32_t nfsvers_error = FALSE;
224 int nfsv3pass = 0;
225 (void) setlocale(LC_ALL, "");
226 #if !defined(TEXT_DOMAIN)
227 #define TEXT_DOMAIN "SYS_TEST"
228 #endif
229 (void) textdomain(TEXT_DOMAIN);
230
231 if (argv[0]) {
232 myname = strrchr(argv[0], '/');
233 if (myname)
234 myname++;
235 else
236 myname = argv[0];
237 } else {
238 myname = "path unknown";
239 }
240
241 optionp = NULL;
242 nomnttab = 0;
243 quiet = 0;
244 readonly = 0;
245 Oflg = 0;
246 cfs_nfsv4ops[0] = '\0';
247
248 /* process command line options */
249 while ((c = getopt(argc, argv, "mo:Orq")) != EOF) {
250 switch (c) {
251 case 'm': /* no entry in /etc/mnttab */
252 nomnttab = 1;
253 break;
254
255 case 'o':
256 optionp = optarg;
257 break;
258
259 case 'O':
260 Oflg++;
261 break;
262
263 case 'r': /* read only mount */
264 readonly = 1;
265 break;
266
267 case 'q':
268 quiet = 1;
269 break;
270
271 default:
272 usage("invalid option");
273 return (1);
274 }
275 }
276
277 /* if -o not specified */
278 if (optionp == NULL) {
279 usage(gettext("\"-o backfstype\" must be specified"));
280 return (1);
281 }
282
283 /* verify special device and mount point are specified */
284 if (argc - optind < 2) {
285 usage(gettext("must specify special device and mount point"));
286 return (1);
287 }
288
289 /* Store mount point and special device. */
290 specp = argv[argc - 2];
291 mntp = argv[argc - 1];
292
293 /* Initialize default mount values */
294 margs.cfs_options.opt_flags = CFS_ACCESS_BACKFS;
295 margs.cfs_options.opt_popsize = DEF_POP_SIZE;
296 margs.cfs_options.opt_fgsize = DEF_FILEGRP_SIZE;
297 margs.cfs_fsid = NULL;
298 memset(margs.cfs_cacheid, 0, sizeof (margs.cfs_cacheid));
299 margs.cfs_cachedir = CFS_DEF_DIR;
300 margs.cfs_backfs = NULL;
301 margs.cfs_acregmin = 0;
302 margs.cfs_acregmax = 0;
303 margs.cfs_acdirmin = 0;
304 margs.cfs_acdirmax = 0;
305 mflag = MS_OPTIONSTR;
306 if (nomnttab)
307 mflag |= MS_NOMNTTAB;
308 backfstypep = NULL;
309
310 /* process -o options */
311 xx = set_cfs_args(optionp, &margs, &mflag, &backfstypep, &reducep,
312 ¬ify, &nfsv3pass);
313 if (xx) {
314 return (1);
315 }
316 strcpy(mops, optionp);
317
318 /* backfstype has to be specified */
319 if (backfstypep == NULL) {
320 usage(gettext("\"-o backfstype\" must be specified"));
321 return (1);
322 }
323
324 if ((strcmp(backfstypep, "nfs") != 0) &&
325 (strcmp(backfstypep, "hsfs") != 0)) {
326 pr_err(gettext("%s as backfstype is not supported."),
327 backfstypep);
328 return (1);
329 }
330
331 /* set default write mode if not specified */
332 if ((margs.cfs_options.opt_flags &
333 (CFS_WRITE_AROUND|CFS_NONSHARED)) == 0) {
334 margs.cfs_options.opt_flags |= CFS_WRITE_AROUND;
335 if (strcmp(backfstypep, "hsfs") == 0)
336 mflag |= MS_RDONLY;
337 }
338
339 /* if read-only was specified with the -r option */
340 if (readonly) {
341 mflag |= MS_RDONLY;
342 }
343
344 /* if overlay was specified with -O option */
345 if (Oflg) {
346 mflag |= MS_OVERLAY;
347 }
348
349 /* get the fsid of the backfs and the cacheid */
350 margs.cfs_fsid = get_back_fsid(specp);
351 if (margs.cfs_fsid == NULL) {
352 pr_err(gettext("out of memory"));
353 return (1);
354 }
355
356 /*
357 * If using this cachedir to mount a file system for the first time
358 * after reboot, the ncheck for the sanity of the cachedir
359 */
360 if (first_time_ab(margs.cfs_cachedir))
361 if (check_cache(margs.cfs_cachedir))
362 return (1);
363
364 /* get the front file system cache id if necessary */
365 if (margs.cfs_cacheid[0] == '\0') {
366 char *cacheid = get_cacheid(margs.cfs_fsid, mntp);
367
368 if (cacheid == NULL) {
369 pr_err(gettext("default cacheid too long"));
370 return (1);
371 }
372
373 strcpy(margs.cfs_cacheid, cacheid);
374 }
375
376 /* lock the cache directory shared */
377 lockid = cachefs_dir_lock(margs.cfs_cachedir, 1);
378 if (lockid == -1) {
379 /* exit if could not get the lock */
380 return (1);
381 }
382
383 /* if no mount point was specified and we are not remounting */
384 mounted = 0;
385 if ((margs.cfs_backfs == NULL) &&
386 (((mflag & MS_REMOUNT) == 0) ||
387 (margs.cfs_options.opt_flags & CFS_SLIDE))) {
388 /* if a disconnectable mount */
389 xx = 0;
390 if (margs.cfs_options.opt_flags & CFS_DISCONNECTABLE) {
391 /* see if the server is alive */
392 xx = pingserver(specp);
393 }
394
395 /* attempt to mount the back file system */
396 if (xx == 0) {
397 xx = dobackmnt(&margs, reducep, specp, backfstypep,
398 myname, readonly);
399 /*
400 * nfs mount exits with a value of 32 if a timeout
401 * error occurs trying the mount.
402 */
403 if (xx && (xx != 32)) {
404 cachefs_dir_unlock(lockid);
405 rmdir(margs.cfs_backfs);
406 return (1);
407 }
408 if (xx == 0)
409 mounted = 1;
410 }
411 }
412
413 /*
414 * At this point the back file system should be mounted.
415 * Get NFS version information for the back filesystem if
416 * it is NFS. The version information is required
417 * because NFS version 4 is incompatible with cachefs
418 * and we provide pass-through support for NFS version 4
419 * with cachefs, aka the cachefs mount is installed but
420 * there is no caching. This is indicated to the kernel
421 * during the mount by setting the CFS_BACKFS_NFSV4 flag.
422 */
423 if (margs.cfs_backfs != NULL && strcmp(backfstypep, "nfs") == 0) {
424
425 nfsvers = cachefs_get_back_nfsvers(margs.cfs_backfs, nomnttab);
426 switch (nfsvers) {
427 case 2:
428 break;
429
430 case 3:
431 if (nfsv3pass) {
432 /* Force pass through (for debugging) */
433 margs.cfs_options.opt_flags = CFS_BACKFS_NFSV4;
434 if (cfs_nfsv4_build_opts(optionp,
435 cfs_nfsv4ops) != 0) {
436 nfsvers_error = TRUE;
437 goto clean_backmnt;
438 }
439 }
440 break;
441
442 case 4:
443 /*
444 * overwrite old option flags with NFSv4 flag.
445 * Note that will also operate in strict
446 * consistency mode. Clean up the option string
447 * to get rid of the cachefs-specific options
448 * to be in sync with the opt flags, otherwise
449 * these can make it into the mnttab and cause
450 * problems (esp. the disconnected option).
451 */
452 margs.cfs_options.opt_flags = CFS_BACKFS_NFSV4;
453 if (cfs_nfsv4_build_opts(optionp, cfs_nfsv4ops) != 0) {
454 nfsvers_error = TRUE;
455 goto clean_backmnt;
456 }
457 break;
458
459 default:
460 /* error, unknown version */
461 nfsvers_error = TRUE;
462 goto clean_backmnt;
463 }
464 }
465
466 /*
467 * Grab server name from special file arg if it is there or set
468 * server name to "server unknown".
469 */
470 margs.cfs_hostname = servname;
471 strncpy(servname, specp, sizeof (servname));
472 servname[sizeof (servname) - 1] = '\0';
473 strp = strchr(servname, ':');
474 if (strp == NULL) {
475 margs.cfs_hostname = "server unknown";
476 margs.cfs_backfsname = specp;
477 } else {
478 *strp = '\0';
479 /*
480 * The rest of the special file arg is the name of
481 * the back filesystem.
482 */
483 strp++;
484 margs.cfs_backfsname = strp;
485 }
486
487 /* mount the cache file system */
488 xx = mount((margs.cfs_backfs != NULL) ? margs.cfs_backfs : "nobackfs",
489 mntp, mflag | MS_DATA, MNTTYPE_CFS,
490 &margs, sizeof (margs),
491 (cfs_nfsv4ops[0] == '\0' ? mops : cfs_nfsv4ops),
492 MAX_MNTOPT_STR);
493 clean_backmnt:
494 if (xx == -1 || nfsvers_error) {
495 if (nfsvers_error) {
496 pr_err(gettext("nfs version error."));
497 } else if (errno == ESRCH) {
498 pr_err(gettext("mount failed, options do not match."));
499 } else if ((errno == EAGAIN) && (margs.cfs_backfs == NULL)) {
500 pr_err(gettext("mount failed, server not responding."));
501 } else {
502 pr_err(gettext("mount failed %s"), strerror(errno));
503 }
504
505 /* try to unmount the back file system if we mounted it */
506 if (mounted) {
507 xx = 1;
508 newargv[xx++] = "umount";
509 newargv[xx++] = margs.cfs_backfs;
510 newargv[xx++] = NULL;
511
512 /* fork */
513 if ((pid = fork()) == -1) {
514 pr_err(gettext("could not fork: %s"),
515 strerror(errno));
516 cachefs_dir_unlock(lockid);
517 return (1);
518 }
519
520 /* if the child */
521 if (pid == 0) {
522 /* do the unmount */
523 doexec(backfstypep, newargv, "umount");
524 }
525
526 /* else if the parent */
527 else {
528 wait(0);
529 }
530 rmdir(margs.cfs_backfs);
531 }
532
533 cachefs_dir_unlock(lockid);
534 return (1);
535 }
536
537 /* release the lock on the cache directory */
538 cachefs_dir_unlock(lockid);
539
540 /* record the mount information in the fscache directory */
541 record_mount(mntp, specp, margs.cfs_backfs, backfstypep,
542 margs.cfs_cachedir, margs.cfs_cacheid,
543 (cfs_nfsv4ops[0] == '\0' ? optionp : cfs_nfsv4ops), reducep);
544
545 /* notify the daemon of the mount */
546 if (notify)
547 daemon_notify(margs.cfs_cachedir, margs.cfs_cacheid);
548
549 /* update mnttab file if necessary */
550 if (!nomnttab) {
551 /*
552 * If we added the back file system, tag it with ignore,
553 * however, don't fail the mount after its done
554 * if the tag can't be added (eg., this would cause
555 * automounter problems).
556 */
557 if (mounted) {
558 FILE *mt;
559 struct extmnttab mnt;
560
561 if ((mt = fopen(MNTTAB, "r")) == NULL)
562 return (1);
563 while (getextmntent(mt, &mnt, sizeof (mnt)) != -1) {
564 if (mnt.mnt_mountp != NULL &&
565 strcmp(margs.cfs_backfs,
566 mnt.mnt_mountp) == 0) {
567 /* found it, do tag ioctl */
568 mtdesc.mtd_major = mnt.mnt_major;
569 mtdesc.mtd_minor = mnt.mnt_minor;
570 mtdesc.mtd_mntpt = margs.cfs_backfs;
571 mtdesc.mtd_tag = MNTOPT_IGNORE;
572
573 (void) ioctl(fileno(mt),
574 MNTIOC_SETTAG, &mtdesc);
575 break;
576 }
577 }
578 fclose(mt);
579 }
580 }
581
582 /* return success */
583 return (0);
584 }
585
586
587 /*
588 *
589 * usage
590 *
591 * Description:
592 * Prints a short usage message.
593 * Arguments:
594 * msgp message to include with the usage message
595 * Returns:
596 * Preconditions:
597 */
598
599 void
600 usage(char *msgp)
601 {
602 if (msgp) {
603 pr_err(gettext("%s"), msgp);
604 }
605
606 fprintf(stderr,
607 gettext("Usage: mount -F cachefs [generic options] "
608 "-o backfstype=file_system_type[FSTypespecific_options] "
609 "special mount_point\n"));
610 }
611
612 /*
613 *
614 * pr_err
615 *
616 * Description:
617 * Prints an error message to stderr.
618 * Arguments:
619 * fmt printf style format
620 * ... arguments for fmt
621 * Returns:
622 * Preconditions:
623 * precond(fmt)
624 */
625
626 void
627 pr_err(char *fmt, ...)
628 {
629 va_list ap;
630
631 va_start(ap, fmt);
632 (void) fprintf(stderr, gettext("mount -F cachefs: "));
633 (void) vfprintf(stderr, fmt, ap);
634 (void) fprintf(stderr, "\n");
635 va_end(ap);
636 }
637
638 /*
639 *
640 * set_cfs_args
641 *
642 * Description:
643 * Parse the comma delimited set of options specified by optionp
644 * and puts the results in margsp, mflagp, and backfstypepp.
645 * A string is constructed of options which are not specific to
646 * cfs and is placed in reducepp.
647 * Pointers to strings are invalid if this routine is called again.
648 * No initialization is done on margsp, mflagp, or backfstypepp.
649 * Arguments:
650 * optionp string of comma delimited options
651 * margsp option results for the mount dataptr arg
652 * mflagp option results for the mount mflag arg
653 * backfstypepp set to name of back file system type
654 * reducepp set to the option string without cfs specific options
655 * Returns:
656 * Returns 0 for success, -1 for an error.
657 * Preconditions:
658 * precond(optionp)
659 * precond(margsp)
660 * precond(mflagp)
661 * precond(backfstypepp)
662 * precond(reducepp)
663 */
664
665 int
666 set_cfs_args(char *optionp, struct cachefs_mountargs *margsp, int *mflagp,
667 char **backfstypepp, char **reducepp, int *notifyp, int *nfsv3pass)
668 {
669 static char *optstrp = NULL;
670 static char *reducep = NULL;
671 char *savep, *strp, *valp;
672 int badopt;
673 int ret;
674 int o_backpath = 0;
675 int o_writemode = 0;
676 int xx;
677 uint_t yy;
678 struct stat64 sinfo;
679 char *pbuf;
680
681 /* free up any previous options */
682 free(optstrp);
683 optstrp = NULL;
684 free(reducep);
685 reducep = NULL;
686
687 /* make a copy of the options so we can modify it */
688 optstrp = strp = strdup(optionp);
689 reducep = malloc(strlen(optionp) + 1000);
690 if ((strp == NULL) || (reducep == NULL)) {
691 pr_err(gettext("out of memory"));
692 return (-1);
693 }
694 *reducep = '\0';
695
696 /* parse the options */
697 badopt = 0;
698 ret = 0;
699 while (*strp) {
700 savep = strp;
701 switch (getsubopt(&strp, cfs_opts, &valp)) {
702
703 case CFSOPT_BACKFSTYPE:
704 if (valp == NULL)
705 badopt = 1;
706 else
707 *backfstypepp = valp;
708 break;
709
710 case CFSOPT_CACHEDIR:
711 if (valp == NULL)
712 badopt = 1;
713 else {
714 margsp->cfs_cachedir = valp;
715 if (valp[0] != '/') {
716 pbuf = (char *)malloc(MAXPATHLEN +
717 strlen(valp) + 3);
718 if (pbuf == NULL) {
719 pr_err(gettext("out of memory"));
720 badopt = 1;
721 break;
722 }
723 if (getcwd(pbuf, MAXPATHLEN+1) == NULL) {
724 pr_err(gettext("cachedir too long"));
725 badopt = 1;
726 break;
727 }
728 if (pbuf[strlen(pbuf)-1] != '/')
729 strcat(pbuf, "/");
730 strcat(pbuf, valp);
731 margsp->cfs_cachedir = pbuf;
732 }
733 }
734 break;
735
736 case CFSOPT_CACHEID:
737 if (valp == NULL) {
738 badopt = 1;
739 break;
740 }
741
742 if (strlen(valp) >= (size_t)C_MAX_MOUNT_FSCDIRNAME) {
743 pr_err(gettext("cacheid too long"));
744 badopt = 1;
745 break;
746 }
747
748 memset(margsp->cfs_cacheid, 0, C_MAX_MOUNT_FSCDIRNAME);
749 strcpy(margsp->cfs_cacheid, valp);
750 break;
751
752 case CFSOPT_BACKPATH:
753 if (valp == NULL)
754 badopt = 1;
755 else {
756 margsp->cfs_backfs = valp;
757 o_backpath = 1;
758 }
759 break;
760
761 case CFSOPT_WRITEAROUND:
762 margsp->cfs_options.opt_flags |= CFS_WRITE_AROUND;
763 o_writemode++;
764 break;
765
766 case CFSOPT_NONSHARED:
767 margsp->cfs_options.opt_flags |= CFS_NONSHARED;
768 o_writemode++;
769 break;
770
771 case CFSOPT_NOCONST:
772 margsp->cfs_options.opt_flags |= CFS_NOCONST_MODE;
773 break;
774
775 case CFSOPT_CODCONST:
776 margsp->cfs_options.opt_flags |= CFS_CODCONST_MODE;
777 break;
778
779 case CFSOPT_LOCALACCESS:
780 margsp->cfs_options.opt_flags &= ~CFS_ACCESS_BACKFS;
781 break;
782
783 case CFSOPT_NOSETSEC:
784 margsp->cfs_options.opt_flags |= CFS_NOACL;
785 break;
786
787 case CFSOPT_LLOCK:
788 margsp->cfs_options.opt_flags |= CFS_LLOCK;
789 strcat(reducep, ",");
790 strcat(reducep, savep);
791 break;
792
793 case CFSOPT_REMOUNT:
794 *mflagp |= MS_REMOUNT;
795 break;
796
797 case CFSOPT_SLIDE:
798 margsp->cfs_options.opt_flags |= CFS_SLIDE;
799 break;
800
801 case CFSOPT_FGSIZE:
802 if (bad(valp))
803 badopt = 1;
804 else
805 margsp->cfs_options.opt_fgsize = atoi(valp);
806 break;
807
808 case CFSOPT_POPSIZE:
809 if (bad(valp))
810 badopt = 1;
811 else
812 margsp->cfs_options.opt_popsize =
813 atoi(valp) * 1024;
814 break;
815
816 case CFSOPT_ACREGMIN:
817 if (bad(valp))
818 badopt = 1;
819 else
820 margsp->cfs_acregmin = atoi(valp);
821 break;
822
823 case CFSOPT_ACREGMAX:
824 if (bad(valp))
825 badopt = 1;
826 else
827 margsp->cfs_acregmax = atoi(valp);
828 break;
829
830 case CFSOPT_ACDIRMIN:
831 if (bad(valp))
832 badopt = 1;
833 else
834 margsp->cfs_acdirmin = atoi(valp);
835 break;
836
837 case CFSOPT_ACDIRMAX:
838 if (bad(valp))
839 badopt = 1;
840 else
841 margsp->cfs_acdirmax = atoi(valp);
842 break;
843
844 case CFSOPT_ACTIMEO:
845 if (bad(valp))
846 badopt = 1;
847 else {
848 yy = atoi(valp);
849 margsp->cfs_acregmin = yy;
850 margsp->cfs_acregmax = yy;
851 margsp->cfs_acdirmin = yy;
852 margsp->cfs_acdirmax = yy;
853 }
854 /*
855 * Note that we do not pass the actimeo options
856 * to the back file system. This change was
857 * made for Chart. Chart needs noac or actimeo=0
858 * so it makes no sense to pass these options on.
859 * In theory it should be okay to not pass these
860 * options on for regular cachefs mounts since
861 * cachefs perform the required attribute caching.
862 */
863 break;
864
865 #if 0
866 case CFSOPT_LAZYMOUNT:
867 margsp->cfs_options.opt_flags |= CFS_LAZYMOUNT;
868 break;
869 #endif
870
871 case CFSOPT_DISCONNECTABLE:
872 case CFSOPT_SNR:
873 margsp->cfs_options.opt_flags |= CFS_DISCONNECTABLE;
874 break;
875
876 case CFSOPT_NOFILL:
877 margsp->cfs_options.opt_flags |= CFS_NOFILL;
878 break;
879
880 case CFSOPT_SOFT:
881 margsp->cfs_options.opt_flags |= CFS_SOFT;
882 break;
883
884 case CFSOPT_NONOTIFY:
885 *notifyp = 0;
886 break;
887
888 #ifdef CFS_NFSV3_PASSTHROUGH
889 case CFSOPT_NFSV3PASSTHROUGH:
890 *nfsv3pass = 1;
891 break;
892 #endif /* CFS_NFSV3_PASSTHROUGH */
893
894 default:
895 /*
896 * unknown or vfs layer option, save for the back
897 * file system
898 */
899 strcat(reducep, ",");
900 strcat(reducep, savep);
901 break;
902 }
903
904 /* if a lexical error occurred */
905 if (badopt) {
906 pr_err(gettext("invalid argument to option: \"%s\""),
907 savep);
908 badopt = 0;
909 ret = -1;
910 }
911 }
912
913 /*
914 * Should mount backfs soft if disconnectable & non-shared options
915 * are used. NFS soft option allows reads and writes to TIMEOUT
916 * when the server is not responding, which is crucial for
917 * disconnectable option to work all the time in non-shared mode.
918 *
919 * Should mount backfs semisoft if disconnectable & write-around
920 * are used. NFS semisoft option allows reads to TIMEOUT and
921 * write to block when the server is not responding, which is
922 * good for write around option because it is shared.
923 *
924 * Since disconnectable and strict options are conflicting,
925 * when disconnectable option is used, default option is set to
926 * demandconst.
927 */
928
929 if (margsp->cfs_options.opt_flags & (CFS_DISCONNECTABLE | CFS_SOFT))
930 if (margsp->cfs_options.opt_flags & CFS_NONSHARED) {
931 strcat(reducep, ",soft,noprint");
932 margsp->cfs_options.opt_flags |= CFS_CODCONST_MODE;
933 }
934 else
935 strcat(reducep, ",semisoft,noprint");
936
937 if (!(margsp->cfs_options.opt_flags & CFS_DISCONNECTABLE)) {
938 /* not snr, no need to notify the cachefsd */
939 *notifyp = 0;
940 }
941
942 /* additional nfs options needed so disconnectable will work */
943 if (margsp->cfs_options.opt_flags & CFS_DISCONNECTABLE) {
944 /*
945 * retry=0 so cachefs can mount if nfs mount fails
946 * even with this nfs takes 3 minutes to give up
947 * actimeo=0 because NFS does not pick up new ctime after
948 * rename
949 */
950 strcat(reducep, ",retry=0");
951 if (margsp->cfs_options.opt_flags & CFS_NONSHARED)
952 strcat(reducep, ",actimeo=0");
953 }
954
955 /* check for conflicting options */
956 xx = margsp->cfs_options.opt_flags;
957 if (o_backpath & (xx & CFS_DISCONNECTABLE)) {
958 pr_err(gettext("backpath cannot be used with disconnectable"));
959 ret = -1;
960 }
961 if (margsp->cfs_acregmin > margsp->cfs_acregmax) {
962 pr_err(gettext("acregmin cannot be greater than acregmax"));
963 ret = -1;
964 }
965 if (margsp->cfs_acdirmin > margsp->cfs_acdirmax) {
966 pr_err(gettext("acdirmin cannot be greater than acdirmax"));
967 ret = -1;
968 }
969
970 xx = CFS_NOCONST_MODE | CFS_CODCONST_MODE;
971 if ((margsp->cfs_options.opt_flags & xx) == xx) {
972 pr_err(gettext("only one of noconst and demandconst"
973 " may be specified"));
974 ret = -1;
975 }
976
977 if (o_writemode > 1) {
978 pr_err(gettext(
979 "only one of write-around or non-shared"
980 " may be specified"));
981 ret = -1;
982 }
983
984 /* if an error occured */
985 if (ret)
986 return (-1);
987
988 /* if there are any options which are not mount specific */
989 if (*reducep)
990 *reducepp = reducep + 1;
991 else
992 *reducepp = NULL;
993
994 /* return success */
995 return (0);
996 }
997
998 /*
999 *
1000 * get_mount_point
1001 *
1002 * Description:
1003 * Makes a suitable mount point for the back file system.
1004 * The name of the mount point created is stored in a malloced
1005 * buffer in pathpp
1006 * Arguments:
1007 * cachedirp the name of the cache directory
1008 * specp the special name of the device for the file system
1009 * pathpp where to store the mount point
1010 * Returns:
1011 * Returns 0 for success, -1 for an error.
1012 * Preconditions:
1013 * precond(cachedirp)
1014 * precond(specp)
1015 * precond(pathpp)
1016 */
1017
1018 int
1019 get_mount_point(char *cachedirp, char *specp, char **pathpp)
1020 {
1021 char *strp;
1022 char *namep;
1023 struct stat64 stat1, stat2;
1024 int xx;
1025 int index;
1026 int max;
1027
1028 /* make a copy of the special device name */
1029 specp = strdup(specp);
1030 if (specp == NULL) {
1031 pr_err(gettext("out of memory"));
1032 return (-1);
1033 }
1034
1035 /* convert the special device name into a file name */
1036 strp = specp;
1037 while (strp = strchr(strp, '/')) {
1038 *strp = '_';
1039 }
1040
1041 /* get some space for the path name */
1042 strp = malloc(MAXPATHLEN);
1043 if (strp == NULL) {
1044 pr_err(gettext("out of memory"));
1045 return (-1);
1046 }
1047
1048 /* see if the mount directory is valid */
1049 /* backfs can contain large files */
1050 sprintf(strp, "%s/%s", cachedirp, BACKMNT_NAME);
1051 xx = stat64(strp, &stat1);
1052 if ((xx == -1) || !S_ISDIR(stat1.st_mode)) {
1053 pr_err(gettext("%s is not a valid cache."), strp);
1054 return (-1);
1055 }
1056
1057 /* find a directory name we can use */
1058 max = 10000;
1059 namep = strp + strlen(strp);
1060 for (index = 1; index < max; index++) {
1061
1062 /* construct a directory name to consider */
1063 if (index == 1)
1064 sprintf(namep, "/%s", specp);
1065 else
1066 sprintf(namep, "/%s_%d", specp, index);
1067
1068 /* try to create the directory */
1069 xx = mkdir(strp, 0755);
1070 if (xx == 0) {
1071 /* done if the create succeeded */
1072 break;
1073 }
1074 }
1075
1076 /* if the search failed */
1077 if (index >= max) {
1078 pr_err(gettext("could not create a directory"));
1079 return (-1);
1080 }
1081
1082 /* return success */
1083 *pathpp = strp;
1084 return (0);
1085 }
1086
1087
1088 int
1089 dobackmnt(struct cachefs_mountargs *margsp, char *reducep, char *specp,
1090 char *backfstypep, char *mynamep, int readonly)
1091 {
1092 int xx;
1093 pid_t pid;
1094 char *newargv[20];
1095 int stat_loc;
1096
1097 /* get a suitable mount point */
1098 xx = get_mount_point(margsp->cfs_cachedir, specp, &margsp->cfs_backfs);
1099 if (xx)
1100 return (1);
1101
1102 /* construct argument list for mounting the back file system */
1103 xx = 1;
1104 newargv[xx++] = "mount";
1105 if (readonly)
1106 newargv[xx++] = "-r";
1107 if (nomnttab)
1108 newargv[xx++] = "-m";
1109 if (quiet)
1110 newargv[xx++] = "-q";
1111 if (reducep) {
1112 newargv[xx++] = "-o";
1113 newargv[xx++] = reducep;
1114 }
1115 newargv[xx++] = specp;
1116 newargv[xx++] = margsp->cfs_backfs;
1117 newargv[xx++] = NULL;
1118
1119 /* fork */
1120 if ((pid = fork()) == -1) {
1121 pr_err(gettext("could not fork %s"), strerror(errno));
1122 return (1);
1123 }
1124
1125 /* if the child */
1126 if (pid == 0) {
1127 /* do the mount */
1128 doexec(backfstypep, newargv, mynamep);
1129 }
1130
1131 /* else if the parent */
1132 else {
1133 /* wait for the child to exit */
1134 if (wait(&stat_loc) == -1) {
1135 pr_err(gettext("wait failed %s"), strerror(errno));
1136 return (1);
1137 }
1138
1139 if (!WIFEXITED(stat_loc)) {
1140 pr_err(gettext("back mount did not exit"));
1141 return (1);
1142 }
1143
1144 xx = WEXITSTATUS(stat_loc);
1145 if (xx) {
1146 pr_err(gettext("back mount failed"));
1147 return (xx);
1148 }
1149 }
1150
1151 return (0);
1152 }
1153
1154 /*
1155 *
1156 * doexec
1157 *
1158 * Description:
1159 * Execs the specified program with the specified command line arguments.
1160 * This function never returns.
1161 * Arguments:
1162 * fstype type of file system
1163 * newargv command line arguments
1164 * progp name of program to exec
1165 * Returns:
1166 * Preconditions:
1167 * precond(fstype)
1168 * precond(newargv)
1169 */
1170
1171 void
1172 doexec(char *fstype, char *newargv[], char *progp)
1173 {
1174 char full_path[PATH_MAX];
1175 char alter_path[PATH_MAX];
1176 char *vfs_path = VFS_PATH;
1177 char *alt_path = ALT_PATH;
1178
1179 /* build the full pathname of the fstype dependent command. */
1180 sprintf(full_path, "%s/%s/%s", vfs_path, fstype, progp);
1181 sprintf(alter_path, "%s/%s/%s", alt_path, fstype, progp);
1182
1183 /* if the program exists */
1184 if (access(full_path, 0) == 0) {
1185 /* invoke the program */
1186 execv(full_path, &newargv[1]);
1187
1188 /* if wrong permissions */
1189 if (errno == EACCES) {
1190 pr_err(gettext("cannot execute %s %s"),
1191 full_path, strerror(errno));
1192 }
1193
1194 /* if it did not work and the shell might make it */
1195 if (errno == ENOEXEC) {
1196 newargv[0] = "sh";
1197 newargv[1] = full_path;
1198 execv("/sbin/sh", &newargv[0]);
1199 }
1200 }
1201
1202 /* try the alternate path */
1203 execv(alter_path, &newargv[1]);
1204
1205 /* if wrong permissions */
1206 if (errno == EACCES) {
1207 pr_err(gettext("cannot execute %s %s"),
1208 alter_path, strerror(errno));
1209 }
1210
1211 /* if it did not work and the shell might make it */
1212 if (errno == ENOEXEC) {
1213 newargv[0] = "sh";
1214 newargv[1] = alter_path;
1215 execv("/sbin/sh", &newargv[0]);
1216 }
1217
1218 pr_err(gettext("operation not applicable to FSType %s"), fstype);
1219 exit(1);
1220 }
1221
1222 /*
1223 *
1224 * get_back_fsid
1225 *
1226 * Description:
1227 * Determines a unique identifier for the back file system.
1228 * Arguments:
1229 * specp the special file of the back fs
1230 * Returns:
1231 * Returns a malloc string which is the unique identifer
1232 * or NULL on failure. NULL is only returned if malloc fails.
1233 * Preconditions:
1234 * precond(specp)
1235 */
1236
1237 char *
1238 get_back_fsid(char *specp)
1239 {
1240 return (strdup(specp));
1241 }
1242
1243 /*
1244 *
1245 * get_cacheid
1246 *
1247 * Description:
1248 * Determines an identifier for the front file system cache.
1249 * The returned string points to a static buffer which is
1250 * overwritten on each call.
1251 * The length of the returned string is < C_MAX_MOUNT_FSCDIRNAME.
1252 * Arguments:
1253 * fsidp back file system id
1254 * mntp front file system mount point
1255 * Returns:
1256 * Returns a pointer to the string identifier, or NULL if the
1257 * identifier was overflowed.
1258 * Preconditions:
1259 * precond(fsidp)
1260 * precond(mntp)
1261 */
1262
1263 char *
1264 get_cacheid(char *fsidp, char *mntp)
1265 {
1266 char *c1;
1267 static char buf[PATH_MAX];
1268 char mnt_copy[PATH_MAX];
1269
1270 /* strip off trailing space in mountpoint -- autofs fallout */
1271 if (strlen(mntp) >= sizeof (mnt_copy))
1272 return (NULL);
1273 (void) strcpy(mnt_copy, mntp);
1274 c1 = mnt_copy + strlen(mnt_copy) - 1;
1275 if (*c1 == ' ')
1276 *c1 = '\0';
1277
1278 if ((strlen(fsidp) + strlen(mnt_copy) + 2) >=
1279 (size_t)C_MAX_MOUNT_FSCDIRNAME)
1280 return (NULL);
1281
1282 strcpy(buf, fsidp);
1283 strcat(buf, ":");
1284 strcat(buf, mnt_copy);
1285 c1 = buf;
1286 while ((c1 = strpbrk(c1, "/")) != NULL)
1287 *c1 = '_';
1288 return (buf);
1289 }
1290
1291
1292 /*
1293 *
1294 * check_cache
1295 *
1296 * Description:
1297 * Checks the cache we are about to use.
1298 * Arguments:
1299 * cachedirp cachedirectory to check
1300 * Returns:
1301 * Returns 0 for success, -1 for an error.
1302 * Preconditions:
1303 */
1304 int
1305 check_cache(cachedirp)
1306 char *cachedirp;
1307 {
1308 char *fsck_argv[4];
1309 int status = 0;
1310 pid_t pid;
1311
1312 fsck_argv[1] = "fsck";
1313 fsck_argv[2] = cachedirp;
1314 fsck_argv[3] = NULL;
1315
1316 /* fork */
1317 if ((pid = fork()) == -1) {
1318 pr_err(gettext("could not fork %s"),
1319 strerror(errno));
1320 return (1);
1321 }
1322
1323 if (pid == 0) {
1324 /* do the fsck */
1325 doexec("cachefs", fsck_argv, "fsck");
1326 } else {
1327 /* wait for the child to exit */
1328 if (wait(&status) == -1) {
1329 pr_err(gettext("wait failed %s"),
1330 strerror(errno));
1331 return (1);
1332 }
1333
1334 if (!WIFEXITED(status)) {
1335 pr_err(gettext("cache fsck did not exit"));
1336 return (1);
1337 }
1338
1339 if (WEXITSTATUS(status) != 0) {
1340 pr_err(gettext("cache fsck mount failed"));
1341 return (1);
1342 }
1343 }
1344 return (0);
1345 }
1346
1347 /*
1348 *
1349 * record_mount
1350 *
1351 * Description:
1352 * Records mount information in a file in the fscache directory.
1353 * Arguments:
1354 * Returns:
1355 * Preconditions:
1356 */
1357
1358 void
1359 record_mount(char *mntp, char *specp, char *backfsp, char *backfstypep,
1360 char *cachedirp, char *cacheidp, char *optionp, char *reducep)
1361 {
1362 char buf[MAXPATHLEN*2];
1363 FILE *fout;
1364 time_t tval;
1365
1366 tval = time(NULL);
1367
1368 /* this file is < 2GB */
1369 sprintf(buf, "%s/%s/%s", cachedirp, cacheidp, CACHEFS_MNT_FILE);
1370 fout = fopen(buf, "w");
1371 if (fout == NULL) {
1372 pr_err(gettext("could not open %s, %d"), buf, errno);
1373 return;
1374 }
1375
1376 fprintf(fout, "cachedir: %s\n", cachedirp);
1377 fprintf(fout, "mnt_point: %s\n", mntp);
1378 if (specp) {
1379 fprintf(fout, "special: %s\n", specp);
1380 }
1381 if (backfsp)
1382 fprintf(fout, "backpath: %s\n", backfsp);
1383 fprintf(fout, "backfstype: %s\n", backfstypep);
1384 fprintf(fout, "cacheid: %s\n", cacheidp);
1385 fprintf(fout, "cachefs_options: %s\n", optionp);
1386 if (reducep)
1387 fprintf(fout, "backfs_options: %s\n", reducep);
1388 fprintf(fout, "mount_time: %u\n", tval);
1389
1390 fclose(fout);
1391 }
1392
1393 int
1394 daemon_notify(char *cachedirp, char *cacheidp)
1395 {
1396 CLIENT *clnt;
1397 enum clnt_stat retval;
1398 int ret;
1399 int xx;
1400 int result;
1401 char *hostp;
1402 struct utsname info;
1403 struct cachefsd_fs_mounted args;
1404
1405 /* get the host name */
1406 xx = uname(&info);
1407 if (xx == -1) {
1408 pr_err(gettext("cannot get host name, errno %d"), errno);
1409 return (1);
1410 }
1411 hostp = info.nodename;
1412
1413 /* creat the connection to the daemon */
1414 clnt = clnt_create(hostp, CACHEFSDPROG, CACHEFSDVERS, "local");
1415 if (clnt == NULL) {
1416 pr_err(gettext("cachefsd is not running"));
1417 return (1);
1418 }
1419
1420 args.mt_cachedir = cachedirp;
1421 args.mt_cacheid = cacheidp;
1422 retval = cachefsd_fs_mounted_1(&args, NULL, clnt);
1423 if (retval != RPC_SUCCESS) {
1424 clnt_perror(clnt, gettext("cachefsd is not responding"));
1425 clnt_destroy(clnt);
1426 return (1);
1427 }
1428
1429 ret = 0;
1430
1431 clnt_destroy(clnt);
1432
1433 return (ret);
1434 }
1435
1436 /* returns 0 if the server is alive, -1 if an error */
1437 int
1438 pingserver(char *backmntp)
1439 {
1440 CLIENT *clnt;
1441 static struct timeval TIMEOUT = { 25, 0 };
1442 enum clnt_stat retval;
1443 int ret;
1444 int xx;
1445 char *hostp;
1446 char buf[MAXPATHLEN];
1447 char *pc;
1448
1449 /* get the host name */
1450 strcpy(buf, backmntp);
1451 pc = strchr(buf, ':');
1452 if (pc == NULL) {
1453 /* no host name, pretend it works */
1454 return (0);
1455 }
1456 *pc = '\0';
1457 hostp = buf;
1458
1459 /* create the connection to the mount daemon */
1460 clnt = clnt_create(hostp, NFS_PROGRAM, NFS_VERSION, "udp");
1461 if (clnt == NULL) {
1462 return (-1);
1463 }
1464
1465 ret = 0;
1466
1467 /* see if the mountd responds */
1468 retval = clnt_call(clnt, 0, xdr_void, NULL, xdr_void, NULL,
1469 TIMEOUT);
1470 if (retval != RPC_SUCCESS) {
1471 ret = -1;
1472 }
1473
1474 clnt_destroy(clnt);
1475
1476 return (ret);
1477 }
1478
1479 /*
1480 * first_time_ab : first time after boot - returns non-zero value
1481 * if the cachedir is being used for the first time
1482 * after the system reboot, otherwise zero.
1483 */
1484 int
1485 first_time_ab(char *buf)
1486 {
1487 struct stat sinfo;
1488 char name[MAXPATHLEN];
1489 int ufd;
1490 time32_t btime;
1491
1492 sprintf(name, "%s/%s", buf, CACHEFS_UNMNT_FILE);
1493 if (stat(name, &sinfo) != 0)
1494 return (1);
1495 if (sinfo.st_size == 0)
1496 return (1);
1497 if ((ufd = open(name, O_RDONLY)) == -1)
1498 return (1);
1499 if (read(ufd, &btime, sizeof (time32_t)) == -1)
1500 return (1);
1501 close(ufd);
1502 if (get_boottime() != btime)
1503 return (1);
1504 return (0);
1505 }
1506
1507 /*
1508 * cachefs_get_back_nfsvers
1509 *
1510 * Returns: nfs version
1511 *
1512 * Params:
1513 * cfs_backfs - backfile system mountpoint
1514 * nomnttab - mnttab entry does not exist
1515 *
1516 * Uses the kstat interface to extract the nfs version for
1517 * the mount.
1518 */
1519 uint32_t
1520 cachefs_get_back_nfsvers(char *cfs_backfs, int nomnttab)
1521 {
1522 kstat_ctl_t *kc = NULL;
1523 FILE *mnttab = NULL;
1524 struct extmnttab mnt;
1525 kstat_t *ksp;
1526 dev_t my_fsid = NODEV;
1527 struct mntinfo_kstat mik;
1528 uint32_t nfsvers = 0;
1529 struct stat64 st;
1530
1531 /*
1532 * Initialize kernel statistics facility.
1533 */
1534 if ((kc = kstat_open()) == NULL) {
1535 pr_err(gettext("kstat_open() can't open /dev/kstat: %s"),
1536 strerror(errno));
1537 goto end;
1538 }
1539
1540 /*
1541 * Locate the mount information in the mnttab if the nomnttab
1542 * flag is not set, otherwise look for the entry by doing
1543 * stat'ting the mountpoint.
1544 */
1545 if (!nomnttab) {
1546 if ((mnttab = fopen(MNTTAB, "r")) == NULL) {
1547 pr_err(gettext("can't open /etc/mnttab: %s"),
1548 strerror(errno));
1549 goto end;
1550 }
1551
1552 while (getextmntent(mnttab, &mnt, sizeof (mnt)) != -1) {
1553 if (mnt.mnt_mountp == NULL ||
1554 strcmp(cfs_backfs, mnt.mnt_mountp) != 0) {
1555 continue;
1556 }
1557 my_fsid = makedev(mnt.mnt_major, mnt.mnt_minor);
1558 break;
1559 }
1560 }
1561
1562 if (my_fsid == NODEV) {
1563 if (stat64(cfs_backfs, &st) == -1) {
1564 pr_err(gettext("can't stat mountpoint: %s"),
1565 strerror(errno));
1566 goto end;
1567 } else {
1568 my_fsid = st.st_dev;
1569 }
1570
1571 }
1572
1573 /*
1574 * Walk the kstat control structures to locate the
1575 * structure that describes the nfs module/mntinfo
1576 * statistics for the mounted backfilesystem.
1577 */
1578 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
1579
1580 if (ksp->ks_type != KSTAT_TYPE_RAW)
1581 continue;
1582 if (strcmp(ksp->ks_module, "nfs") != 0)
1583 continue;
1584 if (strcmp(ksp->ks_name, "mntinfo") != 0)
1585 continue;
1586 if ((my_fsid & MAXMIN) != ksp->ks_instance)
1587 continue;
1588
1589 /*
1590 * At this point we have located the
1591 * kstat info for the mount, read the
1592 * statistics and return version info.
1593 */
1594 if (kstat_read(kc, ksp, &mik) == -1) {
1595 pr_err(gettext("kstat_read() can't read %s/%s: %s"),
1596 ksp->ks_module, ksp->ks_name, strerror(errno));
1597 goto end;
1598 }
1599
1600 nfsvers = mik.mik_vers;
1601 break;
1602 }
1603
1604 end:
1605 if (kc)
1606 kstat_close(kc);
1607 if (mnttab)
1608 fclose(mnttab);
1609
1610 return (nfsvers);
1611 }
1612
1613 /*
1614 * cfs_nfsv4_build_opts
1615 *
1616 * Returns: 0 on success, -1 on failure
1617 *
1618 * Params:
1619 * optionp - original option pointer
1620 * cfs_nfsv4ops - modified options for nfsv4 cachefs mount
1621 *
1622 * Parse the comma delimited set of options specified by optionp
1623 * and clean out options that we don't want to use with NFSv4.
1624 */
1625 int
1626 cfs_nfsv4_build_opts(char *optionp, char *cfs_nfsv4ops)
1627 {
1628 char *optstrp;
1629 char *strp;
1630 char *savep;
1631 char *valp;
1632 uint32_t first = TRUE;
1633
1634 /* Make a copy of the options so we can modify it */
1635 optstrp = strp = strdup(optionp);
1636 if (strp == NULL) {
1637 pr_err(gettext("out of memory"));
1638 return (-1);
1639 }
1640
1641 /* Parse the options, cfs_nfsv4ops is initialized in main */
1642 while (*strp) {
1643 savep = strp;
1644 switch (getsubopt(&strp, cfs_opts, &valp)) {
1645
1646 /* Ignore options that set cfs option flags */
1647 case CFSOPT_WRITEAROUND:
1648 case CFSOPT_NONSHARED:
1649 case CFSOPT_NOCONST:
1650 case CFSOPT_CODCONST:
1651 case CFSOPT_LOCALACCESS:
1652 case CFSOPT_NOSETSEC:
1653 case CFSOPT_LLOCK:
1654 case CFSOPT_SLIDE:
1655 case CFSOPT_DISCONNECTABLE:
1656 case CFSOPT_SNR:
1657 case CFSOPT_NOFILL:
1658 case CFSOPT_SOFT:
1659 break;
1660
1661 default:
1662 /*
1663 * Copy in option for cachefs nfsv4 mount.
1664 */
1665 snprintf(cfs_nfsv4ops, MAX_MNTOPT_STR,
1666 "%s%s%s", cfs_nfsv4ops, first ? "" : ",",
1667 savep);
1668 first = FALSE;
1669 break;
1670 }
1671 }
1672 free(optstrp);
1673
1674 return (0);
1675 }