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