ubik-warning-cleanup-20011005
[openafs.git] / src / ubik / phys.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 RCSID("$Header$");
14
15 #include <sys/types.h>
16 #ifdef AFS_NT40_ENV
17 #include <winsock2.h>
18 #include <io.h>
19 #include <fcntl.h>
20 #else
21 #include <sys/file.h>
22 #include <netinet/in.h>
23 #endif
24 #include <sys/stat.h>
25 #include <lwp.h>
26 #include <lock.h>
27 #include <errno.h>
28 #ifdef HAVE_STRING_H
29 #include <string.h>
30 #else
31 #ifdef HAVE_STRINGS_H
32 #include <strings.h>
33 #endif
34 #endif
35
36 #define UBIK_INTERNALS 1
37 #include "ubik.h"
38
39 /* these routines are called via the proc ptr in the ubik_dbase structure.  They provide access to
40  * the physical disk, by converting the file numbers being processed (>= 0 for user data space, < 0
41  * for ubik system files, such as the log) to actual pathnames to open, read, write, truncate, sync,
42  * etc.
43  */
44
45 #define MAXFDCACHE  4
46 static struct fdcache {
47     int fd;
48     int fileID;
49     int refCount;
50 } fdcache[MAXFDCACHE];
51
52 static char pbuffer[1024];
53
54 /* beware, when using this function, of the header in front of most files */
55 static int uphys_open(adbase, afid)
56     register struct ubik_dbase *adbase;
57     afs_int32 afid; {
58     char temp[20];
59     register int fd;
60     static int initd;
61     register int i;
62     register struct fdcache *tfd;
63     struct fdcache *bestfd;
64
65     /* initialize package */
66     if (!initd) {
67         initd=1;
68         tfd=fdcache;
69         for(i=0;i<MAXFDCACHE;tfd++,i++) {
70             tfd->fd = -1;           /* invalid value */
71             tfd->fileID = -10000;   /* invalid value */
72             tfd->refCount = 0;
73         }
74     }
75
76     /* scan file descr cache */
77     for(tfd=fdcache,i=0; i<MAXFDCACHE; i++,tfd++) {
78         if (afid == tfd->fileID && tfd->refCount == 0) {    /* don't use open fd */
79             lseek(tfd->fd, 0, 0);   /* reset ptr just like open would have */
80             tfd->refCount++;
81             return tfd->fd;
82         }
83     }
84
85     /* not found, open it and try to enter in cache */
86     strcpy(pbuffer, adbase->pathName);
87     strcat(pbuffer, ".DB");
88     if (afid < 0) {
89         i = -afid;
90         strcat(pbuffer, "SYS");
91     }
92     else i = afid;
93     sprintf(temp, "%d", i);
94     strcat(pbuffer, temp);
95     fd = open(pbuffer, O_CREAT | O_RDWR, 0600);
96     if (fd < 0) {
97         /* try opening read-only */
98         fd = open(pbuffer, O_RDONLY, 0);
99         if (fd < 0) return fd;
100     }
101     
102     /* enter it in the cache */
103     tfd = fdcache;
104     bestfd = (struct fdcache *) 0;
105     for(i=0;i<MAXFDCACHE;i++,tfd++) {   /* look for empty slot */
106         if (tfd->fd == -1) {
107             bestfd = tfd;
108             break;
109         }
110     }
111     if (!bestfd) {                      /* look for reclaimable slot */
112         tfd = fdcache;
113         for(i=0;i<MAXFDCACHE;i++,tfd++) {
114             if (tfd->refCount == 0) {
115                 bestfd = tfd;
116                 break;
117             }
118         }
119     }
120     if (bestfd) {           /* found a usable slot */
121         tfd = bestfd;
122         if (tfd->fd >= 0) close(tfd->fd);
123         tfd->fd = fd;
124         tfd->refCount = 1;      /* us */
125         tfd->fileID = afid;
126     }
127
128     /* finally, we're done */
129     return fd;
130 }
131
132 /* close the file, maintaining ref count in cache structure */
133 uphys_close (afd)
134 register int afd; {
135     register int i;
136     register struct fdcache *tfd;
137
138     if (afd < 0) return EBADF;
139     tfd = fdcache;
140     for(i=0;i<MAXFDCACHE;i++,tfd++) {
141         if (tfd->fd == afd) {
142             tfd->refCount--;
143             return 0;
144         }
145     }
146     return close(afd);
147 }
148
149 uphys_stat(adbase, afid, astat)
150     struct ubik_stat *astat;
151     afs_int32 afid;
152     struct ubik_dbase *adbase; {
153     register int fd;
154     struct stat tstat;
155     register afs_int32 code;
156     
157     fd = uphys_open(adbase, afid);
158     if (fd < 0) return fd;
159     code = fstat(fd, &tstat);
160     uphys_close(fd);
161     if (code < 0) {
162         return code;
163     }
164     astat->mtime = tstat.st_mtime;
165     code = tstat.st_size-HDRSIZE;
166     if (code < 0) astat->size = 0;
167     else astat->size = code;
168     return 0;
169 }
170
171 uphys_read(adbase, afile, abuffer, apos, alength)
172     register struct ubik_dbase *adbase;
173     register char *abuffer;
174     afs_int32 apos;
175     afs_int32 afile;
176     afs_int32 alength; {
177     register int fd;
178     register afs_int32 code;
179
180     fd = uphys_open(adbase, afile);
181     if (fd < 0) return -1;
182     code = lseek(fd, apos+HDRSIZE, 0);
183     if (code < 0) {
184         uphys_close(fd);
185         return -1;
186     }
187     code = read(fd, abuffer, alength);
188     uphys_close(fd);
189     return code;
190 }
191
192 uphys_write(adbase, afile, abuffer, apos, alength)
193     register struct ubik_dbase *adbase;
194     register char *abuffer;
195     afs_int32 apos;
196     afs_int32 afile;
197     afs_int32 alength; {
198     register int fd;
199     register afs_int32 code;
200     afs_int32 length;
201
202     fd = uphys_open(adbase, afile);
203     if (fd < 0) return -1;
204     code = lseek(fd, apos+HDRSIZE, 0);
205     if (code < 0) {
206         uphys_close(fd);
207         return -1;
208     }
209     length = write(fd, abuffer, alength);
210     code = uphys_close(fd);
211     if (code) return -1;
212     else return length;
213 }
214
215 uphys_truncate(adbase, afile, asize)
216     afs_int32 asize;
217     register struct ubik_dbase *adbase;
218     afs_int32 afile; {
219     register afs_int32 code, fd;
220     fd = uphys_open(adbase, afile);
221     if (fd < 0) return UNOENT;
222     code = ftruncate(fd, asize+HDRSIZE);
223     uphys_close(fd);
224     return code;
225 }
226
227 /* get number of dbase files */
228 uphys_getnfiles(adbase) {
229     /* really should scan dir for data */
230     return 1;
231 }
232
233 /* get database label, with aversion in host order */
234 uphys_getlabel(adbase, afile, aversion)
235     register struct ubik_dbase *adbase;
236     afs_int32 afile;
237     struct ubik_version *aversion; {
238     struct ubik_hdr thdr;
239     register afs_int32 code, fd;
240
241     fd = uphys_open(adbase, afile);
242     if (fd < 0) return UNOENT;
243     code = read(fd, &thdr, sizeof(thdr));
244     if (code != sizeof(thdr)) {
245         uphys_close(fd);
246         return EIO;
247     }
248     aversion->epoch = ntohl(thdr.version.epoch);
249     aversion->counter=ntohl(thdr.version.counter);
250     uphys_close(fd);
251     return 0;
252 }
253
254 /* label database, with aversion in host order */
255 uphys_setlabel(adbase, afile, aversion)
256     register struct ubik_dbase *adbase;
257     afs_int32 afile;
258     struct ubik_version *aversion; {
259     struct ubik_hdr thdr;
260     register afs_int32 code, fd;
261
262     fd = uphys_open(adbase, afile);
263     if (fd < 0) return UNOENT;
264     thdr.version.epoch = htonl(aversion->epoch);
265     thdr.version.counter = htonl(aversion->counter);
266     thdr.magic = htonl(UBIK_MAGIC);
267     thdr.size = htonl(HDRSIZE);
268     code = write(fd, &thdr, sizeof(thdr));
269     fsync(fd);      /* preserve over crash */
270     uphys_close(fd);
271     if (code != sizeof(thdr)) {
272         return EIO;
273     }
274     return 0;
275 }
276
277 uphys_sync(adbase, afile)
278     register struct ubik_dbase *adbase;
279     afs_int32 afile; {
280     register afs_int32 code, fd;
281     fd = uphys_open(adbase, afile);
282     code = fsync(fd);
283     uphys_close(fd);
284     return code;
285 }