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