arp_core.c

Go to the documentation of this file.

/*
 * kernel_net/layer_2/arp/arp_core.c
 *
 * Copyright (c) 2003-2005 Lukasz Dembinski <dembol@nasa.com.pl>
 * All Rights Reserved
 * 
 * Date:        2005/06
 * Author:      Lukasz Dembinski
 * Info:        arp_core.c core file
 * Contact:     mailto: <dembol@nasa.com.pl>
 *
 */

#include <agnix/agnix.h>
#include <agnix/adi/adi.h>
#include <agnix/net/net.h>
#include <agnix/memory.h>
#include <agnix/console.h>
#include <agnix/resources.h>
#include <agnix/timers.h>
#include <agnix/counters.h>
#include <agnix/list.h>
#include <agnix/wait.h>
#include <agnix/sched.h>
#include <agnix/spinlock.h>
#include <agnix/data_structures.h>

#define MOD_NAME        "ARP: "

struct arp_entry_s arp_entries[ARP_MAX_ENTRIES];
u32 arp_bitmap[ARP_BITMAP_LEN];

struct list_head arp_entries_list;
struct list_head arp_requests_list;
spinlock_t arp_entries_list_lock;
spinlock_t arp_requests_list_lock;

int arp_hash_desc;
int arp_resource_desc;
int arp_cache;

void arp_timer_expire(void *data);
int arp_del_entry_lock(struct arp_entry_s *entry);

struct resource_s arp_resource = {
    .resource_name      = "arp",
    .resource_bitmap    = arp_bitmap,
    .resource_len       = ARP_BITMAP_LEN
};

struct timer_s arp_timer = {
    .timer_function     = arp_timer_expire,
    .timer_data         = NULL,
    .timer_expire       = 0,
    .timer_flags        = TIMER_FLAG_ONESHOT,
};

struct arp_stats_s arp_stats;

extern int counter_jiffies_desc;
extern struct list_head adi_netdev_list;
extern spinlock_t adi_netdev_list_lock;

int arp_reply(struct adi_netdev_s *netdev, struct arp_neigh_s *neigh_src, struct arp_neigh_s *neigh_dest,
              u8 *mac_dest);

int get_free_arp_entry(void)
{
    return get_free_resource(arp_resource_desc);
}

int put_free_arp_entry(int arp_entry_desc)
{
    return put_free_resource(arp_resource_desc, arp_entry_desc);
}

int arp_request_add_lock(struct arp_request_s *arp_request)
{
    list_add_tail(&(arp_request->list), &arp_requests_list);
    return 0;
}

int arp_request_add(struct arp_request_s *arp_request)
{
    u32 flags;

    spin_lock_irqsave(&arp_requests_list_lock, flags);
    arp_request_add_lock(arp_request);
    spin_unlock_irqrestore(&arp_requests_list_lock, flags);
    
    return 0;
}

int arp_request_del_lock(struct arp_request_s *arp_request)
{
    list_del(&(arp_request->list));
    return 0;
}

int arp_request_del(struct arp_request_s *arp_request)
{
    u32 flags;

    spin_lock_irqsave(&arp_requests_list_lock, flags);
    arp_request_del_lock(arp_request);
    spin_unlock_irqrestore(&arp_requests_list_lock, flags);
    
    return 0;
}

int arp_request_wake_up(struct arp_neigh_s *neigh)
{
    struct arp_request_s *arp_request;
    struct list_head *tmp;
    u32 flags;

    spin_lock_irqsave(&arp_requests_list_lock, flags);        

    if (list_empty(&arp_requests_list)) {
        spin_unlock_irqrestore(&arp_requests_list_lock, flags);    
        return 0;
    }
    
    list_for_each(tmp, &arp_requests_list) {
        arp_request = list_entry(tmp, struct arp_request_s, list);

        if (!memcmp(arp_request->neigh->addr.address, neigh->addr.address, neigh->addr.address_len)) {
            sched_activate_task(arp_request->task);
        }
    }

    spin_unlock_irqrestore(&arp_requests_list_lock, flags);    
    
    return 0;
}

int arp_timer_refresh_lock(void)
{
    struct arp_entry_s *arp_entry;

    if (arp_timer.timer_expire != 0) {
        arp_timer.timer_expire = 0;
        unregister_timer(&arp_timer);
    }
    
    if (list_empty(&arp_entries_list))
        return 1;

    arp_entry = list_entry(arp_entries_list.prev, struct arp_entry_s, list);    

    arp_timer.timer_flags  = TIMER_FLAG_ONESHOT;
    arp_timer.timer_expire = ARP_EXPIRE;
    arp_timer.timer_data   = (void *)arp_entry;
    register_timer(&arp_timer);

    return 0;
}

