bool split_branch (void *self, branch_s *parent, int k)
{
branch_s *child = self;
branch_s *sibling;
int upper;
int midpoint;
u64 midpoint_key;
FN;
if (!branch_is_full(child)) return FALSE;
sibling = new_branch(bdev(child));
midpoint = child->br_num / 2;
upper = midpoint + 1;
sibling->br_first = child->br_key[midpoint].k_block;
midpoint_key = child->br_key[midpoint].k_key;
memmove(sibling->br_key, &child->br_key[upper],
sizeof(key_s) * (child->br_num - upper));
sibling->br_num = child->br_num - upper;
child->br_num = midpoint;
bdirty(child);
bput(child);
insert_sibling(parent, sibling, k, midpoint_key);
bput(sibling);
return TRUE;
}
static int insert_branch (
tree_s *tree,
branch_s *parent,
u64 key,
void *rec,
unint len)
{
void *child;
int k; /* Critical that this be signed */
FN;
for (;;) {
do {
k = binary_search_branch(key, parent->br_key,
parent->br_num);
child = bget(bdev(parent), parent->br_key[k].k_block);
if (!child) {
bput(parent);
return qERR_NOT_FOUND;
}
} while (split(child, parent, k, len));
bput(parent);
if (type(child) != BRANCH) {
return insert_head(tree, child, key, rec, len);
}
parent = child;
}
}
bool split_leaf (void *self, branch_s *parent, int k, unint len)
{
leaf_s *child = self;
leaf_s *sibling;
int upper;
u64 upper_key;
FN;
if (!leaf_is_full(child, len)) {
return FALSE;
}
sibling = new_leaf(bdev(parent));
upper = (child->l_num + 1) / 2;
upper_key = child->l_rec[upper].r_key;
copy_recs(sibling, child, upper);
child->l_num = upper;
child->l_total += (BLK_SIZE - sizeof(leaf_s)) - sibling->l_total;
bdirty(child);
bput(child);
insert_sibling(parent, sibling, k, upper_key);
bput(sibling);
return TRUE;
}
TASKTYPE TASKMOD producer(void * n)
{
int i,nn; char c;
nn = (int)n;
printf(" [[Producer started (n=%d)] ",nn);
i=0;
for (i=0,c='A'; c<='Z' && i<nn; c++,i++){
bput(c);
}
bput(' '); ++i;
HExitThread(i);
return 0;
}
static int join_leaf (
tree_s *tree,
branch_s *parent,
leaf_s *child,
int k)
{
leaf_s *sibling;
sibling = bget(tree->t_dev, parent->br_key[k+1].k_block);
if (!sibling) return qERR_NOT_FOUND;
if (child->l_total + sibling->l_total > MAX_FREE) {
FN;
compact(child);
compact(sibling);
copy_recs(child, sibling, 0);
memmove( &parent->br_key[k+1], &parent->br_key[k+2],
sizeof(parent->br_key[0]) * (parent->br_num - (k+2)));
--parent->br_num;
bdirty(parent);
}
//verify_leaf(child, WHERE);
bput(sibling); // Should free sibling
return 0;
}
static int join_branch (
tree_s *tree,
branch_s *parent,
branch_s *child,
int k)
{
branch_s *sibling;
sibling = bget(tree->t_dev, parent->br_key[k+1].k_block);
if (!sibling) {
return qERR_NOT_FOUND;
}
if (child->br_num+sibling->br_num < KEYS_PER_BRANCH-1) {
FN;
child->br_key[child->br_num].k_key = parent->br_key[k+1].k_key;
child->br_key[child->br_num].k_block = sibling->br_first;
++child->br_num;
memmove( &child->br_key[child->br_num], sibling->br_key,
sibling->br_num * sizeof(sibling->br_key[0]));
child->br_num += sibling->br_num;
bdirty(child);
memmove( &parent->br_key[k+1], &parent->br_key[k+2],
sizeof(parent->br_key[0]) * (parent->br_num - (k+2)));
--parent->br_num;
bdirty(parent);
}
bput(sibling); // Sibling should be freed.
return 0;
}
/*
* This routine fixes up our tables after an Abort, so we won't
* think we detected spurious ups or downs. The refresh routine
* has seen these two keys go down but has not told us about them.
* We, however, will see them go up, and this lets us know that
* their upgoings are OK.
*
* This routine is called from the refresh routine or the start
* of the monitor code for an Abort. If it fails, Aborts won't work.
*/
abortfix()
{
#ifdef KEYBARF
gp->keyswitch[ABORTKEY1] = PRESSED;
gp->keyswitch[ABORTKEY2] = PRESSED;
#endif KEYBARF
/* Tell mainline that keyboard is idle, (even tho it isn't)
to avoid its thinking that an autorepeat should occur */
bput (gp->g_keybuf, IDLEKEY);
}
void *grow_tree (tree_s *tree, unint len)
{
void *root;
branch_s *branch;
int rc;
FN;
if (root_blkno(tree)) {
root = bget(tree->t_dev, root_blkno(tree));
if (!root) return NULL;
switch (type(root)) {
case LEAF:
if (!leaf_is_full(root, len)) {
return root;
}
break;
case BRANCH:
if (!branch_is_full(root)) {
return root;
}
break;
default:
bput(root);
error("Bad block");
exit(1);
break;
}
branch = new_branch(tree->t_dev);
branch->br_first = bblkno(root);
bput(root);
root = branch;
} else {
root = new_leaf(tree->t_dev);
}
rc = change_root(tree, root);
if (rc) {
error("Couldn't grow tree");
return NULL;
}
return root;
}
static int redo_alloc_block (log_s *log, logrec_s *logrec)
{
super_s *super;
buf_s *buf;
FN;
buf = bget(log->lg_sys, SUPER_BLOCK);
if (!buf) {
eprintf("redo_alloc_block: no super block");
return qERR_NOT_FOUND;
}
super = buf->b_data;
if (logrec->lr_lsn <= super->sp_lsn) {
bput(buf);
return 0;
}
super->sp_lsn = logrec->lr_lsn;
super->sp_next = logrec->lr_user[0];
bdirty(buf);
bput(buf);
return 0;
}
int insert_leaf (tree_s *tree, leaf_s *leaf, u64 key, void *rec, unint len)
{
rec_s *r;
int total = len + sizeof(rec_s);
FN;
r = leaf_search(leaf, key);
if (found(leaf, r, key)) {
bput(leaf);
return qERR_DUP;
}
memmove(r + 1, r, (char *)&leaf->l_rec[leaf->l_num] - (char *)r);
++leaf->l_num;
leaf->l_total -= total;
leaf->l_end -= len;
r->r_start = leaf->l_end;
r->r_len = len;
r->r_key = key;
pack_rec(tree, (u8 *)leaf + r->r_start, rec, len);
bdirty(leaf);
bput(leaf);
return 0;
}
int change_root_string (tree_s *tree, buf_s *root)
{
super_s *super;
buf_s *buf;
FN;
buf = bget(tree->t_dev, SUPER_BLOCK);
if (!buf) {
eprintf("change_root_string: no super block");
return qERR_NOT_FOUND;
}
super = buf->b_data;
super->sp_root = root->b_blknum;
bdirty(buf);
bput(buf);
return 0;
}
static void init_super_block (tree_s *tree)
{
super_s *super;
buf_s *buf;
buf = bget(tree->t_dev, SUPER_BLOCK);
super = buf->b_data;
if (super->sp_magic != SUPER_MAGIC) {
super->sp_magic = SUPER_MAGIC;
super->sp_root = 0;
super->sp_next = SUPER_BLOCK + 1;
bdirty(buf);
}
bput(buf);
}
u64 root_string (tree_s *tree)
{
super_s *super;
buf_s *buf;
u64 root;
FN;
buf = bget(tree->t_dev, SUPER_BLOCK);
if (!buf) {
eprintf("root_string: no super block");
return qERR_NOT_FOUND;
}
super = buf->b_data;
root = super->sp_root;
bput(buf);
return root;
}
buf_s *alloc_block (dev_s *dev)
{
super_s *super;
buf_s *buf;
u64 blknum;
FN;
buf = bget(dev, SUPER_BLOCK);
super = buf->b_data;
if (super->sp_magic != SUPER_MAGIC) {
eprintf("no super block");
}
blknum = super->sp_next++;
bdirty(buf);
bput(buf);
return bnew(dev, blknum);
}
u64 alloc_ino (dev_s *dev)
{
super_s *super;
buf_s *buf;
u64 ino;
FN;
buf = bget(dev, SUPER_BLOCK);
super = buf->b_data;
if (super->sp_magic != SUPER_MAGIC) {
eprintf("no super block");
}
ino = super->sp_ino++;
bdirty(buf);
bput(buf);
return ino;
}
static void init_super_block (void)
{
super_s *super;
buf_s *buf;
FN;
buf = bget(Inode_tree.t_dev, SUPER_BLOCK);
super = buf->b_data;
if (super->sp_magic != SUPER_MAGIC) {
super->sp_magic = SUPER_MAGIC;
super->sp_root = 0;
super->sp_next = SUPER_BLOCK + 1;
super->sp_ino = ROOT_INO + 1;
bdirty(buf);
}
bput(buf);
init_root_inode();
}
void stat_block (dev_s *dev, u64 blkno, btree_stat_s *bs, int height)
{
void *data;
data = bget(dev, blkno);
if (!data) return;
switch (type(data)) {
case LEAF: stat_leaf(data, bs);
break;
case BRANCH: stat_branch(dev, data, bs, height + 1);
break;
default: eprintf("Unknown block type %d\n", type(data));
break;
}
if (height > bs->st_height) {
bs->st_height = height;
}
bput(data);
}
void dump_block (
tree_s *tree,
u64 blkno,
unint indent)
{
void *data;
//FN;
data = bget(tree->t_dev, blkno);
if (!data) return;
switch (type(data)) {
case LEAF: dump_leaf(tree, data, indent);
break;
case BRANCH: dump_branch(tree, data, indent);
break;
default: prmem("Unknown block type", data, BLK_SIZE);
break;
}
bput(data);
}
static int join (tree_s *tree, branch_s *parent, int k)
{
void *child;
int rc;
FN;
if (k == parent->br_num - 1) {
/* no sibling to the right */
return 0;
}
child = bget(tree->t_dev, parent->br_key[k].k_block);
if (!child) return qERR_NOT_FOUND;
switch (type(child)) {
case LEAF: rc = join_leaf(tree, parent, child, k);
break;
case BRANCH: rc = join_branch(tree, parent, child, k);
break;
default: rc = qERR_BAD_BLOCK;
break;
}
bput(child);
return rc;
}
void
fileout(register Archive_t* ap, register File_t* f)
{
register size_t m;
register ssize_t n;
register off_t c;
int err;
Buffer_t* bp;
if (f->delta.op == DELTA_verify)
ap->selected--;
else if (putheader(ap, f))
{
if (!ap->format->putdata || !(*ap->format->putdata)(&state, ap, f, f->fd))
{
err = 0;
c = f->st->st_size;
while (c > 0)
{
n = m = c > state.buffersize ? state.buffersize : c;
if (!err)
{
if (f->fd >= 0)
{
if ((n = read(f->fd, ap->io->next, m)) < 0 && errno == EIO)
{
static char* buf;
if (!buf)
{
n = 1024 * 8;
error(1, "EIO read error -- falling back to aligned reads");
if (!(buf = malloc(state.buffersize + n)))
nospace();
buf += n - (((ssize_t)buf) & (n - 1));
}
if ((n = read(f->fd, buf, m)) > 0)
memcpy(ap->io->next, buf, n);
}
}
else if (bp = getbuffer(f->fd))
{
memcpy(ap->io->next, bp->next, m);
if (f->extended && ap->convert[SECTION_CONTROL].f2a)
ccmapstr(ap->convert[SECTION_CONTROL].f2a, ap->io->next, m);
bp->next += m;
}
else if (bread(f->ap, ap->io->next, (off_t)0, (off_t)n, 1) <= 0)
n = -1;
}
if (n <= 0)
{
if (n)
error(ERROR_SYSTEM|2, "%s: read error", f->path);
else
error(2, "%s: file size changed", f->path);
memzero(ap->io->next, state.buffersize);
err = 1;
}
else
{
c -= n;
bput(ap, n);
}
}
}
puttrailer(ap, f);
}
if (f->fd >= 0)
closein(ap, f, f->fd);
}
void
print(struct termios *tp, struct winsize *wp, int ldisc, enum FMT fmt)
{
struct cchar *p;
long tmp;
u_char *cc;
int cnt, ispeed, ospeed;
char buf1[100], buf2[100];
cnt = 0;
/* Line discipline. */
if (ldisc != TTYDISC) {
switch(ldisc) {
case SLIPDISC:
cnt += printf("slip disc; ");
break;
case PPPDISC:
cnt += printf("ppp disc; ");
break;
default:
cnt += printf("#%d disc; ", ldisc);
break;
}
}
/* Line speed. */
ispeed = cfgetispeed(tp);
ospeed = cfgetospeed(tp);
if (ispeed != ospeed)
cnt +=
printf("ispeed %d baud; ospeed %d baud;", ispeed, ospeed);
else
cnt += printf("speed %d baud;", ispeed);
if (fmt >= BSD)
cnt += printf(" %d rows; %d columns;", wp->ws_row, wp->ws_col);
if (cnt)
(void)printf("\n");
#define on(f) ((tmp & (f)) != 0)
#define put(n, f, d) \
if (fmt >= BSD || on(f) != (d)) \
bput((n) + on(f));
/* "local" flags */
tmp = tp->c_lflag;
binit("lflags");
put("-icanon", ICANON, 1);
put("-isig", ISIG, 1);
put("-iexten", IEXTEN, 1);
put("-echo", ECHO, 1);
put("-echoe", ECHOE, 0);
put("-echok", ECHOK, 0);
put("-echoke", ECHOKE, 0);
put("-echonl", ECHONL, 0);
put("-echoctl", ECHOCTL, 0);
put("-echoprt", ECHOPRT, 0);
put("-altwerase", ALTWERASE, 0);
put("-noflsh", NOFLSH, 0);
put("-tostop", TOSTOP, 0);
put("-flusho", FLUSHO, 0);
put("-pendin", PENDIN, 0);
put("-nokerninfo", NOKERNINFO, 0);
put("-extproc", EXTPROC, 0);
/* input flags */
tmp = tp->c_iflag;
binit("iflags");
put("-istrip", ISTRIP, 0);
put("-icrnl", ICRNL, 1);
put("-inlcr", INLCR, 0);
put("-igncr", IGNCR, 0);
put("-ixon", IXON, 1);
put("-ixoff", IXOFF, 0);
put("-ixany", IXANY, 1);
put("-imaxbel", IMAXBEL, 1);
put("-ignbrk", IGNBRK, 0);
put("-brkint", BRKINT, 1);
put("-inpck", INPCK, 0);
put("-ignpar", IGNPAR, 0);
put("-parmrk", PARMRK, 0);
/* output flags */
tmp = tp->c_oflag;
binit("oflags");
put("-opost", OPOST, 1);
put("-onlcr", ONLCR, 1);
put("-ocrnl", OCRNL, 0);
switch(tmp&TABDLY) {
case TAB0:
bput("tab0");
break;
case TAB3:
bput("tab3");
break;
}
put("-onocr", ONOCR, 0);
put("-onlret", ONLRET, 0);
/* control flags (hardware state) */
tmp = tp->c_cflag;
binit("cflags");
put("-cread", CREAD, 1);
switch(tmp&CSIZE) {
case CS5:
bput("cs5");
break;
case CS6:
bput("cs6");
break;
case CS7:
bput("cs7");
break;
case CS8:
bput("cs8");
break;
}
bput("-parenb" + on(PARENB));
put("-parodd", PARODD, 0);
put("-hupcl", HUPCL, 1);
put("-clocal", CLOCAL, 0);
put("-cstopb", CSTOPB, 0);
switch(tmp & (CCTS_OFLOW | CRTS_IFLOW)) {
case CCTS_OFLOW:
bput("ctsflow");
break;
case CRTS_IFLOW:
bput("rtsflow");
break;
default:
put("-crtscts", CCTS_OFLOW | CRTS_IFLOW, 0);
break;
}
put("-dsrflow", CDSR_OFLOW, 0);
put("-dtrflow", CDTR_IFLOW, 0);
put("-mdmbuf", MDMBUF, 0); /* XXX mdmbuf == dtrflow */
/* special control characters */
cc = tp->c_cc;
if (fmt == POSIX) {
binit("cchars");
for (p = cchars1; p->name; ++p) {
(void)snprintf(buf1, sizeof(buf1), "%s = %s;",
p->name, ccval(p, cc[p->sub]));
bput(buf1);
}
binit(NULL);
} else {
binit(NULL);
for (p = cchars1, cnt = 0; p->name; ++p) {
if (fmt != BSD && cc[p->sub] == p->def)
continue;
#define WD "%-8s"
(void)snprintf(buf1 + cnt * 8, sizeof(buf1) - cnt * 8,
WD, p->name);
(void)snprintf(buf2 + cnt * 8, sizeof(buf2) - cnt * 8,
WD, ccval(p, cc[p->sub]));
if (++cnt == LINELENGTH / 8) {
cnt = 0;
(void)printf("%s\n", buf1);
(void)printf("%s\n", buf2);
}
}
if (cnt) {
(void)printf("%s\n", buf1);
(void)printf("%s\n", buf2);
}
}
}
static int
paxput(Pax_t* pax, Paxarchive_t* ap, off_t n)
{
bput(ap, n);
return 0;
}
