int close(int fd) { int ret; struct fdtab_entry *e = fdtab_get(fd); if (e->type == FDTAB_TYPE_AVAILABLE) { return -1; } if (e->type == FDTAB_TYPE_LWIP_SOCKET) { if(e->inherited) { // Perform shallow close on lwip so that it will not terminate // the TCP session printf("close: Inherited socket, not closing completely\n"); ret = 0; } else { ret = lwip_close(e->fd); if(ret < 0) { POSIXCOMPAT_DEBUG("[%d]error in lwip_close\n", disp_get_domain_id()); return -1; } } fdtab_free(fd); } else { ret = vfsfd_close(fd); } return ret; }
int close(int fd) { int ret; struct fdtab_entry *e = fdtab_get(fd); if (e->type == FDTAB_TYPE_AVAILABLE) { return -1; } // Might need to remove from epoll list if(e->epoll_fd != -1) { ret = epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, fd, NULL); assert(ret == 0); } switch(e->type) { case FDTAB_TYPE_LWIP_SOCKET: if (e->inherited) { // Perform shallow close on lwip so that it will not terminate // the TCP session printf("close: Inherited socket, not closing completely\n"); ret = 0; } else { ret = lwip_close(e->fd); if(ret < 0) { POSIXCOMPAT_DEBUG("[%d]error in lwip_close\n", disp_get_domain_id()); return -1; } } fdtab_free(fd); break; case FDTAB_TYPE_PTM: ret = ptm_close(fd); break; case FDTAB_TYPE_PTS: ret = pts_close(fd); break; default: ret = vfsfd_close(fd); } return ret; }
static void remaining_lwip_initialization(char *card_name, uint64_t queueid) { nb = netbench_alloc("app", RECORDED_EVENTS_COUNT); //asq: connect to the NIC driver, before doing anything else idc_connect_to_driver(card_name, queueid); DEBUGPRINTPS("Connected to driver [%s]\n", card_name); stats_init(); sys_init(); DEBUGPRINTPS("remaining_lwip_init: allocating pbuf memory\n"); #ifdef CONFIG_QEMU_NETWORK printf("#### Networking with small amount of memory #####\n"); #endif // CONFIG_QEMU_NETWORK printf("#### [%u:%"PRIuDOMAINID":%s] [%s] [%d] MEM_SIZE[%d], " "PBUF_POOL_SIZE[%d], MEMP_MAX[%d], RECEIVE_BUFFERS[%d] qid[%"PRIu64"]####\n", disp_get_core_id(), disp_get_domain_id(), disp_name(), MEM_CONF_LOC, is_ctl, MEM_SIZE, PBUF_POOL_SIZE, MEMP_MAX, RECEIVE_BUFFERS, queueid); memp_init(); // 0'st buffer DEBUGPRINTPS("remaining_lwip_init: allocating memory for sending\n"); mem_init(); // 1'th buffer DEBUGPRINTPS("remaining_lwip_init: done with memroy allocation\n"); DEBUGPRINTPS("LWIP: lwip_starting\n"); netif_init(); #if LWIP_SOCKET lwip_socket_init(); #endif /* LWIP_SOCKET */ ip_init(); DEBUGPRINTPS("r_lwip_init: done ip_init\n"); #if LWIP_ARP etharp_init(); #endif /* LWIP_ARP */ #if LWIP_RAW raw_init(); #endif /* LWIP_RAW */ #if LWIP_UDP udp_init(); DEBUGPRINTPS("r_lwip_init: done udp_init\n"); #endif /* LWIP_UDP */ #if LWIP_TCP tcp_init(); DEBUGPRINTPS("r_lwip_init: done tcp_init\n"); #endif /* LWIP_TCP */ #if LWIP_SNMP snmp_init(); DEBUGPRINTPS("r_lwip_init: done snmp_init\n"); #endif /* LWIP_SNMP */ #if LWIP_AUTOIP autoip_init(); DEBUGPRINTPS("r_lwip_init: done autoip_init\n"); #endif /* LWIP_AUTOIP */ #if LWIP_IGMP igmp_init(); DEBUGPRINTPS("r_lwip_init: done igmp_init\n"); #endif /* LWIP_IGMP */ DEBUGPRINTPS("r_lwip_init: done2 igmp_init\n"); #if LWIP_DNS DEBUGPRINTPS("r_lwip_init: starting DNS_init\n"); dns_init(); DEBUGPRINTPS("r_lwip_init: done DNS_init\n"); #endif /* LWIP_DNS */ DEBUGPRINTPS("LWIP: lwip_started\n"); }
int main(int argc, char *argv[]) { BLINK_PRINT(("%s, pid: %u\r\n", disp_name(), disp_get_domain_id())); uint32_t blink_rate = (argc > 1) ? atoi(argv[1]) : 1; uint32_t no_of_blinks = (argc > 2) ? atoi(argv[2]) : 10; delayus_t delay = 1000.0/(float)blink_rate; errval_t err; struct capref retcap; size_t retlen; err = aos_rpc_get_dev_cap(&local_rpc, OMAP44XX_MAP_L4_PER_UART3, OMAP44XX_MAP_L4_PER_UART3_SIZE, &retcap, &retlen); if (err_is_fail(err)) { debug_printf("Failed to get IO Cap from init... %s\n"); err_print_calltrace(err); abort(); } BLINK_PRINT("dev cap received, dev mapped. OK\r\n"); size_t offset = GPIO1_BASE - 0x40000000; lvaddr_t uart_addr = (1UL << 28)*3; err = paging_map_user_device(get_current_paging_state(), uart_addr, retcap, offset, OMAP44XX_MAP_L4_PER_UART3_SIZE, VREGION_FLAGS_READ_WRITE_NOCACHE); set_gpio1_registers(uart_addr); BLINK_PRINT("user device registers set. OK\r\n"); err = periodic_event_create(&pe, get_default_waitset(), delay, MKCLOSURE((void *) blink_led, NULL)); if (err_is_fail(err)) { DEBUG_ERR(err, "failed to register periodic event!\n"); err_print_calltrace(err); } else { BLINK_PRINT("periodic event registered.\r\n"); } for(uint32_t i = 0; i < no_of_blinks; i++) { err = event_dispatch(get_default_waitset()); if (err_is_fail(err)) { DEBUG_ERR(err, "failed to dispatch event\n"); err_print_calltrace(err); } } err = periodic_event_cancel(&pe); if(err_is_fail(err)){ err_print_calltrace(err); abort(); } BLINK_PRINT("blink exiting\n"); err = aos_rpc_send_string(&local_rpc, "bye"); if (err_is_fail(err)) { DEBUG_ERR(err, "fail to say bye\n"); err_print_calltrace(err); } return 0; }
//XXX: flags are ignored... int vfsfd_open(const char *pathname, int flags) { vfs_handle_t vh; errval_t err; char *path = vfs_path_mkabs(pathname); assert(path != NULL); // If O_CREAT was given, we use vfs_create() if(flags & O_CREAT) { // If O_EXCL was also given, we check whether we can open() first if(flags & O_EXCL) { err = vfs_open(path, &vh); if(err_is_ok(err)) { vfs_close(vh); errno = EEXIST; return -1; } assert(err_no(err) == FS_ERR_NOTFOUND); } err = vfs_create(path, &vh); } else { // Regular open() err = vfs_open(path, &vh); } free(path); if (err_is_fail(err)) { VFSFD_DEBUG("open('%s') failed\n", pathname); switch(err_no(err)) { case FS_ERR_NOTFOUND: errno = ENOENT; break; default: #ifdef VFSFD_DEBUG_ENABLED DEBUG_ERR(err, "vfs_open"); #endif break; } return -1; } struct fdtab_entry e = { .type = FDTAB_TYPE_FILE, .handle = vh, .epoll_fd = -1, }; int fd = fdtab_alloc(&e); VFSFD_DEBUG("open(%s) as fd %d\n", pathname, fd); if (fd < 0) { vfs_close(vh); return -1; } else { return fd; } } int vfsfd_read(int fd, void *buf, size_t len) { struct fdtab_entry *e = fdtab_get(fd); size_t retlen = 0; switch(e->type) { case FDTAB_TYPE_FILE: { errval_t err = vfs_read((vfs_handle_t)e->handle, buf, len, &retlen); VFSFD_DEBUG("%d : read(%d, %d) = %lu\n", disp_get_domain_id(), fd, len, retlen); if (err_is_fail(err)) { DEBUG_ERR(err, "error in vfs_read"); return -1; } } break; case FDTAB_TYPE_STDIN: retlen = terminal_read((char *)buf, len); break; case FDTAB_TYPE_STDOUT: case FDTAB_TYPE_STDERR: case FDTAB_TYPE_AVAILABLE: default: return -1; } return retlen; } int vfsfd_write(int fd, const void *buf, size_t len) { struct fdtab_entry *e = fdtab_get(fd); if (e->type == FDTAB_TYPE_AVAILABLE) { return -1; } size_t retlen = 0; switch(e->type) { case FDTAB_TYPE_FILE: { errval_t err = vfs_write((vfs_handle_t)e->handle, buf, len, &retlen); VFSFD_DEBUG("write(%d, %d) = %lu\n", fd, len, retlen); if (err_is_fail(err)) { DEBUG_ERR(err, "error in vfs_write"); return -1; } } break; case FDTAB_TYPE_STDOUT: /* only support writting to terminal */ retlen = terminal_write((const char*) buf, len); break; case FDTAB_TYPE_STDERR: retlen = terminal_write((const char*) buf, len); break; case FDTAB_TYPE_STDIN: case FDTAB_TYPE_AVAILABLE: default: return -1; } return retlen; } int vfsfd_close(int fd) { errval_t err; struct fdtab_entry *e = fdtab_get(fd); if (e->type == FDTAB_TYPE_AVAILABLE) { return -1; } VFSFD_DEBUG("close(%d)\n", fd); switch(e->type) { case FDTAB_TYPE_FILE: err = vfs_close((vfs_handle_t)e->handle); if (err_is_fail(err)) { DEBUG_ERR(err, "error in vfs_close"); return -1; } break; case FDTAB_TYPE_STDIN: case FDTAB_TYPE_STDOUT: case FDTAB_TYPE_STDERR: // XXX: Should call fclose() when closing last FD break; default: return -1; } // end switch fdtab_free(fd); return 0; }
int main(int argc, char *argv[]) { struct ip_addr peer_ip; // IP address of peer uint16_t port = 0; // Port number of the peer ws = get_default_waitset(); // Parse args if (argc != 5) { printf("Usage: %s <direction> <IP> <Port> <packets * %d>\n", argv[0], MULTIPLIER); printf("eg (to send microbenchmark): %s 1 10.110.4.41 3000 1000\n", argv[0]); printf("eg (to recv microbenchmark): %s 0 10.110.4.41 3000 1000\n", argv[0]); return 1; } // Flag to choose between sender(1) and receiver(0) int as_sender = atoi(argv[1]); struct in_addr peer_ip_gen; int ret = inet_aton(argv[2], &peer_ip_gen); if (ret == 0) { printf("Invalid IP addr: %s\n", argv[2]); return 1; } // end if : ip validation peer_ip.addr = peer_ip_gen.s_addr; port = atoi(argv[3]); if (port <= 0) { printf("Invalid port given [%s] == [%"PRIu16"]\n", argv[3], port); return 1; } // end if : port validation iterations = atoi(argv[4]); if (iterations <= 0) { printf("Invalid no. of iterations [%s] == [%"PRIu64"]\n", argv[4], iterations); return 1; } // end if : port validation iterations = iterations * MULTIPLIER; if (lwip_init_auto() == false) { printf("ERROR: lwip_init_auto failed!\n"); return 1; } // lwip_init("e1000"); // create pcb for connection struct udp_pcb *upcb; upcb = udp_new(); assert(upcb != NULL); printf("U: #####################################\n"); printf("U: %d.%"PRIuDOMAINID": Performing [%"PRIu64"] iterations\n", disp_get_core_id(), disp_get_domain_id(), iterations); #if UDP_BENCHMARK_TRACE errval_t err = trace_control(TRACE_EVENT(TRACE_SUBSYS_BNET, TRACE_EVENT_BNET_START, 0), TRACE_EVENT(TRACE_SUBSYS_BNET, TRACE_EVENT_BNET_STOP, 0), 0); if(err_is_fail(err)) { USER_PANIC_ERR(err, "trace_control failed"); } printf("U: Tracing enabled!!!!\n"); // trace_event(TRACE_SUBSYS_BNET, TRACE_EVENT_BNET_START, 0); #endif // UDP_BENCHMARK_TRACE if(as_sender == 1) { udp_sender(upcb, peer_ip, port); } else { udp_receiver(upcb, IP_ADDR_ANY, port); } // end else: printf("U: Init finished.\n"); while (1) { errval_t r = event_dispatch(ws); if (err_is_fail(r)) { DEBUG_ERR(r, "in event_dispatch"); break; } } udp_remove(upcb); } // end function: main