int arp_timer_refresh(void)
{
    int ret;
    u32 flags;

    spin_lock_irqsave(&arp_entries_list_lock, flags);        
    ret = arp_timer_refresh_lock();
    spin_unlock_irqrestore(&arp_entries_list_lock, flags);    
    
    return ret;
}

void arp_timer_expire(void *data)
{
    struct arp_entry_s *arp_entry;
    struct arp_entry_s *arp_entry_list;
    struct list_head *tmp, *n;
    u32 flags;

    spin_lock_irqsave(&arp_entries_list_lock, flags);    

    arp_entry = (struct arp_entry_s *)data;
    list_for_each_safe(tmp, n, &arp_entries_list) {
        arp_entry_list = list_entry(tmp, struct arp_entry_s, list);        
        if (arp_entry_list->timer == arp_entry->timer) {
            arp_del_entry_lock(arp_entry_list);
        }
    }
    arp_timer_refresh_lock();

    spin_unlock_irqrestore(&arp_entries_list_lock, flags);    
}

void arp_cache_set(int on)
{
    arp_cache = on;
}

struct arp_entry_s *arp_get_entry_lock(struct net_addr_s *addr)
{
    struct arp_entry_s *arp_entry;
    u32 ptr;

    arp_entry = NULL;
    if ((ptr = hash_entry_find(arp_hash_desc, *(u32 *)addr->address))) {
        arp_entry = (struct arp_entry_s *)ptr;
    }
    
    return arp_entry;
}

int arp_get_local_mac(struct arp_neigh_s *neigh)
{
    struct list_head *tmp;
    struct adi_netdev_s *netdev;
    int found;
    u32 flags;
    
    spin_lock_irqsave(&adi_netdev_list_lock, flags);
    
    found = 0;
    list_for_each(tmp, &adi_netdev_list) {
        netdev = list_entry(tmp, struct adi_netdev_s, list);

        if (!memcmp(netdev->if_layer_3.if_addr.address, neigh->addr.address, neigh->addr.address_len)) {
            found = 1;
            break;
        }
    }
    
    spin_unlock_irqrestore(&adi_netdev_list_lock, flags);
    
    if (found) {
        memcpy(neigh->mac, netdev->if_layer_2.if_addr, ETH_ALEN);
        return 1;
    }
    
    return 0;
}

int arp_get_neigh_lock(struct arp_neigh_s *neigh)
{
    struct arp_entry_s *arp_entry;

    if ((arp_entry = arp_get_entry_lock(&neigh->addr)) != NULL) {

        memcpy(neigh->mac, arp_entry->neigh->mac, ETH_ALEN);
        return 1;       
    }
    
    return 0;
}

int arp_get_neigh(struct arp_neigh_s *neigh)
{
    int ret;
    u32 flags;
    
    spin_lock_irqsave(&arp_entries_list_lock, flags);
    ret = arp_get_neigh_lock(neigh);    
    spin_unlock_irqrestore(&arp_entries_list_lock, flags);
    
    return ret;
}

struct arp_neigh_s *arp_neigh_clone(struct arp_neigh_s *neigh)
{
    struct arp_neigh_s *neigh_cloned;
    
    /* yes, slab allocator is required, I know */
    neigh_cloned = (struct arp_neigh_s *)get_free_pages(0);
    memcpy(neigh_cloned, neigh, sizeof(struct arp_neigh_s));
    
    return neigh_cloned;
}

int arp_add_neigh_lock(struct arp_neigh_s *neigh)
{
    u32 arp_entry_idx;
    struct arp_entry_s *arp_entry;
    struct arp_neigh_s *neigh_cloned;

    neigh_cloned     = arp_neigh_clone(neigh);
    arp_entry_idx    = get_free_arp_entry();
    arp_entry        = (struct arp_entry_s *)&arp_entries[arp_entry_idx];
    arp_entry->neigh = neigh_cloned;
    arp_entry->idx   = arp_entry_idx;
    hash_entry_add(arp_hash_desc, *(u32 *)neigh->addr.address, (u32)arp_entry);
    arp_entry->timer = ARP_EXPIRE;
    
    list_add_tail(&arp_entry->list, &arp_entries_list);
    arp_timer_refresh_lock();
    
    return 0;
}

int arp_del_entry_lock(struct arp_entry_s *arp_entry)
{
    int ret;

    ret = hash_entry_del(arp_hash_desc, *(u32 *)arp_entry->neigh->addr.address);
    list_del(&arp_entry->list);
    put_free_arp_entry(arp_entry->idx);
    put_free_pages((u32)arp_entry->neigh, 0);
    memset(arp_entry, 0, sizeof(struct arp_entry_s));
    
    return 0;
}

