contrib/amd/amd/ops_autofs.c

   1 /*
   2  * Copyright (c) 1997-1999 Erez Zadok
   3  * Copyright (c) 1990 Jan-Simon Pendry
   4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
   5  * Copyright (c) 1990 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Jan-Simon Pendry at Imperial College, London.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgment:
  21  *      This product includes software developed by the University of
  22  *      California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  *      %W% (Berkeley) %G%
  40  *
  41  * $Id: ops_autofs.c,v 1.4 1999/01/13 23:31:00 ezk Exp $
  42  *
  43  */
  44
  45 /*
  46  * Automounter filesystem
  47  */
  48
  49 #ifdef HAVE_CONFIG_H
  50 # include <config.h>
  51 #endif /* HAVE_CONFIG_H */
  52 #include <am_defs.h>
  53 #include <amd.h>
  54
  55 /*
  56  * KLUDGE: wrap whole file in HAVE_FS_AUTOFS, because
  57  * not all systems with an automounter file system are supported
  58  * by am-utils yet...
  59  */
  60
  61 #ifdef HAVE_FS_AUTOFS
  62
  63 /*
  64  * MACROS:
  65  */
  66 #ifndef AUTOFS_NULL
  67 # define AUTOFS_NULL    ((u_long)0)
  68 #endif /* not AUTOFS_NULL */
  69
  70 /*
  71  * VARIABLES:
  72  */
  73
  74 /* forward declarations */
  75 static int mount_autofs(char *dir, char *opts);
  76 static int autofs_mount_1_svc(struct mntrequest *mr, struct mntres *result, struct authunix_parms *cred);
  77 static int autofs_unmount_1_svc(struct umntrequest *ur, struct umntres *result, struct authunix_parms *cred);
  78
  79 /* external declarations */
  80 extern bool_t xdr_mntrequest(XDR *, mntrequest *);
  81 extern bool_t xdr_mntres(XDR *, mntres *);
  82 extern bool_t xdr_umntrequest(XDR *, umntrequest *);
  83 extern bool_t xdr_umntres(XDR *, umntres *);
  84
  85 /*
  86  * STRUCTURES:
  87  */
  88
  89 /* Sun's kernel-based automounter-supporting file system */
  90 am_ops autofs_ops =
  91 {
  92   "autofs",
  93   amfs_auto_match,
  94   0,                            /* amfs_auto_init */
  95   autofs_mount,
  96   0,
  97   autofs_umount,
  98   0,
  99   amfs_auto_lookuppn,
 100   amfs_auto_readdir,            /* browsable version of readdir() */
 101   0,                            /* autofs_readlink */
 102   autofs_mounted,
 103   0,                            /* autofs_umounted */
 104   find_amfs_auto_srvr,
 105   FS_MKMNT | FS_NOTIMEOUT | FS_BACKGROUND | FS_AMQINFO | FS_DIRECTORY
 106 };
 107
 108
 109 /****************************************************************************
 110  *** FUNCTIONS                                                            ***
 111  ****************************************************************************/
 112
 113 /*
 114  * Mount the top-level using autofs
 115  */
 116 int
 117 autofs_mount(am_node *mp)
 118 {
 119   mntfs *mf = mp->am_mnt;
 120   struct stat stb;
 121   char opts[256], preopts[256];
 122   int error;
 123   char *mnttype;
 124
 125   /*
 126    * Mounting the automounter.
 127    * Make sure the mount directory exists, construct
 128    * the mount options and call the mount_autofs routine.
 129    */
 130
 131   if (stat(mp->am_path, &stb) < 0) {
 132     return errno;
 133   } else if ((stb.st_mode & S_IFMT) != S_IFDIR) {
 134     plog(XLOG_WARNING, "%s is not a directory", mp->am_path);
 135     return ENOTDIR;
 136   }
 137   if (mf->mf_ops == &autofs_ops)
 138     mnttype = "indirect";
 139   else if (mf->mf_ops == &amfs_direct_ops)
 140     mnttype = "direct";
 141 #ifdef HAVE_AM_FS_UNION
 142   else if (mf->mf_ops == &amfs_union_ops)
 143     mnttype = "union";
 144 #endif /* HAVE_AM_FS_UNION */
 145   else
 146     mnttype = "auto";
 147
 148   /*
 149    * Construct some mount options:
 150    *
 151    * Tack on magic map=<mapname> option in mtab to emulate
 152    * SunOS automounter behavior.
 153    */
 154   preopts[0] = '\0';
 155 #ifdef MNTTAB_OPT_INTR
 156   strcat(preopts, MNTTAB_OPT_INTR);
 157   strcat(preopts, ",");
 158 #endif /* MNTTAB_OPT_INTR */
 159 #ifdef MNTTAB_OPT_IGNORE
 160   strcat(preopts, MNTTAB_OPT_IGNORE);
 161   strcat(preopts, ",");
 162 #endif /* MNTTAB_OPT_IGNORE */
 163   sprintf(opts, "%s%s,%s=%d,%s=%d,%s=%d,%s,map=%s",
 164           preopts,
 165           MNTTAB_OPT_RW,
 166           MNTTAB_OPT_PORT, nfs_port,
 167           MNTTAB_OPT_TIMEO, gopt.amfs_auto_timeo,
 168           MNTTAB_OPT_RETRANS, gopt.amfs_auto_retrans,
 169           mnttype, mf->mf_info);
 170
 171   /* now do the mount */
 172   error = mount_autofs(mf->mf_mount, opts);
 173   if (error) {
 174     errno = error;
 175     plog(XLOG_FATAL, "mount_autofs: %m");
 176     return error;
 177   }
 178   return 0;
 179 }
 180
 181
 182 void
 183 autofs_mounted(mntfs *mf)
 184 {
 185   amfs_auto_mkcacheref(mf);
 186 }
 187
 188
 189 /*
 190  * Unmount a top-level automount node
 191  */
 192 int
 193 autofs_umount(am_node *mp)
 194 {
 195   int error;
 196   struct stat stb;
 197
 198   /*
 199    * The lstat is needed if this mount is type=direct.  When that happens,
 200    * the kernel cache gets confused between the underlying type (dir) and
 201    * the mounted type (link) and so needs to be re-synced before the
 202    * unmount.  This is all because the unmount system call follows links and
 203    * so can't actually unmount a link (stupid!).  It was noted that doing an
 204    * ls -ld of the mount point to see why things were not working actually
 205    * fixed the problem - so simulate an ls -ld here.
 206    */
 207   if (lstat(mp->am_path, &stb) < 0) {
 208 #ifdef DEBUG
 209     dlog("lstat(%s): %m", mp->am_path);
 210 #endif /* DEBUG */
 211   }
 212   error = UMOUNT_FS(mp->am_path, mnttab_file_name);
 213   if (error == EBUSY && mp->am_flags & AMF_AUTOFS) {
 214     plog(XLOG_WARNING, "autofs_unmount of %s busy (autofs). exit", mp->am_path);
 215     error = 0;                  /* fake unmount was ok */
 216   }
 217   return error;
 218 }
 219
 220
 221 /*
 222  * Mount an automounter directory.
 223  * The automounter is connected into the system
 224  * as a user-level NFS server.  mount_autofs constructs
 225  * the necessary NFS parameters to be given to the
 226  * kernel so that it will talk back to us.
 227  */
 228 static int
 229 mount_autofs(char *dir, char *opts)
 230 {
 231   char fs_hostname[MAXHOSTNAMELEN + MAXPATHLEN + 1];
 232   char *map_opt, buf[MAXHOSTNAMELEN];
 233   int retry, error, flags;
 234   struct utsname utsname;
 235   mntent_t mnt;
 236   autofs_args_t autofs_args;
 237   MTYPE_TYPE type = MOUNT_TYPE_AUTOFS;
 238
 239   memset((voidp) &autofs_args, 0, sizeof(autofs_args)); /* Paranoid */
 240
 241   memset((voidp) &mnt, 0, sizeof(mnt));
 242   mnt.mnt_dir = dir;
 243   mnt.mnt_fsname = pid_fsname;
 244   mnt.mnt_opts = opts;
 245   mnt.mnt_type = type;
 246
 247   retry = hasmntval(&mnt, "retry");
 248   if (retry <= 0)
 249     retry = 2;                  /* XXX */
 250
 251   /*
 252    * SET MOUNT ARGS
 253    */
 254   if (uname(&utsname) < 0) {
 255     strcpy(buf, "localhost.autofs");
 256   } else {
 257     strcpy(buf, utsname.nodename);
 258     strcat(buf, ".autofs");
 259   }
 260 #ifdef HAVE_FIELD_AUTOFS_ARGS_T_ADDR
 261   autofs_args.addr.buf = buf;
 262   autofs_args.addr.len = strlen(autofs_args.addr.buf);
 263   autofs_args.addr.maxlen = autofs_args.addr.len;
 264 #endif /* HAVE_FIELD_AUTOFS_ARGS_T_ADDR */
 265
 266   autofs_args.path = dir;
 267   autofs_args.opts = opts;
 268
 269   map_opt = hasmntopt(&mnt, "map");
 270   if (map_opt) {
 271     map_opt += sizeof("map="); /* skip the "map=" */
 272     if (map_opt == NULL) {
 273       plog(XLOG_WARNING, "map= has a null map name. reset to amd.unknown");
 274       map_opt = "amd.unknown";
 275     }
 276   }
 277   autofs_args.map = map_opt;
 278
 279   /* XXX: these I set arbitrarily... */
 280   autofs_args.mount_to = 300;
 281   autofs_args.rpc_to = 60;
 282   autofs_args.direct = 0;
 283
 284   /*
 285    * Make a ``hostname'' string for the kernel
 286    */
 287   sprintf(fs_hostname, "pid%ld@%s:%s",
 288           (long) (foreground ? am_mypid : getppid()),
 289           am_get_hostname(), dir);
 290
 291   /*
 292    * Most kernels have a name length restriction.
 293    */
 294   if (strlen(fs_hostname) >= MAXHOSTNAMELEN)
 295     strcpy(fs_hostname + MAXHOSTNAMELEN - 3, "..");
 296
 297   /*
 298    * Finally we can compute the mount flags set above.
 299    */
 300   flags = compute_mount_flags(&mnt);
 301
 302   /*
 303    * This is it!  Here we try to mount amd on its mount points.
 304    */
 305   error = mount_fs(&mnt, flags, (caddr_t) &autofs_args, retry, type, 0, NULL, mnttab_file_name);
 306   return error;
 307 }
 308
 309
 310 /****************************************************************************/
 311 /* autofs program dispatcher */
 312 void
 313 autofs_program_1(struct svc_req *rqstp, SVCXPRT *transp)
 314 {
 315   int ret;
 316   union {
 317     mntrequest autofs_mount_1_arg;
 318     umntrequest autofs_umount_1_arg;
 319   } argument;
 320   union {
 321     mntres mount_res;
 322     umntres umount_res;
 323   } result;
 324
 325   bool_t (*xdr_argument)(), (*xdr_result)();
 326   int (*local)();
 327
 328   switch (rqstp->rq_proc) {
 329
 330   case AUTOFS_NULL:
 331     svc_sendreply(transp,
 332                   (XDRPROC_T_TYPE) xdr_void,
 333                   (SVC_IN_ARG_TYPE) NULL);
 334     return;
 335
 336   case AUTOFS_MOUNT:
 337     xdr_argument = xdr_mntrequest;
 338     xdr_result = xdr_mntres;
 339     local = (int (*)()) autofs_mount_1_svc;
 340     break;
 341
 342   case AUTOFS_UNMOUNT:
 343     xdr_argument = xdr_umntrequest;
 344     xdr_result = xdr_umntres;
 345     local = (int (*)()) autofs_unmount_1_svc;
 346     break;
 347
 348   default:
 349     svcerr_noproc(transp);
 350     return;
 351   }
 352
 353   memset((char *) &argument, 0, sizeof(argument));
 354   if (!svc_getargs(transp,
 355                    (XDRPROC_T_TYPE) xdr_argument,
 356                    (SVC_IN_ARG_TYPE) &argument)) {
 357     plog(XLOG_ERROR,
 358          "AUTOFS xdr decode failed for %d %d %d",
 359          (int) rqstp->rq_prog, (int) rqstp->rq_vers, (int) rqstp->rq_proc);
 360     svcerr_decode(transp);
 361     return;
 362   }
 363
 364   ret = (*local) (&argument, &result, rqstp);
 365   if (!svc_sendreply(transp,
 366                      (XDRPROC_T_TYPE) xdr_result,
 367                      (SVC_IN_ARG_TYPE) &result)) {
 368     svcerr_systemerr(transp);
 369   }
 370
 371   if (!svc_freeargs(transp,
 372                     (XDRPROC_T_TYPE) xdr_argument,
 373                     (SVC_IN_ARG_TYPE) &argument)) {
 374     plog(XLOG_FATAL, "unable to free rpc arguments in autofs_program_1");
 375     going_down(1);
 376   }
 377 }
 378
 379
 380 static int
 381 autofs_mount_1_svc(struct mntrequest *mr, struct mntres *result, struct authunix_parms *cred)
 382 {
 383   int err = 0;
 384   am_node *anp, *anp2;
 385
 386   plog(XLOG_INFO, "XXX: autofs_mount_1_svc: %s:%s:%s:%s",
 387        mr->map, mr->name, mr->opts, mr->path);
 388
 389   /* look for map (eg. "/home") */
 390   anp = find_ap(mr->path);
 391   if (!anp) {
 392     plog(XLOG_ERROR, "map %s not found", mr->path);
 393     err = ENOENT;
 394     goto out;
 395   }
 396   /* turn on autofs in map flags */
 397   if (!(anp->am_flags & AMF_AUTOFS)) {
 398     plog(XLOG_INFO, "turning on AMF_AUTOFS for node %s", mr->path);
 399     anp->am_flags |= AMF_AUTOFS;
 400   }
 401
 402   /*
 403    * Look for (and create if needed) the new node.
 404    *
 405    * If an error occurred, return it.  If a -1 was returned, that indicates
 406    * that a mount is in progress, so sleep a while (while the backgrounded
 407    * mount is happening), and then signal the autofs to retry the mount.
 408    *
 409    * There's something I don't understand.  I was thinking that this code
 410    * here is the one which will succeed eventually and will send an RPC
 411    * reply to the kernel, but apparently that happens somewhere else, not
 412    * here.  It works though, just that I don't know how.  Arg. -Erez.
 413    * */
 414   err = 0;
 415   anp2 = autofs_lookuppn(anp, mr->name, &err, VLOOK_CREATE);
 416   if (!anp2) {
 417     if (err == -1) {            /* then tell autofs to retry */
 418       sleep(1);
 419       err = EAGAIN;
 420     }
 421     goto out;
 422   }
 423
 424 out:
 425   result->status = err;
 426   return err;
 427 }
 428
 429
 430 static int
 431 autofs_unmount_1_svc(struct umntrequest *ur, struct umntres *result, struct authunix_parms *cred)
 432 {
 433   int err = 0;
 434
 435 #ifdef HAVE_FIELD_UMNTREQUEST_RDEVID
 436   plog(XLOG_INFO, "XXX: autofs_unmount_1_svc: %d:%lu:%lu:0x%lx",
 437        ur->isdirect, (unsigned long) ur->devid, (unsigned long) ur->rdevid,
 438        (unsigned long) ur->next);
 439 #else /* HAVE_FIELD_UMNTREQUEST_RDEVID */
 440   plog(XLOG_INFO, "XXX: autofs_unmount_1_svc: %d:%lu:0x%lx",
 441        ur->isdirect, (unsigned long) ur->devid,
 442        (unsigned long) ur->next);
 443 #endif /* HAVE_FIELD_UMNTREQUEST_RDEVID */
 444
 445   err = EINVAL;                 /* XXX: not implemented yet */
 446   goto out;
 447
 448 out:
 449   result->status = err;
 450   return err;
 451 }
 452
 453
 454 /*
 455  * Pick a file system to try mounting and
 456  * do that in the background if necessary
 457  *
 458  For each location:
 459  if it is new -defaults then
 460  extract and process
 461  continue;
 462  fi
 463  if it is a cut then
 464  if a location has been tried then
 465  break;
 466  fi
 467  continue;
 468  fi
 469  parse mount location
 470  discard previous mount location if required
 471  find matching mounted filesystem
 472  if not applicable then
 473  this_error = No such file or directory
 474  continue
 475  fi
 476  if the filesystem failed to be mounted then
 477  this_error = error from filesystem
 478  elif the filesystem is mounting or unmounting then
 479  this_error = -1
 480  elif the fileserver is down then
 481  this_error = -1
 482  elif the filesystem is already mounted
 483  this_error = 0
 484  break
 485  fi
 486  if no error on this mount then
 487  this_error = initialize mount point
 488  fi
 489  if no error on this mount and mount is delayed then
 490  this_error = -1
 491  fi
 492  if this_error < 0 then
 493  retry = true
 494  fi
 495  if no error on this mount then
 496  make mount point if required
 497  fi
 498  if no error on this mount then
 499  if mount in background then
 500  run mount in background
 501  return -1
 502  else
 503  this_error = mount in foreground
 504  fi
 505  fi
 506  if an error occurred on this mount then
 507  update stats
 508  save error in mount point
 509  fi
 510  endfor
 511  */
 512 static int
 513 autofs_bgmount(struct continuation * cp, int mpe)
 514 {
 515   mntfs *mf = cp->mp->am_mnt;   /* Current mntfs */
 516   mntfs *mf_retry = 0;          /* First mntfs which needed retrying */
 517   int this_error = -1;          /* Per-mount error */
 518   int hard_error = -1;
 519   int mp_error = mpe;
 520
 521   /*
 522    * Try to mount each location.
 523    * At the end:
 524    * hard_error == 0 indicates something was mounted.
 525    * hard_error > 0 indicates everything failed with a hard error
 526    * hard_error < 0 indicates nothing could be mounted now
 527    */
 528   for (; this_error && *cp->ivec; cp->ivec++) {
 529     am_ops *p;
 530     am_node *mp = cp->mp;
 531     char *link_dir;
 532     int dont_retry;
 533
 534     if (hard_error < 0)
 535       hard_error = this_error;
 536
 537     this_error = -1;
 538
 539     if (**cp->ivec == '-') {
 540       /*
 541        * Pick up new defaults
 542        */
 543       if (cp->auto_opts && *cp->auto_opts)
 544         cp->def_opts = str3cat(cp->def_opts, cp->auto_opts, ";", *cp->ivec + 1);
 545       else
 546         cp->def_opts = strealloc(cp->def_opts, *cp->ivec + 1);
 547 #ifdef DEBUG
 548       dlog("Setting def_opts to \"%s\"", cp->def_opts);
 549 #endif /* DEBUG */
 550       continue;
 551     }
 552     /*
 553      * If a mount has been attempted, and we find
 554      * a cut then don't try any more locations.
 555      */
 556     if (STREQ(*cp->ivec, "/") || STREQ(*cp->ivec, "||")) {
 557       if (cp->tried) {
 558 #ifdef DEBUG
 559         dlog("Cut: not trying any more locations for %s",
 560              mp->am_path);
 561 #endif /* DEBUG */
 562         break;
 563       }
 564       continue;
 565     }
 566
 567     /* match the operators */
 568     p = ops_match(&cp->fs_opts, *cp->ivec, cp->def_opts, mp->am_path, cp->key, mp->am_parent->am_mnt->mf_info);
 569
 570     /*
 571      * Find a mounted filesystem for this node.
 572      */
 573     mp->am_mnt = mf = realloc_mntfs(mf, p, &cp->fs_opts,
 574                                     cp->fs_opts.opt_fs,
 575                                     cp->fs_opts.fs_mtab,
 576                                     cp->auto_opts,
 577                                     cp->fs_opts.opt_opts,
 578                                     cp->fs_opts.opt_remopts);
 579
 580     p = mf->mf_ops;
 581 #ifdef DEBUG
 582     dlog("Got a hit with %s", p->fs_type);
 583 #endif /* DEBUG */
 584
 585     /*
 586      * Note whether this is a real mount attempt
 587      */
 588     if (p == &amfs_error_ops) {
 589       plog(XLOG_MAP, "Map entry %s for %s failed to match", *cp->ivec, mp->am_path);
 590       if (this_error <= 0)
 591         this_error = ENOENT;
 592       continue;
 593     } else {
 594       if (cp->fs_opts.fs_mtab) {
 595         plog(XLOG_MAP, "Trying mount of %s on \"%s\" fstype %s",
 596              cp->fs_opts.fs_mtab, mp->am_path, p->fs_type);
 597       }
 598       cp->tried = TRUE;
 599     }
 600
 601     this_error = 0;
 602     dont_retry = FALSE;
 603
 604     if (mp->am_link) {
 605       XFREE(mp->am_link);
 606       mp->am_link = 0;
 607     }
 608     link_dir = mf->mf_fo->opt_sublink;
 609
 610     if (link_dir && *link_dir) {
 611       if (*link_dir == '/') {
 612         mp->am_link = strdup(link_dir);
 613       } else {
 614         /*
 615          * try getting fs option from continuation, not mountpoint!
 616          * Don't try logging the string from mf, since it may be bad!
 617          */
 618         if (cp->fs_opts.opt_fs != mf->mf_fo->opt_fs)
 619           plog(XLOG_ERROR, "use %s instead of 0x%lx",
 620                cp->fs_opts.opt_fs, (unsigned long) mf->mf_fo->opt_fs);
 621
 622         mp->am_link = str3cat((char *) 0,
 623                               cp->fs_opts.opt_fs, "/", link_dir);
 624
 625         normalize_slash(mp->am_link);
 626       }
 627     }
 628
 629     if (mf->mf_error > 0) {
 630       this_error = mf->mf_error;
 631     } else if (mf->mf_flags & (MFF_MOUNTING | MFF_UNMOUNTING)) {
 632       /*
 633        * Still mounting - retry later
 634        */
 635 #ifdef DEBUG
 636       dlog("Duplicate pending mount fstype %s", p->fs_type);
 637 #endif /* DEBUG */
 638       this_error = -1;
 639     } else if (FSRV_ISDOWN(mf->mf_server)) {
 640       /*
 641        * Would just mount from the same place
 642        * as a hung mount - so give up
 643        */
 644 #ifdef DEBUG
 645       dlog("%s is already hung - giving up", mf->mf_mount);
 646 #endif /* DEBUG */
 647       mp_error = EWOULDBLOCK;
 648       dont_retry = TRUE;
 649       this_error = -1;
 650     } else if (mf->mf_flags & MFF_MOUNTED) {
 651 #ifdef DEBUG
 652       dlog("duplicate mount of \"%s\" ...", mf->mf_info);
 653 #endif /* DEBUG */
 654
 655       /*
 656        * Just call mounted()
 657        */
 658       am_mounted(mp);
 659
 660       this_error = 0;
 661       break;
 662     }
 663
 664     /*
 665      * Will usually need to play around with the mount nodes
 666      * file attribute structure.  This must be done here.
 667      * Try and get things initialized, even if the fileserver
 668      * is not known to be up.  In the common case this will
 669      * progress things faster.
 670      */
 671     if (!this_error) {
 672       /*
 673        * Fill in attribute fields.
 674        */
 675       if (mf->mf_ops->fs_flags & FS_DIRECTORY)
 676         mk_fattr(mp, NFDIR);
 677       else
 678         mk_fattr(mp, NFLNK);
 679
 680       mp->am_fattr.na_fileid = mp->am_gen;
 681
 682       if (p->fs_init)
 683         this_error = (*p->fs_init) (mf);
 684     }
 685
 686     /*
 687      * Make sure the fileserver is UP before doing any more work
 688      */
 689     if (!FSRV_ISUP(mf->mf_server)) {
 690 #ifdef DEBUG
 691       dlog("waiting for server %s to become available", mf->mf_server->fs_host);
 692 #endif /* DEBUG */
 693       this_error = -1;
 694     }
 695
 696     if (!this_error && mf->mf_fo->opt_delay) {
 697       /*
 698        * If there is a delay timer on the mount
 699        * then don't try to mount if the timer
 700        * has not expired.
 701        */
 702       int i = atoi(mf->mf_fo->opt_delay);
 703       if (i > 0 && clocktime() < (cp->start + i)) {
 704 #ifdef DEBUG
 705         dlog("Mount of %s delayed by %lds", mf->mf_mount, i - clocktime() + cp->start);
 706 #endif /* DEBUG */
 707         this_error = -1;
 708       }
 709     }
 710
 711     if (this_error < 0 && !dont_retry) {
 712       if (!mf_retry)
 713         mf_retry = dup_mntfs(mf);
 714       cp->retry = TRUE;
 715     }
 716
 717     if (!this_error) {
 718       if (p->fs_flags & FS_MBACKGROUND) {
 719         mf->mf_flags |= MFF_MOUNTING;   /* XXX */
 720 #ifdef DEBUG
 721         dlog("backgrounding mount of \"%s\"", mf->mf_mount);
 722 #endif /* DEBUG */
 723         if (cp->callout) {
 724           untimeout(cp->callout);
 725           cp->callout = 0;
 726         }
 727         run_task(try_mount, (voidp) mp, amfs_auto_cont, (voidp) cp);
 728         mf->mf_flags |= MFF_MKMNT;      /* XXX */
 729         if (mf_retry)
 730           free_mntfs(mf_retry);
 731         return -1;
 732       } else {
 733 #ifdef DEBUG
 734         dlog("foreground mount of \"%s\" ...", mf->mf_info);
 735 #endif /* DEBUG */
 736         this_error = try_mount((voidp) mp);
 737         if (this_error < 0) {
 738           if (!mf_retry)
 739             mf_retry = dup_mntfs(mf);
 740           cp->retry = TRUE;
 741         }
 742       }
 743     }
 744
 745     if (this_error >= 0) {
 746       if (this_error > 0) {
 747         amd_stats.d_merr++;
 748         if (mf != mf_retry) {
 749           mf->mf_error = this_error;
 750           mf->mf_flags |= MFF_ERROR;
 751         }
 752       }
 753
 754       /*
 755        * Wakeup anything waiting for this mount
 756        */
 757       wakeup((voidp) mf);
 758     }
 759   }
 760
 761   if (this_error && cp->retry) {
 762     free_mntfs(mf);
 763     mf = cp->mp->am_mnt = mf_retry;
 764     /*
 765      * Not retrying again (so far)
 766      */
 767     cp->retry = FALSE;
 768     cp->tried = FALSE;
 769     /*
 770      * Start at the beginning.
 771      * Rewind the location vector and
 772      * reset the default options.
 773      */
 774     cp->ivec = cp->xivec;
 775     cp->def_opts = strealloc(cp->def_opts, cp->auto_opts);
 776     /*
 777      * Arrange that autofs_bgmount is called
 778      * after anything else happens.
 779      */
 780 #ifdef DEBUG
 781     dlog("Arranging to retry mount of %s", cp->mp->am_path);
 782 #endif /* DEBUG */
 783     sched_task(amfs_auto_retry, (voidp) cp, (voidp) mf);
 784     if (cp->callout)
 785       untimeout(cp->callout);
 786     cp->callout = timeout(RETRY_INTERVAL, wakeup, (voidp) mf);
 787
 788     cp->mp->am_ttl = clocktime() + RETRY_INTERVAL;
 789
 790     /*
 791      * Not done yet - so don't return anything
 792      */
 793     return -1;
 794   }
 795
 796   if (hard_error < 0 || this_error == 0)
 797     hard_error = this_error;
 798
 799   /*
 800    * Discard handle on duff filesystem.
 801    * This should never happen since it
 802    * should be caught by the case above.
 803    */
 804   if (mf_retry) {
 805     if (hard_error)
 806       plog(XLOG_ERROR, "discarding a retry mntfs for %s", mf_retry->mf_mount);
 807     free_mntfs(mf_retry);
 808   }
 809
 810   /*
 811    * If we get here, then either the mount succeeded or
 812    * there is no more mount information available.
 813    */
 814   if (hard_error < 0 && mp_error)
 815     hard_error = cp->mp->am_error = mp_error;
 816   if (hard_error > 0) {
 817     /*
 818      * Set a small(ish) timeout on an error node if
 819      * the error was not a time out.
 820      */
 821     switch (hard_error) {
 822     case ETIMEDOUT:
 823     case EWOULDBLOCK:
 824       cp->mp->am_timeo = 17;
 825       break;
 826     default:
 827       cp->mp->am_timeo = 5;
 828       break;
 829     }
 830     new_ttl(cp->mp);
 831   }
 832
 833   /*
 834    * Make sure that the error value in the mntfs has a
 835    * reasonable value.
 836    */
 837   if (mf->mf_error < 0) {
 838     mf->mf_error = hard_error;
 839     if (hard_error)
 840       mf->mf_flags |= MFF_ERROR;
 841   }
 842
 843   /*
 844    * In any case we don't need the continuation any more
 845    */
 846   free_continuation(cp);
 847
 848   return hard_error;
 849 }
 850
 851
 852 /*
 853  * Automount interface to RPC lookup routine
 854  * Find the corresponding entry and return
 855  * the file handle for it.
 856  */
 857 am_node *
 858 autofs_lookuppn(am_node *mp, char *fname, int *error_return, int op)
 859 {
 860   am_node *ap, *new_mp, *ap_hung;
 861   char *info;                   /* Mount info - where to get the file system */
 862   char **ivec, **xivec;         /* Split version of info */
 863   char *auto_opts;              /* Automount options */
 864   int error = 0;                /* Error so far */
 865   char path_name[MAXPATHLEN];   /* General path name buffer */
 866   char apath[MAXPATHLEN];       /* autofs path (added space) */
 867   char *pfname;                 /* Path for database lookup */
 868   struct continuation *cp;      /* Continuation structure if need to mount */
 869   int in_progress = 0;          /* # of (un)mount in progress */
 870   char *dflts;
 871   mntfs *mf;
 872
 873 #ifdef DEBUG
 874   dlog("in autofs_lookuppn");
 875 #endif /* DEBUG */
 876
 877   /*
 878    * If the server is shutting down
 879    * then don't return information
 880    * about the mount point.
 881    */
 882   if (amd_state == Finishing) {
 883 #ifdef DEBUG
 884     if ((mf = mp->am_mnt) == 0 || mf->mf_ops == &amfs_direct_ops) {
 885       dlog("%s mount ignored - going down", fname);
 886     } else {
 887       dlog("%s/%s mount ignored - going down", mp->am_path, fname);
 888     }
 889 #endif /* DEBUG */
 890     ereturn(ENOENT);
 891   }
 892
 893   /*
 894    * Handle special case of "." and ".."
 895    */
 896   if (fname[0] == '.') {
 897     if (fname[1] == '\0')
 898       return mp;                /* "." is the current node */
 899     if (fname[1] == '.' && fname[2] == '\0') {
 900       if (mp->am_parent) {
 901 #ifdef DEBUG
 902         dlog(".. in %s gives %s", mp->am_path, mp->am_parent->am_path);
 903 #endif /* DEBUG */
 904         return mp->am_parent;   /* ".." is the parent node */
 905       }
 906       ereturn(ESTALE);
 907     }
 908   }
 909
 910   /*
 911    * Check for valid key name.
 912    * If it is invalid then pretend it doesn't exist.
 913    */
 914   if (!valid_key(fname)) {
 915     plog(XLOG_WARNING, "Key \"%s\" contains a disallowed character", fname);
 916     ereturn(ENOENT);
 917   }
 918
 919   /*
 920    * Expand key name.
 921    * fname is now a private copy.
 922    */
 923   fname = expand_key(fname);
 924
 925   for (ap_hung = 0, ap = mp->am_child; ap; ap = ap->am_osib) {
 926     /*
 927      * Otherwise search children of this node
 928      */
 929     if (FSTREQ(ap->am_name, fname)) {
 930       mf = ap->am_mnt;
 931       if (ap->am_error) {
 932         error = ap->am_error;
 933         continue;
 934       }
 935       /*
 936        * If the error code is undefined then it must be
 937        * in progress.
 938        */
 939       if (mf->mf_error < 0)
 940         goto in_progrss;
 941
 942       /*
 943        * Check for a hung node
 944        */
 945       if (FSRV_ISDOWN(mf->mf_server)) {
 946 #ifdef DEBUG
 947         dlog("server hung");
 948 #endif /* DEBUG */
 949         error = ap->am_error;
 950         ap_hung = ap;
 951         continue;
 952       }
 953       /*
 954        * If there was a previous error with this node
 955        * then return that error code.
 956        */
 957       if (mf->mf_flags & MFF_ERROR) {
 958         error = mf->mf_error;
 959         continue;
 960       }
 961       if (!(mf->mf_flags & MFF_MOUNTED) || (mf->mf_flags & MFF_UNMOUNTING)) {
 962       in_progrss:
 963         /*
 964          * If the fs is not mounted or it is unmounting then there
 965          * is a background (un)mount in progress.  In this case
 966          * we just drop the RPC request (return nil) and
 967          * wait for a retry, by which time the (un)mount may
 968          * have completed.
 969          */
 970 #ifdef DEBUG
 971         dlog("ignoring mount of %s in %s -- flags (%x) in progress",
 972              fname, mf->mf_mount, mf->mf_flags);
 973 #endif /* DEBUG */
 974         in_progress++;
 975         continue;
 976       }
 977
 978       /*
 979        * Otherwise we have a hit: return the current mount point.
 980        */
 981 #ifdef DEBUG
 982       dlog("matched %s in %s", fname, ap->am_path);
 983 #endif /* DEBUG */
 984       XFREE(fname);
 985       return ap;
 986     }
 987   }
 988
 989   if (in_progress) {
 990 #ifdef DEBUG
 991     dlog("Waiting while %d mount(s) in progress", in_progress);
 992 #endif /* DEBUG */
 993     XFREE(fname);
 994     ereturn(-1);
 995   }
 996
 997   /*
 998    * If an error occurred then return it.
 999    */
1000   if (error) {
1001 #ifdef DEBUG
1002     errno = error;              /* XXX */
1003     dlog("Returning error: %m");
1004 #endif /* DEBUG */
1005     XFREE(fname);
1006     ereturn(error);
1007   }
1008
1009   /*
1010    * If doing a delete then don't create again!
1011    */
1012   switch (op) {
1013   case VLOOK_DELETE:
1014     ereturn(ENOENT);
1015
1016   case VLOOK_CREATE:
1017     break;
1018
1019   default:
1020     plog(XLOG_FATAL, "Unknown op to autofs_lookuppn: 0x%x", op);
1021     ereturn(EINVAL);
1022   }
1023
1024   /*
1025    * If the server is going down then just return,
1026    * don't try to mount any more file systems
1027    */
1028   if ((int) amd_state >= (int) Finishing) {
1029 #ifdef DEBUG
1030     dlog("not found - server going down anyway");
1031 #endif /* DEBUG */
1032     XFREE(fname);
1033     ereturn(ENOENT);
1034   }
1035
1036   /*
1037    * If we get there then this is a reference to an,
1038    * as yet, unknown name so we need to search the mount
1039    * map for it.
1040    */
1041   if (mp->am_pref) {
1042     sprintf(path_name, "%s%s", mp->am_pref, fname);
1043     pfname = path_name;
1044   } else {
1045     pfname = fname;
1046   }
1047
1048   mf = mp->am_mnt;
1049
1050 #ifdef DEBUG
1051   dlog("will search map info in %s to find %s", mf->mf_info, pfname);
1052 #endif /* DEBUG */
1053   /*
1054    * Consult the oracle for some mount information.
1055    * info is malloc'ed and belongs to this routine.
1056    * It ends up being free'd in free_continuation().
1057    *
1058    * Note that this may return -1 indicating that information
1059    * is not yet available.
1060    */
1061   error = mapc_search((mnt_map *) mf->mf_private, pfname, &info);
1062   if (error) {
1063     if (error > 0)
1064       plog(XLOG_MAP, "No map entry for %s", pfname);
1065     else
1066       plog(XLOG_MAP, "Waiting on map entry for %s", pfname);
1067     XFREE(fname);
1068     ereturn(error);
1069   }
1070 #ifdef DEBUG
1071   dlog("mount info is %s", info);
1072 #endif /* DEBUG */
1073
1074   /*
1075    * Split info into an argument vector.
1076    * The vector is malloc'ed and belongs to
1077    * this routine.  It is free'd in free_continuation()
1078    */
1079   xivec = ivec = strsplit(info, ' ', '\"');
1080
1081   /*
1082    * Default error code...
1083    */
1084   if (ap_hung)
1085     error = EWOULDBLOCK;
1086   else
1087     error = ENOENT;
1088
1089   /*
1090    * Allocate a new map
1091    */
1092   new_mp = exported_ap_alloc();
1093   if (new_mp == 0) {
1094     XFREE(xivec);
1095     XFREE(info);
1096     XFREE(fname);
1097     ereturn(ENOSPC);
1098   }
1099   if (mf->mf_auto)
1100     auto_opts = mf->mf_auto;
1101   else
1102     auto_opts = "";
1103
1104   auto_opts = strdup(auto_opts);
1105
1106 #ifdef DEBUG
1107   dlog("searching for /defaults entry");
1108 #endif /* DEBUG */
1109   if (mapc_search((mnt_map *) mf->mf_private, "/defaults", &dflts) == 0) {
1110     char *dfl;
1111     char **rvec;
1112 #ifdef DEBUG
1113     dlog("/defaults gave %s", dflts);
1114 #endif /* DEBUG */
1115     if (*dflts == '-')
1116       dfl = dflts + 1;
1117     else
1118       dfl = dflts;
1119
1120     /*
1121      * Chop the defaults up
1122      */
1123     rvec = strsplit(dfl, ' ', '\"');
1124
1125     if (gopt.flags & CFM_ENABLE_DEFAULT_SELECTORS) {
1126       /*
1127        * Pick whichever first entry matched the list of selectors.
1128        * Strip the selectors from the string, and assign to dfl the
1129        * rest of the string.
1130        */
1131       if (rvec) {
1132         am_opts ap;
1133         am_ops *pt;
1134         char **sp = rvec;
1135         while (*sp) {           /* loop until you find something, if any */
1136           memset((char *) &ap, 0, sizeof(am_opts));
1137           pt = ops_match(&ap, *sp, "", mp->am_path, "/defaults",
1138                          mp->am_parent->am_mnt->mf_info);
1139           free_opts(&ap);       /* don't leak */
1140           if (pt == &amfs_error_ops) {
1141             plog(XLOG_MAP, "failed to match defaults for \"%s\"", *sp);
1142           } else {
1143             dfl = strip_selectors(*sp, "/defaults");
1144             plog(XLOG_MAP, "matched default selectors \"%s\"", dfl);
1145             break;
1146           }
1147           ++sp;
1148         }
1149       }
1150     } else {                    /* not enable_default_selectors */
1151       /*
1152        * Extract first value
1153        */
1154       dfl = rvec[0];
1155     }
1156
1157     /*
1158      * If there were any values at all...
1159      */
1160     if (dfl) {
1161       /*
1162        * Log error if there were other values
1163        */
1164       if (!(gopt.flags & CFM_ENABLE_DEFAULT_SELECTORS) && rvec[1]) {
1165 # ifdef DEBUG
1166         dlog("/defaults chopped into %s", dfl);
1167 # endif /* DEBUG */
1168         plog(XLOG_USER, "More than a single value for /defaults in %s", mf->mf_info);
1169       }
1170
1171       /*
1172        * Prepend to existing defaults if they exist,
1173        * otherwise just use these defaults.
1174        */
1175       if (*auto_opts && *dfl) {
1176         char *nopts = (char *) xmalloc(strlen(auto_opts) + strlen(dfl) + 2);
1177         sprintf(nopts, "%s;%s", dfl, auto_opts);
1178         XFREE(auto_opts);
1179         auto_opts = nopts;
1180       } else if (*dfl) {
1181         auto_opts = strealloc(auto_opts, dfl);
1182       }
1183     }
1184     XFREE(dflts);
1185     /*
1186      * Don't need info vector any more
1187      */
1188     XFREE(rvec);
1189   }
1190
1191   /*
1192    * Fill it in
1193    */
1194   init_map(new_mp, fname);
1195
1196   /*
1197    * Turn on autofs flag if needed.
1198    */
1199   if (mp->am_flags & AMF_AUTOFS) {
1200     new_mp->am_flags |= AMF_AUTOFS;
1201   }
1202
1203   /*
1204    * Put it in the table
1205    */
1206   insert_am(new_mp, mp);
1207
1208   /*
1209    * Fill in some other fields,
1210    * path and mount point.
1211    *
1212    * bugfix: do not prepend old am_path if direct map
1213    *         <wls@astro.umd.edu> William Sebok
1214    */
1215
1216   strcpy(apath, fname);
1217   strcat(apath, " ");
1218   new_mp->am_path = str3cat(new_mp->am_path,
1219                             mf->mf_ops == &amfs_direct_ops ? "" : mp->am_path,
1220                             *fname == '/' ? "" : "/",
1221                             apath);
1222
1223 #ifdef DEBUG
1224   dlog("setting path to \"%s\"", new_mp->am_path);
1225 #endif /* DEBUG */
1226
1227   /*
1228    * Take private copy of pfname
1229    */
1230   pfname = strdup(pfname);
1231
1232   /*
1233    * Construct a continuation
1234    */
1235   cp = ALLOC(struct continuation);
1236   cp->callout = 0;
1237   cp->mp = new_mp;
1238   cp->xivec = xivec;
1239   cp->ivec = ivec;
1240   cp->info = info;
1241   cp->key = pfname;
1242   cp->auto_opts = auto_opts;
1243   cp->retry = FALSE;
1244   cp->tried = FALSE;
1245   cp->start = clocktime();
1246   cp->def_opts = strdup(auto_opts);
1247   memset((voidp) &cp->fs_opts, 0, sizeof(cp->fs_opts));
1248
1249   /*
1250    * Try and mount the file system.  If this succeeds immediately (possible
1251    * for a ufs file system) then return the attributes, otherwise just
1252    * return an error.
1253    */
1254   error = autofs_bgmount(cp, error);
1255   reschedule_timeout_mp();
1256   if (!error) {
1257     XFREE(fname);
1258     return new_mp;
1259   }
1260
1261   /*
1262    * Code for quick reply.  If nfs_program_2_transp is set, then
1263    * its the transp that's been passed down from nfs_program_2().
1264    * If new_mp->am_transp is not already set, set it by copying in
1265    * nfs_program_2_transp.  Once am_transp is set, quick_reply() can
1266    * use it to send a reply to the client that requested this mount.
1267    */
1268   if (nfs_program_2_transp && !new_mp->am_transp) {
1269     new_mp->am_transp = (SVCXPRT *) xmalloc(sizeof(SVCXPRT));
1270     *(new_mp->am_transp) = *nfs_program_2_transp;
1271   }
1272   if (error && (new_mp->am_mnt->mf_ops == &amfs_error_ops))
1273     new_mp->am_error = error;
1274
1275   assign_error_mntfs(new_mp);
1276
1277   XFREE(fname);
1278
1279   ereturn(error);
1280 }
1281 #endif /* HAVE_FS_AUTOFS */