src/afs/afs_osi.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("$Header$");
  14
  15 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  16 #include "afsincludes.h"        /* Afs-based standard headers */
  17 #include "afs/afs_stats.h"   /* afs statistics */
  18 #ifdef AFS_AIX_ENV
  19 #include <sys/adspace.h>        /* for vm_att(), vm_det() */
  20 #endif
  21
  22 static char memZero;                    /* address of 0 bytes for kmem_alloc */
  23
  24 struct osimem {
  25     struct osimem *next;
  26 };
  27
  28 /* osi_Init -- do once per kernel installation initialization.
  29  *     -- On Solaris this is called from modload initialization.
  30  *     -- On AIX called from afs_config.
  31  *     -- On HP called from afsc_link.
  32  *     -- On SGI called from afs_init. */
  33
  34 #ifdef AFS_SGI53_ENV
  35 lock_t afs_event_lock;
  36 #endif
  37
  38 #ifdef AFS_SGI64_ENV
  39 flid_t osi_flid;
  40 #endif
  41
  42 void osi_Init(void)
  43 {
  44     static int once = 0;
  45     if (once++ > 0)                     /* just in case */
  46         return;
  47 #if     defined(AFS_HPUX_ENV)
  48     osi_InitGlock();
  49 #else   /* AFS_HPUX_ENV */
  50 #if defined(AFS_GLOBAL_SUNLOCK)
  51 #if defined(AFS_SGI62_ENV)
  52     mutex_init(&afs_global_lock, MUTEX_DEFAULT, "afs_global_lock");
  53 #elif defined(AFS_OSF_ENV)
  54     usimple_lock_init(&afs_global_lock);
  55     afs_global_owner = (thread_t)0;
  56 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
  57     lockinit(&afs_global_lock, PLOCK, "afs global lock", 0, 0);
  58     afs_global_owner = 0;
  59 #elif defined(AFS_AIX41_ENV)
  60     lock_alloc((void*)&afs_global_lock, LOCK_ALLOC_PIN, 1, 1);
  61     simple_lock_init((void *)&afs_global_lock);
  62 #elif !defined(AFS_LINUX22_ENV)
  63      /* Linux initialization in osi directory. Should move the others. */
  64     mutex_init(&afs_global_lock, "afs_global_lock", MUTEX_DEFAULT, NULL);
  65 #endif
  66     /* afs_rxglobal_lock is initialized in rx_Init. */
  67 #endif  /* AFS_GLOBAL_SUNLOCK */
  68 #endif  /* AFS_HPUX_ENV */
  69
  70     if ( !afs_osicred_initialized ) {
  71         memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
  72         crhold(&afs_osi_cred);  /* don't let it evaporate */
  73         afs_osicred_initialized = 1;
  74     }
  75 #ifdef AFS_SGI64_ENV
  76     osi_flid.fl_pid = osi_flid.fl_sysid = 0;
  77 #endif
  78
  79     init_et_to_sys_error();
  80 }
  81
  82 int osi_Active(register struct vcache *avc)
  83 {
  84     AFS_STATCNT(osi_Active);
  85 #if defined(AFS_SUN_ENV) || defined(AFS_AIX_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
  86     if ((avc->opens > 0) || (avc->states & CMAPPED))    return 1;   /* XXX: Warning, verify this XXX  */
  87 #elif   defined(AFS_MACH_ENV)
  88     if (avc->opens > 0 || ((avc->v.v_flag & VTEXT) && !inode_uncache_try(avc))) return 1;
  89 #elif defined(AFS_SGI_ENV)
  90     if ((avc->opens > 0) || AFS_VN_MAPPED(AFSTOV(avc)))
  91         return 1;
  92 #else
  93     if (avc->opens > 0 || (AFSTOV(avc)->v_flag & VTEXT)) return(1);
  94 #endif
  95     return 0;
  96 }
  97
  98 /* this call, unlike osi_FlushText, is supposed to discard caches that may
  99    contain invalid information if a file is written remotely, but that may
 100    contain valid information that needs to be written back if the file is
 101    being written locally.  It doesn't subsume osi_FlushText, since the latter
 102    function may be needed to flush caches that are invalidated by local writes.
 103
 104    avc->pvnLock is already held, avc->lock is guaranteed not to be held (by
 105    us, of course).
 106 */
 107 void osi_FlushPages(register struct vcache *avc, struct AFS_UCRED *credp)
 108 {
 109     afs_hyper_t origDV;
 110     ObtainReadLock(&avc->lock);
 111     /* If we've already purged this version, or if we're the ones
 112        writing this version, don't flush it (could lose the
 113        data we're writing). */
 114     if ((hcmp((avc->m.DataVersion), (avc->mapDV)) <= 0) ||
 115         ((avc->execsOrWriters > 0) && afs_DirtyPages(avc))) {
 116         ReleaseReadLock(&avc->lock);
 117         return;
 118     }
 119     ReleaseReadLock(&avc->lock);
 120     ObtainWriteLock(&avc->lock,10);
 121     /* Check again */
 122     if ((hcmp((avc->m.DataVersion), (avc->mapDV)) <= 0) ||
 123         ((avc->execsOrWriters > 0) && afs_DirtyPages(avc))) {
 124         ReleaseWriteLock(&avc->lock);
 125         return;
 126     }
 127     if (hiszero(avc->mapDV)) {
 128         hset(avc->mapDV, avc->m.DataVersion);
 129         ReleaseWriteLock(&avc->lock);
 130         return;
 131     }
 132
 133     AFS_STATCNT(osi_FlushPages);
 134     hset(origDV, avc->m.DataVersion);
 135     afs_Trace3(afs_iclSetp, CM_TRACE_FLUSHPAGES, ICL_TYPE_POINTER, avc,
 136                    ICL_TYPE_INT32, origDV.low, ICL_TYPE_INT32, avc->m.Length);
 137
 138     ReleaseWriteLock(&avc->lock);
 139     AFS_GUNLOCK();
 140     osi_VM_FlushPages(avc, credp);
 141     AFS_GLOCK();
 142     ObtainWriteLock(&avc->lock,88);
 143
 144     /* do this last, and to original version, since stores may occur
 145        while executing above PUTPAGE call */
 146     hset(avc->mapDV, origDV);
 147     ReleaseWriteLock(&avc->lock);
 148 }
 149
 150 afs_lock_t afs_ftf;             /* flush text lock */
 151
 152 #ifdef  AFS_TEXT_ENV
 153
 154 /* This call is supposed to flush all caches that might be invalidated
 155  * by either a local write operation or a write operation done on
 156  * another client.  This call may be called repeatedly on the same
 157  * version of a file, even while a file is being written, so it
 158  * shouldn't do anything that would discard newly written data before
 159  * it is written to the file system. */
 160
 161 void osi_FlushText_really(register struct vcache *vp)
 162 {
 163     afs_hyper_t fdv;    /* version before which we'll flush */
 164
 165     AFS_STATCNT(osi_FlushText);
 166     /* see if we've already flushed this data version */
 167     if (hcmp(vp->m.DataVersion, vp->flushDV) <= 0) return;
 168
 169 #ifdef AFS_DEC_ENV
 170     {
 171       void afs_gfs_FlushText();
 172       afs_gfs_FlushText(vp);
 173       return;
 174     }
 175 #else
 176
 177     MObtainWriteLock(&afs_ftf,317);
 178     hset(fdv, vp->m.DataVersion);
 179
 180     /* why this disgusting code below?
 181      *    xuntext, called by xrele, doesn't notice when it is called
 182      * with a freed text object.  Sun continually calls xrele or xuntext
 183      * without any locking, as long as VTEXT is set on the
 184      * corresponding vnode.
 185      *    But, if the text object is locked when you check the VTEXT
 186      * flag, several processes can wait in xuntext, waiting for the
 187      * text lock; when the second one finally enters xuntext's
 188      * critical region, the text object is already free, but the check
 189      * was already done by xuntext's caller.
 190      *    Even worse, it turns out that xalloc locks the text object
 191      * before reading or stating a file via the vnode layer.  Thus, we
 192      * could end up in getdcache, being asked to bring in a new
 193      * version of a file, but the corresponding text object could be
 194      * locked.  We can't flush the text object without causing
 195      * deadlock, so now we just don't try to lock the text object
 196      * unless it is guaranteed to work.  And we try to flush the text
 197      * when we need to a bit more often at the vnode layer.  Sun
 198      * really blew the vm-cache flushing interface.
 199      */
 200
 201 #if defined (AFS_HPUX_ENV)
 202     if (vp->v.v_flag & VTEXT) {
 203         xrele(vp);
 204
 205         if (vp->v.v_flag & VTEXT) {     /* still has a text object? */
 206             MReleaseWriteLock(&afs_ftf);
 207             return;
 208         }
 209     }
 210 #endif
 211
 212     /* next do the stuff that need not check for deadlock problems */
 213     mpurge(vp);
 214
 215     /* finally, record that we've done it */
 216     hset(vp->flushDV, fdv);
 217     MReleaseWriteLock(&afs_ftf);
 218
 219 #endif /* AFS_DEC_ENV */
 220 }
 221
 222 #ifdef AFS_DEC_ENV
 223 /* I don't really like using xinval() here, because it kills processes
 224  * a bit aggressively.  Previous incarnations of this functionality
 225  * used to use xrele() instead of xinval, and didn't invoke
 226  * cacheinval().  But they would panic.  So it might be worth looking
 227  * into some middle ground...
 228  */
 229 static void afs_gfs_FlushText(register struct vcache *vp)
 230 {
 231     afs_hyper_t fdv;            /* version before which we'll flush */
 232     register struct text *xp;
 233     struct gnode * gp;
 234
 235     MObtainWriteLock(&afs_ftf,318);
 236     hset(fdv, vp->m.DataVersion);
 237     gp = afs_vntogn(vp);
 238
 239     if (!gp) {
 240         /* this happens frequently after cores are created. */
 241         MReleaseWriteLock(&afs_ftf);
 242         return;
 243     }
 244
 245     if (gp->g_flag & GTEXT) {
 246         if (gp->g_textp) {
 247             xp = (struct text *) gp->g_textp ;
 248             /* if text object is locked, give up */
 249             if (xp && (xp->x_flag & XLOCK)) {
 250                 MReleaseWriteLock(&afs_ftf);
 251                 return;
 252             }
 253         }
 254         else xp = NULL;
 255
 256         if (gp->g_flag & GTEXT) { /* still has a text object? */
 257             xinval(gp);
 258         }
 259     }
 260
 261     /* next do the stuff that need not check for deadlock problems */
 262     /*    maybe xinval(gp); here instead of above */
 263     binval(NODEV, gp);
 264     cacheinval(gp);
 265     /* finally, record that we've done it */
 266     hset(vp->flushDV, fdv);
 267
 268     MReleaseWriteLock(&afs_ftf);
 269 }
 270 #endif /* AFS_DEC_ENV */
 271
 272 #endif /* AFS_TEXT_ENV */
 273
 274 /* mask signals in afsds */
 275 void afs_osi_MaskSignals(void)
 276 {
 277 #ifdef AFS_LINUX22_ENV
 278     osi_linux_mask();
 279 #endif
 280 }
 281
 282 /* unmask signals in rxk listener */
 283 void afs_osi_UnmaskRxkSignals(void)
 284 {
 285 }
 286
 287 /* register rxk listener proc info */
 288 void afs_osi_RxkRegister(void)
 289 {
 290 #ifdef AFS_LINUX22_ENV
 291     osi_linux_rxkreg();
 292 #endif
 293 }
 294
 295 /* procedure for making our processes as invisible as we can */
 296 void afs_osi_Invisible(void)
 297 {
 298 #ifdef AFS_LINUX22_ENV
 299     afs_osi_MaskSignals();
 300 #elif defined(AFS_DEC_ENV)
 301     u.u_procp->p_type |= SSYS;
 302 #elif defined(AFS_SUN5_ENV)
 303     curproc->p_flag |= SSYS;
 304 #elif defined(AFS_HPUX101_ENV)
 305     set_system_proc(u.u_procp);
 306 #elif defined(AFS_DARWIN_ENV)
 307     /* maybe call init_process instead? */
 308     current_proc()->p_flag |= P_SYSTEM;
 309 #elif defined(AFS_XBSD_ENV)
 310     curproc->p_flag |= P_SYSTEM;
 311 #elif defined(AFS_SGI_ENV)
 312     vrelvm();
 313 #endif
 314
 315     AFS_STATCNT(osi_Invisible);
 316 }
 317
 318
 319 #ifndef AFS_LINUX20_ENV /* Linux version in osi_misc.c */
 320 /* set the real time */
 321 void afs_osi_SetTime(osi_timeval_t *atv)
 322 {
 323 #ifdef  AFS_AIX32_ENV
 324     struct timestruc_t t;
 325
 326     t.tv_sec  = atv->tv_sec;
 327     t.tv_nsec = atv->tv_usec * 1000;
 328     ksettimer(&t);              /*  Was -> settimer(TIMEOFDAY, &t); */
 329 #else
 330 #ifdef AFS_SUN55_ENV
 331     stime(atv->tv_sec);
 332 #else
 333 #ifdef  AFS_SUN5_ENV
 334     /*
 335      * To get more than second resolution we can use adjtime. The problem
 336      * is that the usecs from the server are wrong (by now) so it isn't
 337      * worth complicating the following code.
 338      */
 339     struct stimea {
 340         time_t time;
 341     } sta;
 342
 343     sta.time = atv->tv_sec;
 344
 345     stime(&sta, NULL);
 346 #else
 347 #if defined(AFS_SGI_ENV)
 348     struct stimea {
 349         sysarg_t time;
 350     } sta;
 351
 352     AFS_GUNLOCK();
 353     sta.time = atv->tv_sec;
 354     stime(&sta);
 355     AFS_GLOCK();
 356 #else
 357 #if defined(AFS_FBSD_ENV)
 358     /* does not impliment security features of kern_time.c:settime() */
 359     struct timespec ts;
 360     struct timeval tv,delta;
 361     int s;
 362     AFS_GUNLOCK();
 363     s=splclock();
 364     microtime(&tv);
 365     delta=*atv;
 366     timevalsub(&delta, &tv);
 367     ts.tv_sec=atv->tv_sec;
 368     ts.tv_nsec=atv->tv_usec * 1000;
 369     set_timecounter(&ts);
 370     (void) splsoftclock();
 371     lease_updatetime(delta.tv_sec);
 372     splx(s);
 373     resettodr();
 374     AFS_GLOCK();
 375 #else
 376 #if defined(AFS_DARWIN_ENV)
 377     AFS_GUNLOCK();
 378     setthetime(atv);
 379     AFS_GLOCK();
 380 #else
 381     /* stolen from kern_time.c */
 382 #ifndef AFS_AUX_ENV
 383     boottime.tv_sec += atv->tv_sec - time.tv_sec;
 384 #endif
 385 #ifdef AFS_HPUX_ENV
 386     {
 387 #if !defined(AFS_HPUX1122_ENV)
 388  /* drop the setting of the clock for now. spl7 is not
 389   * known on hpux11.22
 390   */
 391         register ulong_t s;
 392         struct timeval t;
 393         t.tv_sec = atv->tv_sec;
 394         t.tv_usec = atv->tv_usec;
 395         s = spl7(); time = t; (void) splx(s);
 396         resettodr(atv);
 397 #endif
 398     }
 399 #else
 400     {
 401         register int s;
 402         s = splclock(); time = *atv; (void) splx(s);
 403     }
 404     resettodr();
 405 #endif
 406 #ifdef  AFS_AUX_ENV
 407     logtchg(atv->tv_sec);
 408 #endif
 409 #endif  /* AFS_DARWIN_ENV */
 410 #endif  /* AFS_FBSD_ENV */
 411 #endif  /* AFS_SGI_ENV */
 412 #endif /* AFS_SUN55_ENV */
 413 #endif /* AFS_SUN5_ENV */
 414 #endif /* AFS_AIX32_ENV */
 415     AFS_STATCNT(osi_SetTime);
 416 }
 417 #endif /* AFS_LINUX20_ENV */
 418
 419
 420 void *afs_osi_Alloc(size_t x)
 421 {
 422     register struct osimem *tm = NULL;
 423     register int size;
 424
 425     AFS_STATCNT(osi_Alloc);
 426     /* 0-length allocs may return NULL ptr from AFS_KALLOC, so we special-case
 427        things so that NULL returned iff an error occurred */
 428     if (x == 0) return &memZero;
 429
 430     AFS_STATS(afs_stats_cmperf.OutStandingAllocs++);
 431     AFS_STATS(afs_stats_cmperf.OutStandingMemUsage += x);
 432 #ifdef AFS_LINUX20_ENV
 433     return osi_linux_alloc(x, 1);
 434 #else
 435     size = x;
 436     tm = (struct osimem *) AFS_KALLOC(size);
 437 #ifdef  AFS_SUN_ENV
 438     if (!tm)
 439         osi_Panic("osi_Alloc: Couldn't allocate %d bytes; out of memory!\n",
 440                   size);
 441 #endif
 442     return (void *) tm;
 443 #endif
 444 }
 445
 446 #if     defined(AFS_SUN_ENV) || defined(AFS_SGI_ENV)
 447
 448 void *afs_osi_Alloc_NoSleep(size_t x)
 449 {
 450     register struct osimem *tm;
 451     register int size;
 452
 453     AFS_STATCNT(osi_Alloc);
 454     /* 0-length allocs may return NULL ptr from AFS_KALLOC, so we special-case
 455        things so that NULL returned iff an error occurred */
 456     if (x == 0) return &memZero;
 457
 458     size = x;
 459     AFS_STATS(afs_stats_cmperf.OutStandingAllocs++);
 460     AFS_STATS(afs_stats_cmperf.OutStandingMemUsage += x);
 461     tm = (struct osimem *) AFS_KALLOC_NOSLEEP(size);
 462     return (void *) tm;
 463 }
 464
 465 #endif  /* SUN || SGI */
 466
 467 void afs_osi_Free(void *x, size_t asize)
 468 {
 469     AFS_STATCNT(osi_Free);
 470     if (x == &memZero) return;  /* check for putting memZero back */
 471
 472     AFS_STATS(afs_stats_cmperf.OutStandingAllocs--);
 473     AFS_STATS(afs_stats_cmperf.OutStandingMemUsage -= asize);
 474 #if defined(AFS_LINUX20_ENV)
 475     osi_linux_free(x);
 476 #else
 477     AFS_KFREE((struct osimem *)x, asize);
 478 #endif
 479 }
 480
 481 void afs_osi_FreeStr(char *x)
 482 {
 483     afs_osi_Free(x, strlen(x) + 1);
 484 }
 485
 486 /* ? is it moderately likely that there are dirty VM pages associated with
 487  * this vnode?
 488  *
 489  *  Prereqs:  avc must be write-locked
 490  *
 491  *  System Dependencies:  - *must* support each type of system for which
 492  *                          memory mapped files are supported, even if all
 493  *                          it does is return TRUE;
 494  *
 495  * NB:  this routine should err on the side of caution for ProcessFS to work
 496  *      correctly (or at least, not to introduce worse bugs than already exist)
 497  */
 498 #ifdef  notdef
 499 int osi_VMDirty_p(struct vcache *avc)
 500 {
 501     int dirtyPages;
 502
 503     if (avc->execsOrWriters <= 0)
 504         return 0;         /* can't be many dirty pages here, I guess */
 505
 506 #if defined (AFS_AIX32_ENV)
 507 #ifdef  notdef
 508     /* because of the level of hardware involvment with VM and all the
 509      * warnings about "This routine must be called at VMM interrupt
 510      * level", I thought it would be safest to disable interrupts while
 511      * looking at the software page fault table.  */
 512
 513     /* convert vm handle into index into array:  I think that stoinio is
 514      * always zero...  Look into this XXX  */
 515 #define VMHASH(handle) ( \
 516                         ( ((handle) & ~vmker.stoinio)  \
 517                          ^ ((((handle) & ~vmker.stoinio) & vmker.stoimask) << vmker.stoihash) \
 518                          ) & 0x000fffff)
 519
 520     if (avc->vmh) {
 521         unsigned int pagef, pri, index, next;
 522
 523         index = VMHASH(avc->vmh);
 524         if (scb_valid(index)) {  /* could almost be an ASSERT */
 525
 526             pri = disable_ints();
 527             for (pagef = scb_sidlist(index); pagef >= 0; pagef = next) {
 528                 next = pft_sidfwd(pagef);
 529                 if (pft_modbit(pagef)) {  /* has page frame been modified? */
 530                     enable_ints(pri);
 531                     return 1;
 532                 }
 533             }
 534             enable_ints(pri);
 535         }
 536     }
 537 #undef VMHASH
 538 #endif
 539 #endif /* AFS_AIX32_ENV */
 540
 541 #if defined (AFS_SUN_ENV)
 542     if (avc->states & CMAPPED) {
 543         struct page * pg;
 544         for (pg = avc->v.v_s.v_Pages ; pg ; pg = pg->p_vpnext) {
 545             if (pg->p_mod) {
 546                 return 1;
 547             }
 548         }
 549     }
 550 #endif
 551     return 0;
 552 }
 553 #endif /* notdef */
 554
 555
 556 /*
 557  * Solaris osi_ReleaseVM should not drop and re-obtain the vcache entry lock.
 558  * This leads to bad races when osi_ReleaseVM() is called from
 559  * afs_InvalidateAllSegments().
 560
 561  * We can do this because Solaris osi_VM_Truncate() doesn't care whether the
 562  * vcache entry lock is held or not.
 563  *
 564  * For other platforms, in some cases osi_VM_Truncate() doesn't care, but
 565  * there may be cases where it does care.  If so, it would be good to fix
 566  * them so they don't care.  Until then, we assume the worst.
 567  *
 568  * Locking:  the vcache entry lock is held.  It is dropped and re-obtained.
 569  */
 570 void osi_ReleaseVM(struct vcache *avc, struct AFS_UCRED *acred)
 571 {
 572 #ifdef  AFS_SUN5_ENV
 573     AFS_GUNLOCK();
 574     osi_VM_Truncate(avc, 0, acred);
 575     AFS_GLOCK();
 576 #else
 577     ReleaseWriteLock(&avc->lock);
 578     AFS_GUNLOCK();
 579     osi_VM_Truncate(avc, 0, acred);
 580     AFS_GLOCK();
 581     ObtainWriteLock(&avc->lock, 80);
 582 #endif
 583 }
 584
 585
 586 void shutdown_osi(void)
 587 {
 588     AFS_STATCNT(shutdown_osi);
 589     if (afs_cold_shutdown) {
 590         LOCK_INIT(&afs_ftf, "afs_ftf");
 591     }
 592 }
 593
 594 #ifndef AFS_OBSD_ENV
 595 int afs_osi_suser(void *credp)
 596 {
 597 #if defined(AFS_SUN5_ENV)
 598     return afs_suser(credp);
 599 #else
 600     return afs_suser();
 601 #endif
 602 }
 603 #endif
 604
 605 #if AFS_GCPAGS
 606
 607 /* afs_osi_TraverseProcTable() - Walk through the systems process
 608  * table, calling afs_GCPAGs_perproc_func() for each process.
 609  */
 610
 611 #if defined(AFS_SUN5_ENV)
 612 void afs_osi_TraverseProcTable(void)
 613 {
 614     struct proc *prp;
 615     for (prp = practive; prp != NULL; prp = prp->p_next) {
 616         afs_GCPAGs_perproc_func(prp);
 617     }
 618 }
 619 #endif
 620
 621 #if defined(AFS_HPUX_ENV)
 622
 623 /*
 624  * NOTE: h/proc_private.h gives the process table locking rules
 625  * It indicates that access to p_cred must be protected by
 626  * mp_mtproc_lock(p);
 627  * mp_mtproc_unlock(p);
 628  *
 629  * The code in sys/pm_prot.c uses pcred_lock() to protect access to
 630  * the process creds, and uses mp_mtproc_lock() only for audit-related
 631  * changes.  To be safe, we use both.
 632  */
 633
 634 void afs_osi_TraverseProcTable(void)
 635 {
 636     register proc_t *p;
 637     int endchain = 0;
 638
 639     MP_SPINLOCK(activeproc_lock);
 640     MP_SPINLOCK(sched_lock);
 641     pcred_lock();
 642
 643     /*
 644      * Instead of iterating through all of proc[], traverse only
 645      * the list of active processes.  As an example of this,
 646      * see foreach_process() in sys/vm_sched.c.
 647      *
 648      * We hold the locks for the entire scan in order to get a
 649      * consistent view of the current set of creds.
 650      */
 651
 652     for(p = proc; endchain == 0; p = &proc[p->p_fandx]) {
 653         if (p->p_fandx == 0) {
 654             endchain = 1;
 655         }
 656
 657         if (system_proc(p))
 658             continue;
 659
 660         mp_mtproc_lock(p);
 661         afs_GCPAGs_perproc_func(p);
 662         mp_mtproc_unlock(p);
 663     }
 664
 665     pcred_unlock();
 666     MP_SPINUNLOCK(sched_lock);
 667     MP_SPINUNLOCK(activeproc_lock);
 668 }
 669 #endif
 670
 671 #if defined(AFS_SGI_ENV)
 672
 673 #ifdef AFS_SGI65_ENV
 674 /* TODO: Fix this later. */
 675 static int SGI_ProcScanFunc(void *p, void *arg, int mode)
 676 {
 677     return 0;
 678 }
 679 #else   /* AFS_SGI65_ENV */
 680 static int SGI_ProcScanFunc(proc_t *p, void *arg, int mode)
 681 {
 682     afs_int32 (*perproc_func)(struct proc *) = arg;
 683     int code=0;
 684     /* we pass in the function pointer for arg,
 685      * mode ==0 for startup call, ==1 for each valid proc,
 686      * and ==2 for terminate call.
 687      */
 688     if(mode == 1) {
 689         code = perproc_func(p);
 690     }
 691     return code;
 692 }
 693 #endif  /* AFS_SGI65_ENV */
 694
 695 void afs_osi_TraverseProcTable(void)
 696 {
 697     procscan(SGI_ProcScanFunc, afs_GCPAGs_perproc_func);
 698 }
 699 #endif  /* AFS_SGI_ENV */
 700
 701 #if defined(AFS_AIX_ENV)
 702 #ifdef AFS_AIX51_ENV
 703 #define max_proc v.ve_proc
 704 #endif
 705 void afs_osi_TraverseProcTable(void)
 706 {
 707     struct proc *p;
 708     int i;
 709
 710     /*
 711      * For binary compatibility, on AIX we need to be careful to use the
 712      * proper size of a struct proc, even if it is different from what
 713      * we were compiled with.
 714      */
 715     if (!afs_gcpags_procsize)
 716         return;
 717
 718 #ifndef AFS_AIX51_ENV
 719     simple_lock(&proc_tbl_lock);
 720 #endif
 721     for (p = (struct proc *)v.vb_proc, i = 0;
 722          p < max_proc;
 723          p = (struct proc *)((char *)p + afs_gcpags_procsize), i++) {
 724
 725 #ifdef AFS_AIX51_ENV
 726         if (p->p_pvprocp->pv_stat == SNONE)
 727             continue;
 728         if (p->p_pvprocp->pv_stat == SIDL)
 729             continue;
 730         if (p->p_pvprocp->pv_stat == SEXIT)
 731             continue;
 732 #else
 733         if (p->p_stat == SNONE)
 734             continue;
 735         if (p->p_stat == SIDL)
 736             continue;
 737         if (p->p_stat == SEXIT)
 738             continue;
 739 #endif
 740
 741         /* sanity check */
 742
 743         if (PROCMASK(p->p_pid) != i) {
 744             afs_gcpags = AFS_GCPAGS_EPIDCHECK;
 745             break;
 746         }
 747
 748         /* sanity check */
 749
 750         if ((p->p_nice < P_NICE_MIN) || (P_NICE_MAX < p->p_nice)) {
 751             afs_gcpags = AFS_GCPAGS_ENICECHECK;
 752             break;
 753         }
 754
 755         afs_GCPAGs_perproc_func(p);
 756     }
 757 #ifndef AFS_AIX51_ENV
 758     simple_unlock(&proc_tbl_lock);
 759 #endif
 760 }
 761 #endif
 762
 763 #if defined(AFS_OSF_ENV)
 764 void afs_osi_TraverseProcTable(void)
 765 {
 766     struct pid_entry *pe;
 767 #ifdef AFS_DUX50_ENV
 768 #define pidNPID (pidtab + npid)
 769 #define PID_LOCK()
 770 #define PID_UNLOCK()
 771 #endif
 772     PID_LOCK();
 773     for (pe = pidtab; pe < pidNPID; ++pe) {
 774        if (pe->pe_proc != PROC_NULL)
 775           afs_GCPAGs_perproc_func(pe->pe_proc);
 776     }
 777     PID_UNLOCK();
 778 }
 779 #endif
 780
 781 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 782 void afs_osi_TraverseProcTable(void)
 783 {
 784     struct proc *p;
 785     LIST_FOREACH(p, &allproc, p_list) {
 786         if (p->p_stat == SIDL)
 787             continue;
 788         if (p->p_stat == SZOMB)
 789             continue;
 790         if (p->p_flag & P_SYSTEM)
 791             continue;
 792           afs_GCPAGs_perproc_func(p);
 793     }
 794 }
 795 #endif
 796
 797 #if defined(AFS_LINUX22_ENV)
 798 void afs_osi_TraverseProcTable()
 799 {
 800     struct task_struct *p;
 801
 802 #ifdef EXPORTED_TASKLIST_LOCK
 803     read_lock(&tasklist_lock);
 804 #endif
 805 #ifdef DEFINED_FOR_EACH_PROCESS
 806     for_each_process(p) if (p->pid) {
 807         if (p->state & TASK_ZOMBIE)
 808             continue;
 809         afs_GCPAGs_perproc_func(p);
 810     }
 811 #else
 812     for_each_task(p) if (p->pid) {
 813         if (p->state & TASK_ZOMBIE)
 814             continue;
 815         afs_GCPAGs_perproc_func(p);
 816     }
 817 #endif
 818 #ifdef EXPORTED_TASKLIST_LOCK
 819     read_unlock(&tasklist_lock);
 820 #endif
 821 }
 822 #endif
 823
 824 /* return a pointer (sometimes a static copy ) to the cred for a
 825  * given AFS_PROC.
 826  * subsequent calls may overwrite the previously returned value.
 827  */
 828
 829 #if defined(AFS_SGI65_ENV)
 830 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *p)
 831 {
 832     return NULL;
 833 }
 834 #elif defined(AFS_HPUX_ENV)
 835 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *p)
 836 {
 837     if (!p)
 838         return;
 839
 840     /*
 841      * Cannot use afs_warnuser() here, as the code path
 842      * eventually wants to grab sched_lock, which is
 843      * already held here
 844      */
 845
 846     return p_cred(p);
 847 }
 848 #elif defined(AFS_AIX_ENV)
 849
 850 /* GLOBAL DECLARATIONS */
 851
 852 /*
 853  * LOCKS: the caller must do
 854  *  simple_lock(&proc_tbl_lock);
 855  *  simple_unlock(&proc_tbl_lock);
 856  * around calls to this function.
 857  */
 858
 859 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pproc)
 860 {
 861     struct AFS_UCRED *pcred = 0;
 862
 863     /*
 864      * pointer to process user structure valid in *our*
 865      * address space
 866      *
 867      * The user structure for a process is stored in the user
 868      * address space (as distinct from the kernel address
 869      * space), and so to refer to the user structure of a
 870      * different process we must employ special measures.
 871      *
 872      * I followed the example used in the AIX getproc() system
 873      * call in bos/kernel/proc/getproc.c
 874      */
 875     struct user *xmem_userp;
 876
 877     struct xmem dp;             /* ptr to xmem descriptor */
 878     int xm;                     /* xmem result */
 879
 880     if (!pproc) {
 881         return pcred;
 882     }
 883
 884     /*
 885      * The process private segment in which the user
 886      * area is located may disappear. We need to increment
 887      * its use count. Therefore we
 888      *    - get the proc_tbl_lock to hold the segment.
 889      *    - get the p_lock to lockout vm_cleardata.
 890      *    - vm_att to load the segment register (no check)
 891      *    - xmattach to bump its use count.
 892      *    - release the p_lock.
 893      *    - release the proc_tbl_lock.
 894      *    - do whatever we need.
 895      *    - xmdetach to decrement the use count.
 896      *    - vm_det to free the segment register (no check)
 897      */
 898
 899     xmem_userp = NULL;
 900     xm = XMEM_FAIL;
 901     /* simple_lock(&proc_tbl_lock); */
 902     if (pproc->p_adspace != NULLSEGVAL) {
 903
 904 #ifdef AFS_AIX51_ENV
 905         simple_lock(&pproc->p_pvprocp->pv_lock);
 906 #else
 907         simple_lock(&pproc->p_lock);
 908 #endif
 909
 910         if (pproc->p_threadcount &&
 911 #ifdef AFS_AIX51_ENV
 912             pproc->p_pvprocp->pv_threadlist) {
 913 #else
 914             pproc->p_threadlist) {
 915 #endif
 916
 917             /*
 918              * arbitrarily pick the first thread in pproc
 919              */
 920             struct thread *pproc_thread =
 921 #ifdef AFS_AIX51_ENV
 922                 pproc->p_pvprocp->pv_threadlist;
 923 #else
 924                 pproc->p_threadlist;
 925 #endif
 926
 927             /*
 928              * location of 'struct user' in pproc's
 929              * address space
 930              */
 931             struct user *pproc_userp =
 932                 pproc_thread->t_userp;
 933
 934             /*
 935              * create a pointer valid in my own address space
 936              */
 937
 938             xmem_userp =
 939                 (struct user *)vm_att(pproc->p_adspace,
 940                                       pproc_userp);
 941
 942             dp.aspace_id = XMEM_INVAL;
 943             xm = xmattach(xmem_userp,
 944                           sizeof(*xmem_userp),
 945                           &dp, SYS_ADSPACE);
 946         }
 947
 948 #ifdef AFS_AIX51_ENV
 949         simple_unlock(&pproc->p_pvprocp->pv_lock);
 950 #else
 951         simple_unlock(&pproc->p_lock);
 952 #endif
 953     }
 954     /* simple_unlock(&proc_tbl_lock); */
 955     if (xm == XMEM_SUCC) {
 956
 957         static struct AFS_UCRED cred;
 958
 959         /*
 960          * What locking should we use to protect access to the user
 961          * area?  If needed also change the code in AIX/osi_groups.c.
 962          */
 963
 964         /* copy cred to local address space */
 965         cred = *xmem_userp->U_cred;
 966         pcred = &cred;
 967
 968         xmdetach(&dp);
 969     }
 970     if (xmem_userp) {
 971         vm_det((void *)xmem_userp);
 972     }
 973
 974     return pcred;
 975 }
 976
 977 #elif defined(AFS_OSF_ENV)
 978 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr)
 979 {
 980     struct AFS_UCRED *rv=NULL;
 981
 982     if(pr == NULL) {
 983        return NULL;
 984     }
 985
 986     if((pr->p_stat == SSLEEP) ||
 987        (pr->p_stat == SRUN) ||
 988        (pr->p_stat == SSTOP))
 989        rv = pr->p_rcred;
 990
 991     return rv;
 992 }
 993 #elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 994 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr)
 995 {
 996     struct AFS_UCRED *rv=NULL;
 997     static struct AFS_UCRED cr;
 998
 999     if(pr == NULL) {
1000        return NULL;
1001     }
1002
1003     if((pr->p_stat == SSLEEP) ||
1004        (pr->p_stat == SRUN) ||
1005        (pr->p_stat == SSTOP)) {
1006        pcred_readlock(pr);
1007        cr.cr_ref=1;
1008        cr.cr_uid=pr->p_cred->pc_ucred->cr_uid;
1009        cr.cr_ngroups=pr->p_cred->pc_ucred->cr_ngroups;
1010        memcpy(cr.cr_groups, pr->p_cred->pc_ucred->cr_groups, NGROUPS *
1011              sizeof(gid_t));
1012        pcred_unlock(pr);
1013        rv = &cr;
1014     }
1015
1016     return rv;
1017 }
1018 #elif defined(AFS_LINUX22_ENV)
1019 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr)
1020 {
1021     struct AFS_UCRED *rv=NULL;
1022     static struct AFS_UCRED cr;
1023
1024     if(pr == NULL) {
1025        return NULL;
1026     }
1027
1028     if ((pr->state == TASK_RUNNING) ||
1029         (pr->state == TASK_INTERRUPTIBLE) ||
1030         (pr->state == TASK_UNINTERRUPTIBLE) ||
1031         (pr->state == TASK_STOPPED)) {
1032         cr.cr_ref=1;
1033         cr.cr_uid=pr->uid;
1034         cr.cr_ngroups=pr->ngroups;
1035         memcpy(cr.cr_groups, pr->groups, NGROUPS * sizeof(gid_t));
1036         rv = &cr;
1037     }
1038
1039     return rv;
1040 }
1041 #else
1042 const struct AFS_UCRED *afs_osi_proc2cred(AFS_PROC *pr)
1043 {
1044     struct AFS_UCRED *rv=NULL;
1045
1046     if(pr == NULL) {
1047        return NULL;
1048     }
1049     rv = pr->p_cred;
1050
1051     return rv;
1052 }
1053 #endif
1054
1055 #endif  /* AFS_GCPAGS */