int arp_header_build(struct frb_s *frb, u16 ar_hrd, u16 ar_pro, u8 ar_hln, u8 ar_pln,
                     u16 ar_op, u8 *ar_sha, u8 *ar_sip, u8 *ar_tha, u8 *ar_tip)
{
    struct arp_hdr_s *arphdr = (struct arp_hdr_s *)frb_pop(frb, sizeof(struct arp_hdr_s));

    arphdr->ar_hrd = htons(ar_hrd);
    arphdr->ar_pro = htons(ar_pro);
    arphdr->ar_hln = ar_hln;
    arphdr->ar_pln = ar_pln;
    arphdr->ar_op  = htons(ar_op);
    memcpy(arphdr->ar_sha, ar_sha, ar_hln);
    memcpy(arphdr->ar_sip, ar_sip, ar_pln);
    memcpy(arphdr->ar_tha, ar_tha, ar_hln);
    memcpy(arphdr->ar_tip, ar_tip, ar_pln);
    
    return 0;
}

int arp_header_build_wrapper(struct frb_s *frb, struct adi_netdev_s *netdev,
                             struct arp_neigh_s *neigh_src, struct arp_neigh_s *neigh_dest,
                             u8 ar_op)
{
    return arp_header_build(frb, ARPHRD_ETHER, ETH_P_IP, ETH_ALEN, 
                            neigh_src->addr.address_len, ar_op, 
                            neigh_src->mac,  neigh_src->addr.address,
                            neigh_dest->mac, neigh_dest->addr.address);
}

int arp_entry_refresh_lock(struct arp_entry_s *arp_entry)
{
    u32 timer[2];

    counter_read(counter_jiffies_desc, timer);
    arp_entry->timer = timer[0];

    list_del(&arp_entry->list);
    list_add_tail(&arp_entry->list, &arp_entries_list);

    return 0;
}

int arp_recv_request_lock(struct frb_s *frb, struct arp_neigh_s *neigh)
{
    struct arp_neigh_s neigh_dest;
    struct arp_hdr_s *arp = (struct arp_hdr_s *)frb_data(frb);

    if (arp->ar_hln > ETH_ALEN)
        arp->ar_hln = ETH_ALEN;

    if (arp->ar_pln > NET_ADDR_MAX_LEN)
        arp->ar_pln = NET_ADDR_MAX_LEN;

    if (!arp_get_local_mac(neigh) && (arp_cache && !arp_get_neigh_lock(neigh)))
        return 0;

    memcpy(neigh_dest.mac, arp->ar_sha, arp->ar_hln);
    memcpy(neigh_dest.addr.address, arp->ar_sip, arp->ar_pln);
    neigh_dest.addr.address_len = arp->ar_pln;

    arp_reply(frb->frb_dev, neigh, &neigh_dest, arp->ar_sha);
    
    return 0;    
}

int arp_recv_reply_lock(struct frb_s *frb, struct arp_neigh_s *neigh)
{
    struct arp_entry_s *arp_entry;

    arp_request_wake_up(neigh);

    if ((arp_entry = arp_get_entry_lock(&neigh->addr))) {
        arp_entry_refresh_lock(arp_entry);

        return 1;
    }

    arp_add_neigh_lock(neigh);
    
    return 0;
}

int arp_recv(struct frb_s *frb)
{
    struct arp_hdr_s *arp = (struct arp_hdr_s *)frb_data(frb);
    struct arp_neigh_s neigh;
    int ret = 0;
    u32 flags;

    neigh.addr.address_len = arp->ar_pln;

    spin_lock_irqsave(&arp_entries_list_lock, flags);

    arp_stats.total_recv_arps++;

    if (ntohs(arp->ar_op) == ARPOP_REQUEST) {
        memcpy(neigh.addr.address, arp->ar_tip, arp->ar_pln);
        memcpy(neigh.mac,          arp->ar_tha, arp->ar_hln);
        arp_stats.recv_reply_arps++;
        
        ret = arp_recv_request_lock(frb, &neigh);
    }
    else
    if (ntohs(arp->ar_op) == ARPOP_REPLY) {
        memcpy(neigh.addr.address, arp->ar_sip, arp->ar_pln);
        memcpy(neigh.mac,          arp->ar_sha, arp->ar_hln);
        arp_stats.recv_reply_arps++;

        ret = arp_recv_reply_lock(frb, &neigh);
    }
    
    spin_unlock_irqrestore(&arp_entries_list_lock, flags);
    
    return ret;
}

