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