--- freem/src/global_bltin.c 2025/03/24 01:33:30 1.6 +++ freem/src/global_bltin.c 2025/04/11 18:24:32 1.20 @@ -1,5 +1,5 @@ /* - * $Id: global_bltin.c,v 1.6 2025/03/24 01:33:30 snw Exp $ + * $Id: global_bltin.c,v 1.20 2025/04/11 18:24:32 snw Exp $ * freem database engine * * @@ -24,6 +24,48 @@ * along with FreeM. If not, see . * * $Log: global_bltin.c,v $ + * Revision 1.20 2025/04/11 18:24:32 snw + * Fix bug in memory cache + * + * Revision 1.19 2025/04/11 16:52:05 snw + * Fix indentation in global handler + * + * Revision 1.18 2025/04/11 16:23:18 snw + * Avoid re-reading the same block consecutively when possible + * + * Revision 1.17 2025/04/11 14:21:03 snw + * Make all but one of the read/write calls in global_bltin use gbl_read_block or gbl_write_block + * + * Revision 1.16 2025/04/11 00:52:40 snw + * Replace all lseek/read calls in global handler to use gbl_read_block function + * + * Revision 1.15 2025/04/10 01:24:38 snw + * Remove C++ style comments + * + * Revision 1.14 2025/04/09 19:52:02 snw + * Eliminate as many warnings as possible while building with -Wall + * + * Revision 1.13 2025/04/09 14:34:30 snw + * Further work on global_bltin.c refactor + * + * Revision 1.12 2025/04/09 00:43:07 snw + * Exit with fatal error if a header mismatch found + * + * Revision 1.11 2025/04/08 21:41:13 snw + * Make insert, update, and splitp global handler functions take a ptr to a global_handle instead of a file descriptor + * + * Revision 1.10 2025/04/08 20:00:56 snw + * Global handler now uses a header file and maintains the last journaling transaction ID + * + * Revision 1.9 2025/04/08 16:46:11 snw + * Add global file header and offsets + * + * Revision 1.8 2025/04/08 14:39:21 snw + * Initial work on global handler refactor + * + * Revision 1.7 2025/03/24 04:13:11 snw + * Replace action macro dat with fra_dat to avoid symbol conflict on OS/2 + * * Revision 1.6 2025/03/24 01:33:30 snw * Guard declaration of time function in global_bltin.c for portability * @@ -43,21 +85,25 @@ #include #include #include - +#include #include - #include "mpsdef.h" +#include "journal.h" +#include "global_bltin.h" -static void b_free (short filedes, unsigned long blknbr); -static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr); -static void update (short filedes, char *ins_key, long keyl); -static void insert (int filedes, char *ins_key, long key_len, unsigned long blknbr); +global_handle *global_handles_head; +unsigned long gbl_cache_misses = 0; +unsigned long gbl_cache_hits = 0; + +static void b_free (global_handle *g, unsigned long blknbr); +static void splitp (global_handle *g, char *block, long *addr, long *offs, unsigned long *blknbr); +static void update (global_handle *g, char *ins_key, long keyl); +static void insert (global_handle *g, char *ins_key, long key_len, unsigned long blknbr); static void scanpblk (char *block, long *adr, long *fnd); static void scandblk (char *block, long *adr, long *fnd); -static void getnewblk (int filedes, unsigned long *blknbr); +static void getnewblk (global_handle *g, unsigned long *blknbr); static short int g_collate (char *t); -//static short int g_numeric (char *str); short g_numeric (char *str); void close_all_globals(void); static void panic (void); @@ -102,9 +148,491 @@ static void panic (void); #define DATA 8 #if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__) - long time (); +long time (); #endif +inline long gbl_path(char *key, char *buf) +{ + long savj; + + register long int i; + register long int j; + register long int k; + register long int ch; + + /* construct full UNIX filename */ + savj = 0; + k = 0; + j = savj; + + if (key[1] == '%' || key[1] == '$') { /* %-globals and SSVN backing storage, no explicit path */ + + if (gloplib[0] != EOL) { + + /* append % global access path */ + while ((ch = buf[k++] = gloplib[j++]) != ':' && ch != EOL); + + } + + } + else if (key[1] != '/') { /* no explicit path specified */ + + if (glopath[0] != EOL) { + + /* append global access path */ + while ((ch = buf[k++] = glopath[j++]) != ':' && ch != EOL); + + } + + } + + if (k > 0) { + + if (k == 1 || (k == 2 && buf[0] == '.')) { + k = 0; + } + else { + buf[k - 1] = '/'; + } + + } + + savj = j; + i = 0; + j = 0; + + while (key[i] != EOL) { + + if ((buf[k] = key[i]) == DELIM) break; + + if (buf[k] == '/') { + + j = i; + + if (k > i) { + i = 0; + j = 0; + k = 0; + + continue; + } + + } + + i++; + k++; + + } + + buf[k] = NUL; /* NUL not EOL !!! */ + + return i; +} /* gbl_path() */ + +void gbl_cache_hit(global_handle *g) +{ + g->cache_hits++; + gbl_cache_hits++; +} /* gbl_cache_hit() */ + +void gbl_cache_miss(global_handle *g) +{ + g->fast_path = 0; + g->cache_misses++; + gbl_cache_misses++; +} /* gbl_cache_miss() */ + +int gbl_lock(global_handle *g, int type) +{ + if (g->locked == TRUE || lonelyflag == TRUE) { + return TRUE; + } + + locking (g->fd, type, 0L); + g->locked = TRUE; + + return TRUE; +} /* gbl_lock() */ + +int gbl_unlock(global_handle *g) +{ + if (g->locked == FALSE || lonelyflag == TRUE) { + return TRUE; + } + + locking (g->fd, 0, 0L); + g->locked = FALSE; + + return TRUE; +} /* gbl_unlock() */ + +void gbl_close(global_handle *g) +{ + if (g->opened == TRUE) { + close (g->fd); + + g->use_count = 0; + g->age = 0; + g->last_block = 0; + g->locked = FALSE; + g->opened = FALSE; + } +} /* gbl_close() */ + +void gbl_close_all(void) +{ + global_handle *g; + + for (g = global_handles_head; g != NULL; g = g->next) { + gbl_close (g); + } +} /* gbl_close_all() */ + +int gbl_write_initial_header(global_handle *g) +{ + global_header hdr; + unsigned long old_position; + char m[5] = GBL_MAGIC; + char msg[256]; + + if (g->opened == FALSE) { + return FALSE; + } + + memcpy (hdr.magic, m, 5); + hdr.format_version = GBL_FORMAT_VERSION; + strncpy (hdr.host_triplet, HOST, 40); + hdr.block_size = BLOCKLEN; + hdr.last_transaction_id = 0; + hdr.created = time (0L); + hdr.last_backup = -1; + + gbl_lock (g, 1); + old_position = lseek (g->fd, 0, SEEK_CUR); + lseek (g->fd, 0, SEEK_SET); + + if (write (g->fd, &hdr, sizeof (global_header)) == -1) { + snprintf (msg, sizeof (msg), "error %d writing global header for %s", errno, g->global_name); + m_fatal (msg); + } + + lseek (g->fd, old_position, SEEK_SET); + gbl_unlock (g); + + return TRUE; +} /* gbl_write_initial_header() */ + + +int gbl_write_header(global_handle *g, global_header *hdr) +{ + unsigned long old_position; + char msg[256]; + + if (g->opened == FALSE) { + return FALSE; + } + + gbl_lock (g, 1); + old_position = lseek (g->fd, 0, SEEK_CUR); + lseek (g->fd, 0, SEEK_SET); + + if (write (g->fd, hdr, sizeof (global_header)) == -1) { + snprintf (msg, sizeof (msg), "error %d writing global header for %s", errno, g->global_name); + m_fatal (msg); + } + + lseek (g->fd, old_position, SEEK_SET); + gbl_unlock (g); + + gbl_read_header (g, &g->header); + + return TRUE; +} /* gbl_write_header() */ + +int gbl_read_header(global_handle *g, global_header *h) +{ + unsigned long old_position; + char m[5] = GBL_MAGIC; + + + if (g->opened == FALSE) { + return GBL_HDR_NOTOPEN; + } + + gbl_lock (g, 1); + old_position = lseek (g->fd, 0, SEEK_CUR); + lseek (g->fd, 0, SEEK_SET); + + read (g->fd, h, sizeof (global_header)); + + lseek (g->fd, old_position, SEEK_SET); + gbl_unlock (g); + + if (strncmp (h->magic, m, 5) != 0) { + return GBL_HDR_BADMAGIC; + } + if (h->format_version != GBL_FORMAT_VERSION) { + return GBL_HDR_BADVERSION; + } + if (h->block_size != BLOCKLEN) { + return GBL_HDR_BADBLOCKSIZE; + } + + return GBL_HDR_OK; +} /* gbl_read_header() */ + +int gbl_update_tid(global_handle *g) +{ + global_header h; + + if (gbl_read_header (g, &h) != GBL_HDR_OK) { + return FALSE; + } + + h.last_transaction_id = jnl_tran_id; + + return gbl_write_header (g, &h); +} /* gbl_update_tid() */ + +int gbl_create(global_handle *g) +{ + while (1) { + errno = 0; + + if ((g->fd = creat (g->global_path, 0666)) != -1) break; + + if (errno == EMFILE || errno == ENFILE) { + gbl_close_all (); + continue; + } + + return PROTECT; + } + + g->opened = TRUE; + g->age = time (0L); + g->last_block = 0; + g->use_count = 1; + g->fast_path = 0; + + gbl_write_initial_header (g); + + return OK; +} /* gbl_create() */ + +short gbl_open(global_handle *g, short action) +{ + int result; + + if (g->opened == FALSE) { + gbl_cache_miss (g); + while (1) { + errno = 0; + g->fd = open (g->global_path, 2); + + if (g->fd != -1) break; + + switch (errno) { + case EINTR: + continue; + + case EMFILE: + case ENFILE: + gbl_close_all (); + continue; + } + + break; + } + + if (g->fd == -1) { + g->use_count = 0; + g->age = 0; + g->last_block = 0; + g->locked = FALSE; + g->opened = FALSE; + } + else { + g->opened = TRUE; + result = gbl_read_header (g, &g->header); + + if (result == GBL_HDR_OK) { + /* initialize last_block_accessed cache */ + g->last_block_accessed = (char *) calloc (g->header.block_size, sizeof (char)); + NULLPTRCHK(g->last_block_accessed,"gbl_open"); + + g->opened = TRUE; + } + else { + gbl_close (g); + set_io (UNIX); + + switch (result) { + + case GBL_HDR_BADMAGIC: + fprintf (stderr, "gbl_open: bad magic value in %s [FATAL]\n", g->global_name); + exit (1); + break; + + case GBL_HDR_BADVERSION: + fprintf (stderr, "gbl_open: global version is %d in %s (must be %d) [FATAL]\n", g->header.format_version, g->global_name, GBL_FORMAT_VERSION); + exit (1); + break; + + } + + return FALSE; + } + } + } + + return g->opened; + +} /* gbl_open() */ + +int gbl_read_block(global_handle *g, unsigned long blocknum, char *block) +{ + struct stat gstat; + unsigned long hdr_offset; + hdr_offset = sizeof (global_header); + + if (g->opened == FALSE) { + return FALSE; + } + + g->use_count++; + + if (!g->locked) gbl_lock (g, 1); + fstat (g->fd, &gstat); + + if ((g->last_block == blocknum) && + (g->have_cached_block) && + (g->cached_block_num == blocknum) && + (gstat.st_mtime < g->last_read_time)) { + /* the global has not been modified since the last read; grab from memory */ + g->memory_reads++; + memcpy (block, g->last_block_accessed, g->header.block_size); + } + else { + /* have to go out to disk */ + lseek (g->fd, hdr_offset + ((long) blocknum * (long) (g->header.block_size)), SEEK_SET); + read (g->fd, block, g->header.block_size); + + /* update cache */ + memcpy (g->last_block_accessed, block, g->header.block_size); + g->have_cached_block = TRUE; + g->cached_block_num = blocknum; + g->last_block = blocknum; + g->read_ops++; + } + + g->last_read_time = time (0L); + g->use_count++; + + if (g->locked) gbl_unlock (g); + + return TRUE; +} /* gbl_read_block() */ + +int gbl_write_block(global_handle *g, unsigned long blocknum, char *block) +{ + int errsav; + unsigned long hdr_offset; + hdr_offset = sizeof (global_header); + + if (g->opened == FALSE) { + return FALSE; + } + + gbl_lock (g, 1); + + for (;;) { + + errno = 0; + + lseek (g->fd, hdr_offset + (blocknum * g->header.block_size), SEEK_SET); + write (g->fd, block, BLOCKLEN); + errsav = errno; + g->last_block = blocknum; + g->use_count++; + g->write_ops++; + + if (errsav == 0) break; + + panic (); + + } + + gbl_update_tid (g); + gbl_unlock (g); + + return TRUE; +} + +global_handle *gbl_handle(char *key) +{ + global_handle *g; + char global_name[256]; + int i; + struct stat dinf; + + i = 0; + while (key[i] != EOL) { + if ((global_name[i] = key[i]) == DELIM) break; + + i++; + } + global_name[i] = NUL; + + + for (g = global_handles_head; g != NULL; g = g->next) { + if (strncmp (g->global_name, global_name, 256) == 0) { + g->use_count++; + if (!lonelyflag) { + g->fast_path = 0; + } + + fstat (g->fd, &dinf); + if (g->age > dinf.st_mtime) { + g->fast_path = 2; + return g; + } + + g->age = time (0L); + g->fast_path = 0; + + return g; + } + } + g = (global_handle *) malloc (sizeof (global_handle)); + NULLPTRCHK(g,"gbl_open"); + + g->use_count = 1; + g->locked = FALSE; + g->age = time (0L); + g->last_read_time = 0; + g->last_block = 0; + g->opened = FALSE; + g->fd = 0; + g->fast_path = -1; + g->cache_misses = 0; + g->cache_hits = 0; + g->read_ops = 0; + g->write_ops = 0; + g->memory_reads = 0; + g->have_cached_block = FALSE; + g->last_block_accessed = NULL; + + strcpy (g->global_name, global_name); + gbl_path (key, g->global_path); + + g->next = global_handles_head; + global_handles_head = g; + + return g; +} /* gbl_handle() */ + + /* globals management */ /* 0 = set_sym 1 = get_sym */ @@ -179,52 +707,52 @@ static void panic (void); * the file is *not* closed on return. since access is regulated by the * locking mechanism, that will not spell trouble. */ - + void global_bltin (short action, char *key, char *data) { - /* these must be static variables */ + global_handle *g; - static short filedes; /* filedescr for global access */ + unsigned long hdr_offset; + + /* these must be static variables */ static char filnam[256]; /* name of global/unix file */ /* the following vars may be */ /* static or dynamic */ - static unsigned long blknbr; /* block number */ - static unsigned long oldblk; static unsigned long newblk; static unsigned long other; static long j1; static long limit; static short typ; /* block type */ - static long keyl, /* length of compacted key */ - datal, /* length of data */ - olddatal, - offset, - found, - addr, /* address of key in 'block' */ - needed, /* new bytes needed to ins. stuff */ - ret_to, /* return code */ - kill_again; + static long keyl; /* length of compacted key */ + static long datal; /* length of data */ + static long olddatal; + static long offset; + static long found; + static long addr; /* address of key in 'block' */ + static long needed; /* new bytes needed to ins. stuff */ + static long ret_to; /* return code */ + static long kill_again; static char key1[256]; static char tmp1[256]; /* intermediate storage for op= */ static char block[BLOCKLEN]; static int getnflag; /* flag 1=$ZO-variable 0=$Q-function */ static int tryfast; /* try fast access if get_sym on */ - /* previous global */ - - struct stat dinf; /* get modification date */ - - long savj, - savch; /* saved j and ch for multiple pathes */ - register long int i, - j, - k, - ch; - long pathscan; /* flag for repeated scan of pathlist setting an undef global */ + /* previous global */ + int iresult; + + register long int i; + register long int j; + register long int k; + register long int ch; + j = 0; + + hdr_offset = sizeof (global_header); + /* process optional limitations */ if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') { @@ -301,8 +829,8 @@ void global_bltin (short action, char *k } } - if (action == getnext) { + if (action == getnext) { getnflag = TRUE; varnam[0] = EOL; @@ -376,90 +904,9 @@ void global_bltin (short action, char *k } } - /* construct full UNIX filename */ - savj = 0; - savch = ch = EOL; - pathscan = TRUE; - nextpath: - k = 0; - j = savj; - - if (key[1] == '%' || key[1] == '$') { /* %-globals and SSVN backing storage, no explicit path */ - - if (gloplib[0] != EOL) { - - /* append % global access path */ - while ((ch = filnam[k++] = gloplib[j++]) != ':' && ch != EOL); - - } - - } - else if (key[1] != '/') { /* no explicit path specified */ - - if (glopath[0] != EOL) { - - /* append global access path */ - while ((ch = filnam[k++] = glopath[j++]) != ':' && ch != EOL); - - } - - } - - if (savj == 0 && ch == EOL) pathscan = FALSE; /* one path only: inhibit search */ - - if (k > 0) { - - if (k == 1 || (k == 2 && filnam[0] == '.')) { - k = 0; - } - else { - filnam[k - 1] = '/'; - } - - } - - savch = ch; - savj = j; - i = 0; - j = 0; - - while (key[i] != EOL) { - - if ((filnam[k] = key[i]) == DELIM) break; + g = gbl_handle (key); + i = gbl_path (key, filnam); - if (filnam[k] == '/') { - - j = i; - - if (k > i) { - i = 0; - j = 0; - k = 0; - - continue; - } - - } - - i++; - k++; - - } - - filnam[k] = NUL; /* NUL not EOL !!! */ - - /* if a unix directory is specified, reposition '^' */ - /* '^/usr/test' becomes '/usr/^test' */ - if (j > 0) { - - for (k = 0; k < j; k++) { - filnam[k] = filnam[k + 1]; - } - - filnam[j] = '^'; - - } - /* compact key to internal format: characters are shifted left */ /* delimiters become LSB of previous character */ /* test subscripts for being numeric or not */ @@ -595,93 +1042,11 @@ void global_bltin (short action, char *k compactkey[k] = g_EOL; - /* look whether file is already open */ - tryfast = FALSE; - ch = usage[i = j = inuse]; - - while (i < NO_GLOBLS) { - - k = 0; - - while (filnam[k] == oldfil[i][k]) { - - if (filnam[k++] == NUL) { - - filedes = olddes[i]; - - if (inuse == i && action == get_sym) { - - tryfast = TRUE; - - if (usage[i] != (-1)) usage[i]++; - if (lonelyflag) goto tfast2; - - fstat (filedes, &dinf); - - if (g_ages[i] > dinf.st_mtime) goto tfast2; - - g_ages[i] = time (0L); - - goto tfast0; - - } - - inuse = i; - - if (usage[i] != (-1)) usage[i]++; - - goto lock; - } - - } - - if (ch < 0 || (usage[i] >= 0 && usage[i] < ch)) ch = usage[j = i]; - - if (i++ == inuse) { - inuse = (-1); - i = 0; - } - - } - - inuse = j; - usage[j] = 1; - - /* close previous file */ - if ((filedes = olddes[j]) > 0) { - close (filedes); - olddes[j] = 0; - } - - strcpy (oldfil[j], filnam); /* save current filename */ - reopen: - for (;;) { - - errno = 0; - - if ((filedes = open (filnam, 2)) != -1) break; - if (errno == EINTR) continue; - - if (errno == EMFILE || errno == ENFILE) { /* too many open files now */ - close_all_globals (); - - continue; - } - - break; - } + gbl_open (g, action); + if (g->fd == -1) { - if (filedes == -1) { - - usage[inuse] = 0; - oldfil[inuse][0] = NUL; - olddes[inuse] = 0; - g_ages[inuse] = 0; - - if ((pathscan || errno != ENOENT) && (savch != EOL)) goto nextpath; /* try next access path */ - /* file not found */ if (action != set_sym) { @@ -690,7 +1055,7 @@ reopen: return; } - if (action == dat || action == zdata) { + if (action == fra_dat || action == zdata) { data[0] = '0'; data[1] = EOL1; @@ -714,15 +1079,7 @@ reopen: merr_raise (PROTECT); return; } - - if (pathscan) { - savj = 0; - savch = ch = EOL; - pathscan = FALSE; - - goto nextpath; - } - + if (setop) { tmp1[0] = EOL; @@ -752,35 +1109,15 @@ reopen: block[NRBLK + 2] = ROOT + 1; /* nr. of blocks */ /* create file, write_lock it and initialize root block */ - for (;;) { + gbl_lock (g, 1); - errno = 0; - - if ((filedes = creat (filnam, 0666)) != -1) break; - - if (errno == EMFILE || errno == ENFILE) { - close_all_globals (); - continue; - } - - merr_raise (PROTECT); + if ((iresult = gbl_create (g)) != OK) { + merr_raise (iresult); return; - } + } - if (lonelyflag == FALSE) locking (filedes, 1, 0L); - - for (;;) { - - errno = 0; - - lseek (filedes, ROOT * BLOCKLEN, 0); - write (filedes, block, BLOCKLEN); + gbl_write_block (g, ROOT, block); - if (errno == 0) break; - - panic (); - } - block[NRBLK] = 0; block[NRBLK + 1] = 0; block[NRBLK + 2] = ROOT; /* clear */ @@ -795,184 +1132,164 @@ reopen: for (;;) { errno = 0; - write (filedes, block, BLOCKLEN); + write (g->fd, block, BLOCKLEN); if (errno == 0) break; - lseek (filedes, (ROOT + 1L) * BLOCKLEN, 0); + lseek (g->fd, hdr_offset + ((ROOT + 1L) * BLOCKLEN), SEEK_SET); panic (); } - close (filedes); - - if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ - + gbl_close (g); + gbl_unlock (g); + gbl_open (g, action); + /* close new file, so other users can find it */ return; } - olddes[inuse] = filedes; /* save current filedescriptor */ - /* request global for exclusive use */ /* odd numbered actions get read access (get_sym,data,fra_order) 3 */ /* even ones read/write access (set_sym,kill_sym) 1 */ -lock: +/* temporarily disabled + lock: +*/ if (action == get_sym) { tfast0: - - if (lonelyflag == FALSE) locking (filedes, 3, 0L); - if (tryfast) goto tfast1; /* try again last block */ + gbl_lock (g, 3); + + if (g->fast_path > 0) goto tfast1; /* try again last block */ - blknbr = oldblk = ROOT; /* start with ROOT block */ + blknbr = g->last_block = ROOT; /* start with ROOT block */ for (;;) { tfast1: + gbl_read_block (g, blknbr, block); - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); - - -tfast2: - - if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */ - - offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); - j = UNSIGN (block[0]); - i = 0; - - stcpy0 (key1, &block[2], j); /* get first key */ - - ch = keyl; /* ch is a register! */ - - while (i < offset) { - - j = UNSIGN (block[i++]); /* length of key - offset */ - k = UNSIGN (block[i++]); /* offset into previous entry */ - -#ifdef VERSNEW +/* temporarily disabled + tfast2: +*/ + if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */ - stcpy0 (&key0[k], &block[i], j); - i += j; - j += k; - -#else + offset = UNSIGN (block[OFFS]) * 256 + + UNSIGN (block[OFFS + 1]); + j = UNSIGN (block[0]); + i = 0; - j += k; + stcpy0 (key1, &block[2], j); /* get first key */ - while (k < j) key1[k++] = block[i++]; /* get key */ - -#endif /* VERSNEW */ - - if (j != ch) { /* keys have different length */ + ch = keyl; /* ch is a register! */ + + while (i < offset) { + + j = UNSIGN (block[i++]); /* length of key - offset */ + k = UNSIGN (block[i++]); /* offset into previous entry */ + + j += k; + + while (k < j) key1[k++] = block[i++]; /* get key */ + + if (j != ch) { /* keys have different length */ + + i += UNSIGN (block[i]); + i++; + + continue; + + } + + j = ch; + + do { + j--; + } while (compactkey[j] == key1[j]); /* compare keys */ + + + if (j < 0) { + + k = UNSIGN (block[i++]); + stcpy0 (data, &block[i], k); /* get value */ + data[k] = EOL1; /* append EOL */ + + goto quit; + + } i += UNSIGN (block[i]); - i++; - - continue; - + i++; /* skip data */ + + } + + /* fast access failed. try normal path */ + if (tryfast) { + gbl_cache_miss (g); + goto tfast0; } - /* key1[j]=g_EOL; */ - j = ch; + merr_raise (M7); + data[0] = EOL; - do { - j--; - } while (compactkey[j] == key1[j]); /* compare keys */ + goto quit; /* variable not found */ + } + else { - - if (j < 0) { + if (g->fast_path > 0) { + gbl_cache_miss (g); + goto tfast0; + } + + if (typ == EMPTY) { - k = UNSIGN (block[i++]); - stcpy0 (data, &block[i], k); /* get value */ - data[k] = EOL1; /* append EOL */ - + if (blknbr == ROOT) { + gbl_close (g); + goto reopen; + } + + merr_raise (DBDGD); goto quit; - + } - - i += UNSIGN (block[i]); - i++; /* skip data */ - - } - - /* fast access failed. try normal path */ - if (tryfast) { - tryfast = FALSE; - goto tfast0; + } - - merr_raise (M7); - data[0] = EOL; - goto quit; /* variable not found */ - } - else { - - if (tryfast) { - tryfast = FALSE; - goto tfast0; - } - - if (typ == EMPTY) { - - if (blknbr == ROOT) { - close (filedes); - goto reopen; - } - + scanpblk (block, &addr, &found); + + addr += UNSIGN (block[addr]) + 2; /* skip key */ + + if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) { merr_raise (DBDGD); goto quit; - } - } - - scanpblk (block, &addr, &found); - - addr += UNSIGN (block[addr]) + 2; /* skip key */ + addr += PLEN; /* skip data */ + g->last_block = blknbr; + g->fast_path = 1; - if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == oldblk) { - merr_raise (DBDGD); - goto quit; - } - - addr += PLEN; /* skip data */ - oldblk = blknbr; - - if (merr () == INRPT) goto quit; + if (merr () == INRPT) goto quit; } } /* end of get_sym */ - - if (lonelyflag == FALSE) locking (filedes, (action & 01 ? 3 : 1), 0L); - + gbl_lock (g, action & 01 ? 3 : 1); + /* a KILL on an unsubscripted global deletes the entire file */ if (action == kill_sym && compactkey[0] == g_EOL) { - lseek (filedes, ROOT, 0); - - /* note : UNIX does not tell other */ - block[BTYP] = EMPTY; /* jobs that a file has been unlinked */ - + /* note : UNIX does not tell other jobs that a file has been unlinked */ /* as long as they keep it open. */ /* so we mark this global as EMPTY */ - write (filedes, block, BLOCKLEN); - - if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ - - close (filedes); - - olddes[inuse] = 0; - oldfil[inuse][0] = NUL; - usage[inuse] = 0; + block[BTYP] = EMPTY; + + gbl_write_block (g, ROOT, block); + + gbl_unlock (g); + gbl_close (g); unlink (filnam); @@ -982,7 +1299,7 @@ tfast2: k_again: /* entry point for repeated kill operations */ /* scan tree for the proper position of key */ - blknbr = oldblk = ROOT; /* start with ROOT block */ + blknbr = g->last_block = ROOT; /* start with ROOT block */ trx = (-1); for (;;) { @@ -994,10 +1311,8 @@ k_again: /* entry point for repeated traceblk[trx] = blknbr; traceadr[trx] = 0; - - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); - + + gbl_read_block (g, blknbr, block); typ = block[BTYP]; if (typ == DATA) { @@ -1008,7 +1323,7 @@ k_again: /* entry point for repeated if (typ == EMPTY) { if (blknbr == ROOT) { - close (filedes); + gbl_close (g); goto reopen; } @@ -1022,13 +1337,14 @@ k_again: /* entry point for repeated addr += UNSIGN (block[addr]); addr += 2; /* skip key */ - if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == oldblk) { + if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) { merr_raise (DBDGD); goto quit; } addr += PLEN; /* skip data */ - oldblk = blknbr; + g->last_block = blknbr; + g->fast_path = 1; } traceadr[trx] = addr; @@ -1039,7 +1355,7 @@ k_again: /* entry point for repeated datal = stlen (data); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (found != 2) { /* new entry */ @@ -1065,7 +1381,8 @@ k_again: /* entry point for repeated } -s10: { +s10: + { long len; /* insert key */ char key0[256]; @@ -1163,10 +1480,9 @@ s10: { } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + gbl_write_block (g, blknbr, block); - if (traceadr[trx] == 0) update (filedes, compactkey, keyl); + if (traceadr[trx] == 0) update (g, compactkey, keyl); break; } @@ -1208,7 +1524,6 @@ s10: { } else { - /* if (j1<0) */ /* we need more space */ if ((offset - j1) > DATALIM) { @@ -1218,7 +1533,7 @@ s10: { goto splitd; } -s20: + s20: i = offset; k = addr + olddatal; @@ -1251,12 +1566,13 @@ s20: } stcpy0 (&block[++addr], data, (long) datal); - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + + gbl_write_block (g, blknbr, block); + break; - case dat: + case fra_dat: data[0] = '0'; data[1] = EOL1; @@ -1277,14 +1593,13 @@ s20: /* get following entry, eventually in the next blk */ offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (addr >= offset) { if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]))) { - - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + + gbl_read_block (g, blknbr, block); j1 = UNSIGN (block[0]); i = 0; @@ -1365,9 +1680,8 @@ s20: goto quit; } /* no next block */ - - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + + gbl_read_block (g, blknbr, block); scandblk (block, &addr, &found); } @@ -1414,7 +1728,7 @@ s20: while (i < keyl) if (compactkey[i++] & 01) - j1++; + j1++; i = 0; j = 0; k = 0; @@ -1447,8 +1761,8 @@ s20: while ((ch = UNSIGN (scratch[i++])) != g_EOL) { ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -1523,12 +1837,11 @@ s20: goto quit; /* no next block */ } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + gbl_read_block (g, blknbr, block); addr = 0; offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); } } @@ -1547,8 +1860,7 @@ s20: goto quit; /* no next block */ } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + gbl_read_block (g, blknbr, block); addr = 0; } @@ -1596,8 +1908,8 @@ s20: while ((ch = UNSIGN (key0[i++])) != g_EOL) { ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -1673,8 +1985,8 @@ s20: } ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -1718,7 +2030,7 @@ s20: case kill_sym: /* search and destroy */ -killo: /* entry from killone section */ + killo: /* entry from killone section */ offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); i = 0; @@ -1757,32 +2069,30 @@ killo: /* entry from killone section other = traceblk[--trx]; addr = traceadr[trx]; - - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + + gbl_read_block (g, other, block); addr += UNSIGN (block[addr]); addr += (2 + PLEN); /* skip previous entry */ offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); traceadr[trx] = addr; if (addr < offset) break; traceadr[trx] = 0; traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); } trx = trxsav; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + gbl_read_block (g, blknbr, block); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); addr = 0; k = UNSIGN (block[0]); stcpy0 (key0, &block[2], k); @@ -1871,47 +2181,43 @@ killo: /* entry from killone section if ((begadr == 0) && (endadr == offset)) { /* block becomes empty */ long left, - right; + right; char block0[BLOCKLEN]; -p_empty: /* entry if pointer block goes empty */ + p_empty: /* entry if pointer block goes empty */ left = UNSIGN (block[LLPTR]) * 65536 + - UNSIGN (block[LLPTR + 1]) * 256 + - UNSIGN (block[LLPTR + 2]); + UNSIGN (block[LLPTR + 1]) * 256 + + UNSIGN (block[LLPTR + 2]); right = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); if (left) { - lseek (filedes, (long) left * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, left, block0); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; - - lseek (filedes, (long) left * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, left, block0); } if (right) { - - lseek (filedes, (long) right * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + + gbl_read_block (g, right, block0); block0[LLPTR] = block[LLPTR]; block0[LLPTR + 1] = block[LLPTR + 1]; block0[LLPTR + 2] = block[LLPTR + 2]; - - lseek (filedes, (long) right * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, right, block0); } - b_free (filedes, blknbr); /* modify free list */ + b_free (g, blknbr); /* modify free list */ /* delete pointer */ /**************************/ @@ -1924,10 +2230,9 @@ p_empty: /* entry if pointer block goes blknbr = traceblk[--trx]; addr = traceadr[trx]; - lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + gbl_read_block (g, blknbr, block); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); freecnt = UNSIGN (block[addr]) + 2 + PLEN; /* delete key */ @@ -1937,18 +2242,19 @@ p_empty: /* entry if pointer block goes if (blknbr == ROOT) { /* global went empty */ - lseek (filedes, 0L, 0); + /* note : UNIX does not tell other */ block[BTYP] = EMPTY; /* jobs that a file has been unlinked */ /* as long as they keep it open. */ /* so we mark this global as EMPTY */ - write (filedes, block, BLOCKLEN); - close (filedes); + gbl_write_block (g, 0L, block); + + gbl_close (g); unlink (filnam); - - if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ + + gbl_unlock (g); olddes[inuse] = 0; oldfil[inuse][0] = NUL; @@ -1969,13 +2275,12 @@ p_empty: /* entry if pointer block goes for (i = offset; i < offset + freecnt; block[i++] = 0); - lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + gbl_write_block (g, blknbr, block); if (addr == 0) { /* update of pointer */ traceadr[trx] = 0; - update (filedes, &block[2], (long) UNSIGN (block[0])); + update (g, &block[2], (long) UNSIGN (block[0])); } trx = trxsav; @@ -2000,28 +2305,29 @@ p_empty: /* entry if pointer block goes j = block[begadr + 1]; k = 0; if (begadr) - while (key0[k] == key1[k]) - k++; /* new key_offset */ + while (key0[k] == key1[k]) + k++; /* new key_offset */ if (k < j) { - ch = j - k; /* space requirement */ - block[begadr] = i + ch; /* new key_length */ - block[begadr + 1] = k; /* new key_offset */ - i = offset; - j = i + ch; - offset = j; - begadr++; - while (i > begadr) - block[j--] = block[i--]; - stcpy0 (&block[begadr + 1], &key0[k], ch); + ch = j - k; /* space requirement */ + block[begadr] = i + ch; /* new key_length */ + block[begadr + 1] = k; /* new key_offset */ + i = offset; + j = i + ch; + offset = j; + begadr++; + while (i > begadr) + block[j--] = block[i--]; + stcpy0 (&block[begadr + 1], &key0[k], ch); } } block[OFFS] = offset / 256; block[OFFS + 1] = offset % 256; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + + gbl_write_block (g, blknbr, block); + if (addr < 3) { /* update of pointer */ - traceadr[trx] = 0; - update (filedes, &block[2], (long) UNSIGN (block[0])); + traceadr[trx] = 0; + update (g, &block[2], (long) UNSIGN (block[0])); } } @@ -2029,7 +2335,7 @@ p_empty: /* entry if pointer block goes break; -zinv: + zinv: { long len; @@ -2043,12 +2349,11 @@ zinv: data[0] = EOL1; goto quit; } /* no previous block */ - - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + + gbl_read_block (g, blknbr, block); addr = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); } @@ -2123,8 +2428,8 @@ zinv: while ((ch = UNSIGN (scratch[i++])) != g_EOL) { ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -2169,167 +2474,142 @@ zinv: case zdata: /* nonstandard data function */ - { - long counties[128]; - char key0[256]; - int icnt, icnt0, len; + { + long counties[128]; + char key0[256]; + int icnt, icnt0, len; - i = 0; + i = 0; - while (i < 128) counties[i++] = 0L; /* init count; */ + while (i < 128) counties[i++] = 0L; /* init count; */ - if (found == 2) { /* ... advance to next entry */ - addr += UNSIGN (block[addr]); - addr += 2; /* skip key */ - addr += UNSIGN (block[addr]); - addr++; /* skip data */ + if (found == 2) { /* ... advance to next entry */ + addr += UNSIGN (block[addr]); + addr += 2; /* skip key */ + addr += UNSIGN (block[addr]); + addr++; /* skip data */ - counties[0] = 1L; - } + counties[0] = 1L; + } - offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); - icnt = 0; - i = 0; + offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); + icnt = 0; + i = 0; - while ((ch = compactkey[i++]) != g_EOL) { - - if (ch & 01) { - icnt++; - } + while ((ch = compactkey[i++]) != g_EOL) { + if (ch & 01) { + icnt++; } - len = i - 1; - i = 0; + } - while (i < addr) { /* compute offset complete key */ + len = i - 1; + i = 0; + + while (i < addr) { /* compute offset complete key */ - icnt0 = UNSIGN (block[i++]); - icnt0 += (j = UNSIGN (block[i++])); + icnt0 = UNSIGN (block[i++]); + icnt0 += (j = UNSIGN (block[i++])); - while (j < icnt0) key0[j++] = block[i++]; + while (j < icnt0) key0[j++] = block[i++]; - key0[j] = g_EOL; - i += UNSIGN (block[i]); + key0[j] = g_EOL; + i += UNSIGN (block[i]); - i++; /* skip data */ + i++; /* skip data */ - } + } - for (;;) { /* is it still a descendant ??? */ + for (;;) { /* is it still a descendant ??? */ - if (addr >= offset) { /* look in next block */ + if (addr >= offset) { /* look in next block */ - if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) { - break; /* no next block */ - } + if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) { + break; /* no next block */ + } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + gbl_read_block (g, blknbr, block); - addr = 0; - offset = UNSIGN (block[OFFS]) * 256 + + addr = 0; + offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); - } + } - i = UNSIGN (block[addr++]); - i += (j = UNSIGN (block[addr++])); + i = UNSIGN (block[addr++]); + i += (j = UNSIGN (block[addr++])); - while (j < i) key0[j++] = block[addr++]; + while (j < i) key0[j++] = block[addr++]; - addr += UNSIGN (block[addr]); - addr++; /* skip data */ - icnt0 = 0; - i = 0; + addr += UNSIGN (block[addr]); + addr++; /* skip data */ + icnt0 = 0; + i = 0; - while (i < j) if (key0[i++] & 01) + while (i < j) if (key0[i++] & 01) - icnt0++; + icnt0++; - if (icnt0 <= icnt) break; + if (icnt0 <= icnt) break; - i = 0; + i = 0; - while (i < len) { + while (i < len) { - if (key0[i] != compactkey[i]) break; + if (key0[i] != compactkey[i]) break; - i++; + i++; - } + } - if (i < len) break; + if (i < len) break; - counties[icnt0 - icnt]++; + counties[icnt0 - icnt]++; - } + } - i = 128; + i = 128; - while (counties[--i] == 0L); + while (counties[--i] == 0L); - lintstr (data, counties[0]); + lintstr (data, counties[0]); - j = 1; - tmp1[0] = ','; + j = 1; + tmp1[0] = ','; - while (j <= i) { - lintstr (&tmp1[1], counties[j++]); - stcat (data, tmp1); - } - + while (j <= i) { + lintstr (&tmp1[1], counties[j++]); + stcat (data, tmp1); } + + } - break; + break; case getinc: - { - int setopsav; + { + int setopsav; - setopsav = setop; - setop = '+'; - data[0] = '1'; - data[1] = EOL; + setopsav = setop; + setop = '+'; + data[0] = '1'; + data[1] = EOL; - global (set_sym, key, data); + global (set_sym, key, data); - setop = setopsav; + setop = setopsav; - return; - } + return; + } case killone: - - { - if (found == 2) goto killo; /* entry found use normal kill routine */ + { + if (found == 2) goto killo; /* entry found use normal kill routine */ - goto quit; - } - - case merge_sym: - - printf("MERGE NOT IMPLEMENTED FOR GLOBALS\n"); - -#ifdef DEBUG_GBL - - int loop; - - printf ("DEBUG MERGE: "); - printf ("[key] is ["); - - for (loop = 0; key[loop] != EOL; loop++) printf ("%c", (key[loop] == DELIM) ? '!' : key[loop]); - - printf ("]\r\n"); - printf ("[data] is ["); - - for(loop = 0; data[loop] != EOL; loop++) printf ("%c", (data[loop] == DELIM) ? '!' : data[loop]); - - printf("]\r\n"); - -#endif - return; + goto quit; + } default: @@ -2340,10 +2620,9 @@ quit: /* clean things up */ - lseek (filedes, ROOT, 0); - - if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ - + lseek (g->fd, hdr_offset + ROOT, SEEK_SET); + gbl_unlock (g); + return; @@ -2354,7 +2633,7 @@ splitd: /* split data block in two se /* 'addr' there I would like to insert, if possible (which is not) */ /* 'offset' filled up to this limit */ - getnewblk (filedes, &newblk); /* get a new block */ + getnewblk (g, &newblk); /* get a new block */ /* if we have to insert at the begin or end of a block */ /* we don't split - we just start a new block */ @@ -2362,8 +2641,8 @@ splitd: /* split data block in two se if (addr >= offset) { long right, - right1, - right2; + right1, + right2; right = UNSIGN (block[RLPTR]); right1 = UNSIGN (block[RLPTR + 1]); @@ -2372,8 +2651,7 @@ splitd: /* split data block in two se block[RLPTR + 1] = newblk % 65536 / 256; block[RLPTR + 2] = newblk % 256; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + gbl_write_block (g, blknbr, block); block[RLPTR] = right; block[RLPTR + 1] = right1; @@ -2385,23 +2663,21 @@ splitd: /* split data block in two se addr = 0; blknbr = newblk; - insert (filedes, compactkey, keyl, newblk); + insert (g, compactkey, keyl, newblk); /* up-date LL-PTR of RL-block */ if ((other = right * 65536 + right1 * 256 + right2)) { char block0[BLOCKLEN]; - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, other, block0); block0[LLPTR] = blknbr / 65536; block0[LLPTR + 1] = blknbr % 65536 / 256; block0[LLPTR + 2] = blknbr % 256; - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); - + gbl_write_block (g, other, block0); + } goto spltex; @@ -2418,9 +2694,8 @@ splitd: /* split data block in two se block[LLPTR + 1] = newblk % 65536 / 256; block[LLPTR + 2] = newblk % 256; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); - + gbl_write_block (g, blknbr, block); + block[LLPTR] = left; block[LLPTR + 1] = left1; block[LLPTR + 2] = left2; @@ -2431,26 +2706,26 @@ splitd: /* split data block in two se blknbr = newblk; traceadr[trx] = (-1); /* inhibit second update of pointers */ - insert (filedes, compactkey, keyl, newblk); + insert (g, compactkey, keyl, newblk); if (addr < 3) { /* update of pointer */ traceadr[trx] = 0; - update (filedes, compactkey, keyl); + update (g, compactkey, keyl); } /* other is ***always*** zero !!! - * if (other=left*65536+left1*256+left2) up-date RL-PTR of LL-block - * { char block0[BLOCKLEN]; - * lseek(filedes,(long)other*(long)(BLOCKLEN),0); - * read(filedes,block0,BLOCKLEN); - * block0[RLPTR ]=blknbr/65536; - * block0[RLPTR+1]=blknbr%65536/256; - * block0[RLPTR+2]=blknbr%256; - * lseek(filedes,(long)other*(long)(BLOCKLEN),0); - * write(filedes,block0,BLOCKLEN); - * } - */ + * if (other=left*65536+left1*256+left2) up-date RL-PTR of LL-block + * { char block0[BLOCKLEN]; + * lseek(filedes,(long)other*(long)(BLOCKLEN),0); + * read(filedes,block0,BLOCKLEN); + * block0[RLPTR ]=blknbr/65536; + * block0[RLPTR+1]=blknbr%65536/256; + * block0[RLPTR+2]=blknbr%256; + * lseek(filedes,(long)other*(long)(BLOCKLEN),0); + * write(filedes,block0,BLOCKLEN); + * } + */ goto spltex; @@ -2532,8 +2807,8 @@ splitd: /* split data block in two se /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; @@ -2544,26 +2819,23 @@ splitd: /* split data block in two se block0[LLPTR + 1] = blknbr % 65536 / 256; block0[LLPTR + 2] = blknbr % 256; - lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + gbl_write_block (g, newblk, block0); offset = limit; /* insert new block in pointer structure */ - insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, other, block0); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, other, block0); } @@ -2572,8 +2844,8 @@ splitd: /* split data block in two se /* save old block away and make new block the current block */ /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; @@ -2584,28 +2856,26 @@ splitd: /* split data block in two se block0[LLPTR + 1] = blknbr % 65536 / 256; block0[LLPTR + 2] = blknbr % 256; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + gbl_write_block (g, blknbr, block); + stcpy0 (block, block0, (long) BLOCKLEN); traceadr[trx] = (addr -= limit); traceblk[trx] = (blknbr = newblk); /* insert new block in pointer structure */ - insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, other, block0); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, other, block0); } @@ -2632,7 +2902,7 @@ spltex: * 'addr' there I would like to insert, if possible (which is not) * 'offset' filled up to this limit */ -static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr) +static void splitp (global_handle *g, char *block, long *addr, long *offs, unsigned long *blknbr) { char block0[BLOCKLEN]; @@ -2640,8 +2910,8 @@ static void splitp (short filedes, char unsigned long newblk; unsigned long other; register int i, j; - - getnewblk (filedes, &newblk); /* get a new block */ + + getnewblk (g, &newblk); /* get a new block */ if (*blknbr == ROOT) { /* ROOT overflow is special */ @@ -2668,16 +2938,15 @@ static void splitp (short filedes, char /* update number of blocks ! */ i = UNSIGN (block0[NRBLK]) * 65536 + - UNSIGN (block0[NRBLK + 1]) * 256 + - UNSIGN (block0[NRBLK + 2]) + 1; + UNSIGN (block0[NRBLK + 1]) * 256 + + UNSIGN (block0[NRBLK + 2]) + 1; block0[NRBLK] = i / 65536; block0[NRBLK + 1] = i % 65536 / 256; block0[NRBLK + 2] = i % 256; block0[BTYP] = POINTER; - lseek (filedes, ROOT, 0); - write (filedes, block0, BLOCKLEN); + gbl_write_block (g, ROOT, block0); /* shift trace_stack */ j = trx++; @@ -2694,7 +2963,7 @@ static void splitp (short filedes, char traceblk[1] = newblk; *blknbr = newblk; - getnewblk (filedes, &newblk); /* get a new block */ + getnewblk (g, &newblk); /* get a new block */ } @@ -2736,8 +3005,8 @@ static void splitp (short filedes, char /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; @@ -2748,25 +3017,22 @@ static void splitp (short filedes, char block0[LLPTR + 1] = (*blknbr) % 65536 / 256; block0[LLPTR + 2] = (*blknbr) % 256; - lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + gbl_write_block (g, newblk, block0); (*offs) = limit; - insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, other, block0); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, other, block0); } @@ -2775,8 +3041,8 @@ static void splitp (short filedes, char /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; @@ -2790,27 +3056,25 @@ static void splitp (short filedes, char (*addr) -= limit; (*offs) -= limit; + + gbl_write_block (g, *blknbr, block); - lseek (filedes, (long) (*blknbr) * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); stcpy0 (block, block0, (long) BLOCKLEN); (*blknbr) = newblk; - insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, other, block0); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, other, block0); } @@ -2825,23 +3089,22 @@ static void splitp (short filedes, char * ins_key: key to be inserted * keyl: length of that key */ -static void update (short filedes, char *ins_key, long keyl) +static void update (global_handle *g, char *ins_key, long keyl) { long offset; long addr; unsigned long blknbr; char block[BLOCKLEN]; long i, j, k; - + while (traceadr[trx] == 0) { /* update of pointer blocks necessary */ if (--trx < 0) break; blknbr = traceblk[trx]; addr = traceadr[trx]; - - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + + gbl_read_block (g, blknbr, block); { long oldkeyl; @@ -2852,7 +3115,7 @@ static void update (short filedes, char j = oldkeyl - keyl; offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (j > 0) { /* surplus space */ @@ -2868,7 +3131,7 @@ static void update (short filedes, char else if (j < 0) { /* we need more space */ /* block too small */ - if ((offset - j) > DATALIM) splitp (filedes, block, &addr, &offset, &blknbr); + if ((offset - j) > DATALIM) splitp (g, block, &addr, &offset, &blknbr); i = offset; offset -= j; @@ -2891,13 +3154,10 @@ static void update (short filedes, char while (i < keyl) block[j++] = ins_key[i++]; /* block pointed to remains the same */ - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); - + gbl_write_block (g, blknbr, block); } - - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + + gbl_read_block (g, blknbr, block); } @@ -2912,7 +3172,7 @@ static void update (short filedes, char * key_len: length of that key * blknbr: key points to this block */ -static void insert (int filedes, char *ins_key, long key_len, unsigned long blknbr) /* insert pointer */ +static void insert (global_handle *g, char *ins_key, long key_len, unsigned long blknbr) /* insert pointer */ { unsigned long blk; char block[BLOCKLEN]; @@ -2921,16 +3181,15 @@ static void insert (int filedes, char *i long needed; long addr; register int i, k; - + trxsav = trx--; blk = traceblk[trx]; addr = traceadr[trx]; - lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + gbl_read_block (g, blk, block); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (traceadr[trx + 1] != (-1)) { addr += UNSIGN (block[addr]); @@ -2939,7 +3198,7 @@ static void insert (int filedes, char *i needed = key_len + 2 + PLEN; - if ((offset + needed) > DATALIM) splitp (filedes, block, &addr, &offset, &blk); + if ((offset + needed) > DATALIM) splitp (g, block, &addr, &offset, &blk); /* insert key */ i = (offset += needed); @@ -2963,8 +3222,7 @@ static void insert (int filedes, char *i block[i++] = blknbr % 65536 / 256; block[i] = blknbr % 256; - lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + gbl_write_block (g, blk, block); trx = trxsav; @@ -2976,37 +3234,33 @@ static void insert (int filedes, char *i * filedes: global file descriptor * blknbr: block to be freed */ -static void b_free (short filedes, unsigned long blknbr) +static void b_free (global_handle *g, unsigned long blknbr) { char block0[BLOCKLEN]; unsigned long free; unsigned long other; long i; long offset; - + /* mark block as empty */ - lseek (filedes, (long) (blknbr) * BLOCKLEN, 0); - read (filedes, block0, BLOCKLEN); - - block0[BTYP] = EMPTY; + gbl_read_block (g, blknbr, block0); - lseek (filedes, (long) (blknbr) * BLOCKLEN, 0); - write (filedes, block0, BLOCKLEN); + block0[BTYP] = EMPTY; + + gbl_write_block (g, blknbr, block0); /* do we have a list of free blocks? */ - lseek (filedes, ROOT, 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, ROOT, block0); if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) { for (;;) { - - lseek (filedes, (long) free * (long) BLOCKLEN, 0); - read (filedes, block0, BLOCKLEN); + + gbl_read_block (g, free, block0); other = UNSIGN (block0[RLPTR]) * 65536 + - UNSIGN (block0[RLPTR + 1]) * 256 + - UNSIGN (block0[RLPTR + 2]); + UNSIGN (block0[RLPTR + 1]) * 256 + + UNSIGN (block0[RLPTR + 2]); if (other == 0) break; @@ -3022,8 +3276,8 @@ static void b_free (short filedes, unsig offset -= PLEN; other = UNSIGN (block0[offset]) * 65536 + - UNSIGN (block0[offset + 1]) * 256 + - UNSIGN (block0[offset + 2]); + UNSIGN (block0[offset + 1]) * 256 + + UNSIGN (block0[offset + 2]); block0[offset] = 0; block0[offset + 1] = 0; @@ -3033,9 +3287,8 @@ static void b_free (short filedes, unsig block0[RLPTR] = other / 65536; block0[RLPTR + 1] = other % 65536 / 256; block0[RLPTR + 2] = other % 256; - - lseek (filedes, (long) free * (long) BLOCKLEN, 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, free, block0); for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */ @@ -3051,19 +3304,16 @@ static void b_free (short filedes, unsig } else { - - getnewblk (filedes, &free); + getnewblk (g, &free); /* set FBLK free blocks pointer */ - lseek (filedes, ROOT, 0); - read (filedes, block0, BLOCKLEN); + gbl_read_block (g, ROOT, block0); block0[FREE] = free / 65536; block0[FREE + 1] = free % 65536 / 256; block0[FREE + 2] = free % 256; - - lseek (filedes, ROOT, 0); - write (filedes, block0, BLOCKLEN); + + gbl_write_block (g, ROOT, block0); for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */ @@ -3078,8 +3328,7 @@ static void b_free (short filedes, unsig block0[OFFS] = offset / 256; block0[OFFS + 1] = offset % 256; - lseek (filedes, (long) free * (long) BLOCKLEN, 0); - write (filedes, block0, BLOCKLEN); + gbl_write_block (g, free, block0); return; } /* end of b_free() */ @@ -3152,7 +3401,7 @@ static void scandblk (char *block, long char key0[256]; offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); while (i < offset) { @@ -3199,23 +3448,21 @@ static void scandblk (char *block, long * filedes: global file descriptor * blknbr: number of new block */ -static void getnewblk (int filedes, unsigned long *blknbr) +static void getnewblk (global_handle *g, unsigned long *blknbr) { char nblock[BLOCKLEN]; unsigned long freeblks, no_of_blks; long other; long offset; - lseek (filedes, ROOT, 0); - read (filedes, nblock, BLOCKLEN); + gbl_read_block (g, ROOT, nblock); freeblks = UNSIGN (nblock[FREE]) * 65536 + UNSIGN (nblock[FREE + 1]) * 256 + UNSIGN (nblock[FREE + 2]); no_of_blks = UNSIGN (nblock[NRBLK]) * 65536 + UNSIGN (nblock[NRBLK + 1]) * 256 + UNSIGN (nblock[NRBLK + 2]); if (freeblks) { - - lseek (filedes, (long) (freeblks) * BLOCKLEN, 0); - read (filedes, nblock, BLOCKLEN); + + gbl_read_block (g, freeblks, nblock); offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]); @@ -3227,28 +3474,24 @@ static void getnewblk (int filedes, unsi /* update RL-block, if any */ if (other) { - lseek (filedes, (long) (other) * BLOCKLEN, 0); - read (filedes, nblock, BLOCKLEN); + gbl_read_block (g, other, nblock); nblock[LLPTR] = 0; nblock[LLPTR + 1] = 0; nblock[LLPTR + 2] = 0; - - lseek (filedes, (long) (other) * BLOCKLEN, 0); - write (filedes, nblock, BLOCKLEN); + + gbl_write_block (g, other, nblock); } /* update ROOT block */ - lseek (filedes, ROOT, 0); - read (filedes, nblock, BLOCKLEN); + gbl_read_block (g, ROOT, nblock); nblock[FREE] = other / 65536; nblock[FREE + 1] = other % 65536 / 256; nblock[FREE + 2] = other % 256; - - lseek (filedes, ROOT, 0); - write (filedes, nblock, BLOCKLEN); + + gbl_write_block (g, ROOT, nblock); return; @@ -3260,9 +3503,8 @@ static void getnewblk (int filedes, unsi nblock[offset + 1] = 0; nblock[OFFS] = offset / 256; nblock[OFFS + 1] = offset % 256; - - lseek (filedes, (long) (freeblks) * BLOCKLEN, 0); - write (filedes, nblock, BLOCKLEN); + + gbl_write_block (g, freeblks, nblock); return; @@ -3273,24 +3515,12 @@ static void getnewblk (int filedes, unsi nblock[NRBLK] = no_of_blks / 65536; nblock[NRBLK + 1] = no_of_blks % 65536 / 256; nblock[NRBLK + 2] = no_of_blks % 256; - - lseek (filedes, ROOT, 0); - write (filedes, nblock, BLOCKLEN); + + gbl_write_block (g, ROOT, nblock); *blknbr = no_of_blks; - - for (;;) { - errno = 0; - - lseek (filedes, (long) (no_of_blks) * BLOCKLEN, 0); - write (filedes, nblock, BLOCKLEN); - - if (errno == 0) break; - - panic (); - - } + gbl_write_block (g, no_of_blks, nblock); return; @@ -3419,7 +3649,6 @@ static short int g_collate (char *t) /* * test whether 'str' is canonical */ -//static short int g_numeric (char *str) short g_numeric (char *str) { register int ptr = 0, ch; @@ -3462,30 +3691,19 @@ short g_numeric (char *str) } /* end g_numeric() */ + +/* DEPRECATED: use gbl_close_all() instead */ void close_all_globals (void) { - register int i; - - for (i = 0; i < NO_GLOBLS; i++) { - - if (oldfil[i][0] != NUL) { - - close (olddes[i]); - - usage[i] = 0; - olddes[i] = 0; - oldfil[i][0] = NUL; - - } - - } - + gbl_close_all (); + return; - } /* end close_all_globals() */ static void panic (void) -{ +{ + printf ("write failed\r\n"); + printf ("\033[s\033[25H\033[5;7mwrite needs more disk space immediately\007"); sleep (1); printf ("\033[m\007\033[2K\033[u"); @@ -3505,15 +3723,46 @@ static void panic (void) void gbl_dump_stat(void) { - register int i; - - printf ("FreeM Global Statistics [PID %d]\r\n", pid); - - printf ("%-10s%-20s%s\r\n", "USECT", "AGE", "FILE"); - printf ("%-10s%-20s%s\r\n", "=====", "===", "===="); - - for (i = 0; i < NO_GLOBLS; i++) { - printf ("%-10d%-20ld%s\r\n", usage[i], g_ages[i], oldfil[i]); - } + global_handle *g; + int ct; + int miss_pct; + int hit_pct; + unsigned long access_total; + unsigned long hit_total; + unsigned long mem_reads_total; + + mem_reads_total = 0; + printf ("\r\nFreeM Global Statistics [PID %d]\r\n\r\n", pid); + + printf ("%-20s%-10s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "GLOBAL", "USECT", "READS", "WRITES", "MEMREADS", "SLOW PTHCT", "AGE", "LAST BLK", "FILE"); + printf ("%-20s%-10s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "======", "=====", "=====", "======", "========", "==========", "===", "========", "===="); + + access_total = 0; + ct = 0; + for (g = global_handles_head; g != NULL; g = g->next) { + printf ("%-20s%-10ld%-10ld%-10ld%-10ld%-12ld%-20ld%-10ld%s\r\n", + g->global_name, + g->use_count, + g->read_ops, + g->write_ops, + g->memory_reads, + g->cache_misses, + g->age, + g->last_block, + g->global_path); + ct++; + mem_reads_total += g->memory_reads; + access_total += g->use_count; + } + if (!ct) printf ("\r\n"); + + hit_total = access_total - gbl_cache_misses; + miss_pct = (gbl_cache_misses * 100) / access_total; + hit_pct = (hit_total * 100) / access_total; + + printf ("\r\nTotal accesses: %ld\r\n", access_total); + printf ("Fast path hits %ld\t(%d%%)\r\n", hit_total, hit_pct); + printf ("Fast path misses: %ld\t(%d%%)\r\n", gbl_cache_misses, miss_pct); + printf ("Disk reads avoided: %ld\r\n", mem_reads_total); }