X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=blobdiff_plain;f=bfile%2Fbfile.c;h=5ee546084840a200536e4bdf711fb86c2ad9cf71;hp=67006795cc434d9a5833bf4271e4f28c86077148;hb=HEAD;hpb=3c5f6226f97612c0d6ac40591f600587c5ffa858 diff --git a/bfile/bfile.c b/bfile/bfile.c index 6700679..5ee5460 100644 --- a/bfile/bfile.c +++ b/bfile/bfile.c @@ -1,254 +1,394 @@ -/* - * Copyright (C) 1994-1999, Index Data - * All rights reserved. - * Sebastian Hammer, Adam Dickmeiss - * - * $Log: bfile.c,v $ - * Revision 1.27 1999-02-02 14:50:01 adam - * Updated WIN32 code specific sections. Changed header. - * - * Revision 1.26 1998/02/17 10:32:52 adam - * Fixed bug: binary files weren't opened with flag b on NT. - * - * Revision 1.25 1997/10/27 14:25:38 adam - * Fixed memory leaks. - * - * Revision 1.24 1997/09/18 08:59:16 adam - * Extra generic handle for the character mapping routines. - * - * Revision 1.23 1997/09/17 12:19:06 adam - * Zebra version corresponds to YAZ version 1.4. - * Changed Zebra server so that it doesn't depend on global common_resource. - * - * Revision 1.22 1997/09/09 13:37:52 adam - * Partial port to WIN95/NT. - * - * Revision 1.21 1996/10/29 13:56:13 adam - * Include of zebrautl.h instead of alexutil.h. - * - * Revision 1.20 1996/03/26 15:59:04 adam - * The directory of the shadow table file can be specified by the new - * bf_lockDir call. - * - * Revision 1.19 1996/02/05 12:28:58 adam - * Removed a LOG_LOG message. - * - * 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 -#else +#endif + +#if HAVE_UNISTD_H #include #endif -#include -#include +#include +#include +#include +#include "mfile.h" #include "cfile.h" +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_struct *register_area; - char *lockDir; + MFile_area register_area; + char *base; + char *cache_fname; }; -BFiles bfs_create (const char *spec) +BFiles bfs_create (const char *spec, const char *base) { - BFiles bfs = xmalloc (sizeof(*bfs)); - bfs->commit_area = NULL; - bfs->register_area = mf_init("register", spec); - bfs->lockDir = NULL; + 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) + { + bfs_destroy(bfs); + return 0; + } return bfs; } -void bfs_destroy (BFiles bfs) +void bfs_destroy(BFiles bfs) { - xfree (bfs->lockDir); - mf_destroy (bfs->commit_area); - mf_destroy (bfs->register_area); - xfree (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) +static FILE *open_cache(BFiles bfs, const char *flags) { - char cacheFilename[1024]; FILE *file; - sprintf (cacheFilename, "%scache", - bfs->lockDir ? bfs->lockDir : ""); - file = fopen (cacheFilename, flags); + file = fopen(bfs->cache_fname, flags); return file; } -static void unlink_cache (BFiles bfs) +static void unlink_cache(BFiles bfs) { - char cacheFilename[1024]; + if (bfs->cache_fname) + unlink(bfs->cache_fname); +} - sprintf (cacheFilename, "%scache", - bfs->lockDir ? bfs->lockDir : ""); - unlink (cacheFilename); +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 + bfs->commit_area = 0; + return ZEBRA_OK; } -void bf_lockDir (BFiles bfs, const char *lockDir) +int bf_close2(BFile bf) { - size_t len; - - xfree (bfs->lockDir); - if (lockDir == NULL) - lockDir = ""; - len = strlen(lockDir); - bfs->lockDir = xmalloc (len+2); - strcpy (bfs->lockDir, lockDir); - - if (len > 0 && bfs->lockDir[len-1] != '/') - strcpy (bfs->lockDir + len, "/"); + int ret = 0; + zebra_lock_rdwr_destroy(&bf->rdwr_lock); + if (bf->cf) + { + 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_cache (BFiles bfs, const char *spec) +void bf_close(BFile bf) { - if (spec) + if (bf_close2(bf)) { - if (!bfs->commit_area) - bfs->commit_area = mf_init ("shadow", spec); + 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 - bfs->commit_area = NULL; + 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_close (BFile bf) +int bf_xclose(BFile bf, int version, const char *more_info) { - if (bf->cf) - cf_close (bf->cf); - mf_close (bf->mf); - xfree (bf); - return 0; + 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 (BFiles bfs, 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)); + + 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) { int first_time; - tmp->mf = mf_open (bfs->register_area, name, block_size, 0); - tmp->cf = cf_open (tmp->mf, bfs->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) { FILE *outf; - outf = open_cache (bfs, "ab"); + outf = open_cache(bfs, "ab"); if (!outf) { - logf (LOG_FATAL|LOG_ERRNO, "open %scache", - bfs->lockDir ? bfs->lockDir : ""); - exit (1); + 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; } - fprintf (outf, "%s %d\n", name, block_size); - fclose (outf); } } else { - tmp->mf = mf_open(bfs->register_area, 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 (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_read"); + } + return ret; } -int bf_write (BFile bf, int no, int offset, int num, const void *buf) +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) - return cf_write (bf->cf, no, offset, num, buf); - return mf_write (bf->mf, no, offset, num, buf); + { + 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_commitExists (BFiles bfs) +int bf_write(BFile bf, zint no, int offset, int nbytes, const void *buf) +{ + int ret = bf_write2(bf, no, offset, nbytes, buf); + + if (ret == -1) + { + zebra_exit("bf_write"); + } + return ret; +} + +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) + 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(BFiles bfs) { FILE *inf; - inf = open_cache (bfs, "rb"); + inf = open_cache(bfs, "rb"); if (inf) { - fclose (inf); + fclose(inf); return 1; } return 0; } -void bf_commitExec (BFiles bfs) +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; @@ -256,54 +396,126 @@ void bf_commitExec (BFiles bfs) MFile mf; CFile cf; int first_time; + int r = 0; - assert (bfs->commit_area); - if (!(inf = open_cache (bfs, "rb"))) + 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 (bfs->register_area, path, block_size, 1); - cf = cf_open (mf, bfs->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; + } + + r = cf_commit(cf); - 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 (BFiles bfs, const char *spec) +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 (!bfs->commit_area) { - bf_cache (bfs, spec); + bf_cache(bfs, spec); mustDisable = 1; } - if (!(inf = open_cache (bfs, "rb"))) - 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 (bfs->register_area, path, block_size, 0); - cf = cf_open (mf, bfs->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 (bfs); - if (mustDisable) - bf_cache (bfs, 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 + */ +