void DB_ViewPut(int vol, struct GBD *ptr) // que block for write
{ short s; // for funcs
volnum = vol; // for ron
writing = 0; // clear this
s = SemOp(SEM_GLOBAL, WRITE); // write lock
if (s < 0) // check error
{ return; // quit if so
}
ptr->last_accessed = MTIME(0); // reset access
if (ptr->mem->type) // if used
{ Used_block(ptr->block); // mark it so
}
else // trying to free it
{ Free_block(ptr->block); // do so
bzero(ptr->mem, systab->vol[(volnum)-1]->vollab->block_size); // clear it
}
level = 0; // for Queit
if (ptr->dirty == NULL) // check dirty ptr
{ ptr->dirty = ptr; // set if reqd
blk[level] = ptr; // ditto
Queit(); // do this
}
if (curr_lock)
{ SemOp(SEM_GLOBAL, -curr_lock); // release lock
}
return; // and exit
}
int DB_SetFlags(mvar *var, int flags) // Set flags
{ int clearit = 0;
int i;
short s;
if (flags < 0)
{ clearit = 1; // setup to clear
flags = -flags; // get flags correct
}
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
systab->vol[volnum-1]->stats.dbset++; // update stats
writing = 1; // say we are writing
while (systab->vol[volnum - 1]->writelock) // check for write lock
{ i = sleep(5); // wait a bit
if (partab.jobtab->attention)
{ return -(ERRZLAST+ERRZ51); // for <Control><C>
}
} // end writelock check
Get_GBDs(1); // ensure this many
s = Get_data(0); // try to find that
if ((s < 0) && (s != -ERRM7)) // check for errors
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return (int) s; // return error
}
i = ((int *)record)[1]; // get current flags
if (clearit)
{ i = i & ~flags; // clear flags
}
else
{ i = i | flags; // set flags
}
((int *)record)[1] = i; // set back to GD
if (blk[level]->dirty == (gbd *) 1) // if reserved
{ blk[level]->dirty = blk[level]; // terminate list
Queit(); // que for write
}
SemOp( SEM_GLOBAL, -curr_lock); // release global lock
return i; // return current flags
}
short Set_key(u_int ptr_blk, int this_level) // set a block#
{ short s; // for returns
u_char tmp[8]; // some space
u_char gtmp[16]; // to find glob
int i; // a handy int
u_int *ui; // an int ptr
cstring *ptr; // spare ptr
int rs; // reqd space
int ts; // trailing size
int rls; // RL space
int trailings; // ptr to orig trail
gbd *cblk[3]; // current level blks
u_int tgb; // top blk in GD
DB_Block *btmp; // ditto
ptr = (cstring *) tmp; // point at this
ptr->len = 4; // always
ui = (u_int *) ptr->buf; // for pointers
*ui = ptr_blk; // copy this here
level = this_level; // set current level
if (!this_level) // top level split
{ gtmp[1] = 128; // start string key
for (i=0; i<8; i++) // for each char
{ if (db_var.name.var_cu[i] == '\0') // check for null
{ break; // break if found
}
gtmp[i+2] = db_var.name.var_cu[i]; // copy char
}
i +=2; // correct count
gtmp[i] = '\0'; // null terminate
gtmp[0] = (u_char) i; // add the count
s=Get_block(systab->vol[db_var.volset-1]->vollab->uci[db_var.uci-1].global);
if (s < 0) // failed?
{ return s; // return error
}
s = Locate(gtmp); // search for it
if (s < 0) // failed?
{ return s; // return error
}
Allign_record(); // if not alligned
tgb = *(u_int *) record; // get block#
level = 1; // at top level
s = New_block(); // get a new block
if (s < 0) // if that failed
{ return s; // return error
}
blk[level]->mem->type = db_var.uci; // pointer block
blk[level]->mem->last_idx = 10; // first Index
blk[level]->mem->last_free
= (systab->vol[volnum-1]->vollab->block_size >> 2) - 3; // use 2 words
bcopy(&db_var.name.var_cu[0], &blk[level]->mem->global, 8);
idx[10] = blk[level]->mem->last_free + 1; // the data
chunk = (cstring *) &iidx[idx[10]]; // point at it
chunk->len = 8; // used two words
chunk->buf[0] = 0; // ccc
chunk->buf[1] = 0; // ucc
record = (cstring *) &chunk->buf[chunk->buf[1]+2]; // setup record ptr
*( (u_int *) record) = tgb; // first entry
s = Insert(&db_var.slen, ptr); // insert this one
if (s < 0) // failed?
{ return s; // return error
}
level = 0; // point at GD
s = Locate(gtmp); // search for it
if (s < 0) // failed?
{ return s; // return error
}
Allign_record(); // if not alligned
*( (u_int *) record) = blk[1]->block; // new top level blk
level = 1;
blk[level]->dirty = blk[level]; // hook to self
if (blk[0]->dirty == (gbd *) 1) // if not queued
{ blk[0]->dirty = blk[level]; // hook it
level = 0; // and clear level
}
Queit(); // que to write
return 0; // end of level == 0
}
