static struct snobj *handle_get_tc_stats(struct snobj *q)
{
const char *tc_name;
struct tc *c;
struct snobj *r;
tc_name = snobj_str_get(q);
if (!tc_name)
return snobj_err(EINVAL, "Argument must be a name in str");
c = ns_lookup(NS_TYPE_TC, tc_name);
if (!c)
return snobj_err(ENOENT, "No TC '%s' found", tc_name);
r = snobj_map();
snobj_map_set(r, "timestamp", snobj_double(get_epoch_time()));
snobj_map_set(r, "count",
snobj_uint(c->stats.usage[RESOURCE_CNT]));
snobj_map_set(r, "cycles",
snobj_uint(c->stats.usage[RESOURCE_CYCLE]));
snobj_map_set(r, "packets",
snobj_uint(c->stats.usage[RESOURCE_PACKET]));
snobj_map_set(r, "bits",
snobj_uint(c->stats.usage[RESOURCE_BIT]));
return r;
}
int ext2_sb_update(ext2_fs_t *fs, ext2_superblock_t *sb)
{
int old = sb->block_size;
fs->sb->block_size=0;
sb->write_time = get_epoch_time();
ext2_write_block(fs, 1, (unsigned char *)sb);
fs->sb = sb;
sb->block_size = old;
return 0;
}
static struct snobj *handle_get_module_info(struct snobj *arg)
{
const char *m_name;
struct module *m;
struct snobj *r;
struct snobj *gates;
m_name = snobj_str_get(arg);
if (!m_name)
return snobj_err(EINVAL, "Argument must be a name in str");
if ((m = find_module(m_name)) == NULL)
return snobj_err(ENOENT, "No module '%s' found", m_name);
r = snobj_map();
gates = snobj_list();
snobj_map_set(r, "name", snobj_str(m->name));
snobj_map_set(r, "mclass", snobj_str(m->mclass->name));
if (m->mclass->get_desc)
snobj_map_set(r, "desc", m->mclass->get_desc(m));
if (m->mclass->get_dump)
snobj_map_set(r, "dump", m->mclass->get_dump(m));
for (int i = 0; i < m->allocated_gates; i++) {
if (m->gates[i].m) {
struct snobj *gate = snobj_map();
snobj_map_set(gate, "gate", snobj_uint(i));
#if TRACK_GATES
snobj_map_set(gate, "cnt",
snobj_uint(m->gates[i].cnt));
snobj_map_set(gate, "pkts",
snobj_uint(m->gates[i].pkts));
snobj_map_set(gate, "timestamp",
snobj_double(get_epoch_time()));
#endif
snobj_map_set(gate, "name", snobj_str(m->gates[i].m->name));
snobj_list_add(gates, gate);
}
}
snobj_map_set(r, "gates", gates);
return r;
}
static struct snobj *handle_get_port_stats(struct snobj *arg)
{
const char *port_name;
struct port *port;
port_stats_t stats;
struct snobj *r;
struct snobj *inc;
struct snobj *out;
port_name = snobj_str_get(arg);
if (!port_name)
return snobj_err(EINVAL, "Argument must be a name in str");
port = find_port(port_name);
if (!port)
return snobj_err(ENOENT, "No port `%s' found", port_name);
get_port_stats(port, &stats);
inc = snobj_map();
snobj_map_set(inc, "packets", snobj_uint(stats[PACKET_DIR_INC].packets));
snobj_map_set(inc, "dropped", snobj_uint(stats[PACKET_DIR_INC].dropped));
snobj_map_set(inc, "bytes", snobj_uint(stats[PACKET_DIR_INC].bytes));
out = snobj_map();
snobj_map_set(out, "packets", snobj_uint(stats[PACKET_DIR_OUT].packets));
snobj_map_set(out, "dropped", snobj_uint(stats[PACKET_DIR_OUT].dropped));
snobj_map_set(out, "bytes", snobj_uint(stats[PACKET_DIR_OUT].bytes));
r = snobj_map();
snobj_map_set(r, "inc", inc);
snobj_map_set(r, "out", out);
snobj_map_set(r, "timestamp", snobj_double(get_epoch_time()));
return r;
}
struct inode *ext2_mount(dev_t dev, u64 block, char *node)
{
ext2_fs_t *fs = get_new_fsvol();
if(!fs) {
printk(5, "[ext2]: Unable to allocate new filesystem!\n");
release_fsvol(fs);
return 0;
}
struct inode *in = get_idir(node, 0);
if(in && dev == -1)
dev = in->dev;
if(in && (int)in->dev != dev)
printk(4, "[ext2]: Odd...node device is different from given device...\n");
iput(in);
fs->block = block;
fs->dev = dev;
fs->sb->block_size=0;
if(node)
strncpy(fs->node, node, 16);
ext2_read_block(fs, 1, (unsigned char *)fs->sb);
if(fs->sb->magic != EXT2_SB_MAGIC) {
release_fsvol(fs);
return 0;
}
if(fs->sb->state == 2)
{
printk(5, "[ext2]: Filesystem has errors: ");
if(fs->sb->errors == 2)
{
printk(5, "Mounting as read-only\n");
fs->read_only=1;
} else if(fs->sb->errors == 3)
panic(0, "ext2 mount failed!");
else
printk(5, "Ignoring...\n");
}
unsigned reqf = fs->sb->features_req;
if(!(reqf&0x2) || (reqf & 0x1) || (reqf &0x4) || (reqf&0x8))
{
release_fsvol(fs);
printk(5, "[ext2]: Cannot mount %s due to feature flags\n", node);
return 0;
}
unsigned rof = fs->sb->features_ro;
if(ext2_sb_inodesize(fs->sb) != 128)
{
release_fsvol(fs);
printk(5, "[ext2]: Inode size %d is not supported\n", ext2_sb_inodesize(fs->sb));
return 0;
}
if(!(rof&0x1) || (rof & 0x2) || (rof&0x4))
{
printk(5, "[ext2]: Filesystem on %s must be mounted read-only due to feature flags\n", node);
fs->read_only=1;
}
ext2_inode_t root;
ext2_inode_read(fs, 2, &root);
fs->root = create_sea_inode(&root, "ext2");
strncpy(fs->root->node_str, node, 128);
if(fs->sb->mount_count > fs->sb->max_mount_count)
fs->sb->mount_count=0;
fs->sb->mount_time = get_epoch_time();
ext2_sb_update(fs, fs->sb);
printk(0, "[ext2]: Optional features flags are %x\n", fs->sb->features_opt);
if(fs->sb->features_opt & 0x4)
printk(0, "[ext2]: Hmm...looks like an ext3 filesystem to me. Oh well. It should still work.\n");
if(fs->sb->features_opt & 0x20)
printk(0, "[ext2]: Hmm...directories have a hash index. I'll look into that later...\n");
return fs->root;
}
