// FIXME: Pass a list of 'resources' rather than a single address+irq number, which may
// not always be sufficient.
static void
scan_devices(void)
{
CORBA_Environment env;
L4_ThreadId_t me = L4_Myself();
thread_ref_t server_;
cap_t device;
/* timer device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VTIMER_SERVER")),
&server_);
timer_server = thread_l4tid(server_);
device_add_resource(timer_server, 0x40a00000,0, MEMORY_RESOURCE, &env);
device_add_resource(timer_server, 27,0, INTERRUPT_RESOURCE, &env);
device_add_resource(timer_server, 28,0, INTERRUPT_RESOURCE, &env);
device = device_create(timer_server, &me, TIMER, &env);
timer_device = device.ref.obj;
/* rtc device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VRTC_SERVER")),
&server_);
rtc_server = thread_l4tid(server_);
device_add_resource(rtc_server, RTC_PHYS, 0, MEMORY_RESOURCE, &env);
device_add_resource(rtc_server, INT_RTC, 0, INTERRUPT_RESOURCE, &env);
device = device_create(rtc_server, &me, RTC, &env);
rtc_device = device.ref.obj;
/* serial device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VSERIAL_SERVER")),
&server_);
serial_server = thread_l4tid(server_);
device_add_resource(serial_server, 0x40100000,0, MEMORY_RESOURCE, &env);
device_add_resource(serial_server, 22,0, INTERRUPT_RESOURCE, &env);
device = device_create(serial_server, &me, UART1, &env);
serial_device = device.ref.obj;
#if 0
/* serial device */
memsection_lookup(iguana_getenv(IGUANA_GETENV_VBUS_SERVER), &server_);
bus_server = thread_l4tid(server_);
device_add_resource(bus_server, 101,0, INTERRUPT_RESOURCE, &env);
device = device_create(bus_server, &me, BUS, &env);
bus_device = device.ref.obj;
DEBUG_TRACE(2, "looking for LCD device\n");
cap_t virtual_bus = virtual_bus_factory_create(bus_server, bus_device,
&lcd_server, 0, NULL);
/* LCD device */
memsection_lookup(iguana_getenv(IGUANA_GETENV_VLCD_SERVER), &server_);
lcd_server = thread_l4tid(server_);
device_add_resource(lcd_server, bus_server.raw, virtual_bus.ref.obj, BUS_RESOURCE, &env);
device_add_resource(lcd_server, bus_server.raw, virtual_bus.ref.obj, BUS_RESOURCE, &env);
device_add_resource(lcd_server, 101,0, INTERRUPT_RESOURCE, &env);
device = device_create(lcd_server, &me, LCD, &env);
lcd_device = device.ref.obj;
#endif
// And any other devices you care to add ...
}
void
__lib_iguana_init(uintptr_t *obj_env)
{
__lib_iguana_init_env(obj_env);
__lib_iguana_init_pager();
default_virtpool = env_virtpool(iguana_getenv("OKL4_DEFAULT_VIRTPOOL"));
default_physpool = env_physpool(iguana_getenv("OKL4_DEFAULT_PHYSPOOL"));
#if defined(CONFIG_MEM_PROTECTED)
__pd_ext_space = pd_ext_l4id(pd_myself());
__pd_ext_return_space = pd_l4id(pd_myself());
__pd_ext_thread = L4_nilthread;
__pd_ext_utcb = pd_ext_l4utcb(pd_myself());
okl4_libmutex_init(&__pd_ext_lock);
#endif
}
int
main(int argc, char **argv)
{
struct driver_ops *ops;
objref_t obj;
/*
* XXX: Should we be inserting the timer device into naming here?
*/
main_tid = thread_l4tid(env_thread(iguana_getenv("MAIN")));
obj = device_create_impl(main_tid, 0UL, NULL);
naming_insert("timer", obj);
ops = TIMER_DRIVER.ops.d_ops;
iguana_cb_handle = cb_attach(__callback_buffer);
#ifdef ENABLE_PM_THREAD
{
L4_ThreadId_t unused;
pm_thread = thread_create_priority(1, &unused);
L4_KDB_SetThreadName(unused, "PwrMgmt");
}
#endif
L4_Accept(L4_AsynchItemsAcceptor);
L4_Set_NotifyMask(1UL << 31);
timer_server_loop();
assert(!"Should reach here\n");
return 0;
}
END_TEST
#if 0
START_TEST(SEGINFO0300)
{
const envitem_t* envitem;
envitem = iguana_getenv("MAIN/STACK");
fail_if(envitem == NULL,
"Couldn't find stack entry.");
envitem = iguana_getenv("main/stack");
fail_if(envitem == NULL,
"Couldn't find stack entry (lowercase).");
envitem = iguana_getenv("does_not_exist");
fail_if(envitem != NULL,
"Search for non-existent item succeeded.");
envitem = env_get_next(NULL);
fail_if(envitem == NULL,
"Failed to get the first item.");
if (envitem != NULL) {
/*
* Check the name of the first item. This test is dependent
* on the current implementation and may fail if something in
* elfweaver changes.
*/
fail_unless(strcmp(env_name(envitem), "MAIN") == 0,
"Unexpected name for first item.");
/*
* Run through the list.
* Because the contents of the object environment are unknown
* it is not possible to test things here. However, if the
* test hangs then something is wrong!
*/
while ((envitem = env_get_next(envitem)) != NULL) {
}
}
}
void __init __setup_vga(void)
{
#ifdef CONFIG_IGUANA
char* vga_obj;
envitem_t *ig_ref;
if ((ig_ref = (envitem_t *)iguana_getenv("vga")) == NULL)
L4_KDB_Enter("didn't find the iguana ref to vga");
if ((vga_obj = env_memsection_base(ig_ref)) == NULL)
L4_KDB_Enter("vga_obj returned is 0");
VGA_offset = (unsigned long)vga_obj - video_ram_resource.start;
request_resource(&iomem_resource, &video_ram_resource);
#endif
}
int
main(void)
{
main_tid = thread_l4tid(env_thread(iguana_getenv("MAIN")));
printf("\nKernel counter example\n");
printf("----------\n");
test01();
test02();
test03();
printf("Kernel counter example finished\n");
L4_KDB_Enter("done");
return 0;
}
int
main(int argc, char **argv)
{
struct okl4_libmutex rm;
L4_ThreadId_t tid;
int i, max_iteration, eg_num, server_on;
L4_Word_t me;
L4_MsgTag_t tag = L4_Niltag;
/*** Initialisation ***/
pi_main = thread_l4tid(env_thread(iguana_getenv("MAIN")));
me = pi_main.raw;
eg_num = max_iteration = server_on = 0;
if (argc == 3) {
eg_num = atoi(argv[0]);
max_iteration = atoi(argv[1]);
server_on = atoi(argv[2]);
} else {
printf("(%s 0x%lx) Error: Argument(s) missing!\n", test_name, me);
return 1;
}
resource_mutex = &rm;
okl4_libmutex_init(resource_mutex);
high_prio_thread = medium1_prio_thread = medium2_prio_thread = medium3_prio_thread = low_prio_thread = L4_nilthread;
high_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_HIGH")));
medium3_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_INTERMEDIATE_2")));
medium2_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_MEDIUM")));
medium1_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_INTERMEDIATE_1")));
low_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_LOW")));
// Tell other threads that it is safe to use libraries
libs_ready = 1;
if (!server_on)
printf("Start %s test #%d(0x%lx)\n", test_name, eg_num, me);
/*** Start test ***/
scenario1 = 1;
for (i = 0; i < 2 * max_iteration; i++) {
// Wait for threads to be ready
tag = L4_Wait(&tid);
// If one thread had a problem while initialisation, then stop the test and notify
// server that the test is dead.
if (L4_Label(tag) == 0xdead) {
rtos_init();
test_died(test_name, eg_num);
rtos_cleanup();
return 1;
}
// Tell high prio thread to start the next iteration.
L4_LoadMR(0, 0);
tag = L4_Send(high_prio_thread);
stop_spinning = 0;
// Wait for the iteration to finish.
L4_Receive(high_prio_thread);
stop_spinning = 1;
// If end of iterations for scenario1, then report results to RTOS server if server is on.
if (i == (max_iteration - 1)) {
if (server_on) {
rtos_init();
mixed_priority_inversion_results(eg_num, 1, max_iteration, cnt_h, cnt_m1, cnt_m2, cnt_l, cnt_i1, cnt_i2);
} else
print_metrics(max_iteration);
// Start scenario2
cnt_h = cnt_m1 = cnt_m2 = cnt_l = cnt_i1 = cnt_i2 = 0;
scenario1 = 0;
scenario2 = 1;
}
}
/*** Test finished ***/
thread_delete(medium1_prio_thread);
thread_delete(medium3_prio_thread);
thread_delete(high_prio_thread);
thread_delete(medium2_prio_thread);
thread_delete(low_prio_thread);
/* Clean up allocated mutexes. */
okl4_libmutex_free(resource_mutex);
// If RTOS server is on, report results to it.
if (server_on) {
mixed_priority_inversion_results(eg_num, 2, max_iteration, cnt_h, cnt_m1, cnt_m2, cnt_l, cnt_i1, cnt_i2);
rtos_cleanup();
} else {
print_metrics(max_iteration);
printf("%s test #%d(0x%lx) finished\n", test_name, eg_num, me);
}
return 0;
}
int
main(int argc, char **argv)
{
int i, tmp, eg_num, nb_philosophers, nb_dinners, server_on;
L4_ThreadId_t *philo_tids;
L4_ThreadId_t tid, any_thread;
L4_MsgTag_t tag = L4_Niltag;
/*** Initialisation ***/
dp_main = thread_l4tid(env_thread(iguana_getenv("MAIN")));
eg_num = nb_philosophers = nb_dinners = server_on = 0;
if (argc == 3) {
eg_num = atoi(argv[0]);
nb_philosophers = atoi(argv[1]);
server_on = atoi(argv[2]);
} else {
printf("(%s 0x%lx) Error: Argument(s) missing!\n", test_name, dp_main.raw);
return 1;
}
if (!server_on)
printf("Start %s test #%d(0x%lx): %d philosophers\n", test_name, eg_num, dp_main.raw, nb_philosophers);
chopstick = malloc((nb_philosophers + 1) * sizeof(okl4_libmutex_t));
philo_tids = malloc(nb_philosophers * sizeof(L4_ThreadId_t));
for (i = 0; i < nb_philosophers; i++) {
chopstick[i] = malloc (sizeof(struct okl4_libmutex));
okl4_libmutex_init(chopstick[i]);
}
chopstick[nb_philosophers] = NULL;
// Tell other threads that it is safe to use libraries and mutexes
libs_ready = 1;
// Retrieve philosophers thread Ids and give them a go
for (i = 0; i < nb_philosophers; i++) {
L4_Wait(&tid);
philo_tids[i] = tid;
}
/*** Start test ***/
meal_served = 1;
tmp = nb_philosophers;
while (tmp) {
tag = L4_Wait(&any_thread);
for (i = 0; i < nb_philosophers; i++) {
if (any_thread.raw == philo_tids[i].raw) {
thread_delete(any_thread);
tmp--;
if (L4_Label(tag) == 0xfed) {
// Philosopher finished eating
nb_dinners++;
}
break;
}
}
}
/*** Test finished ***/
free(philo_tids);
for (i = 0; i < nb_philosophers; i++) {
okl4_libmutex_free(chopstick[i]);
free(chopstick[i]);
}
//free(*chopstick);
// If RTOS server is on, report results to it.
if (server_on) {
rtos_init();
dining_philosophers_results(eg_num, nb_philosophers, nb_dinners);
rtos_cleanup();
}
else
printf("%s test #%d(0x%lx) finished\n", test_name, eg_num, dp_main.raw);
return 0;
}
// FIXME: Pass a list of 'resources' rather than a single address+irq number, which may
// not always be sufficient.
static void
scan_devices(void)
{
CORBA_Environment env;
L4_ThreadId_t me = L4_Myself();
thread_ref_t server_;
cap_t device;
/* timer device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VTIMER_SERVER")),
&server_);
timer_server = thread_l4tid(server_);
device_add_resource(timer_server, TIMER2_PHYS, 0, MEMORY_RESOURCE, &env);
/* XXX only use timer2 */
device_add_resource(timer_server, INT_TIMER2, 0, INTERRUPT_RESOURCE, &env);
device = device_create(timer_server, &me, TIMER, &env);
timer_device = device.ref.obj;
#if 0 // andy - 4
/* rtc device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VRTC_SERVER")),
&server_);
rtc_server = thread_l4tid(server_);
device_add_resource(rtc_server, RTC_PHYS, 0, MEMORY_RESOURCE, &env);
device_add_resource(rtc_server, INT_RTC, 0, INTERRUPT_RESOURCE, &env);
device = device_create(rtc_server, &me, RTC, &env);
rtc_device = device.ref.obj;
#endif // andy - 4
/* This is an example of how to setup a software rtc. */
#if 0
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VRTC_SERVER")),
&server_);
rtc_server = thread_l4tid(server_);
/* Create virtual timer and pass to rtc_device as a resource.*/
cap_t virtual_timer = virtual_timer_factory_create(timer_server,
timer_device,
&rtc_server,
0x3, NULL);
device_add_resource(rtc_server, timer_server.raw, virtual_timer.ref.obj, TIMER_RESOURCE, &env);
device = device_create(rtc_server, &me, RTC, &env);
rtc_device = device.ref.obj;
#endif
/* serial device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VSERIAL_SERVER")),
&server_);
serial_server = thread_l4tid(server_);
device_add_resource(serial_server, UART1_PHYS, 0, MEMORY_RESOURCE, &env);
device_add_resource(serial_server, INT_UART1, 0, INTERRUPT_RESOURCE, &env);
device = device_create(serial_server, &me, UART, &env);
serial_device = device.ref.obj;
#if 0 // andy - 5
/* touchscreen device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VTOUCH_SERVER")),
&server_);
ts_server = thread_l4tid(server_);
device_add_resource(ts_server, TS_PHYS, 0, MEMORY_RESOURCE, &env);
device_add_resource(ts_server, INT_TC, 0, INTERRUPT_RESOURCE, &env);
device_add_resource(ts_server, INT_ADC, 0, INTERRUPT_RESOURCE, &env);
device = device_create(ts_server, &me, VTOUCH, &env);
ts_device = device.ref.obj;
/* spi device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VBUS_SERVER")),
&server_);
spi_server = thread_l4tid(server_);
device_add_resource(spi_server, SPI_PHYS, 0, MEMORY_RESOURCE, &env);
device_add_resource(spi_server, INT_SPI1, 0, INTERRUPT_RESOURCE, &env);
device = device_create(spi_server, &me, SPI1, &env);
spi_device = device.ref.obj;
/* nand device */
memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VMTD_SERVER")),
&server_);
mtd_server = thread_l4tid(server_);
device_add_resource(mtd_server, MTD_PHYS, 0, MEMORY_RESOURCE, &env);
device = device_create(mtd_server, &me, NAND, &env);
mtd_device = device.ref.obj;
/* get a bus handle to provide to the lcd driver */
cap_t virtual_spi = virtual_bus_factory_create(spi_server, spi_device,
&lcd_server, 0, NULL);
#endif // andy - 5
/* lcd device */
// TEMP: REMOVED (jmatthews): causes NPE
/* memsection_lookup((objref_t) env_memsection_base(iguana_getenv("OKL4_VLCD_SERVER")), */
/* &server_); */
/* lcd_server = thread_l4tid(server_); */
/* device_add_resource(lcd_server, LCD_PHYS, 0, MEMORY_RESOURCE, &env); */
/* //device_add_resource(lcd_server, spi_server.raw, virtual_spi.ref.obj, BUS_RESOURCE, &env); */
/* device_add_resource(lcd_server, spi_server.raw, 0, BUS_RESOURCE, &env); */
/* device_add_resource(lcd_server, INT_LCD, 0, INTERRUPT_RESOURCE, &env); */
/* device = device_create(lcd_server, &me, LCD, &env); */
/* lcd_device = device.ref.obj; */
// And any other devices you care to add ...
return;
}
static int __init ig_input_init(void)
{
/* Called when we are initialising the device */
void *buffer_area, *control_area, *input_dev;
thread_ref_t server_;
L4_ThreadId_t server;
thread_ref_t dummy;
CORBA_Environment env;
memsection_ref_t memsect;
uintptr_t base;
int i, irq;
/* Allocate space for the input structure */
ig_input = kmalloc(sizeof(*ig_input), GFP_KERNEL);
input_dev = kmalloc(sizeof(struct input_dev), GFP_KERNEL);
buffer_area = kmalloc(BUFFER_SIZE, GFP_KERNEL);
control_area = kmalloc(sizeof(struct control_block), GFP_KERNEL);
if (!ig_input || !buffer_area || !control_area || !input_dev) {
kfree(ig_input);
kfree(buffer_area);
kfree(control_area);
kfree(input_dev);
return -ENOMEM;
}
memset(ig_input, 0, sizeof(*ig_input));
memset(input_dev, 0, sizeof(struct input_dev));
memset(buffer_area, 0, BUFFER_SIZE);
memset(control_area, 0, sizeof(struct control_block));
irq = iguana_alloc_irq();
printk("IG_KPP got IRQ %d\n", irq);
/* First, we find the input device */
memsection_lookup(env_memsection_base(iguana_getenv("OKL4_CORE_DEVICE_SERVER")),
&server_);
server = thread_l4tid(server_);
ig_input->dev = device_core_get_kpp(server, &ig_input->server,
&timer_thread, IGUANA_IRQ_NOTIFY_MASK(irq), &env);
/* Now, we add the kernel memory section to the server */
memsect = memsection_lookup((objref_t) buffer_area, &dummy);
ig_input->memsect_base = base = (uintptr_t) memsection_base(memsect);
virtual_kpp_add_memsection(ig_input->server, ig_input->dev, memsect, 0, &env);
/* Initialise the control block */
ig_input->control = control_area;
ig_input->control->rx = ~0;
ig_input->rx_last = NULL;
ig_input->free_list = buffer_area;
for (i=0; i < BUFFER_SIZE / sizeof(struct stream_packet); i++) {
ig_input->free_list[i].next = (uintptr_t) &ig_input->free_list[i+1];
ig_input->free_list[i].data_ptr = &ig_input->free_list[i].data;
//vaddr_to_memsect(ig_input, &ig_input->free_list[i].data);
}
ig_input->free_list[i-1].next = 0;
for (i = 0; i < BUFFER_SIZE / sizeof(struct stream_packet); i++) {
struct stream_packet *packet;
int new_q = 0;
packet = ig_input->free_list;
if (packet == NULL) {
panic("Iguana input driver corrupted\n");
}
ig_input->free_list = (void*) packet->next;
packet->next = ~0;
packet->size = PACKET_SIZE;
packet->xferred = 0;
packet->status = 0;
if (ig_input->rx_last != NULL) {
ig_input->rx_last->next = vaddr_to_memsect(ig_input, packet);
if (ig_input->rx_last->status & TERMINATED) {
new_q = 1;
}
} else {
new_q = 1;
}
if (new_q) {
ig_input->control->rx = vaddr_to_memsect(ig_input, packet);
}
ig_input->rx_last = packet;
}
/* Register the control block with the server */
virtual_kpp_register_control_block(ig_input->server,
ig_input->dev,
vaddr_to_memsect(ig_input, ig_input->control), &env);
ig_input->input_dev = input_dev;
ig_input->input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
set_bit(KEY_0, ig_input->input_dev->keybit);
set_bit(KEY_1, ig_input->input_dev->keybit);
set_bit(KEY_2, ig_input->input_dev->keybit);
set_bit(KEY_3, ig_input->input_dev->keybit);
set_bit(KEY_4, ig_input->input_dev->keybit);
set_bit(KEY_5, ig_input->input_dev->keybit);
set_bit(KEY_6, ig_input->input_dev->keybit);
set_bit(KEY_7, ig_input->input_dev->keybit);
set_bit(KEY_8, ig_input->input_dev->keybit);
set_bit(KEY_9, ig_input->input_dev->keybit);
set_bit(KEY_KPASTERISK, ig_input->input_dev->keybit);
set_bit(KEY_CHAT, ig_input->input_dev->keybit);
set_bit(KEY_F17, ig_input->input_dev->keybit);
set_bit(KEY_F18, ig_input->input_dev->keybit);
set_bit(KEY_F19, ig_input->input_dev->keybit);
set_bit(KEY_F20, ig_input->input_dev->keybit);
set_bit(KEY_F21, ig_input->input_dev->keybit);
set_bit(KEY_END, ig_input->input_dev->keybit);
set_bit(/*KEY_F22*/KEY_ENTER, ig_input->input_dev->keybit);
set_bit(KEY_F23, ig_input->input_dev->keybit);
set_bit(KEY_BACK, ig_input->input_dev->keybit);
set_bit(KEY_UP, ig_input->input_dev->keybit);
set_bit(KEY_DOWN, ig_input->input_dev->keybit);
set_bit(KEY_LEFT, ig_input->input_dev->keybit);
set_bit(KEY_RIGHT, ig_input->input_dev->keybit);
set_bit(BTN_LEFT, ig_input->input_dev->keybit);
set_bit(BTN_RIGHT, ig_input->input_dev->keybit);
set_bit(REL_X, ig_input->input_dev->relbit);
set_bit(REL_Y, ig_input->input_dev->relbit);
//set_bit(KEY_CONNECT, ig_input->input_dev->keybit);
//set_bit(KEY_FINANCE, ig_input->input_dev->keybit);
set_bit(/*KEY_F13*/KEY_F1, ig_input->input_dev->keybit);
set_bit(/*KEY_F14*/KEY_F2, ig_input->input_dev->keybit);
set_bit(/*KEY_F15*/KEY_F3, ig_input->input_dev->keybit);
set_bit(/*KEY_F16*/KEY_F4, ig_input->input_dev->keybit);
set_bit(KEY_HOME, ig_input->input_dev->keybit);
set_bit(KEY_POWER, ig_input->input_dev->keybit);
set_bit(KEY_VOLUMEDOWN, ig_input->input_dev->keybit);
set_bit(KEY_VOLUMEUP, ig_input->input_dev->keybit);
set_bit(KEY_RECORD, ig_input->input_dev->keybit);
ig_input->input_dev->name = "Iguana virtual input device";
request_irq(irq, ig_input_interrupt, 0,
ig_input->input_dev->name, ig_input->input_dev);
input_register_device(ig_input->input_dev);
return 0;
}
int
okl4_open(const char *path, int oflag, ...)
{
struct fdesc *f;
int fd, r;
int socket_vector[2];
const envitem_t *the_file;
memsection_ref_t file_memsec;
struct regfile *new_file;
/*
* check that the file exists
*/
if (path == NULL) {
errno = ENOENT;
return -1;
}
if (strcmp(path, "intervm_test") == 0) {
r = okl4_socketpair(0, SOCK_STREAM, 0, socket_vector, 1);
if (r < 0) {
return r;
}
return socket_vector[0];
}
if (strcmp(path, "serial") == 0) {
#ifdef __USE_POSIX
fd = 3;
while (ftable[fd].refcount > 0) {
fd++;
}
if (fd >= MAX_FILES) {
errno = ENFILE;
return -1;
}
f = &(ftable[fd]);
f->ftype = SERIAL;
f->refcount++;
f->U.s.serial = fopen("serial", "rw");
if (f->U.s.serial == NULL) {
f->refcount--;
return -1;
}
return fd;
#else
errno = ENXIO;
return -1;
#endif
}
if (strcmp(path, "test_file") != 0 && strcmp(path, "test_file_2") != 0) {
/*
* check that the flags are ok
*/
if ((oflag & O_WRONLY) == O_WRONLY || (oflag & O_CREAT) == O_CREAT
|| (oflag & O_TRUNC) == O_TRUNC) {
errno = EROFS;
return -1;
}
the_file = iguana_getenv(path);
if (the_file == NULL) {
errno = ENOENT;
return -1;
}
if (env_type(the_file) != ENV_MEMSECTION) {
errno = EINVAL;
return -1;
}
file_memsec = env_memsection(the_file);
new_file = env_memsection_base(the_file);
} else if (strcmp(path, "test_file") == 0) {
new_file = &test_file;
} else {
new_file = &test_file_2;
}
/*
* allocate a new file descriptor
*/
fd = 3;
while (ftable[fd].refcount > 0) {
fd++;
}
if (fd >= MAX_FILES) {
errno = ENFILE;
return -1;
}
f = &(ftable[fd]);
f->size = strtol(new_file->file_size, (char **)NULL, 10);
f->U.r.base = (uintptr_t)&(new_file->data);
f->ftype = REGULAR;
f->flags = oflag;
f->refcount++;
f->U.r.offset = 0;
return fd;
}
