contrib/amd/amd/ops_nfs.c

   1 /*
   2  * Copyright (c) 1997-2006 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  *
  40  * File: am-utils/amd/ops_nfs.c
  41  *
  42  */
  43
  44 /*
  45  * Network file system
  46  */
  47
  48 #ifdef HAVE_CONFIG_H
  49 # include <config.h>
  50 #endif /* HAVE_CONFIG_H */
  51 #include <am_defs.h>
  52 #include <amd.h>
  53
  54 /*
  55  * Convert from nfsstat to UN*X error code
  56  */
  57 #define unx_error(e)    ((int)(e))
  58
  59 /*
  60  * FH_TTL is the time a file handle will remain in the cache since
  61  * last being used.  If the file handle becomes invalid, then it
  62  * will be flushed anyway.
  63  */
  64 #define FH_TTL                  (5 * 60) /* five minutes */
  65 #define FH_TTL_ERROR            (30) /* 30 seconds */
  66 #define FHID_ALLOC()            (++fh_id)
  67
  68 /*
  69  * The NFS layer maintains a cache of file handles.
  70  * This is *fundamental* to the implementation and
  71  * also allows quick remounting when a filesystem
  72  * is accessed soon after timing out.
  73  *
  74  * The NFS server layer knows to flush this cache
  75  * when a server goes down so avoiding stale handles.
  76  *
  77  * Each cache entry keeps a hard reference to
  78  * the corresponding server.  This ensures that
  79  * the server keepalive information is maintained.
  80  *
  81  * The copy of the sockaddr_in here is taken so
  82  * that the port can be twiddled to talk to mountd
  83  * instead of portmap or the NFS server as used
  84  * elsewhere.
  85  * The port# is flushed if a server goes down.
  86  * The IP address is never flushed - we assume
  87  * that the address of a mounted machine never
  88  * changes.  If it does, then you have other
  89  * problems...
  90  */
  91 typedef struct fh_cache fh_cache;
  92 struct fh_cache {
  93   qelem                 fh_q;           /* List header */
  94   wchan_t               fh_wchan;       /* Wait channel */
  95   int                   fh_error;       /* Valid data? */
  96   int                   fh_id;          /* Unique id */
  97   int                   fh_cid;         /* Callout id */
  98   u_long                fh_nfs_version; /* highest NFS version on host */
  99   am_nfs_handle_t       fh_nfs_handle;  /* Handle on filesystem */
 100   int                   fh_status;      /* Status of last rpc */
 101   struct sockaddr_in    fh_sin;         /* Address of mountd */
 102   fserver               *fh_fs;         /* Server holding filesystem */
 103   char                  *fh_path;       /* Filesystem on host */
 104 };
 105
 106 /* forward definitions */
 107 static int nfs_init(mntfs *mf);
 108 static char *nfs_match(am_opts *fo);
 109 static int nfs_mount(am_node *am, mntfs *mf);
 110 static int nfs_umount(am_node *am, mntfs *mf);
 111 static void nfs_umounted(mntfs *mf);
 112 static int call_mountd(fh_cache *fp, u_long proc, fwd_fun f, wchan_t wchan);
 113 static int webnfs_lookup(fh_cache *fp, fwd_fun f, wchan_t wchan);
 114 static int fh_id = 0;
 115
 116 /* globals */
 117 AUTH *nfs_auth;
 118 qelem fh_head = {&fh_head, &fh_head};
 119
 120 /*
 121  * Network file system operations
 122  */
 123 am_ops nfs_ops =
 124 {
 125   "nfs",
 126   nfs_match,
 127   nfs_init,
 128   nfs_mount,
 129   nfs_umount,
 130   amfs_error_lookup_child,
 131   amfs_error_mount_child,
 132   amfs_error_readdir,
 133   0,                            /* nfs_readlink */
 134   0,                            /* nfs_mounted */
 135   nfs_umounted,
 136   find_nfs_srvr,
 137   0,                            /* nfs_get_wchan */
 138   FS_MKMNT | FS_BACKGROUND | FS_AMQINFO,        /* nfs_fs_flags */
 139 #ifdef HAVE_FS_AUTOFS
 140   AUTOFS_NFS_FS_FLAGS,
 141 #endif /* HAVE_FS_AUTOFS */
 142 };
 143
 144
 145 static fh_cache *
 146 find_nfs_fhandle_cache(opaque_t arg, int done)
 147 {
 148   fh_cache *fp, *fp2 = 0;
 149   int id = (long) arg;          /* for 64-bit archs */
 150
 151   ITER(fp, fh_cache, &fh_head) {
 152     if (fp->fh_id == id) {
 153       fp2 = fp;
 154       break;
 155     }
 156   }
 157
 158   if (fp2) {
 159     dlog("fh cache gives fp %#lx, fs %s", (unsigned long) fp2, fp2->fh_path);
 160   } else {
 161     dlog("fh cache search failed");
 162   }
 163
 164   if (fp2 && !done) {
 165     fp2->fh_error = ETIMEDOUT;
 166     return 0;
 167   }
 168
 169   return fp2;
 170 }
 171
 172
 173 /*
 174  * Called when a filehandle appears via the mount protocol
 175  */
 176 static void
 177 got_nfs_fh_mount(voidp pkt, int len, struct sockaddr_in *sa, struct sockaddr_in *ia, opaque_t arg, int done)
 178 {
 179   fh_cache *fp;
 180   struct fhstatus res;
 181 #ifdef HAVE_FS_NFS3
 182   struct am_mountres3 res3;
 183 #endif /* HAVE_FS_NFS3 */
 184
 185   fp = find_nfs_fhandle_cache(arg, done);
 186   if (!fp)
 187     return;
 188
 189   /*
 190    * retrieve the correct RPC reply for the file handle, based on the
 191    * NFS protocol version.
 192    */
 193 #ifdef HAVE_FS_NFS3
 194   if (fp->fh_nfs_version == NFS_VERSION3) {
 195     memset(&res3, 0, sizeof(res3));
 196     fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res3,
 197                                     (XDRPROC_T_TYPE) xdr_am_mountres3);
 198     fp->fh_status = unx_error(res3.fhs_status);
 199     memset(&fp->fh_nfs_handle.v3, 0, sizeof(am_nfs_fh3));
 200     fp->fh_nfs_handle.v3.am_fh3_length = res3.mountres3_u.mountinfo.fhandle.fhandle3_len;
 201     memmove(fp->fh_nfs_handle.v3.am_fh3_data,
 202             res3.mountres3_u.mountinfo.fhandle.fhandle3_val,
 203             fp->fh_nfs_handle.v3.am_fh3_length);
 204   } else {
 205 #endif /* HAVE_FS_NFS3 */
 206     memset(&res, 0, sizeof(res));
 207     fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res,
 208                                     (XDRPROC_T_TYPE) xdr_fhstatus);
 209     fp->fh_status = unx_error(res.fhs_status);
 210     memmove(&fp->fh_nfs_handle.v2, &res.fhs_fh, NFS_FHSIZE);
 211 #ifdef HAVE_FS_NFS3
 212   }
 213 #endif /* HAVE_FS_NFS3 */
 214
 215   if (!fp->fh_error) {
 216     dlog("got filehandle for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
 217   } else {
 218     plog(XLOG_USER, "filehandle denied for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
 219     /*
 220      * Force the error to be EACCES. It's debatable whether it should be
 221      * ENOENT instead, but the server really doesn't give us any clues, and
 222      * EACCES is more in line with the "filehandle denied" message.
 223      */
 224     fp->fh_error = EACCES;
 225   }
 226
 227   /*
 228    * Wakeup anything sleeping on this filehandle
 229    */
 230   if (fp->fh_wchan) {
 231     dlog("Calling wakeup on %#lx", (unsigned long) fp->fh_wchan);
 232     wakeup(fp->fh_wchan);
 233   }
 234 }
 235
 236
 237 /*
 238  * Called when a filehandle appears via WebNFS
 239  */
 240 static void
 241 got_nfs_fh_webnfs(voidp pkt, int len, struct sockaddr_in *sa, struct sockaddr_in *ia, opaque_t arg, int done)
 242 {
 243   fh_cache *fp;
 244   nfsdiropres res;
 245 #ifdef HAVE_FS_NFS3
 246   am_LOOKUP3res res3;
 247 #endif /* HAVE_FS_NFS3 */
 248
 249   fp = find_nfs_fhandle_cache(arg, done);
 250   if (!fp)
 251     return;
 252
 253   /*
 254    * retrieve the correct RPC reply for the file handle, based on the
 255    * NFS protocol version.
 256    */
 257 #ifdef HAVE_FS_NFS3
 258   if (fp->fh_nfs_version == NFS_VERSION3) {
 259     memset(&res3, 0, sizeof(res3));
 260     fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res3,
 261                                     (XDRPROC_T_TYPE) xdr_am_LOOKUP3res);
 262     fp->fh_status = unx_error(res3.status);
 263     memset(&fp->fh_nfs_handle.v3, 0, sizeof(am_nfs_fh3));
 264     fp->fh_nfs_handle.v3.am_fh3_length = res3.res_u.ok.object.am_fh3_length;
 265     memmove(fp->fh_nfs_handle.v3.am_fh3_data,
 266             res3.res_u.ok.object.am_fh3_data,
 267             fp->fh_nfs_handle.v3.am_fh3_length);
 268   } else {
 269 #endif /* HAVE_FS_NFS3 */
 270     memset(&res, 0, sizeof(res));
 271     fp->fh_error = pickup_rpc_reply(pkt, len, (voidp) &res,
 272                                     (XDRPROC_T_TYPE) xdr_diropres);
 273     fp->fh_status = unx_error(res.dr_status);
 274     memmove(&fp->fh_nfs_handle.v2, &res.dr_u.dr_drok_u.drok_fhandle, NFS_FHSIZE);
 275 #ifdef HAVE_FS_NFS3
 276   }
 277 #endif /* HAVE_FS_NFS3 */
 278
 279   if (!fp->fh_error) {
 280     dlog("got filehandle for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
 281   } else {
 282     plog(XLOG_USER, "filehandle denied for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
 283     /*
 284      * Force the error to be EACCES. It's debatable whether it should be
 285      * ENOENT instead, but the server really doesn't give us any clues, and
 286      * EACCES is more in line with the "filehandle denied" message.
 287      */
 288     fp->fh_error = EACCES;
 289   }
 290
 291   /*
 292    * Wakeup anything sleeping on this filehandle
 293    */
 294   if (fp->fh_wchan) {
 295     dlog("Calling wakeup on %#lx", (unsigned long) fp->fh_wchan);
 296     wakeup(fp->fh_wchan);
 297   }
 298 }
 299
 300
 301 void
 302 flush_nfs_fhandle_cache(fserver *fs)
 303 {
 304   fh_cache *fp;
 305
 306   ITER(fp, fh_cache, &fh_head) {
 307     if (fp->fh_fs == fs || fs == NULL) {
 308       /*
 309        * Only invalidate port info for non-WebNFS servers
 310        */
 311       if (!(fp->fh_fs->fs_flags & FSF_WEBNFS))
 312         fp->fh_sin.sin_port = (u_short) 0;
 313       fp->fh_error = -1;
 314     }
 315   }
 316 }
 317
 318
 319 static void
 320 discard_fh(opaque_t arg)
 321 {
 322   fh_cache *fp = (fh_cache *) arg;
 323
 324   rem_que(&fp->fh_q);
 325   if (fp->fh_fs) {
 326     dlog("Discarding filehandle for %s:%s", fp->fh_fs->fs_host, fp->fh_path);
 327     free_srvr(fp->fh_fs);
 328   }
 329   if (fp->fh_path)
 330     XFREE(fp->fh_path);
 331   XFREE(fp);
 332 }
 333
 334
 335 /*
 336  * Determine the file handle for a node
 337  */
 338 static int
 339 prime_nfs_fhandle_cache(char *path, fserver *fs, am_nfs_handle_t *fhbuf, mntfs *mf)
 340 {
 341   fh_cache *fp, *fp_save = 0;
 342   int error;
 343   int reuse_id = FALSE;
 344
 345   dlog("Searching cache for %s:%s", fs->fs_host, path);
 346
 347   /*
 348    * First search the cache
 349    */
 350   ITER(fp, fh_cache, &fh_head) {
 351     if (fs != fp->fh_fs  ||  !STREQ(path, fp->fh_path))
 352       continue;                 /* skip to next ITER item */
 353     /* else we got a match */
 354     switch (fp->fh_error) {
 355     case 0:
 356       plog(XLOG_INFO, "prime_nfs_fhandle_cache: NFS version %d", (int) fp->fh_nfs_version);
 357
 358       error = fp->fh_error = fp->fh_status;
 359
 360       if (error == 0) {
 361         if (mf->mf_flags & MFF_NFS_SCALEDOWN) {
 362           fp_save = fp;
 363           /* XXX: why reuse the ID? */
 364           reuse_id = TRUE;
 365           break;
 366         }
 367
 368         if (fhbuf) {
 369 #ifdef HAVE_FS_NFS3
 370           if (fp->fh_nfs_version == NFS_VERSION3) {
 371             memmove((voidp) &(fhbuf->v3), (voidp) &(fp->fh_nfs_handle.v3),
 372                     sizeof(fp->fh_nfs_handle.v3));
 373           } else
 374 #endif /* HAVE_FS_NFS3 */
 375             {
 376               memmove((voidp) &(fhbuf->v2), (voidp) &(fp->fh_nfs_handle.v2),
 377                       sizeof(fp->fh_nfs_handle.v2));
 378             }
 379         }
 380         if (fp->fh_cid)
 381           untimeout(fp->fh_cid);
 382         fp->fh_cid = timeout(FH_TTL, discard_fh, (opaque_t) fp);
 383       } else if (error == EACCES) {
 384         /*
 385          * Now decode the file handle return code.
 386          */
 387         plog(XLOG_INFO, "Filehandle denied for \"%s:%s\"",
 388              fs->fs_host, path);
 389       } else {
 390         errno = error;  /* XXX */
 391         plog(XLOG_INFO, "Filehandle error for \"%s:%s\": %m",
 392              fs->fs_host, path);
 393       }
 394
 395       /*
 396        * The error was returned from the remote mount daemon.
 397        * Policy: this error will be cached for now...
 398        */
 399       return error;
 400
 401     case -1:
 402       /*
 403        * Still thinking about it, but we can re-use.
 404        */
 405       fp_save = fp;
 406       reuse_id = TRUE;
 407       break;
 408
 409     default:
 410       /*
 411        * Return the error.
 412        * Policy: make sure we recompute if required again
 413        * in case this was caused by a network failure.
 414        * This can thrash mountd's though...  If you find
 415        * your mountd going slowly then:
 416        * 1.  Add a fork() loop to main.
 417        * 2.  Remove the call to innetgr() and don't use
 418        *     netgroups, especially if you don't use YP.
 419        */
 420       error = fp->fh_error;
 421       fp->fh_error = -1;
 422       return error;
 423     }   /* end of switch statement */
 424   } /* end of ITER loop */
 425
 426   /*
 427    * Not in cache
 428    */
 429   if (fp_save) {
 430     fp = fp_save;
 431     /*
 432      * Re-use existing slot
 433      */
 434     untimeout(fp->fh_cid);
 435     free_srvr(fp->fh_fs);
 436     XFREE(fp->fh_path);
 437   } else {
 438     fp = ALLOC(struct fh_cache);
 439     memset((voidp) fp, 0, sizeof(struct fh_cache));
 440     ins_que(&fp->fh_q, &fh_head);
 441   }
 442   if (!reuse_id)
 443     fp->fh_id = FHID_ALLOC();
 444   fp->fh_wchan = get_mntfs_wchan(mf);
 445   fp->fh_error = -1;
 446   fp->fh_cid = timeout(FH_TTL, discard_fh, (opaque_t) fp);
 447
 448   /*
 449    * If fs->fs_ip is null, remote server is probably down.
 450    */
 451   if (!fs->fs_ip) {
 452     /* Mark the fileserver down and invalid again */
 453     fs->fs_flags &= ~FSF_VALID;
 454     fs->fs_flags |= FSF_DOWN;
 455     error = AM_ERRNO_HOST_DOWN;
 456     return error;
 457   }
 458
 459   /*
 460    * Either fp has been freshly allocated or the address has changed.
 461    * Initialize address and nfs version.  Don't try to re-use the port
 462    * information unless using WebNFS where the port is fixed either by
 463    * the spec or the "port" mount option.
 464    */
 465   if (fp->fh_sin.sin_addr.s_addr != fs->fs_ip->sin_addr.s_addr) {
 466     fp->fh_sin = *fs->fs_ip;
 467     if (!(mf->mf_flags & MFF_WEBNFS))
 468         fp->fh_sin.sin_port = 0;
 469     fp->fh_nfs_version = fs->fs_version;
 470   }
 471
 472   fp->fh_fs = dup_srvr(fs);
 473   fp->fh_path = strdup(path);
 474
 475   if (mf->mf_flags & MFF_WEBNFS)
 476     error = webnfs_lookup(fp, got_nfs_fh_webnfs, get_mntfs_wchan(mf));
 477   else
 478     error = call_mountd(fp, MOUNTPROC_MNT, got_nfs_fh_mount, get_mntfs_wchan(mf));
 479   if (error) {
 480     /*
 481      * Local error - cache for a short period
 482      * just to prevent thrashing.
 483      */
 484     untimeout(fp->fh_cid);
 485     fp->fh_cid = timeout(error < 0 ? 2 * ALLOWED_MOUNT_TIME : FH_TTL_ERROR,
 486                          discard_fh, (opaque_t) fp);
 487     fp->fh_error = error;
 488   } else {
 489     error = fp->fh_error;
 490   }
 491
 492   return error;
 493 }
 494
 495
 496 int
 497 make_nfs_auth(void)
 498 {
 499   AUTH_CREATE_GIDLIST_TYPE group_wheel = 0;
 500
 501   /* Some NFS mounts (particularly cross-domain) require FQDNs to succeed */
 502
 503 #ifdef HAVE_TRANSPORT_TYPE_TLI
 504   if (gopt.flags & CFM_FULLY_QUALIFIED_HOSTS) {
 505     plog(XLOG_INFO, "Using NFS auth for FQHN \"%s\"", hostd);
 506     nfs_auth = authsys_create(hostd, 0, 0, 1, &group_wheel);
 507   } else {
 508     nfs_auth = authsys_create_default();
 509   }
 510 #else /* not HAVE_TRANSPORT_TYPE_TLI */
 511   if (gopt.flags & CFM_FULLY_QUALIFIED_HOSTS) {
 512     plog(XLOG_INFO, "Using NFS auth for FQHN \"%s\"", hostd);
 513     nfs_auth = authunix_create(hostd, 0, 0, 1, &group_wheel);
 514   } else {
 515     nfs_auth = authunix_create_default();
 516   }
 517 #endif /* not HAVE_TRANSPORT_TYPE_TLI */
 518
 519   if (!nfs_auth)
 520     return ENOBUFS;
 521
 522   return 0;
 523 }
 524
 525
 526 static int
 527 call_mountd(fh_cache *fp, u_long proc, fwd_fun fun, wchan_t wchan)
 528 {
 529   struct rpc_msg mnt_msg;
 530   int len;
 531   char iobuf[UDPMSGSIZE];
 532   int error;
 533   u_long mnt_version;
 534
 535   if (!nfs_auth) {
 536     error = make_nfs_auth();
 537     if (error)
 538       return error;
 539   }
 540
 541   if (fp->fh_sin.sin_port == 0) {
 542     u_short mountd_port;
 543     error = get_mountd_port(fp->fh_fs, &mountd_port, wchan);
 544     if (error)
 545       return error;
 546     fp->fh_sin.sin_port = mountd_port;
 547   }
 548
 549   /* find the right version of the mount protocol */
 550 #ifdef HAVE_FS_NFS3
 551   if (fp->fh_nfs_version == NFS_VERSION3)
 552     mnt_version = AM_MOUNTVERS3;
 553   else
 554 #endif /* HAVE_FS_NFS3 */
 555     mnt_version = MOUNTVERS;
 556   plog(XLOG_INFO, "call_mountd: NFS version %d, mount version %d",
 557        (int) fp->fh_nfs_version, (int) mnt_version);
 558
 559   rpc_msg_init(&mnt_msg, MOUNTPROG, mnt_version, MOUNTPROC_NULL);
 560   len = make_rpc_packet(iobuf,
 561                         sizeof(iobuf),
 562                         proc,
 563                         &mnt_msg,
 564                         (voidp) &fp->fh_path,
 565                         (XDRPROC_T_TYPE) xdr_nfspath,
 566                         nfs_auth);
 567
 568   if (len > 0) {
 569     error = fwd_packet(MK_RPC_XID(RPC_XID_MOUNTD, fp->fh_id),
 570                        iobuf,
 571                        len,
 572                        &fp->fh_sin,
 573                        &fp->fh_sin,
 574                        (opaque_t) ((long) fp->fh_id), /* cast to long needed for 64-bit archs */
 575                        fun);
 576   } else {
 577     error = -len;
 578   }
 579
 580   /*
 581    * It may be the case that we're sending to the wrong MOUNTD port.  This
 582    * occurs if mountd is restarted on the server after the port has been
 583    * looked up and stored in the filehandle cache somewhere.  The correct
 584    * solution, if we're going to cache port numbers is to catch the ICMP
 585    * port unreachable reply from the server and cause the portmap request
 586    * to be redone.  The quick solution here is to invalidate the MOUNTD
 587    * port.
 588    */
 589   fp->fh_sin.sin_port = 0;
 590
 591   return error;
 592 }
 593
 594
 595 static int
 596 webnfs_lookup(fh_cache *fp, fwd_fun fun, wchan_t wchan)
 597 {
 598   struct rpc_msg wnfs_msg;
 599   int len;
 600   char iobuf[UDPMSGSIZE];
 601   int error;
 602   u_long proc;
 603   XDRPROC_T_TYPE xdr_fn;
 604   voidp argp;
 605   nfsdiropargs args;
 606 #ifdef HAVE_FS_NFS3
 607   am_LOOKUP3args args3;
 608 #endif
 609   char *wnfs_path;
 610   size_t l;
 611
 612   if (!nfs_auth) {
 613     error = make_nfs_auth();
 614     if (error)
 615       return error;
 616   }
 617
 618   if (fp->fh_sin.sin_port == 0) {
 619     /* FIXME: wrong, don't discard sin_port in the first place for WebNFS. */
 620     plog(XLOG_WARNING, "webnfs_lookup: port == 0 for nfs on %s, fixed",
 621          fp->fh_fs->fs_host);
 622     fp->fh_sin.sin_port = htons(NFS_PORT);
 623   }
 624
 625   /*
 626    * Use native path like the rest of amd (cf. RFC 2054, 6.1).
 627    */
 628   l = strlen(fp->fh_path) + 2;
 629   wnfs_path = (char *) xmalloc(l);
 630   wnfs_path[0] = 0x80;
 631   xstrlcpy(wnfs_path + 1, fp->fh_path, l - 1);
 632
 633   /* find the right program and lookup procedure */
 634 #ifdef HAVE_FS_NFS3
 635   if (fp->fh_nfs_version == NFS_VERSION3) {
 636     proc = AM_NFSPROC3_LOOKUP;
 637     xdr_fn = (XDRPROC_T_TYPE) xdr_am_LOOKUP3args;
 638     argp = &args3;
 639     /* WebNFS public file handle */
 640     args3.what.dir.am_fh3_length = 0;
 641     args3.what.name = wnfs_path;
 642   } else {
 643 #endif /* HAVE_FS_NFS3 */
 644     proc = NFSPROC_LOOKUP;
 645     xdr_fn = (XDRPROC_T_TYPE) xdr_diropargs;
 646     argp = &args;
 647     /* WebNFS public file handle */
 648     memset(&args.da_fhandle, 0, NFS_FHSIZE);
 649     args.da_name = wnfs_path;
 650 #ifdef HAVE_FS_NFS3
 651   }
 652 #endif /* HAVE_FS_NFS3 */
 653
 654   plog(XLOG_INFO, "webnfs_lookup: NFS version %d", (int) fp->fh_nfs_version);
 655
 656   rpc_msg_init(&wnfs_msg, NFS_PROGRAM, fp->fh_nfs_version, proc);
 657   len = make_rpc_packet(iobuf,
 658                         sizeof(iobuf),
 659                         proc,
 660                         &wnfs_msg,
 661                         argp,
 662                         (XDRPROC_T_TYPE) xdr_fn,
 663                         nfs_auth);
 664
 665   if (len > 0) {
 666     error = fwd_packet(MK_RPC_XID(RPC_XID_WEBNFS, fp->fh_id),
 667                        iobuf,
 668                        len,
 669                        &fp->fh_sin,
 670                        &fp->fh_sin,
 671                        (opaque_t) ((long) fp->fh_id), /* cast to long needed for 64-bit archs */
 672                        fun);
 673   } else {
 674     error = -len;
 675   }
 676
 677   XFREE(wnfs_path);
 678   return error;
 679 }
 680
 681
 682 /*
 683  * NFS needs the local filesystem, remote filesystem
 684  * remote hostname.
 685  * Local filesystem defaults to remote and vice-versa.
 686  */
 687 static char *
 688 nfs_match(am_opts *fo)
 689 {
 690   char *xmtab;
 691   size_t l;
 692
 693   if (fo->opt_fs && !fo->opt_rfs)
 694     fo->opt_rfs = fo->opt_fs;
 695   if (!fo->opt_rfs) {
 696     plog(XLOG_USER, "nfs: no remote filesystem specified");
 697     return NULL;
 698   }
 699   if (!fo->opt_rhost) {
 700     plog(XLOG_USER, "nfs: no remote host specified");
 701     return NULL;
 702   }
 703
 704   /*
 705    * Determine magic cookie to put in mtab
 706    */
 707   l = strlen(fo->opt_rhost) + strlen(fo->opt_rfs) + 2;
 708   xmtab = (char *) xmalloc(l);
 709   xsnprintf(xmtab, l, "%s:%s", fo->opt_rhost, fo->opt_rfs);
 710   dlog("NFS: mounting remote server \"%s\", remote fs \"%s\" on \"%s\"",
 711        fo->opt_rhost, fo->opt_rfs, fo->opt_fs);
 712
 713   return xmtab;
 714 }
 715
 716
 717 /*
 718  * Initialize am structure for nfs
 719  */
 720 static int
 721 nfs_init(mntfs *mf)
 722 {
 723   int error;
 724   am_nfs_handle_t fhs;
 725   char *colon;
 726
 727   if (mf->mf_private) {
 728     if (mf->mf_flags & MFF_NFS_SCALEDOWN) {
 729       fserver *fs;
 730
 731       /* tell remote mountd that we're done with this filehandle */
 732       mf->mf_ops->umounted(mf);
 733
 734       mf->mf_prfree(mf->mf_private);
 735       fs = mf->mf_ops->ffserver(mf);
 736       free_srvr(mf->mf_server);
 737       mf->mf_server = fs;
 738     } else
 739       return 0;
 740   }
 741
 742   colon = strchr(mf->mf_info, ':');
 743   if (colon == 0)
 744     return ENOENT;
 745
 746   error = prime_nfs_fhandle_cache(colon + 1, mf->mf_server, &fhs, mf);
 747   if (!error) {
 748     mf->mf_private = (opaque_t) ALLOC(am_nfs_handle_t);
 749     mf->mf_prfree = (void (*)(opaque_t)) free;
 750     memmove(mf->mf_private, (voidp) &fhs, sizeof(fhs));
 751   }
 752   return error;
 753 }
 754
 755
 756 int
 757 mount_nfs_fh(am_nfs_handle_t *fhp, char *mntdir, char *fs_name, mntfs *mf)
 758 {
 759   MTYPE_TYPE type;
 760   char *colon;
 761   char *xopts=NULL, transp_timeo_opts[40], transp_retrans_opts[40];
 762   char host[MAXHOSTNAMELEN + MAXPATHLEN + 2];
 763   fserver *fs = mf->mf_server;
 764   u_long nfs_version = fs->fs_version;
 765   char *nfs_proto = fs->fs_proto; /* "tcp" or "udp" */
 766   int on_autofs = mf->mf_flags & MFF_ON_AUTOFS;
 767   int error;
 768   int genflags;
 769   int retry;
 770   int proto = AMU_TYPE_NONE;
 771   mntent_t mnt;
 772   nfs_args_t nfs_args;
 773
 774   /*
 775    * Extract HOST name to give to kernel.
 776    * Some systems like osf1/aix3/bsd44 variants may need old code
 777    * for NFS_ARGS_NEEDS_PATH.
 778    */
 779   if (!(colon = strchr(fs_name, ':')))
 780     return ENOENT;
 781 #ifdef MOUNT_TABLE_ON_FILE
 782   *colon = '\0';
 783 #endif /* MOUNT_TABLE_ON_FILE */
 784   xstrlcpy(host, fs_name, sizeof(host));
 785 #ifdef MOUNT_TABLE_ON_FILE
 786   *colon = ':';
 787 #endif /* MOUNT_TABLE_ON_FILE */
 788 #ifdef MAXHOSTNAMELEN
 789   /* most kernels have a name length restriction */
 790   if (strlen(host) >= MAXHOSTNAMELEN)
 791     xstrlcpy(host + MAXHOSTNAMELEN - 3, "..",
 792              sizeof(host) - MAXHOSTNAMELEN + 3);
 793 #endif /* MAXHOSTNAMELEN */
 794
 795   /*
 796    * Create option=VAL for udp/tcp specific timeouts and retrans values, but
 797    * only if these options were specified.
 798    */
 799
 800   transp_timeo_opts[0] = transp_retrans_opts[0] = '\0'; /* initialize */
 801   if (STREQ(nfs_proto, "udp"))
 802     proto = AMU_TYPE_UDP;
 803   else if (STREQ(nfs_proto, "tcp"))
 804     proto = AMU_TYPE_TCP;
 805   if (proto != AMU_TYPE_NONE) {
 806     if (gopt.amfs_auto_timeo[proto] > 0)
 807       xsnprintf(transp_timeo_opts, sizeof(transp_timeo_opts), "%s=%d,",
 808                 MNTTAB_OPT_TIMEO, gopt.amfs_auto_timeo[proto]);
 809     if (gopt.amfs_auto_retrans[proto] > 0)
 810       xsnprintf(transp_retrans_opts, sizeof(transp_retrans_opts), "%s=%d,",
 811                 MNTTAB_OPT_RETRANS, gopt.amfs_auto_retrans[proto]);
 812   }
 813
 814   if (mf->mf_remopts && *mf->mf_remopts &&
 815       !islocalnet(fs->fs_ip->sin_addr.s_addr)) {
 816     plog(XLOG_INFO, "Using remopts=\"%s\"", mf->mf_remopts);
 817     /* use transp_opts first, so map-specific opts will override */
 818     xopts = str3cat(xopts, transp_timeo_opts, transp_retrans_opts, mf->mf_remopts);
 819   } else {
 820     /* use transp_opts first, so map-specific opts will override */
 821     xopts = str3cat(xopts, transp_timeo_opts, transp_retrans_opts, mf->mf_mopts);
 822   }
 823
 824   memset((voidp) &mnt, 0, sizeof(mnt));
 825   mnt.mnt_dir = mntdir;
 826   mnt.mnt_fsname = fs_name;
 827   mnt.mnt_opts = xopts;
 828
 829   /*
 830    * Set mount types accordingly
 831    */
 832 #ifndef HAVE_FS_NFS3
 833   type = MOUNT_TYPE_NFS;
 834   mnt.mnt_type = MNTTAB_TYPE_NFS;
 835 #else /* HAVE_FS_NFS3 */
 836   if (nfs_version == NFS_VERSION3) {
 837     type = MOUNT_TYPE_NFS3;
 838     /*
 839      * Systems that include the mount table "vers" option generally do not
 840      * set the mnttab entry to "nfs3", but to "nfs" and then they set
 841      * "vers=3".  Setting it to "nfs3" works, but it may break some things
 842      * like "df -t nfs" and the "quota" program (esp. on Solaris and Irix).
 843      * So on those systems, set it to "nfs".
 844      * Note: MNTTAB_OPT_VERS is always set for NFS3 (see am_compat.h).
 845      */
 846 # if defined(MNTTAB_OPT_VERS) && defined(MOUNT_TABLE_ON_FILE)
 847     mnt.mnt_type = MNTTAB_TYPE_NFS;
 848 # else /* defined(MNTTAB_OPT_VERS) && defined(MOUNT_TABLE_ON_FILE) */
 849     mnt.mnt_type = MNTTAB_TYPE_NFS3;
 850 # endif /* defined(MNTTAB_OPT_VERS) && defined(MOUNT_TABLE_ON_FILE) */
 851   } else {
 852     type = MOUNT_TYPE_NFS;
 853     mnt.mnt_type = MNTTAB_TYPE_NFS;
 854   }
 855 #endif /* HAVE_FS_NFS3 */
 856   plog(XLOG_INFO, "mount_nfs_fh: NFS version %d", (int) nfs_version);
 857   plog(XLOG_INFO, "mount_nfs_fh: using NFS transport %s", nfs_proto);
 858
 859   retry = hasmntval(&mnt, MNTTAB_OPT_RETRY);
 860   if (retry <= 0)
 861     retry = 1;                  /* XXX */
 862
 863   genflags = compute_mount_flags(&mnt);
 864 #ifdef HAVE_FS_AUTOFS
 865   if (on_autofs)
 866     genflags |= autofs_compute_mount_flags(&mnt);
 867 #endif /* HAVE_FS_AUTOFS */
 868
 869   /* setup the many fields and flags within nfs_args */
 870   compute_nfs_args(&nfs_args,
 871                    &mnt,
 872                    genflags,
 873                    NULL,        /* struct netconfig *nfsncp */
 874                    fs->fs_ip,
 875                    nfs_version,
 876                    nfs_proto,
 877                    fhp,
 878                    host,
 879                    fs_name);
 880
 881   /* finally call the mounting function */
 882   if (amuDebug(D_TRACE)) {
 883     print_nfs_args(&nfs_args, nfs_version);
 884     plog(XLOG_DEBUG, "Generic mount flags 0x%x used for NFS mount", genflags);
 885   }
 886   error = mount_fs(&mnt, genflags, (caddr_t) &nfs_args, retry, type,
 887                     nfs_version, nfs_proto, mnttab_file_name, on_autofs);
 888   XFREE(xopts);
 889
 890 #ifdef HAVE_TRANSPORT_TYPE_TLI
 891   free_knetconfig(nfs_args.knconf);
 892   if (nfs_args.addr)
 893     XFREE(nfs_args.addr);       /* allocated in compute_nfs_args() */
 894 #endif /* HAVE_TRANSPORT_TYPE_TLI */
 895
 896   return error;
 897 }
 898
 899
 900 static int
 901 nfs_mount(am_node *am, mntfs *mf)
 902 {
 903   int error = 0;
 904   mntent_t mnt;
 905
 906   if (!mf->mf_private) {
 907     plog(XLOG_ERROR, "Missing filehandle for %s", mf->mf_info);
 908     return EINVAL;
 909   }
 910
 911   mnt.mnt_opts = mf->mf_mopts;
 912   if (amu_hasmntopt(&mnt, "softlookup") ||
 913       (amu_hasmntopt(&mnt, "soft") && !amu_hasmntopt(&mnt, "nosoftlookup")))
 914     am->am_flags |= AMF_SOFTLOOKUP;
 915
 916   error = mount_nfs_fh((am_nfs_handle_t *) mf->mf_private,
 917                        mf->mf_mount,
 918                        mf->mf_info,
 919                        mf);
 920
 921   if (error) {
 922     errno = error;
 923     dlog("mount_nfs: %m");
 924   }
 925
 926   return error;
 927 }
 928
 929
 930 static int
 931 nfs_umount(am_node *am, mntfs *mf)
 932 {
 933   int unmount_flags, new_unmount_flags, error;
 934
 935   unmount_flags = (mf->mf_flags & MFF_ON_AUTOFS) ? AMU_UMOUNT_AUTOFS : 0;
 936   error = UMOUNT_FS(mf->mf_mount, mnttab_file_name, unmount_flags);
 937
 938 #if defined(HAVE_UMOUNT2) && (defined(MNT2_GEN_OPT_FORCE) || defined(MNT2_GEN_OPT_DETACH))
 939   /*
 940    * If the attempt to unmount failed with EBUSY, and this fserver was
 941    * marked for forced unmounts, then use forced/lazy unmounts.
 942    */
 943   if (error == EBUSY &&
 944       gopt.flags & CFM_FORCED_UNMOUNTS &&
 945       mf->mf_server->fs_flags & FSF_FORCE_UNMOUNT) {
 946     plog(XLOG_INFO, "EZK: nfs_umount: trying forced/lazy unmounts");
 947     /*
 948      * XXX: turning off the FSF_FORCE_UNMOUNT may not be perfectly
 949      * incorrect.  Multiple nodes may need to be timed out and restarted for
 950      * a single hung fserver.
 951      */
 952     mf->mf_server->fs_flags &= ~FSF_FORCE_UNMOUNT;
 953     new_unmount_flags = unmount_flags | AMU_UMOUNT_FORCE | AMU_UMOUNT_DETACH;
 954     error = UMOUNT_FS(mf->mf_mount, mnttab_file_name, new_unmount_flags);
 955   }
 956 #endif /* HAVE_UMOUNT2 && (MNT2_GEN_OPT_FORCE || MNT2_GEN_OPT_DETACH) */
 957
 958   /*
 959    * Here is some code to unmount 'restarted' file systems.
 960    * The restarted file systems are marked as 'nfs', not
 961    * 'host', so we only have the map information for the
 962    * the top-level mount.  The unmount will fail (EBUSY)
 963    * if there are anything else from the NFS server mounted
 964    * below the mount-point.  This code checks to see if there
 965    * is anything mounted with the same prefix as the
 966    * file system to be unmounted ("/a/b/c" when unmounting "/a/b").
 967    * If there is, and it is a 'restarted' file system, we unmount
 968    * it.
 969    * Added by Mike Mitchell, mcm@unx.sas.com, 09/08/93
 970    */
 971   if (error == EBUSY) {
 972     mntfs *new_mf;
 973     int len = strlen(mf->mf_mount);
 974     int didsome = 0;
 975
 976     ITER(new_mf, mntfs, &mfhead) {
 977       if (new_mf->mf_ops != mf->mf_ops ||
 978           new_mf->mf_refc > 1 ||
 979           mf == new_mf ||
 980           ((new_mf->mf_flags & (MFF_MOUNTED | MFF_UNMOUNTING | MFF_RESTART)) == (MFF_MOUNTED | MFF_RESTART)))
 981         continue;
 982
 983       if (NSTREQ(mf->mf_mount, new_mf->mf_mount, len) &&
 984           new_mf->mf_mount[len] == '/') {
 985         new_unmount_flags =
 986           (new_mf->mf_flags & MFF_ON_AUTOFS) ? AMU_UMOUNT_AUTOFS : 0;
 987         UMOUNT_FS(new_mf->mf_mount, mnttab_file_name, new_unmount_flags);
 988         didsome = 1;
 989       }
 990     }
 991     if (didsome)
 992       error = UMOUNT_FS(mf->mf_mount, mnttab_file_name, unmount_flags);
 993   }
 994   if (error)
 995     return error;
 996
 997   return 0;
 998 }
 999
1000
1001 static void
1002 nfs_umounted(mntfs *mf)
1003 {
1004   fserver *fs;
1005   char *colon, *path;
1006
1007   if (mf->mf_error || mf->mf_refc > 1)
1008     return;
1009
1010   /*
1011    * No need to inform mountd when WebNFS is in use.
1012    */
1013   if (mf->mf_flags & MFF_WEBNFS)
1014     return;
1015
1016   /*
1017    * Call the mount daemon on the server to announce that we are not using
1018    * the fs any more.
1019    *
1020    * XXX: This is *wrong*.  The mountd should be called when the fhandle is
1021    * flushed from the cache, and a reference held to the cached entry while
1022    * the fs is mounted...
1023    */
1024   fs = mf->mf_server;
1025   colon = path = strchr(mf->mf_info, ':');
1026   if (fs && colon) {
1027     fh_cache f;
1028
1029     dlog("calling mountd for %s", mf->mf_info);
1030     *path++ = '\0';
1031     f.fh_path = path;
1032     f.fh_sin = *fs->fs_ip;
1033     f.fh_sin.sin_port = (u_short) 0;
1034     f.fh_nfs_version = fs->fs_version;
1035     f.fh_fs = fs;
1036     f.fh_id = 0;
1037     f.fh_error = 0;
1038     prime_nfs_fhandle_cache(colon + 1, mf->mf_server, (am_nfs_handle_t *) 0, mf);
1039     call_mountd(&f, MOUNTPROC_UMNT, (fwd_fun *) 0, (wchan_t) 0);
1040     *colon = ':';
1041   }
1042 }