/* * $Id$ */ #define RTEMS_FAST_MUTEX #ifdef RTEMS_FAST_MUTEX #define __RTEMS_VIOLATE_KERNEL_VISIBILITY__ 1 #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * Memory allocation */ static int nmbuf = (64 * 1024) / MSIZE; int nmbclusters = (128 * 1024) / MCLBYTES; /* * Socket buffering parameters */ unsigned long sb_efficiency = 8; /* * Network task synchronization */ static rtems_id networkSemaphore; #ifdef RTEMS_FAST_MUTEX Semaphore_Control *the_networkSemaphore; #endif static rtems_id networkDaemonTid; static rtems_unsigned32 networkDaemonPriority; static void networkDaemon (void *task_argument); /* * Network timing */ int rtems_bsdnet_ticks_per_second; int rtems_bsdnet_microseconds_per_tick; /* * Callout processing */ static rtems_interval ticksWhenCalloutsLastChecked; static struct callout *callfree, calltodo; /* * FreeBSD variables */ int nfs_diskless_valid; /* * BOOTP values */ struct in_addr rtems_bsdnet_log_host_address; struct in_addr rtems_bsdnet_bootp_server_address; char *rtems_bsdnet_bootp_boot_file_name; char *rtems_bsdnet_bootp_server_name; char *rtems_bsdnet_domain_name; struct in_addr rtems_bsdnet_nameserver[sizeof rtems_bsdnet_config.name_server / sizeof rtems_bsdnet_config.name_server[0]]; int rtems_bsdnet_nameserver_count; struct in_addr rtems_bsdnet_ntpserver[sizeof rtems_bsdnet_config.ntp_server / sizeof rtems_bsdnet_config.ntp_server[0]]; int rtems_bsdnet_ntpserver_count; long rtems_bsdnet_timeoffset; /* * Perform FreeBSD memory allocation. * FIXME: This should be modified to keep memory allocation statistics. */ #undef malloc #undef free extern void *malloc (size_t); extern void free (void *); void * rtems_bsdnet_malloc (unsigned long size, int type, int flags) { void *p; int try = 0; for (;;) { p = malloc (size); if (p || (flags & M_NOWAIT)) return p; rtems_bsdnet_semaphore_release (); if (++try >= 30) { printf ("rtems_bsdnet_malloc still waiting.\n"); try = 0; } rtems_task_wake_after (rtems_bsdnet_ticks_per_second); rtems_bsdnet_semaphore_obtain (); } } /* * Free FreeBSD memory * FIXME: This should be modified to keep memory allocation statistics. */ void rtems_bsdnet_free (void *addr, int type) { free (addr); } /* * Do the initializations required by the BSD code */ static int bsd_init (void) { int i; char *p; /* * Set up mbuf cluster data strutures */ p = malloc ((nmbclusters*MCLBYTES)+MCLBYTES-1); if (p == NULL) { printf ("Can't get network cluster memory.\n"); return -1; } p = (char *)(((unsigned long)p + (MCLBYTES-1)) & ~(MCLBYTES-1)); mbutl = (struct mbuf *)p; for (i = 0; i < nmbclusters; i++) { ((union mcluster *)p)->mcl_next = mclfree; mclfree = (union mcluster *)p; p += MCLBYTES; mbstat.m_clfree++; } mbstat.m_clusters = nmbclusters; mclrefcnt = malloc (nmbclusters); if (mclrefcnt == NULL) { printf ("Can't get mbuf cluster reference counts memory.\n"); return -1; } memset (mclrefcnt, '\0', nmbclusters); /* * Set up mbuf data structures */ p = malloc(nmbuf * MSIZE + MSIZE - 1); p = (char *)(((unsigned int)p + MSIZE - 1) & ~(MSIZE - 1)); if (p == NULL) { printf ("Can't get network memory.\n"); return -1; } for (i = 0; i < nmbuf; i++) { ((struct mbuf *)p)->m_next = mmbfree; mmbfree = (struct mbuf *)p; p += MSIZE; } mbstat.m_mbufs = nmbuf; mbstat.m_mtypes[MT_FREE] = nmbuf; /* * Set up domains */ { extern struct domain routedomain; extern struct domain inetdomain; routedomain.dom_next = domains; domains = &routedomain; inetdomain.dom_next = domains; domains = &inetdomain; domaininit (NULL); } /* * Set up interfaces */ ifinit (NULL); return 0; } /* * Initialize and start network operations */ static int rtems_bsdnet_initialize (void) { rtems_status_code sc; /* * Set the priority of all network tasks */ if (rtems_bsdnet_config.network_task_priority == 0) networkDaemonPriority = 100; else networkDaemonPriority = rtems_bsdnet_config.network_task_priority; /* * Set the memory allocation limits */ if (rtems_bsdnet_config.mbuf_bytecount) nmbuf = rtems_bsdnet_config.mbuf_bytecount / MSIZE; if (rtems_bsdnet_config.mbuf_cluster_bytecount) nmbclusters = rtems_bsdnet_config.mbuf_cluster_bytecount / MCLBYTES; /* * Create the task-synchronization semaphore */ sc = rtems_semaphore_create (rtems_build_name('B', 'S', 'D', 'n'), 0, RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL, 0, &networkSemaphore); if (sc != RTEMS_SUCCESSFUL) { printf ("Can't create network seamphore: `%s'\n", rtems_status_text (sc)); return -1; } #ifdef RTEMS_FAST_MUTEX { Objects_Locations location; the_networkSemaphore = _Semaphore_Get( networkSemaphore, &location ); _Thread_Enable_dispatch(); } #endif /* * Compute clock tick conversion factors */ rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &rtems_bsdnet_ticks_per_second); if (rtems_bsdnet_ticks_per_second <= 0) rtems_bsdnet_ticks_per_second = 1; rtems_bsdnet_microseconds_per_tick = 1000000 / rtems_bsdnet_ticks_per_second; /* * Ensure that `seconds' is greater than 0 */ rtems_task_wake_after (rtems_bsdnet_ticks_per_second); /* * Set up BSD-style sockets */ if (bsd_init () < 0) return -1; /* * Start network daemon */ networkDaemonTid = rtems_bsdnet_newproc ("ntwk", 4096, networkDaemon, NULL); /* * Let other network tasks begin */ rtems_bsdnet_semaphore_release (); return 0; } /* * Obtain network mutex */ void rtems_bsdnet_semaphore_obtain (void) { #ifdef RTEMS_FAST_MUTEX ISR_Level level; _ISR_Disable (level); _CORE_mutex_Seize ( &the_networkSemaphore->Core_control.mutex, networkSemaphore, 1, /* wait */ 0, /* forever */ level ); if (_Thread_Executing->Wait.return_code) rtems_panic ("Can't obtain network semaphore\n"); #else rtems_status_code sc; sc = rtems_semaphore_obtain (networkSemaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_panic ("Can't obtain network semaphore: `%s'\n", rtems_status_text (sc)); #endif } /* * Release network mutex */ void rtems_bsdnet_semaphore_release (void) { #ifdef RTEMS_FAST_MUTEX int i; _Thread_Disable_dispatch(); i = _CORE_mutex_Surrender ( &the_networkSemaphore->Core_control.mutex, networkSemaphore, NULL ); _Thread_Enable_dispatch(); if (i) rtems_panic ("Can't release network semaphore\n"); #else rtems_status_code sc; sc = rtems_semaphore_release (networkSemaphore); if (sc != RTEMS_SUCCESSFUL) rtems_panic ("Can't release network semaphore: `%s'\n", rtems_status_text (sc)); #endif } /* * Wait for something to happen to a socket buffer */ int sbwait(sb) struct sockbuf *sb; { rtems_event_set events; rtems_id tid; rtems_status_code sc; /* * Soak up any pending events. * The sleep/wakeup synchronization in the FreeBSD * kernel has no memory. */ rtems_event_receive (SBWAIT_EVENT, RTEMS_EVENT_ANY | RTEMS_NO_WAIT, RTEMS_NO_TIMEOUT, &events); /* * Set this task as the target of the wakeup operation. */ rtems_task_ident (RTEMS_SELF, 0, &tid); sb->sb_sel.si_pid = tid; /* * Show that socket is waiting */ sb->sb_flags |= SB_WAIT; /* * Release the network semaphore. */ rtems_bsdnet_semaphore_release (); /* * Wait for the wakeup event. */ sc = rtems_event_receive (SBWAIT_EVENT, RTEMS_EVENT_ANY | RTEMS_WAIT, sb->sb_timeo, &events); /* * Reobtain the network semaphore. */ rtems_bsdnet_semaphore_obtain (); /* * Return the status of the wait. */ switch (sc) { case RTEMS_SUCCESSFUL: return 0; case RTEMS_TIMEOUT: return EWOULDBLOCK; default: return ENXIO; } } /* * Wake up the task waiting on a socket buffer. */ void sowakeup(so, sb) register struct socket *so; register struct sockbuf *sb; { if (sb->sb_flags & SB_WAIT) { sb->sb_flags &= ~SB_WAIT; rtems_event_send (sb->sb_sel.si_pid, SBWAIT_EVENT); } if (sb->sb_wakeup) { (*sb->sb_wakeup) (so, sb->sb_wakeuparg); } } /* * For now, a socket can be used by only one task at a time. */ int sb_lock(sb) register struct sockbuf *sb; { rtems_panic ("Socket buffer is already in use."); return 0; } void wakeup (void *p) { rtems_panic ("Wakeup called"); } /* * Wait for a connection/disconnection event. */ int soconnsleep (struct socket *so) { rtems_event_set events; rtems_id tid; rtems_status_code sc; /* * Soak up any pending events. * The sleep/wakeup synchronization in the FreeBSD * kernel has no memory. */ rtems_event_receive (SOSLEEP_EVENT, RTEMS_EVENT_ANY | RTEMS_NO_WAIT, RTEMS_NO_TIMEOUT, &events); /* * Set this task as the target of the wakeup operation. */ if (so->so_pgid) rtems_panic ("Another task is already sleeping on that socket"); rtems_task_ident (RTEMS_SELF, 0, &tid); so->so_pgid = tid; /* * Wait for the wakeup event. */ sc = rtems_bsdnet_event_receive (SOSLEEP_EVENT, RTEMS_EVENT_ANY | RTEMS_WAIT, so->so_rcv.sb_timeo, &events); /* * Relinquish ownership of the socket. */ so->so_pgid = 0; switch (sc) { case RTEMS_SUCCESSFUL: return 0; case RTEMS_TIMEOUT: return EWOULDBLOCK; default: return ENXIO; } } /* * Wake up a task waiting for a connection/disconnection to complete. */ void soconnwakeup (struct socket *so) { if (so->so_pgid) rtems_event_send (so->so_pgid, SOSLEEP_EVENT); } /* * Send an event to the network daemon. * This corresponds to sending a software interrupt in the BSD kernel. */ void rtems_bsdnet_schednetisr (int n) { rtems_event_send (networkDaemonTid, 1 << n); } /* * The network daemon * This provides a context to run BSD software interrupts */ static void networkDaemon (void *task_argument) { rtems_event_set events; rtems_interval now; int ticksPassed; unsigned32 timeout; struct callout *c; for (;;) { c = calltodo.c_next; if (c) timeout = c->c_time; else timeout = RTEMS_NO_TIMEOUT; rtems_bsdnet_event_receive (NETISR_EVENTS, RTEMS_EVENT_ANY | RTEMS_WAIT, timeout, &events); if (events & NETISR_IP_EVENT) ipintr (); if (events & NETISR_ARP_EVENT) arpintr (); rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); ticksPassed = now - ticksWhenCalloutsLastChecked; if (ticksPassed != 0) { ticksWhenCalloutsLastChecked = now; c = calltodo.c_next; if (c) { c->c_time -= ticksPassed; while ((c = calltodo.c_next) != NULL && c->c_time <= 0) { void *arg; void (*func) (void *); func = c->c_func; arg = c->c_arg; calltodo.c_next = c->c_next; c->c_next = callfree; callfree = c; (*func)(arg); } } } } } /* * Structure passed to task-start stub */ struct newtask { void (*entry)(void *); void *arg; }; /* * Task-start stub */ static void taskEntry (rtems_task_argument arg) { struct newtask t; /* * Pick up task information and free * the memory allocated to pass the * information to this task. */ t = *(struct newtask *)arg; free ((struct newtask *)arg); /* * Enter the competition for the network semaphore */ rtems_bsdnet_semaphore_obtain (); /* * Enter the task */ (*t.entry)(t.arg); rtems_panic ("Network task returned!\n"); } /* * Start a network task */ rtems_id rtems_bsdnet_newproc (char *name, int stacksize, void(*entry)(void *), void *arg) { struct newtask *t; char nm[4]; rtems_id tid; rtems_status_code sc; strncpy (nm, name, 4); sc = rtems_task_create (rtems_build_name(nm[0], nm[1], nm[2], nm[3]), networkDaemonPriority, stacksize, RTEMS_PREEMPT|RTEMS_NO_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0), RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL, &tid); if (sc != RTEMS_SUCCESSFUL) rtems_panic ("Can't create network daemon `%s': `%s'\n", name, rtems_status_text (sc)); /* * Set up task arguments */ t = malloc (sizeof *t); t->entry = entry; t->arg = arg; /* * Start the task */ sc = rtems_task_start (tid, taskEntry, (rtems_task_argument)t); if (sc != RTEMS_SUCCESSFUL) rtems_panic ("Can't start network daemon `%s': `%s'\n", name, rtems_status_text (sc)); /* * Let our caller know the i.d. of the new task */ return tid; } rtems_status_code rtems_bsdnet_event_receive ( rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out) { rtems_status_code sc; rtems_bsdnet_semaphore_release (); sc = rtems_event_receive (event_in, option_set, ticks, event_out); rtems_bsdnet_semaphore_obtain (); return sc; } /* * Return time since startup */ void microtime (struct timeval *t) { rtems_interval now; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); t->tv_sec = now / rtems_bsdnet_ticks_per_second; t->tv_usec = (now % rtems_bsdnet_ticks_per_second) * rtems_bsdnet_microseconds_per_tick; } unsigned long rtems_bsdnet_seconds_since_boot (void) { rtems_interval now; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); return now / rtems_bsdnet_ticks_per_second; } /* * Fake random number generator */ unsigned long rtems_bsdnet_random (void) { rtems_interval now; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); return (now * 99991); } /* * Callout list processing */ void timeout(void (*ftn)(void *), void *arg, int ticks) { register struct callout *new, *p, *t; if (ticks <= 0) ticks = 1; /* Fill in the next free callout structure. */ if (callfree == NULL) { callfree = malloc (sizeof *callfree); if (callfree == NULL) rtems_panic ("No memory for timeout table entry"); callfree->c_next = NULL; } new = callfree; callfree = new->c_next; new->c_arg = arg; new->c_func = ftn; /* * The time for each event is stored as a difference from the time * of the previous event on the queue. Walk the queue, correcting * the ticks argument for queue entries passed. Correct the ticks * value for the queue entry immediately after the insertion point * as well. Watch out for negative c_time values; these represent * overdue events. */ for (p = &calltodo; (t = p->c_next) != NULL && ticks > t->c_time; p = t) if (t->c_time > 0) ticks -= t->c_time; new->c_time = ticks; if (t != NULL) t->c_time -= ticks; /* Insert the new entry into the queue. */ p->c_next = new; new->c_next = t; } /* * Ticks till specified time * XXX: This version worries only about seconds, but that's good * enough for the way the network code uses this routine. */ int hzto(struct timeval *tv) { long diff = tv->tv_sec - rtems_bsdnet_seconds_since_boot(); if (diff <= 0) return 1; return diff * rtems_bsdnet_ticks_per_second; } /* * Kernel debugging */ int rtems_bsdnet_log_priority; void rtems_bsdnet_log (int priority, const char *fmt, ...) { va_list args; if (priority & rtems_bsdnet_log_priority) { va_start (args, fmt); vprintf (fmt, args); va_end (args); } } /* * IP header checksum routine for processors which don't have an inline version */ u_int in_cksum_hdr (const void *ip) { rtems_unsigned32 sum; const rtems_unsigned16 *sp; int i; sum = 0; sp = (rtems_unsigned16 *)ip; for (i = 0 ; i < 10 ; i++) sum += *sp++; while (sum > 0xFFFF) sum = (sum & 0xffff) + (sum >> 16); return ~sum & 0xFFFF; } /* * Manipulate routing tables */ int rtems_bsdnet_rtrequest ( int req, struct sockaddr *dst, struct sockaddr *gateway, struct sockaddr *netmask, int flags, struct rtentry **net_nrt) { int error; rtems_bsdnet_semaphore_obtain (); error = rtrequest (req, dst, gateway, netmask, flags, net_nrt); rtems_bsdnet_semaphore_release (); if (error) { errno = error; return -1; } return 0; } static int rtems_bsdnet_setup (void) { struct rtems_bsdnet_ifconfig *ifp; short flags; struct sockaddr_in address; struct sockaddr_in netmask; struct sockaddr_in broadcast; struct sockaddr_in gateway; int i; extern char *strdup (const char *cp); /* * Set local parameters */ if (rtems_bsdnet_config.hostname) sethostname (rtems_bsdnet_config.hostname, strlen (rtems_bsdnet_config.hostname)); if (rtems_bsdnet_config.domainname) rtems_bsdnet_domain_name = strdup (rtems_bsdnet_config.domainname); if (rtems_bsdnet_config.log_host) rtems_bsdnet_log_host_address.s_addr = inet_addr (rtems_bsdnet_config.log_host); for (i = 0 ; i < sizeof rtems_bsdnet_config.name_server / sizeof rtems_bsdnet_config.name_server[0] ; i++) { if (!rtems_bsdnet_config.name_server[i]) break; rtems_bsdnet_nameserver[rtems_bsdnet_nameserver_count++].s_addr = inet_addr (rtems_bsdnet_config.name_server[i]); } for (i = 0 ; i < sizeof rtems_bsdnet_config.ntp_server / sizeof rtems_bsdnet_config.ntp_server[0] ; i++) { if (!rtems_bsdnet_config.ntp_server[i]) break; rtems_bsdnet_ntpserver[rtems_bsdnet_ntpserver_count++].s_addr = inet_addr (rtems_bsdnet_config.ntp_server[i]); } /* * Configure interfaces */ for (ifp = rtems_bsdnet_config.ifconfig ; ifp ; ifp = ifp->next) { if (ifp->ip_address == NULL) continue; /* * Bring interface up */ flags = IFF_UP; if (rtems_bsdnet_ifconfig (ifp->name, SIOCSIFFLAGS, &flags) < 0) { printf ("Can't bring %s up: %s\n", ifp->name, strerror (errno)); continue; } /* * Set interface netmask */ memset (&netmask, '\0', sizeof netmask); netmask.sin_len = sizeof netmask; netmask.sin_family = AF_INET; netmask.sin_addr.s_addr = inet_addr (ifp->ip_netmask); if (rtems_bsdnet_ifconfig (ifp->name, SIOCSIFNETMASK, &netmask) < 0) { printf ("Can't set %s netmask: %s\n", ifp->name, strerror (errno)); continue; } /* * Set interface address */ memset (&address, '\0', sizeof address); address.sin_len = sizeof address; address.sin_family = AF_INET; address.sin_addr.s_addr = inet_addr (ifp->ip_address); if (rtems_bsdnet_ifconfig (ifp->name, SIOCSIFADDR, &address) < 0) { printf ("Can't set %s address: %s\n", ifp->name, strerror (errno)); continue; } /* * Set interface broadcast address if the interface has the * broadcast flag set. */ if (rtems_bsdnet_ifconfig (ifp->name, SIOCGIFFLAGS, &flags) < 0) { printf ("Can't read %s flags: %s\n", ifp->name, strerror (errno)); continue; } if (flags & IFF_BROADCAST) { memset (&broadcast, '\0', sizeof broadcast); broadcast.sin_len = sizeof broadcast; broadcast.sin_family = AF_INET; broadcast.sin_addr.s_addr = address.sin_addr.s_addr | ~netmask.sin_addr.s_addr; if (rtems_bsdnet_ifconfig (ifp->name, SIOCSIFBRDADDR, &broadcast) < 0) { struct in_addr in_addr; in_addr.s_addr = broadcast.sin_addr.s_addr; printf ("Can't set %s broadcast address %s: %s\n", ifp->name, inet_ntoa (in_addr), strerror (errno)); } } } /* * Set default route */ if (rtems_bsdnet_config.gateway) { address.sin_addr.s_addr = INADDR_ANY; netmask.sin_addr.s_addr = INADDR_ANY; memset (&gateway, '\0', sizeof gateway); gateway.sin_len = sizeof gateway; gateway.sin_family = AF_INET; gateway.sin_addr.s_addr = inet_addr (rtems_bsdnet_config.gateway); if (rtems_bsdnet_rtrequest ( RTM_ADD, (struct sockaddr *)&address, (struct sockaddr *)&gateway, (struct sockaddr *)&netmask, (RTF_UP | RTF_GATEWAY | RTF_STATIC), NULL) < 0) { printf ("Can't set default route: %s\n", strerror (errno)); return -1; } } return 0; } /* * Initialize the network */ int rtems_bsdnet_initialize_network (void) { struct rtems_bsdnet_ifconfig *ifp; /* * Start network tasks. * Initialize BSD network data structures. */ if (rtems_bsdnet_initialize () < 0) return -1; /* * Attach interfaces */ for (ifp = rtems_bsdnet_config.ifconfig ; ifp ; ifp = ifp->next) { rtems_bsdnet_attach (ifp); } /* * Bring up the network */ if (rtems_bsdnet_setup () < 0) return -1; if (rtems_bsdnet_config.bootp) (*rtems_bsdnet_config.bootp)(); return 0; } /* * Attach a network interface. */ void rtems_bsdnet_attach (struct rtems_bsdnet_ifconfig *ifp) { if (ifp) { rtems_bsdnet_semaphore_obtain (); (ifp->attach)(ifp, 1); rtems_bsdnet_semaphore_release (); } } /* * Detach a network interface. */ void rtems_bsdnet_detach (struct rtems_bsdnet_ifconfig *ifp) { if (ifp) { rtems_bsdnet_semaphore_obtain (); (ifp->attach)(ifp, 0); rtems_bsdnet_semaphore_release (); } } /* * Interface Configuration. */ int rtems_bsdnet_ifconfig (const char *ifname, unsigned32 cmd, void *param) { int s, r = 0; struct ifreq ifreq; /* * Configure interfaces */ s = socket (AF_INET, SOCK_DGRAM, 0); if (s < 0) return -1; strncpy (ifreq.ifr_name, ifname, IFNAMSIZ); rtems_bsdnet_semaphore_obtain (); switch (cmd) { case SIOCSIFADDR: case SIOCSIFNETMASK: memcpy (&ifreq.ifr_addr, param, sizeof (struct sockaddr)); r = ioctl (s, cmd, &ifreq); break; case OSIOCGIFADDR: case SIOCGIFADDR: case OSIOCGIFNETMASK: case SIOCGIFNETMASK: if ((r = ioctl (s, cmd, &ifreq)) < 0) break; memcpy (param, &ifreq.ifr_addr, sizeof (struct sockaddr)); break; case SIOCGIFFLAGS: case SIOCSIFFLAGS: if ((r = ioctl (s, SIOCGIFFLAGS, &ifreq)) < 0) break; if (cmd == SIOCGIFFLAGS) { *((short*) param) = ifreq.ifr_flags; break; } ifreq.ifr_flags |= *((short*) param); r = ioctl (s, SIOCSIFFLAGS, &ifreq); break; case SIOCSIFDSTADDR: memcpy (&ifreq.ifr_dstaddr, param, sizeof (struct sockaddr)); r = ioctl (s, cmd, &ifreq); break; case OSIOCGIFDSTADDR: case SIOCGIFDSTADDR: if ((r = ioctl (s, cmd, &ifreq)) < 0) break; memcpy (param, &ifreq.ifr_dstaddr, sizeof (struct sockaddr)); break; case SIOCSIFBRDADDR: memcpy (&ifreq.ifr_broadaddr, param, sizeof (struct sockaddr)); r = ioctl (s, cmd, &ifreq); break; case OSIOCGIFBRDADDR: case SIOCGIFBRDADDR: if ((r = ioctl (s, cmd, &ifreq)) < 0) break; memcpy (param, &ifreq.ifr_broadaddr, sizeof (struct sockaddr)); break; case SIOCSIFMETRIC: ifreq.ifr_metric = *((int*) param); r = ioctl (s, cmd, &ifreq); break; case SIOCGIFMETRIC: if ((r = ioctl (s, cmd, &ifreq)) < 0) break; *((int*) param) = ifreq.ifr_metric; break; case SIOCSIFMTU: ifreq.ifr_mtu = *((int*) param); r = ioctl (s, cmd, &ifreq); break; case SIOCGIFMTU: if ((r = ioctl (s, cmd, &ifreq)) < 0) break; *((int*) param) = ifreq.ifr_mtu; break; case SIOCSIFPHYS: ifreq.ifr_phys = *((int*) param); r = ioctl (s, cmd, &ifreq); break; case SIOCGIFPHYS: if ((r = ioctl (s, cmd, &ifreq)) < 0) break; *((int*) param) = ifreq.ifr_phys; break; case SIOCSIFMEDIA: ifreq.ifr_media = *((int*) param); r = ioctl (s, cmd, &ifreq); break; case SIOCGIFMEDIA: if ((r = ioctl (s, cmd, &ifreq)) < 0) break; *((int*) param) = ifreq.ifr_media; break; default: errno = EOPNOTSUPP; r = -1; break; } rtems_bsdnet_semaphore_release (); close (s); return r; } /* * Parse a network driver name into a name and a unit number */ int rtems_bsdnet_parse_driver_name (const struct rtems_bsdnet_ifconfig *config, char **namep) { const char *cp = config->name; char c; int unitNumber = 0; if (cp == NULL) { printf ("No network driver name.\n"); return -1; } while ((c = *cp++) != '\0') { if ((c >= '0') && (c <= '9')) { int len = cp - config->name; if ((len < 2) || (len > 50)) break; for (;;) { unitNumber = (unitNumber * 10) + (c - '0'); c = *cp++; if (c == '\0') { char *unitName = malloc (len); if (unitName == NULL) { printf ("No memory.\n"); return -1; } strncpy (unitName, config->name, len - 1); unitName[len-1] = '\0'; *namep = unitName; return unitNumber; } if ((c < '0') || (c > '9')) break; } break; } } printf ("Bad network driver name `%s'.\n", config->name); return -1; } /* * Handle requests for more network memory * XXX: Another possibility would be to use a semaphore here with * a release in the mbuf free macro. I have chosen this `polling' * approach because: * 1) It is simpler. * 2) It adds no complexity to the free macro. * 3) Running out of mbufs should be a rare * condition -- predeployment testing of * an application should indicate the * required mbuf pool size. * XXX: Should there be a panic if a task is stuck in the loop for * more than a minute or so? */ int m_mballoc (int nmb, int nowait) { if (nowait) return 0; m_reclaim (); if (mmbfree == NULL) { int try = 0; int print_limit = 30 * rtems_bsdnet_ticks_per_second; mbstat.m_wait++; for (;;) { rtems_bsdnet_semaphore_release (); rtems_task_wake_after (1); rtems_bsdnet_semaphore_obtain (); if (mmbfree) break; if (++try >= print_limit) { printf ("Still waiting for mbuf.\n"); try = 0; } } } else { mbstat.m_drops++; } return 1; } int m_clalloc(ncl, nowait) { if (nowait) return 0; m_reclaim (); if (mclfree == NULL) { int try = 0; int print_limit = 30 * rtems_bsdnet_ticks_per_second; mbstat.m_wait++; for (;;) { rtems_bsdnet_semaphore_release (); rtems_task_wake_after (1); rtems_bsdnet_semaphore_obtain (); if (mclfree) break; if (++try >= print_limit) { printf ("Still waiting for mbuf cluster.\n"); try = 0; } } } else { mbstat.m_drops++; } return 1; }