OpenSolaris_b135/cmd/fs.d/cachefs/cfsadmin/cfsadmin.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
*
* cfsadmin.c
*
* Cache FS admin utility.
*/
#include <assert.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <dirent.h>
#include <ftw.h>
#include <fcntl.h>
#include <ctype.h>
#include <stdarg.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/mman.h>
#include <sys/mnttab.h>
#include <sys/fs/cachefs_fs.h>
#include <sys/fs/cachefs_dir.h>
#include <sys/utsname.h>
#include <rpc/rpc.h>
#include <priv.h>
#include "../common/subr.h"
#include "../common/cachefsd.h"
char *cfsadmin_opts[] = {
#define COPT_MAXBLOCKS 0
"maxblocks",
#define COPT_MINBLOCKS 1
"minblocks",
#define COPT_THRESHBLOCKS 2
"threshblocks",
#define COPT_MAXFILES 3
"maxfiles",
#define COPT_MINFILES 4
"minfiles",
#define COPT_THRESHFILES 5
"threshfiles",
#define COPT_MAXFILESIZE 6
"maxfilesize",
#define COPT_HIBLOCKS 7
"hiblocks",
#define COPT_LOWBLOCKS 8
"lowblocks",
#define COPT_HIFILES 9
"hifiles",
#define COPT_LOWFILES 10
"lowfiles",
NULL
};
#define bad(val) ((val) == NULL || !isdigit(*(val)))
/* numbers must be valid percentages ranging from 0 to 100 */
#define badpercent(val) \
((val) == NULL || !isdigit(*(val)) || \
atoi((val)) < 0 || atoi((val)) > 100)
/* forward references */
void usage(char *msg);
void pr_err(char *fmt, ...);
int cfs_get_opts(char *oarg, struct cachefs_user_values *uvp);
int update_cachelabel(char *dirp, char *optionp);
void user_values_defaults(struct cachefs_user_values *uvp);
int check_user_values_for_sanity(const struct cachefs_user_values *uvp);
int cache_stats(char *dirp);
int resource_file_grow(char *dirp, int oldcnt, int newcnt);
int resource_file_dirty(char *dirp);
void simulate_disconnection(char *namep, int disconnect);
/*
*
* main
*
* Description:
* Main routine for the cfsadmin program.
* Arguments:
* argc number of command line arguments
* argv command line arguments
* Returns:
* Returns 0 for failure, > 0 for an error.
* Preconditions:
*/
int
main(int argc, char **argv)
{
int c;
int xx;
int lockid;
char *cacheid;
char *cachedir;
int cflag;
int uflag;
int dflag;
int sflag;
int allflag;
int lflag;
char *optionp;
int Cflag;
int Dflag;
priv_set_t *priv_needed, *priv_effective;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
/* set defaults for command line options */
cflag = 0;
uflag = 0;
dflag = 0;
sflag = 0;
allflag = 0;
lflag = 0;
optionp = NULL;
Cflag = 0;
Dflag = 0;
/* parse the command line arguments */
while ((c = getopt(argc, argv, "cCDuo:d:sl")) != EOF) {
switch (c) {
case 'c': /* create */
cflag = 1;
break;
/*
* -C and -D are undocumented calls used
* to simulate disconnection on a file system.
*/
case 'C': /* connect file system */
Cflag = 1;
break;
case 'D': /* disconnect file system */
Dflag = 1;
break;
case 'u': /* update */
uflag = 1;
break;
case 'd': /* delete */
dflag = 1;
if (strcmp(optarg, "all") == 0)
allflag = 1;
else
cacheid = optarg;
break;
case 's': /* consistency on demand */
sflag = 1;
break;
case 'l': /* list cache ids */
lflag = 1;
break;
case 'o': /* options for update and create */
optionp = optarg;
break;
default:
usage(gettext("illegal option"));
return (1);
}
}
if ((cflag + dflag + lflag + sflag + uflag + Cflag + Dflag) == 0) {
usage(gettext("no options specified"));
return (1);
}
if (cflag || uflag || dflag || Cflag || Dflag)
priv_needed = priv_str_to_set("all", ",", NULL);
if ((cflag || uflag) && getuid() != 0) {
/* These options create files. We want them to be root owned */
pr_err(gettext("must be run by root"));
return (1);
}
else if (lflag)
priv_needed = priv_str_to_set("file_dac_search,file_dac_read",
",", NULL);
else if (sflag)
priv_needed = priv_str_to_set("sys_config", ",", NULL);
priv_effective = priv_allocset();
(void) getppriv(PRIV_EFFECTIVE, priv_effective);
if (priv_issubset(priv_needed, priv_effective) == 0) {
pr_err(gettext("Not privileged."));
return (1);
}
priv_freeset(priv_effective);
priv_freeset(priv_needed);
if ((sflag + Cflag + Dflag) == 0) {
/* make sure cachedir is specified */
if (argc - 1 != optind) {
usage(gettext("cache directory not specified"));
return (1);
}
cachedir = argv[argc-1];
} else {
/* make sure at least one mount point is specified */
if (argc - 1 < optind) {
usage(gettext("mount points not specified"));
return (1);
}
}
/* make sure a reasonable set of flags were specified */
if ((cflag + uflag + dflag + sflag + lflag + Cflag + Dflag) != 1) {
/* flags are mutually exclusive, at least one must be set */
usage(gettext(
"exactly one of -c, -u, -d, -s, -l must be specified"));
return (1);
}
/* make sure -o specified with -c or -u */
if (optionp && !(cflag|uflag)) {
usage(gettext("-o can only be used with -c or -u"));
return (1);
}
/* if creating a cache */
if (cflag) {
struct cachefs_user_values uv;
struct cache_label clabel;
/* get default cache paramaters */
user_values_defaults(&uv);
/* parse the options if specified */
if (optionp) {
xx = cfs_get_opts(optionp, &uv);
if (xx)
return (1);
}
/* verify options are reasonable */
xx = check_user_values_for_sanity(&uv);
if (xx)
return (1);
/* lock the cache directory non-shared */
lockid = cachefs_dir_lock(cachedir, 0);
if (lockid == -1) {
/* quit if could not get the lock */
return (1);
}
/* create the cache */
xx = cachefs_create_cache(cachedir, &uv, &clabel);
if (xx != 0) {
if (xx == -2) {
/* remove a partially created cache dir */
(void) cachefs_delete_all_cache(cachedir);
}
cachefs_dir_unlock(lockid);
return (1);
}
cachefs_dir_unlock(lockid);
}
/* else if updating resource parameters */
else if (uflag) {
/* lock the cache directory non-shared */
lockid = cachefs_dir_lock(cachedir, 0);
if (lockid == -1) {
/* quit if could not get the lock */
return (1);
}
xx = update_cachelabel(cachedir, optionp);
cachefs_dir_unlock(lockid);
if (xx != 0) {
return (1);
}
}
/* else if deleting a specific cacheID (or all caches) */
else if (dflag) {
/* lock the cache directory non-shared */
lockid = cachefs_dir_lock(cachedir, 0);
if (lockid == -1) {
/* quit if could not get the lock */
return (1);
}
/* if the cache is in use */
if (cachefs_inuse(cachedir)) {
pr_err(gettext("Cache %s is in use and "
"cannot be modified."), cachedir);
cachefs_dir_unlock(lockid);
return (1);
}
if (allflag)
xx = cachefs_delete_all_cache(cachedir);
else {
/* mark resource file as dirty */
xx = resource_file_dirty(cachedir);
if (xx == 0)
xx = cachefs_delete_cache(cachedir, cacheid);
}
cachefs_dir_unlock(lockid);
if (xx != 0) {
return (1);
}
}
/* else if listing cache statistics */
else if (lflag) {
xx = cache_stats(cachedir);
if (xx != 0)
return (1);
}
/* else if issuing a check event to cached file systems */
else if (sflag) {
for (xx = optind; xx < argc; xx++) {
issue_cod(argv[xx]);
}
}
/* else if simulating a disconnection */
else if (Dflag) {
for (xx = optind; xx < argc; xx++) {
simulate_disconnection(argv[xx], 1);
}
}
/* else if connection after a simulated disconnection */
else if (Cflag) {
for (xx = optind; xx < argc; xx++) {
simulate_disconnection(argv[xx], 0);
}
}
/* return success */
return (0);
}
/*
*
* usage
*
* Description:
* Prints a usage message for this utility.
* Arguments:
* msgp message to include with the usage message
* Returns:
* Preconditions:
* precond(msgp)
*/
void
usage(char *msgp)
{
fprintf(stderr, gettext("cfsadmin: %s\n"), msgp);
fprintf(stderr, gettext(
"usage: cfsadmin -[cu] [-o parameter-list] cachedir\n"));
fprintf(stderr, gettext(" cfsadmin -d [CacheID|all] cachedir\n"));
fprintf(stderr, gettext(" cfsadmin -l cachedir\n"));
fprintf(stderr, gettext(" cfsadmin -s [mntpnt1 ... | all]\n"));
}
/*
*
* pr_err
*
* Description:
* Prints an error message to stderr.
* Arguments:
* fmt printf style format
* ... arguments for fmt
* Returns:
* Preconditions:
* precond(fmt)
*/
void
pr_err(char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
(void) fprintf(stderr, gettext("cfsadmin: "));
(void) vfprintf(stderr, fmt, ap);
(void) fprintf(stderr, "\n");
va_end(ap);
}
/*
*
* cfs_get_opts
*
* Description:
* Decodes cfs options specified with -o.
* Only the fields referenced by the options are modified.
* Arguments:
* oarg options from -o option
* uvp place to put options
* Returns:
* Returns 0 for success, -1 for an error.
* Preconditions:
* precond(oarg)
* precond(uvp)
*/
int
cfs_get_opts(char *oarg, struct cachefs_user_values *uvp)
{
char *optstr, *opts, *val;
char *saveopts;
int badopt;
/* make a copy of the options because getsubopt modifies it */
optstr = opts = strdup(oarg);
if (opts == NULL) {
pr_err(gettext("no memory"));
return (-1);
}
/* process the options */
badopt = 0;
while (*opts && !badopt) {
saveopts = opts;
switch (getsubopt(&opts, cfsadmin_opts, &val)) {
case COPT_MAXBLOCKS:
if (badpercent(val))
badopt = 1;
else
uvp->uv_maxblocks = atoi(val);
break;
case COPT_MINBLOCKS:
if (badpercent(val))
badopt = 1;
else
uvp->uv_minblocks = atoi(val);
break;
case COPT_THRESHBLOCKS:
if (badpercent(val))
badopt = 1;
else
uvp->uv_threshblocks = atoi(val);
break;
case COPT_MAXFILES:
if (badpercent(val))
badopt = 1;
else
uvp->uv_maxfiles = atoi(val);
break;
case COPT_MINFILES:
if (badpercent(val))
badopt = 1;
else
uvp->uv_minfiles = atoi(val);
break;
case COPT_THRESHFILES:
if (badpercent(val))
badopt = 1;
else
uvp->uv_threshfiles = atoi(val);
break;
case COPT_MAXFILESIZE:
if (bad(val))
badopt = 1;
else
uvp->uv_maxfilesize = atoi(val);
break;
case COPT_HIBLOCKS:
if (badpercent(val))
badopt = 1;
else
uvp->uv_hiblocks = atoi(val);
break;
case COPT_LOWBLOCKS:
if (badpercent(val))
badopt = 1;
else
uvp->uv_lowblocks = atoi(val);
break;
case COPT_HIFILES:
if (badpercent(val))
badopt = 1;
else
uvp->uv_hifiles = atoi(val);
break;
case COPT_LOWFILES:
if (badpercent(val))
badopt = 1;
else
uvp->uv_lowfiles = atoi(val);
break;
default:
/* if a bad option argument */
pr_err(gettext("Invalid option %s"), saveopts);
return (-1);
}
}
/* if a bad value for an option, display an error message */
if (badopt) {
pr_err(gettext("invalid argument to option: \"%s\""),
saveopts);
}
/* free the duplicated option string */
free(optstr);
/* return the result */
return (badopt ? -1 : 0);
}
/*
*
* update_cachelabel
*
* Description:
* Changes the parameters of the cache_label.
* If optionp is NULL then the cache_label is set to
* default values.
* Arguments:
* dirp the name of the cache directory
* optionp comma delimited options
* Returns:
* Returns 0 for success and -1 for an error.
* Preconditions:
* precond(dirp)
*/
int
update_cachelabel(char *dirp, char *optionp)
{
char path[CACHEFS_XMAXPATH];
struct cache_label clabel_new;
struct cache_label clabel_orig;
struct cachefs_user_values uv_orig, uv_new;
int xx;
/* if the cache is in use */
if (cachefs_inuse(dirp)) {
pr_err(gettext("Cache %s is in use and cannot be modified."),
dirp);
return (-1);
}
/* make sure we don't overwrite path */
if (strlen(dirp) > (size_t)PATH_MAX) {
pr_err(gettext("name of label file %s is too long."),
dirp);
return (-1);
}
/* construct the pathname to the cach_label file */
sprintf(path, "%s/%s", dirp, CACHELABEL_NAME);
/* read the current set of parameters */
xx = cachefs_label_file_get(path, &clabel_orig);
if (xx == -1) {
pr_err(gettext("reading %s failed"), path);
return (-1);
}
xx = cachefs_label_file_vcheck(path, &clabel_orig);
if (xx != 0) {
pr_err(gettext("version mismatch on %s"), path);
return (-1);
}
/* convert the cache_label to user values */
xx = cachefs_convert_cl2uv(&clabel_orig, &uv_orig, dirp);
if (xx) {
return (-1);
}
/* if options were specified */
if (optionp) {
/* start with the original values */
uv_new = uv_orig;
/* parse the options */
xx = cfs_get_opts(optionp, &uv_new);
if (xx) {
return (-1);
}
/* verify options are reasonable */
xx = check_user_values_for_sanity(&uv_new);
if (xx) {
return (-1);
}
}
/* else if options where not specified, get defaults */
else {
user_values_defaults(&uv_new);
}
/* convert user values to a cache_label */
xx = cachefs_convert_uv2cl(&uv_new, &clabel_new, dirp);
if (xx) {
return (-1);
}
/* do not allow the cache size to shrink */
if (uv_orig.uv_maxblocks > uv_new.uv_maxblocks) {
pr_err(gettext("Cache size cannot be reduced,"
" maxblocks current %d%%, requested %d%%"),
uv_orig.uv_maxblocks, uv_new.uv_maxblocks);
return (-1);
}
if (clabel_orig.cl_maxinodes > clabel_new.cl_maxinodes) {
pr_err(gettext("Cache size cannot be reduced,"
" maxfiles current %d%% requested %d%%"),
uv_orig.uv_maxfiles, uv_new.uv_maxfiles);
return (-1);
}
/* write back the new values */
xx = cachefs_label_file_put(path, &clabel_new);
if (xx == -1) {
pr_err(gettext("writing %s failed"), path);
return (-1);
}
/* put the new values in the duplicate cache label file also */
sprintf(path, "%s/%s.dup", dirp, CACHELABEL_NAME);
xx = cachefs_label_file_put(path, &clabel_new);
if (xx == -1) {
pr_err(gettext("writing %s failed"), path);
return (-1);
}
/* grow resouces file if necessary */
xx = 0;
if (clabel_orig.cl_maxinodes != clabel_new.cl_maxinodes) {
xx = resource_file_grow(dirp, clabel_orig.cl_maxinodes,
clabel_new.cl_maxinodes);
}
/* return status */
return (xx);
}
/*
*
* user_values_defaults
*
* Description:
* Sets default values in the cachefs_user_values object.
* Arguments:
* uvp cachefs_user_values object to set values for
* Returns:
* Preconditions:
* precond(uvp)
*/
void
user_values_defaults(struct cachefs_user_values *uvp)
{
uvp->uv_maxblocks = 90;
uvp->uv_minblocks = 0;
uvp->uv_threshblocks = 85;
uvp->uv_maxfiles = 90;
uvp->uv_minfiles = 0;
uvp->uv_threshfiles = 85;
uvp->uv_maxfilesize = 3;
uvp->uv_hiblocks = 85;
uvp->uv_lowblocks = 75;
uvp->uv_hifiles = 85;
uvp->uv_lowfiles = 75;
}
/*
*
* check_user_values_for_sanity
*
* Description:
* Check the cachefs_user_values for sanity.
* Arguments:
* uvp cachefs_user_values object to check
* Returns:
* Returns 0 if okay, -1 if not.
* Preconditions:
* precond(uvp)
*/
int
check_user_values_for_sanity(const struct cachefs_user_values *uvp)
{
int ret;
ret = 0;
if (uvp->uv_lowblocks >= uvp->uv_hiblocks) {
pr_err(gettext("lowblocks can't be >= hiblocks."));
ret = -1;
}
if (uvp->uv_lowfiles >= uvp->uv_hifiles) {
pr_err(gettext("lowfiles can't be >= hifiles."));
ret = -1;
}
/* XXX more conditions to check here? */
/* XXX make sure thresh values are between min and max values */
/* return status */
return (ret);
}
/*
*
* cache_stats
*
* Description:
* Show each cache in the directory, cache resource statistics,
* and, for each fs in the cache, the name of the fs, and the
* cache resource parameters.
* Arguments:
* dirp name of the cache directory
* Returns:
* Returns 0 for success, -1 for an error.
* Errors:
* Preconditions:
*/
int
cache_stats(char *dirp)
{
DIR *dp;
struct dirent64 *dep;
char path[CACHEFS_XMAXPATH];
struct stat64 statinfo;
int ret;
int xx;
struct cache_label clabel;
struct cachefs_user_values uv;
/* make sure cache dir name is not too long */
if (strlen(dirp) > (size_t)PATH_MAX) {
pr_err(gettext("path name %s is too long."), dirp);
return (-1);
}
/* read the cache label file */
sprintf(path, "%s/%s", dirp, CACHELABEL_NAME);
xx = cachefs_label_file_get(path, &clabel);
if (xx == -1) {
pr_err(gettext("Reading %s failed."), path);
return (-1);
}
xx = cachefs_label_file_vcheck(path, &clabel);
if (xx != 0) {
pr_err(gettext("Version mismatch on %s."), path);
return (-1);
}
/* convert the cache_label to user values */
xx = cachefs_convert_cl2uv(&clabel, &uv, dirp);
if (xx)
return (-1);
/* display the parameters */
printf(gettext("cfsadmin: list cache FS information\n"));
#if 0
printf(gettext(" Version %3d\n"), clabel.cl_cfsversion);
#endif
printf(gettext(" maxblocks %3d%%\n"), uv.uv_maxblocks);
printf(gettext(" minblocks %3d%%\n"), uv.uv_minblocks);
printf(gettext(" threshblocks %3d%%\n"), uv.uv_threshblocks);
printf(gettext(" maxfiles %3d%%\n"), uv.uv_maxfiles);
printf(gettext(" minfiles %3d%%\n"), uv.uv_minfiles);
printf(gettext(" threshfiles %3d%%\n"), uv.uv_threshfiles);
printf(gettext(" maxfilesize %3dMB\n"), uv.uv_maxfilesize);
/* open the directory */
if ((dp = opendir(dirp)) == NULL) {
pr_err(gettext("opendir %s failed: %s"), dirp,
strerror(errno));
return (-1);
}
/* loop reading the contents of the directory */
ret = 0;
while ((dep = readdir64(dp)) != NULL) {
/* ignore . and .. */
if ((strcmp(dep->d_name, ".") == 0) ||
(strcmp(dep->d_name, "..") == 0))
continue;
/* stat the file */
sprintf(path, "%s/%s", dirp, dep->d_name);
xx = lstat64(path, &statinfo);
if (xx == -1) {
pr_err(gettext("lstat %s failed: %s"),
path, strerror(errno));
closedir(dp);
return (-1);
}
/* ignore anything that is not a link */
if (!S_ISLNK(statinfo.st_mode))
continue;
/* print the file system cache directory name */
printf(gettext(" %s\n"), dep->d_name);
/* XXX anything else */
}
/* XXX what about stats */
/* return status */
return (ret);
}
/*
*
* resource_file_grow
*
* Description:
* Grows the resource file in the specified directory
* to its new size.
* Arguments:
* dirp cache directory resource file is in
* oldcnt previous number of files in resource file
* newcnt new number of files in resource file
* Returns:
* Returns 0 for success, -1 for an error.
* Preconditions:
* precond(dirp)
* precond(oldcnt <= newcnt)
* precond(cache is locked exclusively)
* precond(cache is not in use)
*/
int
resource_file_grow(char *dirp, int oldcnt, int newcnt)
{
int fd;
char path[CACHEFS_XMAXPATH];
int xx;
struct stat64 st;
static struct cachefs_rinfo rold, rnew;
struct cache_usage cusage, *cusagep;
char buf[MAXBSIZE];
int cnt;
caddr_t addrp;
int dirty;
/* get info about the resouce file for the various sizes */
cachefs_resource_size(oldcnt, &rold);
cachefs_resource_size(newcnt, &rnew);
/* open the resource file for writing */
/* this file is < 2GB */
sprintf(path, "%s/%s", dirp, RESOURCE_NAME);
fd = open(path, O_RDWR);
if (fd == -1) {
pr_err(gettext("Could not open %s: %s, run fsck"), path,
strerror(errno));
return (-1);
}
/* get info on the file */
xx = fstat64(fd, &st);
if (xx == -1) {
pr_err(gettext("Could not stat %s: %s"), path,
strerror(errno));
close(fd);
return (-1);
}
/* make sure the size is the correct */
if ((off_t)st.st_size != rold.r_fsize) {
pr_err(gettext("Resource file has wrong size %d %d, run fsck"),
(off_t)st.st_size, rold.r_fsize);
close(fd);
return (-1);
}
/* read the cache usage structure */
xx = read(fd, &cusage, sizeof (cusage));
if (xx != sizeof (cusage)) {
pr_err(gettext("Could not read cache_usage, %d, run fsck"),
xx);
close(fd);
return (-1);
}
/* rewind */
xx = lseek(fd, 0, SEEK_SET);
if (xx == -1) {
pr_err(gettext("Could not lseek %s: %s"), path,
strerror(errno));
close(fd);
return (-1);
}
/* indicate cache is dirty if necessary */
dirty = 1;
if ((cusage.cu_flags & CUSAGE_ACTIVE) == 0) {
dirty = 0;
cusage.cu_flags |= CUSAGE_ACTIVE;
xx = write(fd, &cusage, sizeof (cusage));
if (xx != sizeof (cusage)) {
pr_err(gettext(
"Could not write cache_usage, %d, run fsck"),
xx);
close(fd);
return (-1);
}
}
/* go to the end of the file */
xx = lseek(fd, 0, SEEK_END);
if (xx == -1) {
pr_err(gettext("Could not lseek %s: %s"), path,
strerror(errno));
close(fd);
return (-1);
}
/* grow the file to the new size */
memset(buf, 0, sizeof (buf));
cnt = rnew.r_fsize - rold.r_fsize;
assert((cnt % MAXBSIZE) == 0);
cnt /= MAXBSIZE;
while (cnt-- > 0) {
xx = write(fd, buf, sizeof (buf));
if (xx != sizeof (buf)) {
pr_err(gettext("Could not write file, %d, run fsck"),
xx);
close(fd);
return (-1);
}
}
/* mmap the file into our address space */
addrp = mmap(NULL, rnew.r_fsize, PROT_READ | PROT_WRITE, MAP_SHARED,
fd, 0);
if (addrp == (void *)-1) {
pr_err(gettext("Could not mmap file %s: %s"), path,
strerror(errno));
close(fd);
return (-1);
}
/* close the file descriptor, we do not need it anymore */
close(fd);
/* move the idents region to its new location */
memmove(addrp + rnew.r_identoffset, addrp + rold.r_identoffset,
rold.r_identsize);
/* zero out the old idents region that is now in the pointers region */
memset(addrp + rold.r_identoffset, 0,
rnew.r_identoffset - rold.r_identoffset);
/* sync the data to the file */
xx = msync(addrp, rnew.r_fsize, MS_SYNC);
if (xx == -1) {
pr_err(gettext("Could not sync file %s: %s"), path,
strerror(errno));
munmap(addrp, rnew.r_fsize);
return (-1);
}
/* mark the file as clean if it was not dirty originally */
if (!dirty) {
cusagep = (struct cache_usage *)addrp;
cusagep->cu_flags &= ~CUSAGE_ACTIVE;
/* sync the data to the file */
xx = msync(addrp, rnew.r_fsize, MS_SYNC);
if (xx == -1) {
pr_err(gettext("Could not sync file %s: %s"), path,
strerror(errno));
munmap(addrp, rnew.r_fsize);
return (-1);
}
}
/* unmap the file */
munmap(addrp, rnew.r_fsize);
/* return success */
return (0);
}
/*
*
* resource_file_dirty
*
* Description:
* Marks the resource file as dirty.
* This will cause fsck to fix it up the next time it
* is run.
* Arguments:
* dirp cache directory resource file is in
* Returns:
* Returns 0 for success, -1 for an error.
* Preconditions:
* precond(dirp)
* precond(cache is locked exclusively)
* precond(cache is not in use)
*/
int
resource_file_dirty(char *dirp)
{
int fd;
char path[CACHEFS_XMAXPATH];
int xx;
struct cache_usage cusage;
/* open the resource file for writing */
/* this file is < 2GB */
sprintf(path, "%s/%s", dirp, RESOURCE_NAME);
fd = open(path, O_RDWR);
if (fd == -1) {
pr_err(gettext("Could not open %s: %s, run fsck"), path,
strerror(errno));
return (-1);
}
/* read the cache usage structure */
xx = read(fd, &cusage, sizeof (cusage));
if (xx != sizeof (cusage)) {
pr_err(gettext("Could not read cache_usage, %d, run fsck"),
xx);
close(fd);
return (-1);
}
/* rewind */
xx = lseek(fd, 0, SEEK_SET);
if (xx == -1) {
pr_err(gettext("Could not lseek %s: %s"), path,
strerror(errno));
close(fd);
return (-1);
}
/* indicate cache is dirty if necessary */
if ((cusage.cu_flags & CUSAGE_ACTIVE) == 0) {
cusage.cu_flags |= CUSAGE_ACTIVE;
xx = write(fd, &cusage, sizeof (cusage));
if (xx != sizeof (cusage)) {
pr_err(gettext(
"Could not write cache_usage, %d, run fsck"),
xx);
close(fd);
return (-1);
}
}
xx = close(fd);
if (xx == -1) {
pr_err(gettext("Could not successfully close %s: %s"), path,
strerror(errno));
}
return (xx);
}
/*
*
* issue_cod
*
* Description:
* Executes the _FIOCOD ioctl on the specified file.
* Arguments:
* name filename to issue ioctl on (or "all")
* Returns:
* Returns 0 for success, -1 for an error.
* Preconditions:
* precond(dirp)
*/
int
issue_cod(char *name)
{
int fd;
int xx;
int arg;
char *dirp;
FILE *mfp;
struct mnttab mt, mtpref;
#ifndef MNTTYPE_CACHEFS
#define MNTTYPE_CACHEFS "cachefs"
#endif
arg = 0;
if (strcmp(name, "all") == 0) {
/*
* if "all" was specified rather than a mount point,
* we locate a cachefs mount in /etc/mnttab (any cachefs
* mount will do). We issue the ioctl on this mount point,
* and specify a non-zero argument to the ioctl. The non-zero
* arg tells the kernel to do demandconst on all relevant
* cachefs mounts
*/
if ((mfp = fopen(MNTTAB, "r")) == NULL) {
pr_err(gettext("Could not open %s."), MNTTAB);
return (-1);
}
mtpref.mnt_special = NULL;
mtpref.mnt_mountp = NULL;
mtpref.mnt_mntopts = NULL;
mtpref.mnt_time = NULL;
mtpref.mnt_fstype = MNTTYPE_CACHEFS;
if (getmntany(mfp, &mt, &mtpref) != 0) {
(void) fclose(mfp);
return (-1);
}
(void) fclose(mfp);
dirp = mt.mnt_mountp;
arg = 1;
} else {
dirp = name;
}
/* open the file */
fd = open(dirp, O_RDONLY);
if (fd == -1) {
pr_err(gettext("Could not open %s, %s."),
dirp, strerror(errno));
return (-1);
}
/* issue the ioctl */
xx = ioctl(fd, _FIOCOD, arg);
if (xx) {
if (errno == ENOTTY) {
pr_err(gettext("%s is not a CacheFS file system"),
dirp);
} else if (errno == EBUSY) {
if (arg == 0)
/* we're quiet if "all" was specified */
pr_err(gettext("CacheFS file system %s is not"
" mounted demandconst."), dirp);
} else {
pr_err(gettext("Could not issue consistency request"
" on %s\n %s."), dirp, strerror(errno));
}
}
close(fd);
return (xx);
}
/*
*
* simulate_disconnection
*
* Description:
* Sends the rpc message to the cachefsd to turn simulated
* disconnection on or off
* Arguments:
* namep name of file system or "all"
* disconnect 1 means disconnect, 0 means connect
* Returns:
* Preconditions:
* precond(name)
*/
void
simulate_disconnection(char *namep, int disconnect)
{
CLIENT *clnt;
enum clnt_stat retval;
int ret;
int xx;
int result;
char *hostp;
struct utsname info;
struct cachefsd_disconnection_args args;
char *msgp;
struct timeval tval;
/* get the host name */
xx = uname(&info);
if (xx == -1) {
pr_err(gettext("cannot get host name, errno %d"), errno);
return;
}
hostp = info.nodename;
/* creat the connection to the daemon */
clnt = clnt_create(hostp, CACHEFSDPROG, CACHEFSDVERS, "local");
if (clnt == NULL) {
pr_err(gettext("cachefsd is not running"));
return;
}
/* give it a chance to complete */
tval.tv_sec = 60 * 60 * 24;
tval.tv_usec = 0;
clnt_control(clnt, CLSET_TIMEOUT, (char *)&tval);
/* perform the operation */
args.cda_mntpt = namep;
args.cda_disconnect = disconnect;
retval = cachefsd_disconnection_1(&args, &ret, clnt);
if (retval != RPC_SUCCESS) {
clnt_perror(clnt, gettext("cachefsd is not responding"));
clnt_destroy(clnt);
return;
}
/* check for error from daemon */
if (ret != 0) {
if (disconnect) {
switch (ret) {
default:
msgp = "unknown error";
break;
case 1:
msgp = "not mounted disconnectable";
break;
case 2:
msgp = "already disconnected";
break;
case 3:
msgp = "not a cached file system";
break;
}
pr_err(gettext("Could not disconnect %s: %s"),
namep, msgp);
} else {
switch (ret) {
default:
msgp = "unknown error";
break;
case 1:
msgp = "already connected";
break;
case 2:
msgp = "not simulated disconnection";
break;
case 3:
msgp = "not a cached file system";
break;
}
pr_err(gettext("Could not reconnect %s: %s"),
namep, msgp);
}
}
ret = 0;
clnt_destroy(clnt);
}