usr/src/cmd/fs.d/cachefs/common/subr.c

   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 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * Common subroutines used by the programs in these subdirectories.
  31  */
  32
  33 #include <locale.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <assert.h>
  38 #include <unistd.h>
  39 #include <limits.h>
  40 #include <errno.h>
  41 #include <wait.h>
  42 #include <ctype.h>
  43 #include <fcntl.h>
  44 #include <ftw.h>
  45 #include <dirent.h>
  46 #include <sys/types.h>
  47 #include <sys/time.h>
  48 #include <utmpx.h>
  49 #include <sys/uio.h>
  50 #include <sys/param.h>
  51 #include <sys/stat.h>
  52 #include <sys/fcntl.h>
  53 #include <sys/mount.h>
  54 #include <sys/mntent.h>
  55 #include <sys/mnttab.h>
  56 #include <sys/mman.h>
  57 #include <sys/fs/cachefs_fs.h>
  58 #include "subr.h"
  59
  60 /*
  61  *
  62  *                      cachefs_dir_lock
  63  *
  64  * Description:
  65  *      Gets a lock on the cache directory.
  66  *      To release the lock, call cachefs_dir_unlock
  67  *      with the returned value.
  68  * Arguments:
  69  *      cachedirp       name of the cache directory
  70  *      shared          1 if shared, 0 if not
  71  * Returns:
  72  *      Returns -1 if the lock cannot be obtained immediatly.
  73  *      If the lock is obtained, returns a value >= 0.
  74  * Preconditions:
  75  *      precond(cachedirp)
  76  */
  77
  78 int
  79 cachefs_dir_lock(const char *cachedirp, int shared)
  80 {
  81         int fd;
  82         int xx;
  83         int len;
  84         char buf[MAXPATHLEN];
  85         struct flock fl;
  86         char *strp;
  87         struct stat statb;
  88
  89         /* make a path prefix to the cache directory lock file */
  90         strp = CACHEFS_ROOTRUN;
  91         xx = stat(strp, &statb);
  92         if ((xx < 0) || ((statb.st_mode & S_IFMT) != S_IFDIR))
  93                 strp = "/tmp";
  94
  95         /* won't overflow */
  96         len = snprintf(buf, sizeof (buf), "%s/%s", strp, CACHEFS_LOCKDIR_PRE);
  97
  98         if (strlcat(buf, cachedirp, sizeof (buf)) >= sizeof (buf)) {
  99                 pr_err(gettext("Cache directory name %s is too long"),
 100                         cachedirp);
 101                 return (-1);
 102         }
 103
 104         strp = &buf[len];
 105
 106         while (strp = strchr(strp, '/')) {      /* convert path to a file */
 107                 *strp = '_';
 108         }
 109
 110         /*
 111          * Create and open the cache directory lock file.
 112          * This file will be <2G.
 113          */
 114         fd = open(buf, O_RDWR | O_CREAT, 0700);
 115         if (fd == -1) {
 116                 pr_err(gettext("Cannot open lock file %s"), buf);
 117                 return (-1);
 118         }
 119
 120         /* try to set the lock */
 121         fl.l_type = (shared == 1) ? F_RDLCK : F_WRLCK;
 122         fl.l_whence = 0;
 123         fl.l_start = 1024;
 124         fl.l_len = 1024;
 125         fl.l_sysid = 0;
 126         fl.l_pid = 0;
 127         /* CACHEFS_LOCK_FILE will be <2GB */
 128         xx = fcntl(fd, F_SETLKW, &fl);
 129         if (xx == -1) {
 130                 if (errno == EAGAIN) {
 131                         pr_err(gettext("Cannot gain access to the "
 132                             "cache directory %s."), cachedirp);
 133                 } else {
 134                         pr_err(gettext("Unexpected failure on lock file %s %s"),
 135                             buf, strerror(errno));
 136                 }
 137                 close(fd);
 138                 return (-1);
 139         }
 140
 141         /* return the file descriptor which can be used to release the lock */
 142         return (fd);
 143 }
 144
 145 /*
 146  *
 147  *                      cachefs_dir_unlock
 148  *
 149  * Description:
 150  *      Releases an advisory lock on the cache directory.
 151  * Arguments:
 152  *      fd      cookie returned by cachefs_dir_lock
 153  * Returns:
 154  *      Returns -1 if the lock cannot be released or 0 for success.
 155  * Preconditions:
 156  */
 157
 158 int
 159 cachefs_dir_unlock(int fd)
 160 {
 161         struct flock fl;
 162         int error = 0;
 163         int xx;
 164
 165         /* release the lock */
 166         fl.l_type = F_UNLCK;
 167         fl.l_whence = 0;
 168         fl.l_start = 1024;
 169         fl.l_len = 1024;
 170         fl.l_sysid = 0;
 171         fl.l_pid = 0;
 172         /* fd will be <2GB */
 173         xx = fcntl(fd, F_SETLK, &fl);
 174         if (xx == -1) {
 175                 pr_err(gettext("Unexpected failure releasing lock file %s"),
 176                         strerror(errno));
 177                 error = -1;
 178         }
 179
 180         /* close the lock file */
 181         close(fd);
 182
 183         return (error);
 184 }
 185
 186 /*
 187  *
 188  *                      cachefs_label_file_get
 189  *
 190  * Description:
 191  *      Gets the contents of a cache label file.
 192  *      Performs error checking on the file.
 193  * Arguments:
 194  *      filep   name of the cache label file
 195  *      clabelp where to put the file contents
 196  * Returns:
 197  *      Returns 0 for success or -1 if an error occurs.
 198  * Preconditions:
 199  *      precond(filep)
 200  *      precond(clabelp)
 201  */
 202
 203 int
 204 cachefs_label_file_get(const char *filep, struct cache_label *clabelp)
 205 {
 206         int xx;
 207         int fd;
 208         struct stat64 statinfo;
 209
 210         /* get info on the file */
 211         xx = lstat64(filep, &statinfo);
 212         if (xx == -1) {
 213                 if (errno != ENOENT) {
 214                         pr_err(gettext("Cannot stat file %s: %s"),
 215                             filep, strerror(errno));
 216                 } else {
 217                         pr_err(gettext("File %s does not exist."), filep);
 218                 }
 219
 220                 return (-1);
 221         }
 222
 223         /* if the file is the wrong type */
 224         if (!S_ISREG(statinfo.st_mode)) {
 225                 pr_err(gettext("Cache label file %s corrupted"), filep);
 226                 return (-1);
 227         }
 228
 229         /* if the file is the wrong size; it will be <2GB */
 230         if (statinfo.st_size != (offset_t)sizeof (struct cache_label)) {
 231                 pr_err(gettext("Cache label file %s wrong size"), filep);
 232                 return (-1);
 233         }
 234
 235         /* open the cache label file */
 236         fd = open(filep, O_RDONLY);
 237         if (fd == -1) {
 238                 pr_err(gettext("Error opening %s: %s"), filep,
 239                     strerror(errno));
 240                 return (-1);
 241         }
 242
 243         /* read the current set of parameters */
 244         xx = read(fd, clabelp, sizeof (struct cache_label));
 245         if (xx != sizeof (struct cache_label)) {
 246                 pr_err(gettext("Reading %s failed: %s\n"), filep,
 247                     strerror(errno));
 248                 close(fd);
 249                 return (-1);
 250         }
 251         close(fd);
 252
 253         /* return success */
 254         return (0);
 255 }
 256
 257 /*
 258  *
 259  *                      cachefs_label_file_put
 260  *
 261  * Description:
 262  *      Outputs the contents of a cache label object to a file.
 263  * Arguments:
 264  *      filep   name of the cache label file
 265  *      clabelp where to get the file contents
 266  * Returns:
 267  *      Returns 0 for success or -1 if an error occurs.
 268  * Preconditions:
 269  *      precond(filep)
 270  *      precond(clabelp)
 271  */
 272
 273 int
 274 cachefs_label_file_put(const char *filep, struct cache_label *clabelp)
 275 {
 276         int xx;
 277         int fd;
 278
 279         /* get rid of the file if it already exists */
 280         xx = unlink(filep);
 281         if ((xx == -1) && (errno != ENOENT)) {
 282                 pr_err(gettext("Could not remove %s: %s"), filep,
 283                     strerror(errno));
 284                 return (-1);
 285         }
 286
 287         /* open the cache label file; this file will be <2GB */
 288         fd = open(filep, O_CREAT | O_RDWR, 0600);
 289         if (fd == -1) {
 290                 pr_err(gettext("Error creating %s: %s"), filep,
 291                     strerror(errno));
 292                 return (-1);
 293         }
 294
 295         /* write out the cache label object */
 296         xx = write(fd, clabelp, sizeof (struct cache_label));
 297         if (xx != sizeof (struct cache_label)) {
 298                 pr_err(gettext("Writing %s failed: %s"), filep,
 299                     strerror(errno));
 300                 close(fd);
 301                 return (-1);
 302         }
 303
 304         /* make sure the contents get to disk */
 305         if (fsync(fd) != 0) {
 306                 pr_err(gettext("Writing %s failed on sync: %s"), filep,
 307                     strerror(errno));
 308                 close(fd);
 309                 return (-1);
 310         }
 311
 312         close(fd);
 313
 314         /* return success */
 315         return (0);
 316 }
 317
 318 int
 319 cachefs_label_file_vcheck(char *filep, struct cache_label *clabelp)
 320 {
 321         /* check for an invalid version number */
 322         if (clabelp->cl_cfsversion != CFSVERSION) {
 323                 pr_err(gettext("Cache label file %s corrupted"), filep);
 324                 return (-1);
 325         }
 326
 327         return (0);
 328 }
 329
 330 /*
 331  *
 332  *                      cachefs_inuse
 333  *
 334  * Description:
 335  *      Tests whether or not the cache directory is in use by
 336  *      the cache file system.
 337  * Arguments:
 338  *      cachedirp       name of the file system cache directory
 339  * Returns:
 340  *      Returns 1 if the cache is in use or an error, 0 if not.
 341  * Preconditions:
 342  *      precond(cachedirp)
 343  */
 344
 345 int
 346 cachefs_inuse(const char *cachedirp)
 347 {
 348         int fd;
 349         int xx;
 350         char buf[MAXPATHLEN];
 351         char *lockp = CACHEFS_LOCK_FILE;
 352         struct flock fl;
 353
 354         /* see if path name is too long */
 355         xx = strlen(cachedirp) + strlen(lockp) + 3;
 356         if (xx >= MAXPATHLEN) {
 357                 pr_err(gettext("Cache directory name %s is too long"),
 358                     cachedirp);
 359                 return (1);
 360         }
 361
 362         /* make a path to the cache directory lock file */
 363         snprintf(buf, sizeof (buf), "%s/%s", cachedirp, lockp);
 364
 365         /* Open the kernel in use lock file.  This file will be <2GB. */
 366         fd = open(buf, O_RDWR, 0700);
 367         if (fd == -1) {
 368                 pr_err(gettext("Cannot open lock file %s"), buf);
 369                 return (1);
 370         }
 371
 372         /* test the lock status */
 373         fl.l_type = F_WRLCK;
 374         fl.l_whence = 0;
 375         fl.l_start = 0;
 376         fl.l_len = 1024;
 377         fl.l_sysid = 0;
 378         fl.l_pid = 0;
 379         xx = fcntl(fd, F_GETLK, &fl);
 380         if (xx == -1) {
 381                 pr_err(gettext("Unexpected failure on lock file %s %s"),
 382                     buf, strerror(errno));
 383                 close(fd);
 384                 return (1);
 385         }
 386         close(fd);
 387
 388         if (fl.l_type == F_UNLCK)
 389                 xx = 0;
 390         else
 391                 xx = 1;
 392
 393         /* return whether or not the cache is in use */
 394         return (xx);
 395 }
 396
 397 /*
 398  *
 399  *                      cachefs_resouce_size
 400  *
 401  * Description:
 402  *      Returns information about a resource file.
 403  * Arguments:
 404  *      maxinodes       number of inodes to be managed by the resource file
 405  *      rinfop          set to info about the resource file
 406  * Returns:
 407  * Preconditions:
 408  *      precond(rinfop)
 409  */
 410
 411 void
 412 cachefs_resource_size(int maxinodes, struct cachefs_rinfo *rinfop)
 413 {
 414         int fsize;
 415
 416         fsize = MAXBSIZE;
 417
 418         rinfop->r_ptroffset = fsize;
 419
 420         fsize += MAXBSIZE * (maxinodes / CACHEFS_RLPMBS);
 421         if ((maxinodes % CACHEFS_RLPMBS) != 0)
 422                 fsize += MAXBSIZE;
 423
 424         rinfop->r_fsize = fsize;
 425 }
 426
 427 /*
 428  *
 429  *                      cachefs_create_cache
 430  *
 431  * Description:
 432  *      Creates the specified cache directory and populates it as
 433  *      needed by CFS.
 434  * Arguments:
 435  *      dirp            the name of the cache directory
 436  *      uv              user values (may be NULL)
 437  *      clabel          label file contents, or placeholder for this
 438  * Returns:
 439  *      Returns 0 for success or:
 440  *              -1 for an error
 441  *              -2 for an error and cache directory partially created
 442  * Preconditions:
 443  *      precond(dirp)
 444  */
 445
 446 int
 447 cachefs_create_cache(char *dirp, struct cachefs_user_values *uv,
 448     struct cache_label *clabel)
 449 {
 450         int xx;
 451         char path[CACHEFS_XMAXPATH];
 452         int fd;
 453         void *bufp;
 454         int cnt;
 455         struct cache_usage cu;
 456         FILE *fp;
 457         char *parent;
 458         struct statvfs64 svfs;
 459
 460         cu.cu_blksused = 0;
 461         cu.cu_filesused = 0;
 462         cu.cu_flags = 0;
 463
 464         /* make sure cache dir name is not too long */
 465         if (strlen(dirp) > (size_t)PATH_MAX) {
 466                 pr_err(gettext("path name %s is too long."), dirp);
 467                 return (-1);
 468         }
 469
 470         /* ensure the path isn't in cachefs */
 471         parent = cachefs_file_to_dir(dirp);
 472         if (parent == NULL) {
 473                 pr_err(gettext("Out of memory"));
 474                 return (-1);
 475         }
 476         if (statvfs64(parent, &svfs) != 0) {
 477                 pr_err(gettext("%s: %s"), parent, strerror(errno));
 478                 free(parent);
 479                 return (-1);
 480         }
 481         if (strcmp(svfs.f_basetype, CACHEFS_BASETYPE) == 0) {
 482                 pr_err(gettext("Cannot create cache in cachefs filesystem"));
 483                 free(parent);
 484                 return (-1);
 485         }
 486         free(parent);
 487
 488         /* make the directory */
 489         if (mkdir(dirp, 0) == -1) {
 490                 switch (errno) {
 491                 case EEXIST:
 492                         pr_err(gettext("%s already exists."), dirp);
 493                         break;
 494
 495                 default:
 496                         pr_err(gettext("mkdir %s failed: %s"),
 497                             dirp, strerror(errno));
 498                 }
 499                 return (-1);
 500         }
 501         cu.cu_filesused += 1;
 502         cu.cu_blksused += 1;
 503
 504         /* convert user values to a cache_label */
 505         if (uv != NULL) {
 506                 xx = cachefs_convert_uv2cl(uv, clabel, dirp);
 507                 if (xx)
 508                         return (-2);
 509         }
 510
 511         /*
 512          * Create the cache directory lock file.
 513          * Used by the kernel module to indicate the cache is in use.
 514          * This file will be <2G.
 515          */
 516         snprintf(path, sizeof (path), "%s/%s", dirp, CACHEFS_LOCK_FILE);
 517         fd = open(path, O_RDWR | O_CREAT, 0700);
 518         if (fd == -1) {
 519                 pr_err(gettext("Cannot create lock file %s"), path);
 520                 return (-1);
 521         }
 522         close(fd);
 523
 524         /* make the directory for the back file system mount points */
 525         /* note: we do not count this directory in the resources */
 526         snprintf(path, sizeof (path), "%s/%s", dirp, BACKMNT_NAME);
 527         if (mkdir(path, 0700) == -1) {
 528                 pr_err(gettext("mkdir %s failed: %s"), path,
 529                     strerror(errno));
 530                 return (-2);
 531         }
 532
 533         /* make the directory for lost+found */
 534         /* note: we do not count this directory in the resources */
 535         snprintf(path, sizeof (path), "%s/%s", dirp, CACHEFS_LOSTFOUND_NAME);
 536         if (mkdir(path, 0700) == -1) {
 537                 pr_err(gettext("mkdir %s failed: %s"), path,
 538                     strerror(errno));
 539                 return (-2);
 540         }
 541
 542         /* make the networker "don't back up" file; this file is <2GB */
 543         xx = 0;
 544         snprintf(path, sizeof (path), "%s/%s", dirp, NOBACKUP_NAME);
 545         if ((fp = fopen(path, "w")) != NULL) {
 546                 if (realpath(dirp, path) != NULL) {
 547                         fprintf(fp, "<< ./ >>\n");
 548                         fprintf(fp, "+skip: .?* *\n");
 549                         if (fclose(fp) == 0)
 550                                 xx = 1;
 551                 }
 552         }
 553         if (xx == 0) {
 554                 snprintf(path, sizeof (path), "%s/%s", dirp, NOBACKUP_NAME);
 555                 pr_err(gettext("can't create %s"), path);
 556                 (void) unlink(path);
 557         } else {
 558                 cu.cu_filesused += 1;
 559                 cu.cu_blksused += 1;
 560         }
 561
 562         /* create the unmount file */
 563         xx = 0;
 564         snprintf(path, sizeof (path), "%s/%s", dirp, CACHEFS_UNMNT_FILE);
 565         if ((fp = fopen(path, "w")) != NULL) {
 566                 time32_t btime;
 567
 568                 btime = get_boottime();
 569                 fwrite((void *)&btime, sizeof (btime), 1, fp);
 570                 if (fclose(fp) == 0)
 571                         xx = 1;
 572         }
 573         if (xx == 0)
 574                 pr_err(gettext("can't create .cfs_unmnt file"));
 575
 576         /* create the cache label file */
 577         snprintf(path, sizeof (path), "%s/%s", dirp, CACHELABEL_NAME);
 578         xx = cachefs_label_file_put(path, clabel);
 579         if (xx == -1) {
 580                 pr_err(gettext("creating %s failed."), path);
 581                 return (-2);
 582         }
 583         cu.cu_filesused += 1;
 584         cu.cu_blksused += 1;
 585
 586         /* create the cache label duplicate file */
 587         snprintf(path, sizeof (path), "%s/%s.dup", dirp, CACHELABEL_NAME);
 588         xx = cachefs_label_file_put(path, clabel);
 589         if (xx == -1) {
 590                 pr_err(gettext("creating %s failed."), path);
 591                 return (-2);
 592         }
 593         cu.cu_filesused += 1;
 594         cu.cu_blksused += 1;
 595
 596         /* create the resouce file; this file will be <2GB */
 597         snprintf(path, sizeof (path), "%s/%s", dirp, RESOURCE_NAME);
 598         fd = open(path, O_CREAT | O_RDWR, 0600);
 599         if (fd == -1) {
 600                 pr_err(gettext("create %s failed: %s"), path,
 601                     strerror(errno));
 602                 return (-2);
 603         }
 604         cu.cu_filesused += 1;
 605
 606         /* allocate a zeroed buffer for filling the resouce file */
 607         bufp = calloc(1, MAXBSIZE);
 608         if (bufp == NULL) {
 609                 pr_err(gettext("out of space %d."), MAXBSIZE);
 610                 close(fd);
 611                 return (-2);
 612         }
 613
 614         /* determine number of MAXBSIZE chunks to make the file */
 615         cnt = 1;        /* for the header */
 616         cnt += clabel->cl_maxinodes / CACHEFS_RLPMBS;
 617         if ((clabel->cl_maxinodes % CACHEFS_RLPMBS) != 0)
 618                 ++cnt;
 619
 620         /* fill up the file with zeros */
 621         for (xx = 0; xx < cnt; xx++) {
 622                 if (write(fd, bufp, MAXBSIZE) != MAXBSIZE) {
 623                         pr_err(gettext("write %s failed: %s"), path,
 624                             strerror(errno));
 625                         close(fd);
 626                         free(bufp);
 627                         return (-2);
 628                 }
 629         }
 630         free(bufp);
 631         cu.cu_blksused += cnt;
 632
 633         /* position to the begining of the file */
 634         if (lseek(fd, 0, SEEK_SET) == -1) {
 635                 pr_err(gettext("lseek %s failed: %s"), path,
 636                     strerror(errno));
 637                 close(fd);
 638                 return (-2);
 639         }
 640
 641         /* write the cache usage structure */
 642         xx = sizeof (struct cache_usage);
 643         if (write(fd, &cu, xx) != xx) {
 644                 pr_err(gettext("cu write %s failed: %s"), path,
 645                     strerror(errno));
 646                 close(fd);
 647                 return (-2);
 648         }
 649
 650         /* make sure the contents get to disk */
 651         if (fsync(fd) != 0) {
 652                 pr_err(gettext("fsync %s failed: %s"), path,
 653                     strerror(errno));
 654                 close(fd);
 655                 return (-2);
 656         }
 657         close(fd);
 658
 659         /* return success */
 660         return (0);
 661 }
 662
 663 /*
 664  *
 665  *                      cachefs_delete_all_cache
 666  *
 667  * Description:
 668  *      Delete all caches in cache directory.
 669  * Arguments:
 670  *      dirp    the pathname of of the cache directory to delete
 671  * Returns:
 672  *      Returns 0 for success or -1 for an error.
 673  * Preconditions:
 674  *      precond(dirp)
 675  */
 676
 677 int
 678 cachefs_delete_all_cache(char *dirp)
 679 {
 680         DIR *dp;
 681         struct dirent64 *dep;
 682         int xx;
 683         char path[CACHEFS_XMAXPATH];
 684         struct stat64 statinfo;
 685
 686         /* make sure cache dir name is not too long */
 687         if (strlen(dirp) > (size_t)PATH_MAX) {
 688                 pr_err(gettext("path name %s is too long."),
 689                     dirp);
 690                 return (-1);
 691         }
 692
 693         /* check that dirp is probably a cachefs directory */
 694         snprintf(path, sizeof (path), "%s/%s", dirp, BACKMNT_NAME);
 695         xx = access(path, R_OK | W_OK | X_OK);
 696
 697         snprintf(path, sizeof (path), "%s/%s", dirp, CACHELABEL_NAME);
 698         xx |= access(path, R_OK | W_OK);
 699
 700         if (xx) {
 701                 pr_err(gettext("%s does not appear to be a "
 702                     "cachefs cache directory."), dirp);
 703                 return (-1);
 704         }
 705
 706         /* remove the lost+found directory if it exists and is empty */
 707         snprintf(path, sizeof (path), "%s/%s", dirp, CACHEFS_LOSTFOUND_NAME);
 708         xx = rmdir(path);
 709         if (xx == -1) {
 710                 if (errno == EEXIST) {
 711                         pr_err(gettext("Cannot delete cache '%s'.  "
 712                             "First move files in '%s' to a safe location."),
 713                             dirp, path);
 714                         return (-1);
 715                 } else if (errno != ENOENT) {
 716                         pr_err(gettext("rmdir %s failed: %s"), path,
 717                             strerror(errno));
 718                         return (-1);
 719                 }
 720         }
 721
 722         /* delete the back FS mount point directory if it exists */
 723         snprintf(path, sizeof (path), "%s/%s", dirp, BACKMNT_NAME);
 724         xx = lstat64(path, &statinfo);
 725         if (xx == -1) {
 726                 if (errno != ENOENT) {
 727                         pr_err(gettext("lstat %s failed: %s"), path,
 728                             strerror(errno));
 729                         return (-1);
 730                 }
 731         } else {
 732                 xx = nftw64(path, cachefs_delete_file, 16,
 733                     FTW_PHYS | FTW_DEPTH | FTW_MOUNT);
 734                 if (xx == -1) {
 735                         pr_err(gettext("unable to delete %s"), path);
 736                         return (-1);
 737                 }
 738         }
 739
 740         /* open the cache directory specified */
 741         if ((dp = opendir(dirp)) == NULL) {
 742                 pr_err(gettext("cannot open cache directory %s: %s"),
 743                     dirp, strerror(errno));
 744                 return (-1);
 745         }
 746
 747         /* read the file names in the cache directory */
 748         while ((dep = readdir64(dp)) != NULL) {
 749                 /* ignore . and .. */
 750                 if (strcmp(dep->d_name, ".") == 0 ||
 751                                 strcmp(dep->d_name, "..") == 0)
 752                         continue;
 753
 754                 /* stat the file */
 755                 snprintf(path, sizeof (path), "%s/%s", dirp, dep->d_name);
 756                 xx = lstat64(path, &statinfo);
 757                 if (xx == -1) {
 758                         if (errno == ENOENT) {
 759                                 /* delete_cache may have nuked a directory */
 760                                 continue;
 761                         }
 762
 763                         pr_err(gettext("lstat %s failed: %s"),
 764                             path, strerror(errno));
 765                         closedir(dp);
 766                         return (-1);
 767                 }
 768
 769                 /* ignore anything that is not a link */
 770                 if (!S_ISLNK(statinfo.st_mode))
 771                         continue;
 772
 773                 /* delete the file system cache directory */
 774                 xx = cachefs_delete_cache(dirp, dep->d_name);
 775                 if (xx) {
 776                         closedir(dp);
 777                         return (-1);
 778                 }
 779         }
 780         closedir(dp);
 781
 782         /* remove the cache dir unmount file */
 783         snprintf(path, sizeof (path), "%s/%s", dirp, CACHEFS_UNMNT_FILE);
 784         xx = unlink(path);
 785         if ((xx == -1) && (errno != ENOENT)) {
 786                 pr_err(gettext("unlink %s failed: %s"), path,
 787                     strerror(errno));
 788                 return (-1);
 789         }
 790
 791         /* remove the cache label file */
 792         snprintf(path, sizeof (path), "%s/%s", dirp, CACHELABEL_NAME);
 793         xx = unlink(path);
 794         if ((xx == -1) && (errno != ENOENT)) {
 795                 pr_err(gettext("unlink %s failed: %s"), path,
 796                     strerror(errno));
 797                 return (-1);
 798         }
 799
 800         /* remove the cache label duplicate file */
 801         snprintf(path, sizeof (path), "%s/%s.dup", dirp, CACHELABEL_NAME);
 802         xx = unlink(path);
 803         if ((xx == -1) && (errno != ENOENT)) {
 804                 pr_err(gettext("unlink %s failed: %s"), path,
 805                     strerror(errno));
 806                 return (-1);
 807         }
 808
 809         /* remove the resource file */
 810         snprintf(path, sizeof (path), "%s/%s", dirp, RESOURCE_NAME);
 811         xx = unlink(path);
 812         if ((xx == -1) && (errno != ENOENT)) {
 813                 pr_err(gettext("unlink %s failed: %s"), path,
 814                     strerror(errno));
 815                 return (-1);
 816         }
 817
 818         /* remove the cachefslog file if it exists */
 819         snprintf(path, sizeof (path), "%s/%s", dirp, LOG_STATUS_NAME);
 820         (void) unlink(path);
 821
 822         /* remove the networker "don't back up" file if it exists */
 823         snprintf(path, sizeof (path), "%s/%s", dirp, NOBACKUP_NAME);
 824         (void) unlink(path);
 825
 826         /* remove the lock file */
 827         snprintf(path, sizeof (path), "%s/%s", dirp, CACHEFS_LOCK_FILE);
 828         xx = unlink(path);
 829         if ((xx == -1) && (errno != ENOENT)) {
 830                 pr_err(gettext("unlink %s failed: %s"), path,
 831                     strerror(errno));
 832                 return (-1);
 833         }
 834
 835         /* remove the directory */
 836         xx = rmdir(dirp);
 837         if (xx == -1) {
 838                 pr_err(gettext("rmdir %s failed: %s"), dirp,
 839                     strerror(errno));
 840                 return (-1);
 841         }
 842
 843         /* return success */
 844         return (0);
 845 }
 846
 847 /*
 848  *
 849  *                      cachefs_delete_cache
 850  *
 851  * Description:
 852  *      Deletes the specified file system cache.
 853  * Arguments:
 854  *      dirp    cache directory name
 855  *      namep   file system cache directory to delete
 856  * Returns:
 857  *      Returns 0 for success, -1 for failure.
 858  * Preconditions:
 859  *      precond(dirp)
 860  *      precond(namep)
 861  */
 862
 863 int
 864 cachefs_delete_cache(char *dirp, char *namep)
 865 {
 866         char path[CACHEFS_XMAXPATH];
 867         char buf[CACHEFS_XMAXPATH];
 868         int xx;
 869         struct stat64 statinfo;
 870
 871         /* make sure cache dir name is not too long */
 872         if (strlen(dirp) > (size_t)PATH_MAX) {
 873                 pr_err(gettext("path name %s is too long."),
 874                     dirp);
 875                 return (-1);
 876         }
 877
 878         /* construct the path name of the file system cache directory */
 879         snprintf(path, sizeof (path), "%s/%s", dirp, namep);
 880
 881         /* stat the specified file */
 882         xx = lstat64(path, &statinfo);
 883         if (xx == -1) {
 884                 pr_err(gettext("lstat %s failed: %s"), path,
 885                     strerror(errno));
 886                 return (-1);
 887         }
 888
 889         /* make sure name is a symbolic link */
 890         if (!S_ISLNK(statinfo.st_mode)) {
 891                 pr_err(gettext("\"%s\" is not a valid cache id."), namep);
 892                 return (-1);
 893         }
 894
 895         /* read the contents of the symbolic link */
 896         xx = readlink(path, buf, sizeof (buf));
 897         if (xx == -1) {
 898                 pr_err(gettext("Readlink of %s failed: %s"), path,
 899                     strerror(errno));
 900                 return (-1);
 901         }
 902         buf[xx] = '\0';
 903
 904         /* remove the directory */
 905         snprintf(path, sizeof (path), "%s/%s", dirp, buf);
 906         xx = nftw64(path, cachefs_delete_file, 16,
 907             FTW_PHYS | FTW_DEPTH | FTW_MOUNT);
 908         if (xx == -1) {
 909                 pr_err(gettext("directory walk of %s failed."), dirp);
 910                 return (-1);
 911         }
 912
 913         /* delete the link */
 914         snprintf(path, sizeof (path), "%s/%s", dirp, namep);
 915         if (unlink(path) == -1) {
 916                 pr_err(gettext("unlink %s failed: %s"), path,
 917                     strerror(errno));
 918                 return (-1);
 919         }
 920
 921         /* return success */
 922         return (0);
 923 }
 924
 925 /*
 926  *
 927  *                      cachefs_delete_file
 928  *
 929  * Description:
 930  *      Remove a file or directory; called by nftw64().
 931  * Arguments:
 932  *      namep   pathname of the file
 933  *      statp   stat info about the file
 934  *      flg     info about file
 935  *      ftwp    depth information
 936  * Returns:
 937  *      Returns 0 for success, -1 for failure.
 938  * Preconditions:
 939  *      precond(namep)
 940  */
 941
 942 int
 943 cachefs_delete_file(const char *namep, const struct stat64 *statp, int flg,
 944     struct FTW *ftwp)
 945 {
 946         /* ignore . and .. */
 947         if (strcmp(namep, ".") == 0 || strcmp(namep, "..") == 0)
 948                 return (0);
 949
 950         switch (flg) {
 951         case FTW_F:     /* files */
 952         case FTW_SL:
 953                 if (unlink(namep) == -1) {
 954                         pr_err(gettext("unlink %s failed: %s"),
 955                             namep, strerror(errno));
 956                         return (-1);
 957                 }
 958                 break;
 959
 960         case FTW_DP:    /* directories that have their children processed */
 961                 if (rmdir(namep) == -1) {
 962                         pr_err(gettext("rmdir %s failed: %s"),
 963                             namep, strerror(errno));
 964                         return (-1);
 965                 }
 966                 break;
 967
 968         case FTW_D:     /* ignore directories if children not processed */
 969                 break;
 970
 971         default:
 972                 pr_err(gettext("failure on file %s, flg %d."),
 973                     namep, flg);
 974                 return (-1);
 975         }
 976
 977         /* return success */
 978         return (0);
 979 }
 980
 981 /*
 982  *
 983  *                      cachefs_convert_uv2cl
 984  *
 985  * Description:
 986  *      Copies the contents of a cachefs_user_values object into a
 987  *      cache_label object, performing the necessary conversions.
 988  * Arguments:
 989  *      uvp     cachefs_user_values to copy from
 990  *      clp     cache_label to copy into
 991  *      dirp    cache directory
 992  * Returns:
 993  *      Returns 0 for success, -1 for an error.
 994  * Preconditions:
 995  *      precond(uvp)
 996  *      precond(clp)
 997  *      precond(dirp)
 998  */
 999
