freem/src/global_bltin.c - diff

Return to global_bltin.c CVS log

Up to [Coherent Logic Development] / freem / src

Diff for /freem/src/global_bltin.c between versions 1.16 and 1.18

version 1.16, 2025/04/11 00:52:40	version 1.18, 2025/04/11 16:23:18
Line 24	Line 24
* along with FreeM. If not, see <https://www.gnu.org/licenses/>.	* along with FreeM. If not, see <https://www.gnu.org/licenses/>.
*	*
* $Log$	* $Log$
	* 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	* Revision 1.16 2025/04/11 00:52:40 snw
* Replace all lseek/read calls in global handler to use gbl_read_block function	* Replace all lseek/read calls in global handler to use gbl_read_block function
*	*
Line 84 global_handle *global_handles_head;	Line 90 global_handle *global_handles_head;
unsigned long gbl_cache_misses = 0;	unsigned long gbl_cache_misses = 0;
unsigned long gbl_cache_hits = 0;	unsigned long gbl_cache_hits = 0;

static void b_free (short filedes, unsigned long blknbr);	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 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 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 insert (global_handle g, char ins_key, long key_len, unsigned long blknbr);
static void scanpblk (char block, long adr, long *fnd);	static void scanpblk (char block, long adr, long *fnd);
static void scandblk (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_collate (char *t);
short g_numeric (char *str);	short g_numeric (char *str);
void close_all_globals(void);	void close_all_globals(void);
Line 319 int gbl_write_header(global_handle *g, g	Line 325 int gbl_write_header(global_handle *g, g
if (g->opened == FALSE) {	if (g->opened == FALSE) {
return FALSE;	return FALSE;
}	}

gbl_lock (g, 1);	gbl_lock (g, 1);
old_position = lseek (g->fd, 0, SEEK_CUR);	old_position = lseek (g->fd, 0, SEEK_CUR);
lseek (g->fd, 0, SEEK_SET);	lseek (g->fd, 0, SEEK_SET);
Line 442 short gbl_open(global_handle *g, short a	Line 448 short gbl_open(global_handle *g, short a
}	}
else {	else {
g->opened = TRUE;	g->opened = TRUE;
result = gbl_read_header (g, &g->header);	result = gbl_read_header (g, &g->header);

if (result == GBL_HDR_OK) {	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;	g->opened = TRUE;
}	}
else {	else {
Line 476 short gbl_open(global_handle *g, short a	Line 486 short gbl_open(global_handle *g, short a

int gbl_read_block(global_handle g, unsigned long blocknum, char block)	int gbl_read_block(global_handle g, unsigned long blocknum, char block)
{	{
	struct stat gstat;
unsigned long hdr_offset;	unsigned long hdr_offset;
hdr_offset = sizeof (global_header);	hdr_offset = sizeof (global_header);

Line 483 int gbl_read_block(global_handle *g, uns	Line 494 int gbl_read_block(global_handle *g, uns
return FALSE;	return FALSE;
}	}

gbl_lock (g, 1);
lseek (g->fd, hdr_offset + ((long) blocknum * (long) (g->header.block_size)), SEEK_SET);
read (g->fd, block, g->header.block_size);
g->last_block = blocknum;
g->use_count++;	g->use_count++;
g->read_ops++;
	fstat (g->fd, &gstat);
	if (!g->locked) gbl_lock (g, 1);


	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++;
	g->last_read_time = time (0L);
	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->last_read_time = time (0L);
	g->cached_block_num = blocknum;

	g->last_block = blocknum;
	g->use_count++;
	g->read_ops++;
	}

	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);	gbl_unlock (g);

return TRUE;	return TRUE;
Line 535 global_handle gbl_handle(char key)	Line 606 global_handle gbl_handle(char key)
g->use_count = 1;	g->use_count = 1;
g->locked = FALSE;	g->locked = FALSE;
g->age = time (0L);	g->age = time (0L);
	g->last_read_time = 0;
g->last_block = 0;	g->last_block = 0;
g->opened = FALSE;	g->opened = FALSE;
g->fd = 0;	g->fd = 0;
Line 543 global_handle gbl_handle(char key)	Line 615 global_handle gbl_handle(char key)
g->cache_hits = 0;	g->cache_hits = 0;
g->read_ops = 0;	g->read_ops = 0;
g->write_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);	strcpy (g->global_name, global_name);
gbl_path (key, g->global_path);	gbl_path (key, g->global_path);
Line 1036 reopen:	Line 1111 reopen:
merr_raise (iresult);	merr_raise (iresult);
return;	return;
}	}

for (;;) {

errno = 0;

lseek (g->fd, hdr_offset + (ROOT * BLOCKLEN), SEEK_SET);
write (g->fd, block, BLOCKLEN);

if (errno == 0) break;

panic ();
}

	gbl_write_block (g, ROOT, block);

block[NRBLK] = 0;	block[NRBLK] = 0;
block[NRBLK + 1] = 0;	block[NRBLK + 1] = 0;
block[NRBLK + 2] = ROOT; /* clear */	block[NRBLK + 2] = ROOT; /* clear */
Line 1085 reopen:	Line 1150 reopen:
/* even ones read/write access (set_sym,kill_sym) 1 */	/* even ones read/write access (set_sym,kill_sym) 1 */

/* temporarily disabled	/* temporarily disabled
lock:	lock:
*/	*/

if (action == get_sym) {	if (action == get_sym) {

tfast0:	tfast0:
gbl_lock (g, 3);	gbl_lock (g, 3);

if (g->fast_path > 0) goto tfast1; /* try again last block */	if (g->fast_path > 0) goto tfast1; /* try again last block */
Line 1100 tfast0:	Line 1165 tfast0:
for (;;) {	for (;;) {


tfast1:	tfast1:
gbl_read_block (g, blknbr, block);	gbl_read_block (g, blknbr, block);

/* temporarily disabled	/* temporarily disabled
tfast2:	tfast2:
*/	*/
if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */	if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
j = UNSIGN (block[0]);	j = UNSIGN (block[0]);
i = 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 */

j += k;	stcpy0 (key1, &block[2], j); /* get first key */

while (k < j) key1[k++] = block[i++]; /* get key */	ch = keyl; /* ch is a register! */

if (j != ch) { /* keys have different length */	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 += UNSIGN (block[i]);
i++;	i++; /* skip data */

continue;	}

	/* fast access failed. try normal path */
	if (tryfast) {
	gbl_cache_miss (g);
	goto tfast0;
}	}

j = ch;	merr_raise (M7);
	data[0] = EOL;

do {	goto quit; /* variable not found */
j--;	}
} while (compactkey[j] == key1[j]); /* compare keys */	else {

	if (g->fast_path > 0) {
if (j < 0) {	gbl_cache_miss (g);
	goto tfast0;
	}

	if (typ == EMPTY) {

k = UNSIGN (block[i++]);	if (blknbr == ROOT) {
stcpy0 (data, &block[i], k); /* get value */	gbl_close (g);
data[k] = EOL1; /* append EOL */	goto reopen;
	}

	merr_raise (DBDGD);
goto quit;	goto quit;

}	}

i += UNSIGN (block[i]);
i++; /* skip data */

}

/* fast access failed. try normal path */
if (tryfast) {
gbl_cache_miss (g);
goto tfast0;
}

merr_raise (M7);
data[0] = EOL;

goto quit; /* variable not found */
}
else {

if (g->fast_path > 0) {
gbl_cache_miss (g);
goto tfast0;
}

if (typ == EMPTY) {

if (blknbr == ROOT) {
gbl_close (g);
goto reopen;
}

merr_raise (DBDGD);
goto quit;

}	}

}	scanpblk (block, &addr, &found);

scanpblk (block, &addr, &found);	addr += UNSIGN (block[addr]) + 2; /* skip key */

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) {

if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {
merr_raise (DBDGD);	merr_raise (DBDGD);
goto quit;	goto quit;
}	}
Line 1212 tfast2:	Line 1277 tfast2:
/* a KILL on an unsubscripted global deletes the entire file */	/* a KILL on an unsubscripted global deletes the entire file */
if (action == kill_sym && compactkey[0] == g_EOL) {	if (action == kill_sym && compactkey[0] == g_EOL) {

lseek (g->fd, hdr_offset + ROOT, SEEK_SET);	/* note : UNIX does not tell other jobs that a file has been unlinked */

/* note : UNIX does not tell other */
block[BTYP] = EMPTY; /* jobs that a file has been unlinked */

/* as long as they keep it open. */	/* as long as they keep it open. */
/* so we mark this global as EMPTY */	/* so we mark this global as EMPTY */
write (g->fd, block, BLOCKLEN);	block[BTYP] = EMPTY;

	gbl_write_block (g, ROOT, block);

gbl_unlock (g);	gbl_unlock (g);
gbl_close (g);	gbl_close (g);
Line 1412 s10: {	Line 1475 s10: {

}	}

lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

if (traceadr[trx] == 0) update (g, compactkey, keyl);	if (traceadr[trx] == 0) update (g, compactkey, keyl);

Line 1499 s20:	Line 1561 s20:
}	}

stcpy0 (&block[++addr], data, (long) datal);	stcpy0 (&block[++addr], data, (long) datal);
lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);

gbl_update_tid (g);	gbl_write_block (g, blknbr, block);

break;	break;

Line 2135 p_empty: /* entry if pointer block goes	Line 2195 p_empty: /* entry if pointer block goes
block0[RLPTR] = block[RLPTR];	block0[RLPTR] = block[RLPTR];
block0[RLPTR + 1] = block[RLPTR + 1];	block0[RLPTR + 1] = block[RLPTR + 1];
block0[RLPTR + 2] = block[RLPTR + 2];	block0[RLPTR + 2] = block[RLPTR + 2];

lseek (g->fd, hdr_offset + ((long) left * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, left, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 2148 p_empty: /* entry if pointer block goes	Line 2207 p_empty: /* entry if pointer block goes
block0[LLPTR] = block[LLPTR];	block0[LLPTR] = block[LLPTR];
block0[LLPTR + 1] = block[LLPTR + 1];	block0[LLPTR + 1] = block[LLPTR + 1];
block0[LLPTR + 2] = block[LLPTR + 2];	block0[LLPTR + 2] = block[LLPTR + 2];

lseek (g->fd, hdr_offset + ((long) right * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, right, block0);
write (g->fd, block0, BLOCKLEN);

}	}

b_free (g->fd, blknbr); /* modify free list */	b_free (g, blknbr); /* modify free list */

/* delete pointer */	/* delete pointer */
/**************************/	/**************************/
Line 2179 p_empty: /* entry if pointer block goes	Line 2237 p_empty: /* entry if pointer block goes

if (blknbr == ROOT) { /* global went empty */	if (blknbr == ROOT) { /* global went empty */

lseek (g->fd, hdr_offset + 0L, SEEK_SET);

/* note : UNIX does not tell other */	/* note : UNIX does not tell other */
block[BTYP] = EMPTY; /* jobs that a file has been unlinked */	block[BTYP] = EMPTY; /* jobs that a file has been unlinked */

/* as long as they keep it open. */	/* as long as they keep it open. */
/* so we mark this global as EMPTY */	/* so we mark this global as EMPTY */
write (g->fd, block, BLOCKLEN);	gbl_write_block (g, 0L, block);

gbl_close (g);	gbl_close (g);
unlink (filnam);	unlink (filnam);

Line 2211 p_empty: /* entry if pointer block goes	Line 2270 p_empty: /* entry if pointer block goes

for (i = offset; i < offset + freecnt; block[i++] = 0);	for (i = offset; i < offset + freecnt; block[i++] = 0);

lseek (g->fd, hdr_offset + ((long) (blknbr) * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

if (addr == 0) { /* update of pointer */	if (addr == 0) { /* update of pointer */
traceadr[trx] = 0;	traceadr[trx] = 0;
Line 2259 p_empty: /* entry if pointer block goes	Line 2317 p_empty: /* entry if pointer block goes
}	}
block[OFFS] = offset / 256;	block[OFFS] = offset / 256;
block[OFFS + 1] = offset % 256;	block[OFFS + 1] = offset % 256;
lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	gbl_write_block (g, blknbr, block);

if (addr < 3) { /* update of pointer */	if (addr < 3) { /* update of pointer */
traceadr[trx] = 0;	traceadr[trx] = 0;
update (g, &block[2], (long) UNSIGN (block[0]));	update (g, &block[2], (long) UNSIGN (block[0]));
}	}
}	}

Line 2593 splitd: /* split data block in two se	Line 2652 splitd: /* split data block in two se
/* 'addr' there I would like to insert, if possible (which is not) */	/* 'addr' there I would like to insert, if possible (which is not) */
/* 'offset' filled up to this limit */	/* 'offset' filled up to this limit */

getnewblk (g->fd, &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 */	/* if we have to insert at the begin or end of a block */
/* we don't split - we just start a new block */	/* we don't split - we just start a new block */
Line 2611 splitd: /* split data block in two se	Line 2670 splitd: /* split data block in two se
block[RLPTR + 1] = newblk % 65536 / 256;	block[RLPTR + 1] = newblk % 65536 / 256;
block[RLPTR + 2] = newblk % 256;	block[RLPTR + 2] = newblk % 256;

lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

block[RLPTR] = right;	block[RLPTR] = right;
block[RLPTR + 1] = right1;	block[RLPTR + 1] = right1;
Line 2637 splitd: /* split data block in two se	Line 2695 splitd: /* split data block in two se
block0[LLPTR + 1] = blknbr % 65536 / 256;	block0[LLPTR + 1] = blknbr % 65536 / 256;
block0[LLPTR + 2] = blknbr % 256;	block0[LLPTR + 2] = blknbr % 256;

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

goto spltex;	goto spltex;
Line 2656 splitd: /* split data block in two se	Line 2713 splitd: /* split data block in two se
block[LLPTR + 1] = newblk % 65536 / 256;	block[LLPTR + 1] = newblk % 65536 / 256;
block[LLPTR + 2] = newblk % 256;	block[LLPTR + 2] = newblk % 256;

lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

block[LLPTR] = left;	block[LLPTR] = left;
block[LLPTR + 1] = left1;	block[LLPTR + 1] = left1;
block[LLPTR + 2] = left2;	block[LLPTR + 2] = left2;
Line 2782 splitd: /* split data block in two se	Line 2838 splitd: /* split data block in two se
block0[LLPTR + 1] = blknbr % 65536 / 256;	block0[LLPTR + 1] = blknbr % 65536 / 256;
block0[LLPTR + 2] = blknbr % 256;	block0[LLPTR + 2] = blknbr % 256;

lseek (g->fd, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, newblk, block0);
write (g->fd, block0, BLOCKLEN);

offset = limit;	offset = limit;
/* insert new block in pointer structure */	/* insert new block in pointer structure */
Line 2798 splitd: /* split data block in two se	Line 2853 splitd: /* split data block in two se
block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 2821 splitd: /* split data block in two se	Line 2875 splitd: /* split data block in two se
block0[LLPTR + 1] = blknbr % 65536 / 256;	block0[LLPTR + 1] = blknbr % 65536 / 256;
block0[LLPTR + 2] = blknbr % 256;	block0[LLPTR + 2] = blknbr % 256;

lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);
stcpy0 (block, block0, (long) BLOCKLEN);	stcpy0 (block, block0, (long) BLOCKLEN);

traceadr[trx] = (addr -= limit);	traceadr[trx] = (addr -= limit);
Line 2839 splitd: /* split data block in two se	Line 2893 splitd: /* split data block in two se
block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 2876 static void splitp (global_handle *g, ch	Line 2929 static void splitp (global_handle *g, ch
unsigned long newblk;	unsigned long newblk;
unsigned long other;	unsigned long other;
register int i, j;	register int i, j;

long hdr_offset;

hdr_offset = sizeof (global_header);

getnewblk (g->fd, &newblk); /* get a new block */	getnewblk (g, &newblk); /* get a new block */

if (blknbr == ROOT) { / ROOT overflow is special */	if (blknbr == ROOT) { / ROOT overflow is special */

Line 2916 static void splitp (global_handle *g, ch	Line 2965 static void splitp (global_handle *g, ch
block0[NRBLK + 2] = i % 256;	block0[NRBLK + 2] = i % 256;
block0[BTYP] = POINTER;	block0[BTYP] = POINTER;

lseek (g->fd, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, block0);
write (g->fd, block0, BLOCKLEN);

/* shift trace_stack */	/* shift trace_stack */
j = trx++;	j = trx++;
Line 2934 static void splitp (global_handle *g, ch	Line 2982 static void splitp (global_handle *g, ch
traceblk[1] = newblk;	traceblk[1] = newblk;
*blknbr = newblk;	*blknbr = newblk;

getnewblk (g->fd, &newblk); /* get a new block */	getnewblk (g, &newblk); /* get a new block */

}	}

Line 2988 static void splitp (global_handle *g, ch	Line 3036 static void splitp (global_handle *g, ch
block0[LLPTR + 1] = (*blknbr) % 65536 / 256;	block0[LLPTR + 1] = (*blknbr) % 65536 / 256;
block0[LLPTR + 2] = (*blknbr) % 256;	block0[LLPTR + 2] = (*blknbr) % 256;

lseek (g->fd, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, newblk, block0);
write (g->fd, block0, BLOCKLEN);

(*offs) = limit;	(*offs) = limit;

Line 2998 static void splitp (global_handle *g, ch	Line 3045 static void splitp (global_handle *g, ch
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, other, block0);
read (g->fd, block0, BLOCKLEN);

block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 3030 static void splitp (global_handle *g, ch	Line 3075 static void splitp (global_handle *g, ch

(*addr) -= limit;	(*addr) -= limit;
(*offs) -= limit;	(*offs) -= limit;

	gbl_write_block (g, *blknbr, block);

lseek (g->fd, hdr_offset + ((long) (blknbr) (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);
stcpy0 (block, block0, (long) BLOCKLEN);	stcpy0 (block, block0, (long) BLOCKLEN);

(*blknbr) = newblk;	(*blknbr) = newblk;
Line 3042 static void splitp (global_handle *g, ch	Line 3087 static void splitp (global_handle *g, ch
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, other, block0);
read (g->fd, block0, BLOCKLEN);

block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 3072 static void update (global_handle *g, ch	Line 3115 static void update (global_handle *g, ch
unsigned long blknbr;	unsigned long blknbr;
char block[BLOCKLEN];	char block[BLOCKLEN];
long i, j, k;	long i, j, k;
long hdr_offset;

hdr_offset = sizeof (global_header);

while (traceadr[trx] == 0) { /* update of pointer blocks necessary */	while (traceadr[trx] == 0) { /* update of pointer blocks necessary */

Line 3082 static void update (global_handle *g, ch	Line 3122 static void update (global_handle *g, ch

blknbr = traceblk[trx];	blknbr = traceblk[trx];
addr = traceadr[trx];	addr = traceadr[trx];

lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, blknbr, block);
read (g->fd, block, BLOCKLEN);

{	{
long oldkeyl;	long oldkeyl;
Line 3134 static void update (global_handle *g, ch	Line 3173 static void update (global_handle *g, ch
while (i < keyl) block[j++] = ins_key[i++];	while (i < keyl) block[j++] = ins_key[i++];

/* block pointed to remains the same */	/* block pointed to remains the same */
lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

}	}

lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, blknbr, block);
read (g->fd, block, BLOCKLEN);

}	}

Line 3164 static void insert (global_handle *g, ch	Line 3200 static void insert (global_handle *g, ch
long needed;	long needed;
long addr;	long addr;
register int i, k;	register int i, k;
long hdr_offset;

hdr_offset = sizeof (global_header);

trxsav = trx--;	trxsav = trx--;
blk = traceblk[trx];	blk = traceblk[trx];
addr = traceadr[trx];	addr = traceadr[trx];

lseek (g->fd, hdr_offset + ((long) (blk) * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, blk, block);
read (g->fd, block, BLOCKLEN);

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
Line 3209 static void insert (global_handle *g, ch	Line 3241 static void insert (global_handle *g, ch
block[i++] = blknbr % 65536 / 256;	block[i++] = blknbr % 65536 / 256;
block[i] = blknbr % 256;	block[i] = blknbr % 256;

lseek (g->fd, hdr_offset + ((long) (blk) * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blk, block);
write (g->fd, block, BLOCKLEN);

trx = trxsav;	trx = trxsav;

Line 3222 static void insert (global_handle *g, ch	Line 3253 static void insert (global_handle *g, ch
* filedes: global file descriptor	* filedes: global file descriptor
* blknbr: block to be freed	* 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];	char block0[BLOCKLEN];
unsigned long free;	unsigned long free;
unsigned long other;	unsigned long other;
long i;	long i;
long offset;	long offset;
long hdr_offset;

hdr_offset = sizeof (global_header);

/* mark block as empty */	/* mark block as empty */
lseek (filedes, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET);	gbl_read_block (g, blknbr, block0);
read (filedes, block0, BLOCKLEN);

block0[BTYP] = EMPTY;

lseek (filedes, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET);	block0[BTYP] = EMPTY;
write (filedes, block0, BLOCKLEN);
	gbl_write_block (g, blknbr, block0);

/* do we have a list of free blocks? */	/* do we have a list of free blocks? */
lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_read_block (g, ROOT, block0);
read (filedes, block0, BLOCKLEN);

if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {	if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {

for (;;) {	for (;;) {

lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);	gbl_read_block (g, free, block0);
read (filedes, block0, BLOCKLEN);

other = UNSIGN (block0[RLPTR]) * 65536 +	other = UNSIGN (block0[RLPTR]) * 65536 +
UNSIGN (block0[RLPTR + 1]) * 256 +	UNSIGN (block0[RLPTR + 1]) * 256 +
Line 3282 static void b_free (short filedes, unsig	Line 3306 static void b_free (short filedes, unsig
block0[RLPTR] = other / 65536;	block0[RLPTR] = other / 65536;
block0[RLPTR + 1] = other % 65536 / 256;	block0[RLPTR + 1] = other % 65536 / 256;
block0[RLPTR + 2] = other % 256;	block0[RLPTR + 2] = other % 256;

lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);	gbl_write_block (g, free, block0);
write (filedes, block0, BLOCKLEN);

for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */	for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */

Line 3300 static void b_free (short filedes, unsig	Line 3323 static void b_free (short filedes, unsig

}	}
else {	else {
	getnewblk (g, &free);
getnewblk (filedes, &free);

/* set FBLK free blocks pointer */	/* set FBLK free blocks pointer */
lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_read_block (g, ROOT, block0);
read (filedes, block0, BLOCKLEN);

block0[FREE] = free / 65536;	block0[FREE] = free / 65536;
block0[FREE + 1] = free % 65536 / 256;	block0[FREE + 1] = free % 65536 / 256;
block0[FREE + 2] = free % 256;	block0[FREE + 2] = free % 256;

lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, block0);
write (filedes, block0, BLOCKLEN);

for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */	for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */

Line 3327 static void b_free (short filedes, unsig	Line 3347 static void b_free (short filedes, unsig
block0[OFFS] = offset / 256;	block0[OFFS] = offset / 256;
block0[OFFS + 1] = offset % 256;	block0[OFFS + 1] = offset % 256;

lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);	gbl_write_block (g, free, block0);
write (filedes, block0, BLOCKLEN);

return;	return;
} /* end of b_free() */	} /* end of b_free() */
Line 3448 static void scandblk (char *block, long	Line 3467 static void scandblk (char *block, long
* filedes: global file descriptor	* filedes: global file descriptor
* blknbr: number of new block	* 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];	char nblock[BLOCKLEN];
unsigned long freeblks, no_of_blks;	unsigned long freeblks, no_of_blks;
long other;	long other;
long offset;	long offset;
long hdr_offset;

hdr_offset = sizeof (global_header);	gbl_read_block (g, ROOT, nblock);

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]);	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]);	no_of_blks = UNSIGN (nblock[NRBLK]) * 65536 + UNSIGN (nblock[NRBLK + 1]) * 256 + UNSIGN (nblock[NRBLK + 2]);

if (freeblks) {	if (freeblks) {

lseek (filedes, hdr_offset + ((long) (freeblks) * BLOCKLEN), SEEK_SET);	gbl_read_block (g, freeblks, nblock);
read (filedes, nblock, BLOCKLEN);

offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);	offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);

Line 3479 static void getnewblk (int filedes, unsi	Line 3493 static void getnewblk (int filedes, unsi
/* update RL-block, if any */	/* update RL-block, if any */
if (other) {	if (other) {

lseek (filedes, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET);	gbl_read_block (g, other, nblock);
read (filedes, nblock, BLOCKLEN);

nblock[LLPTR] = 0;	nblock[LLPTR] = 0;
nblock[LLPTR + 1] = 0;	nblock[LLPTR + 1] = 0;
nblock[LLPTR + 2] = 0;	nblock[LLPTR + 2] = 0;

lseek (filedes, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET);	gbl_write_block (g, other, nblock);
write (filedes, nblock, BLOCKLEN);

}	}

/* update ROOT block */	/* update ROOT block */
lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_read_block (g, ROOT, nblock);
read (filedes, nblock, BLOCKLEN);

nblock[FREE] = other / 65536;	nblock[FREE] = other / 65536;
nblock[FREE + 1] = other % 65536 / 256;	nblock[FREE + 1] = other % 65536 / 256;
nblock[FREE + 2] = other % 256;	nblock[FREE + 2] = other % 256;

lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, nblock);
write (filedes, nblock, BLOCKLEN);

return;	return;

Line 3512 static void getnewblk (int filedes, unsi	Line 3522 static void getnewblk (int filedes, unsi
nblock[offset + 1] = 0;	nblock[offset + 1] = 0;
nblock[OFFS] = offset / 256;	nblock[OFFS] = offset / 256;
nblock[OFFS + 1] = offset % 256;	nblock[OFFS + 1] = offset % 256;

lseek (filedes, hdr_offset + ((long) (freeblks) * BLOCKLEN), SEEK_SET);	gbl_write_block (g, freeblks, nblock);
write (filedes, nblock, BLOCKLEN);

return;	return;

Line 3525 static void getnewblk (int filedes, unsi	Line 3534 static void getnewblk (int filedes, unsi
nblock[NRBLK] = no_of_blks / 65536;	nblock[NRBLK] = no_of_blks / 65536;
nblock[NRBLK + 1] = no_of_blks % 65536 / 256;	nblock[NRBLK + 1] = no_of_blks % 65536 / 256;
nblock[NRBLK + 2] = no_of_blks % 256;	nblock[NRBLK + 2] = no_of_blks % 256;

lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, nblock);
write (filedes, nblock, BLOCKLEN);

*blknbr = no_of_blks;	*blknbr = no_of_blks;

for (;;) {

errno = 0;	gbl_write_block (g, no_of_blks, nblock);

lseek (filedes, hdr_offset + ((long) (no_of_blks) * BLOCKLEN), SEEK_SET);
write (filedes, nblock, BLOCKLEN);

if (errno == 0) break;

panic ();

}

return;	return;

Line 3751 void gbl_dump_stat(void)	Line 3748 void gbl_dump_stat(void)
int hit_pct;	int hit_pct;
unsigned long access_total;	unsigned long access_total;
unsigned long hit_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 ("\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%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "GLOBAL", "USECT", "READS", "WRITES", "MEMREADS", "SLOW PTHCT", "AGE", "LAST BLK", "FILE");
printf ("%-20s%-10s%-12s%-20s%-10s%s\r\n", "======", "=====", "==========", "===", "========", "====");	printf ("%-20s%-10s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "======", "=====", "=====", "======", "========", "==========", "===", "========", "====");

access_total = 0;	access_total = 0;
ct = 0;	ct = 0;
for (g = global_handles_head; g != NULL; g = g->next) {	for (g = global_handles_head; g != NULL; g = g->next) {
printf ("%-20s%-10ld%-12ld%-20ld%-10ld%s\r\n",	printf ("%-20s%-10ld%-10ld%-10ld%-10ld%-12ld%-20ld%-10ld%s\r\n",
g->global_name,	g->global_name,
g->use_count,	g->use_count,
	g->read_ops,
	g->write_ops,
	g->memory_reads,
g->cache_misses,	g->cache_misses,
g->age,	g->age,
g->last_block,	g->last_block,
g->global_path);	g->global_path);
ct++;	ct++;
	mem_reads_total += g->memory_reads;
access_total += g->use_count;	access_total += g->use_count;
}	}
if (!ct) printf ("<no globals opened in this pid>\r\n");	if (!ct) printf ("<no globals opened in this pid>\r\n");
Line 3778 void gbl_dump_stat(void)	Line 3781 void gbl_dump_stat(void)

printf ("\r\nTotal accesses: %ld\r\n", 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 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 ("Fast path misses: %ld\t(%d%%)\r\n", gbl_cache_misses, miss_pct);
	printf ("Disk reads avoided: %ld\r\n", mem_reads_total);

}	}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.16
changed lines
	Added in v.1.18