curcred-20021008
[openafs.git] / src / afs / IRIX / osi_machdep.h
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 /*
11  * IRIX OSI header file. Extends afs_osi.h.
12  *
13  * afs_osi.h includes this file, which is the only way this file should
14  * be included in a source file. This file can redefine macros declared in
15  * afs_osi.h.
16  */
17 #ifndef _OSI_MACHDEP_H_
18 #define _OSI_MACHDEP_H_
19
20 #include <sys/sema.h>
21 #include <sys/pda.h>
22 extern kmutex_t afs_global_lock;
23
24
25 #undef osi_Time
26 extern time_t time;
27 #define osi_Time() (time)
28
29 #define AFS_UCRED       ucred
30
31 #define osi_vnhold(avc, r)  do { VN_HOLD(AFSTOV(avc)); } while(0)
32
33 #undef afs_osi_Alloc_NoSleep
34 extern void *afs_osi_Alloc_NoSleep(size_t size);
35
36
37 #ifdef AFS_SGI64_ENV
38 #include <sys/flock.h>
39 extern flid_t osi_flid;
40 #define v_op v_bh.bh_first->bd_ops
41 #define v_data v_bh.bh_first->bd_pdata
42 #define vfs_data vfs_bh.bh_first->bd_pdata
43 #endif /* AFS_SGI64_ENV */
44
45
46 /*
47  * Global lock, semaphore, mutex and state vector support.
48  */
49 #define SV_INIT(cv, nm, t, c)   cv_init(cv, nm, t, c)
50 /* Spinlock macros */
51 #define SV_TYPE sv_t
52 #define SV_SIGNAL(cv)           sv_signal(cv)
53 #define SPINLOCK_INIT(l, nm)    spinlock_init((l),(nm))
54 #define SPLOCK(l)               mp_mutex_spinlock(&(l))
55 #define SPUNLOCK(l,s)           mp_mutex_spinunlock(&(l),s)
56 #define SP_WAIT(l, s, cv, p)    mp_sv_wait_sig(cv, p, (void*)(&(l)), s)
57 #ifdef AFS_SGI64_ENV
58 #ifdef AFS_SGI65_ENV
59 /* Add PLTWAIT for afsd's to wait so we don't rack up the load average. */
60 #define AFSD_PRI() ((kt_basepri(curthreadp) == PTIME_SHARE) ? PZERO : (PZERO|PLTWAIT))
61 #undef AFS_MUTEX_ENTER
62 #define AFS_MUTEX_ENTER(mp) \
63   MACRO_BEGIN \
64     register struct kthread *_kthreadP; \
65     while(mutex_tryenter(mp) == 0) { \
66       _kthreadP = (struct kthread*)mutex_owner(mp); \
67       if (_kthreadP != NULL && _kthreadP->k_sonproc == CPU_NONE) { \
68           mutex_lock(mp, AFSD_PRI()); \
69           break; \
70       } \
71     } \
72   MACRO_END
73
74 #else /* AFS_SGI65_ENV */
75 /* Add PLTWAIT for afsd's to wait so we don't rack up the load average. */
76 #define AFSD_PRI() ((curprocp && curprocp->p_rss==0) ? (PZERO|PLTWAIT) : PZERO)
77
78 #define AFS_MUTEX_ENTER(mp) \
79   MACRO_BEGIN \
80     kthread_t *kt; \
81     while(mutex_tryenter(mp) == 0) { \
82         kt = mutex_owner(mp); \
83         if (kt != NULL && kt->k_sonproc == CPU_NONE) { \
84             mutex_lock(mp, AFSD_PRI()); \
85             break; \
86         } \
87     } \
88   MACRO_END
89 #endif /* AFS_SGI65_ENV */
90
91 #define cv_timedwait(cv, l, t)  {                               \
92                                 sv_timedwait(cv, AFSD_PRI(), l, 0, 0, &(t), \
93                                              (struct timespec*)0);      \
94                                 AFS_MUTEX_ENTER(l); \
95                                 }
96 #ifdef cv_wait
97 #undef cv_wait
98 #endif
99 #define cv_wait(cv, l) {                                        \
100                         sv_wait(cv, AFSD_PRI(),  l, 0); \
101                         AFS_MUTEX_ENTER(l); \
102                        }
103 #else /* AFS_SGI64_ENV */
104 #ifdef AFS_SGI62_ENV
105
106 #define AFS_MUTEX_ENTER(mp) \
107   MACRO_BEGIN \
108     register struct proc *_procP; \
109     while(mutex_tryenter(mp) == 0) { \
110         _procP = mutex_owner(mp); \
111         if (_procP != NULL && _procP->p_sonproc == CPU_NONE) { \
112             mutex_enter(mp); \
113             break; \
114         } \
115     } \
116   MACRO_END
117
118 #else /* AFS_SGI62_ENV */
119
120 #define AFS_MUTEX_ENTER(mp)     mutex_enter(mp)
121
122 #endif /* AFS_SGI62_ENV */
123
124 #define cv_timedwait(cv, l, t)  {                               \
125                                   sv_timedwait(cv, l, t);       \
126                                   AFS_GLOCK();                  \
127                                 }
128 #endif /* AFS_SGI64_ENV */
129
130 #if defined(KERNEL)
131 #if defined(MP)
132 #define _MP_NETLOCKS                    /* to get sblock to work right */
133
134 /* On SGI mutex_owned doesn't work, so simulate this by remembering the owning
135  * thread explicitly.  This is only used for debugging so could be disabled for
136  * production builds.
137  *
138  * CAUTION -- The ISAFS_(RX)?GLOCK macros are not safe to use when the lock is
139  *     not held if the test may be made at interrupt level as the code may
140  *     appear to be running as the process that is (or last was) running at
141  *     non-interrupt level. Worse yet, the interrupt may occur just as the 
142  *     process is exiting, in which case, the pid may change from the start
143  *     of the interrupt to the end, since the u area has been changed. So,
144  *     at interrupt level, I'm using the base of the current interrupt stack.
145  *     Note that afs_osinet.c also modifies afs_global_owner for osi_Sleep and 
146  *     afs_osi_Wakeup. Changes made here should be reflected there as well.
147  * NOTE - As of 6.2, we can no longer use mutexes in interrupts, so the above
148  *     concern no longer exists.
149  */
150
151 #ifdef AFS_SGI64_ENV
152 #ifdef AFS_SGI65_ENV
153 /* Irix does not check for deadlocks unless it's a debug kernel. */
154 #define AFS_ASSERT_GNOTME() \
155     (!ISAFS_GLOCK() || (panic("afs global lock held be me"), 0))
156 #define AFS_GLOCK() \
157         { AFS_ASSERT_GNOTME(); AFS_MUTEX_ENTER(&afs_global_lock); }
158 #else
159 #define AFS_GLOCK() AFS_MUTEX_ENTER(&afs_global_lock)
160 #endif
161 #define AFS_GUNLOCK()  (AFS_ASSERT_GLOCK(),  mutex_exit(&afs_global_lock))
162 #define ISAFS_GLOCK() mutex_mine(&afs_global_lock)
163 #else
164 extern long afs_global_owner;
165 #define AFS_GLOCK() \
166   MACRO_BEGIN \
167     AFS_MUTEX_ENTER(&afs_global_lock) ; \
168     afs_global_owner = osi_ThreadUnique(); \
169   MACRO_END
170 #define AFS_GUNLOCK() \
171     (AFS_ASSERT_GLOCK(), afs_global_owner = 0, mutex_exit(&afs_global_lock))
172 #define ISAFS_GLOCK() (osi_ThreadUnique() == afs_global_owner)
173 #endif /* AFS_SGI64_ENV */
174
175 #define AFS_RXGLOCK()
176 #define AFS_RXGUNLOCK()
177 #define ISAFS_RXGLOCK() 1
178
179 #else /* MP */
180 #define AFS_GLOCK()
181 #define AFS_GUNLOCK()
182 #define ISAFS_GLOCK() 1
183
184 #define SPLVAR      register int splvar
185 #define NETPRI      splvar=splnet()
186 #define USERPRI     splx(splvar)
187
188
189 #endif /* MP */
190
191 #endif /* KERNEL  */
192
193
194
195 #ifdef AFS_SGI64_ENV
196 #define gop_rdwr(rw,gp,base,len,offset,segflg,ioflag,ulimit,cr,aresid) \
197    vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(ioflag),(ulimit),(cr),\
198            (int *)(aresid), &osi_flid)
199 #else
200 #define gop_rdwr(rw,gp,base,len,offset,segflg,ioflag,ulimit,cr,aresid) \
201    vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(ioflag),(ulimit),(cr), \
202            (int *)(aresid))
203 #endif
204
205 #ifdef AFS_SGI64_ENV
206 #undef suser
207 #define suser() cap_able(CAP_DEVICE_MGT)
208 #define afs_suser()     suser()
209 #else
210 #define afs_suser           suser
211 #endif
212
213 #define afs_hz HZ
214
215 #ifdef PAGESIZE
216 #undef PAGESIZE
217 #endif
218 #define PAGESIZE 4096
219
220 #ifdef AFS_SGI64_ENV
221 #undef setuerror
222 #undef getuerror
223 #endif
224
225
226 /* OS independent user structure stuff */
227 /*
228  * OSI_GET_CURRENT_PID
229  */
230 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
231 #define OSI_GET_CURRENT_PID() (u.u_procp->p_pid)
232 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
233
234 #if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
235 #define OSI_GET_CURRENT_PID() current_pid()
236 #endif /* AFS_SGI64_ENV */
237
238 #if defined(AFS_SGI65_ENV)
239 #define OSI_GET_CURRENT_PID() proc_pid(curproc())
240 #endif
241
242 #define getpid()  OSI_GET_CURRENT_PID()
243
244 /*
245  * OSI_GET_CURRENT_PROCP
246  */
247 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
248 #define OSI_GET_CURRENT_PROCP() (u.u_procp)
249 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
250
251 #if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
252 #define OSI_GET_CURRENT_PROCP() curprocp
253 #endif /* AFS_SGI64_ENV */
254
255 #if defined(AFS_SGI65_ENV)
256 #define OSI_GET_CURRENT_PROCP() UT_TO_PROC(curuthread)
257 #endif
258
259
260 /*
261  * OSI_GET_LOCKID
262  *
263  * Prior to IRIX 6.4, pid sufficed, now we need kthread.
264  */
265 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
266 #define OSI_GET_LOCKID() (u.u_procp->p_pid)
267 #define OSI_NO_LOCKID (-1)
268 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
269
270 #if defined(AFS_SGI64_ENV)
271 /* IRIX returns k_id, but this way, we've got the thread address for debugging. */
272 #define OSI_GET_LOCKID() \
273         (private.p_curkthread ? (uint64_t)private.p_curkthread : (uint64_t)0)
274 #define OSI_NO_LOCKID ((uint64_t)-1)
275 #endif /* AFS_SGI64_ENV */
276
277 /*
278  * OSI_GET_CURRENT_CRED
279  */
280 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
281 #define OSI_GET_CURRENT_CRED() (u.u_cred)
282 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
283
284 #if defined(AFS_SGI64_ENV)
285 #define OSI_GET_CURRENT_CRED() get_current_cred()
286 #endif /* AFS_SGI64_ENV */
287
288 #define osi_curcred()           OSI_GET_CURRENT_CRED()
289
290 /*
291  * OSI_SET_CURRENT_CRED
292  */
293 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
294 #define OSI_SET_CURRENT_CRED(x) u.u_cred=x
295 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
296
297 #if defined(AFS_SGI64_ENV)
298 #define OSI_SET_CURRENT_CRED(C) set_current_cred((C))
299 #endif /* AFS_SGI64_ENV */
300
301 /*
302  * OSI_GET_CURRENT_ABI
303  */
304 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
305 #define OSI_GET_CURRENT_ABI() (u.u_procp->p_abi)
306 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
307
308 #if defined(AFS_SGI64_ENV)
309 #define OSI_GET_CURRENT_ABI() get_current_abi()
310 #endif /* AFS_SGI64_ENV */
311
312 /*
313  * OSI_GET_CURRENT_SYSID
314  */
315 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
316 #define OSI_GET_CURRENT_SYSID() (u.u_procp->p_sysid)
317 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
318
319 #if defined(AFS_SGI64_ENV)
320 #define OSI_GET_CURRENT_SYSID() (curprocp->p_flid.fl_sysid)
321 #endif /* AFS_SGI64_ENV */
322
323 /*
324  * OSI_GET_CURRENT_COMM
325  */
326 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
327 #define OSI_GET_CURRENT_COMM() (u.u_comm)
328 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
329
330 #if defined(AFS_SGI64_ENV)
331 #define OSI_GET_CURRENT_COMM() (curprocp->p_comm)
332 #endif /* AFS_SGI64_ENV */
333
334 /*
335  * OSI_GET_CURRENT_CDIR
336  */
337 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
338 #define OSI_GET_CURRENT_CDIR() (u.u_cdir)
339 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
340
341 #if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
342 #define OSI_GET_CURRENT_CDIR() (curprocp->p_cdir)
343 #endif /* AFS_SGI64_ENV */
344
345 #if defined(AFS_SGI65_ENV)
346 #define OSI_GET_CURRENT_CDIR() (curuthread->ut_cdir)
347 #endif /* AFS_SGI65_ENV */
348
349
350 /*
351  * OSI_GET_CURRENT_RDIR
352  */
353 #if defined(AFS_SGI_ENV) && !defined(AFS_SGI64_ENV)
354 #define OSI_GET_CURRENT_RDIR() (u.u_rdir)
355 #endif /* AFS_SGI_ENV but not AFS_SGI64_ENV */
356
357 #if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
358 #define OSI_GET_CURRENT_RDIR() (curprocp->p_rdir)
359 #endif /* AFS_SGI64_ENV */
360
361 #if defined(AFS_SGI65_ENV)
362 #define OSI_GET_CURRENT_RDIR() (curuthread->ut_rdir)
363 #endif /* AFS_SGI65_ENV */
364
365
366
367 /* Macros for vcache/vnode and vfs arguments to vnode and vfs ops.
368  *
369  * Note that the _CONVERT routines get the ";" here so that argument lists
370  * can have arguments after the OSI_x_CONVERT macro is called.
371  */
372 #ifdef AFS_SGI64_ENV
373 #undef OSI_VN_ARG
374 #define OSI_VN_ARG(V) bhv_##V
375 #undef OSI_VN_DECL
376 #define OSI_VN_DECL(V)  bhv_desc_t *bhv_##V
377 #undef OSI_VN_CONVERT
378 #define OSI_VN_CONVERT(V) struct vnode * V = (struct vnode*)BHV_TO_VNODE(bhv_##V);
379 #undef OSI_VC_ARG
380 #define OSI_VC_ARG(V) bhv_##V
381 #undef OSI_VC_DECL
382 #define OSI_VC_DECL(V)  bhv_desc_t *bhv_##V
383 #undef OSI_VC_CONVERT
384 #define OSI_VC_CONVERT(V) struct vcache * V = VTOAFS(BHV_TO_VNODE(bhv_##V));
385 #undef OSI_VFS_ARG
386 #define OSI_VFS_ARG(V) bhv_##V
387 #undef OSI_VFS_DECL
388 #define OSI_VFS_DECL(V)  bhv_desc_t *bhv_##V
389 #undef OSI_VFS_CONVERT
390 #define OSI_VFS_CONVERT(V) struct vfs * V = (struct vfs*)bhvtovfs(bhv_##V);
391 #endif /* AFS_SGI64_ENV */
392
393
394
395
396 #endif /* _OSI_MACHDEP_H_ */