bfile/mfile.c

   1 /*
   2  * Copyright (C) 1994, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: mfile.c,v $
   7  * Revision 1.6  1994-09-14 13:10:15  quinn
   8  * Corrected some bugs in the init-phase
   9  *
  10  * Revision 1.5  1994/09/12  08:01:51  quinn
  11  * Small
  12  *
  13  * Revision 1.4  1994/09/01  14:51:07  quinn
  14  * Allowed mf_write to write beyond eof+1.
  15  *
  16  * Revision 1.3  1994/08/24  09:37:17  quinn
  17  * Changed reaction to read return values.
  18  *
  19  * Revision 1.2  1994/08/23  14:50:48  quinn
  20  * Fixed mf_close().
  21  *
  22  * Revision 1.1  1994/08/23  14:41:33  quinn
  23  * First functional version.
  24  *
  25  */
  26
  27
  28  /*
  29   * TODO: The size estimates in init may not be accurate due to
  30   * only partially written final blocks.
  31   */
  32
  33 #include <sys/types.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <dirent.h>
  37 #include <stdlib.h>
  38 #include <assert.h>
  39
  40 #include <util.h>
  41 #include <mfile.h>
  42
  43 static MFile_area_struct *open_areas = 0;
  44 static MFile_area_struct *default_area = 0;
  45
  46 static int scan_areadef(MFile_area ma, const char *name)
  47 {
  48     const char *ad = res_get(common_resource, name);
  49     int offset = 0, rs, size, multi, rd;
  50     char dirname[FILENAME_MAX+1], unit;
  51     mf_dir **dp = &ma->dirs, *dir = *dp;
  52
  53     if (!ad)
  54     {
  55         log(LOG_FATAL, "Could not find resource '%s'", name);
  56         return -1;
  57     }
  58     for (;;)
  59     {
  60         rs = sscanf(ad + offset, "%[^:]:%d%c %n", dirname, &size, &unit, &rd);
  61         if (rs <= 1)
  62             break;
  63         if (rs != 3)
  64         {
  65             log(LOG_FATAL, "Illegal directory description: %s", ad + offset);
  66             return -1;
  67         }
  68         switch (unit)
  69         {
  70             case 'B': case 'b': multi = 1; break;
  71             case 'K': case 'k': multi = 1024; break;
  72             case 'M': case 'm': multi = 1048576; break;
  73             default:
  74                 log(LOG_FATAL, "Illegal unit: %c in %s", unit, ad + offset);
  75                 return -1;
  76         }
  77         *dp = dir = xmalloc(sizeof(mf_dir));
  78         dir->next = 0;
  79         strcpy(dir->name, dirname);
  80         dir->max_bytes = dir->avail_bytes = size * multi;
  81         dp = &dir->next;
  82         offset += rd;
  83     }
  84     return 0;
  85 }
  86
  87 static int file_position(MFile mf, int pos, int offset)
  88 {
  89     int off = 0, c = mf->cur_file, ps;
  90
  91     if ((c > 0 && pos <= mf->files[c-1].top) ||
  92         (c < mf->no_files -1 && pos > mf->files[c].top))
  93     {
  94         c = 0;
  95         while (mf->files[c].top >= 0 && mf->files[c].top < pos)
  96         {
  97             off += mf->files[c].blocks;
  98             c++;
  99         }
 100         assert(c < mf->no_files);
 101     }
 102     else
 103         off = c ? (mf->files[c-1].top + 1) : 0;
 104     if (mf->files[c].fd < 0 && (mf->files[c].fd = open(mf->files[c].path,
 105         mf->wr ? O_RDWR|O_CREAT : O_RDONLY, 0666)) < 0)
 106     {
 107         log(LOG_FATAL|LOG_ERRNO, "Failed to open %s", mf->files[c].path);
 108         return -1;
 109     }
 110     if (lseek(mf->files[c].fd, (ps = pos - off) * mf->blocksize + offset,
 111         SEEK_SET) < 0)
 112     {
 113         log(LOG_FATAL|LOG_ERRNO, "Failed to seek in %s", mf->files[c].path);
 114         return -1;
 115     }
 116     mf->cur_file = c;
 117     return ps;
 118 }
 119
 120 static int cmp_part_file(const void *p1, const void *p2)
 121 {
 122     return ((part_file *)p1)->number - ((part_file *)p2)->number;
 123 }
 124
 125 /*
 126  * Create a new area, cotaining metafiles in directories.
 127  * Find the part-files in each directory, and inventory the existing metafiles.
 128  */
 129 MFile_area mf_init(const char *name)
 130 {
 131     MFile_area ma = xmalloc(sizeof(MFile_area_struct)), mp;
 132     mf_dir *dirp;
 133     meta_file *meta_f;
 134     part_file *part_f;
 135     DIR *dd;
 136     struct dirent *dent;
 137     int fd, number;
 138     char metaname[FILENAME_MAX+1], tmpnam[FILENAME_MAX+1];
 139
 140     log(LOG_DEBUG, "mf_init(%s)", name);
 141     for (mp = open_areas; mp; mp = mp->next)
 142         if (!strcmp(name, mp->name))
 143             abort();
 144     strcpy(ma->name, name);
 145     ma->next = open_areas;
 146     open_areas = ma;
 147     ma->mfiles = 0;
 148     ma->dirs = 0;
 149     if (scan_areadef(ma, name) < 0)
 150     {
 151         log(LOG_FATAL, "Failed to access description of '%s'", name);
 152         return 0;
 153     }
 154     /* look at each directory */
 155     for (dirp = ma->dirs; dirp; dirp = dirp->next)
 156     {
 157         if (!(dd = opendir(dirp->name)))
 158         {
 159             log(LOG_FATAL|LOG_ERRNO, "Failed to open %s", dirp->name);
 160             return 0;
 161         }
 162         /* look at each file */
 163         while ((dent = readdir(dd)))
 164         {
 165             if (*dent->d_name == '.')
 166                 continue;
 167             if (sscanf(dent->d_name, "%[^.].%d", metaname, &number) != 2)
 168             {
 169                 log(LOG_FATAL, "Failed to resolve part-name %s", dent->d_name);
 170                 return 0;
 171             }
 172             for (meta_f = ma->mfiles; meta_f; meta_f = meta_f->next)
 173             {
 174                 /* known metafile */
 175                 if (!strcmp(meta_f->name, metaname))
 176                 {
 177                     part_f = &meta_f->files[meta_f->no_files++];
 178                     break;
 179                 }
 180             }
 181             /* new metafile */
 182             if (!meta_f)
 183             {
 184                 meta_f = xmalloc(sizeof(*meta_f));
 185                 meta_f->ma = ma;
 186                 meta_f->next = ma->mfiles;
 187                 meta_f->open = 0;
 188                 meta_f->cur_file = -1;
 189                 ma->mfiles = meta_f;
 190                 strcpy(meta_f->name, metaname);
 191                 part_f = &meta_f->files[0];
 192                 meta_f->no_files = 1;
 193             }
 194             part_f->number = number;
 195             part_f->dir = dirp;
 196             part_f->fd = -1;
 197             sprintf(tmpnam, "%s/%s", dirp->name, dent->d_name);
 198             part_f->path = xstrdup(tmpnam);
 199             /* get size */
 200             if ((fd = open(part_f->path, O_RDONLY)) < 0)
 201             {
 202                 log(LOG_FATAL|LOG_ERRNO, "Failed to access %s", dent->d_name);
 203                 return 0;
 204             }
 205             if ((part_f->bytes = lseek(fd, 0, SEEK_END)) < 0)
 206             {
 207                 log(LOG_FATAL|LOG_ERRNO, "Failed to seek in %s", dent->d_name);
 208                 return 0;
 209             }
 210             close(fd);
 211             dirp->avail_bytes -= part_f->bytes;
 212         }
 213         closedir(dd);
 214     }
 215     for (meta_f = ma->mfiles; meta_f; meta_f = meta_f->next)
 216     {
 217         log(LOG_DEBUG, "mf_init: %s consists of %d part(s)", meta_f->name,
 218             meta_f->no_files);
 219         qsort(meta_f->files, meta_f->no_files, sizeof(part_file),
 220             cmp_part_file);
 221     }
 222     return ma;
 223 }
 224
 225 /*
 226  * Open a metafile.
 227  * If !ma, Use MF_DEFAULT_AREA.
 228  */
 229 MFile mf_open(MFile_area ma, const char *name, int block_size, int wflag)
 230 {
 231     struct meta_file *new;
 232     int i;
 233     char tmp[FILENAME_MAX+1];
 234     mf_dir *dp;
 235
 236     log(LOG_LOG, "mf_open(%s bs=%d, %s)", name, block_size,
 237         wflag ? "RW" : "RDONLY");
 238     if (!ma)
 239     {
 240         if (!default_area && !(default_area = mf_init(MF_DEFAULT_AREA)))
 241         {
 242             log(LOG_FATAL, "Failed to open default area.");
 243             return 0;
 244         }
 245         ma = default_area;
 246     }
 247     for (new = ma->mfiles; new; new = new->next)
 248         if (!strcmp(name, new->name))
 249             if (new->open)
 250                 abort();
 251             else
 252                 break;
 253     if (!new)
 254     {
 255         new = xmalloc(sizeof(*new));
 256         strcpy(new->name, name);
 257         /* allocate one, empty file */
 258         new->no_files = 1;
 259         new->files[0].bytes = new->files[0].blocks = 0;
 260         new->files[0].top = -1;
 261         new->files[0].number = 0;
 262         new->files[0].fd = -1;
 263         new->min_bytes_creat = MF_MIN_BLOCKS_CREAT * block_size;
 264         for (dp = ma->dirs; dp && dp->avail_bytes < new->min_bytes_creat;
 265             dp = dp->next);
 266         if (!dp)
 267         {
 268             log(LOG_FATAL, "Insufficient space for new mfile.");
 269             return 0;
 270         }
 271         new->files[0].dir = dp;
 272         sprintf(tmp, "%s/%s.%d", dp->name, new->name, 0);
 273         new->files[0].path = xstrdup(tmp);
 274         new->ma = ma;
 275     }
 276     else
 277     {
 278         for (i = 0; i < new->no_files; i++)
 279         {
 280             if (new->files[i].bytes % block_size)
 281                 new->files[i].bytes += block_size - new->files[i].bytes %
 282                     block_size;
 283             new->files[i].blocks = new->files[i].bytes / block_size;
 284         }
 285         assert(!new->open);
 286     }
 287     new->blocksize = block_size;
 288     new->min_bytes_creat = MF_MIN_BLOCKS_CREAT * block_size;
 289     new->wr=wflag;
 290     new->cur_file = 0;
 291     new->open = 1;
 292
 293     for (i = 0; i < new->no_files; i++)
 294     {
 295         new->files[i].blocks = new->files[i].bytes / new->blocksize;
 296         if (i == new->no_files)
 297             new->files[i].top = -1;
 298         else
 299             new->files[i].top = i ? (new->files[i-1].top + new->files[i].blocks)
 300                 : (new->files[i].blocks - 1);
 301     }
 302     return new;
 303 }
 304
 305 /*
 306  * Close a metafile.
 307  */
 308 int mf_close(MFile mf)
 309 {
 310     int i;
 311
 312     assert(mf->open);
 313     for (i = 0; i < mf->no_files; i++)
 314         if (mf->files[i].fd >= 0)
 315             close(mf->files[i].fd);
 316     mf->open = 0;
 317     return 0;
 318 }
 319
 320 /*
 321  * Read one block from a metafile. Interface mirrors bfile.
 322  */
 323 int mf_read(MFile mf, int no, int offset, int num, void *buf)
 324 {
 325     int rd, toread;
 326
 327     if (file_position(mf, no, offset) < 0)
 328         exit(1);
 329     toread = num ? num : mf->blocksize;
 330     if ((rd = read(mf->files[mf->cur_file].fd, buf, toread)) < 0)
 331     {
 332         log(LOG_FATAL|LOG_ERRNO, "mf_read: Read failed (%s)",
 333                 mf->files[mf->cur_file].path);
 334         exit(1);
 335     }
 336     else if (rd < toread)
 337         return 0;
 338     else
 339         return 1;
 340 }
 341
 342 /*
 343  * Write.
 344  */
 345 int mf_write(MFile mf, int no, int offset, int num, const void *buf)
 346 {
 347     int ps, nblocks, towrite;
 348     mf_dir *dp;
 349     char tmp[FILENAME_MAX+1];
 350     unsigned char dummych = '\xff';
 351
 352     if ((ps = file_position(mf, no, offset)) < 0)
 353         exit(1);
 354     /* file needs to grow */
 355     while (ps >= mf->files[mf->cur_file].blocks)
 356     {
 357         log(LOG_DEBUG, "File grows");
 358         /* file overflow - allocate new file */
 359         if ((ps - mf->files[mf->cur_file].blocks + 1) * mf->blocksize >
 360             mf->files[mf->cur_file].dir->avail_bytes)
 361         {
 362             /* cap off file? */
 363             if ((nblocks = mf->files[mf->cur_file].dir->avail_bytes /
 364                 mf->blocksize) > 0)
 365             {
 366                 log(LOG_DEBUG, "Capping off file %s at pos %d",
 367                     mf->files[mf->cur_file].path, nblocks);
 368                 if ((ps = file_position(mf,
 369                     (mf->cur_file ? mf->files[mf->cur_file-1].top : 0) +
 370                     mf->files[mf->cur_file].blocks + nblocks, 0)) < 0)
 371                         exit(1);
 372                 if (write(mf->files[mf->cur_file].fd, &dummych, 1) < 1)
 373                 {
 374                     log(LOG_ERRNO|LOG_FATAL, "write dummy");
 375                     exit(1);
 376                 }
 377                 mf->files[mf->cur_file].blocks += nblocks;
 378                 mf->files[mf->cur_file].bytes += nblocks * mf->blocksize;
 379                 mf->files[mf->cur_file].dir->avail_bytes -= nblocks *
 380                     mf->blocksize;
 381             }
 382             /* get other bit */
 383             log(LOG_DEBUG, "Creating new file.");
 384             for (dp = mf->ma->dirs; dp && dp->avail_bytes < mf->min_bytes_creat;
 385                 dp = dp->next);
 386             if (!dp)
 387             {
 388                 log(LOG_FATAL, "Cannot allocate more space for %s", mf->name);
 389                 exit(1);
 390             }
 391             mf->files[mf->cur_file].top = (mf->cur_file ?
 392                 mf->files[mf->cur_file-1].top : -1) +
 393                 mf->files[mf->cur_file].blocks;
 394             mf->files[++(mf->cur_file)].top = -1;
 395             mf->files[mf->cur_file].dir = dp;
 396             mf->files[mf->cur_file].number =
 397                 mf->files[mf->cur_file-1].number + 1;
 398             mf->files[mf->cur_file].blocks =
 399                 mf->files[mf->cur_file].bytes = 0;
 400             mf->files[mf->cur_file].fd = -1;
 401             sprintf(tmp, "%s/%s.%d", dp->name, mf->name,
 402                 mf->files[mf->cur_file].number);
 403             mf->files[mf->cur_file].path = xstrdup(tmp);
 404             mf->no_files++;
 405             /* open new file and position at beginning */
 406             if ((ps = file_position(mf, no, offset)) < 0)
 407                 exit(1);
 408         }
 409         else
 410         {
 411             nblocks = ps - mf->files[mf->cur_file].blocks + 1;
 412             mf->files[mf->cur_file].blocks += nblocks;
 413             mf->files[mf->cur_file].bytes += nblocks * mf->blocksize;
 414             mf->files[mf->cur_file].dir->avail_bytes -= nblocks * mf->blocksize;
 415         }
 416     }
 417     towrite = num ? num : mf->blocksize;
 418     if (write(mf->files[mf->cur_file].fd, buf, towrite) < towrite)
 419     {
 420         log(LOG_FATAL|LOG_ERRNO, "Write failed");
 421         exit(1);
 422     }
 423     return 0;
 424 }
 425
 426 /*
 427  * Destroy a metafile, unlinking component files. File must be open.
 428  */
 429 int mf_unlink(MFile mf)
 430 {
 431     abort();
 432     return 0;
 433 }
 434
 435 /*
 436  * Unlink the file by name, rather than MFile-handle. File should be closed.
 437  */
 438 int mf_unlink_name(MFile_area ma, const char *name)
 439 {
 440     abort();
 441     return 0;
 442 }