76795673de2ecb9e30db5883e37e9e2f8142f594
[openafs.git] / src / vol / physio.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 /*
11         System:         VICE-TWO
12         Module:         physio.c
13         Institution:    The Information Technology Center, Carnegie-Mellon University
14
15  */
16
17 #include <afsconfig.h>
18 #include <afs/param.h>
19
20
21 #include <stdio.h>
22 #include <sys/types.h>
23 #include <errno.h>
24 #ifdef AFS_NT40_ENV
25 #include <fcntl.h>
26 #else
27 #include <sys/file.h>
28 #include <unistd.h>
29 #include <string.h>
30 #ifdef  AFS_SUN5_ENV
31 #include <sys/fcntl.h>
32 #endif
33 #endif
34 #include <rx/xdr.h>
35 #include <afs/afsint.h>
36 #include <errno.h>
37 #include <afs/afssyscalls.h>
38 #include "nfs.h"
39 #include "ihandle.h"
40 #include "salvage.h"
41 #include <afs/dir.h>
42 #include <assert.h>
43 #include "vol_internal.h"
44
45 /* returns 0 on success, errno on failure */
46 int
47 ReallyRead(DirHandle * file, int block, char *data)
48 {
49     FdHandle_t *fdP;
50     int code;
51     errno = 0;
52     fdP = IH_OPEN(file->dirh_handle);
53     if (fdP == NULL) {
54         code = errno;
55         return code;
56     }
57     if (FDH_SEEK(fdP, block * AFS_PAGESIZE, SEEK_SET) < 0) {
58         code = errno;
59         FDH_REALLYCLOSE(fdP);
60         return code;
61     }
62     code = FDH_READ(fdP, data, (afs_fsize_t) AFS_PAGESIZE);
63     if (code != AFS_PAGESIZE) {
64         if (code < 0)
65             code = errno;
66         else
67             code = EIO;
68         FDH_REALLYCLOSE(fdP);
69         return code;
70     }
71     FDH_CLOSE(fdP);
72     return 0;
73 }
74
75 /* returns 0 on success, errno on failure */
76 int
77 ReallyWrite(DirHandle * file, int block, char *data)
78 {
79     FdHandle_t *fdP;
80     extern int VolumeChanged;
81     int code;
82
83     errno = 0;
84
85     fdP = IH_OPEN(file->dirh_handle);
86     if (fdP == NULL) {
87         code = errno;
88         return code;
89     }
90     if (FDH_SEEK(fdP, block * AFS_PAGESIZE, SEEK_SET) < 0) {
91         code = errno;
92         FDH_REALLYCLOSE(fdP);
93         return code;
94     }
95     code = FDH_WRITE(fdP, data, (afs_fsize_t) AFS_PAGESIZE);
96     if (code != AFS_PAGESIZE) {
97         if (code < 0)
98             code = errno;
99         else
100             code = EIO;
101         FDH_REALLYCLOSE(fdP);
102         return code;
103     }
104     FDH_CLOSE(fdP);
105     VolumeChanged = 1;
106     return 0;
107 }
108
109 /* SetSalvageDirHandle:
110  * Create a handle to a directory entry and reference it (IH_INIT).
111  * The handle needs to be dereferenced with the FidZap() routine.
112  */
113 void
114 SetSalvageDirHandle(DirHandle * dir, afs_int32 volume, Device device,
115                     Inode inode)
116 {
117     static int SalvageCacheCheck = 1;
118     memset(dir, 0, sizeof(DirHandle));
119
120     dir->dirh_device = device;
121     dir->dirh_volume = volume;
122     dir->dirh_inode = inode;
123     IH_INIT(dir->dirh_handle, device, volume, inode);
124     /* Always re-read for a new dirhandle */
125     dir->dirh_cacheCheck = SalvageCacheCheck++;
126 }
127
128 void
129 FidZap(DirHandle * file)
130 {
131     IH_RELEASE(file->dirh_handle);
132     memset(file, 0, sizeof(DirHandle));
133 }
134
135 void
136 FidZero(DirHandle * file)
137 {
138     memset(file, 0, sizeof(DirHandle));
139 }
140
141 int
142 FidEq(DirHandle * afile, DirHandle * bfile)
143 {
144     if (afile->dirh_volume != bfile->dirh_volume)
145         return 0;
146     if (afile->dirh_device != bfile->dirh_device)
147         return 0;
148     if (afile->dirh_cacheCheck != bfile->dirh_cacheCheck)
149         return 0;
150     if (afile->dirh_inode != bfile->dirh_inode)
151         return 0;
152     return 1;
153 }
154
155 int
156 FidVolEq(DirHandle * afile, afs_int32 vid)
157 {
158     if (afile->dirh_volume != vid)
159         return 0;
160     return 1;
161 }
162
163 void
164 FidCpy(DirHandle * tofile, DirHandle * fromfile)
165 {
166     *tofile = *fromfile;
167     IH_COPY(tofile->dirh_handle, fromfile->dirh_handle);
168 }
169
170 void
171 Die(char *msg)
172 {
173     printf("%s\n", msg);
174     assert(1 == 2);
175 }