Skip to content

GitLab

Commit ee6c826d authored by Per Cederqvist's avatar Per Cederqvist
Browse files

Removed unused files.

parent dead20cb
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 2207 deletions
src/server/cache-database.c deleted 100644 → 0
View file @ dead20cb
/*
* cache-database.c
*
* cache: Database low-level driver
*
* Copyright (C) Pontus Hagland 1993-10-07
*
*/
#include <stdio.h>
#include <stdarg.h>
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STDLIB_H
# include <stdlib.h>
#endif
#include <time.h>
#include "cache-database.h"
#include "server/smalloc.h"
/* misc. defines *********************************************/
#define TIME (time(NULL))
#define SAFESTORAGETIME 30 /* seconds to regen blocks */
#define cb_addsafestoragetime(x) ((x)+SAFESTORAGETIME)
#define MAXRECORDSINBLOCK 32
/* no of records in a block is max 32 */
#define DATASIZE(cb) ((cb)->header.blocksize- \
sizeof(struct cb_blockheader)- \
DEFEATSIZE)
/* total size of records in a block */
#define REFRESHTRIGGER(cb) (DATASIZE(cb)/3)
/* trigg refresh of block when unused has reached 1/3 */
#define BLOCKPOSITION(cb,no) \
(((no)-0)*(cb)->header.blocksize+ \
/*sizeof(struct cachebaseheader)+DEFEATSIZE*/0) /* let's block-align */
/* misc. declarations ****************************************/
struct cb_blockheader
{
unsigned long generation; /* 0 if clear, othervise counting upwards */
time_t ts_created;
time_t ts_written;
unsigned long index[MAXRECORDSINBLOCK];
};
struct cb_recordheader
{
unsigned long no;
unsigned long generation; /* 0 if clear, othervise counting upwards,
serial following record number */
time_t ts_created;
unsigned int size;
};
struct cb_blocklist
{
unsigned long no;
time_t early;
unsigned long used;
unsigned long records;
struct cb_blocklist*next;
};
static void cb_addtorefreshlist(struct cachebase *cb,unsigned long no,
time_t since,unsigned long used,unsigned long records);
static void cb_addtofreelist(struct cachebase *cb,unsigned long no);
static unsigned long
cb_search(struct cachebase *cb,unsigned long no);
static void
cb_abandon(struct cachebase *cb,long bn,long no);
static unsigned long
cb_getgeneration(struct cachebase *cb,unsigned long bn,
unsigned long no);
/* internal functions ****************************************/
static unsigned long cb_sizeoflist(struct cb_blocklist *cbb)
{
unsigned long i;
i=0;
while (cbb) { i++; cbb=cbb->next; }
return i;
}
static struct cachebase *
cb_recoverbase(char *filename,char *indexname)
{
struct cachebase *cb;
unsigned long bn;
unsigned long busy;
unsigned long index;
struct cb_blockheader bh;
struct cb_recordheader rh;
int i,c;
unsigned long records,brecords,totsz,erecords;
unsigned long rbn,foo;
cb=smalloc(sizeof(struct cachebase));
if (!cb) { restart_kom("cb_recoverbase: out of memory\n"); return NULL; }
cb->fp=fopen(filename,"r+b");
if (!cb->fp) { sfree(cb); return NULL; }
log("cache: recovering database '%s' (recreating index '%s'):\n",
filename,indexname);
fseek(cb->fp,0,0);
fread(&(cb->header),sizeof(cb->header),1,cb->fp);
if (cb->header.hex01234567!=0x01234567||
cb->header.hex89abcdef!=0x89abcdef||
cb->header.sizeofint!=sizeof(int)||
cb->header.sizeoflong!=sizeof(long))
{
log("cache: can't use database '%s': incompatible architecture "
"(x%lx,x%lx,x%lx,x%lx!=x%lx,x%lx,x%lx,x%lx)\n",
filename,cb->header.hex01234567,cb->header.hex89abcdef,
cb->header.sizeofint,cb->header.sizeoflong,
0x01234567,0x89abcdef,sizeof(int),sizeof(long));
sfree(cb);
return NULL;
}
cb->filename=filename;
cb->indexname=indexname;
cb->freelist=NULL;
cb->regenlist=NULL;
cb->writeonblock=0;
cb->ifp=fopen(indexname,"w+b");
if (!cb->ifp)
{
log("cache: !failure, can't create index '%s'\n",indexname);
fclose(cb->fp);
sfree(cb);
return NULL;
}
records=0;
brecords=0;
erecords=0;
totsz=0;
for (bn=1; ;bn++)
{
fseek(cb->fp,BLOCKPOSITION(cb,bn),0);
if (!fread(&bh,sizeof(struct cb_blockheader),1,cb->fp)) break;
if (bh.generation==0)
{
cb_addtofreelist(cb,bn);
}
else
{
busy=0;
index=sizeof(struct cb_blockheader);
for (i=c=0; bh.index[i]&&i<MAXRECORDSINBLOCK&&
index<cb->header.blocksize; i++)
{
fseek(cb->fp,BLOCKPOSITION(cb,bn)+index,0);
fread(&rh,sizeof(struct cb_recordheader),1,cb->fp);
if (bh.index[i]!=~0&&bh.index[i]==rh.no)
{
if (rbn=cb_search(cb,rh.no))
{
if (cb_getgeneration(cb,rbn,rh.no)<rh.generation)
{
cb_abandon(cb,rbn,rh.no);
fseek(cb->ifp,rh.no*sizeof(unsigned long),0);
fwrite(&bn,sizeof(unsigned long),1,cb->ifp);
brecords++; records--;
}
}
else
{
fseek(cb->ifp,rh.no*sizeof(unsigned long),0);
fwrite(&bn,sizeof(unsigned long),1,cb->ifp);
}
busy+=rh.size;
if (rh.size==0) erecords++;
records++;
c++;
if (cb->header.highnumber<rh.no)
cb->header.highnumber=rh.no;
}
index+=rh.size+sizeof(struct cb_recordheader);
if (bh.index[i]!=rh.no&&bh.index[i]!=~0)
{
log(" block %lu found trashed\n",bn);
for (;i<MAXRECORDSINBLOCK;i++)
bh.index[i]=~0;
fseek(cb->fp,BLOCKPOSITION(cb,bn),0);
if (!fwrite(&bh,sizeof(struct cb_blockheader),1,cb->fp))
{
log("cache: !can't update trashed block (%lu)\n",bn);
fclose(cb->fp); fclose(cb->ifp); sfree(cb);
return NULL;
}
}
}
totsz+=busy;
if (busy<REFRESHTRIGGER(cb))
cb_addtorefreshlist(cb,bn,0,busy,c);
}
}
cb->header.highblock=bn-1;
cb->active_records=records;
log(" database recovering finished:\n");
log(" high block.........%-5lu used blocks.........%-5lu\n",
cb->header.highblock,
cb->header.highblock+1-cb_sizeoflist(cb->freelist));
log(" blocks to refresh..%-5lu free blocks.........%-5lu\n",
cb_sizeoflist(cb->regenlist),
cb_sizeoflist(cb->freelist));
log(" high record........%-5lu used records........%-5lu\n",
cb->header.highnumber,records);
log(" empty records......%-5lu refreshed records...%-5lu\n",
erecords,brecords);
log(" database size:%lub size of data:%lub\n",
BLOCKPOSITION(cb,bn),totsz);
return cb;
}
static struct cachebase *
cb_createbase(char *filename,char *indexname,unsigned int blocksize)
{
struct cachebase *cb;
log("cache: creating missing database '%s':\n",filename);
cb=smalloc(sizeof(struct cachebase));
if (!cb) { restart_kom("cache: cb_createbase: out of memory\n"); return NULL; }
cb->fp=fopen(filename,"rb");
if (cb->fp)
{
log("cache: !database do exists, refusing to recreate ('%s')\n",
filename);
fclose(cb->fp);
sfree(cb);
return NULL;
}
cb->ifp=fopen(indexname,"w+b");
if (!cb->ifp)
{
log("cache: !failure: can't create index file '%s'\n",indexname);
sfree(cb);
return NULL;
}
log("cache: index '%s' created, ok\n",indexname);
cb->fp=fopen(filename,"w+b");
if (!cb->fp)
{
log("cache: !failure: can't create database file\n");
fclose(cb->ifp);
sfree(cb);
return NULL;
}
cb->filename=filename;
cb->indexname=indexname;
cb->freelist=NULL;
cb->regenlist=NULL;
cb->writeonblock=0;
cb->active_records=0;
memset(&cb->header,0,sizeof(struct cachebaseheader));
cb->header.blocksize=blocksize;
cb->header.highblock=0;
cb->header.highnumber=0;
cb->header.ts_written=
cb->header.ts_created=TIME;
cb->header.blockgeneration=0;
cb->header.hex01234567=0x01234567;
cb->header.hex89abcdef=0x89abcdef;
cb->header.sizeofint=sizeof(int);
cb->header.sizeoflong=sizeof(long);
fseek(cb->fp,0,0);
if (fwrite(&(cb->header),sizeof(struct cachebaseheader),1,cb->fp)<1)
{
log("cache: !failure: can't write header\n");
fclose(cb->ifp);
fclose(cb->fp);
sfree(cb);
return NULL;
}
fwrite(DEFEATSTRING,DEFEATSIZE,1,cb->fp);
log(" initialized with 0 block, high number=0, ok\n");
return cb;
}
static void cb_addtorefreshlist(struct cachebase *cb,unsigned long no,
time_t since,unsigned long used,unsigned long records)
{
struct cb_blocklist *bl;
if (records>MAXRECORDSINBLOCK-5) return;
bl=cb->regenlist;
while (bl)
{
if (bl->no==no)
{
bl->used=used;
bl->records=records;
log("debug: block %lu updated in regenlist (used: %lu, records: %lu)\n",
no,used,records);
return;
}
bl=bl->next;
}
bl=smalloc(sizeof(struct cb_blocklist));
if (!bl) { restart_kom("cache: cb_addtorefreshlist: out of memory\n"); return; }
bl->no=no;
if (!since) bl->early=TIME; /* may be changed if time_t != integer */
else bl->early=cb_addsafestoragetime(since);
bl->used=used;
bl->records=records;
bl->next=cb->regenlist;
cb->regenlist=bl;
log("debug: block %lu added to regenlist (used: %lu, records: %lu)\n",
no,used,records);
}
static void cb_addtofreelist(struct cachebase *cb,unsigned long no)
{
struct cb_blocklist *bl;
bl=cb->freelist;
while (bl)
{
if (bl->no==no) return;
bl=bl->next;
}
bl=smalloc(sizeof(struct cb_blocklist));
bl->no=no;
bl->next=cb->freelist;
cb->freelist=bl;
}
static unsigned long
cb_search(struct cachebase *cb,unsigned long no)
{
unsigned long pos;
pos=0;
if (no>cb->header.highnumber) return 0;
fseek(cb->ifp,sizeof(unsigned long)*no,0);
fread(&pos,sizeof(unsigned long),1,cb->ifp);
return pos;
}
static unsigned long
cb_getnewblock(struct cachebase *cb,struct cb_blockheader *bh)
{
struct cb_blocklist *bl;
unsigned long n;
int i;
if (cb->freelist)
{
bl=cb->freelist;
n=bl->no;
cb->freelist=bl->next;
sfree(bl);
}
else
{
n=++(cb->header.highblock);
}
bh->generation=++cb->header.blockgeneration;
bh->ts_created=bh->ts_created=TIME;
for (i=0; i<MAXRECORDSINBLOCK; i++) bh->index[i]=0;
fseek(cb->fp,0,0);
cb->header.ts_written=TIME;
if (!fwrite(&cb->header,sizeof(struct cachebaseheader),1,cb->fp))
{
restart_kom("cache: !write to base header failed ('%s')\n",cb->filename);
return 0;
}
cb->writeonblock=n;
return n;
}
static unsigned long
cb_writenew(struct cachebase *cb,unsigned long no,void *buffert,
unsigned int size,unsigned long lastgeneration)
{
struct cb_blockheader bh;
struct cb_recordheader rh;
unsigned long bn,pos;
unsigned long space,index;
int i;
/* if (size+sizeof(struct cb_recordheader)>DATASIZE(fp)) ... */
bn=cb->writeonblock;
if (bn)
{
fseek(cb->fp,BLOCKPOSITION(cb,bn),0);
fread(&bh,sizeof(struct cb_blockheader),1,cb->fp);
space=DATASIZE(cb);
index=sizeof(struct cb_blockheader);
for (i=0; i<MAXRECORDSINBLOCK&&bh.index[i]; i++)
{
fseek(cb->fp,BLOCKPOSITION(cb,bn)+index,0);
/* optimera fseek'en till att ska framt */
fread(&rh,sizeof(struct cb_recordheader),1,cb->fp);
space-=rh.size+sizeof(struct cb_recordheader);
index+=rh.size+sizeof(struct cb_recordheader);
}
if (i==MAXRECORDSINBLOCK) bn=0;
else if (space<sizeof(struct cb_recordheader)+size)
{
if (DATASIZE(cb)-space<REFRESHTRIGGER(cb))
cb_addtorefreshlist(cb,bn,bh.ts_written,DATASIZE(cb)-space,i);
bn=0;
}
for (i=0; i<MAXRECORDSINBLOCK&&bh.index[i]; i++)
if (bh.index[i]==no) { bn=0; break; }
/* do not store the same record twice in a block */
}
if (!bn)
if (bn=cb_getnewblock(cb,&bh))
{
i=0; /* next record==0 */
index=sizeof(struct cb_blockheader); /* write at this position */
}
else return 0; /* error! (probably restart_kom already done) */
rh.generation=lastgeneration+1;
rh.no=no;
rh.size=size;
rh.ts_created=TIME;
fseek(cb->fp,BLOCKPOSITION(cb,bn)+index,0);
if (!fwrite(&rh,sizeof(struct cb_recordheader),1,cb->fp))
{
restart_kom("cache: Can't write recordheader, r%ib%i, base='%s'\n",
no,bn,cb->filename);
return 0;
}
if (size)
if (!fwrite(buffert,size,1,cb->fp))
{
restart_kom("cache: Can't write record data, r%ib%i, base='%s'\n",
no,bn,cb->filename);
return 0;
}
fseek(cb->fp,BLOCKPOSITION(cb,bn),0);
bh.index[i]=no;
bh.ts_written=TIME;
if (!fwrite(&bh,sizeof(struct cb_blockheader),1,cb->fp))
{
restart_kom("cache: Can't write block header, r%i to b%i, base='%s'\n",
no,bn,cb->filename);
return 0;
}
fseek(cb->ifp,sizeof(unsigned long)*no,0);
if (!fwrite(&bn,sizeof(unsigned long),1,cb->ifp))
{
restart_kom("cache: Can't write record index, r%i to b%i, base='%s', "
"index='%s'\n",
no,bn,cb->filename,cb->indexname);
return 0;
}
log("debug: W: rec %lu as #%lu in bl %lu (pos %lu)\n",
no,i,bn,BLOCKPOSITION(cb,bn)+sizeof(struct cb_recordheader)+index);
if (no>=cb->header.highnumber)
{
cb->header.highnumber=no;
log("debug: highnumber set to %lu\n",no);
fseek(cb->fp,0,0);
cb->header.ts_written=TIME;
if (!fwrite(&cb->header,sizeof(struct cachebaseheader),1,cb->fp))
{
restart_kom("cache: !write to base header failed ('%s')\n",
cb->filename);
return bn;
}
}
return bn;
}
static void
cb_abandon(struct cachebase *cb,long bn,long no)
{
struct cb_blockheader bh;
struct cb_recordheader rh;
int i,c;
unsigned long index;
unsigned long busy;
log("debug: cb_abandon rec %lu from block %lu\n",no,bn);
fseek(cb->fp,BLOCKPOSITION(cb,bn),0);
fread(&bh,sizeof(struct cb_blockheader),1,cb->fp);
for (i=0; i<MAXRECORDSINBLOCK; i++)
if (bh.index[i]==no) bh.index[i]=~0;
fseek(cb->fp,BLOCKPOSITION(cb,bn),0);
if (!fwrite(&bh,sizeof(struct cb_blockheader),1,cb->fp))
{
restart_kom("cache: cb_abandon: failed to write blockheader (b%lu)\n",
bn);
return;
}
index=sizeof(struct cb_blockheader);
for (i=c=0; i<MAXRECORDSINBLOCK&&bh.index[i]; i++)
{
fseek(cb->fp,BLOCKPOSITION(cb,bn)+index,0);
/* optimera fseek'en till att ska framt? */
fread(&rh,sizeof(struct cb_recordheader),1,cb->fp);
if ((bh.index[i]!=~0)&&(rh.no!=bh.index[i]))
{
restart_kom("cache: !record %lu in '%s', "
"index(%lu)!=recordno(%lu) => corrupt\n",
bn,cb->filename,bh.index[i],rh.no);
return;
}
index+=rh.size+sizeof(struct cb_recordheader);
if (bh.index[i]!=~0)
busy+=rh.size+sizeof(struct cb_recordheader),c++;
}
if (busy<REFRESHTRIGGER(cb))
cb_addtorefreshlist(cb,bn,TIME,busy,c);
}
static unsigned long
cb_getgeneration(struct cachebase *cb,unsigned long bn,
unsigned long no)
{
struct cb_blockheader bh;
struct cb_recordheader rh;
int i;
unsigned long index;
if (bn<1)
{
log("cache: cb_getgeneration: warning; bn<1\n");
return 0;
}
if (no<1)
{
log("cache: cb_getgeneration: warning; no<1\n");
return 0;
}
fseek(cb->fp,BLOCKPOSITION(cb,bn),0);
fread(&bh,sizeof(struct cb_blockheader),1,cb->fp);
index=sizeof(struct cb_blockheader);
for (i=0; i<MAXRECORDSINBLOCK&&bh.index[i]; i++)
{
fseek(cb->fp,BLOCKPOSITION(cb,bn)+index,0);
/* optimera fseek'en till att ska framt? */
fread(&rh,sizeof(struct cb_recordheader),1,cb->fp);
if ((bh.index[i]!=~0)&&(rh.no!=bh.index[i]))
{
restart_kom("cache: !record %lu in '%s', "
"index(%lu)!=recordno(%lu) => corrupt\n",
bn,cb->filename,bh.index[i],rh.no);
return 0;
}
if (rh.no==no) return rh.generation;
index+=rh.size+sizeof(struct cb_recordheader);
}
restart_kom("cache: !record %lu in '%s', missing record %lu => corrupt",
bn,cb->filename,rh.no);
log("cache: cb_getgeneration: warning, missing record %ld in block %ld.\n",
no,bn);
return 0;
}
void *
cb_readrecord(struct cachebase *cb,unsigned long bn,
unsigned long no,unsigned long *size,
unsigned long *gen)
{
struct cb_blockheader bh;
struct cb_recordheader rh;
int i;
unsigned long index;
void *buffert;
if (no<1)
{
log("cache: cb_readrecord: warning; no<1\n");
return 0;
}