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