int open(const char *pathname, int flags, ...)
{
int fd = 99;
/* Ugly, but fine. */
if (!strncmp(pathname,LOG_PATH,strlen(LOG_PATH))) {
fd = alloc_fd(FTYPE_CONSOLE);
} else if (!strncmp(pathname, "/dev/mem", strlen("/dev/mem"))) {
fd = alloc_fd(FTYPE_MEM);
} else if (!strncmp(pathname, "/dev/ptmx", strlen("/dev/ptmx"))) {
fd = posix_openpt(flags);
} else if (!strncmp(pathname,SAVE_PATH,strlen(SAVE_PATH))) {
fd = open_savefile(pathname, flags & O_WRONLY);
} else if (!strcmp(pathname, "/etc/nsd/nsd.conf")) {
fd = open_compiled_file(CONFIGURATION, sizeof(CONFIGURATION) - 1, flags);
} else if (!strcmp(pathname, "/var/db/nsd/nsd.db")) {
fd = open_compiled_file(__nsd_database, sizeof(__nsd_database) - 1, flags);
} else if (!strcmp(pathname, "/var/run/nsd.pid")) {
errno = ENOENT;
fd = -1;
} else {
errno = EIO;
fd = -1;
}
printk("open(%s, %d) -> %d\n", pathname, flags, fd);
return fd;
}
static int auth_libwrap(CLI *c) {
#ifdef USE_LIBWRAP
struct request_info request;
int fd[2];
int result=0; /* deny by default */
if(pipe(fd)<0) {
ioerror("pipe");
return -1;
}
if(alloc_fd(fd[0]) || alloc_fd(fd[1]))
return -1;
switch(fork()) {
case -1: /* error */
close(fd[0]);
close(fd[1]);
ioerror("fork");
return -1;
case 0: /* child */
close(fd[0]); /* read side */
request_init(&request,
RQ_DAEMON, c->opt->servname, RQ_FILE, c->local_rfd.fd, 0);
fromhost(&request);
result=hosts_access(&request);
write_blocking(c, fd[1], (u8 *)&result, sizeof(result));
/* ignore the returned error */
close(fd[1]); /* write side */
_exit(0);
default: /* parent */
close(fd[1]); /* write side */
read_blocking(c, fd[0], (u8 *)&result, sizeof(result));
/* ignore the returned error */
close(fd[0]); /* read side */
/* no need to wait() for zombies here:
* - in UCONTEXT/PTHREAD mode they're removed using the signal pipe
* - in FORK mode they're removed with the client process */
}
if(!result) {
s_log(LOG_WARNING, "Connection from %s REFUSED by libwrap",
c->accepting_address);
s_log(LOG_DEBUG, "See hosts_access(5) manual for details");
return -1; /* FAILED */
}
s_log(LOG_DEBUG, "Connection from %s permitted by libwrap",
c->accepting_address);
#endif
return 0; /* OK */
}
int signal_pipe_init(void) {
if(pipe(signal_pipe)) {
ioerror("pipe");
exit(1);
}
alloc_fd(signal_pipe[0]);
alloc_fd(signal_pipe[1]);
#ifdef FD_CLOEXEC
/* close the pipe in child execvp */
fcntl(signal_pipe[0], F_SETFD, FD_CLOEXEC);
fcntl(signal_pipe[1], F_SETFD, FD_CLOEXEC);
#endif
signal(SIGCHLD, sigchld_handler);
return signal_pipe[0];
}
int fbfront_open(struct fbfront_dev *dev)
{
dev->fd = alloc_fd(FTYPE_FB);
printk("fb_open(%s) -> %d\n", dev->nodename, dev->fd);
files[dev->fd].fb.dev = dev;
return dev->fd;
}
int xc_gnttab_open(void)
{
int xcg_handle;
xcg_handle = alloc_fd(FTYPE_GNTMAP);
gntmap_init(&files[xcg_handle].gntmap);
return xcg_handle;
}
CRYSTAX_LOCAL
int open(const char *path, int oflag, va_list &vl)
{
DBG("path=%s, oflag=%d (%s)", path, oflag, mode_s(oflag));
driver_t *driver = find_driver(path);
if (!driver)
return -1;
DBG("use driver %s (%s)", driver->name(), driver->info());
int extfd = driver->open(path, oflag, vl);
DBG("extfd=%d", extfd);
if (extfd == -1)
return -1;
int fd = alloc_fd(path, extfd, driver);
if (fd < 0)
{
ERR("can't alloc fd, return -1");
driver->close(extfd);
errno = EMFILE;
return -1;
}
DBG("return fd=%d", fd);
return fd;
}
int kbdfront_open(struct kbdfront_dev *dev)
{
dev->fd = alloc_fd(FTYPE_KBD);
printk("kbd_open(%s) -> %d\n", dev->nodename, dev->fd);
files[dev->fd].kbd.dev = dev;
return dev->fd;
}
CRYSTAX_LOCAL
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
DBG("sockfd=%d, addrlen=%lu", sockfd, (unsigned long)addrlen);
int extfd;
if (!resolve(sockfd, NULL, &extfd, NULL, NULL))
return -1;
if (extfd == -1)
{
errno = EBADF;
return -1;
}
int extconnfd = system_connect(extfd, addr, addrlen);
if (extconnfd == -1)
return -1;
int connfd = alloc_fd(NULL, extconnfd, system::driver_t::instance());
if (connfd < 0)
{
system_close(extconnfd);
errno = EMFILE;
return -1;
}
DBG("return fd=%d", connfd);
return connfd;
}
static int
create_socket_fd(net_socket* socket, bool kernel)
{
// Get the socket's non-blocking flag, so we can set the respective
// open mode flag.
int32 nonBlock;
socklen_t nonBlockLen = sizeof(int32);
status_t error = sStackInterface->getsockopt(socket, SOL_SOCKET,
SO_NONBLOCK, &nonBlock, &nonBlockLen);
if (error != B_OK)
return error;
// allocate a file descriptor
file_descriptor* descriptor = alloc_fd();
if (descriptor == NULL)
return B_NO_MEMORY;
// init it
descriptor->type = FDTYPE_SOCKET;
descriptor->ops = &sSocketFDOps;
descriptor->u.socket = socket;
descriptor->open_mode = O_RDWR | (nonBlock ? O_NONBLOCK : 0);
// publish it
int fd = new_fd(get_current_io_context(kernel), descriptor);
if (fd < 0)
free(descriptor);
return fd;
}
static int connect_remote(CLI *c) { /* connect to remote host */
SOCKADDR_UNION bind_addr, addr;
SOCKADDR_LIST resolved_list, *address_list;
int error;
int s; /* destination socket */
u16 i;
/* setup address_list */
if(c->opt->option.delayed_lookup) {
resolved_list.num=0;
if(!name2addrlist(&resolved_list,
c->opt->remote_address, DEFAULT_LOOPBACK))
return -1; /* no host resolved */
address_list=&resolved_list;
} else /* use pre-resolved addresses */
address_list=&c->opt->remote_addr;
/* try to connect each host from the list */
for(i=0; i<address_list->num; i++) {
memcpy(&addr, address_list->addr + address_list->cur,
sizeof(SOCKADDR_UNION));
address_list->cur=(address_list->cur+1)%address_list->num;
/* race condition is possible, but harmless in this case */
if((s=socket(addr.sa.sa_family, SOCK_STREAM, 0))<0) {
sockerror("remote socket");
return -1;
}
if(alloc_fd(s))
return -1;
if(c->bind_addr.num) { /* explicit local bind or transparent proxy */
memcpy(&bind_addr, &c->bind_addr.addr[0], sizeof(SOCKADDR_UNION));
if(bind(s, &bind_addr.sa, addr_len(bind_addr))<0) {
sockerror("bind transparent");
closesocket(s);
return -1;
}
}
/* try to connect for the 1st time */
s_ntop(c->connecting_address, &addr);
s_log(LOG_DEBUG, "%s connecting %s",
c->opt->servname, c->connecting_address);
if(!connect(s, &addr.sa, addr_len(addr)))
return s; /* no error -> success (should not be possible) */
error=get_last_socket_error();
if(error!=EINPROGRESS && error!=EWOULDBLOCK) {
s_log(LOG_ERR, "remote connect (%s): %s (%d)",
c->connecting_address, my_strerror(error), error);
closesocket(s);
continue; /* next IP */
}
if(!connect_wait(c, s, c->opt->timeout_connect))
return s; /* success! */
closesocket(s); /* error -> next IP */
}
return -1;
}
grpc_fd *grpc_fd_create(int fd, const char *name) {
grpc_fd *r = alloc_fd(fd);
grpc_iomgr_register_object(&r->iomgr_object, name);
#ifdef GRPC_FD_REF_COUNT_DEBUG
gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, r, name);
#endif
return r;
}
void *client(void *arg) {
CLI *c=arg;
#ifdef DEBUG_STACK_SIZE
stack_info(1); /* initialize */
#endif
s_log(LOG_DEBUG, "%s started", c->opt->servname);
if(alloc_fd(c->local_rfd.fd))
return NULL;
if(c->local_wfd.fd!=c->local_rfd.fd)
if(alloc_fd(c->local_wfd.fd))
return NULL;
#ifndef USE_WIN32
if(c->opt->option.remote && c->opt->option.program)
c->local_rfd.fd=c->local_wfd.fd=connect_local(c);
/* connect and exec options specified together */
/* spawn local program instead of stdio */
#endif
c->remote_fd.fd=-1;
c->ssl=NULL;
cleanup(c, do_client(c));
#ifdef USE_FORK
if(!c->opt->option.remote) /* 'exec' specified */
child_status(); /* null SIGCHLD handler was used */
#else
enter_critical_section(CRIT_CLIENTS); /* for multi-cpu machines */
s_log(LOG_DEBUG, "%s finished (%d left)", c->opt->servname,
--num_clients);
leave_critical_section(CRIT_CLIENTS);
#endif
free(c);
#ifdef DEBUG_STACK_SIZE
stack_info(0); /* display computed value */
#endif
#ifdef USE_WIN32
_endthread();
#endif
#ifdef USE_UCONTEXT
s_log(LOG_DEBUG, "Context %ld closed", ready_head->id);
s_poll_wait(NULL, 0); /* wait on poll() */
s_log(LOG_ERR, "INTERNAL ERROR: failed to drop context");
#endif
return NULL;
}
int xc_evtchn_open(void)
{
int fd = alloc_fd(FTYPE_EVTCHN), i;
for (i = 0; i < MAX_EVTCHN_PORTS; i++) {
files[fd].evtchn.ports[i].port = -1;
files[fd].evtchn.ports[i].bound = 0;
}
printf("evtchn_open() -> %d\n", fd);
return fd;
}
static int auth_user(CLI *c) {
struct servent *s_ent; /* structure for getservbyname */
SOCKADDR_UNION ident; /* IDENT socket name */
int fd; /* IDENT socket descriptor */
char name[STRLEN];
int retval;
int error;
if(!c->opt->username)
return 0; /* -u option not specified */
if((fd=socket(c->peer_addr.addr[0].sa.sa_family, SOCK_STREAM, 0))<0) {
sockerror("socket (auth_user)");
return -1;
}
if(alloc_fd(fd))
return -1;
memcpy(&ident, &c->peer_addr.addr[0], sizeof(SOCKADDR_UNION));
s_ent=getservbyname("auth", "tcp");
if(s_ent) {
ident.in.sin_port=s_ent->s_port;
} else {
s_log(LOG_WARNING, "Unknown service 'auth': using default 113");
ident.in.sin_port=htons(113);
}
if(connect(fd, &ident.sa, addr_len(ident))) {
error=get_last_socket_error();
if(error!=EINPROGRESS && error!=EWOULDBLOCK) {
sockerror("ident connect (auth_user)");
closesocket(fd);
return -1;
}
if(connect_wait(c, fd, c->opt->timeout_connect)) { /* error */
closesocket(fd);
return -1;
}
}
s_log(LOG_DEBUG, "IDENT server connected");
if(fdprintf(c, fd, "%u , %u",
ntohs(c->peer_addr.addr[0].in.sin_port),
ntohs(c->opt->local_addr.addr[0].in.sin_port))<0) {
sockerror("fdprintf (auth_user)");
closesocket(fd);
return -1;
}
if(fdscanf(c, fd, "%*[^:]: USERID :%*[^:]:%s", name)!=1) {
s_log(LOG_ERR, "Incorrect data from IDENT server");
closesocket(fd);
return -1;
}
closesocket(fd);
retval=strcmp(name, c->opt->username) ? -1 : 0;
safestring(name);
s_log(LOG_INFO, "IDENT resolved remote user to %s", name);
return retval;
}
int socket(int domain, int type, int protocol)
{
int fd, res;
fd = lwip_socket(domain, type, protocol);
if (fd < 0)
return -1;
res = alloc_fd(FTYPE_SOCKET);
printk("socket -> %d\n", res);
files[res].socket.fd = fd;
return res;
}
int open(const char *pathname, int flags, ...)
{
int fd;
/* Ugly, but fine. */
if (!strncmp(pathname,LOG_PATH,strlen(LOG_PATH))) {
fd = alloc_fd(FTYPE_CONSOLE);
printk("open(%s) -> %d\n", pathname, fd);
return fd;
}
if (!strncmp(pathname, "/dev/mem", strlen("/dev/mem"))) {
fd = alloc_fd(FTYPE_MEM);
printk("open(/dev/mem) -> %d\n", fd);
return fd;
}
if (!strncmp(pathname, "/dev/ptmx", strlen("/dev/ptmx")))
return posix_openpt(flags);
if (!strncmp(pathname,SAVE_PATH,strlen(SAVE_PATH)))
return open_savefile(pathname, flags & O_WRONLY);
errno = EIO;
return -1;
}
int blkfront_open(struct blkfront_dev *dev)
{
/* Silently prevent multiple opens */
if(dev->fd != -1) {
return dev->fd;
}
dev->fd = alloc_fd(FTYPE_BLK);
printk("blk_open(%s) -> %d\n", dev->nodename, dev->fd);
files[dev->fd].blk.dev = dev;
files[dev->fd].blk.offset = 0;
return dev->fd;
}
int win32_spawn(int job_id, const char *cmd_line, const char **env, int env_count, const char *annotation, const char* echo_cmdline)
{
int result_code = 1;
char buffer[8192];
char env_block[128*1024];
HANDLE output_handle;
STARTUPINFO sinfo;
PROCESS_INFORMATION pinfo;
if (0 != make_env_block(env_block, sizeof(env_block) - 2, env, env_count))
{
fprintf(stderr, "%d: env block error; too big?\n", job_id);
return 1;
}
_snprintf(buffer, sizeof(buffer), "cmd.exe /c \"%s\"", cmd_line);
output_handle = alloc_fd(job_id);
memset(&pinfo, 0, sizeof(pinfo));
memset(&sinfo, 0, sizeof(sinfo));
sinfo.cb = sizeof(sinfo);
sinfo.hStdInput = NULL;
sinfo.hStdOutput = sinfo.hStdError = output_handle;
sinfo.dwFlags = STARTF_USESTDHANDLES;
if (annotation)
println_to_handle(output_handle, annotation);
if (echo_cmdline)
println_to_handle(output_handle, echo_cmdline);
if (CreateProcess(NULL, buffer, NULL, NULL, TRUE, 0, env_block, NULL, &sinfo, &pinfo))
{
DWORD result;
CloseHandle(pinfo.hThread);
while (WAIT_OBJECT_0 != WaitForSingleObject(pinfo.hProcess, INFINITE))
/* nop */;
GetExitCodeProcess(pinfo.hProcess, &result);
CloseHandle(pinfo.hProcess);
result_code = (int) result;
}
else
{
fprintf(stderr, "%d: Couldn't launch process; Win32 error = %d\n", job_id, (int) GetLastError());
}
free_fd(job_id, output_handle);
return result_code;
}
int posix_openpt(int flags)
{
struct consfront_dev *dev;
/* Ignore flags */
dev = init_consfront(NULL);
dev->fd = alloc_fd(FTYPE_CONSOLE);
files[dev->fd].cons.dev = dev;
printk("fd(%d) = posix_openpt\n", dev->fd);
return(dev->fd);
}
int tpm_tis_open(struct tpm_chip* tpm)
{
/* Silently prevent multiple opens */
if(tpm->fd != -1) {
return tpm->fd;
}
tpm->fd = alloc_fd(FTYPE_TPM_TIS);
printk("tpm_tis_open() -> %d\n", tpm->fd);
files[tpm->fd].tpm_tis.dev = tpm;
files[tpm->fd].tpm_tis.offset = 0;
files[tpm->fd].tpm_tis.respgot = 0;
return tpm->fd;
}
int tpmfront_open(struct tpmfront_dev* dev)
{
/* Silently prevent multiple opens */
if(dev->fd != -1) {
return dev->fd;
}
dev->fd = alloc_fd(FTYPE_TPMFRONT);
printk("tpmfront_open(%s) -> %d\n", dev->nodename, dev->fd);
files[dev->fd].tpmfront.dev = dev;
files[dev->fd].tpmfront.offset = 0;
files[dev->fd].tpmfront.respgot = 0;
return dev->fd;
}
static int open_compiled_file(const unsigned char *content, off_t size, int flags)
{
int fd;
if (flags != 0) {
errno = EPERM;
return -1;
}
fd = alloc_fd(FTYPE_COMPILED_FILE);
files[fd].compiled_file.offset = 0;
files[fd].compiled_file.size = size;
files[fd].compiled_file.content = content;
return fd;
}
int netfront_tap_open(char *nodename) {
struct netfront_dev *dev;
dev = init_netfront(nodename, NETIF_SELECT_RX, NULL, NULL);
if (!dev) {
printk("TAP open failed\n");
errno = EIO;
return -1;
}
dev->fd = alloc_fd(FTYPE_TAP);
printk("tap_open(%s) -> %d\n", nodename, dev->fd);
files[dev->fd].tap.dev = dev;
return dev->fd;
}
int open_savefile(const char *path, int save)
{
struct consfront_dev *dev;
char nodename[64];
snprintf(nodename, sizeof(nodename), "device/console/%d", save ? SAVE_CONSOLE : RESTORE_CONSOLE);
dev = init_consfront(nodename);
dev->fd = alloc_fd(FTYPE_SAVEFILE);
files[dev->fd].cons.dev = dev;
printk("fd(%d) = open_savefile\n", dev->fd);
return(dev->fd);
}
int accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
int fd, res;
if (files[s].type != FTYPE_SOCKET) {
printk("accept(%d): Bad descriptor\n", s);
errno = EBADF;
return -1;
}
fd = lwip_accept(files[s].socket.fd, addr, addrlen);
if (fd < 0)
return -1;
res = alloc_fd(FTYPE_SOCKET);
files[res].socket.fd = fd;
printk("accepted on %d -> %d\n", s, res);
return res;
}
CAMLprim value lwt_glib_get_sources(value Unit)
{
gint timeout;
int i;
int events;
GPollFD *gpollfd;
CAMLparam0();
CAMLlocal3(fds, watches, result);
g_main_context_dispatch(gc);
g_main_context_prepare(gc, &max_priority);
while (fds_count < (n_fds = g_main_context_query(gc, max_priority, &timeout, gpollfds, fds_count))) {
free(gpollfds);
fds_count = n_fds;
gpollfds = lwt_unix_malloc(fds_count * sizeof (GPollFD));
}
fds = caml_alloc_tuple(n_fds);
watches = caml_alloc_tuple(n_fds);
for (i = 0; i < n_fds; i++) {
gpollfd = gpollfds + i;
gpollfd->revents = 0;
events = 0;
if (gpollfd->events & G_IO_IN) events |= 1;
if (gpollfd->events & G_IO_OUT) events |= 2;
#if defined(LWT_ON_WINDOWS)
/* On windows, glib file descriptors are handles */
Field(fds, i) = alloc_fd((HANDLE)gpollfd->fd);
#else
Field(fds, i) = Val_int(gpollfd->fd);
if (gpollfd->fd < 0) events = 0;
#endif
Field(watches, i) = Val_int(events);
}
result = caml_alloc_tuple(3);
Store_field(result, 0, fds);
Store_field(result, 1, watches);
Store_field(result, 2, caml_copy_double(timeout * 1e-3));
CAMLreturn(result);
}
static void daemon_loop(void) {
SOCKADDR_UNION addr;
s_poll_set fds;
LOCAL_OPTIONS *opt;
get_limits();
s_poll_zero(&fds);
#ifndef USE_WIN32
s_poll_add(&fds, signal_pipe_init(), 1, 0);
#endif
if(!local_options.next) {
s_log(LOG_ERR, "No connections defined in config file");
exit(1);
}
num_clients=0;
/* bind local ports */
for(opt=local_options.next; opt; opt=opt->next) {
if(!opt->option.accept) /* no need to bind this service */
continue;
memcpy(&addr, &opt->local_addr.addr[0], sizeof(SOCKADDR_UNION));
if((opt->fd=socket(addr.sa.sa_family, SOCK_STREAM, 0))<0) {
sockerror("local socket");
exit(1);
}
if(alloc_fd(opt->fd))
exit(1);
if(set_socket_options(opt->fd, 0)<0)
exit(1);
s_ntop(opt->local_address, &addr);
if(bind(opt->fd, &addr.sa, addr_len(addr))) {
s_log(LOG_ERR, "Error binding %s to %s",
opt->servname, opt->local_address);
sockerror("bind");
exit(1);
}
s_log(LOG_DEBUG, "%s bound to %s", opt->servname, opt->local_address);
if(listen(opt->fd, 5)) {
sockerror("listen");
exit(1);
}
#ifdef FD_CLOEXEC
fcntl(opt->fd, F_SETFD, FD_CLOEXEC); /* close socket in child execvp */
#endif
s_poll_add(&fds, opt->fd, 1, 0);
}
#if !defined (USE_WIN32) && !defined (__vms)
if(!(options.option.foreground))
daemonize();
drop_privileges();
create_pid();
#endif /* !defined USE_WIN32 && !defined (__vms) */
/* create exec+connect services */
for(opt=local_options.next; opt; opt=opt->next) {
if(opt->option.accept) /* skip ordinary (accepting) services */
continue;
enter_critical_section(CRIT_CLIENTS); /* for multi-cpu machines */
num_clients++;
leave_critical_section(CRIT_CLIENTS);
create_client(-1, -1, alloc_client_session(opt, -1, -1), client);
}
while(1) {
if(s_poll_wait(&fds, -1)<0) /* non-critical error */
log_error(LOG_INFO, get_last_socket_error(),
"daemon_loop: s_poll_wait");
else
for(opt=local_options.next; opt; opt=opt->next)
if(s_poll_canread(&fds, opt->fd))
accept_connection(opt);
}
s_log(LOG_ERR, "INTERNAL ERROR: End of infinite loop 8-)");
}
static struct netfront_dev *_init_netfront(struct netfront_dev *dev,
unsigned char rawmac[6],
char **ip)
{
xenbus_transaction_t xbt;
char* err = NULL;
const char* message=NULL;
struct netif_tx_sring *txs;
struct netif_rx_sring *rxs;
int feature_split_evtchn;
int retry=0;
int i;
char* msg = NULL;
char path[256];
snprintf(path, sizeof(path), "%s/backend-id", dev->nodename);
dev->dom = xenbus_read_integer(path);
snprintf(path, sizeof(path), "%s/backend", dev->nodename);
msg = xenbus_read(XBT_NIL, path, &dev->backend);
snprintf(path, sizeof(path), "%s/mac", dev->nodename);
msg = xenbus_read(XBT_NIL, path, &dev->mac);
if ((dev->backend == NULL) || (dev->mac == NULL)) {
printk("%s: backend/mac failed\n", __func__);
goto error;
}
#ifdef CONFIG_NETMAP
snprintf(path, sizeof(path), "%s/feature-netmap", dev->backend);
dev->netmap = xenbus_read_integer(path) > 0 ? 1 : 0;
if (dev->netmap) {
dev->na = init_netfront_netmap(dev, dev->netif_rx);
goto skip;
}
#endif
/* Check feature-split-event-channels */
snprintf(path, sizeof(path), "%s/feature-split-event-channels",
dev->backend);
feature_split_evtchn = xenbus_read_integer(path) > 0 ? 1 : 0;
#ifdef HAVE_LIBC
/* Force the use of a single event channel */
if (dev->netif_rx == NETIF_SELECT_RX)
feature_split_evtchn = 0;
#endif
printk("************************ NETFRONT for %s **********\n\n\n",
dev->nodename);
init_SEMAPHORE(&dev->tx_sem, NET_TX_RING_SIZE);
for(i=0;i<NET_TX_RING_SIZE;i++)
{
add_id_to_freelist(i,dev->tx_freelist);
#if defined CONFIG_NETFRONT_PERSISTENT_GRANTS || !defined CONFIG_NETFRONT_LWIP_ONLY
dev->tx_buffers[i].page = (void*)alloc_page();
BUG_ON(dev->tx_buffers[i].page == NULL);
#ifdef CONFIG_NETFRONT_PERSISTENT_GRANTS
dev->tx_buffers[i].gref = gnttab_grant_access(dev->dom,
virt_to_mfn(dev->tx_buffers[i].page), 0);
BUG_ON(dev->tx_buffers[i].gref == GRANT_INVALID_REF);
dprintk("tx[%d]: page = %p, gref=0x%x\n", i, dev->tx_buffers[i].page, dev->tx_buffers[i].gref);
#endif
#endif
}
#if defined CONFIG_NETFRONT_PERSISTENT_GRANTS || !defined CONFIG_NETFRONT_LWIP_ONLY
printk("net TX ring size %d, %lu KB\n", NET_TX_RING_SIZE, (unsigned long)(NET_TX_RING_SIZE * PAGE_SIZE)/1024);
#else
printk("net TX ring size %d\n", NET_TX_RING_SIZE);
#endif
#ifdef CONFIG_NETFRONT_PERSISTENT_GRANTS
for(i=0;i<NET_RX_RING_SIZE;i++)
{
/* TODO: that's a lot of memory */
dev->rx_buffers[i].page = (void*)alloc_page();
BUG_ON(dev->rx_buffers[i].page == NULL);
dprintk("rx[%d]: page = %p\n", i, dev->rx_buffers[i].page);
}
printk("net RX ring size %d, %lu KB\n", NET_RX_RING_SIZE, (unsigned long)(NET_RX_RING_SIZE * PAGE_SIZE)/1024);
#else
for(i=0;i<NET_RX_RING_SIZE;i++)
dev->rx_buffers[i] = NULL;
for(i=0;i<NET_RX_BUFFERS;i++)
{
/* allocate rx buffer pool */
dev->rx_buffer_pool[i].page = (void*)alloc_page();
BUG_ON(dev->rx_buffer_pool[i].page == NULL);
dprintk("rx[%d]: page = %p\n", i, dev->rx_buffer_pool[i].page);
add_id_to_freelist(i,dev->rx_freelist);
}
dev->rx_avail = NET_RX_BUFFERS;
printk("net RX ring size %d, %lu KB buffer space\n", NET_RX_RING_SIZE, (unsigned long)(NET_RX_BUFFERS * PAGE_SIZE)/1024);
#endif
if (feature_split_evtchn) {
evtchn_alloc_unbound(dev->dom, netfront_tx_handler, dev,
&dev->tx_evtchn);
evtchn_alloc_unbound(dev->dom, netfront_rx_handler, dev,
&dev->rx_evtchn);
printk("split event channels enabled\n");
} else {
#ifdef HAVE_LIBC
if (dev->netif_rx == NETIF_SELECT_RX)
evtchn_alloc_unbound(dev->dom, netfront_select_handler,
dev, &dev->tx_evtchn);
else
#endif
evtchn_alloc_unbound(dev->dom, netfront_handler,
dev, &dev->tx_evtchn);
dev->rx_evtchn = dev->tx_evtchn;
}
#ifdef CONFIG_NETFRONT_PERSISTENT_GRANTS
printk("persistent grants enabled\n");
#endif
txs = (struct netif_tx_sring *) alloc_page();
rxs = (struct netif_rx_sring *) alloc_page();
memset(txs,0,PAGE_SIZE);
memset(rxs,0,PAGE_SIZE);
SHARED_RING_INIT(txs);
SHARED_RING_INIT(rxs);
FRONT_RING_INIT(&dev->tx, txs, PAGE_SIZE);
FRONT_RING_INIT(&dev->rx, rxs, PAGE_SIZE);
dev->tx_ring_ref = gnttab_grant_access(dev->dom,virt_to_mfn(txs),0);
BUG_ON(dev->tx_ring_ref == GRANT_INVALID_REF);
dev->rx_ring_ref = gnttab_grant_access(dev->dom,virt_to_mfn(rxs),0);
BUG_ON(dev->rx_ring_ref == GRANT_INVALID_REF);
init_rx_buffers(dev);
dev->events = NULL;
again:
err = xenbus_transaction_start(&xbt);
if (err) {
printk("starting transaction\n");
free(err);
}
err = xenbus_printf(xbt, dev->nodename, "tx-ring-ref","%u",
dev->tx_ring_ref);
if (err) {
message = "writing tx ring-ref";
goto abort_transaction;
}
err = xenbus_printf(xbt, dev->nodename, "rx-ring-ref","%u",
dev->rx_ring_ref);
if (err) {
message = "writing rx ring-ref";
goto abort_transaction;
}
if (feature_split_evtchn) {
err = xenbus_printf(xbt, dev->nodename,
"event-channel-tx", "%u", dev->tx_evtchn);
if (err) {
message = "writing event-channel-tx";
goto abort_transaction;
}
err = xenbus_printf(xbt, dev->nodename,
"event-channel-rx", "%u", dev->rx_evtchn);
if (err) {
message = "writing event-channel-rx";
goto abort_transaction;
}
} else {
err = xenbus_printf(xbt, dev->nodename,
"event-channel", "%u", dev->tx_evtchn);
if (err) {
message = "writing event-channel";
goto abort_transaction;
}
}
err = xenbus_printf(xbt, dev->nodename, "feature-rx-notify", "%u", 1);
if (err) {
message = "writing feature-rx-notify";
goto abort_transaction;
}
#ifdef CONFIG_NETFRONT_PERSISTENT_GRANTS
err = xenbus_printf(xbt, dev->nodename, "feature-persistent", "%u", 1);
if (err) {
message = "writing feature-persistent";
goto abort_transaction;
}
#endif
err = xenbus_printf(xbt, dev->nodename, "request-rx-copy", "%u", 1);
if (err) {
message = "writing request-rx-copy";
goto abort_transaction;
}
#if defined(CONFIG_NETFRONT_GSO) && defined(HAVE_LWIP)
err = xenbus_printf(xbt, dev->nodename, "feature-sg", "%u", 1);
if (err) {
message = "writing feature-sg";
goto abort_transaction;
}
err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv4", "%u", 1);
if (err) {
message = "writing feature-gso-tcpv4";
goto abort_transaction;
}
err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv6", "%u", 1);
if (err) {
message = "writing feature-gso-tcpv6";
goto abort_transaction;
}
#endif
snprintf(path, sizeof(path), "%s/state", dev->nodename);
err = xenbus_switch_state(xbt, path, XenbusStateConnected);
if (err) {
message = "switching state";
goto abort_transaction;
}
err = xenbus_transaction_end(xbt, 0, &retry);
free(err);
if (retry) {
goto again;
printk("completing transaction\n");
}
goto done;
abort_transaction:
free(err);
err = xenbus_transaction_end(xbt, 1, &retry);
printk("Abort transaction %s\n", message);
goto error;
done:
snprintf(path, sizeof(path), "%s/mac", dev->nodename);
msg = xenbus_read(XBT_NIL, path, &dev->mac);
if (dev->mac == NULL) {
printk("%s: backend/mac failed\n", __func__);
goto error;
}
printk("backend at %s\n",dev->backend);
printk("mac is %s\n",dev->mac);
{
XenbusState state;
char path[strlen(dev->backend) + strlen("/state") + 1];
snprintf(path, sizeof(path), "%s/state", dev->backend);
xenbus_watch_path_token(XBT_NIL, path, path, &dev->events);
err = NULL;
state = xenbus_read_integer(path);
while (err == NULL && state < XenbusStateConnected)
err = xenbus_wait_for_state_change(path, &state, &dev->events);
if (state != XenbusStateConnected) {
printk("backend not avalable, state=%d\n", state);
xenbus_unwatch_path_token(XBT_NIL, path, path);
goto error;
}
if (ip) {
snprintf(path, sizeof(path), "%s/ip", dev->backend);
xenbus_read(XBT_NIL, path, ip);
}
}
printk("**************************\n");
unmask_evtchn(dev->tx_evtchn);
if (feature_split_evtchn)
unmask_evtchn(dev->rx_evtchn);
#ifdef CONFIG_NETMAP
skip:
if (dev->netmap)
connect_netfront(dev);
#endif
/* Special conversion specifier 'hh' needed for __ia64__. Without
this mini-os panics with 'Unaligned reference'. */
if (rawmac)
sscanf(dev->mac,"%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
&rawmac[0],
&rawmac[1],
&rawmac[2],
&rawmac[3],
&rawmac[4],
&rawmac[5]);
#ifdef CONFIG_SELECT_POLL
dev->fd = alloc_fd(FTYPE_TAP);
files[dev->fd].read = 0;
#endif
#ifdef CONFIG_NETFRONT_STATS
netfront_reset_txcounters(dev);
#endif
return dev;
error:
free(msg);
free(err);
free_netfront(dev);
return NULL;
}
grpc_fd *grpc_fd_create(int fd, const char *name) {
grpc_fd *r = alloc_fd(fd);
grpc_iomgr_register_object(&r->iomgr_object, name);
grpc_pollset_add_fd(grpc_backup_pollset(), r);
return r;
}
grpc_fd *grpc_fd_create(int fd, const char *name) {
grpc_fd *r = alloc_fd(fd);
grpc_iomgr_register_object(&r->iomgr_object, name);
return r;
}