int arp_send(struct adi_netdev_s *netdev, struct frb_s *frb, u8 *mac_dest)
{
    frb->frb_dev = netdev;
    netdev->if_ops->header_build(frb, mac_dest, netdev->if_layer_2.if_addr, ETH_P_ARP);
    netdev->if_ops->transmit_frame(frb);

    return 0;
}

int arp_request(struct adi_netdev_s *netdev, struct arp_neigh_s *neigh)
{
    struct frb_s frb;
    struct arp_neigh_s neigh_src;

    if (arp_get_neigh(neigh)) {
        return 1;
    }
    
    arp_stats.total_send_arps++;
    arp_stats.send_request_arps++;
    
    memcpy(neigh_src.mac, netdev->if_layer_2.if_addr, ETH_ALEN);
    memcpy(neigh_src.addr.address, netdev->if_layer_3.if_addr.address, netdev->if_layer_3.if_addr.address_len);
    neigh_src.addr.address_len = netdev->if_layer_3.if_addr.address_len;
    
    frb_create(&frb);
    frb_reverse(&frb);
    arp_header_build_wrapper(&frb, netdev, &neigh_src, neigh, ARPOP_REQUEST);
    arp_send(netdev, &frb, netdev->if_layer_2.if_addr_broadcast);
    frb_destroy(&frb);
    
    return 0;
}

int arp_reply(struct adi_netdev_s *netdev, struct arp_neigh_s *neigh_src,
              struct arp_neigh_s *neigh_dest, u8 *mac_dest)
{
    struct frb_s frb;

    arp_stats.total_send_arps++;
    arp_stats.send_reply_arps++;

    frb_create(&frb);
    frb_reverse(&frb);
    arp_header_build_wrapper(&frb, netdev, neigh_src, neigh_dest, ARPOP_REPLY);
    arp_send(netdev, &frb, mac_dest);
    frb_destroy(&frb);
    
    return 0;
}

void arp_timeout(void *data)
{
    sched_activate_task((struct task_s *)data);
}

int arp_resolve(struct adi_netdev_s *netdev, struct arp_neigh_s *neigh)
{
    struct arp_request_s *request;
    struct timer_s arp_timer;
    u32 flags;
    
    if (arp_get_neigh(neigh)) {
        return 0;
    }
    
    request = (struct arp_request_s *)get_free_pages(0);
    request->neigh = neigh;
    request->task  = current_task;
    INIT_LIST_HEAD(&(request->list));    
    
    arp_timer.timer_function = arp_timeout;
    arp_timer.timer_data     = current_task;
    arp_timer.timer_expire   = ARP_TIMEOUT;
    arp_timer.timer_flags    = TIMER_FLAG_ONESHOT;
    
    spin_lock_irqsave(&arp_entries_list_lock, flags);    
    
    arp_request_add(request);

    if (arp_request(netdev, neigh)) {
        arp_request_del(request);
        spin_unlock_irqrestore(&arp_entries_list_lock, flags);    
        return 0;
    }

    spin_unlock_irqrestore(&arp_entries_list_lock, flags);    
    sched_deactivate_task(current_task);
    register_timer(&arp_timer);
    schedule_task();

    unregister_timer(&arp_timer);
    spin_lock_irqsave(&arp_entries_list_lock, flags);    
    arp_request_del(request);
    spin_unlock_irqrestore(&arp_entries_list_lock, flags);    
    
    put_free_pages((u32)request, 0);

    if (arp_get_neigh(neigh)) {
        return 0;
    }

    return -1;
}

int arp_print_stats(void)
{
    printf("\n");
    printf("Total recv arps:         %d\n", arp_stats.total_recv_arps);
    printf("Total recv request arps: %d\n", arp_stats.recv_request_arps);
    printf("Total recv reply arps:   %d\n", arp_stats.recv_reply_arps);
    printf("Total send arps:         %d\n", arp_stats.total_send_arps);
    printf("Total send request arps: %d\n", arp_stats.send_request_arps);
    printf("Total send reply arps:   %d\n", arp_stats.send_reply_arps);
    
    return 0;
}

struct net_layer_2_pack arp_pack = {
    .pack_type          = 0x0608,
    .receiver           = arp_recv,
};

int net_layer_2_arp_init(void)
{
    printk(", arp");

    net_layer_2_add_pack(&arp_pack);
    
    if ((arp_hash_desc = register_hash_table("arp", 4096, NULL)) < 0) {
        kernel_panic("can not create hash table for arp!");
    }

    arp_cache_set(1);    
    arp_resource_desc = register_resource(&arp_resource);
    spin_lock_init(&arp_entries_list_lock);
    INIT_LIST_HEAD(&arp_entries_list);
    spin_lock_init(&arp_requests_list_lock);
    INIT_LIST_HEAD(&arp_requests_list);

    return 0;
}