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