Palacios Public Git Repository

To checkout Palacios execute

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.


Minimize the copies for vnet and Virtio bridge
[palacios.git] / palacios / src / palacios / vmm_vnet.c
index dca5b7b..38a9087 100644 (file)
@@ -47,7 +47,7 @@ struct vnet_dev {
     uint8_t mac_addr[6];
     struct v3_vm_info * vm;
     
-    int (*input)(struct v3_vm_info * vm, struct v3_vnet_pkt * pkt,  void * private_data);
+    int (*input)(struct v3_vm_info * vm, struct v3_vnet_pkt * pkt, void * private_data);
     void * private_data;
     
     int dev_id;
@@ -55,6 +55,14 @@ struct vnet_dev {
 } __attribute__((packed));
 
 
+struct vnet_brg_dev {
+    struct v3_vm_info * vm;
+    
+    int (*input)(struct v3_vm_info * vm, struct v3_vnet_pkt * pkt, void * private_data);
+    void * private_data;
+} __attribute__((packed));
+
+
 
 
 
@@ -83,10 +91,12 @@ struct route_list {
 static struct {
     struct list_head routes;
     struct list_head devs;
-
+    
     int num_routes;
     int num_devs;
 
+    struct vnet_brg_dev *bridge;
+
     v3_lock_t lock;
 
     struct gen_queue * inpkt_q;
@@ -98,17 +108,47 @@ static struct {
 
 
 #ifdef CONFIG_DEBUG_VNET
+static inline void mac_to_string(char mac[6], char * buf) {
+    snprintf(buf, 50, "%x:%x:%x:%x:%x:%x", 
+            mac[0], mac[1], mac[2],
+            mac[3], mac[4], mac[5]);
+}
 
-static void print_packet(struct v3_vnet_pkt * pkt) {
-    PrintDebug("Vnet: data_packet: size: %d\n", pkt->size);
-    v3_hexdump(pkt->data, pkt->size, NULL, 0);
+static void print_route(struct vnet_route_info *route){
+    char str[50];
+
+    mac_to_string(route->route_def.src_mac, str);
+    PrintDebug("Src Mac (%s),  src_qual (%d)\n", 
+                       str, route->route_def.src_mac_qual);
+    mac_to_string(route->route_def.dst_mac, str);
+    PrintDebug("Dst Mac (%s),  dst_qual (%d)\n", 
+                       str, route->route_def.dst_mac_qual);
+    PrintDebug("Src dev id (%d), src type (%d)", 
+                       route->route_def.src_id, 
+                       route->route_def.src_type);
+    PrintDebug("Dst dev id (%d), dst type (%d)\n", 
+                       route->route_def.dst_id, 
+                       route->route_def.dst_type);
+    if (route->route_def.dst_type == LINK_INTERFACE) {
+       PrintDebug("dst_dev (%p), dst_dev_id (%d), dst_dev_input (%p), dst_dev_data (%p)\n",
+                                       route->dst_dev,
+                                       route->dst_dev->dev_id,
+                                       route->dst_dev->input,
+                                       route->dst_dev->private_data);
+    }
 }
 
+static void dump_routes(){
+       struct vnet_route_info *route;
 
-static inline void mac_to_string(char mac[6], char * buf) {
-    snprintf(buf, 20, "%02x:%02x:%02x:%02x:%02x:%02x", 
-            mac[0], mac[1], mac[2],
-            mac[3], mac[4], mac[5]);
+       int i = 0;
+       PrintDebug("\n========Dump routes starts ============\n");
+       list_for_each_entry(route, &(vnet_state.routes), node) {
+               PrintDebug("\nroute %d:\n", ++i);
+               
+               print_route(route);
+       }
+       PrintDebug("\n========Dump routes end ============\n");
 }
 
 #endif
@@ -119,17 +159,17 @@ static inline void mac_to_string(char mac[6], char * buf) {
  * This means we can generate the hash from an offset into the pkt struct
  */
 static inline uint_t hash_fn(addr_t hdr_ptr) {    
-    uint8_t * hdr_buf = (uint8_t *)&(hdr_ptr);
-    
+    uint8_t * hdr_buf = (uint8_t *)hdr_ptr;
+
     return v3_hash_buffer(hdr_buf, VNET_HASH_SIZE);
 }
 
-static inline int hash_eq(addr_t key1, addr_t key2) {
+static inline int hash_eq(addr_t key1, addr_t key2) {  
     return (memcmp((uint8_t *)key1, (uint8_t *)key2, VNET_HASH_SIZE) == 0);
 }
 
 
-static int add_route_to_cache(struct v3_vnet_pkt * pkt, struct route_list * routes) {
+static int add_route_to_cache(const struct v3_vnet_pkt * pkt, struct route_list * routes) {
     memcpy(routes->hash_buf, pkt->hash_buf, VNET_HASH_SIZE);    
 
     if (v3_htable_insert(vnet_state.route_cache, (addr_t)routes->hash_buf, (addr_t)routes) == 0) {
@@ -142,37 +182,53 @@ static int add_route_to_cache(struct v3_vnet_pkt * pkt, struct route_list * rout
 
 static int clear_hash_cache() {
 
-    /* USE the hash table iterators. 
-     * See v3_swap_flush(struct v3_vm_info * vm) in vmm_shdw_pg_swapbypass.c
-     */
+    v3_free_htable(vnet_state.route_cache, 1, 1);
+    vnet_state.route_cache = v3_create_htable(0, &hash_fn, &hash_eq);
 
-    // MAKE SURE YOU DELETE the route_list entries
-    struct hashtable_iter * ht_iter = v3_create_htable_iter(vnet_state.route_cache);
+    return 0;
+}
 
-    if (!ht_iter) {
-       PrintError("NULL iterator in vnet cache!\n");
-    }
+static int look_into_cache(const struct v3_vnet_pkt * pkt, struct route_list ** routes) {
+    
+    *routes = (struct route_list *)v3_htable_search(vnet_state.route_cache, (addr_t)(pkt->hash_buf));
+   
+    return 0;
+}
 
-    while (ht_iter->entry) {
-       struct route_list * route_list_ptr = (struct route_list *)v3_htable_get_iter_value(ht_iter);
-       V3_Free(route_list_ptr);
-       v3_htable_iter_advance(ht_iter);
-    }
 
-    V3_Free(ht_iter);
+static struct vnet_dev * find_dev_by_id(int idx) {
+    struct vnet_dev * dev = NULL; 
+    
+    list_for_each_entry(dev, &(vnet_state.devs), node) {
+       int dev_id = dev->dev_id;
 
-    //v3_free_htable(vnet_state.route_cache, 0, 1);
+       if (dev_id == idx)
+           return dev;
+    }
 
-    return 0;
+    return NULL;
 }
 
-static int look_into_cache(struct v3_vnet_pkt * pkt, struct route_list ** routes) {
+static struct vnet_dev * find_dev_by_mac(char mac[6]) {
+    struct vnet_dev * dev = NULL; 
     
-    *routes = (struct route_list *)v3_htable_search(vnet_state.route_cache, (addr_t)pkt);
-   
-    return 0;
+    list_for_each_entry(dev, &(vnet_state.devs), node) {
+       if (!memcmp(dev->mac_addr, mac, 6))
+           return dev;
+    }
+
+    return NULL;
 }
 
+int get_device_id_by_mac(char mac[6]){
+
+    struct vnet_dev *dev = find_dev_by_mac(mac);
+
+    if (dev == NULL)
+       return -1;
+
+    return dev->dev_id;
+}
 
 
 int v3_vnet_add_route(struct v3_vnet_route route) {
@@ -182,24 +238,39 @@ int v3_vnet_add_route(struct v3_vnet_route route) {
     new_route = (struct vnet_route_info *)V3_Malloc(sizeof(struct vnet_route_info));
     memset(new_route, 0, sizeof(struct vnet_route_info));
 
-    PrintDebug("Vnet: vnet_add_route_entry\n");        
+    PrintDebug("Vnet: vnet_add_route_entry: dst_id: %d, dst_type: %d\n",
+                       route.dst_id, route.dst_type);  
     
-    new_route->route_def = route;
+    memcpy(new_route->route_def.src_mac, route.src_mac, 6);
+    memcpy(new_route->route_def.dst_mac, route.dst_mac, 6);
+    new_route->route_def.src_mac_qual = route.src_mac_qual;
+    new_route->route_def.dst_mac_qual = route.dst_mac_qual;
+    new_route->route_def.dst_id = route.dst_id;
+    new_route->route_def.dst_type = route.dst_type;
+    new_route->route_def.src_id = route.src_id;
+    new_route->route_def.src_type = route.src_type;
 
-    /* TODO: Find devices */
     if (new_route->route_def.dst_type == LINK_INTERFACE) {
-       //new_route->dst_dev = FIND_DEV();
+       new_route->dst_dev = find_dev_by_id(new_route->route_def.dst_id);
+       PrintDebug("Vnet: Add route, get device: dev_id %d, input : %p, private_data %p\n",
+                       new_route->dst_dev->dev_id, new_route->dst_dev->input, new_route->dst_dev->private_data);
     }
 
     if (new_route->route_def.src_type == LINK_INTERFACE) {
-       // new_route->src_dev = FIND_DEV()
+       new_route->src_dev = find_dev_by_id(new_route->route_def.src_id);
     }
 
     flags = v3_lock_irqsave(vnet_state.lock);
+
     list_add(&(new_route->node), &(vnet_state.routes));
+    clear_hash_cache();
+
     v3_unlock_irqrestore(vnet_state.lock, flags);
    
-    clear_hash_cache();
+
+#ifdef CONFIG_DEBUG_VNET
+    dump_routes();
+#endif
 
     return 0;
 }
@@ -208,7 +279,7 @@ int v3_vnet_add_route(struct v3_vnet_route route) {
 
 // At the end allocate a route_list
 // This list will be inserted into the cache so we don't need to free it
-static struct route_list * match_route(struct v3_vnet_pkt * pkt) {
+static struct route_list * match_route(const struct v3_vnet_pkt * pkt) {
     struct vnet_route_info * route = NULL; 
     struct route_list * matches = NULL;
     int num_matches = 0;
@@ -220,8 +291,8 @@ static struct route_list * match_route(struct v3_vnet_pkt * pkt) {
 
 #ifdef CONFIG_DEBUG_VNET
     {
-       char dst_str[18];
-       char src_str[18];
+       char dst_str[50];
+       char src_str[50];
 
        mac_to_string(hdr->src_mac, src_str);  
        mac_to_string(hdr->dst_mac, dst_str);
@@ -305,7 +376,7 @@ static struct route_list * match_route(struct v3_vnet_pkt * pkt) {
        }
        
        // Default route
-       if ( (memcmp(route_def->src_mac, hdr->src_mac, 6) == 0) &
+       if ( (memcmp(route_def->src_mac, hdr->src_mac, 6) == 0) &&
             (route_def->dst_mac_qual == MAC_NONE)) {
            UPDATE_MATCHES(4);
        }
@@ -324,7 +395,7 @@ static struct route_list * match_route(struct v3_vnet_pkt * pkt) {
 
     {
        int i = 0;
-       list_for_each_entry(route, &match_list, node) {
+       list_for_each_entry(route, &match_list, match_node) {
            matches->routes[i++] = route;
        }
     }
@@ -332,16 +403,17 @@ static struct route_list * match_route(struct v3_vnet_pkt * pkt) {
     return matches;
 }
 
-static int handle_one_pkt(struct v3_vnet_pkt * pkt) {
+
+int v3_vnet_send_pkt(struct v3_vnet_pkt * pkt, void * private_data) {
     struct route_list * matched_routes = NULL;
+    unsigned long flags;
     int i;
 
-
 #ifdef CONFIG_DEBUG_VNET
    {
-       struct eth_hdr * hdr = (struct eth_hdr *)(pkt->data);
-       char dest_str[18];
-       char src_str[18];
+       struct eth_hdr * hdr = (struct eth_hdr *)(pkt->header);
+       char dest_str[30];
+       char src_str[30];
 
        mac_to_string(hdr->src_mac, src_str);  
        mac_to_string(hdr->dst_mac, dest_str);
@@ -349,24 +421,45 @@ static int handle_one_pkt(struct v3_vnet_pkt * pkt) {
    }
 #endif
 
+    flags = v3_lock_irqsave(vnet_state.lock);
+
     look_into_cache(pkt, &matched_routes);
-    
+       
     if (matched_routes == NULL) {  
-        matched_routes = match_route(pkt);     
-
-      if (matched_routes) {
-           add_route_to_cache(pkt, matched_routes);      
+       PrintDebug("Vnet: send pkt Looking into routing table\n");
+       
+       matched_routes = match_route(pkt);
+               
+       if (matched_routes) {
+           add_route_to_cache(pkt, matched_routes);
        } else {
-           PrintError("Could not find route for packet...\n");
+           PrintDebug("Could not find route for packet... discards packet\n");
+           v3_unlock_irqrestore(vnet_state.lock, flags);
            return -1;
        }
     }
-    
-    
-    for (i = 0; i < matched_routes->num_routes; i++) {
-       struct vnet_route_info * route = matched_routes->routes[i];
 
+    v3_unlock_irqrestore(vnet_state.lock, flags);
+
+
+    PrintDebug("Vnet: send pkt route matches %d\n", matched_routes->num_routes);
+
+    for (i = 0; i < matched_routes->num_routes; i++) {
+        struct vnet_route_info * route = matched_routes->routes[i];
+       
         if (route->route_def.dst_type == LINK_EDGE) {
+            pkt->dst_type = LINK_EDGE;
+            pkt->dst_id = route->route_def.dst_id;
+
+            if (vnet_state.bridge == NULL) {
+                PrintDebug("VNET: No bridge to sent data to links\n");
+                continue;
+            }
+
+            if (vnet_state.bridge->input(vnet_state.bridge->vm, pkt, vnet_state.bridge->private_data) == -1) {
+                PrintDebug("VNET: Packet not sent properly\n");
+                continue;
+           } 
 
         } else if (route->route_def.dst_type == LINK_INTERFACE) {
             if (route->dst_dev->input(route->dst_dev->vm, pkt, route->dst_dev->private_data) == -1) {
@@ -378,120 +471,110 @@ static int handle_one_pkt(struct v3_vnet_pkt * pkt) {
             continue;
         }
 
-        PrintDebug("Vnet: HandleDataOverLink: Forward packet according to Route\n");
+        PrintDebug("Vnet: HandleOnePacket: Forward packet according to Route\n");
     }
     
     return 0;
 }
 
-int v3_vnet_send_pkt(struct v3_vnet_pkt * pkt) {
-    // find the destination and call the send packet function, passing pkt *
+int v3_vnet_add_dev(struct v3_vm_info *vm, uint8_t mac[6], 
+                   int (*netif_input)(struct v3_vm_info * vm, struct v3_vnet_pkt * pkt, void * private_data), 
+                   void * priv_data){
+    struct vnet_dev * new_dev = NULL;
+    unsigned long flags;
+
+    new_dev = (struct vnet_dev *)V3_Malloc(sizeof(struct vnet_dev)); 
 
-    if (handle_one_pkt(pkt) != -1) {
-        PrintDebug("VNET: send one packet! pt length %d\n", pkt->size);  
-    } else {
-        PrintDebug("VNET: Fail to forward one packet, discard it!\n"); 
+    if (new_dev == NULL) {
+       PrintError("VNET: Malloc fails\n");
+       return -1;
     }
+   
+    memcpy(new_dev->mac_addr, mac, 6);
+    new_dev->input = netif_input;
+    new_dev->private_data = priv_data;
+    new_dev->vm = vm;
+    new_dev->dev_id = 0;       
 
-#ifdef CONFIG_DEBUG_VNET
-    print_packet(pkt);
-#endif
+    flags = v3_lock_irqsave(vnet_state.lock);
 
-    return 0;
-}
+    if (!find_dev_by_mac(mac)) {
+       list_add(&(new_dev->node), &(vnet_state.devs));
+       new_dev->dev_id = ++vnet_state.num_devs;
+    }
 
-struct vnet_dev * find_dev_by_id(int idx) {
-    struct vnet_dev * dev = NULL; 
-    
-    list_for_each_entry(dev, &(vnet_state.devs), node) {
-       int dev_id = dev->dev_id;
+    v3_unlock_irqrestore(vnet_state.lock, flags);
 
-       if (dev_id == idx)
-           return dev;
+    // if the device was found previosly the id should still be 0
+    if (new_dev->dev_id == 0) {
+       PrintError("Device Alrady exists\n");
+       return -1;
     }
 
-    return NULL;
+    PrintDebug("Vnet: Add Device: dev_id %d, input : %p, private_data %p\n",
+                       new_dev->dev_id, new_dev->input, new_dev->private_data);
+
+    return new_dev->dev_id;
 }
 
-static struct vnet_dev * find_dev_by_mac(char * name) {
-    struct vnet_dev * dev = NULL; 
-    
-    list_for_each_entry(dev, &(vnet_state.devs), node) {
-       if (!memcmp(dev->mac_addr, name, 6))
-           return dev;
-    }
 
-    return NULL;
-}
+int v3_vnet_add_bridge(struct v3_vm_info * vm,
+                      int (*input)(struct v3_vm_info * vm, struct v3_vnet_pkt * pkt, void * private_data), 
+                      void * priv_data) {
+    unsigned long flags;
+    int bridge_free = 0;
+    struct vnet_brg_dev * tmp_bridge = NULL;
+    
+    
+    flags = v3_lock_irqsave(vnet_state.lock);
 
-int v3_vnet_add_dev(struct v3_vm_info *vm,uint8_t mac[6], 
-                   int (*netif_input)(struct v3_vm_info * vm, struct v3_vnet_pkt * pkt, void * private_data), 
-                   void * priv_data){
-    struct vnet_dev * new_dev = NULL;
+    if (vnet_state.bridge == NULL) {
+       bridge_free = 1;
+       vnet_state.bridge = (void *)1;
+    }
 
-    new_dev = find_dev_by_mac(mac);
+    v3_unlock_irqrestore(vnet_state.lock, flags);
 
-    if (new_dev) {
-       PrintDebug("VNET: register device: Already has device with the same mac\n");
+    if (bridge_free == 0) {
+       PrintError("Bridge already set\n");
        return -1;
     }
-    
-    new_dev = (struct vnet_dev *)V3_Malloc(sizeof(struct vnet_dev)); 
 
-    if (new_dev == NULL) {
-       PrintError("VNET: Malloc fails\n");
+    tmp_bridge = (struct vnet_brg_dev *)V3_Malloc(sizeof(struct vnet_brg_dev));
+
+    if (tmp_bridge == NULL) {
+       PrintError("Malloc Fails\n");
        return -1;
     }
     
-    memcpy(new_dev->mac_addr, mac, 6);
-    new_dev->input = netif_input;
-    new_dev->private_data = priv_data;
-    new_dev->vm = vm;
-
-    // ADD TO dev list
-    // increment dev count
-    
-    list_add(&(new_dev->node), &(vnet_state.devs));
-    vnet_state.num_devs ++;
-    new_dev->dev_id = vnet_state.num_devs;
-
-    return 0;
-}
+    tmp_bridge->vm = vm;
+    tmp_bridge->input = input;
+    tmp_bridge->private_data = priv_data;
 
-int v3_vnet_pkt_process() {
-    struct v3_vnet_pkt * pkt = NULL;
+    // make this atomic to avoid possible race conditions
+    flags = v3_lock_irqsave(vnet_state.lock);
+    vnet_state.bridge = tmp_bridge;
+    v3_unlock_irqrestore(vnet_state.lock, flags);
 
-    while ((pkt = (struct v3_vnet_pkt *)v3_dequeue(vnet_state.inpkt_q)) != NULL) {
-        if (handle_one_pkt(pkt) != -1) {
-            PrintDebug("VNET: vnet_check: handle one packet! pt length %d\n", (int)pkt->size);  
-        } else {
-            PrintDebug("VNET: vnet_check: Fail to forward one packet, discard it!\n"); 
-        }
-       
-        V3_Free(pkt); // be careful here
-    }
-    
     return 0;
 }
 
-
 int V3_init_vnet() {
-
-    PrintDebug("VNET: Links table initiated\n");
-
+       
     INIT_LIST_HEAD(&(vnet_state.routes));
     INIT_LIST_HEAD(&(vnet_state.devs));
 
     vnet_state.num_devs = 0;
     vnet_state.num_routes = 0;
 
+    PrintDebug("VNET: Links and Routes tables initiated\n");
+
     if (v3_lock_init(&(vnet_state.lock)) == -1){
         PrintError("VNET: Failure to init lock for routes table\n");
     }
 
-    PrintDebug("VNET: Routes table initiated\n");
+    PrintDebug("VNET: Locks initiated\n");
 
-    /*initial pkt receiving queue */
     vnet_state.inpkt_q = v3_create_queue();
     v3_init_queue(vnet_state.inpkt_q);
     PrintDebug("VNET: Receiving queue initiated\n");
@@ -503,5 +586,7 @@ int V3_init_vnet() {
         return -1;
     }
 
+    PrintDebug("VNET: initiated\n");
+
     return 0;
 }