/* wait:
* -1: non-blocking, always draw screen
* 0: blocking wait for input and always draw screen
* 1: non-blocking, draw screen only if a configured delay has passed or after keypress
*/
int input_handle(int wait) {
int ch;
struct timeval tv;
nodelay(stdscr, wait?1:0);
if(wait != 1)
screen_draw();
else {
gettimeofday(&tv, (void *)NULL);
tv.tv_usec = (1000*(tv.tv_sec % 1000) + (tv.tv_usec / 1000)) / update_delay;
if(lastupdate != tv.tv_usec) {
screen_draw();
lastupdate = tv.tv_usec;
}
}
while((ch = getch()) != ERR) {
if(ch == KEY_RESIZE) {
if(ncresize(min_rows, min_cols))
min_rows = min_cols = 0;
screen_draw();
continue;
}
switch(pstate) {
case ST_CALC: return calc_key(ch);
case ST_BROWSE: return browse_key(ch);
case ST_HELP: return help_key(ch);
case ST_DEL: return delete_key(ch);
}
screen_draw();
}
return 0;
}
int main(int argc, char * argv[]) {
uint64_t n = atol(argv[1]);
uint64_t index;
uint64_t key = 1;
uint64_t height = 16;
// Create an AVL tree with a bunch of elements initially.
for (index = 1; index <= ((1 << height) - 1) && index <= n; index++) {
printf("I %lu\n", calc_key(key++, (1 << height) - 1));
}
// Now generate a sequence of increasing-cost blocks, where each
// block "counts up" how expensive the operations contained are.
uint64_t blockSize = ceil(sqrt(n / height));
uint64_t inBlockIndex = 1;
uint64_t blockIndex = 1;
for ( ; index <= n; index++) {
uint64_t slot = (blockIndex-1) / height + 1;
if (inBlockIndex > slot) {
// Cheap key.
key = calc_key(1, (1 << height) - 1);
}
else if (inBlockIndex == slot) {
// Varying cost key.
uint64_t slotOffset = blockIndex - ((slot - 1) * height) - 1;
key = calc_key(1 << slotOffset, (1 << height) - 1);
}
else {
// Expensive key.
key = calc_key(1 << (height - 1), (1 << height) - 1);
}
inBlockIndex++;
if (inBlockIndex > blockSize) {
inBlockIndex = 1;
blockIndex++;
}
printf("F %lu\n", key);
}
}
/*
* Initialize new session
*/
void init_new_session(u_int32_t sip, u_int32_t dip, u_int16_t sport, u_int16_t dport)
{
struct tcp_session tcpsess;
sess_key keyhash;
memset(&tcpsess, 0, sizeof(tcpsess));
// calc key for sess_map
keyhash = calc_key(sip, dip, sport, dport);
// fill session struct
sess_map[keyhash].ip_src = sip;
sess_map[keyhash].ip_dst = dip;
sess_map[keyhash].tcp_sport = sport;
sess_map[keyhash].tcp_dport = dport;
sess_map[keyhash].active = 1;
}
int h2o_http2_casper_lookup(h2o_http2_casper_t *casper, const char *path, size_t path_len, int set)
{
unsigned key = calc_key(casper, path, path_len);
size_t i;
/* FIXME use binary search */
for (i = 0; i != casper->keys.size; ++i)
if (key <= casper->keys.entries[i])
break;
if (i != casper->keys.size && key == casper->keys.entries[i])
return 1;
if (!set)
return 0;
/* we need to set a new value */
free(casper->cookie_cache.base);
casper->cookie_cache = (h2o_iovec_t){NULL};
h2o_vector_reserve(NULL, &casper->keys, casper->keys.size + 1);
memmove(casper->keys.entries + i + 1, casper->keys.entries + i, (casper->keys.size - i) * sizeof(casper->keys.entries[0]));
++casper->keys.size;
casper->keys.entries[i] = key;
return 0;
}
static struct buffer_head *
affs_getblock(struct inode *inode, s32 block)
{
struct super_block *sb = inode->i_sb;
int ofs = sb->u.affs_sb.s_flags & SF_OFS;
int ext = block / AFFS_I2HSIZE(inode);
struct buffer_head *bh, *ebh, *pbh = NULL;
struct key_cache *kc;
s32 key, nkey;
int cf, j, pt;
int index;
int err;
pr_debug("AFFS: getblock(%lu,%d)\n",inode->i_ino,block);
if (block < 0)
goto out_fail;
key = calc_key(inode,&ext);
block -= ext * AFFS_I2HSIZE(inode);
pt = ext ? T_LIST : T_SHORT;
/* Key refers now to the last known extension block,
* ext is its sequence number (if 0, key refers to the
* header block), and block is the block number relative
* to the first block stored in that extension block.
*/
for (;;) { /* Loop over header block and extension blocks */
struct file_front *fdp;
bh = affs_bread(inode->i_dev,key,AFFS_I2BSIZE(inode));
if (!bh)
goto out_fail;
fdp = (struct file_front *) bh->b_data;
err = affs_checksum_block(AFFS_I2BSIZE(inode),bh->b_data,&cf,&j);
if (err || cf != pt || j != ST_FILE) {
affs_error(sb, "getblock",
"Block %d is not a valid %s", key,
pt == T_SHORT ? "file header" : "ext block");
goto out_free_bh;
}
j = be32_to_cpu(((struct file_front *)bh->b_data)->block_count);
for (cf = 0; j < AFFS_I2HSIZE(inode) && j <= block; j++) {
if (ofs && !pbh && inode->u.affs_i.i_lastblock >= 0) {
if (j > 0) {
s32 k = AFFS_BLOCK(bh->b_data, inode,
j - 1);
pbh = affs_bread(inode->i_dev,
be32_to_cpu(k),
AFFS_I2BSIZE(inode));
} else
pbh = affs_getblock(inode,inode->u.affs_i.i_lastblock);
if (!pbh) {
affs_error(sb,"getblock",
"Cannot get last block in file");
break;
}
}
nkey = affs_new_data(inode);
if (!nkey)
break;
inode->u.affs_i.i_lastblock++;
if (AFFS_BLOCK(bh->b_data,inode,j)) {
affs_warning(sb,"getblock","Block already allocated");
affs_free_block(sb,nkey);
continue;
}
AFFS_BLOCK(bh->b_data,inode,j) = cpu_to_be32(nkey);
if (ofs) {
ebh = affs_bread(inode->i_dev,nkey,AFFS_I2BSIZE(inode));
if (!ebh) {
affs_error(sb,"getblock",
"Cannot get block %d",nkey);
affs_free_block(sb,nkey);
AFFS_BLOCK(bh->b_data,inode,j) = 0;
break;
}
DATA_FRONT(ebh)->primary_type = cpu_to_be32(T_DATA);
DATA_FRONT(ebh)->header_key = cpu_to_be32(inode->i_ino);
DATA_FRONT(ebh)->sequence_number = cpu_to_be32(inode->u.affs_i.i_lastblock + 1);
affs_fix_checksum(AFFS_I2BSIZE(inode),
ebh->b_data, 5);
mark_buffer_dirty(ebh, 0);
if (pbh) {
DATA_FRONT(pbh)->data_size = cpu_to_be32(AFFS_I2BSIZE(inode) - 24);
DATA_FRONT(pbh)->next_data = cpu_to_be32(nkey);
affs_fix_checksum(AFFS_I2BSIZE(inode),pbh->b_data,5);
mark_buffer_dirty(pbh,0);
affs_brelse(pbh);
}
pbh = ebh;
}
cf = 1;
}
/* N.B. May need to release pbh after here */
if (cf) {
if (pt == T_SHORT)
fdp->first_data = AFFS_BLOCK(bh->b_data,inode,0);
fdp->block_count = cpu_to_be32(j);
affs_fix_checksum(AFFS_I2BSIZE(inode),bh->b_data,5);
mark_buffer_dirty(bh,1);
}
if (block < j) {
if (pbh)
affs_brelse(pbh);
break;
}
if (j < AFFS_I2HSIZE(inode)) {
/* N.B. What about pbh here? */
goto out_free_bh;
}
block -= AFFS_I2HSIZE(inode);
key = be32_to_cpu(FILE_END(bh->b_data,inode)->extension);
if (!key) {
key = affs_new_header(inode);
if (!key)
goto out_free_bh;
ebh = affs_bread(inode->i_dev,key,AFFS_I2BSIZE(inode));
if (!ebh) {
/* N.B. must free bh here */
goto out_free_block;
}
((struct file_front *)ebh->b_data)->primary_type = cpu_to_be32(T_LIST);
((struct file_front *)ebh->b_data)->own_key = cpu_to_be32(key);
FILE_END(ebh->b_data,inode)->secondary_type = cpu_to_be32(ST_FILE);
FILE_END(ebh->b_data,inode)->parent = cpu_to_be32(inode->i_ino);
affs_fix_checksum(AFFS_I2BSIZE(inode),ebh->b_data,5);
mark_buffer_dirty(ebh, 1);
FILE_END(bh->b_data,inode)->extension = cpu_to_be32(key);
affs_fix_checksum(AFFS_I2BSIZE(inode),bh->b_data,5);
mark_buffer_dirty(bh,1);
affs_brelse(bh);
bh = ebh;
}
pt = T_LIST;
ext++;
index = seqnum_to_index(ext);
if (index > inode->u.affs_i.i_ec->max_ext &&
AFFS_ISINDEX(ext)) {
inode->u.affs_i.i_ec->ec[index] = key;
inode->u.affs_i.i_ec->max_ext = index;
}
affs_brelse(bh);
}
/* Invalidate key cache */
for (j = 0; j < 4; j++) {
kc = &inode->u.affs_i.i_ec->kc[j];
kc->kc_last = -1;
}
key = be32_to_cpu(AFFS_BLOCK(bh->b_data,inode,block));
affs_brelse(bh);
if (!key)
goto out_fail;
bh = affs_bread(inode->i_dev, key, AFFS_I2BSIZE(inode));
return bh;
out_free_block:
affs_free_block(sb, key);
out_free_bh:
affs_brelse(bh);
out_fail:
return NULL;
}
static int
affs_bmap(struct inode *inode, int block)
{
struct buffer_head *bh;
s32 key, nkey;
s32 ptype, stype;
int ext;
int index;
int keycount;
struct key_cache *kc;
struct key_cache *tkc;
struct timeval tv;
s32 *keyp;
int i;
pr_debug("AFFS: bmap(%lu,%d)\n",inode->i_ino,block);
if (block < 0) {
affs_error(inode->i_sb,"bmap","Block < 0");
return 0;
}
if (!inode->u.affs_i.i_ec) {
if (alloc_ext_cache(inode)) {
return 0;
}
}
/* Try to find the requested key in the cache.
* In order to speed this up as much as possible,
* the cache line lookup is done in a separate
* step.
*/
for (i = 0; i < 4; i++) {
tkc = &inode->u.affs_i.i_ec->kc[i];
/* Look in any cache if the key is there */
if (block <= tkc->kc_last && block >= tkc->kc_first) {
return tkc->kc_keys[block - tkc->kc_first];
}
}
kc = NULL;
#ifdef OSKIT
tv.tv_sec = CURRENT_TIME;
tv.tv_usec = 0;
#else
tv = xtime;
#endif
for (i = 0; i < 4; i++) {
tkc = &inode->u.affs_i.i_ec->kc[i];
if (tkc->kc_lru_time.tv_sec > tv.tv_sec)
continue;
if (tkc->kc_lru_time.tv_sec < tv.tv_sec ||
tkc->kc_lru_time.tv_usec < tv.tv_usec) {
kc = tkc;
tv = tkc->kc_lru_time;
}
}
if (!kc) /* Really shouldn't happen */
kc = tkc;
#ifdef OSKIT
kc->kc_lru_time.tv_sec = CURRENT_TIME;
kc->kc_lru_time.tv_usec = 0;
#else
kc->kc_lru_time = xtime;
#endif
keyp = kc->kc_keys;
kc->kc_first = block;
kc->kc_last = -1;
keycount = AFFS_KCSIZE;
/* Calculate sequence number of the extension block where the
* number of the requested block is stored. 0 means it's in
* the file header.
*/
ext = block / AFFS_I2HSIZE(inode);
key = calc_key(inode,&ext);
block -= ext * AFFS_I2HSIZE(inode);
for (;;) {
bh = affs_bread(inode->i_dev,key,AFFS_I2BSIZE(inode));
if (!bh)
return 0;
index = seqnum_to_index(ext);
if (index > inode->u.affs_i.i_ec->max_ext &&
(affs_checksum_block(AFFS_I2BSIZE(inode),bh->b_data,&ptype,&stype) ||
(ptype != T_SHORT && ptype != T_LIST) || stype != ST_FILE)) {
affs_brelse(bh);
return 0;
}
nkey = be32_to_cpu(FILE_END(bh->b_data,inode)->extension);
if (block < AFFS_I2HSIZE(inode)) {
/* Fill cache as much as possible */
if (keycount) {
kc->kc_first = ext * AFFS_I2HSIZE(inode) + block;
keycount = keycount < AFFS_I2HSIZE(inode) - block ? keycount :
AFFS_I2HSIZE(inode) - block;
for (i = 0; i < keycount; i++)
kc->kc_keys[i] = be32_to_cpu(AFFS_BLOCK(bh->b_data,inode,block + i));
kc->kc_last = kc->kc_first + i - 1;
}
break;
}
block -= AFFS_I2HSIZE(inode);
affs_brelse(bh);
ext++;
if (index > inode->u.affs_i.i_ec->max_ext && AFFS_ISINDEX(ext)) {
inode->u.affs_i.i_ec->ec[index] = nkey;
inode->u.affs_i.i_ec->max_ext = index;
}
key = nkey;
}
kc->kc_this_key = key;
kc->kc_this_seq = ext;
kc->kc_next_key = nkey;
key = be32_to_cpu(AFFS_BLOCK(bh->b_data,inode,block));
affs_brelse(bh);
return key;
}