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