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
