SOLARIS: Avoid uninitialized caller_context_t
[openafs.git] / src / afs / SOLARIS / osi_file.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
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #include "afsincludes.h"        /* Afs-based standard headers */
16 #include "afs/afs_stats.h"      /* afs statistics */
17 #include "afs/osi_inode.h"
18
19
20 int afs_osicred_initialized = 0;
21 afs_lock_t afs_xosi;            /* lock is for tvattr */
22 extern struct osi_dev cacheDev;
23 extern struct vfs *afs_cacheVfsp;
24
25
26 #ifdef AFS_HAVE_VXFS
27
28 /* Support for UFS and VXFS caches. The assumption here is that the size of
29  * a cache file also does not exceed 32 bits. 
30  */
31
32 /* Initialized in osi_InitCacheFSType(). Used to determine inode type. */
33 int afs_CacheFSType = -1;
34
35 /* pointer to VXFS routine to access vnodes by inode number */
36 int (*vxfs_vx_vp_byino) ();
37
38 /* Initialize the cache operations. Called while initializing cache files. */
39 void
40 afs_InitDualFSCacheOps(struct vnode *vp)
41 {
42     int code;
43     static int inited = 0;
44     struct vfs *vfsp;
45     struct statvfs64 vfst;
46
47     if (inited)
48         return;
49     inited = 1;
50
51     if (vp == NULL)
52         return;
53
54     vfsp = vp->v_vfsp;
55     if (vfsp == NULL)
56         osi_Panic("afs_InitDualFSCacheOps: vp->v_vfsp is NULL");
57     code = VFS_STATVFS(vfsp, &vfst);
58     if (code)
59         osi_Panic("afs_InitDualFSCacheOps: statvfs failed");
60
61     if (strcmp(vfst.f_basetype, "vxfs") == 0) {
62         vxfs_vx_vp_byino = (int (*)())modlookup("vxfs", "vx_vp_byino");
63         if (vxfs_vx_vp_byino == NULL)
64             osi_Panic
65                 ("afs_InitDualFSCacheOps: modlookup(vx_vp_byino) failed");
66
67         afs_CacheFSType = AFS_SUN_VXFS_CACHE;
68         return;
69     }
70
71     afs_CacheFSType = AFS_SUN_UFS_CACHE;
72     return;
73 }
74
75 ino_t
76 VnodeToIno(vnode_t * vp)
77 {
78     int code;
79     struct vattr vattr;
80
81     vattr.va_mask = AT_FSID | AT_NODEID;        /* quick return using this mask. */
82 #ifdef AFS_SUN511_ENV
83     code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp, NULL);
84 #else
85     code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp);
86 #endif
87     if (code) {
88         osi_Panic("VnodeToIno");
89     }
90     return vattr.va_nodeid;
91 }
92
93 dev_t
94 VnodeToDev(vnode_t * vp)
95 {
96     int code;
97     struct vattr vattr;
98
99     vattr.va_mask = AT_FSID | AT_NODEID;        /* quick return using this mask. */
100     AFS_GUNLOCK();
101 #ifdef AFS_SUN511_ENV
102     code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp, NULL);
103 #else
104     code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp);
105 #endif
106     AFS_GLOCK();
107     if (code) {
108         osi_Panic("VnodeToDev");
109     }
110     return (dev_t) vattr.va_fsid;
111 }
112
113 afs_int32
114 VnodeToSize(vnode_t * vp)
115 {
116     int code;
117     struct vattr vattr;
118
119     /*
120      * We lock xosi in osi_Stat, so we probably should
121      * lock it here too - RWH.
122      */
123     ObtainWriteLock(&afs_xosi, 578);
124     vattr.va_mask = AT_SIZE;
125     AFS_GUNLOCK();
126 #ifdef AFS_SUN511_ENV
127     code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp, NULL);
128 #else
129     code = VOP_GETATTR(vp, &vattr, 0, afs_osi_credp);
130 #endif
131     AFS_GLOCK();
132     if (code) {
133         osi_Panic("VnodeToSize");
134     }
135     ReleaseWriteLock(&afs_xosi);
136     return (afs_int32) (vattr.va_size);
137 }
138
139 void *
140 osi_VxfsOpen(afs_dcache_id_t *ainode)
141 {
142     struct vnode *vp;
143     struct osi_file *afile = NULL;
144     afs_int32 code = 0;
145     int dummy;
146     afile = osi_AllocSmallSpace(sizeof(struct osi_file));
147     AFS_GUNLOCK();
148     code = (*vxfs_vx_vp_byino) (afs_cacheVfsp, &vp, (unsigned int)ainode->ufs);
149     AFS_GLOCK();
150     if (code) {
151         osi_FreeSmallSpace(afile);
152         osi_Panic("VxfsOpen: vx_vp_byino failed");
153     }
154     afile->vnode = vp;
155     afile->size = VnodeToSize(afile->vnode);
156     afile->offset = 0;
157     afile->proc = (int (*)())0;
158     return (void *)afile;
159 }
160 #endif /* AFS_HAVE_VXFS */
161
162 void *
163 osi_UfsOpen(afs_dcache_id_t *ainode)
164 {
165 #ifdef AFS_CACHE_VNODE_PATH
166     struct vnode *vp;
167 #else
168     struct inode *ip;
169 #endif
170     struct osi_file *afile = NULL;
171     afs_int32 code = 0;
172     int dummy;
173 #ifdef AFS_CACHE_VNODE_PATH
174     char namebuf[1024];
175     struct pathname lookpn;
176 #endif
177     struct osi_stat tstat;
178     afile = osi_AllocSmallSpace(sizeof(struct osi_file));
179     AFS_GUNLOCK();
180
181 /*
182  * AFS_CACHE_VNODE_PATH can be used with any file system, including ZFS or tmpfs.
183  * The ainode is not an inode number but a path.
184  */
185 #ifdef AFS_CACHE_VNODE_PATH
186         /* Can not use vn_open or lookupname, they use user's CRED() 
187          * We need to run as root So must use low level lookuppnvp
188          * assume fname starts with /
189          */
190
191         code = pn_get_buf(ainode->ufs, AFS_UIOSYS, &lookpn, namebuf, sizeof(namebuf));
192     if (code != 0) 
193         osi_Panic("UfsOpen: pn_get_buf failed %ld %s", code, ainode->ufs);
194  
195         VN_HOLD(rootdir); /* released in loopuppnvp */
196         code = lookuppnvp(&lookpn, NULL, FOLLOW, NULL, &vp, 
197            rootdir, rootdir, afs_osi_credp);
198     if (code != 0)  
199         osi_Panic("UfsOpen: lookuppnvp failed %ld %s", code, ainode->ufs);
200         
201 #ifdef AFS_SUN511_ENV
202     code = VOP_OPEN(&vp, FREAD|FWRITE, afs_osi_credp, NULL);
203 #else
204     code = VOP_OPEN(&vp, FREAD|FWRITE, afs_osi_credp);
205 #endif
206
207     if (code != 0)
208         osi_Panic("UfsOpen: VOP_OPEN failed %ld %s", code, ainode->ufs);
209
210 #else
211     code =
212         igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode->ufs, &ip,
213                   CRED(), &dummy);
214 #endif
215     AFS_GLOCK();
216     if (code) {
217         osi_FreeSmallSpace(afile);
218         osi_Panic("UfsOpen: igetinode failed %ld %s", code, ainode->ufs);
219     }
220 #ifdef AFS_CACHE_VNODE_PATH
221     afile->vnode = vp;
222     code = afs_osi_Stat(afile, &tstat);
223     afile->size = tstat.size;
224 #else
225     afile->vnode = ITOV(ip);
226     afile->size = VTOI(afile->vnode)->i_size;
227 #endif
228     afile->offset = 0;
229     afile->proc = (int (*)())0;
230     return (void *)afile;
231 }
232
233 /**
234   * In Solaris 7 we use 64 bit inode numbers
235   */
236 void *
237 osi_UFSOpen(afs_dcache_id_t *ainode)
238 {
239     extern int cacheDiskType;
240     AFS_STATCNT(osi_UFSOpen);
241     if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
242         osi_Panic("UFSOpen called for non-UFS cache\n");
243     }
244     if (!afs_osicred_initialized) {
245         afs_osi_credp = kcred;
246         afs_osicred_initialized = 1;
247     }
248 #ifdef AFS_HAVE_VXFS
249     if (afs_CacheFSType == AFS_SUN_VXFS_CACHE)
250         return osi_VxfsOpen(ainode);
251 #endif
252     return osi_UfsOpen(ainode);
253 }
254
255 int
256 afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
257 {
258     afs_int32 code;
259     struct vattr tvattr;
260     AFS_STATCNT(osi_Stat);
261     ObtainWriteLock(&afs_xosi, 320);
262     /* Ufs doesn't seem to care about the flags so we pass 0 for now */
263     tvattr.va_mask = AT_ALL;
264     AFS_GUNLOCK();
265 #ifdef AFS_SUN511_ENV 
266     code = VOP_GETATTR(afile->vnode, &tvattr, 0, afs_osi_credp, NULL);
267 #else
268     code = VOP_GETATTR(afile->vnode, &tvattr, 0, afs_osi_credp);
269 #endif
270     AFS_GLOCK();
271     if (code == 0) {
272         astat->size = tvattr.va_size;
273         astat->mtime = tvattr.va_mtime.tv_sec;
274         astat->atime = tvattr.va_atime.tv_sec;
275     }
276     ReleaseWriteLock(&afs_xosi);
277     return code;
278 }
279
280 int
281 osi_UFSClose(struct osi_file *afile)
282 {
283     AFS_STATCNT(osi_Close);
284     if (afile->vnode) {
285         AFS_RELE(afile->vnode);
286     }
287
288     osi_FreeSmallSpace(afile);
289     return 0;
290 }
291
292 int
293 osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
294 {
295     afs_ucred_t *oldCred;
296     struct vattr tvattr;
297     afs_int32 code;
298     struct osi_stat tstat;
299     AFS_STATCNT(osi_Truncate);
300
301     /* This routine only shrinks files, and most systems
302      * have very slow truncates, even when the file is already
303      * small enough.  Check now and save some time.
304      */
305     code = afs_osi_Stat(afile, &tstat);
306     if (code || tstat.size <= asize)
307         return code;
308     ObtainWriteLock(&afs_xosi, 321);
309     tvattr.va_mask = AT_SIZE;
310     tvattr.va_size = asize;
311     /*
312      * The only time a flag is used (ATTR_UTIME) is when we're changing the time 
313      */
314     AFS_GUNLOCK();
315 #ifdef AFS_SUN510_ENV
316     code = VOP_SETATTR(afile->vnode, &tvattr, 0, afs_osi_credp, NULL);
317 #else
318     code = VOP_SETATTR(afile->vnode, &tvattr, 0, afs_osi_credp);
319 #endif
320     AFS_GLOCK();
321     ReleaseWriteLock(&afs_xosi);
322     return code;
323 }
324
325 void
326 osi_DisableAtimes(struct vnode *avp)
327 {
328     if (afs_CacheFSType == AFS_SUN_UFS_CACHE) {
329 #ifndef AFS_CACHE_VNODE_PATH 
330         struct inode *ip = VTOI(avp);
331         rw_enter(&ip->i_contents, RW_READER);
332         mutex_enter(&ip->i_tlock);
333         ip->i_flag &= ~IACC;
334         mutex_exit(&ip->i_tlock);
335         rw_exit(&ip->i_contents);
336 #endif
337     }
338 }
339
340
341 /* Generic read interface */
342 int
343 afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
344              afs_int32 asize)
345 {
346     afs_ucred_t *oldCred;
347     ssize_t resid;
348     afs_int32 code;
349     afs_int32 cnt1 = 0;
350     AFS_STATCNT(osi_Read);
351
352     /**
353       * If the osi_file passed in is NULL, panic only if AFS is not shutting
354       * down. No point in crashing when we are already shutting down
355       */
356     if (!afile) {
357         if (!afs_shuttingdown)
358             osi_Panic("osi_Read called with null param");
359         else
360             return -EIO;
361     }
362
363     if (offset != -1)
364         afile->offset = offset;
365     AFS_GUNLOCK();
366     code =
367         gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset,
368                  AFS_UIOSYS, 0, 0, afs_osi_credp, &resid);
369     AFS_GLOCK();
370     if (code == 0) {
371         code = asize - resid;
372         afile->offset += code;
373         osi_DisableAtimes(afile->vnode);
374     } else {
375         afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid,
376                    ICL_TYPE_INT32, code);
377         if (code > 0) {
378             code = -code;
379         }
380     }
381     return code;
382 }
383
384 /* Generic write interface */
385 int
386 afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
387               afs_int32 asize)
388 {
389     afs_ucred_t *oldCred;
390     ssize_t resid;
391     afs_int32 code;
392     AFS_STATCNT(osi_Write);
393     if (!afile)
394         osi_Panic("afs_osi_Write called with null param");
395     if (offset != -1)
396         afile->offset = offset;
397     AFS_GUNLOCK();
398     code =
399         gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
400                  afile->offset, AFS_UIOSYS, 0, RLIM64_INFINITY, afs_osi_credp,
401                  &resid);
402     AFS_GLOCK();
403     if (code == 0) {
404         code = asize - resid;
405         afile->offset += code;
406     } else {
407         if (code > 0) {
408             code = -code;
409         }
410     }
411     if (afile->proc) {
412         (*afile->proc) (afile, code);
413     }
414     return code;
415 }
416
417
418 /*  This work should be handled by physstrat in ca/machdep.c.
419     This routine written from the RT NFS port strategy routine.
420     It has been generalized a bit, but should still be pretty clear. */
421 int
422 afs_osi_MapStrategy(int (*aproc) (), struct buf *bp)
423 {
424     afs_int32 returnCode;
425
426     AFS_STATCNT(osi_MapStrategy);
427     returnCode = (*aproc) (bp);
428
429     return returnCode;
430 }
431
432
433
434 void
435 shutdown_osifile(void)
436 {
437     AFS_STATCNT(shutdown_osifile);
438     if (afs_cold_shutdown) {
439         afs_osicred_initialized = 0;
440     }
441 }