size_t tmpfs_write(struct robject *self, rp_t source, uint8_t *buffer, size_t size, off_t offset) {
uint8_t *file_data;
off_t _file_size = 0;
off_t *file_size;
mutex_spin(&self->driver_mutex);
file_data = robject_data(self, "data");
file_size = robject_data(self, "size");
if (!file_size) {
file_size = &_file_size;
}
if (offset + size >= *file_size) {
file_data = realloc(file_data, offset + size);
robject_set_data(self, "data", file_data);
if (file_size == &_file_size) {
file_size = malloc(sizeof(off_t));
}
*file_size = offset + size;
robject_set_data(self, "size", file_size);
}
memcpy(&file_data[offset], buffer, size);
mutex_free(&self->driver_mutex);
return size;
}
void __rdi_class_link_setup() {
rdi_class_link = robject_cons(0, rdi_class_core);
robject_set_call(rdi_class_link, "find", _find, AC_NULL);
robject_set_call(rdi_class_link, "set-link", _set_link, AC_WRITE);
robject_set_call(rdi_class_link, "get-link", _get_link, AC_READ);
robject_set_data(rdi_class_link, "type", (void*) "link");
robject_set_data(rdi_class_link, "name", (void*) "RDI-class-link");
}
struct robject *rdi_link_cons(uint32_t index, uint32_t access, const char *link) {
struct robject *r;
r = robject_cons(index, rdi_class_link);
robject_set_default_access(r, access);
if (link) robject_set_data(r, "link", strdup(link));
return r;
}
struct robject *pipe_file_cons(rp_t source, int argc, char **argv) {
struct robject *new_r;
struct pipe *pipe;
new_r = rdi_file_cons(robject_new_index(), ACCS_READ | ACCS_WRITE);
pipe = pipe_new();
robject_set_data(new_r, "pipe", pipe);
return new_r;
}
char *tmpfs_reset(struct robject *self, rp_t source, int argc, char **argv) {
uint8_t *file_data;
off_t *file_size;
mutex_spin(&self->driver_mutex);
file_data = robject_data(self, "data");
file_size = robject_data(self, "size");
free(file_data);
free(file_size);
robject_set_data(self, "data", NULL);
robject_set_data(self, "size", NULL);
mutex_free(&self->driver_mutex);
return strdup("T");
}
static char *_set_link(struct robject *r, rp_t src, int argc, char **argv) {
char *link;
char *old;
if (argc == 2) {
link = argv[1];
old = robject_get_data(r, "link");
robject_set_data(r, "link", strdup(link));
free(old);
return strdup("T");
}
return errorstr(EINVAL);
}
int main(int argc, char **argv) {
uint32_t slot, func, bus;
struct pci_header *hdr;
struct robject *root;
struct robject *device;
char *name;
rdi_init();
root = rdi_dir_cons(1, ACCS_READ | ACCS_WRITE);
for (bus = 0; bus < 256; bus++) {
for (slot = 0; slot < 32; slot++) {
for (func = 0; func < 8; func++) {
if (_pci_ping(bus, slot, func)) {
hdr = malloc(sizeof(struct pci_header));
_pci_read(bus, slot, func, hdr);
device = rdi_file_cons((bus << 16) | (slot << 11) | (func << 8) + 2, ACCS_READ);
robject_set_data(device, "pci-header", hdr);
name = saprintf("/b%2Xs%2Xf%1X", bus, slot, func);
rdi_vfs_add(root, name, device);
free(name);
printf("%02x:%02x.%x :\n", bus, slot, func);
printf("\tdevice ID: %X\n", hdr->device_id);
printf("\tvendor ID: %X\n", hdr->vendor_id);
printf("\tclass: %X %X\n", hdr->class_code, hdr->subclass);
for (int i = 0; i < 5; i++) {
printf("\tBAR%d: %X\n", i, hdr->bar[i]);
}
}
}
}
}
rdi_global_read_hook = pci_read;
msendb(getppid(), ACTION_CHILD);
_done();
return 0;
}
int main(int argc, char **argv) {
struct robject *canvas;
char *modesstr0;
char *modestr;
int i;
rdi_init();
canvas = rdi_file_cons(robject_new_index(), ACCS_READ | ACCS_WRITE | ACCS_EVENT);
robject_set_data(canvas, "type", (void*) "canvas share");
svga_init();
// generate list of modes
modesstr = strdup("");
for (i = 0; i < modelist_count; i++) {
modesstr0 = modesstr;
modestr = malloc(16);
sprintf(modestr, "%d:%d:%d ", modelist[i].w, modelist[i].h, modelist[i].d);
modesstr = strvcat(modesstr, modestr, NULL);
free(modesstr0);
}
svga_set_mode(svga_find_mode(640, 480, 24));
buffer = malloc(svga.w * svga.h * 4);
/* set up driver interface */
robject_set_call(canvas, "getmode", svga_rcall_getmode, STAT_READER);
robject_set_call(canvas, "listmodes", svga_rcall_listmodes, STAT_READER);
robject_set_call(canvas, "unshare", svga_rcall_unshare, STAT_WRITER);
robject_set_call(canvas, "setmode", svga_rcall_setmode, STAT_WRITER);
robject_set_call(canvas, "syncrect", svga_rcall_syncrect, STAT_WRITER);
robject_set_call(canvas, "sync", svga_rcall_sync, STAT_WRITER);
rdi_global_share_hook = svga_share;
/* register the driver as /dev/svga0 */
fs_plink("/dev/svga0", RP_CONS(getpid(), canvas->index), NULL);
msendb(RP_CONS(getppid(), 0), PORT_CHILD);
_done();
return 0;
}
int main(int argc, char **argv) {
struct tar_block *block;
struct robject *root;
struct robject *file;
size_t i, n;
off_t *poff, *size;
/* reject if no parent is speicified */
if (argc < 2) {
fprintf(stderr, "%s: no parent driver specified\n", argv[0]);
abort();
}
else {
/* get parent driver stream */
parent = fopen(argv[1], "r");
if (!parent) {
/* parent does not exist - fail */
fprintf(stderr, "%s: no parent driver %s\n", argv[0], argv[1]);
abort();
}
}
rdi_init();
/* create root directory */
root = rdi_dir_cons(robject_new_index(), ACCS_READ | ACCS_WRITE);
/* allocate buffer space for header block */
block = malloc(512);
for (i = 0, n = 1;; n++) {
/* read in file header block */
fseek(parent, i, SEEK_SET);
fread(block, 1, 512, parent);
/* break if it's a terminating block */
if (block->filename[0] == '\0' || block->filename[0] == ' ') {
break;
}
if (block->filename[strlen(block->filename) - 1] == '/') {
/* add directory to VFS */
block->filename[strlen(block->filename) - 1] = 0;
file = rdi_dir_cons(robject_new_index(), ACCS_READ | ACCS_WRITE);
rdi_vfs_add(root, block->filename, file);
/* move to next file header */
i += 512;
}
else {
/* add file to VFS */
file = rdi_file_cons(robject_new_index(), ACCS_READ);
rdi_vfs_add(root, block->filename, file);
poff = malloc(sizeof(off_t));
size = malloc(sizeof(off_t));
*poff = i + 512;
*size = getvalue(block->filesize, 12);
robject_set_data(file, "size", size);
robject_set_data(file, "parent-offset", poff);
/* move to next file header */
i += ((*size / 512) + 1) * 512;
if (*size % 512) i += 512;
}
}
free(block);
/* set up interface */
rdi_global_read_hook = tarfs_read;
rdi_global_cons_link_hook = tarfs_link_cons;
/* daemonize */
msendb(RP_CONS(getppid(), 0), ACTION_CHILD);
_done();
return EXIT_SUCCESS;
}
