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