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