X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=blobdiff_plain;f=bfile%2Fbfile.c;h=5ee546084840a200536e4bdf711fb86c2ad9cf71;hp=a160f132f527d4b67c9125ba42f84a05f7aa6004;hb=HEAD;hpb=805db1945539e97bd09b17d91eefc8eeb1652213 diff --git a/bfile/bfile.c b/bfile/bfile.c index a160f13..5ee5460 100644 --- a/bfile/bfile.c +++ b/bfile/bfile.c @@ -1,166 +1,394 @@ -/* - * Copyright (C) 1994, Index Data I/S - * All rights reserved. - * Sebastian Hammer, Adam Dickmeiss - * - * $Log: bfile.c,v $ - * Revision 1.18 1996-01-02 08:59:06 quinn - * Changed "commit" setting to "shadow". - * - * Revision 1.17 1995/12/11 09:03:51 adam - * New function: cf_unlink. - * New member of commit file head: state (0) deleted, (1) hash file. - * - * Revision 1.16 1995/12/08 16:21:13 adam - * Work on commit/update. - * - * Revision 1.15 1995/12/01 16:24:28 adam - * Commit files use separate meta file area. - * - * Revision 1.14 1995/12/01 11:37:21 adam - * Cached/commit files implemented as meta-files. - * - * Revision 1.13 1995/11/30 17:00:49 adam - * Several bug fixes. Commit system runs now. - * - * Revision 1.12 1995/11/30 08:33:10 adam - * Started work on commit facility. - * - * Revision 1.11 1995/09/04 12:33:21 adam - * Various cleanup. YAZ util used instead. - * - * Revision 1.10 1994/08/25 10:15:54 quinn - * Trivial - * - * Revision 1.9 1994/08/24 08:45:48 quinn - * Using mfile. - * - * Revision 1.8 1994/08/23 15:03:34 quinn - * *** empty log message *** - * - * Revision 1.7 1994/08/23 14:25:45 quinn - * Added O_CREAT because some geek wanted it. Sheesh. - * - * Revision 1.6 1994/08/23 14:21:38 quinn - * Fixed call to log - * - * Revision 1.5 1994/08/18 08:10:08 quinn - * Minimal changes - * - * Revision 1.4 1994/08/17 14:27:32 quinn - * last mods - * - * Revision 1.2 1994/08/17 14:09:32 quinn - * Compiles cleanly (still only dummy). - * - * Revision 1.1 1994/08/17 13:55:08 quinn - * New blocksystem. dummy only - * - */ +/* This file is part of the Zebra server. + Copyright (C) Index Data + +Zebra is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +Zebra is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +#if HAVE_CONFIG_H +#include +#endif #include #include +#include #include +#ifdef WIN32 +#include +#endif + +#if HAVE_UNISTD_H #include +#endif -#include -#include +#include +#include +#include +#include "mfile.h" #include "cfile.h" -static MFile_area commit_area = NULL; +struct BFile_struct +{ + MFile mf; + Zebra_lock_rdwr rdwr_lock; + struct CFile_struct *cf; + char *alloc_buf; + int block_size; + int alloc_buf_size; + zint last_block; + zint free_list; + zint root_block; + char *magic; + int header_dirty; +}; + +struct BFiles_struct { + MFile_area commit_area; + MFile_area register_area; + char *base; + char *cache_fname; +}; -void bf_cache (int enableFlag) +BFiles bfs_create (const char *spec, const char *base) { - if (enableFlag) + BFiles bfs = (BFiles) xmalloc(sizeof(*bfs)); + bfs->commit_area = 0; + bfs->base = 0; + bfs->cache_fname = 0; + if (base) + bfs->base = xstrdup(base); + bfs->register_area = mf_init("register", spec, base, 0); + if (!bfs->register_area) { - if (!commit_area) - if (res_get (common_resource, "shadow")) - commit_area = mf_init ("shadow"); - else - { - logf (LOG_FATAL, "Shadow area must be defined if commit" - "is to be enabled"); - exit (1); - } + bfs_destroy(bfs); + return 0; + } + return bfs; +} + +void bfs_destroy(BFiles bfs) +{ + if (!bfs) + return; + xfree(bfs->cache_fname); + xfree(bfs->base); + mf_destroy(bfs->commit_area); + mf_destroy(bfs->register_area); + xfree(bfs); +} + +static FILE *open_cache(BFiles bfs, const char *flags) +{ + FILE *file; + + file = fopen(bfs->cache_fname, flags); + return file; +} + +static void unlink_cache(BFiles bfs) +{ + if (bfs->cache_fname) + unlink(bfs->cache_fname); +} + +ZEBRA_RES bf_cache(BFiles bfs, const char *spec) +{ + if (spec) + { + yaz_log(YLOG_LOG, "enabling shadow spec=%s", spec); + if (!bfs->commit_area) + bfs->commit_area = mf_init("shadow", spec, bfs->base, 1); + if (bfs->commit_area) + { + bfs->cache_fname = xmalloc(strlen(bfs->commit_area->dirs->name)+ + 8); + strcpy(bfs->cache_fname, bfs->commit_area->dirs->name); + strcat(bfs->cache_fname, "/cache"); + yaz_log(YLOG_LOG, "cache_fname = %s", bfs->cache_fname); + } + else + { + yaz_log(YLOG_WARN, "shadow could not be enabled"); + return ZEBRA_FAIL; + } } else - commit_area = NULL; + bfs->commit_area = 0; + return ZEBRA_OK; } -int bf_close (BFile bf) +int bf_close2(BFile bf) { + int ret = 0; + zebra_lock_rdwr_destroy(&bf->rdwr_lock); if (bf->cf) - cf_close (bf->cf); - mf_close (bf->mf); - xfree (bf); - return 0; + { + if (cf_close(bf->cf)) + ret = -1; + } + if (bf->mf) + { + if (mf_close(bf->mf)) + ret = -1; + } + xfree(bf->alloc_buf); + xfree(bf->magic); + xfree(bf); + return ret; +} + +void bf_close(BFile bf) +{ + if (bf_close2(bf)) + { + zebra_exit("bf_close"); + } +} + + +#define HEADER_SIZE 256 + +BFile bf_xopen(BFiles bfs, const char *name, int block_size, int wrflag, + const char *magic, int *read_version, + const char **more_info) +{ + char read_magic[40]; + int l = 0; + int i = 0; + char *hbuf; + zint pos = 0; + BFile bf = bf_open(bfs, name, block_size, wrflag); + + if (!bf) + return 0; + /* HEADER_SIZE is considered enough for our header */ + if (bf->block_size < HEADER_SIZE) + bf->alloc_buf_size = HEADER_SIZE; + else + bf->alloc_buf_size = bf->block_size; + + hbuf = bf->alloc_buf = xmalloc(bf->alloc_buf_size); + + /* fill-in default values */ + bf->free_list = 0; + bf->root_block = bf->last_block = HEADER_SIZE / bf->block_size + 1; + bf->magic = xstrdup(magic); + + if (!bf_read(bf, pos, 0, 0, hbuf + pos * bf->block_size)) + { + if (wrflag) + bf->header_dirty = 1; + return bf; + } + while(hbuf[pos * bf->block_size + i] != '\0') + { + if (i == bf->block_size) + { /* end of block at pos reached .. */ + if (bf->alloc_buf_size < (pos+1) * bf->block_size) + { + /* not room for all in alloc_buf_size */ + yaz_log(YLOG_WARN, "bad header for %s (3)", magic); + bf_close(bf); + return 0; + } + /* read next block in header */ + pos++; + if (!bf_read(bf, pos, 0, 0, hbuf + pos * bf->block_size)) + { + yaz_log(YLOG_WARN, "missing header block %s (4)", magic); + bf_close(bf); + return 0; + } + i = 0; /* pos within block is reset */ + } + else + i++; + } + if (sscanf(hbuf, "%39s %d " ZINT_FORMAT " " ZINT_FORMAT "%n", + read_magic, read_version, &bf->last_block, + &bf->free_list, &l) < 4 && l) /* if %n is counted, it's 5 */ + { + yaz_log(YLOG_WARN, "bad header for %s (1)", magic); + bf_close(bf); + return 0; + } + if (strcmp(read_magic, magic)) + { + yaz_log(YLOG_WARN, "bad header for %s (2)", magic); + bf_close(bf); + return 0; + } + if (hbuf[l] == ' ') + l++; + if (more_info) + *more_info = hbuf + l; + return bf; +} + +int bf_xclose(BFile bf, int version, const char *more_info) +{ + if (bf->header_dirty) + { + zint pos = 0; + assert(bf->alloc_buf); + assert(bf->magic); + sprintf(bf->alloc_buf, "%s %d " ZINT_FORMAT " " ZINT_FORMAT " ", + bf->magic, version, bf->last_block, bf->free_list); + if (more_info) + strcat(bf->alloc_buf, more_info); + while (1) + { + bf_write(bf, pos, 0, 0, bf->alloc_buf + pos * bf->block_size); + pos++; + if (pos * bf->block_size > strlen(bf->alloc_buf)) + break; + } + } + return bf_close2(bf); } -BFile bf_open (const char *name, int block_size, int wflag) +BFile bf_open(BFiles bfs, const char *name, int block_size, int wflag) { - BFile tmp = xmalloc(sizeof(BFile_struct)); + BFile bf = (BFile) xmalloc(sizeof(*bf)); - if (commit_area) + bf->alloc_buf = 0; + bf->magic = 0; + bf->block_size = block_size; + bf->header_dirty = 0; + bf->cf = 0; + bf->mf = 0; + zebra_lock_rdwr_init(&bf->rdwr_lock); + + if (bfs->commit_area) { - FILE *outf; int first_time; - logf (LOG_LOG, "cf,mf_open %s", name); - - tmp->mf = mf_open (0, name, block_size, 0); - tmp->cf = cf_open (tmp->mf, commit_area, name, block_size, - wflag, &first_time); + bf->mf = mf_open(bfs->register_area, name, block_size, 0); + bf->cf = cf_open(bf->mf, bfs->commit_area, name, block_size, + wflag, &first_time); + if (!bf->cf) + { + yaz_log(YLOG_FATAL, "cf_open failed for %s", name); + bf_close(bf); + return 0; + } if (first_time) { - outf = fopen ("cache", "a"); - fprintf (outf, "%s %d\n", name, block_size); - fclose (outf); + FILE *outf; + + outf = open_cache(bfs, "ab"); + if (!outf) + { + yaz_log(YLOG_FATAL|YLOG_ERRNO, "open %s", bfs->cache_fname); + bf_close(bf); + return 0; + } + fprintf(outf, "%s %d\n", name, block_size); + if (fclose(outf)) + { + yaz_log(YLOG_FATAL|YLOG_ERRNO, "fclose %s", bfs->cache_fname); + bf_close(bf); + return 0; + } } } else { - tmp->mf = mf_open(0, name, block_size, wflag); - tmp->cf = NULL; + bf->mf = mf_open(bfs->register_area, name, block_size, wflag); } - if (!tmp->mf) + if (!bf->mf) { - logf (LOG_FATAL, "mf_open failed for %s", name); - xfree (tmp); + yaz_log(YLOG_FATAL, "mf_open failed for %s", name); + bf_close(bf); return 0; } - return(tmp); + return bf; } -int bf_read (BFile bf, int no, int offset, int num, void *buf) +int bf_read(BFile bf, zint no, int offset, int nbytes, void *buf) { - int r; + int ret = bf_read2(bf, no, offset, nbytes, buf); + + if (ret == -1) + { + zebra_exit("bf_read"); + } + return ret; +} + +int bf_read2(BFile bf, zint no, int offset, int nbytes, void *buf) +{ + int ret; + + zebra_lock_rdwr_rlock(&bf->rdwr_lock); + if (bf->cf) + { + if ((ret = cf_read(bf->cf, no, offset, nbytes, buf)) == 0) + ret = mf_read(bf->mf, no, offset, nbytes, buf); + } + else + ret = mf_read(bf->mf, no, offset, nbytes, buf); + zebra_lock_rdwr_runlock(&bf->rdwr_lock); + return ret; +} + +int bf_write(BFile bf, zint no, int offset, int nbytes, const void *buf) +{ + int ret = bf_write2(bf, no, offset, nbytes, buf); - if (bf->cf && (r=cf_read (bf->cf, no, offset, num, buf)) != -1) - return r; - return mf_read (bf->mf, no, offset, num, buf); + if (ret == -1) + { + zebra_exit("bf_write"); + } + return ret; } -int bf_write (BFile bf, int no, int offset, int num, const void *buf) +int bf_write2(BFile bf, zint no, int offset, int nbytes, const void *buf) { + int r; + zebra_lock_rdwr_wlock(&bf->rdwr_lock); if (bf->cf) - return cf_write (bf->cf, no, offset, num, buf); - return mf_write (bf->mf, no, offset, num, buf); + r = cf_write(bf->cf, no, offset, nbytes, buf); + else + r = mf_write(bf->mf, no, offset, nbytes, buf); + zebra_lock_rdwr_wunlock(&bf->rdwr_lock); + return r; } -int bf_commitExists (void) +int bf_commitExists(BFiles bfs) { FILE *inf; - inf = fopen ("cache", "r"); + inf = open_cache(bfs, "rb"); if (inf) { - fclose (inf); + fclose(inf); return 1; } return 0; } -void bf_commitExec (void) +void bf_reset(BFiles bfs) +{ + if (!bfs) + return; + mf_reset(bfs->commit_area, 1); + mf_reset(bfs->register_area, 1); + unlink_cache(bfs); +} + +int bf_commitExec(BFiles bfs) { FILE *inf; int block_size; @@ -168,54 +396,126 @@ void bf_commitExec (void) MFile mf; CFile cf; int first_time; + int r = 0; - assert (commit_area); - if (!(inf = fopen ("cache", "r"))) + assert(bfs->commit_area); + if (!(inf = open_cache(bfs, "rb"))) { - logf (LOG_LOG, "No commit file"); - return ; + yaz_log(YLOG_LOG, "No commit file"); + return -1; } - while (fscanf (inf, "%s %d", path, &block_size) == 2) + while (fscanf(inf, "%s %d", path, &block_size) == 2) { - mf = mf_open (0, path, block_size, 1); - cf = cf_open (mf, commit_area, path, block_size, 0, &first_time); + mf = mf_open(bfs->register_area, path, block_size, 1); + if (!mf) + { + r = -1; + break; + } + cf = cf_open(mf, bfs->commit_area, path, block_size, 0, &first_time); + if (!cf) + { + mf_close(mf); + r = -1; + break; + } - cf_commit (cf); + r = cf_commit(cf); - cf_close (cf); - mf_close (mf); + cf_close(cf); + mf_close(mf); + + if (r) + break; } - fclose (inf); + fclose(inf); + return r; } -void bf_commitClean (void) +void bf_commitClean(BFiles bfs, const char *spec) { - FILE *inf; - int block_size; - char path[256]; - MFile mf; - CFile cf; int mustDisable = 0; - int firstTime; - if (!commit_area) + if (!bfs->commit_area) { - bf_cache (1); + bf_cache(bfs, spec); mustDisable = 1; } - if (!(inf = fopen ("cache", "r"))) - return ; - while (fscanf (inf, "%s %d", path, &block_size) == 2) + mf_reset(bfs->commit_area, 1); + + unlink_cache(bfs); + if (mustDisable) + bf_cache(bfs, 0); +} + +int bf_alloc(BFile bf, int no, zint *blocks) +{ + int i; + assert(bf->alloc_buf); + bf->header_dirty = 1; + for (i = 0; i < no; i++) { - mf = mf_open (0, path, block_size, 0); - cf = cf_open (mf, commit_area, path, block_size, 1, &firstTime); - cf_unlink (cf); - cf_close (cf); - mf_close (mf); + if (!bf->free_list) + blocks[i] = bf->last_block++; + else + { + char buf[16]; + const char *cp = buf; + memset(buf, '\0', sizeof(buf)); + + blocks[i] = bf->free_list; + if (bf_read(bf, bf->free_list, 0, sizeof(buf), buf) != 1) + { + yaz_log(YLOG_WARN, "Bad freelist entry " ZINT_FORMAT, + bf->free_list); + return -1; + } + zebra_zint_decode(&cp, &bf->free_list); + } } - fclose (inf); - unlink ("cache"); - if (mustDisable) - bf_cache (0); + return 0; } + +int bf_free(BFile bf, int no, const zint *blocks) +{ + int i; + assert(bf->alloc_buf); + bf->header_dirty = 1; + for (i = 0; i < no; i++) + { + char buf[16]; + char *cp = buf; + memset(buf, '\0', sizeof(buf)); + zebra_zint_encode(&cp, bf->free_list); + bf->free_list = blocks[i]; + bf_write(bf, bf->free_list, 0, sizeof(buf), buf); + } + return 0; +} + +int bfs_register_directory_stat(BFiles bfs, int no, const char **directory, + double *used_bytes, double *max_bytes) +{ + return mf_area_directory_stat(bfs->register_area, no, directory, + used_bytes, max_bytes); +} + + +int bfs_shadow_directory_stat(BFiles bfs, int no, const char **directory, + double *used_bytes, double *max_bytes) +{ + if (!bfs->commit_area) + return 0; + return mf_area_directory_stat(bfs->commit_area, no, directory, + used_bytes, max_bytes); +} +/* + * Local variables: + * c-basic-offset: 4 + * c-file-style: "Stroustrup" + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ +