Partially working version of the modified network stack.
authorpravin@inf.ethz.ch <pravin@inf.ethz.ch>
Thu, 31 Oct 2013 03:39:56 +0000 (04:39 +0100)
committerpravin@inf.ethz.ch <pravin@inf.ethz.ch>
Thu, 31 Oct 2013 03:39:56 +0000 (04:39 +0100)
Status: Networking works
Small website test works (Barrelfish website without pdfs)
Full website test does not work (Barrelfish website with pdfs)
Tests done with e1000n running on separate core

31 files changed:
include/contmng/contmng.h
include/lwip/debug.h
include/lwip/opt.h
include/trace/trace.h
kernel/arch/x86_64/irq.c
kernel/schedule_rbed.c
kernel/syscall.c
lib/barrelfish/arch/x86_64/dispatch.c
lib/barrelfish/dispatch.c
lib/barrelfish/threads.c
lib/contmng/contmng.c
lib/lwip/src/barrelfish/ARP_lookup_client.c
lib/lwip/src/barrelfish/idc_barrelfish.c
lib/lwip/src/core/ipv4/ip.c
lib/lwip/src/core/udp.c
lib/lwip/src/netif/bfeth.c
lib/lwip/src/netif/etharp.c
lib/lwip/src/sys_arch.c
lib/net_interfaces/interface_raw.c
lib/net_queue_manager/net_soft_filters_srv_impl.c
lib/net_queue_manager/queue_manager.c
lib/nfs/nfs.c
lib/nfs/nfs_debug.h
lib/nfs/rpc.c
trace_definitions/trace_defs.pleco
usr/bench/net_latency/elb/benchmark.c
usr/bench/net_latency/elb/benchmark_tcp.c
usr/drivers/e1000/e1000n.c
usr/netd/ARP_lookup_service.c
usr/webserver/http_cache.c
usr/webserver/main.c

index 87a22b0..a9aa64a 100644 (file)
@@ -66,6 +66,7 @@ void enqueue_cont_q(struct cont_queue *q, struct q_entry *entry);
 void cont_queue_callback(void *arg);
 void cont_queue_show_queue(struct cont_queue *q);
 int queue_free_slots(struct cont_queue *q);
+int queue_used_slots(struct cont_queue *q);
 int is_enough_space_in_queue(struct cont_queue *q);
 
 void show_binary_blob (void *data, int len);
index 00edf5c..ee633a4 100644 (file)
@@ -73,7 +73,7 @@
   LWIP_PLATFORM_ASSERT(message); handler;}} while(0)
 #endif                          /* LWIP_ERROR */
 
-//#define LWIP_DEBUG
+//#define LWIP_DEBUG 1
 #ifdef LWIP_DEBUG
 /** print debug message only if debug message type is enabled...
  *  AND is of correct type AND is at least LWIP_DBG_LEVEL
index 58ade78..7a46d78 100644 (file)
  * UDP_DEBUG: Enable debugging in UDP.
  */
 #ifndef UDP_DEBUG
+//#define UDP_DEBUG                       LWIP_DBG_ON
 #define UDP_DEBUG                       LWIP_DBG_OFF
 #endif
 
index 34c7915..f6c3066 100644 (file)
 #include <trace_definitions/trace_defs.h>
 
 
-/* Constant for low-level networking trace */
-#define TRACE_SUBSYS_LLNET                  0xD000
-#define TRACE_EVENT_LLNET_START             0x0001
-#define TRACE_EVENT_LLNET_STOP              0x0002
-#define TRACE_EVENT_LLNET_IRQ               0x0003
-#define TRACE_EVENT_LLNET_LMPDISP           0x0004
-
-#define TRACE_EVENT_LLNET_DRVIRQ            0x0010
-#define TRACE_EVENT_LLNET_DRVRX             0x0011
-#define TRACE_EVENT_LLNET_DRVTXADD          0x0012
-#define TRACE_EVENT_LLNET_DRVTXDONE         0x0013
-
-#define TRACE_EVENT_LLNET_LWIPPBA1          0x0020
-#define TRACE_EVENT_LLNET_LWIPPBA2          0x0021
-#define TRACE_EVENT_LLNET_LWIPPBF1          0x0022
-#define TRACE_EVENT_LLNET_LWIPPBF2          0x0023
-#define TRACE_EVENT_LLNET_LWIPRX            0x0024
-#define TRACE_EVENT_LLNET_LWIPTX            0x0025
-
-#define TRACE_EVENT_LLNET_APPRX             0x0030
-#define TRACE_EVENT_LLNET_APPTX             0x0031
-
 
 
 #define TRACE_EVENT(s,e,a) ((uint64_t)(s)<<48|(uint64_t)(e)<<32|(a))
@@ -420,7 +398,19 @@ static inline errval_t trace_write_event(struct trace_event *ev)
 {
 #ifdef TRACING_EXISTS
     dispatcher_handle_t handle = curdispatcher();
+
+    if (((uintptr_t)handle) == ((uintptr_t)NULL)) {
+        // FIXME: should return TRACE_ERR_NOT_VALID_HANDLE
+        return TRACE_ERR_NO_BUFFER;
+    }
+
     struct dispatcher_generic *disp = get_dispatcher_generic(handle);
+
+    if (disp == NULL) {
+        // FIXME: should return TRACE_ERR_NOT_VALID_DISP
+        return TRACE_ERR_NO_BUFFER;
+    }
+
     struct trace_buffer *trace_buf = disp->trace_buf;
 
     if (trace_buf == NULL) {
@@ -492,6 +482,7 @@ static inline errval_t trace_event_raw(uint64_t raw)
 }
 
 #ifdef TRACING_EXISTS
+#include <stdio.h>
 /// Is the subsystem enabled, i.e. should we log events for it?
 static inline bool trace_is_subsys_enabled(uint16_t subsys)
 {
index d94f505..bdf3974 100644 (file)
@@ -529,7 +529,7 @@ static __attribute__ ((used,noreturn))
     assert(vec < NEXCEPTIONS);
 
     printk(LOG_PANIC, "exception %d (error code 0x%lx): ", (int)vec, error);
-    
+
     if (vec == ia32_vec_pf) {
         printf("%s page fault due to %s%s, while in %s mode%s\n",
                error & ERR_PF_READ_WRITE ? "write" : "read",
@@ -552,32 +552,32 @@ static __attribute__ ((used,noreturn))
     // Print faulting instruction pointer
     uintptr_t rip = gdb_save_frame[GDB_X86_64_RIP_REG];
     printf("Faulting instruction pointer (or next instruction): 0x%lx\n", rip);
-    printf("  => i.e. unrelocated kernel address 0x%lx\n", 
+    printf("  => i.e. unrelocated kernel address 0x%lx\n",
            rip - (uintptr_t)&_start_kernel + X86_64_START_KERNEL_PHYS);
-    
+
     printf("Registers:\n");
-    printf(" rax: 0x%016lx  r8 : 0x%016lx\n", 
+    printf(" rax: 0x%016lx  r8 : 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RAX_REG],
            gdb_save_frame[GDB_X86_64_R8_REG]);
-    printf(" rbx: 0x%016lx  r9 : 0x%016lx\n", 
+    printf(" rbx: 0x%016lx  r9 : 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RBX_REG],
            gdb_save_frame[GDB_X86_64_R9_REG]);
-    printf(" rcx: 0x%016lx  r10: 0x%016lx\n", 
+    printf(" rcx: 0x%016lx  r10: 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RCX_REG],
            gdb_save_frame[GDB_X86_64_R10_REG]);
-    printf(" rdx: 0x%016lx  r11: 0x%016lx\n", 
+    printf(" rdx: 0x%016lx  r11: 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RDX_REG],
            gdb_save_frame[GDB_X86_64_R11_REG]);
-    printf(" rsp: 0x%016lx  r12: 0x%016lx\n", 
+    printf(" rsp: 0x%016lx  r12: 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RSP_REG],
            gdb_save_frame[GDB_X86_64_R12_REG]);
-    printf(" rdi: 0x%016lx  r13: 0x%016lx\n", 
+    printf(" rdi: 0x%016lx  r13: 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RDI_REG],
            gdb_save_frame[GDB_X86_64_R13_REG]);
-    printf(" rsi: 0x%016lx  r14: 0x%016lx\n", 
+    printf(" rsi: 0x%016lx  r14: 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RSI_REG],
            gdb_save_frame[GDB_X86_64_R14_REG]);
-    printf(" rip: 0x%016lx  r15: 0x%016lx\n", 
+    printf(" rip: 0x%016lx  r15: 0x%016lx\n",
            gdb_save_frame[GDB_X86_64_RIP_REG],
            gdb_save_frame[GDB_X86_64_R15_REG]);
 
@@ -740,6 +740,7 @@ static __attribute__ ((used))
             if (vec == IDT_DB) { // debug exception: just continue
                 resume(dispatcher_get_trap_save_area(handle));
             } else {
+
                 // can't handle a trap while disabled: nowhere safe to deliver it
                 scheduler_remove(dcb_current);
                 dispatch(schedule());
index fd771d7..e531fa5 100644 (file)
@@ -448,7 +448,7 @@ void make_runnable(struct dcb *dcb)
         break;
 
     case TASK_TYPE_SOFT_REALTIME:
-        //        u_srt += 
+        //        u_srt +=
         panic("Unimplemented!");
         break;
 
index cc333ec..225823f 100644 (file)
@@ -178,6 +178,8 @@ sys_dispatcher_properties(struct capability *to,
     assert(wcet <= period);
     assert(type != TASK_TYPE_BEST_EFFORT || weight > 0);
 
+    trace_event(TRACE_SUBSYS_KERNEL, TRACE_EVENT_KERNEL_SCHED_REMOVE,
+                152);
     scheduler_remove(dcb);
 
     /* Set task properties */
@@ -488,6 +490,10 @@ struct sysret sys_yield(capaddr_t target)
     systime_t wakeup = disp->wakeup;
     if (!disp->haswork && disp->lmp_delivered == disp->lmp_seen
         && (wakeup == 0 || wakeup > kernel_now)) {
+
+    trace_event(TRACE_SUBSYS_KERNEL, TRACE_EVENT_KERNEL_SCHED_REMOVE,
+                151);
+
         scheduler_remove(dcb_current);
         if (wakeup != 0) {
             wakeup_set(dcb_current, wakeup);
@@ -507,8 +513,8 @@ struct sysret sys_yield(capaddr_t target)
             panic("invalid type in yield cap");
         }
 
-//        trace_event(TRACE_SUBSYS_BNET, TRACE_EVENT_BNET_YIELD,
-//            (uint32_t)(lvaddr_t)target_dcb & 0xFFFFFFFF);
+        trace_event(TRACE_SUBSYS_BNET, TRACE_EVENT_BNET_YIELD,
+            (uint32_t)(lvaddr_t)target_dcb & 0xFFFFFFFF);
         make_runnable(target_dcb);
         dispatch(target_dcb);
     } else {
index 613cc65..0522ff6 100644 (file)
@@ -248,6 +248,8 @@ disp_save(dispatcher_handle_t handle, arch_registers_state_t *state,
                     );
 
     if (yield) {
+//        trace_event(TRACE_SUBSYS_THREADS, TRACE_EVENT_THREADS_SYS_YIELD, 1);
+
         sys_yield(yield_to);
         // may fail if target doesn't exist; if so, just fall through
     }
index 191f532..e694dd5 100644 (file)
 #include <barrelfish_kpi/cpu_arch.h>
 #include "threads_priv.h"
 
+
+#include <trace/trace.h>
+#include <trace_definitions/trace_defs.h>
+
 #ifdef CONFIG_INTERCONNECT_DRIVER_LMP
 # include <barrelfish/lmp_chan.h>
 #endif
@@ -189,6 +193,7 @@ void disp_yield_disabled(dispatcher_handle_t handle)
     disp->yieldcount++;
 #endif
 
+    trace_event(TRACE_SUBSYS_THREADS, TRACE_EVENT_THREADS_SYS_YIELD, 2);
     sys_yield(CPTR_NULL);
     assert_print("dispatcher PANIC: sys_yield returned");
     for (;;);
index 9ca11d9..0e0e075 100644 (file)
@@ -28,6 +28,8 @@
 #include <arch/registers.h>
 #include <trace/trace.h>
 
+#include <trace_definitions/trace_defs.h>
+
 #include "arch/threads.h"
 #include "threads_priv.h"
 #include "init.h"
@@ -615,6 +617,7 @@ void thread_yield(void)
     } else {
         assert_disabled(disp_gen->runq != NULL);
         assert_disabled(disp->haswork);
+        trace_event(TRACE_SUBSYS_THREADS, TRACE_EVENT_THREADS_C_DISP_SAVE, 3);
         disp_save(handle, enabled_area, true, CPTR_NULL);
     }
 }
@@ -638,6 +641,8 @@ void thread_yield_dispatcher(struct capref endpoint)
 
     assert_disabled(disp_gen->runq != NULL);
     assert_disabled(disp->haswork);
+
+    trace_event(TRACE_SUBSYS_THREADS, TRACE_EVENT_THREADS_C_DISP_SAVE, 1);
     disp_save(handle, enabled_area, true, get_cap_addr(endpoint));
 }
 
@@ -845,6 +850,7 @@ void *thread_block_and_release_spinlock_disabled(dispatcher_handle_t handle,
         assert_disabled(disp_gen->runq == NULL);
         disp_gen->current = NULL;
         disp->haswork = havework_disabled(handle);
+        trace_event(TRACE_SUBSYS_THREADS, TRACE_EVENT_THREADS_C_DISP_SAVE, 2);
         disp_save(handle, &me->regs, true, CPTR_NULL);
     }
 
index ae2a425..40a8c26 100644 (file)
@@ -70,6 +70,20 @@ struct cont_queue *create_cont_q(char *name)
 
 
 
+// Tells how many slots are actually used
+int queue_used_slots(struct cont_queue *q)
+{
+    uint64_t nhead = q->head % MAX_QUEUE_SIZE;
+    uint64_t ntail = q->tail % MAX_QUEUE_SIZE;
+    if ( nhead >= ntail) {
+        return (nhead - ntail);
+    } else {
+        return (ntail + (MAX_QUEUE_SIZE - nhead));
+    }
+} // end function: queue_used_slots
+
+
+
 /* Tells if queue has enough space to add more events,
  * or if the producer should pause for a while */
 int queue_free_slots(struct cont_queue *q)
@@ -196,8 +210,8 @@ void cont_queue_show_queue(struct cont_queue *q)
 
     int len = 0;
     len = q->head - q->tail;
-    printf("Showing the cont queue status for queue[%s]\n", q->name);
-    printf("queue len [%d]==> head [%d] - tail [%d]\n", len, q->head, q->tail);
+    printf("queue [%s] len [%d]==> head [%d] - tail [%d]\n",
+            q->name, len, q->head, q->tail);
 
     /*
     int i = 0;
index cba6a3b..2bfe1fd 100644 (file)
@@ -98,8 +98,7 @@ static void init_net_ARP_connection(char *service_name)
 // In case of error, it will panic!!
 void idc_connect_ARP_lookup_service(char *service_name)
 {
-    //LWIPBF_DEBUG
-    printf("idc_c_ARP_lookup_srv: trying to [%s]\n", service_name);
+    LWIPBF_DEBUG("idc_c_ARP_lookup_srv: trying to [%s]\n", service_name);
 
     /* FIXME: decide if this is the best place to connect with net_ARP */
     init_net_ARP_connection(service_name);
@@ -114,8 +113,7 @@ void idc_connect_ARP_lookup_service(char *service_name)
             USER_PANIC_ERR(err, "in event_dispatch while binding ARP_service");
         }
     }
-    //LWIPBF_DEBUG
-    printf("idc_c_ARP_lookup_srv: success [%s]\n", service_name);
+    LWIPBF_DEBUG("idc_c_ARP_lookup_srv: success [%s]\n", service_name);
 }
 
 
@@ -154,8 +152,7 @@ void idc_get_ip_from_ARP_lookup(void)
     netif_set_default(&netif);
     netif_set_up(&netif);
 
-    //LWIPBF_DEBUG
-    printf("client: owner has the IP address %d.%d.%d.%d\n",
+    LWIPBF_DEBUG("client: owner has the IP address %d.%d.%d.%d\n",
                  ip4_addr1(&netif.ip_addr), ip4_addr2(&netif.ip_addr),
                  ip4_addr3(&netif.ip_addr), ip4_addr4(&netif.ip_addr));
 }
index b0a096d..6243f1d 100644 (file)
@@ -135,7 +135,7 @@ uint64_t idc_send_packet_to_network_driver(struct pbuf *p)
         trace_event(TRACE_SUBSYS_LLNET, TRACE_EVENT_LLNET_LWIPTX, 0);
 #endif // TRACE_ONLY_LLNET
 
-    LWIPBF_DEBUG("idc_send_packet_to_network_driver: called\n");
+    LWIPBF_DEBUG("%s: idc_send_packet_to_network_driver: called\n", disp_name());
 
     size_t pbuf_chain_len = pbuf_clen(p);
     struct waitset *ws = get_default_waitset();
index c4a45dd..adf4b7c 100644 (file)
@@ -603,7 +603,6 @@ err_t ip_output_if_opt(struct pbuf * p, struct ip_addr * src,
 
             IP_STATS_INC(ip.err);
             snmp_inc_ipoutdiscards();
-            printf("netif->output() %d\n", __LINE__);
             return ERR_BUF;
         }
 
index aa2c23e..8019a3d 100644 (file)
@@ -446,7 +446,6 @@ udp_sendto_if(struct udp_pcb * pcb, struct pbuf * p,
     /* not enough space to add an UDP header to first pbuf in given p chain? */
     if (pbuf_header(p, UDP_HLEN)) {
         /* allocate header in a separate new pbuf */
-        printf("Not enough room in buffer for header!!\n");
         q = pbuf_alloc(PBUF_IP, UDP_HLEN, PBUF_RAM);
         /* new header pbuf could not be allocated? */
         if (q == NULL) {
@@ -622,7 +621,6 @@ err_t udp_bind(struct udp_pcb * pcb, struct ip_addr * ipaddr, u16_t port)
     LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | 3, ("udp_bind: starting %u\n",
                                                  port));
 
-    //printf("udp_bind:called............................ \n");
     /* Following modifications are part of DEMUX : PS */
     if (port == 0) {
         err = idc_udp_new_port(&port);
@@ -715,7 +713,6 @@ err_t udp_connect(struct udp_pcb * pcb, struct ip_addr * ipaddr, u16_t port)
 {
     struct udp_pcb *ipcb;
 
-//    printf("udp_connect:called............................ \n");
     if (pcb->local_port == 0) {
         err_t err = udp_bind(pcb, &pcb->local_ip, pcb->local_port);
 
index 3fd3ddc..a409b43 100644 (file)
@@ -135,7 +135,6 @@ static err_t low_level_output(struct netif *netif, struct pbuf *p)
         pbuf_ref(tmpp);
         ++numpbuf;
     }
-
 #if ETH_PAD_SIZE
     pbuf_header(p, -ETH_PAD_SIZE);      /* drop the padding word */
 #endif
@@ -250,7 +249,6 @@ bfeth_input(struct netif *netif, uint64_t pbuf_id, uint64_t paddr, uint64_t len,
     uint64_t ts = rdtsc();
     struct pbuf *replaced_pbuf = mem_barrelfish_replace_pbuf(pbuf_id);
     if (replaced_pbuf == NULL) {
-        printf("\n");
         assert(replaced_pbuf != NULL);
         USER_PANIC("Can't replace received pbuf in RX ring\n");
     }
index ad0c8fd..007b60b 100644 (file)
@@ -858,6 +858,7 @@ err_t etharp_output(struct netif *netif, struct pbuf *q, struct ip_addr *ipaddr)
 {
     struct eth_addr *dest, mcastaddr;
 
+    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, "etharp_output : called\n");
     /* make room for Ethernet header - should not fail */
     if (pbuf_header(q, sizeof(struct eth_hdr)) != 0) {
         /* bail out */
@@ -901,6 +902,8 @@ err_t etharp_output(struct netif *netif, struct pbuf *q, struct ip_addr *ipaddr)
                 return ERR_RTE;
             }
         }
+        LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
+            ("%s:etharp_output : queue for etharp_query\n", disp_name()));
         /* queue on destination Ethernet address belonging to ipaddr */
         return etharp_query(netif, ipaddr, q);
     }
@@ -908,6 +911,8 @@ err_t etharp_output(struct netif *netif, struct pbuf *q, struct ip_addr *ipaddr)
     /* continuation for multicast/broadcast destinations */
     /* obtain source Ethernet address of the given interface */
     /* send packet directly on the link */
+    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
+        ("%s:etharp_output : send packet directly on link\n", disp_name()));
     return etharp_send_ip(netif, q, (struct eth_addr *) (netif->hwaddr), dest);
 }
 
@@ -971,6 +976,9 @@ etharp_query(struct netif * netif, struct ip_addr * ipaddr, struct pbuf * q)
     err_t result = ERR_MEM;
     s8_t i;                     /* ARP entry index */
 
+    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
+        ("%s:etharp_query: called\n", disp_name()));
+
     /* non-unicast address? */
     if (ip_addr_isbroadcast(ipaddr, netif) ||
         ip_addr_ismulticast(ipaddr) || ip_addr_isany(ipaddr)) {
@@ -995,6 +1003,8 @@ etharp_query(struct netif * netif, struct ip_addr * ipaddr, struct pbuf * q)
                         ("etharp_query: packet dropped\n"));
             ETHARP_STATS_INC(etharp.memerr);
         }
+        LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
+            ("%s:etharp_query: error: could not find/create entry\n", disp_name()));
         return (err_t) i;
     }
 
@@ -1025,7 +1035,11 @@ etharp_query(struct netif * netif, struct ip_addr * ipaddr, struct pbuf * q)
             }
         } else {
             // This is a ARP client
+            LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
+                ("%s:etharp_query: this is ARP client\n", disp_name()));
             arp_table[i].ethaddr = etharp_request_via_ARP_srv(netif, ipaddr);
+            LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
+                ("%s:etharp_query: ARP client got reply\n", disp_name()));
             arp_table[i].state = ETHARP_STATE_STABLE;
         } // end else: not a special app
     } // end if: ARP table state pending
@@ -1094,21 +1108,21 @@ etharp_query(struct netif * netif, struct ip_addr * ipaddr, struct pbuf * q)
                         arp_table[i].q = new_entry;
                     }
                     LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
-                                ("etharp_query: queued packet %p on ARP entry %"
+                        ("etharp_query: queued packet %p on ARP entry %"
                                  S16_F "\n", (void *) q, (s16_t) i));
                     result = ERR_OK;
                 } else {
                     /* the pool MEMP_ARP_QUEUE is empty */
                     pbuf_free(p);
                     LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
-                                ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n",
+                        ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n",
                                  (void *) q));
                     /* { result == ERR_MEM } through initialization */
                 }
             } else {
                 ETHARP_STATS_INC(etharp.memerr);
                 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
-                            ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n",
+                    ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n",
                              (void *) q));
                 /* { result == ERR_MEM } through initialization */
             }
@@ -1116,7 +1130,7 @@ etharp_query(struct netif * netif, struct ip_addr * ipaddr, struct pbuf * q)
             /* q && state == PENDING && ARP_QUEUEING == 0 => result = ERR_MEM */
             /* { result == ERR_MEM } through initialization */
             LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
-                        ("etharp_query: Ethernet destination address unknown, queueing disabled, packet %p dropped\n",
+                ("etharp_query: Ethernet destination address unknown, queueing disabled, packet %p dropped\n",
                          (void *) q));
 #endif
         }
@@ -1213,6 +1227,8 @@ etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
 
     hdr->ethhdr.type = htons(ETHTYPE_ARP);
     /* send ARP query */
+    LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
+        ("%s: etharp_raw\n", disp_name()));
     result = netif->linkoutput(netif, p);
     ETHARP_STATS_INC(etharp.xmit);
     /* free ARP query packet */
@@ -1282,9 +1298,9 @@ err_t ethernet_input(struct pbuf *p, struct netif *netif)
             /* skip Ethernet header */
             if (pbuf_header(p, -(s16_t) sizeof(struct eth_hdr))) {
 //        LWIP_ASSERT("Can't move over header in packet", 0);
-                printf
+            LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
                   ("ethernet_input: Can't move over header in packet %d, %p\n",
-                   p->len, p->next);
+                   p->len, p->next));
                 pbuf_free(p);
                 p = NULL;
             } else {
@@ -1360,16 +1376,15 @@ static struct eth_addr etharp_request_via_ARP_srv(struct netif * netif,
         struct ip_addr * ipaddr)
 {
     LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
-                ("etharp_request_via_ARP_srv: sending ARP request.\n"));
+        ("etharp_request_via_ARP_srv: sending ARP request.\n" ));
     LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
-                ("etharp_request_via_ARP_srv: sending ARP request:"
+            ("etharp_request_via_ARP_srv: sending ARP request:"
                  "%" U16_F ".%" U16_F ".%" U16_F ".%" U16_F "\n",
                  ip4_addr1(ipaddr), ip4_addr2(ipaddr), ip4_addr3(ipaddr),
                  ip4_addr4(ipaddr)));
 
     uint64_t found_mac = idc_ARP_lookup(ipaddr->addr);
     if (found_mac == 0) {
-        printf("could not find MAC with ARP_lookup service\n");
         abort();
     }
     return (convert_uint64_to_eth_addr(found_mac));
index 40baed8..35cafd8 100644 (file)
@@ -9,6 +9,7 @@
 
 #include <lwip/sys.h>
 #include <barrelfish/barrelfish.h>
+#include <barrelfish/deferred.h>
 
 /*
  * TODO:
index 5e96ca3..0c35f7c 100644 (file)
@@ -31,7 +31,8 @@ static void idc_register_buffer(struct net_queue_manager_binding *binding,
                                 uint64_t qid, uint64_t slots, uint8_t role);
 
 static errval_t idc_raw_add_buffer(struct net_queue_manager_binding *binding,
-                     uint64_t offset, uint64_t len, uint64_t more_chunks);
+                               uint64_t offset, uint64_t len,
+                               uint64_t more_chunks, bool blocking);
 
 static void idc_get_mac_address(struct net_queue_manager_binding *binding,
                                 uint64_t qid);
@@ -60,7 +61,7 @@ errval_t buffer_tx_add(size_t idx, size_t offset, size_t len, size_t more_chunks
 
     errval_t err = SYS_ERR_OK;
     err = idc_raw_add_buffer(binding_tx, idx * BUFFER_SIZE + offset, len,
-            (uint64_t)more_chunks);
+            (uint64_t)more_chunks, 0);
     return err;
 }
 
@@ -68,7 +69,7 @@ errval_t buffer_rx_add(size_t idx)
 {
 
     errval_t err = SYS_ERR_OK;
-    err = idc_raw_add_buffer(binding_rx, idx * BUFFER_SIZE, BUFFER_SIZE, 0);
+    err = idc_raw_add_buffer(binding_rx, idx * BUFFER_SIZE, BUFFER_SIZE, 0, 1);
     return err;
 }
 
@@ -125,8 +126,10 @@ static errval_t send_raw_add_buffer(struct q_entry entry)
     }
 }
 
+
 static errval_t idc_raw_add_buffer(struct net_queue_manager_binding *binding,
-                               uint64_t offset, uint64_t len, uint64_t more_chunks)
+                               uint64_t offset, uint64_t len,
+                               uint64_t more_chunks, bool blocking)
 {
 
     struct q_entry entry;
@@ -148,6 +151,18 @@ static errval_t idc_raw_add_buffer(struct net_queue_manager_binding *binding,
         ++passed_events;
     }
 
+
+    if (blocking) {
+        while (queue_used_slots(binding->st) > 1) {
+            /*
+            printf("%s:The event count is %d\n", disp_name(),
+                        queue_used_slots(binding->st));
+            cont_queue_show_queue(binding->st);
+            */
+            event_dispatch(ws);
+        }
+    }
+
     enqueue_cont_q(binding->st, &entry);
     return SYS_ERR_OK;
 }
index 785e0b8..3c98c38 100644 (file)
@@ -1312,18 +1312,23 @@ void sf_process_received_packet(void *opaque, size_t pkt_len, bool is_last)
 
     // check for application specific packet
     if (handle_application_packet(pkt_data, pkt_len)) {
-        ETHERSRV_DEBUG("application specific packet.. len %"PRIu64"\n", pkt_len);
+        ETHERSRV_DEBUG
+//          printf
+          ("application specific packet.. len %"PRIu64"\n", pkt_len);
         goto out;
     }
 
     // check for ARP packet
      if (handle_arp_packet(pkt_data, pkt_len)) {
-        ETHERSRV_DEBUG("ARP packet..\n");
+        ETHERSRV_DEBUG
+//        printf
+            ("ARP packet..\n");
         goto out;
     }
 
     // last resort: send packet to netd
 
+    ETHERSRV_DEBUG("orphan packet, goes to netd..\n");
     handle_netd_packet(pkt_data, pkt_len);
 
 out:
index 3d4417a..4c001c5 100755 (executable)
@@ -791,7 +791,6 @@ static void raw_add_buffer(struct net_queue_manager_binding *cc,
     paddr = (uint64_t) (uintptr_t) buffer->pa + offset;
     vaddr = (void*) ((uintptr_t) buffer->va + offset);
 
-
     if (buffer->role == TX_BUFFER_ID) {
         // Make sure that there is opaque slot available (isfull)
         assert(buffer->txq.buffer_state_used < (buffer->txq.buffer_state_size - 1));
@@ -813,6 +812,8 @@ static void raw_add_buffer(struct net_queue_manager_binding *cc,
         cl->driver_buff_list[cl->chunk_counter].len = length;
         ++cl->chunk_counter;
         if (more == 0) {
+            // ETHERSRV_DEBUG
+//            printf("sending out packet\n");
             err = ether_transmit_pbuf_list_ptr(cl->driver_buff_list, cl->chunk_counter, opaque);
             assert(err_is_ok(err));
             cl->chunk_counter = 0;
@@ -847,6 +848,9 @@ static void raw_add_buffer(struct net_queue_manager_binding *cc,
             assert(length == rx_buffer_size);
             rx_register_buffer_fn_ptr(paddr, vaddr, opaque);
         }
+
+        // FIXME: send a message back acking receiving of message.
+
     } // end else: RX_BUFFER_ID
 } // end function: raw_add_buffer
 
index 9524f5b..a0eb869 100644 (file)
@@ -139,9 +139,14 @@ static err_t portmap_lookup(struct nfs_client *client, u_int prog, u_int vers)
         .prot = IPPROTO_UDP,
         .port = 0 /* ignored */
     };
-    return rpc_call(&client->rpc_client, PMAP_PORT, PMAP_PROG, PMAP_VERS,
+
+    NFSDEBUGPRINT("portmap_lookup: portmap_lookup calling rpc_call\n");
+    err_t err = rpc_call(&client->rpc_client, PMAP_PORT, PMAP_PROG, PMAP_VERS,
                     PMAPPROC_GETPORT, (xdrproc_t) xdr_mapping, &mount_map,
                     sizeof(mount_map), mount_reply_handler, NULL, NULL);
+    NFSDEBUGPRINT("portmap_lookup: portmap_lookup done with rpc_call returned %d \n",
+            err);
+    return  err;
 }
 
 /** \brief Initiate an NFS mount operation
@@ -164,18 +169,22 @@ struct nfs_client *nfs_mount(struct ip_addr server, const char *path,
     if (client == NULL) {
         return NULL;
     }
+    NFSDEBUGPRINT("nfs_mount: calling rpc_init\n");
     err_t r = rpc_init(&client->rpc_client, server);
     if (r != ERR_OK) {
         free(client);
         return NULL;
     }
 
+    NFSDEBUGPRINT("nfs_mount: rpc_init done\n");
     client->mount_path = path;
     client->mount_state = NFS_INIT_GETPORT_MOUNT;
     client->mount_callback = callback;
     client->mount_cbarg = cbarg;
 
+    NFSDEBUGPRINT("nfs_mount: calling portmap_lookup\n");
     r = portmap_lookup(client, MOUNT_PROGRAM, MOUNT_V3);
+    NFSDEBUGPRINT("nfs_mount: portmap_lookup done \n");
     if (r != ERR_OK) {
         nfs_destroy(client);
         return NULL;
index d091501..f9ffeb1 100644 (file)
@@ -15,6 +15,8 @@
  * Debug printer:
  *****************************************************************/
 
+//#define NFS_CLIENT_DEBUG 1
+
 #if defined(NFS_CLIENT_DEBUG) || defined(GLOBAL_DEBUG)
 #define NFSDEBUGPRINT(arg...) printf("nfs: " arg)
 #else
index 04c7ee0..527e90c 100644 (file)
@@ -403,7 +403,7 @@ err_t rpc_call(struct rpc_client *client, uint16_t port, uint32_t prog,
     err_t r;
     bool rb;
     uint32_t xid;
-
+    RPC_DEBUGP("rpc_call: started, trying to get a lock\n");
     if (lwip_mutex != NULL) {
         if(thread_mutex_trylock(lwip_mutex)) {
            printf("rpc_call: thread_mutex_trylock failed\n");
@@ -411,6 +411,7 @@ err_t rpc_call(struct rpc_client *client, uint16_t port, uint32_t prog,
         }
     }
 
+    RPC_DEBUGP("rpc_call:  calling xdr_pbuf_create_send\n");
     rb = xdr_pbuf_create_send(&xdr, args_size + RPC_CALL_HEADER_LEN);
     if (!rb) {
         return ERR_MEM;
@@ -418,11 +419,13 @@ err_t rpc_call(struct rpc_client *client, uint16_t port, uint32_t prog,
 
     xid = client->nextxid++;
 
+    RPC_DEBUGP("rpc_call: calling rpc_call_init\n");
     r = rpc_call_init(&xdr, xid, prog, vers, proc);
     if (r != ERR_OK) {
         XDR_DESTROY(&xdr);
         return r;
     }
+    RPC_DEBUGP("rpc_call: rpc_call_init done\n");
 
     rb = args_xdrproc(&xdr, args);
     if (!rb) {
@@ -450,6 +453,7 @@ err_t rpc_call(struct rpc_client *client, uint16_t port, uint32_t prog,
         call->pbuf->tot_len -= ((struct pbuf *)xdr.x_base)->len - xdr.x_handy;
         ((struct pbuf *)xdr.x_base)->len = xdr.x_handy;
     }
+    RPC_DEBUGP("rpc_call: calling UPD_connect\n");
     r = udp_connect(client->pcb, &client->server, port);
     if (r != ERR_OK) {
         XDR_DESTROY(&xdr);
@@ -462,6 +466,7 @@ err_t rpc_call(struct rpc_client *client, uint16_t port, uint32_t prog,
     call->next = client->call_hash[hid];
     client->call_hash[hid] = call;
 
+    RPC_DEBUGP("rpc_call: calling UPD_send\n");
     r = udp_send(client->pcb, call->pbuf);
     if (r != ERR_OK) {
         /* dequeue */
@@ -472,6 +477,7 @@ err_t rpc_call(struct rpc_client *client, uint16_t port, uint32_t prog,
         free(call);
     }
 
+    RPC_DEBUGP("rpc_call: rpc_call done\n");
     lwip_record_event_simple(RPC_CALL_T, ts);
     return r;
 }
index 5295a6d..95de183 100644 (file)
@@ -19,7 +19,7 @@
  * Example:
  *
  * The subystem:
- * 
+ *
  * subsystem mysubsystem {
  *             event myevent "",
  * }
@@ -71,7 +71,9 @@ subsystem threads {
     event SEM_WAIT_ENTER                       "",
     event SEM_WAIT_LEAVE                       "",
     event SEM_TRYWAIT                          "",
-    event SEM_POST                                     "",
+    event SEM_POST                              "",
+    event SYS_YIELD                             "Calling sys_yield for co-op scheduling",
+    event C_DISP_SAVE                           "calling disp_save",
 };
 
 subsystem memserv {
@@ -298,6 +300,32 @@ subsystem nnet {
 
 };
 
+
+subsystem llnet {
+/* Constant for low-level networking trace */
+ event START             "",
+ event STOP              "",
+ event IRQ              "",
+ event LMPDISP          "",
+
+ event DRVIRQ           "",
+ event DRVRX            "",
+ event DRVTXADD         "",
+ event DRVTXDONE        "",
+
+ event LWIPPBA1         "",
+ event LWIPPBA2         "",
+ event LWIPPBF1         "",
+ event LWIPPBF2         "",
+ event LWIPRX           "",
+ event LWIPTX           "",
+
+ event APPRX            "",
+ event APPTX            "",
+
+};
+
+
 /* The example subsystem is used to demonstrate how the tracing framework
  * works. It is used by the program in "examples/xmpl-trace". */
 subsystem xmpl {
index 156b0df..18db9df 100644 (file)
@@ -293,7 +293,7 @@ void benchmark_rx_done(size_t idx, size_t pkt_len)
 
 #if TRACE_ONLY_LLNET
             trace_event(TRACE_SUBSYS_LLNET, TRACE_EVENT_LLNET_STOP, 0);
-            size_t trsz = trace_dump(trbuf, sizeof(trbuf) - 1);
+            size_t trsz = trace_dump(trbuf, sizeof(trbuf) - 1, NULL);
             trbuf[trsz] = 0;
             printf("\n\n\n\nTrace results:\n%s\n\n\n", trbuf);
 #endif // TRACE_ONLY_LLNET
index ac7b136..66abc26 100644 (file)
@@ -233,7 +233,7 @@ void handle_data_arrived(char *payload, size_t data_len)
 
 #if TRACE_ONLY_LLNET
             trace_event(TRACE_SUBSYS_LLNET, TRACE_EVENT_LLNET_STOP, 0);
-            size_t trsz = trace_dump(trbuf, sizeof(trbuf) - 1);
+            size_t trsz = trace_dump(trbuf, sizeof(trbuf) - 1, NULL);
             trbuf[trsz] = 0;
             printf("\n\n\n\nTrace results:\n%s\n\n\n", trbuf);
 #endif // TRACE_ONLY_LLNET
index 266370a..fe50247 100644 (file)
@@ -307,7 +307,7 @@ static bool handle_free_TX_slot_fn(void)
     /* Actual place where packet is sent.  Adding trace_event here */
 #if TRACE_ETHERSRV_MODE
     trace_event(TRACE_SUBSYS_NET, TRACE_EVENT_NET_NO_S,
-                (uint32_t)client_data);
+                (uint32_t)ether_transmit_index);
 #endif
 
     return 0;
@@ -334,7 +334,7 @@ static errval_t transmit_pbuf_list_fn(struct driver_buffer *buffers,
     }
 
     if (count > 1) {
-        printf("Sending %zx chunks\n", count);
+        E1000_DEBUG("Sending %zx chunks\n", count);
     }
     for (int i = 0; i < count; i++) {
         errval_t r = transmit_pbuf(buffers[i].pa, buffers[i].len,
index e9b3d1b..a642632 100755 (executable)
@@ -217,6 +217,7 @@ static uint64_t refresh_cache(uint32_t dst_ip_addr)
     struct waitset *ws = NULL;
     ws = get_default_waitset();
    while (is_ip_present_in_arp_cache(&dst_ip) == false) {
+//        NETD_DEBUG("refresh_arp_cache: event dispatched\n");
         r = event_dispatch(ws);
         if (err_is_fail(r)) {
             DEBUG_ERR(r, "in event_dispatch");
@@ -235,6 +236,9 @@ static void ARP_resolve_request(struct net_ARP_binding *cc,
     uint64_t found_mac = refresh_cache(ip);
     assert(found_mac != 0);
 //    assert(!"NYI ARP resolve request");
+    NETD_DEBUG("ARP_resolve_request: MAC found for ARP request ip %"
+            PRIu32" over iface %"PRIu32" == %"PRIu64"\n",
+            ip, iface, found_mac);
     wrapper_ARP_lookup_response(cc, SYS_ERR_OK, found_mac);
 } // end function: ARP_resolve_request
 
index 25d8fae..3ecc300 100644 (file)
@@ -613,7 +613,8 @@ err_t http_cache_init(struct ip_addr server, const char *path,
     struct timer *cache_timer;      /* timer for triggering cache timeouts */
     init_callback = callback;
 
-    /* FIXME: Start the trace */
+
+    // FIXME: Start the trace
 #if ENABLE_WEB_TRACING
     printf("Starting tracing\n");
 
@@ -629,12 +630,28 @@ err_t http_cache_init(struct ip_addr server, const char *path,
     printf("Tracing not enabled\n");
 #endif // ENABLE_WEB_TRACING
 
+    DEBUGPRINT ("nfs_mount calling.\n");
     my_nfs_client = nfs_mount(server, path, mount_callback, NULL);
+    DEBUGPRINT ("nfs_mount calling done.\n");
+
+    /* FIXME: stop the trace. */
+#if ENABLE_WEB_TRACING
+    trace_event(TRACE_SUBSYS_NET, TRACE_EVENT_NET_STOP, 0);
+
+    char *buf = malloc(4096*4096);
+    trace_dump(buf, 4096*4096, NULL);
+    printf("%s\n", buf);
+    printf("exiting the webserver for debugging purposes\n");
+    USER_PANIC("aborting execution for debugging purposes\n");
+
+#endif // ENABLE_WEB_TRACING
+
     assert(my_nfs_client != NULL);
     /* creating the empty cache */
     cache_table = NULL;
     create_404_page_cache();
 
+
     cache_timer = timer_create(MAX_STALENESS, true, cache_timeout_event,
             cache_table);
     assert (cache_timer != NULL);
index 7374dc1..635aaf4 100644 (file)
@@ -70,7 +70,7 @@ int main(int argc, char**argv)
     while (1) {
         // check for any event without blocking
         //err = event_dispatch_non_block(ws);
-        err = event_dispatch(ws);
+        err = event_dispatch_non_block(ws);
         if (err != LIB_ERR_NO_EVENT) {
             if (err_is_fail(err)) {
                 DEBUG_ERR(err, "in event_dispatch");
@@ -78,6 +78,8 @@ int main(int argc, char**argv)
             }
         }
 
+//        printf("webserver:%u:  dispatching next event\n", disp_get_core_id());
+
         // Check if lwip has any pending work to finish
         wrapper_perform_lwip_work();
         err = event_dispatch(ws);