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 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 *
31 * cfsadmin.c
32 *
33 * Cache FS admin utility.
34 */
35
36 #include <assert.h>
37 #include <locale.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 #include <string.h>
42 #include <errno.h>
43 #include <limits.h>
44 #include <dirent.h>
45 #include <ftw.h>
46 #include <fcntl.h>
47 #include <ctype.h>
48 #include <stdarg.h>
49 #include <sys/param.h>
50 #include <sys/types.h>
51 #include <sys/stat.h>
52 #include <sys/statvfs.h>
53 #include <sys/mman.h>
54 #include <sys/mnttab.h>
55 #include <sys/fs/cachefs_fs.h>
56 #include <sys/fs/cachefs_dir.h>
57 #include <sys/utsname.h>
58 #include <rpc/rpc.h>
59 #include <priv.h>
60 #include "../common/subr.h"
61 #include "../common/cachefsd.h"
62
63 char *cfsadmin_opts[] = {
64 #define COPT_MAXBLOCKS 0
65 "maxblocks",
66 #define COPT_MINBLOCKS 1
67 "minblocks",
68 #define COPT_THRESHBLOCKS 2
69 "threshblocks",
70
71 #define COPT_MAXFILES 3
72 "maxfiles",
73 #define COPT_MINFILES 4
74 "minfiles",
75 #define COPT_THRESHFILES 5
76 "threshfiles",
77
78 #define COPT_MAXFILESIZE 6
79 "maxfilesize",
80
81 #define COPT_HIBLOCKS 7
82 "hiblocks",
83 #define COPT_LOWBLOCKS 8
84 "lowblocks",
85 #define COPT_HIFILES 9
86 "hifiles",
87 #define COPT_LOWFILES 10
88 "lowfiles",
89 NULL
90 };
91
92 #define bad(val) ((val) == NULL || !isdigit(*(val)))
93
94 /* numbers must be valid percentages ranging from 0 to 100 */
95 #define badpercent(val) \
96 ((val) == NULL || !isdigit(*(val)) || \
97 atoi((val)) < 0 || atoi((val)) > 100)
98
99 /* forward references */
100 void usage(char *msg);
101 void pr_err(char *fmt, ...);
102 int cfs_get_opts(char *oarg, struct cachefs_user_values *uvp);
103 int update_cachelabel(char *dirp, char *optionp);
104 void user_values_defaults(struct cachefs_user_values *uvp);
105 int check_user_values_for_sanity(const struct cachefs_user_values *uvp);
106 int cache_stats(char *dirp);
107 int resource_file_grow(char *dirp, int oldcnt, int newcnt);
108 int resource_file_dirty(char *dirp);
109 void simulate_disconnection(char *namep, int disconnect);
110
111 /*
112 *
113 * main
114 *
115 * Description:
116 * Main routine for the cfsadmin program.
117 * Arguments:
118 * argc number of command line arguments
119 * argv command line arguments
120 * Returns:
121 * Returns 0 for failure, > 0 for an error.
122 * Preconditions:
123 */
124
125 int
126 main(int argc, char **argv)
127 {
128 int c;
129 int xx;
130 int lockid;
131
132 char *cacheid;
133 char *cachedir;
134
135 int cflag;
136 int uflag;
137 int dflag;
138 int sflag;
139 int allflag;
140 int lflag;
141 char *optionp;
142 int Cflag;
143 int Dflag;
144
145 priv_set_t *priv_needed, *priv_effective;
146
147 (void) setlocale(LC_ALL, "");
148
149 #if !defined(TEXT_DOMAIN)
150 #define TEXT_DOMAIN "SYS_TEST"
151 #endif
152 (void) textdomain(TEXT_DOMAIN);
153
154 /* set defaults for command line options */
155 cflag = 0;
156 uflag = 0;
157 dflag = 0;
158 sflag = 0;
159 allflag = 0;
160 lflag = 0;
161 optionp = NULL;
162 Cflag = 0;
163 Dflag = 0;
164
165 /* parse the command line arguments */
166 while ((c = getopt(argc, argv, "cCDuo:d:sl")) != EOF) {
167 switch (c) {
168
169 case 'c': /* create */
170 cflag = 1;
171 break;
172
173 /*
174 * -C and -D are undocumented calls used
175 * to simulate disconnection on a file system.
176 */
177 case 'C': /* connect file system */
178 Cflag = 1;
179 break;
180 case 'D': /* disconnect file system */
181 Dflag = 1;
182 break;
183
184 case 'u': /* update */
185 uflag = 1;
186 break;
187
188 case 'd': /* delete */
189 dflag = 1;
190 if (strcmp(optarg, "all") == 0)
191 allflag = 1;
192 else
193 cacheid = optarg;
194 break;
195
196 case 's': /* consistency on demand */
197 sflag = 1;
198 break;
199
200 case 'l': /* list cache ids */
201 lflag = 1;
202 break;
203
204 case 'o': /* options for update and create */
205 optionp = optarg;
206 break;
207
208 default:
209 usage(gettext("illegal option"));
210 return (1);
211 }
212 }
213
214 if ((cflag + dflag + lflag + sflag + uflag + Cflag + Dflag) == 0) {
215 usage(gettext("no options specified"));
216 return (1);
217 }
218
219 if (cflag || uflag || dflag || Cflag || Dflag)
220 priv_needed = priv_str_to_set("all", ",", NULL);
221 if ((cflag || uflag) && getuid() != 0) {
222 /* These options create files. We want them to be root owned */
223 pr_err(gettext("must be run by root"));
224 return (1);
225 }
226
227 else if (lflag)
228 priv_needed = priv_str_to_set("file_dac_search,file_dac_read",
229 ",", NULL);
230
231 else if (sflag)
232 priv_needed = priv_str_to_set("sys_config", ",", NULL);
233
234 priv_effective = priv_allocset();
235 (void) getppriv(PRIV_EFFECTIVE, priv_effective);
236 if (priv_issubset(priv_needed, priv_effective) == 0) {
237 pr_err(gettext("Not privileged."));
238 return (1);
239 }
240 priv_freeset(priv_effective);
241 priv_freeset(priv_needed);
242
243 if ((sflag + Cflag + Dflag) == 0) {
244 /* make sure cachedir is specified */
245 if (argc - 1 != optind) {
246 usage(gettext("cache directory not specified"));
247 return (1);
248 }
249 cachedir = argv[argc-1];
250 } else {
251 /* make sure at least one mount point is specified */
252 if (argc - 1 < optind) {
253 usage(gettext("mount points not specified"));
254 return (1);
255 }
256 }
257
258 /* make sure a reasonable set of flags were specified */
259 if ((cflag + uflag + dflag + sflag + lflag + Cflag + Dflag) != 1) {
260 /* flags are mutually exclusive, at least one must be set */
261 usage(gettext(
262 "exactly one of -c, -u, -d, -s, -l must be specified"));
263 return (1);
264 }
265
266 /* make sure -o specified with -c or -u */
267 if (optionp && !(cflag|uflag)) {
268 usage(gettext("-o can only be used with -c or -u"));
269 return (1);
270 }
271
272 /* if creating a cache */
273 if (cflag) {
274 struct cachefs_user_values uv;
275 struct cache_label clabel;
276
277 /* get default cache paramaters */
278 user_values_defaults(&uv);
279
280 /* parse the options if specified */
281 if (optionp) {
282 xx = cfs_get_opts(optionp, &uv);
283 if (xx)
284 return (1);
285 }
286
287 /* verify options are reasonable */
288 xx = check_user_values_for_sanity(&uv);
289 if (xx)
290 return (1);
291
292 /* lock the cache directory non-shared */
293 lockid = cachefs_dir_lock(cachedir, 0);
294 if (lockid == -1) {
295 /* quit if could not get the lock */
296 return (1);
297 }
298
299 /* create the cache */
300 xx = cachefs_create_cache(cachedir, &uv, &clabel);
301 if (xx != 0) {
302 if (xx == -2) {
303 /* remove a partially created cache dir */
304 (void) cachefs_delete_all_cache(cachedir);
305 }
306 cachefs_dir_unlock(lockid);
307 return (1);
308 }
309 cachefs_dir_unlock(lockid);
310 }
311
312 /* else if updating resource parameters */
313 else if (uflag) {
314 /* lock the cache directory non-shared */
315 lockid = cachefs_dir_lock(cachedir, 0);
316 if (lockid == -1) {
317 /* quit if could not get the lock */
318 return (1);
319 }
320
321 xx = update_cachelabel(cachedir, optionp);
322 cachefs_dir_unlock(lockid);
323 if (xx != 0) {
324 return (1);
325 }
326 }
327
328 /* else if deleting a specific cacheID (or all caches) */
329 else if (dflag) {
330 /* lock the cache directory non-shared */
331 lockid = cachefs_dir_lock(cachedir, 0);
332 if (lockid == -1) {
333 /* quit if could not get the lock */
334 return (1);
335 }
336
337 /* if the cache is in use */
338 if (cachefs_inuse(cachedir)) {
339 pr_err(gettext("Cache %s is in use and "
340 "cannot be modified."), cachedir);
341 cachefs_dir_unlock(lockid);
342 return (1);
343 }
344
345 if (allflag)
346 xx = cachefs_delete_all_cache(cachedir);
347 else {
348 /* mark resource file as dirty */
349 xx = resource_file_dirty(cachedir);
350 if (xx == 0)
351 xx = cachefs_delete_cache(cachedir, cacheid);
352 }
353 cachefs_dir_unlock(lockid);
354 if (xx != 0) {
355 return (1);
356 }
357 }
358
359 /* else if listing cache statistics */
360 else if (lflag) {
361 xx = cache_stats(cachedir);
362 if (xx != 0)
363 return (1);
364 }
365
366 /* else if issuing a check event to cached file systems */
367 else if (sflag) {
368 for (xx = optind; xx < argc; xx++) {
369 issue_cod(argv[xx]);
370 }
371 }
372
373 /* else if simulating a disconnection */
374 else if (Dflag) {
375 for (xx = optind; xx < argc; xx++) {
376 simulate_disconnection(argv[xx], 1);
377 }
378 }
379
380 /* else if connection after a simulated disconnection */
381 else if (Cflag) {
382 for (xx = optind; xx < argc; xx++) {
383 simulate_disconnection(argv[xx], 0);
384 }
385 }
386
387 /* return success */
388 return (0);
389 }
390
391
392 /*
393 *
394 * usage
395 *
396 * Description:
397 * Prints a usage message for this utility.
398 * Arguments:
399 * msgp message to include with the usage message
400 * Returns:
401 * Preconditions:
402 * precond(msgp)
403 */
404
405 void
406 usage(char *msgp)
407 {
408 fprintf(stderr, gettext("cfsadmin: %s\n"), msgp);
409 fprintf(stderr, gettext(
410 "usage: cfsadmin -[cu] [-o parameter-list] cachedir\n"));
411 fprintf(stderr, gettext(" cfsadmin -d [CacheID|all] cachedir\n"));
412 fprintf(stderr, gettext(" cfsadmin -l cachedir\n"));
413 fprintf(stderr, gettext(" cfsadmin -s [mntpnt1 ... | all]\n"));
414 }
415
416 /*
417 *
418 * pr_err
419 *
420 * Description:
421 * Prints an error message to stderr.
422 * Arguments:
423 * fmt printf style format
424 * ... arguments for fmt
425 * Returns:
426 * Preconditions:
427 * precond(fmt)
428 */
429
430 void
431 pr_err(char *fmt, ...)
432 {
433 va_list ap;
434
435 va_start(ap, fmt);
436 (void) fprintf(stderr, gettext("cfsadmin: "));
437 (void) vfprintf(stderr, fmt, ap);
438 (void) fprintf(stderr, "\n");
439 va_end(ap);
440 }
441
442 /*
443 *
444 * cfs_get_opts
445 *
446 * Description:
447 * Decodes cfs options specified with -o.
448 * Only the fields referenced by the options are modified.
449 * Arguments:
450 * oarg options from -o option
451 * uvp place to put options
452 * Returns:
453 * Returns 0 for success, -1 for an error.
454 * Preconditions:
455 * precond(oarg)
456 * precond(uvp)
457 */
458
459 int
460 cfs_get_opts(char *oarg, struct cachefs_user_values *uvp)
461 {
462 char *optstr, *opts, *val;
463 char *saveopts;
464 int badopt;
465
466 /* make a copy of the options because getsubopt modifies it */
467 optstr = opts = strdup(oarg);
468 if (opts == NULL) {
469 pr_err(gettext("no memory"));
470 return (-1);
471 }
472
473 /* process the options */
474 badopt = 0;
475 while (*opts && !badopt) {
476 saveopts = opts;
477 switch (getsubopt(&opts, cfsadmin_opts, &val)) {
478 case COPT_MAXBLOCKS:
479 if (badpercent(val))
480 badopt = 1;
481 else
482 uvp->uv_maxblocks = atoi(val);
483 break;
484 case COPT_MINBLOCKS:
485 if (badpercent(val))
486 badopt = 1;
487 else
488 uvp->uv_minblocks = atoi(val);
489 break;
490 case COPT_THRESHBLOCKS:
491 if (badpercent(val))
492 badopt = 1;
493 else
494 uvp->uv_threshblocks = atoi(val);
495 break;
496
497 case COPT_MAXFILES:
498 if (badpercent(val))
499 badopt = 1;
500 else
501 uvp->uv_maxfiles = atoi(val);
502 break;
503 case COPT_MINFILES:
504 if (badpercent(val))
505 badopt = 1;
506 else
507 uvp->uv_minfiles = atoi(val);
508 break;
509 case COPT_THRESHFILES:
510 if (badpercent(val))
511 badopt = 1;
512 else
513 uvp->uv_threshfiles = atoi(val);
514 break;
515
516 case COPT_MAXFILESIZE:
517 if (bad(val))
518 badopt = 1;
519 else
520 uvp->uv_maxfilesize = atoi(val);
521 break;
522
523 case COPT_HIBLOCKS:
524 if (badpercent(val))
525 badopt = 1;
526 else
527 uvp->uv_hiblocks = atoi(val);
528 break;
529 case COPT_LOWBLOCKS:
530 if (badpercent(val))
531 badopt = 1;
532 else
533 uvp->uv_lowblocks = atoi(val);
534 break;
535 case COPT_HIFILES:
536 if (badpercent(val))
537 badopt = 1;
538 else
539 uvp->uv_hifiles = atoi(val);
540 break;
541 case COPT_LOWFILES:
542 if (badpercent(val))
543 badopt = 1;
544 else
545 uvp->uv_lowfiles = atoi(val);
546 break;
547 default:
548 /* if a bad option argument */
549 pr_err(gettext("Invalid option %s"), saveopts);
550 return (-1);
551 }
552 }
553
554 /* if a bad value for an option, display an error message */
555 if (badopt) {
556 pr_err(gettext("invalid argument to option: \"%s\""),
557 saveopts);
558 }
559
560 /* free the duplicated option string */
561 free(optstr);
562
563 /* return the result */
564 return (badopt ? -1 : 0);
565 }
566
567 /*
568 *
569 * update_cachelabel
570 *
571 * Description:
572 * Changes the parameters of the cache_label.
573 * If optionp is NULL then the cache_label is set to
574 * default values.
575 * Arguments:
576 * dirp the name of the cache directory
577 * optionp comma delimited options
578 * Returns:
579 * Returns 0 for success and -1 for an error.
580 * Preconditions:
581 * precond(dirp)
582 */
583
584 int
585 update_cachelabel(char *dirp, char *optionp)
586 {
587 char path[CACHEFS_XMAXPATH];
588 struct cache_label clabel_new;
589 struct cache_label clabel_orig;
590 struct cachefs_user_values uv_orig, uv_new;
591 int xx;
592
593 /* if the cache is in use */
594 if (cachefs_inuse(dirp)) {
595 pr_err(gettext("Cache %s is in use and cannot be modified."),
596 dirp);
597 return (-1);
598 }
599
600 /* make sure we don't overwrite path */
601 if (strlen(dirp) > (size_t)PATH_MAX) {
602 pr_err(gettext("name of label file %s is too long."),
603 dirp);
604 return (-1);
605 }
606
607 /* construct the pathname to the cach_label file */
608 sprintf(path, "%s/%s", dirp, CACHELABEL_NAME);
609
610 /* read the current set of parameters */
611 xx = cachefs_label_file_get(path, &clabel_orig);
612 if (xx == -1) {
613 pr_err(gettext("reading %s failed"), path);
614 return (-1);
615 }
616 xx = cachefs_label_file_vcheck(path, &clabel_orig);
617 if (xx != 0) {
618 pr_err(gettext("version mismatch on %s"), path);
619 return (-1);
620 }
621
622 /* convert the cache_label to user values */
623 xx = cachefs_convert_cl2uv(&clabel_orig, &uv_orig, dirp);
624 if (xx) {
625 return (-1);
626 }
627
628 /* if options were specified */
629 if (optionp) {
630 /* start with the original values */
631 uv_new = uv_orig;
632
633 /* parse the options */
634 xx = cfs_get_opts(optionp, &uv_new);
635 if (xx) {
636 return (-1);
637 }
638
639 /* verify options are reasonable */
640 xx = check_user_values_for_sanity(&uv_new);
641 if (xx) {
642 return (-1);
643 }
644 }
645
646 /* else if options where not specified, get defaults */
647 else {
648 user_values_defaults(&uv_new);
649 }
650
651 /* convert user values to a cache_label */
652 xx = cachefs_convert_uv2cl(&uv_new, &clabel_new, dirp);
653 if (xx) {
654 return (-1);
655 }
656
657 /* do not allow the cache size to shrink */
658 if (uv_orig.uv_maxblocks > uv_new.uv_maxblocks) {
659 pr_err(gettext("Cache size cannot be reduced,"
660 " maxblocks current %d%%, requested %d%%"),
661 uv_orig.uv_maxblocks, uv_new.uv_maxblocks);
662 return (-1);
663 }
664 if (clabel_orig.cl_maxinodes > clabel_new.cl_maxinodes) {
665 pr_err(gettext("Cache size cannot be reduced,"
666 " maxfiles current %d%% requested %d%%"),
667 uv_orig.uv_maxfiles, uv_new.uv_maxfiles);
668 return (-1);
669 }
670
671 /* write back the new values */
672 xx = cachefs_label_file_put(path, &clabel_new);
673 if (xx == -1) {
674 pr_err(gettext("writing %s failed"), path);
675 return (-1);
676 }
677
678 /* put the new values in the duplicate cache label file also */
679 sprintf(path, "%s/%s.dup", dirp, CACHELABEL_NAME);
680 xx = cachefs_label_file_put(path, &clabel_new);
681 if (xx == -1) {
682 pr_err(gettext("writing %s failed"), path);
683 return (-1);
684 }
685
686 /* grow resouces file if necessary */
687 xx = 0;
688 if (clabel_orig.cl_maxinodes != clabel_new.cl_maxinodes) {
689 xx = resource_file_grow(dirp, clabel_orig.cl_maxinodes,
690 clabel_new.cl_maxinodes);
691 }
692
693 /* return status */
694 return (xx);
695 }
696
697 /*
698 *
699 * user_values_defaults
700 *
701 * Description:
702 * Sets default values in the cachefs_user_values object.
703 * Arguments:
704 * uvp cachefs_user_values object to set values for
705 * Returns:
706 * Preconditions:
707 * precond(uvp)
708 */
709
710 void
711 user_values_defaults(struct cachefs_user_values *uvp)
712 {
713 uvp->uv_maxblocks = 90;
714 uvp->uv_minblocks = 0;
715 uvp->uv_threshblocks = 85;
716 uvp->uv_maxfiles = 90;
717 uvp->uv_minfiles = 0;
718 uvp->uv_threshfiles = 85;
719 uvp->uv_maxfilesize = 3;
720 uvp->uv_hiblocks = 85;
721 uvp->uv_lowblocks = 75;
722 uvp->uv_hifiles = 85;
723 uvp->uv_lowfiles = 75;
724 }
725
726 /*
727 *
728 * check_user_values_for_sanity
729 *
730 * Description:
731 * Check the cachefs_user_values for sanity.
732 * Arguments:
733 * uvp cachefs_user_values object to check
734 * Returns:
735 * Returns 0 if okay, -1 if not.
736 * Preconditions:
737 * precond(uvp)
738 */
739
740 int
741 check_user_values_for_sanity(const struct cachefs_user_values *uvp)
742 {
743 int ret;
744
745 ret = 0;
746
747 if (uvp->uv_lowblocks >= uvp->uv_hiblocks) {
748 pr_err(gettext("lowblocks can't be >= hiblocks."));
749 ret = -1;
750 }
751 if (uvp->uv_lowfiles >= uvp->uv_hifiles) {
752 pr_err(gettext("lowfiles can't be >= hifiles."));
753 ret = -1;
754 }
755
756 /* XXX more conditions to check here? */
757
758 /* XXX make sure thresh values are between min and max values */
759
760 /* return status */
761 return (ret);
762 }
763
764 /*
765 *
766 * cache_stats
767 *
768 * Description:
769 * Show each cache in the directory, cache resource statistics,
770 * and, for each fs in the cache, the name of the fs, and the
771 * cache resource parameters.
772 * Arguments:
773 * dirp name of the cache directory
774 * Returns:
775 * Returns 0 for success, -1 for an error.
776 * Errors:
777 * Preconditions:
778 */
779
780 int
781 cache_stats(char *dirp)
782 {
783 DIR *dp;
784 struct dirent64 *dep;
785 char path[CACHEFS_XMAXPATH];
786 struct stat64 statinfo;
787 int ret;
788 int xx;
789 struct cache_label clabel;
790 struct cachefs_user_values uv;
791
792 /* make sure cache dir name is not too long */
793 if (strlen(dirp) > (size_t)PATH_MAX) {
794 pr_err(gettext("path name %s is too long."), dirp);
795 return (-1);
796 }
797
798 /* read the cache label file */
799 sprintf(path, "%s/%s", dirp, CACHELABEL_NAME);
800 xx = cachefs_label_file_get(path, &clabel);
801 if (xx == -1) {
802 pr_err(gettext("Reading %s failed."), path);
803 return (-1);
804 }
805 xx = cachefs_label_file_vcheck(path, &clabel);
806 if (xx != 0) {
807 pr_err(gettext("Version mismatch on %s."), path);
808 return (-1);
809 }
810
811 /* convert the cache_label to user values */
812 xx = cachefs_convert_cl2uv(&clabel, &uv, dirp);
813 if (xx)
814 return (-1);
815
816 /* display the parameters */
817 printf(gettext("cfsadmin: list cache FS information\n"));
818 #if 0
819 printf(gettext(" Version %3d\n"), clabel.cl_cfsversion);
820 #endif
821 printf(gettext(" maxblocks %3d%%\n"), uv.uv_maxblocks);
822 printf(gettext(" minblocks %3d%%\n"), uv.uv_minblocks);
823 printf(gettext(" threshblocks %3d%%\n"), uv.uv_threshblocks);
824 printf(gettext(" maxfiles %3d%%\n"), uv.uv_maxfiles);
825 printf(gettext(" minfiles %3d%%\n"), uv.uv_minfiles);
826 printf(gettext(" threshfiles %3d%%\n"), uv.uv_threshfiles);
827 printf(gettext(" maxfilesize %3dMB\n"), uv.uv_maxfilesize);
828
829 /* open the directory */
830 if ((dp = opendir(dirp)) == NULL) {
831 pr_err(gettext("opendir %s failed: %s"), dirp,
832 strerror(errno));
833 return (-1);
834 }
835
836 /* loop reading the contents of the directory */
837 ret = 0;
838 while ((dep = readdir64(dp)) != NULL) {
839 /* ignore . and .. */
840 if ((strcmp(dep->d_name, ".") == 0) ||
841 (strcmp(dep->d_name, "..") == 0))
842 continue;
843
844 /* stat the file */
845 sprintf(path, "%s/%s", dirp, dep->d_name);
846 xx = lstat64(path, &statinfo);
847 if (xx == -1) {
848 pr_err(gettext("lstat %s failed: %s"),
849 path, strerror(errno));
850 closedir(dp);
851 return (-1);
852 }
853
854 /* ignore anything that is not a link */
855 if (!S_ISLNK(statinfo.st_mode))
856 continue;
857
858 /* print the file system cache directory name */
859 printf(gettext(" %s\n"), dep->d_name);
860
861 /* XXX anything else */
862 }
863
864 /* XXX what about stats */
865
866 /* return status */
867 return (ret);
868 }
869
870 /*
871 *
872 * resource_file_grow
873 *
874 * Description:
875 * Grows the resource file in the specified directory
876 * to its new size.
877 * Arguments:
878 * dirp cache directory resource file is in
879 * oldcnt previous number of files in resource file
880 * newcnt new number of files in resource file
881 * Returns:
882 * Returns 0 for success, -1 for an error.
883 * Preconditions:
884 * precond(dirp)
885 * precond(oldcnt <= newcnt)
886 * precond(cache is locked exclusively)
887 * precond(cache is not in use)
888 */
889
890 int
891 resource_file_grow(char *dirp, int oldcnt, int newcnt)
892 {
893 int fd;
894 char path[CACHEFS_XMAXPATH];
895 int xx;
896 struct stat64 st;
897 static struct cachefs_rinfo rold, rnew;
898 struct cache_usage cusage, *cusagep;
899 char buf[MAXBSIZE];
900 int cnt;
901 caddr_t addrp;
902 int dirty;
903
904 /* get info about the resouce file for the various sizes */
905 cachefs_resource_size(oldcnt, &rold);
906 cachefs_resource_size(newcnt, &rnew);
907
908 /* open the resource file for writing */
909 /* this file is < 2GB */
910 sprintf(path, "%s/%s", dirp, RESOURCE_NAME);
911 fd = open(path, O_RDWR);
912 if (fd == -1) {
913 pr_err(gettext("Could not open %s: %s, run fsck"), path,
914 strerror(errno));
915 return (-1);
916 }
917
918 /* get info on the file */
919 xx = fstat64(fd, &st);
920 if (xx == -1) {
921 pr_err(gettext("Could not stat %s: %s"), path,
922 strerror(errno));
923 close(fd);
924 return (-1);
925 }
926
927 /* make sure the size is the correct */
928 if ((off_t)st.st_size != rold.r_fsize) {
929 pr_err(gettext("Resource file has wrong size %d %d, run fsck"),
930 (off_t)st.st_size, rold.r_fsize);
931 close(fd);
932 return (-1);
933 }
934
935 /* read the cache usage structure */
936 xx = read(fd, &cusage, sizeof (cusage));
937 if (xx != sizeof (cusage)) {
938 pr_err(gettext("Could not read cache_usage, %d, run fsck"),
939 xx);
940 close(fd);
941 return (-1);
942 }
943
944 /* rewind */
945 xx = lseek(fd, 0, SEEK_SET);
946 if (xx == -1) {
947 pr_err(gettext("Could not lseek %s: %s"), path,
948 strerror(errno));
949 close(fd);
950 return (-1);
951 }
952
953 /* indicate cache is dirty if necessary */
954 dirty = 1;
955 if ((cusage.cu_flags & CUSAGE_ACTIVE) == 0) {
956 dirty = 0;
957 cusage.cu_flags |= CUSAGE_ACTIVE;
958 xx = write(fd, &cusage, sizeof (cusage));
959 if (xx != sizeof (cusage)) {
960 pr_err(gettext(
961 "Could not write cache_usage, %d, run fsck"),
962 xx);
963 close(fd);
964 return (-1);
965 }
966 }
967
968 /* go to the end of the file */
969 xx = lseek(fd, 0, SEEK_END);
970 if (xx == -1) {
971 pr_err(gettext("Could not lseek %s: %s"), path,
972 strerror(errno));
973 close(fd);
974 return (-1);
975 }
976
977 /* grow the file to the new size */
978 memset(buf, 0, sizeof (buf));
979 cnt = rnew.r_fsize - rold.r_fsize;
980 assert((cnt % MAXBSIZE) == 0);
981 cnt /= MAXBSIZE;
982 while (cnt-- > 0) {
983 xx = write(fd, buf, sizeof (buf));
984 if (xx != sizeof (buf)) {
985 pr_err(gettext("Could not write file, %d, run fsck"),
986 xx);
987 close(fd);
988 return (-1);
989 }
990 }
991
992 /* mmap the file into our address space */
993 addrp = mmap(NULL, rnew.r_fsize, PROT_READ | PROT_WRITE, MAP_SHARED,
994 fd, 0);
995 if (addrp == (void *)-1) {
996 pr_err(gettext("Could not mmap file %s: %s"), path,
997 strerror(errno));
998 close(fd);
999 return (-1);
1000 }
1001
1002 /* close the file descriptor, we do not need it anymore */
1003 close(fd);
1004
1005 /* move the idents region to its new location */
1006 memmove(addrp + rnew.r_identoffset, addrp + rold.r_identoffset,
1007 rold.r_identsize);
1008
1009 /* zero out the old idents region that is now in the pointers region */
1010 memset(addrp + rold.r_identoffset, 0,
1011 rnew.r_identoffset - rold.r_identoffset);
1012
1013 /* sync the data to the file */
1014 xx = msync(addrp, rnew.r_fsize, MS_SYNC);
1015 if (xx == -1) {
1016 pr_err(gettext("Could not sync file %s: %s"), path,
1017 strerror(errno));
1018 munmap(addrp, rnew.r_fsize);
1019 return (-1);
1020 }
1021
1022 /* mark the file as clean if it was not dirty originally */
1023 if (!dirty) {
1024 cusagep = (struct cache_usage *)addrp;
1025 cusagep->cu_flags &= ~CUSAGE_ACTIVE;
1026
1027 /* sync the data to the file */
1028 xx = msync(addrp, rnew.r_fsize, MS_SYNC);
1029 if (xx == -1) {
1030 pr_err(gettext("Could not sync file %s: %s"), path,
1031 strerror(errno));
1032 munmap(addrp, rnew.r_fsize);
1033 return (-1);
1034 }
1035 }
1036
1037 /* unmap the file */
1038 munmap(addrp, rnew.r_fsize);
1039
1040 /* return success */
1041 return (0);
1042 }
1043
1044 /*
1045 *
1046 * resource_file_dirty
1047 *
1048 * Description:
1049 * Marks the resource file as dirty.
1050 * This will cause fsck to fix it up the next time it
1051 * is run.
1052 * Arguments:
1053 * dirp cache directory resource file is in
1054 * Returns:
1055 * Returns 0 for success, -1 for an error.
1056 * Preconditions:
1057 * precond(dirp)
1058 * precond(cache is locked exclusively)
1059 * precond(cache is not in use)
1060 */
1061
1062 int
1063 resource_file_dirty(char *dirp)
1064 {
1065 int fd;
1066 char path[CACHEFS_XMAXPATH];
1067 int xx;
1068 struct cache_usage cusage;
1069
1070 /* open the resource file for writing */
1071 /* this file is < 2GB */
1072 sprintf(path, "%s/%s", dirp, RESOURCE_NAME);
1073 fd = open(path, O_RDWR);
1074 if (fd == -1) {
1075 pr_err(gettext("Could not open %s: %s, run fsck"), path,
1076 strerror(errno));
1077 return (-1);
1078 }
1079
1080 /* read the cache usage structure */
1081 xx = read(fd, &cusage, sizeof (cusage));
1082 if (xx != sizeof (cusage)) {
1083 pr_err(gettext("Could not read cache_usage, %d, run fsck"),
1084 xx);
1085 close(fd);
1086 return (-1);
1087 }
1088
1089 /* rewind */
1090 xx = lseek(fd, 0, SEEK_SET);
1091 if (xx == -1) {
1092 pr_err(gettext("Could not lseek %s: %s"), path,
1093 strerror(errno));
1094 close(fd);
1095 return (-1);
1096 }
1097
1098 /* indicate cache is dirty if necessary */
1099 if ((cusage.cu_flags & CUSAGE_ACTIVE) == 0) {
1100 cusage.cu_flags |= CUSAGE_ACTIVE;
1101 xx = write(fd, &cusage, sizeof (cusage));
1102 if (xx != sizeof (cusage)) {
1103 pr_err(gettext(
1104 "Could not write cache_usage, %d, run fsck"),
1105 xx);
1106 close(fd);
1107 return (-1);
1108 }
1109 }
1110
1111 xx = close(fd);
1112 if (xx == -1) {
1113 pr_err(gettext("Could not successfully close %s: %s"), path,
1114 strerror(errno));
1115 }
1116 return (xx);
1117 }
1118
1119 /*
1120 *
1121 * issue_cod
1122 *
1123 * Description:
1124 * Executes the _FIOCOD ioctl on the specified file.
1125 * Arguments:
1126 * name filename to issue ioctl on (or "all")
1127 * Returns:
1128 * Returns 0 for success, -1 for an error.
1129 * Preconditions:
1130 * precond(dirp)
1131 */
1132
1133 int
1134 issue_cod(char *name)
1135 {
1136 int fd;
1137 int xx;
1138 int arg;
1139 char *dirp;
1140 FILE *mfp;
1141 struct mnttab mt, mtpref;
1142
1143 #ifndef MNTTYPE_CACHEFS
1144 #define MNTTYPE_CACHEFS "cachefs"
1145 #endif
1146
1147 arg = 0;
1148 if (strcmp(name, "all") == 0) {
1149 /*
1150 * if "all" was specified rather than a mount point,
1151 * we locate a cachefs mount in /etc/mnttab (any cachefs
1152 * mount will do). We issue the ioctl on this mount point,
1153 * and specify a non-zero argument to the ioctl. The non-zero
1154 * arg tells the kernel to do demandconst on all relevant
1155 * cachefs mounts
1156 */
1157 if ((mfp = fopen(MNTTAB, "r")) == NULL) {
1158 pr_err(gettext("Could not open %s."), MNTTAB);
1159 return (-1);
1160 }
1161 mtpref.mnt_special = NULL;
1162 mtpref.mnt_mountp = NULL;
1163 mtpref.mnt_mntopts = NULL;
1164 mtpref.mnt_time = NULL;
1165 mtpref.mnt_fstype = MNTTYPE_CACHEFS;
1166 if (getmntany(mfp, &mt, &mtpref) != 0) {
1167 (void) fclose(mfp);
1168 return (-1);
1169 }
1170 (void) fclose(mfp);
1171 dirp = mt.mnt_mountp;
1172 arg = 1;
1173 } else {
1174 dirp = name;
1175 }
1176
1177 /* open the file */
1178 fd = open(dirp, O_RDONLY);
1179 if (fd == -1) {
1180 pr_err(gettext("Could not open %s, %s."),
1181 dirp, strerror(errno));
1182 return (-1);
1183 }
1184
1185 /* issue the ioctl */
1186 xx = ioctl(fd, _FIOCOD, arg);
1187 if (xx) {
1188 if (errno == ENOTTY) {
1189 pr_err(gettext("%s is not a CacheFS file system"),
1190 dirp);
1191 } else if (errno == EBUSY) {
1192 if (arg == 0)
1193 /* we're quiet if "all" was specified */
1194 pr_err(gettext("CacheFS file system %s is not"
1195 " mounted demandconst."), dirp);
1196 } else {
1197 pr_err(gettext("Could not issue consistency request"
1198 " on %s\n %s."), dirp, strerror(errno));
1199 }
1200 }
1201 close(fd);
1202 return (xx);
1203 }
1204
1205 /*
1206 *
1207 * simulate_disconnection
1208 *
1209 * Description:
1210 * Sends the rpc message to the cachefsd to turn simulated
1211 * disconnection on or off
1212 * Arguments:
1213 * namep name of file system or "all"
1214 * disconnect 1 means disconnect, 0 means connect
1215 * Returns:
1216 * Preconditions:
1217 * precond(name)
1218 */
1219
1220 void
1221 simulate_disconnection(char *namep, int disconnect)
1222 {
1223 CLIENT *clnt;
1224 enum clnt_stat retval;
1225 int ret;
1226 int xx;
1227 int result;
1228 char *hostp;
1229 struct utsname info;
1230 struct cachefsd_disconnection_args args;
1231 char *msgp;
1232 struct timeval tval;
1233
1234 /* get the host name */
1235 xx = uname(&info);
1236 if (xx == -1) {
1237 pr_err(gettext("cannot get host name, errno %d"), errno);
1238 return;
1239 }
1240 hostp = info.nodename;
1241
1242 /* creat the connection to the daemon */
1243 clnt = clnt_create(hostp, CACHEFSDPROG, CACHEFSDVERS, "local");
1244 if (clnt == NULL) {
1245 pr_err(gettext("cachefsd is not running"));
1246 return;
1247 }
1248
1249 /* give it a chance to complete */
1250 tval.tv_sec = 60 * 60 * 24;
1251 tval.tv_usec = 0;
1252 clnt_control(clnt, CLSET_TIMEOUT, (char *)&tval);
1253
1254 /* perform the operation */
1255 args.cda_mntpt = namep;
1256 args.cda_disconnect = disconnect;
1257 retval = cachefsd_disconnection_1(&args, &ret, clnt);
1258 if (retval != RPC_SUCCESS) {
1259 clnt_perror(clnt, gettext("cachefsd is not responding"));
1260 clnt_destroy(clnt);
1261 return;
1262 }
1263
1264 /* check for error from daemon */
1265 if (ret != 0) {
1266 if (disconnect) {
1267 switch (ret) {
1268 default:
1269 msgp = "unknown error";
1270 break;
1271 case 1:
1272 msgp = "not mounted disconnectable";
1273 break;
1274 case 2:
1275 msgp = "already disconnected";
1276 break;
1277 case 3:
1278 msgp = "not a cached file system";
1279 break;
1280 }
1281 pr_err(gettext("Could not disconnect %s: %s"),
1282 namep, msgp);
1283 } else {
1284 switch (ret) {
1285 default:
1286 msgp = "unknown error";
1287 break;
1288 case 1:
1289 msgp = "already connected";
1290 break;
1291 case 2:
1292 msgp = "not simulated disconnection";
1293 break;
1294 case 3:
1295 msgp = "not a cached file system";
1296 break;
1297 }
1298 pr_err(gettext("Could not reconnect %s: %s"),
1299 namep, msgp);
1300 }
1301 }
1302
1303 ret = 0;
1304
1305 clnt_destroy(clnt);
1306 }