Add zebrasrv.pid
[idzebra-moved-to-github.git] / bfile / mfile.c
1 /* $Id: mfile.c,v 1.52 2003-04-05 12:32:34 adam Exp $
2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
3    Index Data Aps
4
5 This file is part of the Zebra server.
6
7 Zebra is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21 */
22
23
24
25
26  /*
27   * TODO: The size estimates in init may not be accurate due to
28   * only partially written final blocks.
29   */
30
31 #include <sys/types.h>
32 #include <fcntl.h>
33 #ifdef WIN32
34 #include <io.h>
35 #else
36 #include <unistd.h>
37 #endif
38 #include <direntz.h>
39 #include <string.h>
40 #include <stdlib.h>
41 #include <stdio.h>
42 #include <assert.h>
43 #include <errno.h>
44
45 #include <zebra-lock.h>
46 #include <zebrautl.h>
47 #include <mfile.h>
48
49 static int scan_areadef(MFile_area ma, const char *ad, const char *base)
50 {
51     /*
52      * If no definition is given, use current directory, unlimited.
53      */
54     char dirname[FILENAME_MAX+1]; 
55     mf_dir **dp = &ma->dirs, *dir = *dp;
56
57     if (!ad)
58         ad = ".:-1b";
59     for (;;)
60     {
61         const char *ad0 = ad;
62         int i = 0, fact = 1, multi;
63         mfile_off_t size = 0;
64
65         while (*ad == ' ' || *ad == '\t')
66             ad++;
67         if (!*ad)
68             break;
69         if (!yaz_is_abspath(ad) && base)
70         {
71             strcpy (dirname, base);
72             i = strlen(dirname);
73             dirname[i++] = '/';
74         }
75         while (*ad)
76         {
77             if (*ad == ':' && strchr ("+-0123456789", ad[1]))
78                 break;
79             if (i < FILENAME_MAX)
80                 dirname[i++] = *ad;
81             ad++;
82         }
83         dirname[i] = '\0';
84         if (*ad++ != ':')
85         {
86             logf (LOG_WARN, "Missing colon after path: %s", ad0);
87             return -1;
88         }
89         if (i == 0)
90         {
91             logf (LOG_WARN, "Empty path: %s", ad0);
92             return -1;
93         }
94         while (*ad == ' ' || *ad == '\t')
95             ad++;
96         if (*ad == '-')
97         {
98             fact = -1;
99             ad++;
100         }
101         else if (*ad == '+')
102             ad++;
103         size = 0;
104         if (*ad < '0' || *ad > '9')
105         {
106             logf (LOG_FATAL, "Missing size after path: %s", ad0);
107             return -1;
108         }
109         size = 0;
110         while (*ad >= '0' && *ad <= '9')
111             size = size*10 + (*ad++ - '0');
112         switch (*ad)
113         {
114         case 'B': case 'b': multi = 1; break;
115         case 'K': case 'k': multi = 1024; break;
116         case 'M': case 'm': multi = 1048576; break;
117         case 'G': case 'g': multi = 1073741824; break;
118         case '\0':
119             logf (LOG_FATAL, "Missing unit: %s", ad0);
120             return -1;
121         default:
122             logf (LOG_FATAL, "Illegal unit: %c in %s", *ad, ad0);
123             return -1;
124         }
125         ad++;
126         *dp = dir = (mf_dir *) xmalloc(sizeof(mf_dir));
127         dir->next = 0;
128         strcpy(dir->name, dirname);
129         dir->max_bytes = dir->avail_bytes = fact * size * multi;
130         dp = &dir->next;
131     }
132     return 0;
133 }
134
135 static int file_position(MFile mf, int pos, int offset)
136 {
137     int off = 0, c = mf->cur_file, ps;
138
139     if ((c > 0 && pos <= mf->files[c-1].top) ||
140         (c < mf->no_files -1 && pos > mf->files[c].top))
141     {
142         c = 0;
143         while (c + 1 < mf->no_files && mf->files[c].top < pos)
144         {
145             off += mf->files[c].blocks;
146             c++;
147         }
148         assert(c < mf->no_files);
149     }
150     else
151         off = c ? (mf->files[c-1].top + 1) : 0;
152     if (mf->files[c].fd < 0)
153     {
154         if ((mf->files[c].fd = open(mf->files[c].path,
155                                     mf->wr ?
156                                         (O_BINARY|O_RDWR|O_CREAT) :
157                                         (O_BINARY|O_RDONLY), 0666)) < 0)
158         {
159             if (!mf->wr && errno == ENOENT && off == 0)
160                 return -2;
161             logf (LOG_WARN|LOG_ERRNO, "Failed to open %s", mf->files[c].path);
162              return -1;
163         }
164     }
165     ps = pos - off;
166     if (mfile_seek(mf->files[c].fd, ps * (mfile_off_t) mf->blocksize + offset,
167         SEEK_SET) < 0)
168     {
169         logf (LOG_WARN|LOG_ERRNO, "Failed to seek in %s", mf->files[c].path);
170         logf(LOG_WARN, "pos=%d off=%d blocksize=%d offset=%d",
171                        pos, off, mf->blocksize, offset);
172         return -1;
173     }
174     mf->cur_file = c;
175     return ps;
176 }
177
178 static int cmp_part_file(const void *p1, const void *p2)
179 {
180     return ((part_file *)p1)->number - ((part_file *)p2)->number;
181 }
182
183 /*
184  * Create a new area, cotaining metafiles in directories.
185  * Find the part-files in each directory, and inventory the existing metafiles.
186  */
187 MFile_area mf_init(const char *name, const char *spec, const char *base)
188 {
189     MFile_area ma = (MFile_area) xmalloc(sizeof(*ma));
190     mf_dir *dirp;
191     meta_file *meta_f;
192     part_file *part_f = 0;
193     DIR *dd;
194     struct dirent *dent;
195     int fd, number;
196     char metaname[FILENAME_MAX+1], tmpnam[FILENAME_MAX+1];
197     
198     logf (LOG_DEBUG, "mf_init(%s)", name);
199     strcpy(ma->name, name);
200     ma->mfiles = 0;
201     ma->dirs = 0;
202     if (scan_areadef(ma, spec, base) < 0)
203     {
204         logf (LOG_WARN, "Failed to access description of '%s'", name);
205         return 0;
206     }
207     /* look at each directory */
208     for (dirp = ma->dirs; dirp; dirp = dirp->next)
209     {
210         if (!(dd = opendir(dirp->name)))
211         {
212             logf (LOG_WARN|LOG_ERRNO, "Failed to open directory %s",
213                                      dirp->name);
214             return 0;
215         }
216         /* look at each file */
217         while ((dent = readdir(dd)))
218         {
219             int len = strlen(dent->d_name);
220             const char *cp = strrchr (dent->d_name, '-');
221             if (strchr (".-", *dent->d_name))
222                 continue;
223             if (len < 5 || !cp || strcmp (dent->d_name + len - 3, ".mf"))
224                 continue;
225             number = atoi(cp+1);
226             memcpy (metaname, dent->d_name, cp - dent->d_name);
227             metaname[ cp - dent->d_name] = '\0';
228
229             for (meta_f = ma->mfiles; meta_f; meta_f = meta_f->next)
230             {
231                 /* known metafile */
232                 if (!strcmp(meta_f->name, metaname))
233                 {
234                     part_f = &meta_f->files[meta_f->no_files++];
235                     break;
236                 }
237             }
238             /* new metafile */
239             if (!meta_f)
240             {
241                 meta_f = (meta_file *) xmalloc(sizeof(*meta_f));
242                 zebra_mutex_init (&meta_f->mutex);
243                 meta_f->ma = ma;
244                 meta_f->next = ma->mfiles;
245                 meta_f->open = 0;
246                 meta_f->cur_file = -1;
247                 meta_f->unlink_flag = 0;
248                 ma->mfiles = meta_f;
249                 strcpy(meta_f->name, metaname);
250                 part_f = &meta_f->files[0];
251                 meta_f->no_files = 1;
252             }
253             part_f->number = number;
254             part_f->dir = dirp;
255             part_f->fd = -1;
256             sprintf(tmpnam, "%s/%s", dirp->name, dent->d_name);
257             part_f->path = xstrdup(tmpnam);
258             /* get size */
259             if ((fd = open(part_f->path, O_BINARY|O_RDONLY)) < 0)
260             {
261                 logf (LOG_FATAL|LOG_ERRNO, "Failed to access %s",
262                       dent->d_name);
263                 return 0;
264             }
265             if ((part_f->bytes = mfile_seek(fd, 0, SEEK_END)) < 0)
266             {
267                 logf (LOG_FATAL|LOG_ERRNO, "Failed to seek in %s",
268                       dent->d_name);
269                 return 0;
270             }
271 #ifndef WIN32
272             fsync(fd);
273 #endif
274             close(fd);
275             if (dirp->max_bytes >= 0)
276                 dirp->avail_bytes -= part_f->bytes;
277         }
278         closedir(dd);
279     }
280     for (meta_f = ma->mfiles; meta_f; meta_f = meta_f->next)
281     {
282         logf (LOG_DEBUG, "mf_init: %s consists of %d part(s)", meta_f->name,
283               meta_f->no_files);
284         qsort(meta_f->files, meta_f->no_files, sizeof(part_file),
285               cmp_part_file);
286     }
287     return ma;
288 }
289
290 void mf_destroy(MFile_area ma)
291 {
292     mf_dir *dp;
293     meta_file *meta_f;
294
295     if (!ma)
296         return;
297     dp = ma->dirs;
298     while (dp)
299     {
300         mf_dir *d = dp;
301         dp = dp->next;
302         xfree (d);
303     }
304     meta_f = ma->mfiles;
305     while (meta_f)
306     {
307         int i;
308         meta_file *m = meta_f;
309         
310         for (i = 0; i<m->no_files; i++)
311         {
312             xfree (m->files[i].path);
313         }
314         zebra_mutex_destroy (&meta_f->mutex);
315         meta_f = meta_f->next;
316         xfree (m);
317     }
318     xfree (ma);
319 }
320
321 void mf_reset(MFile_area ma)
322 {
323     meta_file *meta_f;
324
325     if (!ma)
326         return;
327     meta_f = ma->mfiles;
328     while (meta_f)
329     {
330         int i;
331         meta_file *m = meta_f;
332
333         assert (!m->open);
334         for (i = 0; i<m->no_files; i++)
335         {
336             unlink (m->files[i].path);
337             xfree (m->files[i].path);
338         }
339         meta_f = meta_f->next;
340         xfree (m);
341     }
342     ma->mfiles = 0;
343 }
344
345 /*
346  * Open a metafile.
347  * If !ma, Use MF_DEFAULT_AREA.
348  */
349 MFile mf_open(MFile_area ma, const char *name, int block_size, int wflag)
350 {
351     meta_file *mnew;
352     int i;
353     char tmp[FILENAME_MAX+1];
354     mf_dir *dp;
355
356     logf(LOG_DEBUG, "mf_open(%s bs=%d, %s)", name, block_size,
357          wflag ? "RW" : "RDONLY");
358     assert (ma);
359     for (mnew = ma->mfiles; mnew; mnew = mnew->next)
360         if (!strcmp(name, mnew->name))
361         {
362             if (mnew->open)
363                 abort();
364             else
365                 break;
366         }
367     if (!mnew)
368     {
369         mnew = (meta_file *) xmalloc(sizeof(*mnew));
370         strcpy(mnew->name, name);
371         /* allocate one, empty file */
372         zebra_mutex_init (&mnew->mutex);
373         mnew->no_files = 1;
374         mnew->files[0].bytes = 0;
375         mnew->files[0].blocks = 0;
376         mnew->files[0].top = -1;
377         mnew->files[0].number = 0;
378         mnew->files[0].fd = -1;
379         mnew->unlink_flag = 0;
380         mnew->min_bytes_creat = MF_MIN_BLOCKS_CREAT * block_size;
381         for (dp = ma->dirs; dp && dp->max_bytes >= 0 && dp->avail_bytes <
382             mnew->min_bytes_creat; dp = dp->next);
383         if (!dp)
384         {
385             logf (LOG_FATAL, "Insufficient space for new mfile.");
386             return 0;
387         }
388         mnew->files[0].dir = dp;
389         sprintf(tmp, "%s/%s-%d.mf", dp->name, mnew->name, 0);
390         mnew->files[0].path = xstrdup(tmp);
391         mnew->ma = ma;
392         mnew->next = ma->mfiles;
393         ma->mfiles = mnew;
394     }
395     else
396     {
397         for (i = 0; i < mnew->no_files; i++)
398         {
399             if (mnew->files[i].bytes % block_size)
400                 mnew->files[i].bytes += block_size - mnew->files[i].bytes %
401                     block_size;
402             mnew->files[i].blocks = (int) (mnew->files[i].bytes / block_size);
403         }
404         assert(!mnew->open);
405     }
406     mnew->blocksize = block_size;
407     mnew->min_bytes_creat = MF_MIN_BLOCKS_CREAT * block_size;
408     mnew->wr=wflag;
409     mnew->cur_file = 0;
410     mnew->open = 1;
411
412     for (i = 0; i < mnew->no_files; i++)
413     {
414         mnew->files[i].blocks = (int)(mnew->files[i].bytes / mnew->blocksize);
415         if (i == mnew->no_files - 1)
416             mnew->files[i].top = -1;
417         else
418             mnew->files[i].top =
419                 i ? (mnew->files[i-1].top + mnew->files[i].blocks)
420                 : (mnew->files[i].blocks - 1);
421     }
422     return mnew;
423 }
424
425 /*
426  * Close a metafile.
427  */
428 int mf_close(MFile mf)
429 {
430     int i;
431
432     logf (LOG_DEBUG, "mf_close(%s)", mf->name);
433     assert(mf->open);
434     for (i = 0; i < mf->no_files; i++)
435     {
436         if (mf->files[i].fd >= 0)
437         {
438 #ifndef WIN32
439             fsync(mf->files[i].fd);
440 #endif
441             close(mf->files[i].fd);
442             mf->files[i].fd = -1;
443         }
444         if (mf->unlink_flag)
445             unlink(mf->files[i].path);
446     }
447     mf->open = 0;
448     return 0;
449 }
450
451 /*
452  * Read one block from a metafile. Interface mirrors bfile.
453  */
454 int mf_read(MFile mf, int no, int offset, int nbytes, void *buf)
455 {
456     int rd, toread;
457
458     zebra_mutex_lock (&mf->mutex);
459     if ((rd = file_position(mf, no, offset)) < 0)
460     {
461         if (rd == -2)
462         {
463             zebra_mutex_unlock (&mf->mutex);
464             return 0;
465         }
466         else
467         {
468             yaz_log (LOG_FATAL, "mf_read %s internal error", mf->name);
469             exit(1);
470         }
471     }
472     toread = nbytes ? nbytes : mf->blocksize;
473     if ((rd = read(mf->files[mf->cur_file].fd, buf, toread)) < 0)
474     {
475         logf (LOG_FATAL|LOG_ERRNO, "mf_read: Read failed (%s)",
476               mf->files[mf->cur_file].path);
477         exit(1);
478     }
479     zebra_mutex_unlock (&mf->mutex);
480     if (rd < toread)
481         return 0;
482     else
483         return 1;
484 }
485
486 /*
487  * Write.
488  */
489 int mf_write(MFile mf, int no, int offset, int nbytes, const void *buf)
490 {
491     int ps, nblocks, towrite;
492     mf_dir *dp;
493     char tmp[FILENAME_MAX+1];
494     unsigned char dummych = '\xff';
495
496     zebra_mutex_lock (&mf->mutex);
497     if ((ps = file_position(mf, no, offset)) < 0)
498     {
499         yaz_log (LOG_FATAL, "mf_write %s internal error (1)", mf->name);
500         exit(1);
501     }
502     /* file needs to grow */
503     while (ps >= mf->files[mf->cur_file].blocks)
504     {
505         mfile_off_t needed = (ps - mf->files[mf->cur_file].blocks + 1) *
506                        mf->blocksize;
507         /* file overflow - allocate new file */
508         if (mf->files[mf->cur_file].dir->max_bytes >= 0 &&
509             needed > mf->files[mf->cur_file].dir->avail_bytes)
510         {
511             /* cap off file? */
512             if ((nblocks = (int) (mf->files[mf->cur_file].dir->avail_bytes /
513                 mf->blocksize)) > 0)
514             {
515                 logf (LOG_DEBUG, "Capping off file %s at pos %d",
516                     mf->files[mf->cur_file].path, nblocks);
517                 if ((ps = file_position(mf,
518                     (mf->cur_file ? mf->files[mf->cur_file-1].top : 0) +
519                     mf->files[mf->cur_file].blocks + nblocks - 1, 0)) < 0)
520                 {
521                     yaz_log (LOG_FATAL, "mf_write %s internal error (2)",
522                                  mf->name);
523                     exit(1);
524                 }
525                 logf (LOG_DEBUG, "ps = %d", ps);
526                 if (write(mf->files[mf->cur_file].fd, &dummych, 1) < 1)
527                 {
528                     logf (LOG_ERRNO|LOG_FATAL, "mf_write %s internal error (3)",
529                                       mf->name);
530                     exit(1);
531                 }
532                 mf->files[mf->cur_file].blocks += nblocks;
533                 mf->files[mf->cur_file].bytes += nblocks * mf->blocksize;
534                 mf->files[mf->cur_file].dir->avail_bytes -= nblocks *
535                     mf->blocksize;
536             }
537             /* get other bit */
538             logf (LOG_DEBUG, "Creating new file.");
539             for (dp = mf->ma->dirs; dp && dp->max_bytes >= 0 &&
540                 dp->avail_bytes < needed; dp = dp->next);
541             if (!dp)
542             {
543                 logf (LOG_FATAL, "Cannot allocate more space for %s",
544                       mf->name);
545                 exit(1);
546             }
547             mf->files[mf->cur_file].top = (mf->cur_file ?
548                 mf->files[mf->cur_file-1].top : -1) +
549                 mf->files[mf->cur_file].blocks;
550             mf->files[++(mf->cur_file)].top = -1;
551             mf->files[mf->cur_file].dir = dp;
552             mf->files[mf->cur_file].number =
553                 mf->files[mf->cur_file-1].number + 1;
554             mf->files[mf->cur_file].blocks = 0;
555             mf->files[mf->cur_file].bytes = 0;
556             mf->files[mf->cur_file].fd = -1;
557             sprintf(tmp, "%s/%s-%d.mf", dp->name, mf->name,
558                 mf->files[mf->cur_file].number);
559             mf->files[mf->cur_file].path = xstrdup(tmp);
560             mf->no_files++;
561             /* open new file and position at beginning */
562             if ((ps = file_position(mf, no, offset)) < 0)
563             {
564                 yaz_log (LOG_FATAL, "mf_write %s internal error (4)",
565                                  mf->name);
566                 exit(1);
567             }   
568         }
569         else
570         {
571             nblocks = ps - mf->files[mf->cur_file].blocks + 1;
572             mf->files[mf->cur_file].blocks += nblocks;
573             mf->files[mf->cur_file].bytes += nblocks * mf->blocksize;
574             if (mf->files[mf->cur_file].dir->max_bytes >= 0)
575                 mf->files[mf->cur_file].dir->avail_bytes -=
576                 nblocks * mf->blocksize;
577         }
578     }
579     towrite = nbytes ? nbytes : mf->blocksize;
580     if (write(mf->files[mf->cur_file].fd, buf, towrite) < towrite)
581     {
582         logf (LOG_FATAL|LOG_ERRNO, "Write failed for file %s part %d",
583                 mf->name, mf->cur_file);
584         exit(1);
585     }
586     zebra_mutex_unlock (&mf->mutex);
587     return 0;
588 }
589
590 /*
591  * Destroy a metafile, unlinking component files. File must be open.
592  */
593 int mf_unlink(MFile mf)
594 {
595     if (mf->open)
596         mf->unlink_flag = 1;
597     else
598     {
599         int i;
600         for (i = 0; i<mf->no_files; i++)
601             unlink(mf->files[i].path);
602     }
603     return 0;
604 }
605
606 /*
607  * Unlink the file by name, rather than MFile-handle. File should be closed.
608  */
609 int mf_unlink_name(MFile_area ma, const char *name)
610 {
611     abort();
612     return 0;
613 }