--- freem/src/global_bltin.c 2025/03/24 01:33:30 1.6 +++ freem/src/global_bltin.c 2025/04/10 01:24:38 1.15 @@ -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.15 2025/04/10 01:24:38 snw Exp $ * freem database engine * * @@ -24,6 +24,33 @@ * along with FreeM. If not, see . * * $Log: global_bltin.c,v $ + * 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 +70,25 @@ #include #include #include - +#include #include - #include "mpsdef.h" +#include "journal.h" +#include "global_bltin.h" + +global_handle *global_handles_head; +unsigned long gbl_cache_misses = 0; +unsigned long gbl_cache_hits = 0; 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); +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 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); @@ -105,6 +136,399 @@ static void panic (void); 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) { + 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() */ + +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_block = 0; + g->opened = FALSE; + g->fd = 0; + g->fast_path = -1; + g->cache_misses = 0; + g->cache_hits = 0; + + 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,34 +603,34 @@ 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]; @@ -214,17 +638,17 @@ void global_bltin (short action, char *k 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 */ - + 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 +725,8 @@ void global_bltin (short action, char *k } } - if (action == getnext) { + if (action == getnext) { getnflag = TRUE; varnam[0] = EOL; @@ -376,90 +800,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 */ + g = gbl_handle (key); + i = gbl_path (key, filnam); - 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; - - 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 +938,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; - } - - if (filedes == -1) { + gbl_open (g, action); + if (g->fd == -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 +951,7 @@ reopen: return; } - if (action == dat || action == zdata) { + if (action == fra_dat || action == zdata) { data[0] = '0'; data[1] = EOL1; @@ -714,15 +975,7 @@ reopen: merr_raise (PROTECT); return; } - - if (pathscan) { - savj = 0; - savch = ch = EOL; - pathscan = FALSE; - - goto nextpath; - } - + if (setop) { tmp1[0] = EOL; @@ -752,29 +1005,19 @@ 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); + lseek (g->fd, hdr_offset + (ROOT * BLOCKLEN), SEEK_SET); + write (g->fd, block, BLOCKLEN); if (errno == 0) break; @@ -795,51 +1038,51 @@ 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 */ +/* 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: - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); - + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); +/* temporarily disabled tfast2: - +*/ if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */ offset = UNSIGN (block[OFFS]) * 256 + @@ -856,20 +1099,10 @@ tfast2: j = UNSIGN (block[i++]); /* length of key - offset */ k = UNSIGN (block[i++]); /* offset into previous entry */ -#ifdef VERSNEW - - stcpy0 (&key0[k], &block[i], j); - i += j; - j += k; - -#else - j += k; while (k < j) key1[k++] = block[i++]; /* get key */ -#endif /* VERSNEW */ - if (j != ch) { /* keys have different length */ i += UNSIGN (block[i]); @@ -879,7 +1112,6 @@ tfast2: } - /* key1[j]=g_EOL; */ j = ch; do { @@ -904,7 +1136,7 @@ tfast2: /* fast access failed. try normal path */ if (tryfast) { - tryfast = FALSE; + gbl_cache_miss (g); goto tfast0; } @@ -915,15 +1147,15 @@ tfast2: } else { - if (tryfast) { - tryfast = FALSE; + if (g->fast_path > 0) { + gbl_cache_miss (g); goto tfast0; } if (typ == EMPTY) { if (blknbr == ROOT) { - close (filedes); + gbl_close (g); goto reopen; } @@ -938,41 +1170,36 @@ tfast2: addr += UNSIGN (block[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; 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); + lseek (g->fd, hdr_offset + ROOT, SEEK_SET); /* 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); - - if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ - - close (filedes); - - olddes[inuse] = 0; - oldfil[inuse][0] = NUL; - usage[inuse] = 0; + write (g->fd, block, BLOCKLEN); + + gbl_unlock (g); + gbl_close (g); unlink (filnam); @@ -982,7 +1209,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 (;;) { @@ -995,8 +1222,8 @@ k_again: /* entry point for repeated traceblk[trx] = blknbr; traceadr[trx] = 0; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); typ = block[BTYP]; @@ -1008,7 +1235,7 @@ k_again: /* entry point for repeated if (typ == EMPTY) { if (blknbr == ROOT) { - close (filedes); + gbl_close (g); goto reopen; } @@ -1022,13 +1249,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; @@ -1163,10 +1391,10 @@ s10: { } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); - if (traceadr[trx] == 0) update (filedes, compactkey, keyl); + if (traceadr[trx] == 0) update (g, compactkey, keyl); break; } @@ -1208,7 +1436,6 @@ s10: { } else { - /* if (j1<0) */ /* we need more space */ if ((offset - j1) > DATALIM) { @@ -1251,12 +1478,15 @@ s20: } stcpy0 (&block[++addr], data, (long) datal); - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); + + gbl_update_tid (g); + break; - case dat: + case fra_dat: data[0] = '0'; data[1] = EOL1; @@ -1283,8 +1513,8 @@ s20: 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); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); j1 = UNSIGN (block[0]); i = 0; @@ -1366,8 +1596,8 @@ s20: goto quit; } /* no next block */ - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); scandblk (block, &addr, &found); } @@ -1523,8 +1753,8 @@ s20: goto quit; /* no next block */ } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); addr = 0; offset = UNSIGN (block[OFFS]) * 256 + @@ -1547,8 +1777,8 @@ s20: goto quit; /* no next block */ } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); addr = 0; } @@ -1758,8 +1988,8 @@ killo: /* entry from killone section other = traceblk[--trx]; addr = traceadr[trx]; - lseek (filedes, (long) other * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); addr += UNSIGN (block[addr]); addr += (2 + PLEN); /* skip previous entry */ @@ -1778,8 +2008,8 @@ killo: /* entry from killone section trx = trxsav; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); @@ -1885,33 +2115,33 @@ p_empty: /* entry if pointer block goes if (left) { - lseek (filedes, (long) left * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) left * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) left * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); } if (right) { - lseek (filedes, (long) right * (long) (BLOCKLEN), 0); - read (filedes, block0, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) right * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) right * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); } - b_free (filedes, blknbr); /* modify free list */ + b_free (g->fd, blknbr); /* modify free list */ /* delete pointer */ /**************************/ @@ -1924,8 +2154,8 @@ p_empty: /* entry if pointer block goes blknbr = traceblk[--trx]; addr = traceadr[trx]; - lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) (blknbr) * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); freecnt = UNSIGN (block[addr]) + 2 + PLEN; @@ -1937,18 +2167,18 @@ p_empty: /* entry if pointer block goes if (blknbr == ROOT) { /* global went empty */ - lseek (filedes, 0L, 0); + lseek (g->fd, hdr_offset + 0L, SEEK_SET); /* 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); + write (g->fd, block, BLOCKLEN); + 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 +2199,13 @@ 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); + lseek (g->fd, hdr_offset + ((long) (blknbr) * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); 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; @@ -2017,11 +2247,11 @@ p_empty: /* entry if pointer block goes } block[OFFS] = offset / 256; block[OFFS + 1] = offset % 256; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); if (addr < 3) { /* update of pointer */ traceadr[trx] = 0; - update (filedes, &block[2], (long) UNSIGN (block[0])); + update (g, &block[2], (long) UNSIGN (block[0])); } } @@ -2044,8 +2274,8 @@ zinv: goto quit; } /* no previous block */ - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); addr = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); @@ -2224,8 +2454,8 @@ zinv: break; /* no next block */ } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); addr = 0; offset = UNSIGN (block[OFFS]) * 256 + @@ -2340,10 +2570,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 +2583,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->fd, &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 */ @@ -2372,8 +2601,8 @@ 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); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); block[RLPTR] = right; block[RLPTR + 1] = right1; @@ -2385,22 +2614,22 @@ 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); } @@ -2418,8 +2647,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); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); block[LLPTR] = left; block[LLPTR + 1] = left1; @@ -2431,12 +2660,12 @@ 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 !!! @@ -2544,26 +2773,26 @@ 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); + lseek (g->fd, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); } @@ -2584,28 +2813,28 @@ 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); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); } @@ -2632,7 +2861,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]; @@ -2641,7 +2870,11 @@ static void splitp (short filedes, char unsigned long other; register int i, j; - getnewblk (filedes, &newblk); /* get a new block */ + long hdr_offset; + + hdr_offset = sizeof (global_header); + + getnewblk (g->fd, &newblk); /* get a new block */ if (*blknbr == ROOT) { /* ROOT overflow is special */ @@ -2676,8 +2909,8 @@ static void splitp (short filedes, char block0[NRBLK + 2] = i % 256; block0[BTYP] = POINTER; - lseek (filedes, ROOT, 0); - write (filedes, block0, BLOCKLEN); + lseek (g->fd, hdr_offset + ROOT, SEEK_SET); + write (g->fd, block0, BLOCKLEN); /* shift trace_stack */ j = trx++; @@ -2694,7 +2927,7 @@ static void splitp (short filedes, char traceblk[1] = newblk; *blknbr = newblk; - getnewblk (filedes, &newblk); /* get a new block */ + getnewblk (g->fd, &newblk); /* get a new block */ } @@ -2748,25 +2981,25 @@ 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); + lseek (g->fd, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); (*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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); } @@ -2791,26 +3024,26 @@ static void splitp (short filedes, char (*addr) -= limit; (*offs) -= limit; - lseek (filedes, (long) (*blknbr) * (long) (BLOCKLEN), 0); - write (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) (*blknbr) * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block0, BLOCKLEN); 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); + lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block0, BLOCKLEN); } @@ -2825,14 +3058,17 @@ 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; + long hdr_offset; + hdr_offset = sizeof (global_header); + while (traceadr[trx] == 0) { /* update of pointer blocks necessary */ if (--trx < 0) break; @@ -2840,8 +3076,8 @@ static void update (short filedes, char blknbr = traceblk[trx]; addr = traceadr[trx]; - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); { long oldkeyl; @@ -2868,7 +3104,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 +3127,13 @@ 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); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); } - lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); } @@ -2912,7 +3148,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,13 +3157,16 @@ static void insert (int filedes, char *i long needed; long addr; register int i, k; + long hdr_offset; + hdr_offset = sizeof (global_header); + trxsav = trx--; blk = traceblk[trx]; addr = traceadr[trx]; - lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0); - read (filedes, block, BLOCKLEN); + lseek (g->fd, hdr_offset + ((long) (blk) * (long) (BLOCKLEN)), SEEK_SET); + read (g->fd, block, BLOCKLEN); offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); @@ -2939,7 +3178,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 +3202,8 @@ 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); + lseek (g->fd, hdr_offset + ((long) (blk) * (long) (BLOCKLEN)), SEEK_SET); + write (g->fd, block, BLOCKLEN); trx = trxsav; @@ -2983,25 +3222,28 @@ static void b_free (short filedes, unsig unsigned long other; long i; long offset; - + long hdr_offset; + + hdr_offset = sizeof (global_header); + /* mark block as empty */ - lseek (filedes, (long) (blknbr) * BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET); read (filedes, block0, BLOCKLEN); block0[BTYP] = EMPTY; - lseek (filedes, (long) (blknbr) * BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET); write (filedes, block0, BLOCKLEN); /* do we have a list of free blocks? */ - lseek (filedes, ROOT, 0); + lseek (filedes, hdr_offset + ROOT, SEEK_SET); read (filedes, block0, BLOCKLEN); if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) { for (;;) { - lseek (filedes, (long) free * (long) BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET); read (filedes, block0, BLOCKLEN); other = UNSIGN (block0[RLPTR]) * 65536 + @@ -3034,7 +3276,7 @@ static void b_free (short filedes, unsig block0[RLPTR + 1] = other % 65536 / 256; block0[RLPTR + 2] = other % 256; - lseek (filedes, (long) free * (long) BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET); write (filedes, block0, BLOCKLEN); for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */ @@ -3055,14 +3297,14 @@ static void b_free (short filedes, unsig getnewblk (filedes, &free); /* set FBLK free blocks pointer */ - lseek (filedes, ROOT, 0); + lseek (filedes, hdr_offset + ROOT, SEEK_SET); read (filedes, block0, BLOCKLEN); block0[FREE] = free / 65536; block0[FREE + 1] = free % 65536 / 256; block0[FREE + 2] = free % 256; - lseek (filedes, ROOT, 0); + lseek (filedes, hdr_offset + ROOT, SEEK_SET); write (filedes, block0, BLOCKLEN); for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */ @@ -3078,7 +3320,7 @@ static void b_free (short filedes, unsig block0[OFFS] = offset / 256; block0[OFFS + 1] = offset % 256; - lseek (filedes, (long) free * (long) BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET); write (filedes, block0, BLOCKLEN); return; @@ -3205,8 +3447,11 @@ static void getnewblk (int filedes, unsi unsigned long freeblks, no_of_blks; long other; long offset; + long hdr_offset; - lseek (filedes, ROOT, 0); + hdr_offset = sizeof (global_header); + + lseek (filedes, hdr_offset + ROOT, SEEK_SET); read (filedes, nblock, BLOCKLEN); freeblks = UNSIGN (nblock[FREE]) * 65536 + UNSIGN (nblock[FREE + 1]) * 256 + UNSIGN (nblock[FREE + 2]); @@ -3214,7 +3459,7 @@ static void getnewblk (int filedes, unsi if (freeblks) { - lseek (filedes, (long) (freeblks) * BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) (freeblks) * BLOCKLEN), SEEK_SET); read (filedes, nblock, BLOCKLEN); offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]); @@ -3227,27 +3472,27 @@ static void getnewblk (int filedes, unsi /* update RL-block, if any */ if (other) { - lseek (filedes, (long) (other) * BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET); read (filedes, nblock, BLOCKLEN); nblock[LLPTR] = 0; nblock[LLPTR + 1] = 0; nblock[LLPTR + 2] = 0; - lseek (filedes, (long) (other) * BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET); write (filedes, nblock, BLOCKLEN); } /* update ROOT block */ - lseek (filedes, ROOT, 0); + lseek (filedes, hdr_offset + ROOT, SEEK_SET); read (filedes, nblock, BLOCKLEN); nblock[FREE] = other / 65536; nblock[FREE + 1] = other % 65536 / 256; nblock[FREE + 2] = other % 256; - lseek (filedes, ROOT, 0); + lseek (filedes, hdr_offset + ROOT, SEEK_SET); write (filedes, nblock, BLOCKLEN); return; @@ -3261,7 +3506,7 @@ static void getnewblk (int filedes, unsi nblock[OFFS] = offset / 256; nblock[OFFS + 1] = offset % 256; - lseek (filedes, (long) (freeblks) * BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) (freeblks) * BLOCKLEN), SEEK_SET); write (filedes, nblock, BLOCKLEN); return; @@ -3274,7 +3519,7 @@ static void getnewblk (int filedes, unsi nblock[NRBLK + 1] = no_of_blks % 65536 / 256; nblock[NRBLK + 2] = no_of_blks % 256; - lseek (filedes, ROOT, 0); + lseek (filedes, hdr_offset + ROOT, SEEK_SET); write (filedes, nblock, BLOCKLEN); *blknbr = no_of_blks; @@ -3283,7 +3528,7 @@ static void getnewblk (int filedes, unsi errno = 0; - lseek (filedes, (long) (no_of_blks) * BLOCKLEN, 0); + lseek (filedes, hdr_offset + ((long) (no_of_blks) * BLOCKLEN), SEEK_SET); write (filedes, nblock, BLOCKLEN); if (errno == 0) break; @@ -3419,7 +3664,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 +3706,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 +3738,38 @@ 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; + + printf ("\r\nFreeM Global Statistics [PID %d]\r\n\r\n", pid); + + printf ("%-20s%-10s%-12s%-20s%-10s%s\r\n", "GLOBAL", "USECT", "SLOW PTHCT", "AGE", "LAST BLK", "FILE"); + printf ("%-20s%-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%-12ld%-20ld%-10ld%s\r\n", + g->global_name, + g->use_count, + g->cache_misses, + g->age, + g->last_block, + g->global_path); + ct++; + 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); }