src/afs/afs_daemons.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 #ifdef AFS_AIX51_ENV
  17 #define __FULL_PROTO
  18 #include <sys/sleep.h>
  19 #endif
  20
  21 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  22 #include "afsincludes.h"        /* Afs-based standard headers */
  23 #include "afs/afs_stats.h"      /* statistics gathering code */
  24 #include "afs/afs_cbqueue.h"
  25 #ifdef AFS_AIX_ENV
  26 #include <sys/adspace.h>        /* for vm_att(), vm_det() */
  27 #endif
  28
  29
  30 /* background request queue size */
  31 afs_lock_t afs_xbrs;            /* lock for brs */
  32 static int brsInit = 0;
  33 short afs_brsWaiters = 0;       /* number of users waiting for brs buffers */
  34 short afs_brsDaemons = 0;       /* number of daemons waiting for brs requests */
  35 struct brequest afs_brs[NBRS];  /* request structures */
  36 struct afs_osi_WaitHandle AFS_WaitHandler, AFS_CSWaitHandler;
  37 static int afs_brs_count = 0;   /* request counter, to service reqs in order */
  38
  39 static int rxepoch_checked = 0;
  40 #define afs_CheckRXEpoch() {if (rxepoch_checked == 0 && rxkad_EpochWasSet) { \
  41         rxepoch_checked = 1; afs_GCUserData(/* force flag */ 1);  } }
  42
  43 /* PAG garbage collection */
  44 /* We induce a compile error if param.h does not define AFS_GCPAGS */
  45 afs_int32 afs_gcpags = AFS_GCPAGS;
  46 afs_int32 afs_gcpags_procsize = 0;
  47
  48 afs_int32 afs_CheckServerDaemonStarted = 0;
  49 #ifdef DEFAULT_PROBE_INTERVAL
  50 afs_int32 PROBE_INTERVAL = DEFAULT_PROBE_INTERVAL;      /* overridding during compile */
  51 #else
  52 afs_int32 PROBE_INTERVAL = 180; /* default to 3 min */
  53 #endif
  54
  55 #define PROBE_WAIT() (1000 * (PROBE_INTERVAL - ((afs_random() & 0x7fffffff) \
  56                       % (PROBE_INTERVAL/2))))
  57
  58 void
  59 afs_CheckServerDaemon(void)
  60 {
  61     afs_int32 now, delay, lastCheck, last10MinCheck;
  62
  63     afs_CheckServerDaemonStarted = 1;
  64
  65     while (afs_initState < 101)
  66         afs_osi_Sleep(&afs_initState);
  67     afs_osi_Wait(PROBE_WAIT(), &AFS_CSWaitHandler, 0);
  68
  69     last10MinCheck = lastCheck = osi_Time();
  70     while (1) {
  71         if (afs_termState == AFSOP_STOP_CS) {
  72             afs_termState = AFSOP_STOP_BKG;
  73             afs_osi_Wakeup(&afs_termState);
  74             break;
  75         }
  76
  77         now = osi_Time();
  78         if (PROBE_INTERVAL + lastCheck <= now) {
  79             afs_CheckServers(1, NULL);  /* check down servers */
  80             lastCheck = now = osi_Time();
  81         }
  82
  83         if (600 + last10MinCheck <= now) {
  84             afs_Trace1(afs_iclSetp, CM_TRACE_PROBEUP, ICL_TYPE_INT32, 600);
  85             afs_CheckServers(0, NULL);
  86             last10MinCheck = now = osi_Time();
  87         }
  88         /* shutdown check. */
  89         if (afs_termState == AFSOP_STOP_CS) {
  90             afs_termState = AFSOP_STOP_BKG;
  91             afs_osi_Wakeup(&afs_termState);
  92             break;
  93         }
  94
  95         /* Compute time to next probe. */
  96         delay = PROBE_INTERVAL + lastCheck;
  97         if (delay > 600 + last10MinCheck)
  98             delay = 600 + last10MinCheck;
  99         delay -= now;
 100         if (delay < 1)
 101             delay = 1;
 102         afs_osi_Wait(delay * 1000, &AFS_CSWaitHandler, 0);
 103     }
 104     afs_CheckServerDaemonStarted = 0;
 105 }
 106
 107 void
 108 afs_Daemon(void)
 109 {
 110     afs_int32 code;
 111     struct afs_exporter *exporter;
 112     afs_int32 now;
 113     afs_int32 last3MinCheck, last10MinCheck, last60MinCheck, lastNMinCheck;
 114     afs_int32 last1MinCheck;
 115     afs_uint32 lastCBSlotBump;
 116     char cs_warned = 0;
 117
 118     AFS_STATCNT(afs_Daemon);
 119     last1MinCheck = last3MinCheck = last60MinCheck = last10MinCheck =
 120         lastNMinCheck = 0;
 121
 122     afs_rootFid.Fid.Volume = 0;
 123     while (afs_initState < 101)
 124         afs_osi_Sleep(&afs_initState);
 125
 126     now = osi_Time();
 127     lastCBSlotBump = now;
 128
 129     /* when a lot of clients are booted simultaneously, they develop
 130      * annoying synchronous VL server bashing behaviors.  So we stagger them.
 131      */
 132     last1MinCheck = now + ((afs_random() & 0x7fffffff) % 60);   /* an extra 30 */
 133     last3MinCheck = now - 90 + ((afs_random() & 0x7fffffff) % 180);
 134     last60MinCheck = now - 1800 + ((afs_random() & 0x7fffffff) % 3600);
 135     last10MinCheck = now - 300 + ((afs_random() & 0x7fffffff) % 600);
 136     lastNMinCheck = now - 90 + ((afs_random() & 0x7fffffff) % 180);
 137
 138     /* start off with afs_initState >= 101 (basic init done) */
 139     while (1) {
 140         afs_CheckCallbacks(20); /* unstat anything which will expire soon */
 141
 142         /* things to do every 20 seconds or less - required by protocol spec */
 143         if (afs_nfsexporter)
 144             afs_FlushActiveVcaches(0);  /* flush NFS writes */
 145         afs_FlushVCBs(1);       /* flush queued callbacks */
 146         afs_MaybeWakeupTruncateDaemon();        /* free cache space if have too */
 147         rx_CheckPackets();      /* Does RX need more packets? */
 148 #if     defined(AFS_AIX32_ENV) || defined(AFS_HPUX_ENV)
 149         /*
 150          * Hack: We always want to make sure there are plenty free
 151          * entries in the small free pool so that we don't have to
 152          * worry about rx (with disabled interrupts) to have to call
 153          * malloc). So we do the dummy call below...
 154          */
 155         if (((afs_stats_cmperf.SmallBlocksAlloced -
 156               afs_stats_cmperf.SmallBlocksActive)
 157              <= AFS_SALLOC_LOW_WATER))
 158             osi_FreeSmallSpace(osi_AllocSmallSpace(AFS_SMALLOCSIZ));
 159         if (((afs_stats_cmperf.MediumBlocksAlloced -
 160               afs_stats_cmperf.MediumBlocksActive)
 161              <= AFS_MALLOC_LOW_WATER + 50))
 162             osi_AllocMoreMSpace(AFS_MALLOC_LOW_WATER * 2);
 163 #endif
 164
 165         now = osi_Time();
 166         if (lastCBSlotBump + CBHTSLOTLEN < now) {       /* pretty time-dependant */
 167             lastCBSlotBump = now;
 168             if (afs_BumpBase()) {
 169                 afs_CheckCallbacks(20); /* unstat anything which will expire soon */
 170             }
 171         }
 172
 173         if (last1MinCheck + 60 < now) {
 174             /* things to do every minute */
 175             DFlush();           /* write out dir buffers */
 176             afs_WriteThroughDSlots();   /* write through cacheinfo entries */
 177             afs_FlushActiveVcaches(1);  /* keep flocks held & flush nfs writes */
 178 #ifdef AFS_DISCON_ENV
 179             afs_StoreDirtyVcaches();
 180 #endif
 181             afs_CheckRXEpoch();
 182             last1MinCheck = now;
 183         }
 184
 185         if (last3MinCheck + 180 < now) {
 186             afs_CheckTokenCache();      /* check for access cache resets due to expired
 187                                          * tickets */
 188             last3MinCheck = now;
 189         }
 190         if (!afs_CheckServerDaemonStarted) {
 191             /* Do the check here if the correct afsd is not installed. */
 192             if (!cs_warned) {
 193                 cs_warned = 1;
 194                 printf("Please install afsd with check server daemon.\n");
 195             }
 196             if (lastNMinCheck + PROBE_INTERVAL < now) {
 197                 /* only check down servers */
 198                 afs_CheckServers(1, NULL);
 199                 lastNMinCheck = now;
 200             }
 201         }
 202         if (last10MinCheck + 600 < now) {
 203 #ifdef AFS_USERSPACE_IP_ADDR
 204             extern int rxi_GetcbiInfo(void);
 205 #endif
 206             afs_Trace1(afs_iclSetp, CM_TRACE_PROBEUP, ICL_TYPE_INT32, 600);
 207 #ifdef AFS_USERSPACE_IP_ADDR
 208             if (rxi_GetcbiInfo()) {     /* addresses changed from last time */
 209                 afs_FlushCBs();
 210             }
 211 #else /* AFS_USERSPACE_IP_ADDR */
 212             if (rxi_GetIFInfo()) {      /* addresses changed from last time */
 213                 afs_FlushCBs();
 214             }
 215 #endif /* else AFS_USERSPACE_IP_ADDR */
 216             if (!afs_CheckServerDaemonStarted)
 217                 afs_CheckServers(0, NULL);
 218             afs_GCUserData(0);  /* gc old conns */
 219             /* This is probably the wrong way of doing GC for the various exporters but it will suffice for a while */
 220             for (exporter = root_exported; exporter;
 221                  exporter = exporter->exp_next) {
 222                 (void)EXP_GC(exporter, 0);      /* Generalize params */
 223             }
 224             {
 225                 static int cnt = 0;
 226                 if (++cnt < 12) {
 227                     afs_CheckVolumeNames(AFS_VOLCHECK_EXPIRED |
 228                                          AFS_VOLCHECK_BUSY);
 229                 } else {
 230                     cnt = 0;
 231                     afs_CheckVolumeNames(AFS_VOLCHECK_EXPIRED |
 232                                          AFS_VOLCHECK_BUSY |
 233                                          AFS_VOLCHECK_MTPTS);
 234                 }
 235             }
 236             last10MinCheck = now;
 237         }
 238         if (last60MinCheck + 3600 < now) {
 239             afs_Trace1(afs_iclSetp, CM_TRACE_PROBEVOLUME, ICL_TYPE_INT32,
 240                        3600);
 241             afs_CheckRootVolume();
 242 #if AFS_GCPAGS
 243             if (afs_gcpags == AFS_GCPAGS_OK) {
 244                 afs_int32 didany;
 245                 afs_GCPAGs(&didany);
 246             }
 247 #endif
 248             last60MinCheck = now;
 249         }
 250         if (afs_initState < 300) {      /* while things ain't rosy */
 251             code = afs_CheckRootVolume();
 252             if (code == 0)
 253                 afs_initState = 300;    /* succeeded */
 254             if (afs_initState < 200)
 255                 afs_initState = 200;    /* tried once */
 256             afs_osi_Wakeup(&afs_initState);
 257         }
 258
 259         /* 18285 is because we're trying to divide evenly into 128, that is,
 260          * CBSlotLen, while staying just under 20 seconds.  If CBSlotLen
 261          * changes, should probably change this interval, too.
 262          * Some of the preceding actions may take quite some time, so we
 263          * might not want to wait the entire interval */
 264         now = 18285 - (osi_Time() - now);
 265         if (now > 0) {
 266             afs_osi_Wait(now, &AFS_WaitHandler, 0);
 267         }
 268
 269         if (afs_termState == AFSOP_STOP_AFS) {
 270             if (afs_CheckServerDaemonStarted)
 271                 afs_termState = AFSOP_STOP_CS;
 272             else
 273                 afs_termState = AFSOP_STOP_BKG;
 274             afs_osi_Wakeup(&afs_termState);
 275             return;
 276         }
 277     }
 278 }
 279
 280 int
 281 afs_CheckRootVolume(void)
 282 {
 283     char rootVolName[32];
 284     struct volume *tvp = NULL;
 285     int usingDynroot = afs_GetDynrootEnable();
 286     int localcell;
 287
 288     AFS_STATCNT(afs_CheckRootVolume);
 289     if (*afs_rootVolumeName == 0) {
 290         strcpy(rootVolName, "root.afs");
 291     } else {
 292         strcpy(rootVolName, afs_rootVolumeName);
 293     }
 294
 295     if (!usingDynroot) {
 296         struct cell *lc = afs_GetPrimaryCell(READ_LOCK);
 297
 298         if (!lc)
 299             return ENOENT;
 300         localcell = lc->cellNum;
 301         afs_PutCell(lc, READ_LOCK);
 302     }
 303
 304     if (usingDynroot) {
 305         afs_GetDynrootFid(&afs_rootFid);
 306         tvp = afs_GetVolume(&afs_rootFid, NULL, READ_LOCK);
 307     } else {
 308         tvp = afs_GetVolumeByName(rootVolName, localcell, 1, NULL, READ_LOCK);
 309     }
 310     if (!tvp && !usingDynroot) {
 311         char buf[128];
 312         int len = strlen(rootVolName);
 313
 314         if ((len < 9) || strcmp(&rootVolName[len - 9], ".readonly")) {
 315             strcpy(buf, rootVolName);
 316             afs_strcat(buf, ".readonly");
 317             tvp = afs_GetVolumeByName(buf, localcell, 1, NULL, READ_LOCK);
 318         }
 319     }
 320     if (tvp) {
 321         if (!usingDynroot) {
 322             int volid = (tvp->roVol ? tvp->roVol : tvp->volume);
 323             afs_rootFid.Cell = localcell;
 324             if (afs_rootFid.Fid.Volume && afs_rootFid.Fid.Volume != volid
 325                 && afs_globalVp) {
 326                 /* If we had a root fid before and it changed location we reset
 327                  * the afs_globalVp so that it will be reevaluated.
 328                  * Just decrement the reference count. This only occurs during
 329                  * initial cell setup and can panic the machine if we set the
 330                  * count to zero and fs checkv is executed when the current
 331                  * directory is /afs.
 332                  */
 333                 AFS_FAST_RELE(afs_globalVp);
 334                 afs_globalVp = 0;
 335             }
 336             afs_rootFid.Fid.Volume = volid;
 337             afs_rootFid.Fid.Vnode = 1;
 338             afs_rootFid.Fid.Unique = 1;
 339         }
 340         afs_initState = 300;    /* won */
 341         afs_osi_Wakeup(&afs_initState);
 342         afs_PutVolume(tvp, READ_LOCK);
 343     }
 344 #ifdef AFS_DEC_ENV
 345 /* This is to make sure that we update the root gnode */
 346 /* every time root volume gets released */
 347     {
 348         struct gnode *rootgp;
 349         struct mount *mp;
 350         int code;
 351
 352         /* Only do this if afs_globalVFS is properly set due to race conditions
 353          * this routine could be called before the gfs_mount is performed!
 354          * Furthermore, afs_root (called below) *waits* until
 355          * initState >= 200, so we don't try this until we've gotten
 356          * at least that far */
 357         if (afs_globalVFS && afs_initState >= 200) {
 358             if (code = afs_root(afs_globalVFS, &rootgp))
 359                 return code;
 360             mp = (struct mount *)afs_globalVFS->vfs_data;
 361             mp->m_rootgp = gget(mp, 0, 0, (char *)rootgp);
 362             afs_unlock(mp->m_rootgp);   /* unlock basic gnode */
 363             afs_vrele(VTOAFS(rootgp));  /* zap afs_root's vnode hold */
 364         }
 365     }
 366 #endif
 367     if (afs_rootFid.Fid.Volume)
 368         return 0;
 369     else
 370         return ENOENT;
 371 }
 372
 373 /* ptr_parm 0 is the pathname, size_parm 0 to the fetch is the chunk number */
 374 static void
 375 BPath(register struct brequest *ab)
 376 {
 377     register struct dcache *tdc = NULL;
 378     struct vcache *tvc = NULL;
 379     struct vnode *tvn = NULL;
 380 #ifdef AFS_LINUX22_ENV
 381     struct dentry *dp = NULL;
 382 #endif
 383     afs_size_t offset, len;
 384     struct vrequest treq;
 385     afs_int32 code;
 386
 387     AFS_STATCNT(BPath);
 388     if ((code = afs_InitReq(&treq, ab->cred)))
 389         return;
 390     AFS_GUNLOCK();
 391 #ifdef AFS_LINUX22_ENV
 392     code = gop_lookupname((char *)ab->ptr_parm[0], AFS_UIOSYS, 1, NULL, &dp);
 393     if (dp)
 394         tvn = (struct vnode *)dp->d_inode;
 395 #else
 396     code = gop_lookupname((char *)ab->ptr_parm[0], AFS_UIOSYS, 1, NULL, &tvn);
 397 #endif
 398     AFS_GLOCK();
 399     osi_FreeLargeSpace((char *)ab->ptr_parm[0]);        /* free path name buffer here */
 400     if (code)
 401         return;
 402     /* now path may not have been in afs, so check that before calling our cache manager */
 403     if (!tvn || !IsAfsVnode(tvn)) {
 404         /* release it and give up */
 405         if (tvn) {
 406 #ifdef AFS_DEC_ENV
 407             grele(tvn);
 408 #else
 409 #ifdef AFS_LINUX22_ENV
 410             dput(dp);
 411 #else
 412             AFS_RELE(tvn);
 413 #endif
 414 #endif
 415         }
 416         return;
 417     }
 418 #ifdef AFS_DEC_ENV
 419     tvc = VTOAFS(afs_gntovn(tvn));
 420 #else
 421     tvc = VTOAFS(tvn);
 422 #endif
 423     /* here we know its an afs vnode, so we can get the data for the chunk */
 424     tdc = afs_GetDCache(tvc, ab->size_parm[0], &treq, &offset, &len, 1);
 425     if (tdc) {
 426         afs_PutDCache(tdc);
 427     }
 428 #ifdef AFS_DEC_ENV
 429     grele(tvn);
 430 #else
 431 #ifdef AFS_LINUX22_ENV
 432     dput(dp);
 433 #else
 434     AFS_RELE(tvn);
 435 #endif
 436 #endif
 437 }
 438
 439 /* size_parm 0 to the fetch is the chunk number,
 440  * ptr_parm 0 is the dcache entry to wakeup,
 441  * size_parm 1 is true iff we should release the dcache entry here.
 442  */
 443 static void
 444 BPrefetch(register struct brequest *ab)
 445 {
 446     register struct dcache *tdc;
 447     register struct vcache *tvc;
 448     afs_size_t offset, len;
 449     struct vrequest treq;
 450
 451     AFS_STATCNT(BPrefetch);
 452     if ((len = afs_InitReq(&treq, ab->cred)))
 453         return;
 454     tvc = ab->vc;
 455     tdc = afs_GetDCache(tvc, ab->size_parm[0], &treq, &offset, &len, 1);
 456     if (tdc) {
 457         afs_PutDCache(tdc);
 458     }
 459     /* now, dude may be waiting for us to clear DFFetchReq bit; do so.  Can't
 460      * use tdc from GetDCache since afs_GetDCache may fail, but someone may
 461      * be waiting for our wakeup anyway.
 462      */
 463     tdc = (struct dcache *)(ab->ptr_parm[0]);
 464     ObtainSharedLock(&tdc->lock, 640);
 465     if (tdc->mflags & DFFetchReq) {
 466         UpgradeSToWLock(&tdc->lock, 641);
 467         tdc->mflags &= ~DFFetchReq;
 468         ReleaseWriteLock(&tdc->lock);
 469     } else {
 470         ReleaseSharedLock(&tdc->lock);
 471     }
 472     afs_osi_Wakeup(&tdc->validPos);
 473     if (ab->size_parm[1]) {
 474         afs_PutDCache(tdc);     /* put this one back, too */
 475     }
 476 }
 477
 478
 479 static void
 480 BStore(register struct brequest *ab)
 481 {
 482     register struct vcache *tvc;
 483     register afs_int32 code;
 484     struct vrequest treq;
 485 #if defined(AFS_SGI_ENV)
 486     struct cred *tmpcred;
 487 #endif
 488
 489     AFS_STATCNT(BStore);
 490     if ((code = afs_InitReq(&treq, ab->cred)))
 491         return;
 492     code = 0;
 493     tvc = ab->vc;
 494 #if defined(AFS_SGI_ENV)
 495     /*
 496      * Since StoreOnLastReference can end up calling osi_SyncVM which
 497      * calls into VM code that assumes that u.u_cred has the
 498      * correct credentials, we set our to theirs for this xaction
 499      */
 500     tmpcred = OSI_GET_CURRENT_CRED();
 501     OSI_SET_CURRENT_CRED(ab->cred);
 502
 503     /*
 504      * To avoid recursion since the WriteLock may be released during VM
 505      * operations, we hold the VOP_RWLOCK across this transaction as
 506      * do the other callers of StoreOnLastReference
 507      */
 508     AFS_RWLOCK((vnode_t *) tvc, 1);
 509 #endif
 510     ObtainWriteLock(&tvc->lock, 209);
 511     code = afs_StoreOnLastReference(tvc, &treq);
 512     ReleaseWriteLock(&tvc->lock);
 513 #if defined(AFS_SGI_ENV)
 514     OSI_SET_CURRENT_CRED(tmpcred);
 515     AFS_RWUNLOCK((vnode_t *) tvc, 1);
 516 #endif
 517     /* now set final return code, and wakeup anyone waiting */
 518     if ((ab->flags & BUVALID) == 0) {
 519         ab->code = afs_CheckCode(code, &treq, 43);      /* set final code, since treq doesn't go across processes */
 520         ab->flags |= BUVALID;
 521         if (ab->flags & BUWAIT) {
 522             ab->flags &= ~BUWAIT;
 523             afs_osi_Wakeup(ab);
 524         }
 525     }
 526 }
 527
 528 /* release a held request buffer */
 529 void
 530 afs_BRelease(register struct brequest *ab)
 531 {
 532
 533     AFS_STATCNT(afs_BRelease);
 534     MObtainWriteLock(&afs_xbrs, 294);
 535     if (--ab->refCount <= 0) {
 536         ab->flags = 0;
 537     }
 538     if (afs_brsWaiters)
 539         afs_osi_Wakeup(&afs_brsWaiters);
 540     MReleaseWriteLock(&afs_xbrs);
 541 }
 542
 543 /* return true if bkg fetch daemons are all busy */
 544 int
 545 afs_BBusy(void)
 546 {
 547     AFS_STATCNT(afs_BBusy);
 548     if (afs_brsDaemons > 0)
 549         return 0;
 550     return 1;
 551 }
 552
 553 struct brequest *
 554 afs_BQueue(register short aopcode, register struct vcache *avc,
 555            afs_int32 dontwait, afs_int32 ause, struct AFS_UCRED *acred,
 556            afs_size_t asparm0, afs_size_t asparm1, void *apparm0)
 557 {
 558     register int i;
 559     register struct brequest *tb;
 560
 561     AFS_STATCNT(afs_BQueue);
 562     MObtainWriteLock(&afs_xbrs, 296);
 563     while (1) {
 564         tb = afs_brs;
 565         for (i = 0; i < NBRS; i++, tb++) {
 566             if (tb->refCount == 0)
 567                 break;
 568         }
 569         if (i < NBRS) {
 570             /* found a buffer */
 571             tb->opcode = aopcode;
 572             tb->vc = avc;
 573             tb->cred = acred;
 574             crhold(tb->cred);
 575             if (avc) {
 576 #ifdef  AFS_DEC_ENV
 577                 avc->vrefCount++;
 578 #else
 579                 VN_HOLD(AFSTOV(avc));
 580 #endif
 581             }
 582             tb->refCount = ause + 1;
 583             tb->size_parm[0] = asparm0;
 584             tb->size_parm[1] = asparm1;
 585             tb->ptr_parm[0] = apparm0;
 586             tb->flags = 0;
 587             tb->code = 0;
 588             tb->ts = afs_brs_count++;
 589             /* if daemons are waiting for work, wake them up */
 590             if (afs_brsDaemons > 0) {
 591                 afs_osi_Wakeup(&afs_brsDaemons);
 592             }
 593             MReleaseWriteLock(&afs_xbrs);
 594             return tb;
 595         }
 596         if (dontwait) {
 597             MReleaseWriteLock(&afs_xbrs);
 598             return NULL;
 599         }
 600         /* no free buffers, sleep a while */
 601         afs_brsWaiters++;
 602         MReleaseWriteLock(&afs_xbrs);
 603         afs_osi_Sleep(&afs_brsWaiters);
 604         MObtainWriteLock(&afs_xbrs, 301);
 605         afs_brsWaiters--;
 606     }
 607 }
 608
 609 #ifdef  AFS_AIX32_ENV
 610 #ifdef AFS_AIX41_ENV
 611 /* AIX 4.1 has a much different sleep/wakeup mechanism available for use.
 612  * The modifications here will work for either a UP or MP machine.
 613  */
 614 struct buf *afs_asyncbuf = (struct buf *)0;
 615 tid_t afs_asyncbuf_cv = EVENT_NULL;
 616 afs_int32 afs_biodcnt = 0;
 617
 618 /* in implementing this, I assumed that all external linked lists were
 619  * null-terminated.
 620  *
 621  * Several places in this code traverse a linked list.  The algorithm
 622  * used here is probably unfamiliar to most people.  Careful examination
 623  * will show that it eliminates an assignment inside the loop, as compared
 624  * to the standard algorithm, at the cost of occasionally using an extra
 625  * variable.
 626  */
 627
 628 /* get_bioreq()
 629  *
 630  * This function obtains, and returns, a pointer to a buffer for
 631  * processing by a daemon.  It sleeps until such a buffer is available.
 632  * The source of buffers for it is the list afs_asyncbuf (see also
 633  * naix_vm_strategy).  This function may be invoked concurrently by
 634  * several processes, that is, several instances of the same daemon.
 635  * naix_vm_strategy, which adds buffers to the list, runs at interrupt
 636  * level, while get_bioreq runs at process level.
 637  *
 638  * Since AIX 4.1 can wake just one process at a time, the separate sleep
 639  * addresses have been removed.
 640  * Note that the kernel_lock is held until the e_sleep_thread() occurs.
 641  * The afs_asyncbuf_lock is primarily used to serialize access between
 642  * process and interrupts.
 643  */
 644 Simple_lock afs_asyncbuf_lock;
 645 /*static*/ struct buf *
 646 afs_get_bioreq()
 647 {
 648     struct buf *bp = NULL;
 649     struct buf *bestbp;
 650     struct buf **bestlbpP, **lbpP;
 651     long bestage, stop;
 652     struct buf *t1P, *t2P;      /* temp pointers for list manipulation */
 653     int oldPriority;
 654     afs_uint32 wait_ret;
 655     struct afs_bioqueue *s;
 656
 657     /* ??? Does the forward pointer of the returned buffer need to be NULL?
 658      */
 659
 660     /* Disable interrupts from the strategy function, and save the
 661      * prior priority level and lock access to the afs_asyncbuf.
 662      */
 663     AFS_GUNLOCK();
 664     oldPriority = disable_lock(INTMAX, &afs_asyncbuf_lock);
 665
 666     while (1) {
 667         if (afs_asyncbuf) {
 668             /* look for oldest buffer */
 669             bp = bestbp = afs_asyncbuf;
 670             bestage = (long)bestbp->av_back;
 671             bestlbpP = &afs_asyncbuf;
 672             while (1) {
 673                 lbpP = &bp->av_forw;
 674                 bp = *lbpP;
 675                 if (!bp)
 676                     break;
 677                 if ((long)bp->av_back - bestage < 0) {
 678                     bestbp = bp;
 679                     bestlbpP = lbpP;
 680                     bestage = (long)bp->av_back;
 681                 }
 682             }
 683             bp = bestbp;
 684             *bestlbpP = bp->av_forw;
 685             break;
 686         } else {
 687             /* If afs_asyncbuf is null, it is necessary to go to sleep.
 688              * e_wakeup_one() ensures that only one thread wakes.
 689              */
 690             int interrupted;
 691             /* The LOCK_HANDLER indicates to e_sleep_thread to only drop the
 692              * lock on an MP machine.
 693              */
 694             interrupted =
 695                 e_sleep_thread(&afs_asyncbuf_cv, &afs_asyncbuf_lock,
 696                                LOCK_HANDLER | INTERRUPTIBLE);
 697             if (interrupted == THREAD_INTERRUPTED) {
 698                 /* re-enable interrupts from strategy */
 699                 unlock_enable(oldPriority, &afs_asyncbuf_lock);
 700                 AFS_GLOCK();
 701                 return (NULL);
 702             }
 703         }                       /* end of "else asyncbuf is empty" */
 704     }                           /* end of "inner loop" */
 705
 706     /*assert (bp); */
 707
 708     unlock_enable(oldPriority, &afs_asyncbuf_lock);
 709     AFS_GLOCK();
 710
 711     /* For the convenience of other code, replace the gnodes in
 712      * the b_vp field of bp and the other buffers on the b_work
 713      * chain with the corresponding vnodes.
 714      *
 715      * ??? what happens to the gnodes?  They're not just cut loose,
 716      * are they?
 717      */
 718     for (t1P = bp;;) {
 719         t2P = (struct buf *)t1P->b_work;
 720         t1P->b_vp = ((struct gnode *)t1P->b_vp)->gn_vnode;
 721         if (!t2P)
 722             break;
 723
 724         t1P = (struct buf *)t2P->b_work;
 725         t2P->b_vp = ((struct gnode *)t2P->b_vp)->gn_vnode;
 726         if (!t1P)
 727             break;
 728     }
 729
 730     /* If the buffer does not specify I/O, it may immediately
 731      * be returned to the caller.  This condition is detected
 732      * by examining the buffer's flags (the b_flags field).  If
 733      * the B_PFPROT bit is set, the buffer represents a protection
 734      * violation, rather than a request for I/O.  The remainder
 735      * of the outer loop handles the case where the B_PFPROT bit is clear.
 736      */
 737     if (bp->b_flags & B_PFPROT) {
 738         return (bp);
 739     }
 740     return (bp);
 741
 742 }                               /* end of function get_bioreq() */
 743
 744
 745 /* afs_BioDaemon
 746  *
 747  * This function is the daemon.  It is called from the syscall
 748  * interface.  Ordinarily, a script or an administrator will run a
 749  * daemon startup utility, specifying the number of I/O daemons to
 750  * run.  The utility will fork off that number of processes,
 751  * each making the appropriate syscall, which will cause this
 752  * function to be invoked.
 753  */
 754 static int afs_initbiod = 0;    /* this is self-initializing code */
 755 int DOvmlock = 0;
 756 int
 757 afs_BioDaemon(afs_int32 nbiods)
 758 {
 759     afs_int32 code, s, pflg = 0;
 760     label_t jmpbuf;
 761     struct buf *bp, *bp1, *tbp1, *tbp2; /* temp pointers only */
 762     caddr_t tmpaddr;
 763     struct vnode *vp;
 764     struct vcache *vcp;
 765     char tmperr;
 766     if (!afs_initbiod) {
 767         /* XXX ###1 XXX */
 768         afs_initbiod = 1;
 769         /* pin lock, since we'll be using it in an interrupt. */
 770         lock_alloc(&afs_asyncbuf_lock, LOCK_ALLOC_PIN, 2, 1);
 771         simple_lock_init(&afs_asyncbuf_lock);
 772         pin(&afs_asyncbuf, sizeof(struct buf *));
 773         pin(&afs_asyncbuf_cv, sizeof(afs_int32));
 774     }
 775
 776     /* Ignore HUP signals... */
 777     {
 778         sigset_t sigbits, osigbits;
 779         /*
 780          * add SIGHUP to the set of already masked signals
 781          */
 782         SIGFILLSET(sigbits);    /* allow all signals    */
 783         SIGDELSET(sigbits, SIGHUP);     /*   except SIGHUP      */
 784         limit_sigs(&sigbits, &osigbits);        /*   and already masked */
 785     }
 786     /* Main body starts here -- this is an intentional infinite loop, and
 787      * should NEVER exit
 788      *
 789      * Now, the loop will exit if get_bioreq() returns NULL, indicating
 790      * that we've been interrupted.
 791      */
 792     while (1) {
 793         bp = afs_get_bioreq();
 794         if (!bp)
 795             break;              /* we were interrupted */
 796         if (code = setjmpx(&jmpbuf)) {
 797             /* This should not have happend, maybe a lack of resources  */
 798             AFS_GUNLOCK();
 799             s = disable_lock(INTMAX, &afs_asyncbuf_lock);
 800             for (bp1 = bp; bp; bp = bp1) {
 801                 if (bp1)
 802                     bp1 = (struct buf *)bp1->b_work;
 803                 bp->b_actf = 0;
 804                 bp->b_error = code;
 805                 bp->b_flags |= B_ERROR;
 806                 iodone(bp);
 807             }
 808             unlock_enable(s, &afs_asyncbuf_lock);
 809             AFS_GLOCK();
 810             continue;
 811         }
 812         vcp = VTOAFS(bp->b_vp);
 813         if (bp->b_flags & B_PFSTORE) {  /* XXXX */
 814             ObtainWriteLock(&vcp->lock, 404);
 815             if (vcp->v.v_gnode->gn_mwrcnt) {
 816                 afs_offs_t newlength =
 817                     (afs_offs_t) dbtob(bp->b_blkno) + bp->b_bcount;
 818                 if (vcp->m.Length < newlength) {
 819                     afs_Trace4(afs_iclSetp, CM_TRACE_SETLENGTH,
 820                                ICL_TYPE_STRING, __FILE__, ICL_TYPE_LONG,
 821                                __LINE__, ICL_TYPE_OFFSET,
 822                                ICL_HANDLE_OFFSET(vcp->m.Length),
 823                                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(newlength));
 824                     vcp->m.Length = newlength;
 825                 }
 826             }
 827             ReleaseWriteLock(&vcp->lock);
 828         }
 829         /* If the buffer represents a protection violation, rather than
 830          * an actual request for I/O, no special action need be taken.
 831          */
 832         if (bp->b_flags & B_PFPROT) {
 833             iodone(bp);         /* Notify all users of the buffer that we're done */
 834             clrjmpx(&jmpbuf);
 835             continue;
 836         }
 837         if (DOvmlock)
 838             ObtainWriteLock(&vcp->pvmlock, 211);
 839         /*
 840          * First map its data area to a region in the current address space
 841          * by calling vm_att with the subspace identifier, and a pointer to
 842          * the data area.  vm_att returns  a new data area pointer, but we
 843          * also want to hang onto the old one.
 844          */
 845         tmpaddr = bp->b_baddr;
 846         bp->b_baddr = (caddr_t) vm_att(bp->b_xmemd.subspace_id, tmpaddr);
 847         tmperr = afs_ustrategy(bp);     /* temp variable saves offset calculation */
 848         if (tmperr) {           /* in non-error case */
 849             bp->b_flags |= B_ERROR;     /* should other flags remain set ??? */
 850             bp->b_error = tmperr;
 851         }
 852
 853         /* Unmap the buffer's data area by calling vm_det.  Reset data area
 854          * to the value that we saved above.
 855          */
 856         vm_det(bp->b_baddr);
 857         bp->b_baddr = tmpaddr;
 858
 859         /*
 860          * buffer may be linked with other buffers via the b_work field.
 861          * See also naix_vm_strategy.  For each buffer in the chain (including
 862          * bp) notify all users of the buffer that the daemon is finished
 863          * using it by calling iodone.
 864          * assumes iodone can modify the b_work field.
 865          */
 866         for (tbp1 = bp;;) {
 867             tbp2 = (struct buf *)tbp1->b_work;
 868             iodone(tbp1);
 869             if (!tbp2)
 870                 break;
 871
 872             tbp1 = (struct buf *)tbp2->b_work;
 873             iodone(tbp2);
 874             if (!tbp1)
 875                 break;
 876         }
 877         if (DOvmlock)
 878             ReleaseWriteLock(&vcp->pvmlock);    /* Unlock the vnode.  */
 879         clrjmpx(&jmpbuf);
 880     }                           /* infinite loop (unless we're interrupted) */
 881 }                               /* end of afs_BioDaemon() */
 882
 883 #else /* AFS_AIX41_ENV */
 884
 885
 886 #define squeue afs_q
 887 struct afs_bioqueue {
 888     struct squeue lruq;
 889     int sleeper;
 890     int cnt;
 891 };
 892 struct afs_bioqueue afs_bioqueue;
 893 struct buf *afs_busyq = NULL;
 894 struct buf *afs_asyncbuf;
 895 afs_int32 afs_biodcnt = 0;
 896
 897 /* in implementing this, I assumed that all external linked lists were
 898  * null-terminated.
 899  *
 900  * Several places in this code traverse a linked list.  The algorithm
 901  * used here is probably unfamiliar to most people.  Careful examination
 902  * will show that it eliminates an assignment inside the loop, as compared
 903  * to the standard algorithm, at the cost of occasionally using an extra
 904  * variable.
 905  */
 906
 907 /* get_bioreq()
 908  *
 909  * This function obtains, and returns, a pointer to a buffer for
 910  * processing by a daemon.  It sleeps until such a buffer is available.
 911  * The source of buffers for it is the list afs_asyncbuf (see also
 912  * naix_vm_strategy).  This function may be invoked concurrently by
 913  * several processes, that is, several instances of the same daemon.
 914  * naix_vm_strategy, which adds buffers to the list, runs at interrupt
 915  * level, while get_bioreq runs at process level.
 916  *
 917  * The common kernel paradigm of sleeping and waking up, in which all the
 918  * competing processes sleep waiting for wakeups on one address, is not
 919  * followed here.  Instead, the following paradigm is used:  when a daemon
 920  * goes to sleep, it checks for other sleeping daemons.  If there aren't any,
 921  * it sleeps on the address of variable afs_asyncbuf.  But if there is
 922  * already a daemon sleeping on that address, it threads its own unique
 923  * address onto a list, and sleeps on that address.  This way, every
 924  * sleeper is sleeping on a different address, and every wakeup wakes up
 925  * exactly one daemon.  This prevents a whole bunch of daemons from waking
 926  * up and then immediately having to go back to sleep.  This provides a
 927  * performance gain and makes the I/O scheduling a bit more deterministic.
 928  * The list of sleepers is variable afs_bioqueue.  The unique address
 929  * on which to sleep is passed to get_bioreq as its parameter.
 930  */
 931 /*static*/ struct buf *
 932 afs_get_bioreq(self)
 933      struct afs_bioqueue *self; /* address on which to sleep */
 934
 935 {
 936     struct buf *bp = NULL;
 937     struct buf *bestbp;
 938     struct buf **bestlbpP, **lbpP;
 939     int bestage, stop;
 940     struct buf *t1P, *t2P;      /* temp pointers for list manipulation */
 941     int oldPriority;
 942     afs_uint32 wait_ret;
 943     struct afs_bioqueue *s;
 944
 945     /* ??? Does the forward pointer of the returned buffer need to be NULL?
 946      */
 947
 948     /* Disable interrupts from the strategy function, and save the
 949      * prior priority level
 950      */
 951     oldPriority = i_disable(INTMAX);
 952
 953     /* Each iteration of following loop either pulls
 954      * a buffer off afs_asyncbuf, or sleeps.
 955      */
 956     while (1) {                 /* inner loop */
 957         if (afs_asyncbuf) {
 958             /* look for oldest buffer */
 959             bp = bestbp = afs_asyncbuf;
 960             bestage = (int)bestbp->av_back;
 961             bestlbpP = &afs_asyncbuf;
 962             while (1) {
 963                 lbpP = &bp->av_forw;
 964                 bp = *lbpP;
 965                 if (!bp)
 966                     break;
 967                 if ((int)bp->av_back - bestage < 0) {
 968                     bestbp = bp;
 969                     bestlbpP = lbpP;
 970                     bestage = (int)bp->av_back;
 971                 }
 972             }
 973             bp = bestbp;
 974             *bestlbpP = bp->av_forw;
 975             break;
 976         } else {
 977             int interrupted;
 978
 979             /* If afs_asyncbuf is null, it is necessary to go to sleep.
 980              * There are two possibilities:  either there is already a
 981              * daemon that is sleeping on the address of afs_asyncbuf,
 982              * or there isn't.
 983              */
 984             if (afs_bioqueue.sleeper) {
 985                 /* enqueue */
 986                 QAdd(&(afs_bioqueue.lruq), &(self->lruq));
 987                 interrupted = sleep((caddr_t) self, PCATCH | (PZERO + 1));
 988                 if (self->lruq.next != &self->lruq) {   /* XXX ##3 XXX */
 989                     QRemove(&(self->lruq));     /* dequeue */
 990                 }
 991                 self->cnt++;
 992                 afs_bioqueue.sleeper = FALSE;
 993                 if (interrupted) {
 994                     /* re-enable interrupts from strategy */
 995                     i_enable(oldPriority);
 996                     return (NULL);
 997                 }
 998                 continue;
 999             } else {
1000                 afs_bioqueue.sleeper = TRUE;
1001                 interrupted =
1002                     sleep((caddr_t) & afs_asyncbuf, PCATCH | (PZERO + 1));
1003                 afs_bioqueue.sleeper = FALSE;
1004                 if (interrupted) {
1005                     /*
1006                      * We need to wakeup another daemon if present
1007                      * since we were waiting on afs_asyncbuf.
1008                      */
1009 #ifdef  notdef                  /* The following doesn't work as advertised */
1010                     if (afs_bioqueue.lruq.next != &afs_bioqueue.lruq) {
1011                         struct squeue *bq = afs_bioqueue.lruq.next;
1012                         QRemove(bq);
1013                         wakeup(bq);
1014                     }
1015 #endif
1016                     /* re-enable interrupts from strategy */
1017                     i_enable(oldPriority);
1018                     return (NULL);
1019                 }
1020                 continue;
1021             }
1022
1023         }                       /* end of "else asyncbuf is empty" */
1024     }                           /* end of "inner loop" */
1025
1026     /*assert (bp); */
1027
1028     i_enable(oldPriority);      /* re-enable interrupts from strategy */
1029
1030     /* For the convenience of other code, replace the gnodes in
1031      * the b_vp field of bp and the other buffers on the b_work
1032      * chain with the corresponding vnodes.
1033      *
1034      * ??? what happens to the gnodes?  They're not just cut loose,
1035      * are they?
1036      */
1037     for (t1P = bp;;) {
1038         t2P = (struct buf *)t1P->b_work;
1039         t1P->b_vp = ((struct gnode *)t1P->b_vp)->gn_vnode;
1040         if (!t2P)
1041             break;
1042
1043         t1P = (struct buf *)t2P->b_work;
1044         t2P->b_vp = ((struct gnode *)t2P->b_vp)->gn_vnode;
1045         if (!t1P)
1046             break;
1047     }
1048
1049     /* If the buffer does not specify I/O, it may immediately
1050      * be returned to the caller.  This condition is detected
1051      * by examining the buffer's flags (the b_flags field).  If
1052      * the B_PFPROT bit is set, the buffer represents a protection
1053      * violation, rather than a request for I/O.  The remainder
1054      * of the outer loop handles the case where the B_PFPROT bit is clear.
1055      */
1056     if (bp->b_flags & B_PFPROT) {
1057         return (bp);
1058     }
1059
1060     /* wake up another process to handle the next buffer, and return
1061      * bp to the caller.
1062      */
1063     oldPriority = i_disable(INTMAX);
1064
1065     /* determine where to find the sleeping process.
1066      * There are two cases: either it is sleeping on
1067      * afs_asyncbuf, or it is sleeping on its own unique
1068      * address.  These cases are distinguished by examining
1069      * the sleeper field of afs_bioqueue.
1070      */
1071     if (afs_bioqueue.sleeper) {
1072         wakeup(&afs_asyncbuf);
1073     } else {
1074         if (afs_bioqueue.lruq.next == &afs_bioqueue.lruq) {
1075             /* queue is empty, what now? ??? */
1076             /* Should this be impossible, or does    */
1077             /* it just mean that nobody is sleeping? */ ;
1078         } else {
1079             struct squeue *bq = afs_bioqueue.lruq.next;
1080             QRemove(bq);
1081             QInit(bq);
1082             wakeup(bq);
1083             afs_bioqueue.sleeper = TRUE;
1084         }
1085     }
1086     i_enable(oldPriority);      /* re-enable interrupts from strategy */
1087     return (bp);
1088
1089 }                               /* end of function get_bioreq() */
1090
1091
1092 /* afs_BioDaemon
1093  *
1094  * This function is the daemon.  It is called from the syscall
1095  * interface.  Ordinarily, a script or an administrator will run a
1096  * daemon startup utility, specifying the number of I/O daemons to
1097  * run.  The utility will fork off that number of processes,
1098  * each making the appropriate syscall, which will cause this
1099  * function to be invoked.
1100  */
1101 static int afs_initbiod = 0;    /* this is self-initializing code */
1102 int DOvmlock = 0;
1103 afs_BioDaemon(nbiods)
1104      afs_int32 nbiods;
1105 {
1106     struct afs_bioqueue *self;
1107     afs_int32 code, s, pflg = 0;
1108     label_t jmpbuf;
1109     struct buf *bp, *bp1, *tbp1, *tbp2; /* temp pointers only */
1110     caddr_t tmpaddr;
1111     struct vnode *vp;
1112     struct vcache *vcp;
1113     char tmperr;
1114     if (!afs_initbiod) {
1115         /* XXX ###1 XXX */
1116         afs_initbiod = 1;
1117         /* Initialize the queue of waiting processes, afs_bioqueue.  */
1118         QInit(&(afs_bioqueue.lruq));
1119     }
1120
1121     /* establish ourself as a kernel process so shutdown won't kill us */
1122 /*    u.u_procp->p_flag |= SKPROC;*/
1123
1124     /* Initialize a token (self) to use in the queue of sleeping processes.   */
1125     self = (struct afs_bioqueue *)afs_osi_Alloc(sizeof(struct afs_bioqueue));
1126     pin(self, sizeof(struct afs_bioqueue));     /* fix in memory */
1127     memset(self, 0, sizeof(*self));
1128     QInit(&(self->lruq));       /* initialize queue entry pointers */
1129
1130
1131     /* Ignore HUP signals... */
1132     SIGDELSET(u.u_procp->p_sig, SIGHUP);
1133     SIGADDSET(u.u_procp->p_sigignore, SIGHUP);
1134     SIGDELSET(u.u_procp->p_sigcatch, SIGHUP);
1135     /* Main body starts here -- this is an intentional infinite loop, and
1136      * should NEVER exit
1137      *
1138      * Now, the loop will exit if get_bioreq() returns NULL, indicating
1139      * that we've been interrupted.
1140      */
1141     while (1) {
1142         bp = afs_get_bioreq(self);
1143         if (!bp)
1144             break;              /* we were interrupted */
1145         if (code = setjmpx(&jmpbuf)) {
1146             /* This should not have happend, maybe a lack of resources  */
1147             s = splimp();
1148             for (bp1 = bp; bp; bp = bp1) {
1149                 if (bp1)
1150                     bp1 = bp1->b_work;
1151                 bp->b_actf = 0;
1152                 bp->b_error = code;
1153                 bp->b_flags |= B_ERROR;
1154                 iodone(bp);
1155             }
1156             splx(s);
1157             continue;
1158         }
1159         vcp = VTOAFS(bp->b_vp);
1160         if (bp->b_flags & B_PFSTORE) {
1161             ObtainWriteLock(&vcp->lock, 210);
1162             if (vcp->v.v_gnode->gn_mwrcnt) {
1163                 afs_offs_t newlength =
1164                     (afs_offs_t) dbtob(bp->b_blkno) + bp->b_bcount;
1165                 if (vcp->m.Length < newlength) {
1166                     afs_Trace4(afs_iclSetp, CM_TRACE_SETLENGTH,
1167                                ICL_TYPE_STRING, __FILE__, ICL_TYPE_LONG,
1168                                __LINE__, ICL_TYPE_OFFSET,
1169                                ICL_HANDLE_OFFSET(vcp->m.Length),
1170                                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(newlength));
1171                     vcp->m.Length = newlength;
1172                 }
1173             }
1174             ReleaseWriteLock(&vcp->lock);
1175         }
1176         /* If the buffer represents a protection violation, rather than
1177          * an actual request for I/O, no special action need be taken.
1178          */
1179         if (bp->b_flags & B_PFPROT) {
1180             iodone(bp);         /* Notify all users of the buffer that we're done */
1181             continue;
1182         }
1183         if (DOvmlock)
1184             ObtainWriteLock(&vcp->pvmlock, 558);
1185         /*
1186          * First map its data area to a region in the current address space
1187          * by calling vm_att with the subspace identifier, and a pointer to
1188          * the data area.  vm_att returns  a new data area pointer, but we
1189          * also want to hang onto the old one.
1190          */
1191         tmpaddr = bp->b_baddr;
1192         bp->b_baddr = vm_att(bp->b_xmemd.subspace_id, tmpaddr);
1193         tmperr = afs_ustrategy(bp);     /* temp variable saves offset calculation */
1194         if (tmperr) {           /* in non-error case */
1195             bp->b_flags |= B_ERROR;     /* should other flags remain set ??? */
1196             bp->b_error = tmperr;
1197         }
1198
1199         /* Unmap the buffer's data area by calling vm_det.  Reset data area
1200          * to the value that we saved above.
1201          */
1202         vm_det(bp->b_un.b_addr);
1203         bp->b_baddr = tmpaddr;
1204
1205         /*
1206          * buffer may be linked with other buffers via the b_work field.
1207          * See also naix_vm_strategy.  For each buffer in the chain (including
1208          * bp) notify all users of the buffer that the daemon is finished
1209          * using it by calling iodone.
1210          * assumes iodone can modify the b_work field.
1211          */
1212         for (tbp1 = bp;;) {
1213             tbp2 = (struct buf *)tbp1->b_work;
1214             iodone(tbp1);
1215             if (!tbp2)
1216                 break;
1217
1218             tbp1 = (struct buf *)tbp2->b_work;
1219             iodone(tbp2);
1220             if (!tbp1)
1221                 break;
1222         }
1223         if (DOvmlock)
1224             ReleaseWriteLock(&vcp->pvmlock);    /* Unlock the vnode.  */
1225         clrjmpx(&jmpbuf);
1226     }                           /* infinite loop (unless we're interrupted) */
1227     unpin(self, sizeof(struct afs_bioqueue));
1228     afs_osi_Free(self, sizeof(struct afs_bioqueue));
1229 }                               /* end of afs_BioDaemon() */
1230 #endif /* AFS_AIX41_ENV */
1231 #endif /* AFS_AIX32_ENV */
1232
1233
1234 int afs_nbrs = 0;
1235 void
1236 afs_BackgroundDaemon(void)
1237 {
1238     struct brequest *tb;
1239     int i, foundAny;
1240
1241     AFS_STATCNT(afs_BackgroundDaemon);
1242     /* initialize subsystem */
1243     if (brsInit == 0) {
1244         LOCK_INIT(&afs_xbrs, "afs_xbrs");
1245         memset((char *)afs_brs, 0, sizeof(afs_brs));
1246         brsInit = 1;
1247 #if defined (AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
1248         /*
1249          * steal the first daemon for doing delayed DSlot flushing
1250          * (see afs_GetDownDSlot)
1251          */
1252         AFS_GUNLOCK();
1253         afs_sgidaemon();
1254         return;
1255 #endif
1256     }
1257     afs_nbrs++;
1258
1259     MObtainWriteLock(&afs_xbrs, 302);
1260     while (1) {
1261         int min_ts = 0;
1262         struct brequest *min_tb = NULL;
1263
1264         if (afs_termState == AFSOP_STOP_BKG) {
1265             if (--afs_nbrs <= 0)
1266                 afs_termState = AFSOP_STOP_TRUNCDAEMON;
1267             MReleaseWriteLock(&afs_xbrs);
1268             afs_osi_Wakeup(&afs_termState);
1269             return;
1270         }
1271
1272         /* find a request */
1273         tb = afs_brs;
1274         foundAny = 0;
1275         for (i = 0; i < NBRS; i++, tb++) {
1276             /* look for request with smallest ts */
1277             if ((tb->refCount > 0) && !(tb->flags & BSTARTED)) {
1278                 /* new request, not yet picked up */
1279                 if ((min_tb && (min_ts - tb->ts > 0)) || !min_tb) {
1280                     min_tb = tb;
1281                     min_ts = tb->ts;
1282                 }
1283             }
1284         }
1285         if ((tb = min_tb)) {
1286             /* claim and process this request */
1287             tb->flags |= BSTARTED;
1288             MReleaseWriteLock(&afs_xbrs);
1289             foundAny = 1;
1290             afs_Trace1(afs_iclSetp, CM_TRACE_BKG1, ICL_TYPE_INT32,
1291                        tb->opcode);
1292             if (tb->opcode == BOP_FETCH)
1293                 BPrefetch(tb);
1294             else if (tb->opcode == BOP_STORE)
1295                 BStore(tb);
1296             else if (tb->opcode == BOP_PATH)
1297                 BPath(tb);
1298             else
1299                 panic("background bop");
1300             if (tb->vc) {
1301 #ifdef  AFS_DEC_ENV
1302                 tb->vc->vrefCount--;    /* fix up reference count */
1303 #else
1304                 AFS_RELE(AFSTOV(tb->vc));       /* MUST call vnode layer or could lose vnodes */
1305 #endif
1306                 tb->vc = NULL;
1307             }
1308             if (tb->cred) {
1309                 crfree(tb->cred);
1310                 tb->cred = (struct AFS_UCRED *)0;
1311             }
1312             afs_BRelease(tb);   /* this grabs and releases afs_xbrs lock */
1313             MObtainWriteLock(&afs_xbrs, 305);
1314         }
1315         if (!foundAny) {
1316             /* wait for new request */
1317             afs_brsDaemons++;
1318             MReleaseWriteLock(&afs_xbrs);
1319             afs_osi_Sleep(&afs_brsDaemons);
1320             MObtainWriteLock(&afs_xbrs, 307);
1321             afs_brsDaemons--;
1322         }
1323     }
1324 }
1325
1326
1327 void
1328 shutdown_daemons(void)
1329 {
1330     AFS_STATCNT(shutdown_daemons);
1331     if (afs_cold_shutdown) {
1332         afs_brsDaemons = brsInit = 0;
1333         rxepoch_checked = afs_nbrs = 0;
1334         memset((char *)afs_brs, 0, sizeof(afs_brs));
1335         memset((char *)&afs_xbrs, 0, sizeof(afs_lock_t));
1336         afs_brsWaiters = 0;
1337 #ifdef AFS_AIX32_ENV
1338 #ifdef AFS_AIX41_ENV
1339         lock_free(&afs_asyncbuf_lock);
1340         unpin(&afs_asyncbuf, sizeof(struct buf *));
1341         pin(&afs_asyncbuf_cv, sizeof(afs_int32));
1342 #else /* AFS_AIX41_ENV */
1343         afs_busyq = NULL;
1344         afs_biodcnt = 0;
1345         memset((char *)&afs_bioqueue, 0, sizeof(struct afs_bioqueue));
1346 #endif
1347         afs_initbiod = 0;
1348 #endif
1349     }
1350 }
1351
1352 #if defined(AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
1353 /*
1354  * sgi - daemon - handles certain operations that otherwise
1355  * would use up too much kernel stack space
1356  *
1357  * This all assumes that since the caller must have the xdcache lock
1358  * exclusively that the list will never be more than one long
1359  * and noone else can attempt to add anything until we're done.
1360  */
1361 SV_TYPE afs_sgibksync;
1362 SV_TYPE afs_sgibkwait;
1363 lock_t afs_sgibklock;
1364 struct dcache *afs_sgibklist;
1365
1366 int
1367 afs_sgidaemon(void)
1368 {
1369     int s;
1370     struct dcache *tdc;
1371
1372     if (afs_sgibklock == NULL) {
1373         SV_INIT(&afs_sgibksync, "bksync", 0, 0);
1374         SV_INIT(&afs_sgibkwait, "bkwait", 0, 0);
1375         SPINLOCK_INIT(&afs_sgibklock, "bklock");
1376     }
1377     s = SPLOCK(afs_sgibklock);
1378     for (;;) {
1379         /* wait for something to do */
1380         SP_WAIT(afs_sgibklock, s, &afs_sgibksync, PINOD);
1381         osi_Assert(afs_sgibklist);
1382
1383         /* XX will probably need to generalize to real list someday */
1384         s = SPLOCK(afs_sgibklock);
1385         while (afs_sgibklist) {
1386             tdc = afs_sgibklist;
1387             afs_sgibklist = NULL;
1388             SPUNLOCK(afs_sgibklock, s);
1389             AFS_GLOCK();
1390             tdc->dflags &= ~DFEntryMod;
1391             afs_WriteDCache(tdc, 1);
1392             AFS_GUNLOCK();
1393             s = SPLOCK(afs_sgibklock);
1394         }
1395
1396         /* done all the work - wake everyone up */
1397         while (SV_SIGNAL(&afs_sgibkwait));
1398     }
1399 }
1400 #endif