contrib/amd/amd/nfs_subr.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: nfs_subr.c,v 1.3 1999/01/13 23:31:00 ezk Exp $
  42  *
  43  */
  44
  45 #ifdef HAVE_CONFIG_H
  46 # include <config.h>
  47 #endif /* HAVE_CONFIG_H */
  48 #include <am_defs.h>
  49 #include <amd.h>
  50
  51 /*
  52  * Convert from UN*X to NFS error code.
  53  * Some systems like linux define their own (see
  54  * conf/mount/mount_linux.h).
  55  */
  56 #ifndef nfs_error
  57 # define nfs_error(e) ((nfsstat)(e))
  58 #endif /* nfs_error */
  59
  60 /* forward declarations */
  61 static void count_map_entries(const am_node *mp, u_int *out_blocks, u_int *out_bfree, u_int *out_bavail);
  62
  63
  64 static char *
  65 do_readlink(am_node *mp, int *error_return, nfsattrstat **attrpp)
  66 {
  67   char *ln;
  68
  69   /*
  70    * If there is a readlink method, then use
  71    * that, otherwise if a link exists use
  72    * that, otherwise use the mount point.
  73    */
  74   if (mp->am_mnt->mf_ops->readlink) {
  75     int retry = 0;
  76     mp = (*mp->am_mnt->mf_ops->readlink) (mp, &retry);
  77     if (mp == 0) {
  78       *error_return = retry;
  79       return 0;
  80     }
  81     /* reschedule_timeout_mp(); */
  82   }
  83
  84   if (mp->am_link) {
  85     ln = mp->am_link;
  86   } else {
  87     ln = mp->am_mnt->mf_mount;
  88   }
  89   if (attrpp)
  90     *attrpp = &mp->am_attr;
  91
  92   return ln;
  93 }
  94
  95
  96 voidp
  97 nfsproc_null_2_svc(voidp argp, struct svc_req *rqstp)
  98 {
  99   static char res;
 100
 101   return (voidp) &res;
 102 }
 103
 104
 105 nfsattrstat *
 106 nfsproc_getattr_2_svc(am_nfs_fh *argp, struct svc_req *rqstp)
 107 {
 108   static nfsattrstat res;
 109   am_node *mp;
 110   int retry;
 111
 112 #ifdef DEBUG
 113   amuDebug(D_TRACE)
 114     plog(XLOG_DEBUG, "getattr:");
 115 #endif /* DEBUG */
 116
 117   mp = fh_to_mp2(argp, &retry);
 118   if (mp == 0) {
 119
 120 #ifdef DEBUG
 121     amuDebug(D_TRACE)
 122       plog(XLOG_DEBUG, "\tretry=%d", retry);
 123 #endif /* DEBUG */
 124
 125     if (retry < 0)
 126       return 0;
 127     res.ns_status = nfs_error(retry);
 128   } else {
 129     nfsattrstat *attrp = &mp->am_attr;
 130
 131 #ifdef DEBUG
 132     amuDebug(D_TRACE)
 133       plog(XLOG_DEBUG, "\tstat(%s), size = %d", mp->am_path,
 134            (int) attrp->ns_u.ns_attr_u.na_size);
 135 #endif /* DEBUG */
 136
 137     mp->am_stats.s_getattr++;
 138     return attrp;
 139   }
 140
 141 #ifndef MNT2_NFS_OPT_SYMTTL
 142   /*
 143    * This code is needed to defeat Solaris 2.4's (and newer) symlink values
 144    * cache.  It forces the last-modified time of the symlink to be current.
 145    * It is not needed if the O/S has an nfs flag to turn off the
 146    * symlink-cache at mount time (such as Irix 5.x and 6.x). -Erez.
 147    */
 148   if (++res.ns_u.ns_attr_u.na_mtime.nt_useconds == 0)
 149     ++res.ns_u.ns_attr_u.na_mtime.nt_seconds;
 150 #endif /* not MNT2_NFS_OPT_SYMTTL */
 151
 152   return &res;
 153 }
 154
 155
 156 nfsattrstat *
 157 nfsproc_setattr_2_svc(nfssattrargs *argp, struct svc_req *rqstp)
 158 {
 159   static nfsattrstat res;
 160
 161   if (!fh_to_mp(&argp->sag_fhandle))
 162     res.ns_status = nfs_error(ESTALE);
 163   else
 164     res.ns_status = nfs_error(EROFS);
 165
 166   return &res;
 167 }
 168
 169
 170 voidp
 171 nfsproc_root_2_svc(voidp argp, struct svc_req *rqstp)
 172 {
 173   static char res;
 174
 175   return (voidp) &res;
 176 }
 177
 178
 179 nfsdiropres *
 180 nfsproc_lookup_2_svc(nfsdiropargs *argp, struct svc_req *rqstp)
 181 {
 182   static nfsdiropres res;
 183   am_node *mp;
 184   int retry;
 185
 186 #ifdef DEBUG
 187   amuDebug(D_TRACE)
 188     plog(XLOG_DEBUG, "lookup:");
 189 #endif /* DEBUG */
 190
 191   mp = fh_to_mp2(&argp->da_fhandle, &retry);
 192   if (mp == 0) {
 193     if (retry < 0)
 194       return 0;
 195     res.dr_status = nfs_error(retry);
 196   } else {
 197     int error;
 198     am_node *ap;
 199 #ifdef DEBUG
 200     amuDebug(D_TRACE)
 201       plog(XLOG_DEBUG, "\tlookuppn(%s, %s)", mp->am_path, argp->da_name);
 202 #endif /* DEBUG */
 203     ap = (*mp->am_mnt->mf_ops->lookuppn) (mp, argp->da_name, &error, VLOOK_CREATE);
 204     if (ap == 0) {
 205       if (error < 0) {
 206 #ifdef DEBUG
 207         dlog("Not sending RPC reply");
 208 #endif /* DEBUG */
 209         amd_stats.d_drops++;
 210         return 0;
 211       }
 212       res.dr_status = nfs_error(error);
 213     } else {
 214       /*
 215        * XXX: EXPERIMENTAL! Delay unmount of what was looked up.  This
 216        * should reduce the chance for race condition between unmounting an
 217        * entry synchronously, and re-mounting it asynchronously.
 218        */
 219       if (ap->am_ttl < mp->am_ttl)
 220         ap->am_ttl = mp->am_ttl;
 221       mp_to_fh(ap, &res.dr_u.dr_drok_u.drok_fhandle);
 222       res.dr_u.dr_drok_u.drok_attributes = ap->am_fattr;
 223       res.dr_status = NFS_OK;
 224     }
 225     mp->am_stats.s_lookup++;
 226     /* reschedule_timeout_mp(); */
 227   }
 228
 229   return &res;
 230 }
 231
 232
 233 void
 234 quick_reply(am_node *mp, int error)
 235 {
 236   SVCXPRT *transp = mp->am_transp;
 237   nfsdiropres res;
 238   xdrproc_t xdr_result = (xdrproc_t) xdr_diropres;
 239
 240   /*
 241    * If there's a transp structure then we can reply to the client's
 242    * nfs lookup request.
 243    */
 244   if (transp) {
 245     if (error == 0) {
 246       /*
 247        * Construct a valid reply to a lookup request.  Same
 248        * code as in nfsproc_lookup_2_svc() above.
 249        */
 250       mp_to_fh(mp, &res.dr_u.dr_drok_u.drok_fhandle);
 251       res.dr_u.dr_drok_u.drok_attributes = mp->am_fattr;
 252       res.dr_status = NFS_OK;
 253     } else
 254       /*
 255        * Return the error that was passed to us.
 256        */
 257       res.dr_status = nfs_error(error);
 258
 259     /*
 260      * Send off our reply
 261      */
 262     if (!svc_sendreply(transp, (XDRPROC_T_TYPE) xdr_result, (SVC_IN_ARG_TYPE) & res))
 263       svcerr_systemerr(transp);
 264
 265     /*
 266      * Free up transp.  It's only used for one reply.
 267      */
 268     XFREE(transp);
 269     mp->am_transp = NULL;
 270 #ifdef DEBUG
 271     dlog("Quick reply sent for %s", mp->am_mnt->mf_mount);
 272 #endif /* DEBUG */
 273   }
 274 }
 275
 276
 277 nfsreadlinkres *
 278 nfsproc_readlink_2_svc(am_nfs_fh *argp, struct svc_req *rqstp)
 279 {
 280   static nfsreadlinkres res;
 281   am_node *mp;
 282   int retry;
 283
 284 #ifdef DEBUG
 285   amuDebug(D_TRACE)
 286     plog(XLOG_DEBUG, "readlink:");
 287 #endif /* DEBUG */
 288
 289   mp = fh_to_mp2(argp, &retry);
 290   if (mp == 0) {
 291   readlink_retry:
 292     if (retry < 0)
 293       return 0;
 294     res.rlr_status = nfs_error(retry);
 295   } else {
 296     char *ln = do_readlink(mp, &retry, (nfsattrstat **) 0);
 297     if (ln == 0)
 298       goto readlink_retry;
 299     res.rlr_status = NFS_OK;
 300 #ifdef DEBUG
 301     amuDebug(D_TRACE)
 302       if (ln)
 303         plog(XLOG_DEBUG, "\treadlink(%s) = %s", mp->am_path, ln);
 304 #endif /* DEBUG */
 305     res.rlr_u.rlr_data_u = ln;
 306     mp->am_stats.s_readlink++;
 307   }
 308
 309   return &res;
 310 }
 311
 312
 313 nfsreadres *
 314 nfsproc_read_2_svc(nfsreadargs *argp, struct svc_req *rqstp)
 315 {
 316   static nfsreadres res;
 317
 318   memset((char *) &res, 0, sizeof(res));
 319   res.rr_status = nfs_error(EACCES);
 320
 321   return &res;
 322 }
 323
 324
 325 voidp
 326 nfsproc_writecache_2_svc(voidp argp, struct svc_req *rqstp)
 327 {
 328   static char res;
 329
 330   return (voidp) &res;
 331 }
 332
 333
 334 nfsattrstat *
 335 nfsproc_write_2_svc(nfswriteargs *argp, struct svc_req *rqstp)
 336 {
 337   static nfsattrstat res;
 338
 339   if (!fh_to_mp(&argp->wra_fhandle))
 340     res.ns_status = nfs_error(ESTALE);
 341   else
 342     res.ns_status = nfs_error(EROFS);
 343
 344   return &res;
 345 }
 346
 347
 348 nfsdiropres *
 349 nfsproc_create_2_svc(nfscreateargs *argp, struct svc_req *rqstp)
 350 {
 351   static nfsdiropres res;
 352
 353   if (!fh_to_mp(&argp->ca_where.da_fhandle))
 354     res.dr_status = nfs_error(ESTALE);
 355   else
 356     res.dr_status = nfs_error(EROFS);
 357
 358   return &res;
 359 }
 360
 361
 362 static nfsstat *
 363 unlink_or_rmdir(nfsdiropargs *argp, struct svc_req *rqstp, int unlinkp)
 364 {
 365   static nfsstat res;
 366   int retry;
 367
 368   am_node *mp = fh_to_mp3(&argp->da_fhandle, &retry, VLOOK_DELETE);
 369   if (mp == 0) {
 370     if (retry < 0)
 371       return 0;
 372     res = nfs_error(retry);
 373     goto out;
 374   }
 375
 376   if (mp->am_fattr.na_type != NFDIR) {
 377     res = nfs_error(ENOTDIR);
 378     goto out;
 379   }
 380
 381 #ifdef DEBUG
 382   amuDebug(D_TRACE)
 383     plog(XLOG_DEBUG, "\tremove(%s, %s)", mp->am_path, argp->da_name);
 384 #endif /* DEBUG */
 385
 386   mp = (*mp->am_mnt->mf_ops->lookuppn) (mp, argp->da_name, &retry, VLOOK_DELETE);
 387   if (mp == 0) {
 388     /*
 389      * Ignore retries...
 390      */
 391     if (retry < 0)
 392       retry = 0;
 393     /*
 394      * Usual NFS workaround...
 395      */
 396     else if (retry == ENOENT)
 397       retry = 0;
 398     res = nfs_error(retry);
 399   } else {
 400     forcibly_timeout_mp(mp);
 401     res = NFS_OK;
 402   }
 403
 404 out:
 405   return &res;
 406 }
 407
 408
 409 nfsstat *
 410 nfsproc_remove_2_svc(nfsdiropargs *argp, struct svc_req *rqstp)
 411 {
 412   return unlink_or_rmdir(argp, rqstp, TRUE);
 413 }
 414
 415
 416 nfsstat *
 417 nfsproc_rename_2_svc(nfsrenameargs *argp, struct svc_req *rqstp)
 418 {
 419   static nfsstat res;
 420
 421   if (!fh_to_mp(&argp->rna_from.da_fhandle) || !fh_to_mp(&argp->rna_to.da_fhandle))
 422     res = nfs_error(ESTALE);
 423   /*
 424    * If the kernel is doing clever things with referenced files
 425    * then let it pretend...
 426    */
 427   else if (NSTREQ(argp->rna_to.da_name, ".nfs", 4))
 428     res = NFS_OK;
 429   /*
 430    * otherwise a failure
 431    */
 432   else
 433     res = nfs_error(EROFS);
 434
 435   return &res;
 436 }
 437
 438
 439 nfsstat *
 440 nfsproc_link_2_svc(nfslinkargs *argp, struct svc_req *rqstp)
 441 {
 442   static nfsstat res;
 443
 444   if (!fh_to_mp(&argp->la_fhandle) || !fh_to_mp(&argp->la_to.da_fhandle))
 445     res = nfs_error(ESTALE);
 446   else
 447     res = nfs_error(EROFS);
 448
 449   return &res;
 450 }
 451
 452
 453 nfsstat *
 454 nfsproc_symlink_2_svc(nfssymlinkargs *argp, struct svc_req *rqstp)
 455 {
 456   static nfsstat res;
 457
 458   if (!fh_to_mp(&argp->sla_from.da_fhandle))
 459     res = nfs_error(ESTALE);
 460   else
 461     res = nfs_error(EROFS);
 462
 463   return &res;
 464 }
 465
 466
 467 nfsdiropres *
 468 nfsproc_mkdir_2_svc(nfscreateargs *argp, struct svc_req *rqstp)
 469 {
 470   static nfsdiropres res;
 471
 472   if (!fh_to_mp(&argp->ca_where.da_fhandle))
 473     res.dr_status = nfs_error(ESTALE);
 474   else
 475     res.dr_status = nfs_error(EROFS);
 476
 477   return &res;
 478 }
 479
 480
 481 nfsstat *
 482 nfsproc_rmdir_2_svc(nfsdiropargs *argp, struct svc_req *rqstp)
 483 {
 484   return unlink_or_rmdir(argp, rqstp, FALSE);
 485 }
 486
 487
 488 nfsreaddirres *
 489 nfsproc_readdir_2_svc(nfsreaddirargs *argp, struct svc_req *rqstp)
 490 {
 491   static nfsreaddirres res;
 492   static nfsentry e_res[MAX_READDIR_ENTRIES];
 493   am_node *mp;
 494   int retry;
 495
 496 #ifdef DEBUG
 497   amuDebug(D_TRACE)
 498     plog(XLOG_DEBUG, "readdir:");
 499 #endif /* DEBUG */
 500
 501   mp = fh_to_mp2(&argp->rda_fhandle, &retry);
 502   if (mp == 0) {
 503     if (retry < 0)
 504       return 0;
 505     res.rdr_status = nfs_error(retry);
 506   } else {
 507 #ifdef DEBUG
 508     amuDebug(D_TRACE)
 509       plog(XLOG_DEBUG, "\treaddir(%s)", mp->am_path);
 510 #endif /* DEBUG */
 511     res.rdr_status = nfs_error((*mp->am_mnt->mf_ops->readdir)
 512                            (mp, argp->rda_cookie,
 513                             &res.rdr_u.rdr_reply_u, e_res, argp->rda_count));
 514     mp->am_stats.s_readdir++;
 515   }
 516
 517   return &res;
 518 }
 519
 520
 521 nfsstatfsres *
 522 nfsproc_statfs_2_svc(am_nfs_fh *argp, struct svc_req *rqstp)
 523 {
 524   static nfsstatfsres res;
 525   am_node *mp;
 526   int retry;
 527   mntent_t mnt;
 528
 529 #ifdef DEBUG
 530   amuDebug(D_TRACE)
 531     plog(XLOG_DEBUG, "statfs:");
 532 #endif /* DEBUG */
 533
 534   mp = fh_to_mp2(argp, &retry);
 535   if (mp == 0) {
 536     if (retry < 0)
 537       return 0;
 538     res.sfr_status = nfs_error(retry);
 539   } else {
 540     nfsstatfsokres *fp;
 541 #ifdef DEBUG
 542     amuDebug(D_TRACE)
 543       plog(XLOG_DEBUG, "\tstat_fs(%s)", mp->am_path);
 544 #endif /* DEBUG */
 545
 546     /*
 547      * just return faked up file system information
 548      */
 549     fp = &res.sfr_u.sfr_reply_u;
 550
 551     fp->sfrok_tsize = 1024;
 552     fp->sfrok_bsize = 1024;
 553
 554     /* check if map is browsable and show_statfs_entries=yes  */
 555     if ((gopt.flags & CFM_SHOW_STATFS_ENTRIES) &&
 556         mp->am_mnt && mp->am_mnt->mf_mopts) {
 557       mnt.mnt_opts = mp->am_mnt->mf_mopts;
 558       if (hasmntopt(&mnt, "browsable")) {
 559         count_map_entries(mp,
 560                           &fp->sfrok_blocks,
 561                           &fp->sfrok_bfree,
 562                           &fp->sfrok_bavail);
 563       }
 564     } else {
 565       fp->sfrok_blocks = 0; /* set to 1 if you don't want empty automounts */
 566       fp->sfrok_bfree = 0;
 567       fp->sfrok_bavail = 0;
 568     }
 569
 570     res.sfr_status = NFS_OK;
 571     mp->am_stats.s_statfs++;
 572   }
 573
 574   return &res;
 575 }
 576
 577
 578 /*
 579  * count how many total entries there are in a map, and how many
 580  * of them are in use.
 581  */
 582 static void
 583 count_map_entries(const am_node *mp, u_int *out_blocks, u_int *out_bfree, u_int *out_bavail)
 584 {
 585   u_int blocks, bfree, bavail, i;
 586   mntfs *mf;
 587   mnt_map *mmp;
 588   kv *k;
 589
 590   blocks = bfree = bavail = 0;
 591   if (!mp)
 592     goto out;
 593   mf = mp->am_mnt;
 594   if (!mf)
 595     goto out;
 596   mmp = (mnt_map *) mf->mf_private;
 597   if (!mmp)
 598     goto out;
 599
 600   /* iterate over keys */
 601   for (i = 0; i < NKVHASH; i++) {
 602     for (k = mmp->kvhash[i]; k ; k = k->next) {
 603       if (!k->key)
 604         continue;
 605       blocks++;
 606       /*
 607        * XXX: Need to count how many are actively in use and recompute
 608        * bfree and bavail based on it.
 609        */
 610     }
 611   }
 612
 613 out:
 614   *out_blocks = blocks;
 615   *out_bfree = bfree;
 616   *out_bavail = bavail;
 617 }