source: rtems/cpukit/libnetworking/rtems/rtems_glue.c @ e800b07

5
Last change on this file since e800b07 was e800b07, checked in by Sebastian Huber <sebastian.huber@…>, on 04/22/16 at 07:15:11

network: Fix warnings
  • Property mode set to 100644
File size: 28.9 KB
Line 
1#if HAVE_CONFIG_H
2#include "config.h"
3#endif
4
5#define RTEMS_FAST_MUTEX
6
7#include <string.h>
8#include <stdarg.h>
9#include <stdio.h>
10#include <errno.h>
11
12#include <rtems.h>
13#include <rtems/libio.h>
14#include <rtems/error.h>
15#include <rtems/rtems_bsdnet.h>
16#include <rtems/rtems/semimpl.h>
17#include <rtems/score/coremuteximpl.h>
18#include <sys/types.h>
19#include <sys/param.h>
20#include <sys/domain.h>
21#include <sys/mbuf.h>
22#include <sys/socketvar.h>
23#include <sys/socket.h>
24#include <sys/sockio.h>
25#include <sys/callout.h>
26#include <sys/proc.h>
27#include <sys/ioctl.h>
28#include <sys/systm.h>
29#include <net/if.h>
30#include <net/route.h>
31#include <netinet/in.h>
32#include <vm/vm.h>
33#include <arpa/inet.h>
34
35#include <net/netisr.h>
36#include <net/route.h>
37
38#include "loop.h"
39
40/*
41 * Memory allocation
42 */
43static uint32_t nmbuf       = (64L * 1024L) / MSIZE;
44       uint32_t nmbclusters = (128L * 1024L) / MCLBYTES;
45
46/*
47 * Network task synchronization
48 */
49static rtems_id networkSemaphore;
50#ifdef RTEMS_FAST_MUTEX
51Semaphore_Control   *the_networkSemaphore;
52#endif
53static rtems_id networkDaemonTid;
54static uint32_t   networkDaemonPriority;
55#ifdef RTEMS_SMP
56static const cpu_set_t *networkDaemonCpuset = 0;
57static size_t          networkDaemonCpusetSize = 0;
58#endif
59static void networkDaemon (void *task_argument);
60
61/*
62 * Network timing
63 */
64int                     rtems_bsdnet_ticks_per_second;
65int                     rtems_bsdnet_microseconds_per_tick;
66
67/*
68 * Callout processing
69 */
70static rtems_interval   ticksWhenCalloutsLastChecked;
71struct callout *callfree = NULL;
72struct callout calltodo;
73
74/*
75 * FreeBSD variables
76 */
77int nfs_diskless_valid;
78
79/*
80 * BOOTP values
81 */
82struct in_addr rtems_bsdnet_log_host_address = {0};
83struct in_addr rtems_bsdnet_bootp_server_address = {0};
84char *rtems_bsdnet_bootp_boot_file_name = 0;
85char *rtems_bsdnet_bootp_server_name = 0;
86char *rtems_bsdnet_domain_name = 0;
87char *rtems_bsdnet_bootp_cmdline = 0;
88static struct in_addr _rtems_bsdnet_nameserver[sizeof rtems_bsdnet_config.name_server /
89                        sizeof rtems_bsdnet_config.name_server[0]];
90struct in_addr *rtems_bsdnet_nameserver = _rtems_bsdnet_nameserver;
91int rtems_bsdnet_nameserver_count = 0;
92static struct in_addr _rtems_bsdnet_ntpserver[sizeof rtems_bsdnet_config.ntp_server /
93                        sizeof rtems_bsdnet_config.ntp_server[0]];
94struct in_addr *rtems_bsdnet_ntpserver = _rtems_bsdnet_ntpserver;
95int rtems_bsdnet_ntpserver_count = 0;
96int32_t rtems_bsdnet_timeoffset = 0;
97
98static const struct sockaddr_in address_template = {
99        sizeof(address_template),
100        AF_INET,
101        0,
102        { INADDR_ANY },
103        { 0, 0, 0, 0, 0, 0, 0, 0 }
104};
105
106static void
107rtems_bsdnet_initialize_sockaddr_in(struct sockaddr_in *addr)
108{
109        memcpy(addr, &address_template, sizeof(*addr));
110}
111
112uint32_t
113rtems_bsdnet_semaphore_release_recursive(void)
114{
115#ifdef RTEMS_FAST_MUTEX
116        uint32_t nest_count;
117        uint32_t i;
118
119        nest_count =
120                the_networkSemaphore ?
121                the_networkSemaphore->Core_control.mutex.nest_count : 0;
122        for (i = 0; i < nest_count; ++i) {
123                rtems_bsdnet_semaphore_release();
124        }
125
126        return nest_count;
127#else
128        #error "not implemented"
129#endif
130}
131
132void
133rtems_bsdnet_semaphore_obtain_recursive(uint32_t nest_count)
134{
135        uint32_t i;
136
137        for (i = 0; i < nest_count; ++i) {
138                rtems_bsdnet_semaphore_obtain();
139        }
140}
141
142/*
143 * Perform FreeBSD memory allocation.
144 * FIXME: This should be modified to keep memory allocation statistics.
145 */
146#undef malloc
147#undef free
148extern void *malloc (size_t);
149extern void free (void *);
150void *
151rtems_bsdnet_malloc (size_t size, int type, int flags)
152{
153        void *p;
154        int try = 0;
155
156        for (;;) {
157                uint32_t nest_count;
158
159                p = malloc (size);
160                if (p || (flags & M_NOWAIT))
161                        return p;
162                nest_count = rtems_bsdnet_semaphore_release_recursive ();
163                if (++try >= 30) {
164                        rtems_bsdnet_malloc_starvation();
165                        try = 0;
166                }
167                rtems_task_wake_after (rtems_bsdnet_ticks_per_second);
168                rtems_bsdnet_semaphore_obtain_recursive (nest_count);
169        }
170}
171
172/*
173 * Free FreeBSD memory
174 * FIXME: This should be modified to keep memory allocation statistics.
175 */
176void
177rtems_bsdnet_free (void *addr, int type)
178{
179        free (addr);
180}
181
182/*
183 * Externs for BSD data we have to access during initialization
184 */
185extern struct domain routedomain;
186extern struct domain inetdomain;
187
188/*
189 * Do the initializations required by the BSD code
190 */
191static int
192bsd_init (void)
193{
194        int i;
195        char *p;
196
197        /*
198         * Set up mbuf cluster data strutures
199         */
200        p = rtems_bsdnet_malloc_mbuf ((nmbclusters*MCLBYTES)+MCLBYTES-1, MBUF_MALLOC_NMBCLUSTERS);
201        if (p == NULL) {
202                printf ("Can't get network cluster memory.\n");
203                return -1;
204        }
205        p = (char *)(((intptr_t)p + (MCLBYTES-1)) & ~(MCLBYTES-1));
206        mbutl = (struct mbuf *)p;
207        for (i = 0; i < nmbclusters; i++) {
208                ((union mcluster *)p)->mcl_next = mclfree;
209                mclfree = (union mcluster *)p;
210                p += MCLBYTES;
211                mbstat.m_clfree++;
212        }
213        mbstat.m_clusters = nmbclusters;
214        mclrefcnt = rtems_bsdnet_malloc_mbuf (nmbclusters, MBUF_MALLOC_MCLREFCNT);
215        if (mclrefcnt == NULL) {
216                printf ("Can't get mbuf cluster reference counts memory.\n");
217                return -1;
218        }
219        memset (mclrefcnt, '\0', nmbclusters);
220
221        /*
222         * Set up mbuf data structures
223         */
224
225        p = rtems_bsdnet_malloc_mbuf(nmbuf * MSIZE + MSIZE - 1,MBUF_MALLOC_MBUF);
226        p = (char *)(((uintptr_t)p + MSIZE - 1) & ~(MSIZE - 1));
227        if (p == NULL) {
228                printf ("Can't get network memory.\n");
229                return -1;
230        }
231        for (i = 0; i < nmbuf; i++) {
232                ((struct mbuf *)p)->m_next = mmbfree;
233                mmbfree = (struct mbuf *)p;
234                p += MSIZE;
235        }
236        mbstat.m_mbufs = nmbuf;
237        mbstat.m_mtypes[MT_FREE] = nmbuf;
238
239        /*
240         * Set up domains
241         */
242        {
243
244        routedomain.dom_next = domains;
245        domains = &routedomain;
246        inetdomain.dom_next = domains;
247        domains = &inetdomain;
248        domaininit (NULL);
249        }
250
251  /*
252   * Setup the sysctl, normally done by a SYSINIT call.
253   */
254  sysctl_register_all(0);
255
256        /*
257         * Set up interfaces
258         */
259        ifinit (NULL);
260        return 0;
261}
262
263/*
264 * Initialize and start network operations
265 */
266static int
267rtems_bsdnet_initialize (void)
268{
269        rtems_status_code sc;
270
271        /*
272         * Set the priority of all network tasks
273         */
274        if (rtems_bsdnet_config.network_task_priority == 0)
275                networkDaemonPriority = 100;
276#ifdef RTEMS_MULTIPROCESSING
277        /*
278         * Allow network tasks to run with priority 0 (PRIORITY_PSEUDO_ISR) using
279         * UINT32_MAX for the network task priority in the network configuration.
280         * This enables MPCI via a TCP/IP network.
281         */
282        else if (rtems_bsdnet_config.network_task_priority != UINT32_MAX)
283#else
284        else
285#endif
286                networkDaemonPriority = rtems_bsdnet_config.network_task_priority;
287
288        /*
289         * Default network task CPU affinity
290         */
291#ifdef RTEMS_SMP
292        networkDaemonCpuset = rtems_bsdnet_config.network_task_cpuset;
293        networkDaemonCpusetSize = rtems_bsdnet_config.network_task_cpuset_size;
294#endif
295
296        /*
297         * Set the memory allocation limits
298         */
299        if (rtems_bsdnet_config.mbuf_bytecount)
300                nmbuf = rtems_bsdnet_config.mbuf_bytecount / MSIZE;
301        if (rtems_bsdnet_config.mbuf_cluster_bytecount)
302                nmbclusters = rtems_bsdnet_config.mbuf_cluster_bytecount / MCLBYTES;
303
304        rtems_set_udp_buffer_sizes(
305          rtems_bsdnet_config.udp_tx_buf_size,
306          rtems_bsdnet_config.udp_rx_buf_size
307        );
308
309        rtems_set_tcp_buffer_sizes(
310          rtems_bsdnet_config.tcp_tx_buf_size,
311          rtems_bsdnet_config.tcp_rx_buf_size
312        );
313
314        rtems_set_sb_efficiency( rtems_bsdnet_config.sb_efficiency );
315
316        /*
317         * Create the task-synchronization semaphore
318         */
319        sc = rtems_semaphore_create (rtems_build_name('B', 'S', 'D', 'n'),
320                                        0,
321                                        RTEMS_PRIORITY |
322                                                RTEMS_BINARY_SEMAPHORE |
323                                                RTEMS_INHERIT_PRIORITY |
324                                                RTEMS_NO_PRIORITY_CEILING |
325                                                RTEMS_LOCAL,
326                                        0,
327                                        &networkSemaphore);
328        if (sc != RTEMS_SUCCESSFUL) {
329                printf ("Can't create network seamphore: `%s'\n", rtems_status_text (sc));
330                return -1;
331        }
332#ifdef RTEMS_FAST_MUTEX
333        {
334        Objects_Locations location;
335        the_networkSemaphore = _Semaphore_Get( networkSemaphore, &location );
336        _Thread_Enable_dispatch();
337        }
338#endif
339
340        /*
341         * Compute clock tick conversion factors
342         */
343        rtems_bsdnet_ticks_per_second = rtems_clock_get_ticks_per_second();
344        if (rtems_bsdnet_ticks_per_second <= 0)
345                rtems_bsdnet_ticks_per_second = 1;
346        rtems_bsdnet_microseconds_per_tick =
347                1000000 / rtems_bsdnet_ticks_per_second;
348
349        /*
350         * Set up BSD-style sockets
351         */
352        if (bsd_init () < 0)
353                return -1;
354
355        /*
356         * Start network daemon
357         */
358        networkDaemonTid = rtems_bsdnet_newproc ("ntwk", 4096, networkDaemon, NULL);
359
360        /*
361         * Let other network tasks begin
362         */
363        rtems_bsdnet_semaphore_release ();
364
365        rtems_bsdnet_initialize_loop();
366
367        return 0;
368}
369
370/*
371 * Obtain network mutex
372 */
373void
374rtems_bsdnet_semaphore_obtain (void)
375{
376#ifdef RTEMS_FAST_MUTEX
377        ISR_lock_Context lock_context;
378        Thread_Control *executing;
379        _ISR_lock_ISR_disable(&lock_context);
380        if (!the_networkSemaphore)
381                rtems_panic ("rtems-net: network sema obtain: network not initialised\n");
382        executing = _Thread_Executing;
383        _CORE_mutex_Seize (
384                &the_networkSemaphore->Core_control.mutex,
385                executing,
386                1,              /* wait */
387                0,              /* forever */
388                &lock_context
389                );
390        if (executing->Wait.return_code)
391                rtems_panic ("rtems-net: can't obtain network sema: %d\n",
392                 executing->Wait.return_code);
393#else
394        rtems_status_code sc;
395
396        sc = rtems_semaphore_obtain (networkSemaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
397        if (sc != RTEMS_SUCCESSFUL)
398                rtems_panic ("rtems-net: can't obtain network semaphore: `%s'\n",
399                 rtems_status_text (sc));
400#endif
401}
402
403/*
404 * Release network mutex
405 */
406void
407rtems_bsdnet_semaphore_release (void)
408{
409#ifdef RTEMS_FAST_MUTEX
410        ISR_lock_Context lock_context;
411        CORE_mutex_Status status;
412
413        if (!the_networkSemaphore)
414                rtems_panic ("rtems-net: network sema obtain: network not initialised\n");
415        _ISR_lock_ISR_disable(&lock_context);
416        status = _CORE_mutex_Surrender (
417                &the_networkSemaphore->Core_control.mutex,
418                NULL,
419                0,
420                &lock_context
421                );
422        if (status != CORE_MUTEX_STATUS_SUCCESSFUL)
423                rtems_panic ("rtems-net: can't release network sema: %i\n");
424#else
425        rtems_status_code sc;
426
427        sc = rtems_semaphore_release (networkSemaphore);
428        if (sc != RTEMS_SUCCESSFUL)
429                rtems_panic ("rtems-net: can't release network semaphore: `%s'\n",
430                 rtems_status_text (sc));
431#endif
432}
433
434static int
435rtems_bsdnet_sleep(rtems_event_set in, rtems_interval ticks)
436{
437        rtems_status_code sc;
438        rtems_event_set out;
439        rtems_event_set out2;
440
441        in |= RTEMS_EVENT_SYSTEM_NETWORK_CLOSE;
442
443        /*
444         * Soak up any pending events.  The sleep/wakeup synchronization in the
445         * FreeBSD kernel has no memory.
446         */
447        rtems_event_system_receive(in, RTEMS_EVENT_ANY | RTEMS_NO_WAIT,
448            RTEMS_NO_TIMEOUT, &out);
449
450        /*
451         * Wait for the wakeup event.
452         */
453        sc = rtems_bsdnet_event_receive(in, RTEMS_EVENT_ANY | RTEMS_WAIT,
454            ticks, &out);
455
456        /*
457         * Get additional events that may have been received between the
458         * rtems_event_system_receive() and the rtems_bsdnet_semaphore_obtain().
459         */
460        rtems_event_system_receive(in, RTEMS_EVENT_ANY | RTEMS_NO_WAIT,
461            RTEMS_NO_TIMEOUT, &out2);
462        out |= out2;
463
464        if (out & RTEMS_EVENT_SYSTEM_NETWORK_CLOSE)
465                return (ENXIO);
466
467        if (sc == RTEMS_SUCCESSFUL)
468                return (0);
469
470        return (EWOULDBLOCK);
471}
472
473/*
474 * Wait for something to happen to a socket buffer
475 */
476int
477sbwait(struct sockbuf *sb)
478{
479        int error;
480
481        /*
482         * Set this task as the target of the wakeup operation.
483         */
484        sb->sb_sel.si_pid = rtems_task_self();
485
486        /*
487         * Show that socket is waiting
488         */
489        sb->sb_flags |= SB_WAIT;
490
491        error = rtems_bsdnet_sleep(SBWAIT_EVENT, sb->sb_timeo);
492        if (error != ENXIO)
493                sb->sb_flags &= ~SB_WAIT;
494
495        return (error);
496}
497
498
499/*
500 * Wake up the task waiting on a socket buffer.
501 */
502void
503sowakeup(
504        struct socket *so,
505        struct sockbuf *sb)
506{
507        if (sb->sb_flags & SB_WAIT) {
508                rtems_event_system_send (sb->sb_sel.si_pid, SBWAIT_EVENT);
509        }
510        if (sb->sb_wakeup) {
511                (*sb->sb_wakeup) (so, sb->sb_wakeuparg);
512        }
513}
514
515/*
516 * For now, a socket can be used by only one task at a time.
517 */
518int
519sb_lock(struct sockbuf *sb)
520{
521        rtems_panic ("Socket buffer is already in use.");
522        return 0;
523}
524void
525wakeup (void *p)
526{
527        rtems_panic ("Wakeup called");
528}
529
530/*
531 * Wait for a connection/disconnection event.
532 */
533int
534soconnsleep (struct socket *so)
535{
536        int error;
537
538        /*
539         * Set this task as the target of the wakeup operation.
540         */
541        if (so->so_pgid)
542                rtems_panic ("Another task is already sleeping on that socket");
543        so->so_pgid = rtems_task_self();
544
545        error = rtems_bsdnet_sleep(SOSLEEP_EVENT, so->so_rcv.sb_timeo);
546        if (error != ENXIO)
547                so->so_pgid = 0;
548
549        return (error);
550}
551
552/*
553 * Wake up a task waiting for a connection/disconnection to complete.
554 */
555void
556soconnwakeup (struct socket *so)
557{
558        if (so->so_pgid)
559                rtems_event_system_send (so->so_pgid, SOSLEEP_EVENT);
560}
561
562/*
563 * Send an event to the network daemon.
564 * This corresponds to sending a software interrupt in the BSD kernel.
565 */
566void
567rtems_bsdnet_schednetisr (int n)
568{
569        rtems_event_system_send (networkDaemonTid, 1 << n);
570}
571
572/*
573 * The network daemon
574 * This provides a context to run BSD software interrupts
575 */
576static void
577networkDaemon (void *task_argument)
578{
579        rtems_status_code sc;
580        rtems_event_set events;
581        rtems_interval now;
582        int ticksPassed;
583        uint32_t   timeout;
584        struct callout *c;
585
586        for (;;) {
587                c = calltodo.c_next;
588                if (c)
589                        timeout = c->c_time;
590                else
591                        timeout = RTEMS_NO_TIMEOUT;
592
593                sc = rtems_bsdnet_event_receive (NETISR_EVENTS,
594                                                RTEMS_EVENT_ANY | RTEMS_WAIT,
595                                                timeout,
596                                                &events);
597                if ( sc == RTEMS_SUCCESSFUL ) {
598                        if (events & NETISR_IP_EVENT)
599                                ipintr ();
600                        if (events & NETISR_ARP_EVENT)
601                                arpintr ();
602                }
603
604                now = rtems_clock_get_ticks_since_boot();
605                ticksPassed = now - ticksWhenCalloutsLastChecked;
606                if (ticksPassed != 0) {
607                        ticksWhenCalloutsLastChecked = now;
608
609                        c = calltodo.c_next;
610                        if (c) {
611                                c->c_time -= ticksPassed;
612                                while ((c = calltodo.c_next) != NULL && c->c_time <= 0) {
613                                        void *arg;
614                                        void (*func) (void *);
615
616                                        func = c->c_func;
617                                        arg = c->c_arg;
618                                        calltodo.c_next = c->c_next;
619                                        c->c_next = callfree;
620                                        callfree = c;
621                                        (*func)(arg);
622                                }
623                        }
624                }
625        }
626}
627
628/*
629 * Structure passed to task-start stub
630 */
631struct newtask {
632        void (*entry)(void *);
633        void *arg;
634};
635
636/*
637 * Task-start stub
638 */
639static void
640taskEntry (rtems_task_argument arg)
641{
642        struct newtask t;
643
644        /*
645         * Pick up task information and free
646         * the memory allocated to pass the
647         * information to this task.
648         */
649        t = *(struct newtask *)arg;
650        free ((struct newtask *)arg);
651
652        /*
653         * Enter the competition for the network semaphore
654         */
655        rtems_bsdnet_semaphore_obtain ();
656
657        /*
658         * Enter the task
659         */
660        (*t.entry)(t.arg);
661        rtems_panic ("Network task returned!\n");
662}
663
664
665/*
666 * Start a network task
667 */
668#ifdef RTEMS_SMP
669rtems_id
670rtems_bsdnet_newproc (char *name, int stacksize, void(*entry)(void *), void *arg)
671{
672        return rtems_bsdnet_newproc_affinity( name, stacksize, entry, arg,
673                networkDaemonCpuset, networkDaemonCpusetSize );
674}
675
676rtems_id
677rtems_bsdnet_newproc_affinity (char *name, int stacksize, void(*entry)(void *),
678    void *arg, const cpu_set_t *set, const size_t setsize)
679#else
680rtems_id
681rtems_bsdnet_newproc (char *name, int stacksize, void(*entry)(void *), void *arg)
682#endif
683{
684        struct newtask *t;
685        char nm[4];
686        rtems_id tid;
687        rtems_status_code sc;
688
689        strncpy (nm, name, 4);
690        sc = rtems_task_create (rtems_build_name(nm[0], nm[1], nm[2], nm[3]),
691                networkDaemonPriority,
692                stacksize,
693                RTEMS_PREEMPT|RTEMS_NO_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
694#ifdef RTEMS_MULTIPROCESSING
695                RTEMS_SYSTEM_TASK |
696#endif
697                RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL,
698                &tid);
699        if (sc != RTEMS_SUCCESSFUL)
700                rtems_panic ("Can't create network daemon `%s': `%s'\n", name, rtems_status_text (sc));
701
702#ifdef RTEMS_SMP
703        /*
704         * Use the default affinity or use the user-provided CPU set
705         */
706        if ( set != 0 )
707                rtems_task_set_affinity( tid, setsize, set );
708#endif
709
710        /*
711         * Set up task arguments
712         */
713        t = malloc (sizeof *t);
714        t->entry = entry;
715        t->arg = arg;
716
717        /*
718         * Start the task
719         */
720        sc = rtems_task_start (tid, taskEntry, (rtems_task_argument)t);
721        if (sc != RTEMS_SUCCESSFUL)
722                rtems_panic ("Can't start network daemon `%s': `%s'\n", name, rtems_status_text (sc));
723
724        /*
725         * Let our caller know the i.d. of the new task
726         */
727        return tid;
728}
729
730rtems_status_code rtems_bsdnet_event_receive (
731  rtems_event_set  event_in,
732  rtems_option     option_set,
733  rtems_interval   ticks,
734  rtems_event_set *event_out)
735{
736        rtems_status_code sc;
737
738        rtems_bsdnet_semaphore_release ();
739        sc = rtems_event_system_receive (event_in, option_set, ticks, event_out);
740        rtems_bsdnet_semaphore_obtain ();
741        return sc;
742}
743
744/*
745 * Fake random number generator
746 */
747unsigned long
748rtems_bsdnet_random (void)
749{
750        rtems_interval now;
751
752        now = rtems_clock_get_ticks_since_boot();
753        return (now * 99991);
754}
755
756/*
757 * Callout list processing
758 */
759void
760rtems_bsdnet_timeout(void (*ftn)(void *), void *arg, int ticks)
761{
762        register struct callout *new, *p, *t;
763
764        if (ticks <= 0)
765                ticks = 1;
766
767        /* Fill in the next free callout structure. */
768        if (callfree == NULL) {
769                callfree = malloc (sizeof *callfree);
770                if (callfree == NULL)
771                        rtems_panic ("No memory for timeout table entry");
772                callfree->c_next = NULL;
773        }
774
775        new = callfree;
776        callfree = new->c_next;
777        new->c_arg = arg;
778        new->c_func = ftn;
779
780        /*
781         * The time for each event is stored as a difference from the time
782         * of the previous event on the queue.  Walk the queue, correcting
783         * the ticks argument for queue entries passed.  Correct the ticks
784         * value for the queue entry immediately after the insertion point
785         * as well.  Watch out for negative c_time values; these represent
786         * overdue events.
787         */
788        for (p = &calltodo;
789            (t = p->c_next) != NULL && ticks > t->c_time; p = t)
790                if (t->c_time > 0)
791                        ticks -= t->c_time;
792        new->c_time = ticks;
793        if (t != NULL)
794                t->c_time -= ticks;
795
796        /* Insert the new entry into the queue. */
797        p->c_next = new;
798        new->c_next = t;
799}
800
801/*
802 * Ticks till specified time
803 * XXX: This version worries only about seconds, but that's good
804 * enough for the way the network code uses this routine.
805 */
806int
807hzto(struct timeval *tv)
808{
809        long diff = tv->tv_sec - rtems_bsdnet_seconds_since_boot();
810
811        if (diff <= 0)
812                return 1;
813        return diff * rtems_bsdnet_ticks_per_second;
814}
815
816/*
817 * Kernel debugging
818 */
819int rtems_bsdnet_log_priority;
820void
821rtems_bsdnet_log (int priority, const char *fmt, ...)
822{
823        va_list args;
824
825        if (priority & rtems_bsdnet_log_priority) {
826                va_start (args, fmt);
827                vprintf (fmt, args);
828                va_end (args);
829        }
830}
831
832/*
833 * IP header checksum routine for processors which don't have an inline version
834 */
835
836u_int in_cksum_hdr(const struct ip *);
837
838u_int
839in_cksum_hdr (const struct ip *ip)
840{
841        uint32_t   sum;
842        const uint16_t   *sp;
843        int i;
844
845        sum = 0;
846        sp = (uint16_t   *)ip;
847        for (i = 0 ; i < 10 ; i++)
848                sum += *sp++;
849        while (sum > 0xFFFF)
850                sum = (sum & 0xffff) + (sum >> 16);
851        return ~sum & 0xFFFF;
852}
853
854/*
855 * Manipulate routing tables
856 */
857int rtems_bsdnet_rtrequest (
858    int req,
859    struct sockaddr *dst,
860    struct sockaddr *gateway,
861    struct sockaddr *netmask,
862    int flags,
863    struct rtentry **net_nrt)
864{
865        int error;
866
867        rtems_bsdnet_semaphore_obtain ();
868        error = rtrequest (req, dst, gateway, netmask, flags, net_nrt);
869        rtems_bsdnet_semaphore_release ();
870        if (error) {
871                errno = error;
872                return -1;
873        }
874        return 0;
875}
876
877static bool
878rtems_bsdnet_setup_interface(
879        const char *name,
880        const char *ip_address,
881        const char *ip_netmask
882)
883{
884        struct sockaddr_in address;
885        struct sockaddr_in netmask;
886        short flags;
887
888        /*
889         * Bring interface up
890         */
891        flags = IFF_UP;
892        if (rtems_bsdnet_ifconfig (name, SIOCSIFFLAGS, &flags) < 0) {
893                printf ("Can't bring %s up: %s\n", name, strerror (errno));
894                return false;
895        }
896
897        /*
898         * Set interface netmask
899         */
900        rtems_bsdnet_initialize_sockaddr_in(&netmask);
901        netmask.sin_addr.s_addr = inet_addr (ip_netmask);
902        if (rtems_bsdnet_ifconfig (name, SIOCSIFNETMASK, &netmask) < 0) {
903                printf ("Can't set %s netmask: %s\n", name, strerror (errno));
904                return false;
905        }
906
907        /*
908         * Set interface address
909         */
910        rtems_bsdnet_initialize_sockaddr_in(&address);
911        address.sin_addr.s_addr = inet_addr (ip_address);
912        if (rtems_bsdnet_ifconfig (name, SIOCSIFADDR, &address) < 0) {
913                printf ("Can't set %s address: %s\n", name, strerror (errno));
914                return false;
915        }
916
917        /*
918         * Set interface broadcast address if the interface has the
919         * broadcast flag set.
920         */
921        if (rtems_bsdnet_ifconfig (name, SIOCGIFFLAGS, &flags) < 0) {
922                printf ("Can't read %s flags: %s\n", name, strerror (errno));
923                return false;
924        }
925
926        if (flags & IFF_BROADCAST) {
927                struct sockaddr_in broadcast;
928
929                rtems_bsdnet_initialize_sockaddr_in(&broadcast);
930                broadcast.sin_addr.s_addr =
931                                address.sin_addr.s_addr | ~netmask.sin_addr.s_addr;
932                if (rtems_bsdnet_ifconfig (name, SIOCSIFBRDADDR, &broadcast) < 0) {
933                        struct in_addr  in_addr;
934                        char                    buf[20];
935                        in_addr.s_addr = broadcast.sin_addr.s_addr;
936                        if (!inet_ntop(AF_INET, &in_addr, buf, sizeof(buf)))
937                                        strcpy(buf,"?.?.?.?");
938                        printf ("Can't set %s broadcast address %s: %s\n",
939                                name, buf, strerror (errno));
940                }
941        }
942
943        return true;
944}
945
946static int
947rtems_bsdnet_setup (void)
948{
949        struct rtems_bsdnet_ifconfig *ifp;
950        int i;
951        bool any_if_configured = false;
952
953        /*
954         * Set local parameters
955         */
956        if (rtems_bsdnet_config.hostname)
957                sethostname (rtems_bsdnet_config.hostname,
958                                        strlen (rtems_bsdnet_config.hostname));
959        if (rtems_bsdnet_config.domainname)
960                rtems_bsdnet_domain_name =
961                                        strdup (rtems_bsdnet_config.domainname);
962        if (rtems_bsdnet_config.log_host)
963                rtems_bsdnet_log_host_address.s_addr =
964                                inet_addr (rtems_bsdnet_config.log_host);
965        for (i = 0 ; i < sizeof rtems_bsdnet_config.name_server /
966                        sizeof rtems_bsdnet_config.name_server[0] ; i++) {
967                if (!rtems_bsdnet_config.name_server[i])
968                        break;
969                rtems_bsdnet_nameserver[rtems_bsdnet_nameserver_count++].s_addr
970                        = inet_addr (rtems_bsdnet_config.name_server[i]);
971        }
972        for (i = 0 ; i < sizeof rtems_bsdnet_config.ntp_server /
973                        sizeof rtems_bsdnet_config.ntp_server[0] ; i++) {
974                if (!rtems_bsdnet_config.ntp_server[i])
975                        break;
976                rtems_bsdnet_ntpserver[rtems_bsdnet_ntpserver_count++].s_addr
977                        = inet_addr (rtems_bsdnet_config.ntp_server[i]);
978        }
979
980        /*
981         * Configure interfaces
982         */
983        any_if_configured |= rtems_bsdnet_setup_interface(
984                "lo0",
985                "127.0.0.1",
986                "255.0.0.0"
987        );
988        for (ifp = rtems_bsdnet_config.ifconfig ; ifp ; ifp = ifp->next) {
989                if (ifp->ip_address == NULL)
990                        continue;
991
992                any_if_configured |= rtems_bsdnet_setup_interface(
993                        ifp->name,
994                        ifp->ip_address,
995                        ifp->ip_netmask
996                );
997        }
998
999        /*
1000         * Set default route
1001         */
1002        if (rtems_bsdnet_config.gateway && any_if_configured) {
1003                struct sockaddr_in address;
1004                struct sockaddr_in netmask;
1005                struct sockaddr_in gateway;
1006
1007                rtems_bsdnet_initialize_sockaddr_in(&address);
1008                rtems_bsdnet_initialize_sockaddr_in(&netmask);
1009                rtems_bsdnet_initialize_sockaddr_in(&gateway);
1010
1011                gateway.sin_addr.s_addr = inet_addr (rtems_bsdnet_config.gateway);
1012
1013                if (rtems_bsdnet_rtrequest (
1014                                RTM_ADD,
1015                                (struct sockaddr *)&address,
1016                                (struct sockaddr *)&gateway,
1017                                (struct sockaddr *)&netmask,
1018                                (RTF_UP | RTF_GATEWAY | RTF_STATIC), NULL) < 0) {
1019                        printf ("Can't set default route: %s\n", strerror (errno));
1020                        return -1;
1021                }
1022        }
1023        return 0;
1024}
1025
1026/*
1027 * Initialize the network
1028 */
1029int
1030rtems_bsdnet_initialize_network(void)
1031{
1032        struct rtems_bsdnet_ifconfig *ifp;
1033
1034        /*
1035         * Start network tasks.
1036         * Initialize BSD network data structures.
1037         */
1038        if (rtems_bsdnet_initialize () < 0)
1039                return -1;
1040
1041        /*
1042         * Attach interfaces
1043         */
1044        for (ifp = rtems_bsdnet_config.ifconfig ; ifp ; ifp = ifp->next) {
1045                rtems_bsdnet_attach (ifp);
1046        }
1047
1048        /*
1049         * Bring up the network
1050         */
1051        if (rtems_bsdnet_setup () < 0)
1052                return -1;
1053        if (rtems_bsdnet_config.bootp)
1054                (*rtems_bsdnet_config.bootp)();
1055        return 0;
1056}
1057
1058/*
1059 * Attach a network interface.
1060 */
1061void rtems_bsdnet_attach(struct rtems_bsdnet_ifconfig *ifp)
1062{
1063        if (ifp) {
1064                rtems_bsdnet_semaphore_obtain ();
1065                (ifp->attach)(ifp, 1);
1066                rtems_bsdnet_semaphore_release ();
1067        }
1068}
1069
1070/*
1071 * Detach a network interface.
1072 */
1073void rtems_bsdnet_detach (struct rtems_bsdnet_ifconfig *ifp)
1074{
1075        if (ifp) {
1076                rtems_bsdnet_semaphore_obtain ();
1077                (ifp->attach)(ifp, 0);
1078                rtems_bsdnet_semaphore_release ();
1079        }
1080}
1081
1082/*
1083 * Interface Configuration.
1084 */
1085int rtems_bsdnet_ifconfig(const char *ifname, uint32_t cmd, void *param)
1086{
1087        int s, r = 0;
1088        struct ifreq ifreq;
1089
1090        /*
1091         * Configure interfaces
1092         */
1093        s = socket (AF_INET, SOCK_DGRAM, 0);
1094        if (s < 0)
1095                return -1;
1096
1097        strncpy (ifreq.ifr_name, ifname, IFNAMSIZ);
1098
1099        rtems_bsdnet_semaphore_obtain ();
1100
1101        switch (cmd) {
1102                case SIOCSIFADDR:
1103                case SIOCSIFNETMASK:
1104                        memcpy (&ifreq.ifr_addr, param, sizeof (struct sockaddr));
1105                        r = ioctl (s, cmd, &ifreq);
1106                        break;
1107
1108                case OSIOCGIFADDR:
1109                case SIOCGIFADDR:
1110                case OSIOCGIFNETMASK:
1111                case SIOCGIFNETMASK:
1112                        if ((r = ioctl (s, cmd, &ifreq)) < 0)
1113                                break;
1114                        memcpy (param, &ifreq.ifr_addr, sizeof (struct sockaddr));
1115                        break;
1116
1117                case SIOCGIFFLAGS:
1118                case SIOCSIFFLAGS:
1119                        if ((r = ioctl (s, SIOCGIFFLAGS, &ifreq)) < 0)
1120                                break;
1121                        if (cmd == SIOCGIFFLAGS) {
1122                                *((short*) param) = ifreq.ifr_flags;
1123                                break;
1124                        }
1125                        ifreq.ifr_flags |= *((short*) param);
1126                        if ( (*((short*) param) & IFF_UP ) == 0 ) {
1127                            /* set the interface down */
1128                            ifreq.ifr_flags &= ~(IFF_UP);
1129                        }
1130                        r = ioctl (s, SIOCSIFFLAGS, &ifreq);
1131                        break;
1132
1133                case SIOCSIFDSTADDR:
1134                        memcpy (&ifreq.ifr_dstaddr, param, sizeof (struct sockaddr));
1135                        r = ioctl (s, cmd, &ifreq);
1136                        break;
1137
1138                case OSIOCGIFDSTADDR:
1139                case SIOCGIFDSTADDR:
1140                        if ((r = ioctl (s, cmd, &ifreq)) < 0)
1141                                break;
1142                        memcpy (param, &ifreq.ifr_dstaddr, sizeof (struct sockaddr));
1143                        break;
1144
1145                case SIOCSIFBRDADDR:
1146                        memcpy (&ifreq.ifr_broadaddr, param, sizeof (struct sockaddr));
1147                        r = ioctl (s, cmd, &ifreq);
1148                        break;
1149
1150                case OSIOCGIFBRDADDR:
1151                case SIOCGIFBRDADDR:
1152                        if ((r = ioctl (s, cmd, &ifreq)) < 0)
1153                                break;
1154                        memcpy (param, &ifreq.ifr_broadaddr, sizeof (struct sockaddr));
1155                        break;
1156
1157                case SIOCSIFMETRIC:
1158                        ifreq.ifr_metric = *((int*) param);
1159                        r = ioctl (s, cmd, &ifreq);
1160                        break;
1161
1162                case SIOCGIFMETRIC:
1163                        if ((r = ioctl (s, cmd, &ifreq)) < 0)
1164                                break;
1165                        *((int*) param) = ifreq.ifr_metric;
1166                        break;
1167
1168                case SIOCSIFMTU:
1169                        ifreq.ifr_mtu = *((int*) param);
1170                        r = ioctl (s, cmd, &ifreq);
1171                        break;
1172
1173                case SIOCGIFMTU:
1174                        if ((r = ioctl (s, cmd, &ifreq)) < 0)
1175                                break;
1176                        *((int*) param) = ifreq.ifr_mtu;
1177                        break;
1178
1179                case SIOCSIFPHYS:
1180                        ifreq.ifr_phys = *((int*) param);
1181                        r = ioctl (s, cmd, &ifreq);
1182                        break;
1183
1184                case SIOCGIFPHYS:
1185                        if ((r = ioctl (s, cmd, &ifreq)) < 0)
1186                                break;
1187                        *((int*) param) = ifreq.ifr_phys;
1188                        break;
1189
1190                case SIOCSIFMEDIA:
1191                        ifreq.ifr_media = *((int*) param);
1192                        r = ioctl (s, cmd, &ifreq);
1193                        break;
1194
1195                case SIOCGIFMEDIA:
1196                        /* 'param' passes the phy index they want to
1197                         * look at...
1198                         */
1199                        ifreq.ifr_media = *((int*) param);
1200                        if ((r = ioctl (s, cmd, &ifreq)) < 0)
1201                                break;
1202                        *((int*) param) = ifreq.ifr_media;
1203                        break;
1204
1205                case SIOCAIFADDR:
1206                case SIOCDIFADDR:
1207                        r = ioctl(s, cmd, (struct ifreq *) param);
1208                        break;
1209
1210                default:
1211                        errno = EOPNOTSUPP;
1212                        r = -1;
1213                        break;
1214        }
1215
1216        rtems_bsdnet_semaphore_release ();
1217
1218        close (s);
1219        return r;
1220}
1221
1222/**
1223 * @brief Splits a network interface name with interface configuration @a
1224 * config into the unit name and number parts.
1225 *
1226 * Memory for the unit name will be allocated from the heap and copied to @a
1227 * namep.  If @a namep is NULL nothing will be allocated and copied.
1228 *
1229 * Returns the unit number or -1 on error.
1230 */
1231int
1232rtems_bsdnet_parse_driver_name (const struct rtems_bsdnet_ifconfig *config, char **namep)
1233{
1234        const char *cp = config->name;
1235        char c;
1236        int unitNumber = 0;
1237
1238        if (cp == NULL) {
1239                printf ("No network driver name.\n");
1240                return -1;
1241        }
1242        while ((c = *cp++) != '\0') {
1243                if ((c >= '0') && (c <= '9')) {
1244                        int len = cp - config->name;
1245                        if ((len < 2) || (len > 50))
1246                                break;
1247                        for (;;) {
1248                                unitNumber = (unitNumber * 10) + (c - '0');
1249                                c = *cp++;
1250                                if (c == '\0') {
1251                                        if (namep != NULL) {
1252                                                char *unitName = malloc (len);
1253                                                if (unitName == NULL) {
1254                                                        printf ("No memory.\n");
1255                                                        return -1;
1256                                                }
1257                                                strncpy (unitName, config->name, len - 1);
1258                                                unitName[len-1] = '\0';
1259                                                *namep = unitName;
1260                                        }
1261                                        return unitNumber;
1262                                }
1263                                if ((c < '0') || (c > '9'))
1264                                        break;
1265                        }
1266                        break;
1267                }
1268        }
1269        printf ("Bad network driver name `%s'.\n", config->name);
1270        return -1;
1271}
1272
1273/*
1274 * Handle requests for more network memory
1275 * XXX: Another possibility would be to use a semaphore here with
1276 *      a release in the mbuf free macro.  I have chosen this `polling'
1277 *      approach because:
1278 *      1) It is simpler.
1279 *      2) It adds no complexity to the free macro.
1280 *      3) Running out of mbufs should be a rare
1281 *         condition -- predeployment testing of
1282 *         an application should indicate the
1283 *         required mbuf pool size.
1284 * XXX: Should there be a panic if a task is stuck in the loop for
1285 *      more than a minute or so?
1286 */
1287int
1288m_mballoc(int nmb, int nowait)
1289{
1290        if (nowait)
1291                return 0;
1292        m_reclaim ();
1293        if (mmbfree == NULL) {
1294                int try = 0;
1295                int print_limit = 30 * rtems_bsdnet_ticks_per_second;
1296
1297                mbstat.m_wait++;
1298                for (;;) {
1299                        uint32_t nest_count = rtems_bsdnet_semaphore_release_recursive ();
1300                        rtems_task_wake_after (1);
1301                        rtems_bsdnet_semaphore_obtain_recursive (nest_count);
1302                        if (mmbfree)
1303                                break;
1304                        if (++try >= print_limit) {
1305                                printf ("Still waiting for mbuf.\n");
1306                                try = 0;
1307                        }
1308                }
1309        }
1310        else {
1311                mbstat.m_drops++;
1312        }
1313        return 1;
1314}
1315
1316int
1317m_clalloc(int ncl, int nowait)
1318{
1319        if (nowait)
1320                return 0;
1321        m_reclaim ();
1322        if (mclfree == NULL) {
1323                int try = 0;
1324                int print_limit = 30 * rtems_bsdnet_ticks_per_second;
1325
1326                mbstat.m_wait++;
1327                for (;;) {
1328                        uint32_t nest_count = rtems_bsdnet_semaphore_release_recursive ();
1329                        rtems_task_wake_after (1);
1330                        rtems_bsdnet_semaphore_obtain_recursive (nest_count);
1331                        if (mclfree)
1332                                break;
1333                        if (++try >= print_limit) {
1334                                printf ("Still waiting for mbuf cluster.\n");
1335                                try = 0;
1336                        }
1337                }
1338        }
1339        else {
1340                mbstat.m_drops++;
1341        }
1342        return 1;
1343}
1344
Note: See TracBrowser for help on using the repository browser.