freebsd-50-20030423
[openafs.git] / src / afs / afs_osi.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 #ifndef _AFS_OSI_
11 #define _AFS_OSI_
12
13 #include "h/types.h"
14 #include "h/param.h"
15
16 #ifdef AFS_LINUX20_ENV
17 #ifndef _LINUX_CODA_FS_I
18 #define _LINUX_CODA_FS_I
19 #define _CODA_HEADER_
20 struct coda_inode_info {};
21 #endif
22 #ifndef _LINUX_XFS_FS_I
23 #define _LINUX_XFS_FS_I
24 struct xfs_inode_info {};
25 #endif
26 #include "h/fs.h"
27 #include "h/mm.h"
28 #endif
29
30
31 /* this is just a dummy type decl, we're really using struct sockets here */
32 struct osi_socket {
33     int junk;
34 };
35
36 struct osi_stat {
37     afs_int32 size;         /* file size in bytes */
38     afs_int32 blksize;   /* optimal transfer size in bytes */
39     afs_int32 mtime;        /* modification date */
40     afs_int32 atime;        /* access time */
41 };
42
43 struct osi_file {
44     afs_int32 size;             /* file size in bytes XXX Must be first field XXX */
45 #ifdef AFS_LINUX22_ENV
46     struct dentry dentry; /* merely to hold the pointer to the inode. */
47     struct file file; /* May need this if we really open the file. */
48 #else
49     struct vnode *vnode;
50 #endif
51 #if     defined(AFS_HPUX102_ENV)
52     k_off_t offset;
53 #else
54     afs_int32 offset;
55 #endif
56     int (*proc)(struct osi_file *afile, afs_int32 code);        /* proc, which, if not null, is called on writes */
57     char *rock;         /* rock passed to proc */
58     ino_t inum;         /* guarantee validity of hint */
59 #if defined(UKERNEL)
60     int fd;             /* file descriptor for user space files */
61 #endif /* defined(UKERNEL) */
62 };
63
64 struct osi_dev {
65 #ifdef AFS_OBSD_ENV
66     struct mount *mp;
67     struct vnode *held_vnode;
68 #else
69     afs_int32 dev;
70 #endif
71 };
72
73 struct afs_osi_WaitHandle {
74     caddr_t proc;       /* process waiting */
75 };
76
77 #define osi_SetFileProc(x,p)    ((x)->proc=(p))
78 #define osi_SetFileRock(x,r)    ((x)->rock=(r))
79 #define osi_GetFileProc(x)      ((x)->proc)
80 #define osi_GetFileRock(x)      ((x)->rock)
81
82 #ifdef  AFS_TEXT_ENV
83 #define osi_FlushText(vp) if (hcmp((vp)->m.DataVersion, (vp)->flushDV) > 0) \
84                             osi_FlushText_really(vp)
85 #else
86 #define osi_FlushText(vp)
87 #endif
88
89
90 #define AFSOP_STOP_RXEVENT   214 /* stop rx event deamon */
91 #define AFSOP_STOP_COMPLETE  215 /* afs has been shutdown */
92 #define AFSOP_STOP_RXK_LISTENER   217 /* stop rx listener daemon */
93
94
95 #define osi_NPACKETS    20              /* number of cluster pkts to alloc */
96
97 /*
98  * Alloc declarations.
99  */
100 #define afs_osi_Alloc_NoSleep afs_osi_Alloc
101
102 /*
103  * Vnode related macros
104  */
105 #ifndef AFS_OBSD_ENV
106 #if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
107 extern int (**afs_vnodeop_p)();
108 #define IsAfsVnode(vc)      ((vc)->v_op == afs_vnodeop_p)
109 #define SetAfsVnode(vc)     (vc)->v_op = afs_vnodeop_p
110 #else
111 extern struct vnodeops *afs_ops;
112 #define IsAfsVnode(vc)      ((vc)->v_op == afs_ops)
113 #define SetAfsVnode(vc)     (vc)->v_op = afs_ops
114 #endif
115 #define vType(vc)           (vc)->v.v_type
116 #define vSetType(vc,type)   (vc)->v.v_type = (type)
117 #define vSetVfsp(vc,vfsp)   (vc)->v.v_vfsp = (vfsp)
118 #endif
119
120 #ifdef AFS_SGI65_ENV
121 #define gop_lookupname(fnamep,segflg,followlink,dirvpp,compvpp) \
122              lookupname((fnamep),(segflg),(followlink),(dirvpp),(compvpp),\
123                         NULL)
124 #else
125 #ifndef AFS_OBSD_ENV
126 #define gop_lookupname(fnamep,segflg,followlink,dirvpp,compvpp) \
127              lookupname((fnamep),(segflg),(followlink),(dirvpp),(compvpp))
128 #endif
129 #endif
130
131 /*
132  * In IRIX 6.5 we cannot have DEBUG turned on since certain
133  * system-defined structures are a different size with DEBUG on, the
134  * kernel is compiled without DEBUG on, and the resulting differences
135  * would break our ability to interact with the rest of the kernel.
136  *
137  * Is DEBUG only for turning the ASSERT() macro?  If so, we should
138  * be able to eliminate DEBUG entirely.
139  */
140 #if !defined(AFS_SGI65_ENV)
141 #ifndef DEBUG
142 #define DEBUG   1       /* Default is to enable debugging/logging */
143 #endif
144 #endif
145
146 /* 
147  * Time related macros
148  */
149 #define osi_GetuTime(x) osi_GetTime(x)
150
151 /* osi_timeval_t exists because SGI 6.x has two sizes of timeval. */
152 /** In 64 bit Solaris the timeval structure has members that are 64 bit
153   * In the GetTime() interface we expect pointers to afs_int32. So the need to
154   * define osi_timeval_t to have 32 bit members. To make this less ambiguous
155   * we now use 32 bit quantities consistently all over the code.
156   * In 64 bit HP-UX the timeval structure has a 64 bit member.
157   */
158
159
160 #if defined(AFS_HPUX_ENV) || defined(AFS_SUN57_ENV) || defined(AFS_LINUX_64BIT_KERNEL) || (defined(AFS_SGI61_ENV) && defined(KERNEL) && defined(_K64U64))
161 typedef struct {
162     afs_int32 tv_sec;
163     afs_int32 tv_usec;
164 } osi_timeval_t;
165 #else
166 typedef struct timeval osi_timeval_t;
167 #endif /* AFS_SGI61_ENV */
168
169 /*
170  * The following three routines provide the fid routines used by the buffer
171  * and directory packages.
172  */
173 #define dirp_Zap(afid)    (*(afid) = -1)
174 #define dirp_Eq(afid, bfid) (*(afid) == *(bfid))
175 #define dirp_Cpy(dfid,sfid) (*(dfid) = *(sfid))
176
177
178 /*
179  * osi_ThreadUnique() should yield a value that can be found in ps
180  * output in order to draw correspondences between ICL traces and what
181  * is going on in the system.  So if ps cannot show thread IDs it is
182  * likely to be the process ID instead.
183  */
184 #ifdef AFS_FBSD50_ENV
185 /* should use curthread, but 'ps' can't display it */
186 #define osi_ThreadUnique()      curproc
187 #else
188 #define osi_ThreadUnique()      getpid()
189 #endif
190
191
192
193 #ifdef AFS_GLOBAL_SUNLOCK
194 #define AFS_ASSERT_GLOCK() \
195     (ISAFS_GLOCK() || (osi_Panic("afs global lock not held at %s:%d\n", __FILE__, __LINE__), 0))
196 #define AFS_ASSERT_RXGLOCK() \
197     (ISAFS_RXGLOCK() || (osi_Panic("rx global lock not held at %s:%d\n", __FILE__, __LINE__), 0))
198 #endif /* AFS_GLOBAL_SUNLOCK */
199
200 #ifdef RX_ENABLE_LOCKS
201 #define RX_AFS_GLOCK()          AFS_GLOCK()
202 #define RX_AFS_GUNLOCK()        AFS_GUNLOCK()
203 #else
204 #define RX_AFS_GLOCK()
205 #define RX_AFS_GUNLOCK()
206 #endif
207
208
209
210 #ifndef KERNEL
211 #define AFS_GLOCK()
212 #define AFS_GUNLOCK()
213 #define ISAFS_GLOCK() 1
214 #define AFS_ASSERT_GLOCK()
215 #define AFS_RXGLOCK()
216 #define AFS_RXGUNLOCK()
217 #define ISAFS_RXGLOCK() 1
218 #define AFS_ASSERT_RXGLOCK()
219 #endif
220
221 /* On an MP that uses multithreading, splnet is not sufficient to provide
222  * mutual exclusion because the other processors will not see it.  On some
223  * early multiprocessors (SunOS413 & SGI5.2) splnet actually obtains a global
224  * mutex, which this works in the UP expected way, it means that the whole MP
225  * can only take one interrupt at a time; a serious performance penalty. */
226
227 #if ((defined(AFS_GLOBAL_SUNLOCK) || defined(RX_ENABLE_LOCKS)) && !defined(AFS_HPUX_ENV)) || !defined(KERNEL)
228 #define SPLVAR
229 #define NETPRI
230 #define USERPRI
231 #endif
232
233 #ifndef AFS_OBSD_ENV
234 /*
235  * vnode/vcache ref count manipulation
236  */
237 #if defined(UKERNEL)
238 #define AFS_RELE(vp) do { VN_RELE(vp); } while (0)
239 #else /* defined(UKERNEL) */
240 #define AFS_RELE(vp) do { AFS_GUNLOCK(); VN_RELE(vp); AFS_GLOCK(); } while (0)
241 #endif /* defined(UKERNEL) */
242 #endif
243
244 /*
245  * For some reason we do bare refcount manipulation in some places, for some
246  * platforms.  The assumption is apparently that either we wouldn't call
247  * afs_inactive anyway (because we know the ref count is high), or that it's
248  * OK not to call it (because we don't expect CUnlinked or CDirty).
249  * (Also, of course, the vnode is assumed to be one of ours.  Can't use this
250  * macro for V-file vnodes.)
251  */
252 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
253 /* Bare refcount manipulation would probably work on this platform, but just
254    calling VREF does not */
255 #define AFS_FAST_HOLD(vp) osi_vnhold((vp),0)
256 #else
257 #define AFS_FAST_HOLD(vp) VN_HOLD(&(vp)->v)
258 #endif
259 #define AFS_FAST_RELE(vp) AFS_RELE(AFSTOV(vp))
260
261 /*
262  * MP safe versions of routines to copy memory between user space
263  * and kernel space. Call these to avoid taking page faults while
264  * holding the global lock.
265  */
266 #ifdef AFS_GLOBAL_SUNLOCK
267
268 #define AFS_COPYIN(SRC,DST,LEN,CODE)                            \
269         do {                                                    \
270             int haveGlock = ISAFS_GLOCK();                      \
271             if (haveGlock)                                      \
272                 AFS_GUNLOCK();                                  \
273             CODE = copyin((SRC),(DST),(LEN));                   \
274             if (haveGlock)                                      \
275                 AFS_GLOCK();                                    \
276         } while(0)
277
278 #define AFS_COPYINSTR(SRC,DST,LEN,CNT,CODE)                     \
279         do {                                                    \
280             int haveGlock = ISAFS_GLOCK();                      \
281             if (haveGlock)                                      \
282                 AFS_GUNLOCK();                                  \
283             CODE = copyinstr((SRC),(DST),(LEN),(CNT));          \
284             if (haveGlock)                                      \
285                 AFS_GLOCK();                                    \
286         } while(0)
287
288 #define AFS_COPYOUT(SRC,DST,LEN,CODE)                           \
289         do {                                                    \
290             int haveGlock = ISAFS_GLOCK();                      \
291             if (haveGlock)                                      \
292                 AFS_GUNLOCK();                                  \
293             CODE = copyout((SRC),(DST),(LEN));                  \
294             if (haveGlock)                                      \
295                 AFS_GLOCK();                                    \
296         } while(0)
297
298 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
299 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                        \
300         do {                                                    \
301             int haveGlock = ISAFS_GLOCK();                      \
302             if (haveGlock)                                      \
303                 AFS_GUNLOCK();                                  \
304             (UIO)->uio_rw = (RW);                               \
305             CODE = uiomove((SRC),(LEN),(UIO));                  \
306             if (haveGlock)                                      \
307                 AFS_GLOCK();                                    \
308         } while(0)
309 #else
310 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                        \
311         do {                                                    \
312             int haveGlock = ISAFS_GLOCK();                      \
313             if (haveGlock)                                      \
314                 AFS_GUNLOCK();                                  \
315             CODE = uiomove((SRC),(LEN),(RW),(UIO));             \
316             if (haveGlock)                                      \
317                 AFS_GLOCK();                                    \
318         } while(0)
319 #endif
320
321 #else /* AFS_GLOBAL_SUNLOCK */
322
323 #define AFS_COPYIN(SRC,DST,LEN,CODE)                            \
324         do {                                                    \
325             CODE = copyin((SRC),(DST),(LEN));                   \
326         } while(0)
327
328 #define AFS_COPYINSTR(SRC,DST,LEN,CNT,CODE)                     \
329         do {                                                    \
330             CODE = copyinstr((SRC),(DST),(LEN),(CNT));          \
331         } while(0)
332
333 #define AFS_COPYOUT(SRC,DST,LEN,CODE)                           \
334         do {                                                    \
335             CODE = copyout((SRC),(DST),(LEN));                  \
336         } while(0)
337
338 #if defined(AFS_OSF_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
339 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                        \
340         do {                                                    \
341             (UIO)->uio_rw = (RW);                               \
342             CODE = uiomove((SRC),(LEN),(UIO));                  \
343         } while(0)
344 #else /* AFS_OSF_ENV || AFS_FBSD_ENV */
345 #define AFS_UIOMOVE(SRC,LEN,RW,UIO,CODE)                        \
346         do {                                                    \
347             CODE = uiomove((SRC),(LEN),(RW),(UIO));             \
348         } while(0)
349 #endif /* AFS_OSF_ENV || AFS_FBSD_ENV */
350
351 #endif /* AFS_GLOBAL_SUNLOCK */
352
353 /*
354  * encapsulation of kernel data structure accesses
355  */
356 #define setuerror(erval)        u.u_error = (erval)
357 #define getuerror()             u.u_error
358
359 /* Macros for vcache/vnode and vfs arguments to vnode and vfs ops.
360  * These are required for IRIX 6.4 and later, which pass behavior pointers.
361  * Note that the _CONVERT routines get the ";" here so that argument lists
362  * can have arguments after the OSI_x_CONVERT macro is called.
363  */
364 #define OSI_VN_ARG(V) V
365 #define OSI_VN_DECL(V) struct vnode *V
366 #define OSI_VN_CONVERT(V)
367 #define OSI_VC_ARG(V) V
368 #define OSI_VC_DECL(V) struct vcache *V
369 #define OSI_VC_CONVERT(V)
370 #define OSI_VFS_ARG(V) V
371 #define OSI_VFS_DECL(V) struct vfs *V
372 #define OSI_VFS_CONVERT(V)
373
374
375 /*
376 ** Macro for Solaris 2.6 returns 1 if file is larger than 2GB; else returns 0 
377 */
378 #define AfsLargeFileUio(uio)       0
379 #define AfsLargeFileSize(pos, off) 0
380
381 /* Now include system specific OSI header file. It will redefine macros
382  * defined here as required by the OS.
383  */
384 #include "osi_machdep.h"
385
386 /* Declare any structures which use these macros after the OSI implementation
387  * has had the opportunity to redefine them.
388  */
389 extern struct AFS_UCRED afs_osi_cred;
390
391 #ifndef osi_curcred
392 #define osi_curcred() (u.u_cred)
393 #endif
394
395 #endif /* _AFS_OSI_ */