afs: Remove afs_xosi
[openafs.git] / src / afs / NBSD / 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 #include "afs/sysincludes.h"    /* Standard vendor system headers */
14 #include "afs/afsincludes.h"    /* Afs-based standard headers */
15 #include "afs/afs_stats.h"      /* afs statistics */
16
17
18 int afs_osicred_initialized;
19 extern struct osi_dev cacheDev;
20 extern struct mount *afs_cacheVfsp;
21
22 void *
23 osi_UFSOpen(afs_dcache_id_t *ainode)
24 {
25     struct osi_file *afile;
26     struct vnode *vp;
27     extern int cacheDiskType;
28     afs_int32 code;
29
30     AFS_STATCNT(osi_UFSOpen);
31     if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
32         osi_Panic("UFSOpen called for non-UFS cache\n");
33     afile = osi_AllocSmallSpace(sizeof(struct osi_file));
34     AFS_GUNLOCK();
35     code = VFS_VGET(cacheDev.mp, (ino_t) ainode->ufs, &vp);
36     AFS_GLOCK();
37     if (code == 0 && vp->v_type == VNON)
38         code = ENOENT;
39     if (code) {
40         osi_FreeSmallSpace(afile);
41         osi_Panic("UFSOpen: igetinode failed");
42     }
43 #if defined(AFS_NBSD60_ENV)
44     VOP_UNLOCK(vp);
45 #else
46     VOP_UNLOCK(vp, 0);
47 #endif
48     afile->vnode = vp;
49     afile->size = VTOI(vp)->i_ffs1_size;
50     afile->offset = 0;
51     afile->proc = NULL;
52     return (void *)afile;
53 }
54
55 int
56 afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
57 {
58     afs_int32 code;
59     struct vattr tvattr;
60
61     AFS_STATCNT(osi_Stat);
62     AFS_GUNLOCK();
63 #ifdef AFS_NBSD50_ENV
64         code = VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp);
65 #else
66     code = VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp,
67                        osi_curproc());
68 #endif
69     AFS_GLOCK();
70     if (code == 0) {
71         astat->size = afile->size = tvattr.va_size;
72         astat->mtime = tvattr.va_mtime.tv_sec;
73         astat->atime = tvattr.va_atime.tv_sec;
74     }
75     return code;
76 }
77
78 int
79 osi_UFSClose(struct osi_file *afile)
80 {
81     AFS_STATCNT(osi_Close);
82
83     if (afile->vnode)
84         AFS_RELE(afile->vnode);
85
86     osi_FreeSmallSpace(afile);
87     return 0;
88 }
89
90 int
91 osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
92 {
93     struct vattr tvattr;
94     afs_int32 code;
95     struct osi_stat tstat;
96
97     AFS_STATCNT(osi_Truncate);
98
99     /*
100      * This routine only shrinks files, and most systems
101      * have very slow truncates, even when the file is already
102      * small enough.  Check now and save some time.
103      */
104     code = afs_osi_Stat(afile, &tstat);
105     if (code || tstat.size <= asize)
106         return code;
107
108     VATTR_NULL(&tvattr);
109     tvattr.va_size = asize;
110     AFS_GUNLOCK();
111     VOP_LOCK(afile->vnode, LK_EXCLUSIVE | LK_RETRY);
112 #ifdef AFS_NBSD50_ENV
113     code = VOP_SETATTR(afile->vnode, &tvattr, afs_osi_credp);
114 #else
115     code = VOP_SETATTR(afile->vnode, &tvattr, afs_osi_credp,
116                        osi_curproc());
117 #endif
118 #ifdef AFS_NBSD60_ENV
119     VOP_UNLOCK(afile->vnode);
120 #else
121     VOP_UNLOCK(afile->vnode, 0);
122 #endif
123     AFS_GLOCK();
124     if (code == 0)
125         afile->size = asize;
126     return code;
127 }
128
129 void
130 osi_DisableAtimes(struct vnode *avp)
131 {
132 #if 0
133     VTOI(avp)->i_flag &= ~IN_ACCESS;
134 #endif
135 }
136
137
138 /* Generic read interface */
139 int
140 afs_osi_Read(struct osi_file *afile, int offset, void *aptr, afs_int32 asize)
141 {
142     size_t resid;
143     afs_int32 code;
144
145     AFS_STATCNT(osi_Read);
146
147     /*
148      * If the osi_file passed in is NULL, panic only if AFS is not shutting
149      * down. No point in crashing when we are already shutting down
150      */
151     if (!afile) {
152         if (afs_shuttingdown == AFS_RUNNING)
153             osi_Panic("osi_Read called with null param");
154         else
155             return -EIO;
156     }
157
158     if (offset != -1)
159         afile->offset = offset;
160     AFS_GUNLOCK();
161     code =
162         vn_rdwr(UIO_READ, afile->vnode, aptr, asize, afile->offset,
163                 AFS_UIOSYS, IO_UNIT, afs_osi_credp, &resid,
164                 osi_curproc());
165     AFS_GLOCK();
166     if (code == 0) {
167         code = asize - resid;
168         afile->offset += code;
169         osi_DisableAtimes(afile->vnode);
170     } else {
171         afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid,
172                    ICL_TYPE_INT32, code);
173         if (code > 0) {
174             code = -code;
175         }
176     }
177     return code;
178 }
179
180 /* Generic write interface */
181 int
182 afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
183               afs_int32 asize)
184 {
185     size_t resid;
186     afs_int32 code;
187
188     AFS_STATCNT(osi_Write);
189     if (!afile)
190         osi_Panic("afs_osi_Write called with null afile");
191     if (offset != -1)
192         afile->offset = offset;
193
194     AFS_GUNLOCK();
195     code =
196         vn_rdwr(UIO_WRITE, afile->vnode, aptr, asize, afile->offset,
197                 AFS_UIOSYS, IO_UNIT, afs_osi_credp, &resid, osi_curproc());
198     AFS_GLOCK();
199
200     if (code == 0) {
201         code = asize - resid;
202         afile->offset += code;
203         if (afile->offset > afile->size)
204             afile->size = afile->offset;
205     } else {
206         if (code > 0) {
207             code = -code;
208         }
209     }
210
211     if (afile->proc)
212         (*afile->proc) (afile, code);
213
214     return code;
215 }
216
217 /*
218  * This work should be handled by physstrat in ca/machdep.c.  This routine
219  * written from the RT NFS port strategy routine.  It has been generalized a
220  * bit, but should still be pretty clear.
221  */
222 int
223 afs_osi_MapStrategy(int (*aproc)(struct buf *), struct buf *bp)
224 {
225     afs_int32 returnCode;
226
227     AFS_STATCNT(osi_MapStrategy);
228     returnCode = (*aproc) (bp);
229
230     return returnCode;
231 }
232
233 void
234 shutdown_osifile(void)
235 {
236     AFS_STATCNT(shutdown_osifile);
237     if (afs_cold_shutdown)
238         afs_osicred_initialized = 0;
239 }