src/afs/afs_nfsclnt.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include "afs/param.h"
  12
  13 RCSID
  14     ("$Header$");
  15
  16 #if !defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV)
  17 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  18 #include "afsincludes.h"        /* Afs-based standard headers */
  19 #include "afs/afs_stats.h"      /* statistics */
  20 #include "afs/nfsclient.h"
  21
  22 int afs_nfsclient_reqhandler(), afs_nfsclient_hold(), afs_PutNfsClientPag();
  23 int afs_nfsclient_sysname(), afs_nfsclient_GC(), afs_nfsclient_stats();
  24 #ifdef AFS_AIX_IAUTH_ENV
  25 int afs_allnfsreqs, afs_nfscalls;
  26 #endif
  27
  28 /* routines exported to the "AFS exporter" layer */
  29 struct exporterops nfs_exportops = {
  30     afs_nfsclient_reqhandler,
  31     afs_nfsclient_hold,
  32     afs_PutNfsClientPag,        /* Used to be afs_nfsclient_rele */
  33     afs_nfsclient_sysname,
  34     afs_nfsclient_GC,
  35     afs_nfsclient_stats,
  36 };
  37
  38
  39 struct nfsclientpag *afs_nfspags[NNFSCLIENTS];
  40 afs_lock_t afs_xnfspag /*, afs_xnfsreq */ ;
  41 extern struct afs_exporter *afs_nfsexporter;
  42
  43 /* Creates an nfsclientpag structure for the (uid, host) pair if one doesn't exist. RefCount is incremented and it's time stamped. */
  44 static struct nfsclientpag *
  45 afs_GetNfsClientPag(uid, host)
  46      register afs_int32 uid, host;
  47 {
  48     register struct nfsclientpag *np;
  49     register afs_int32 i, now;
  50
  51 #if defined(AFS_SGIMP_ENV)
  52     osi_Assert(ISAFS_GLOCK());
  53 #endif
  54     AFS_STATCNT(afs_GetNfsClientPag);
  55     i = NHash(host);
  56     now = osi_Time();
  57     MObtainWriteLock(&afs_xnfspag, 314);
  58     for (np = afs_nfspags[i]; np; np = np->next) {
  59         if (np->uid == uid && np->host == host) {
  60             np->refCount++;
  61             np->lastcall = now;
  62             MReleaseWriteLock(&afs_xnfspag);
  63             return np;
  64         }
  65     }
  66     /* next try looking for NOPAG dude, if we didn't find an exact match */
  67     for (np = afs_nfspags[i]; np; np = np->next) {
  68         if (np->uid == NOPAG && np->host == host) {
  69             np->refCount++;
  70             np->lastcall = now;
  71             MReleaseWriteLock(&afs_xnfspag);
  72             return np;
  73         }
  74     }
  75     np = (struct nfsclientpag *)afs_osi_Alloc(sizeof(struct nfsclientpag));
  76     memset((char *)np, 0, sizeof(struct nfsclientpag));
  77     /* Copy the necessary afs_exporter fields */
  78     memcpy((char *)np, (char *)afs_nfsexporter, sizeof(struct afs_exporter));
  79     np->next = afs_nfspags[i];
  80     afs_nfspags[i] = np;
  81     np->uid = uid;
  82     np->host = host;
  83     np->refCount = 1;
  84     np->lastcall = now;
  85     MReleaseWriteLock(&afs_xnfspag);
  86     return np;
  87 }
  88
  89
  90 /* Decrement refCount; must always match a previous afs_FindNfsClientPag/afs_GetNfsClientPag call .
  91 It's also called whenever a unixuser structure belonging to the remote user associated with the nfsclientpag structure, np, is garbage collected. */
  92 int
  93 afs_PutNfsClientPag(np)
  94      register struct nfsclientpag *np;
  95 {
  96 #if defined(AFS_SGIMP_ENV)
  97     osi_Assert(ISAFS_GLOCK());
  98 #endif
  99     AFS_STATCNT(afs_PutNfsClientPag);
 100     --np->refCount;
 101 }
 102
 103
 104 /* Return the nfsclientpag structure associated with the (uid, host) or {pag, host} pair, if pag is nonzero. RefCount is incremented and it's time stamped. */
 105 static struct nfsclientpag *
 106 afs_FindNfsClientPag(uid, host, pag)
 107      register afs_int32 uid, host, pag;
 108 {
 109     register struct nfsclientpag *np;
 110     register afs_int32 i;
 111
 112 #if defined(AFS_SGIMP_ENV)
 113     osi_Assert(ISAFS_GLOCK());
 114 #endif
 115     AFS_STATCNT(afs_FindNfsClientPag);
 116     i = NHash(host);
 117     MObtainWriteLock(&afs_xnfspag, 315);
 118     for (np = afs_nfspags[i]; np; np = np->next) {
 119         if (np->host == host) {
 120             if ((pag && pag == np->pag) || (!pag && (uid == np->uid))) {
 121                 np->refCount++;
 122                 np->lastcall = osi_Time();
 123                 MReleaseWriteLock(&afs_xnfspag);
 124                 return np;
 125             }
 126         }
 127     }
 128     /* still not there, try looking for a wildcard dude */
 129     for (np = afs_nfspags[i]; np; np = np->next) {
 130         if (np->host == host) {
 131             if (np->uid == NOPAG) {
 132                 np->refCount++;
 133                 np->lastcall = osi_Time();
 134                 MReleaseWriteLock(&afs_xnfspag);
 135                 return np;
 136             }
 137         }
 138     }
 139     MReleaseWriteLock(&afs_xnfspag);
 140     return NULL;
 141 }
 142
 143
 144 /* routine to initialize the exporter, made global so we can call it
 145  * from pioctl calls.
 146  */
 147 struct afs_exporter *afs_nfsexported = 0;
 148 static afs_int32 init_nfsexporter = 0;
 149 afs_nfsclient_init()
 150 {
 151 #if defined(AFS_SGIMP_ENV)
 152     osi_Assert(ISAFS_GLOCK());
 153 #endif
 154     if (!init_nfsexporter) {
 155         extern struct afs_exporter *exporter_add();
 156
 157         init_nfsexporter = 1;
 158         LOCK_INIT(&afs_xnfspag, "afs_xnfspag");
 159         afs_nfsexported =
 160             exporter_add(0, &nfs_exportops, EXP_EXPORTED, EXP_NFS, NULL);
 161     }
 162 }
 163
 164
 165 /* Main handler routine for the NFS exporter. It's called in the early
 166  * phases of any remote call (via the NFS server or pioctl).
 167  */
 168 int
 169 afs_nfsclient_reqhandler(exporter, cred, host, pagparam, outexporter)
 170      register struct afs_exporter *exporter, **outexporter;
 171      struct AFS_UCRED **cred;
 172      register afs_int32 host;
 173      afs_int32 *pagparam;
 174 {
 175     register struct nfsclientpag *np, *tnp;
 176     extern struct unixuser *afs_FindUser(), *afs_GetUser();
 177     register struct unixuser *au = 0;
 178     afs_int32 pag, code = 0;
 179
 180     AFS_ASSERT_GLOCK();
 181     AFS_STATCNT(afs_nfsclient_reqhandler);
 182     if (!afs_nfsexporter)
 183         afs_nfsexporter = afs_nfsexported;
 184
 185     afs_nfsexporter->exp_stats.calls++;
 186     if (!(afs_nfsexporter->exp_states & EXP_EXPORTED)) {
 187         /* No afs requests accepted as long as EXPORTED flag is turned 'off'. Set/Reset via a pioctl call (fs exportafs). Note that this is on top of the /etc/exports nfs requirement (i.e. /afs must be exported to all or whomever there too!)
 188          */
 189         afs_nfsexporter->exp_stats.rejectedcalls++;
 190         return EINVAL;
 191     }
 192 /*    ObtainWriteLock(&afs_xnfsreq); */
 193     pag = PagInCred(*cred);
 194     if (pag != NOPAG) {
 195         /* Do some minimal pag verification */
 196         if (pag > getpag()) {
 197             pag = NOPAG;        /* treat it as not paged since couldn't be good  */
 198         } else {
 199             if (au = afs_FindUser(pag, -1, READ_LOCK)) {
 200                 if (!au->exporter) {
 201                     pag = NOPAG;
 202                     afs_PutUser(au, READ_LOCK);
 203                     au = NULL;
 204                 }
 205             } else
 206                 pag = NOPAG;    /*  No unixuser struct so pag not trusted  */
 207         }
 208     }
 209     np = afs_FindNfsClientPag((*cred)->cr_uid, host, 0);
 210     afs_Trace4(afs_iclSetp, CM_TRACE_NFSREQH, ICL_TYPE_INT32, pag,
 211                ICL_TYPE_LONG, (*cred)->cr_uid, ICL_TYPE_INT32, host,
 212                ICL_TYPE_POINTER, np);
 213     if (!np) {
 214         /* Even if there is a "good" pag coming in we don't accept it if no nfsclientpag struct exists for the user since that would mean that the translator rebooted and therefore we ignore all older pag values */
 215 #ifdef  AFS_OSF_ENV
 216         if (code = setpag(u.u_procp, cred, -1, &pag, 1)) {      /* XXX u.u_procp is a no-op XXX */
 217 #else
 218         if (code = setpag(cred, -1, &pag, 1)) {
 219 #endif
 220             if (au)
 221                 afs_PutUser(au, READ_LOCK);
 222 /*          ReleaseWriteLock(&afs_xnfsreq);             */
 223 #if defined(KERNEL_HAVE_UERROR)
 224             setuerror(code);
 225 #endif
 226             return (code);
 227         }
 228         np = afs_GetNfsClientPag((*cred)->cr_uid, host);
 229         np->pag = pag;
 230     } else {
 231         if (pag == NOPAG) {
 232 #ifdef  AFS_OSF_ENV
 233             if (code = setpag(u.u_procp, cred, np->pag, &pag, 1)) {     /* XXX u.u_procp is a no-op XXX */
 234 #else
 235             if (code = setpag(cred, np->pag, &pag, 1)) {
 236 #endif
 237                 afs_PutNfsClientPag(np);
 238 /*              ReleaseWriteLock(&afs_xnfsreq); */
 239 #if defined(KERNEL_HAVE_UERROR)
 240                 setuerror(code);
 241 #endif
 242                 return (code);
 243             }
 244         } else if (au->exporter
 245                    && ((struct afs_exporter *)np != au->exporter)) {
 246             tnp = (struct nfsclientpag *)au->exporter;
 247             if (tnp->uid && (tnp->uid != (afs_int32) - 2)) {    /* allow "root" initiators */
 248                 /* Pag doesn't belong to caller; treat it as an unpaged call too */
 249 #ifdef  AFS_OSF_ENV
 250                 if (code = setpag(u.u_procp, cred, np->pag, &pag, 1)) { /* XXX u.u_procp is a no-op XXX */
 251 #else
 252                 if (code = setpag(cred, np->pag, &pag, 1)) {
 253 #endif
 254                     afs_PutNfsClientPag(np);
 255                     afs_PutUser(au, READ_LOCK);
 256                     /*      ReleaseWriteLock(&afs_xnfsreq);     */
 257 #if defined(KERNEL_HAVE_UERROR)
 258                     setuerror(code);
 259 #endif
 260                     return (code);
 261                 }
 262                 afs_nfsexporter->exp_stats.invalidpag++;
 263             }
 264         }
 265     }
 266     if (au)
 267         afs_PutUser(au, READ_LOCK);
 268     au = afs_GetUser(pag, -1, WRITE_LOCK);
 269     if (!(au->exporter)) {      /* Created new unixuser struct */
 270         np->refCount++;         /* so it won't disappear */
 271         au->exporter = (struct afs_exporter *)np;
 272     }
 273     *pagparam = pag;
 274     *outexporter = (struct afs_exporter *)np;
 275     afs_PutUser(au, WRITE_LOCK);
 276 #ifdef  AFS_OSF_ENV
 277     (*cred)->cr_ruid = NFSXLATOR_CRED;  /* Identify it as nfs xlator call */
 278 #else
 279     (*cred)->cr_rgid = NFSXLATOR_CRED;  /* Identify it as nfs xlator call */
 280 #endif
 281 /*    ReleaseWriteLock(&afs_xnfsreq);   */
 282     return 0;
 283 }
 284
 285
 286 /* It's called whenever a new unixuser structure is created for the remote user associated with the nfsclientpag structure, np */
 287 int
 288 afs_nfsclient_hold(np)
 289      register struct nfsclientpag *np;
 290 {
 291 #if defined(AFS_SGIMP_ENV)
 292     osi_Assert(ISAFS_GLOCK());
 293 #endif
 294     AFS_STATCNT(afs_nfsclient_hold);
 295     np->refCount++;
 296 }
 297
 298
 299 /* if inname is non-null, a new system name value is set for the remote user (inname contains the new sysname). In all cases, outname returns the current sysname value for this remote user */
 300 int
 301 afs_nfsclient_sysname(register struct nfsclientpag *np, char *inname,
 302                       char **outname[], int *num)
 303 {
 304     char *cp;
 305     int count, t;
 306 #if defined(AFS_SGIMP_ENV)
 307     osi_Assert(ISAFS_GLOCK());
 308 #endif
 309     AFS_STATCNT(afs_nfsclient_sysname);
 310     if (inname) {
 311         if (np->sysname) {
 312             for(count=0; count < np->sysnamecount;++count) {
 313                 afs_osi_Free(np->sysname[count], MAXSYSNAME);
 314             }
 315         }
 316         for(count=0; count < *num;++count) {
 317             np->sysname[count]= afs_osi_Alloc(MAXSYSNAME);
 318         }
 319         cp = inname;
 320         for(count=0; count < *num;++count) {
 321             t = strlen(cp);
 322             memcpy(np->sysname[count], cp, t+1); /* include null */
 323             cp += t+1;
 324         }
 325         np->sysnamecount = *num;
 326     } else if (!np->sysname) {
 327         return ENODEV;      /* XXX */
 328     }
 329     *outname = np->sysname;
 330     *num = np->sysnamecount;
 331     return 0;
 332 }
 333
 334
 335 /* Garbage collect routine for the nfs exporter. When pag is -1 then all entries are removed (used by the nfsclient_shutdown routine); else if it's non zero then only the entry with that pag is removed, else all "timedout" entries are removed. TimedOut entries are those who have no "unixuser" structures associated with them (i.e. unixusercnt == 0) and they haven't had any activity the last NFSCLIENTGC seconds */
 336 int
 337 afs_nfsclient_GC(exporter, pag)
 338      register struct afs_exporter *exporter;
 339      register afs_int32 pag;
 340 {
 341     register struct nfsclientpag *np, **tnp, *nnp;
 342     register afs_int32 i, delflag;
 343
 344 #if defined(AFS_SGIMP_ENV)
 345     osi_Assert(ISAFS_GLOCK());
 346 #endif
 347     AFS_STATCNT(afs_nfsclient_GC);
 348     MObtainWriteLock(&afs_xnfspag, 316);
 349     for (i = 0; i < NNFSCLIENTS; i++) {
 350         for (tnp = &afs_nfspags[i], np = *tnp; np; np = nnp) {
 351             nnp = np->next;
 352             delflag = 0;
 353             if (np->refCount == 0 && np->lastcall < osi_Time() - NFSCLIENTGC)
 354                 delflag = 1;
 355             if ((pag == -1) || (!pag && delflag)
 356                 || (pag && (np->refCount == 0) && (np->pag == pag))) {
 357                 *tnp = np->next;
 358                 if (np->sysname)
 359                     afs_osi_Free(np->sysname, MAXSYSNAME);
 360                 afs_osi_Free(np, sizeof(struct nfsclientpag));
 361             } else {
 362                 tnp = &np->next;
 363             }
 364         }
 365     }
 366     MReleaseWriteLock(&afs_xnfspag);
 367 }
 368
 369
 370 int
 371 afs_nfsclient_stats(export)
 372      register struct afs_exporter *export;
 373 {
 374     /* Nothing much to do here yet since most important stats are collected directly in the afs_exporter structure itself */
 375     AFS_STATCNT(afs_nfsclient_stats);
 376     return 0;
 377 }
 378
 379 #ifdef AFS_AIX41_ENV
 380 /* This is exposed so that vop_fid can test it, even if iauth is not
 381  *  installed.
 382  */
 383 extern int afs_iauth_initd;
 384 #endif
 385
 386 #ifdef AFS_AIX_IAUTH_ENV
 387 char *afs_nfs_id = "AFSNFSTRANS";
 388 /* afs_iauth_verify is the AFS authenticator for NFS.
 389  *
 390  * always returns 0.
 391  */
 392 int
 393 afs_iauth_verify(long id, fsid_t * fsidp, long host, int uid,
 394                  struct AFS_UCRED *credp, struct exportinfo *exp)
 395 {
 396     int code;
 397     struct nfsclientpag *nfs_pag;
 398     afs_int32 dummypag;
 399     struct afs_exporter *outexporter = 0;
 400
 401
 402     /* Still needs basic test to see if exporter is on. And need to check the
 403      * whole no submounts bit.
 404      */
 405
 406     if (id != (long)id)
 407         return 0;               /* not us. */
 408
 409     /* Only care if it's AFS */
 410     if ((fsidp->val[0] != AFS_VFSMAGIC) || (fsidp->val[1] != AFS_VFSFSID)) {
 411         return 0;
 412     }
 413
 414     AFS_GLOCK();
 415     code =
 416         afs_nfsclient_reqhandler((struct afs_exporter *)0, &credp, host,
 417                                  &dummypag, &outexporter);
 418     if (!code && outexporter)
 419         EXP_RELE(outexporter);
 420
 421     if (code) {
 422         /* ensure anonymous cred. */
 423         credp->cr_uid = credp->cr_ruid = (uid_t) - 2;   /* anonymous */
 424     }
 425
 426     /* Mark this thread as an NFS translator thread. */
 427     credp->cr_rgid = NFSXLATOR_CRED;
 428
 429     AFS_GUNLOCK();
 430     return 0;
 431 }
 432
 433 /* afs_iauth_register - register the iauth verify routine. Returns 0 on success
 434  * and -1 on failure. Can fail because DFS has already registered.
 435  */
 436 int
 437 afs_iauth_register()
 438 {
 439     if (nfs_iauth_register((unsigned long)afs_nfs_id, afs_iauth_verify))
 440         return -1;
 441     else {
 442         afs_iauth_initd = 1;
 443         return 0;
 444     }
 445 }
 446
 447 /* afs_iauth_unregister - unregister the iauth verify routine. Called on shutdown.
 448  */
 449 void
 450 afs_iauth_unregister()
 451 {
 452     if (afs_iauth_initd)
 453         nfs_iauth_unregister((unsigned long)afs_nfs_id);
 454     afs_iauth_initd = 0;
 455 }
 456 #endif /* AFS_AIX_IAUTH_ENV */
 457
 458
 459
 460 shutdown_nfsclnt()
 461 {
 462 #if defined(AFS_SGIMP_ENV)
 463     osi_Assert(ISAFS_GLOCK());
 464 #endif
 465     AFS_STATCNT(afs_nfsclient_shutdown);
 466 #ifdef AFS_AIX_IAUTH_ENV
 467     afs_iauth_register();
 468 #endif
 469     afs_nfsclient_GC(afs_nfsexporter, -1);
 470     init_nfsexporter = 0;
 471 }
 472 #endif /* AFS_NONFSTRANS */