1000 int
1001 cachefs_convert_uv2cl(const struct cachefs_user_values *uvp,
1002     struct cache_label *clp, const char *dirp)
1003 {
1004         struct statvfs64 fs;
1005         int xx;
1006         double ftmp;
1007         double temp;
1008
1009         /* get file system information */
1010         xx = statvfs64(dirp, &fs);
1011         if (xx == -1) {
1012                 pr_err(gettext("statvfs %s failed: %s"), dirp,
1013                     strerror(errno));
1014                 return (-1);
1015         }
1016
1017         ftmp = (double)fs.f_frsize / (double)MAXBSIZE;
1018
1019         /* front fs is less than 1 terabyte */
1020         temp = (double)uvp->uv_maxblocks / 100.0 *
1021             (double)fs.f_blocks * ftmp + .5;
1022         clp->cl_maxblks = temp < (double)INT_MAX ? (int)temp : INT_MAX;
1023
1024         temp = (double)uvp->uv_minblocks / 100.0 *
1025             (double)fs.f_blocks * ftmp + .5;
1026         clp->cl_blockmin = temp < (double)INT_MAX ? (int)temp : INT_MAX;
1027
1028         temp = (double)uvp->uv_threshblocks / 100.0 *
1029             (double)fs.f_blocks * ftmp + .5;
1030         clp->cl_blocktresh = temp < (double)INT_MAX ? (int)temp : INT_MAX;
1031
1032         temp = (double)uvp->uv_maxfiles / 100.0 * (double)fs.f_files + .5;
1033         clp->cl_maxinodes = temp < (double)INT_MAX ? (int)temp : INT_MAX;
1034
1035         temp = (double)uvp->uv_minfiles / 100.0 * (double)fs.f_files + .5;
1036         clp->cl_filemin = temp < (double)INT_MAX ? (int)temp : INT_MAX;
1037
1038         temp = (double)uvp->uv_threshfiles / 100.0 * (double)fs.f_files +.5;
1039         clp->cl_filetresh = temp < (double)INT_MAX ? (int)temp : INT_MAX;
1040
1041         ftmp = (double)(1024 * 1024) / (double)MAXBSIZE;
1042         clp->cl_maxfiles = uvp->uv_maxfilesize * ftmp + .5;
1043
1044         clp->cl_blkhiwat = uvp->uv_hiblocks / 100.0 * clp->cl_maxblks + .5;
1045         clp->cl_blklowat = uvp->uv_lowblocks / 100.0 * clp->cl_maxblks + .5;
1046
1047         clp->cl_filehiwat = uvp->uv_hifiles / 100.0 * clp->cl_maxinodes + .5;
1048         clp->cl_filelowat = uvp->uv_lowfiles / 100.0 * clp->cl_maxinodes + .5;
1049
1050         clp->cl_cfsversion = CFSVERSION;
1051
1052         /* return success */
1053         return (0);
1054 }
1055
1056 /*
1057  *
1058  *                      cachefs_convert_cl2uv
1059  *
1060  * Description:
1061  *      Copies the contents of a cache_label object into a
1062  *      cachefs_user_values object, performing the necessary conversions.
1063  * Arguments:
1064  *      clp     cache_label to copy from
1065  *      uvp     cachefs_user_values to copy into
1066  *      dirp    cache directory
1067  * Returns:
1068  *      Returns 0 for success, -1 for an error.
1069  * Preconditions:
1070  *      precond(clp)
1071  *      precond(uvp)
1072  *      precond(dirp)
1073  */
1074
1075 int
1076 cachefs_convert_cl2uv(const struct cache_label *clp,
1077     struct cachefs_user_values *uvp, const char *dirp)
1078 {
1079         struct statvfs64 fs;
1080         int xx;
1081         double temp;
1082         double ftmp;
1083         long long ltmp;
1084
1085         /* get file system information */
1086         xx = statvfs64(dirp, &fs);
1087         if (xx == -1) {
1088                 pr_err(gettext("statvfs %s failed: %s"), dirp,
1089                     strerror(errno));
1090                 return (-1);
1091         }
1092
1093 #define BOUND(yy) \
1094         yy = (yy < 0) ? 0 : yy; \
1095         yy = (yy > 100) ? 100 : yy;
1096
1097         ftmp = (double)MAXBSIZE / (double)fs.f_frsize;
1098
1099         temp = (double)clp->cl_maxblks * ftmp /
1100             (double)fs.f_blocks * 100. + .5;
1101         BOUND(temp);
1102         uvp->uv_maxblocks = (int)temp;
1103
1104         temp = (double)clp->cl_blockmin * ftmp /
1105             (double)fs.f_blocks * 100. + .5;
1106         BOUND(temp);
1107         uvp->uv_minblocks = (int)temp;
1108
1109         temp = (double)clp->cl_blocktresh * ftmp /
1110             (double)fs.f_blocks * 100. + .5;
1111         BOUND(temp);
1112         uvp->uv_threshblocks = (int)temp;
1113
1114         temp = ((double)clp->cl_maxinodes / fs.f_files) * 100. + .5;
1115         BOUND(temp);
1116         uvp->uv_maxfiles = (int)temp;
1117
1118         temp = ((double)clp->cl_filemin / fs.f_files) * 100. + .5;
1119         BOUND(temp);
1120         uvp->uv_minfiles = (int)temp;
1121
1122         temp = ((double)clp->cl_filetresh / fs.f_files) * 100. + .5;
1123         BOUND(temp);
1124         uvp->uv_threshfiles = (int)temp;
1125
1126         ltmp = ((long long)clp->cl_maxfiles * MAXBSIZE);
1127         uvp->uv_maxfilesize = (ltmp + (MAXBSIZE / 2)) / (1024 * 1024);
1128
1129         xx = ((double)clp->cl_blkhiwat / clp->cl_maxblks) * 100. + .5;
1130         BOUND(xx);
1131         uvp->uv_hiblocks = xx;
1132
1133         xx = ((double)clp->cl_blklowat / clp->cl_maxblks) * 100. + .5;
1134         BOUND(xx);
1135         uvp->uv_lowblocks = xx;
1136
1137         xx = ((double)clp->cl_filehiwat / clp->cl_maxinodes) * 100. + .5;
1138         BOUND(xx);
1139         uvp->uv_hifiles = xx;
1140
1141         xx = ((double)clp->cl_filelowat / clp->cl_maxinodes) * 100. + .5;
1142         BOUND(xx);
1143         uvp->uv_lowfiles = xx;
1144
1145         /* return success */
1146         return (0);
1147 }
1148
1149 /*
1150  * cachefs_file_to_dir
1151  *
1152  * takes in a path, and returns the parent directory of that path.
1153  *
1154  * it's the caller's responsibility to free the pointer returned by
1155  * this function.
1156  */
1157
1158 char *
1159 cachefs_file_to_dir(const char *path)
1160 {
1161         char *rc, *cp;
1162
1163         if (path == NULL)
1164                 return (NULL);
1165
1166         rc = strdup(path);
1167         if (rc == NULL)
1168                 return (NULL);
1169
1170         if ((cp = strrchr(rc, '/')) == NULL) {
1171
1172                 /*
1173                  * if no slashes at all, return "." (current directory).
1174                  */
1175
1176                 (void) free(rc);
1177                 rc = strdup(".");
1178
1179         } else if (cp == rc) {
1180
1181                 /*
1182                  * else, if the last '/' is the first character, chop
1183                  * off from there (i.e. return "/").
1184                  */
1185
1186                 rc[1] = '\0';
1187
1188         } else {
1189
1190                 /*
1191                  * else, we have a path like /foo/bar or foo/bar.
1192                  * chop off from the last '/'.
1193                  */
1194
1195                 *cp = '\0';
1196
1197         }
1198
1199         return (rc);
1200 }
1201
1202 /*
1203  *                      cachefs_clean_flag_test
1204  *
1205  * Description:
1206  *      Tests whether or not the clean flag on the file system
1207  *      is set.
1208  * Arguments:
1209  *      cachedirp       name of the the file system cache directory
1210  * Returns:
1211  *      Returns 1 if the cache was shut down cleanly, 0 if not.
1212  * Preconditions:
1213  *      precond(cachedirp)
1214  */
1215
1216 int
1217 cachefs_clean_flag_test(const char *cachedirp)
1218 {
1219         char *namep;
1220         int xx;
1221         char buf[MAXPATHLEN];
1222         int fd;
1223         struct cache_usage cu;
1224
1225         /* construct the path name of the resource file */
1226         namep = RESOURCE_NAME;
1227         xx = strlen(cachedirp) + strlen(namep) + 3;
1228         if (xx >= MAXPATHLEN) {
1229                 pr_err(gettext("Path name too long %s/%s"),
1230                     cachedirp, namep);
1231                 return (39);
1232         }
1233         snprintf(buf, sizeof (buf), "%s/%s", cachedirp, namep);
1234
1235         /* open the file; it will be <2GB */
1236         fd = open(buf, O_RDONLY);
1237         if (fd == -1) {
1238                 pr_err(gettext("Cannot open %s: %s"), buf, strerror(errno));
1239                 return (0);
1240         }
1241
1242         /* read the cache_usage structure */
1243         xx = read(fd, &cu, sizeof (cu));
1244         if (xx != sizeof (cu)) {
1245                 pr_err(gettext("Error reading %s: %d %s"), buf,
1246                     xx, strerror(errno));
1247                 close(fd);
1248                 return (0);
1249         }
1250         close(fd);
1251
1252         /* return state of the cache */
1253         return ((cu.cu_flags & CUSAGE_ACTIVE) == 0);
1254 }
1255
1256 time32_t
1257 get_boottime()
1258 {
1259         struct utmpx id, *putmp;
1260
1261         id.ut_type = BOOT_TIME;
1262         setutxent();
1263         if ((putmp = getutxid(&id)) != NULL)
1264                 return ((time32_t)putmp->ut_tv.tv_sec);
1265         return (-1);
1266 }