Changeset 357b5f5 in mainline for uspace/srv/net/netif/lo/lo.c


Ignore:
Timestamp:
2011-01-23T20:09:13Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
fdb9982c
Parents:
cead2aa (diff), 7e36c8d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/netif/lo/lo.c

    rcead2aa r357b5f5  
    4848#include <packet_client.h>
    4949#include <net/device.h>
    50 #include <nil_interface.h>
    51 #include <netif_interface.h>
    52 #include <netif_local.h>
    53 
    54 /** Default hardware address. */
    55 #define DEFAULT_ADDR            "\0\0\0\0\0\0"
     50#include <netif_skel.h>
     51#include <nil_remote.h>
    5652
    5753/** Default address length. */
    58 #define DEFAULT_ADDR_LEN        (sizeof(DEFAULT_ADDR) / sizeof(char))
     54#define DEFAULT_ADDR_LEN  6
    5955
    6056/** Loopback module name. */
    6157#define NAME  "lo"
    6258
    63 /** Network interface global data. */
    64 netif_globals_t netif_globals;
     59static uint8_t default_addr[DEFAULT_ADDR_LEN] =
     60    {0, 0, 0, 0, 0, 0};
    6561
    6662int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
    67     ipc_call_t *answer, int *answer_count)
     63    ipc_call_t *answer, size_t *count)
    6864{
    6965        return ENOTSUP;
    … …  
    7470        if (!address)
    7571                return EBADMEM;
    76 
    77         address->value = str_dup(DEFAULT_ADDR);
     72       
     73        address->value = default_addr;
    7874        address->length = DEFAULT_ADDR_LEN;
    79 
     75       
    8076        return EOK;
    8177}
    … …  
    8379int netif_get_device_stats(device_id_t device_id, device_stats_t *stats)
    8480{
    85         netif_device_t *device;
    86         int rc;
    87 
    8881        if (!stats)
    8982                return EBADMEM;
    90 
    91         rc = find_device(device_id, &device);
     83       
     84        netif_device_t *device;
     85        int rc = find_device(device_id, &device);
    9286        if (rc != EOK)
    9387                return rc;
    94 
     88       
    9589        memcpy(stats, (device_stats_t *) device->specific,
    9690            sizeof(device_stats_t));
    97 
    98         return EOK;
    99 }
    100 
    101 /** Changes the loopback state.
    102  *
    103  * @param[in] device    The device structure.
    104  * @param[in] state     The new device state.
    105  * @return              The new state if changed.
    106  * @return              EOK otherwise.
    107  */
    108 static int change_state_message(netif_device_t *device, device_state_t state)
     91       
     92        return EOK;
     93}
     94
     95/** Change the loopback state.
     96 *
     97 * @param[in] device The device structure.
     98 * @param[in] state  The new device state.
     99 *
     100 * @return New state if changed.
     101 * @return EOK otherwise.
     102 *
     103 */
     104static void change_state_message(netif_device_t *device, device_state_t state)
    109105{
    110106        if (device->state != state) {
    111107                device->state = state;
    112108               
    113                 printf("%s: State changed to %s\n", NAME,
    114                     (state == NETIF_ACTIVE) ? "active" : "stopped");
     109                const char *desc;
     110                switch (state) {
     111                case NETIF_ACTIVE:
     112                        desc = "active";
     113                        break;
     114                case NETIF_STOPPED:
     115                        desc = "stopped";
     116                        break;
     117                default:
     118                        desc = "unknown";
     119                }
    115120               
    116                 return state;
    117         }
    118        
    119         return EOK;
    120 }
    121 
    122 /** Creates and returns the loopback network interface structure.
    123  *
    124  * @param[in] device_id The new devce identifier.
    125  * @param[out] device   The device structure.
    126  * @return              EOK on success.
    127  * @return              EXDEV if one loopback network interface already exists.
    128  * @return              ENOMEM if there is not enough memory left.
    129  */
    130 static int create(device_id_t device_id, netif_device_t **device)
    131 {
    132         int index;
    133 
     121                printf("%s: State changed to %s\n", NAME, desc);
     122        }
     123}
     124
     125/** Create and return the loopback network interface structure.
     126 *
     127 * @param[in]  device_id New devce identifier.
     128 * @param[out] device    Device structure.
     129 *
     130 * @return EOK on success.
     131 * @return EXDEV if one loopback network interface already exists.
     132 * @return ENOMEM if there is not enough memory left.
     133 *
     134 */
     135static int lo_create(device_id_t device_id, netif_device_t **device)
     136{
    134137        if (netif_device_map_count(&netif_globals.device_map) > 0)
    135138                return EXDEV;
    136 
     139       
    137140        *device = (netif_device_t *) malloc(sizeof(netif_device_t));
    138141        if (!*device)
    139142                return ENOMEM;
    140 
     143       
    141144        (*device)->specific = (device_stats_t *) malloc(sizeof(device_stats_t));
    142145        if (!(*device)->specific) {
    … …  
    144147                return ENOMEM;
    145148        }
    146 
     149       
    147150        null_device_stats((device_stats_t *) (*device)->specific);
    148151        (*device)->device_id = device_id;
    149152        (*device)->nil_phone = -1;
    150153        (*device)->state = NETIF_STOPPED;
    151         index = netif_device_map_add(&netif_globals.device_map,
     154        int index = netif_device_map_add(&netif_globals.device_map,
    152155            (*device)->device_id, *device);
    153 
     156       
    154157        if (index < 0) {
    155158                free(*device);
    … …  
    164167int netif_initialize(void)
    165168{
    166         ipcarg_t phonehash;
    167 
    168         return REGISTER_ME(SERVICE_LO, &phonehash);
    169 }
    170 
    171 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
    172 {
     169        sysarg_t phonehash;
     170        return ipc_connect_to_me(PHONE_NS, SERVICE_LO, 0, 0, &phonehash);
     171}
     172
     173int netif_probe_message(device_id_t device_id, int irq, void *io)
     174{
     175        /* Create a new device */
    173176        netif_device_t *device;
    174         int rc;
    175 
    176         /* Create a new device */
    177         rc = create(device_id, &device);
     177        int rc = lo_create(device_id, &device);
    178178        if (rc != EOK)
    179179                return rc;
    180 
    181         /* Print the settings */
     180       
    182181        printf("%s: Device created (id: %d)\n", NAME, device->device_id);
    183 
    184182        return EOK;
    185183}
    … …  
    188186{
    189187        netif_device_t *device;
    190         size_t length;
    191         packet_t *next;
    192         int phone;
    193         int rc;
    194 
    195         rc = find_device(device_id, &device);
     188        int rc = find_device(device_id, &device);
    196189        if (rc != EOK)
    197190                return EOK;
    198 
     191       
    199192        if (device->state != NETIF_ACTIVE) {
    200193                netif_pq_release(packet_get_id(packet));
    201194                return EFORWARD;
    202195        }
    203 
    204         next = packet;
     196       
     197        packet_t *next = packet;
    205198        do {
    206199                ((device_stats_t *) device->specific)->send_packets++;
    207200                ((device_stats_t *) device->specific)->receive_packets++;
    208                 length = packet_get_data_length(next);
     201                size_t length = packet_get_data_length(next);
    209202                ((device_stats_t *) device->specific)->send_bytes += length;
    210203                ((device_stats_t *) device->specific)->receive_bytes += length;
    211204                next = pq_next(next);
    212         } while(next);
    213 
    214         phone = device->nil_phone;
     205        } while (next);
     206       
     207        int phone = device->nil_phone;
    215208        fibril_rwlock_write_unlock(&netif_globals.lock);
     209       
    216210        nil_received_msg(phone, device_id, packet, sender);
     211       
    217212        fibril_rwlock_write_lock(&netif_globals.lock);
    218        
    219213        return EOK;
    220214}
    … …  
    222216int netif_start_message(netif_device_t *device)
    223217{
    224         return change_state_message(device, NETIF_ACTIVE);
     218        change_state_message(device, NETIF_ACTIVE);
     219        return device->state;
    225220}
    226221
    227222int netif_stop_message(netif_device_t *device)
    228223{
    229         return change_state_message(device, NETIF_STOPPED);
    230 }
    231 
    232 /** Default thread for new connections.
    233  *
    234  * @param[in] iid       The initial message identifier.
    235  * @param[in] icall     The initial message call structure.
    236  */
    237 static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
    238 {
    239         /*
    240          * Accept the connection
    241          *  - Answer the first IPC_M_CONNECT_ME_TO call.
    242          */
    243         ipc_answer_0(iid, EOK);
    244        
    245         while (true) {
    246                 ipc_call_t answer;
    247                 int answer_count;
    248                
    249                 /* Clear the answer structure */
    250                 refresh_answer(&answer, &answer_count);
    251                
    252                 /* Fetch the next message */
    253                 ipc_call_t call;
    254                 ipc_callid_t callid = async_get_call(&call);
    255                
    256                 /* Process the message */
    257                 int res = netif_module_message(NAME, callid, &call, &answer,
    258                     &answer_count);
    259                
    260                 /*
    261                  * End if told to either by the message or the processing
    262                  * result.
    263                  */
    264                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
    265                     (res == EHANGUP))
    266                         return;
    267                
    268                 /* Answer the message */
    269                 answer_call(callid, res, &answer, answer_count);
    270         }
     224        change_state_message(device, NETIF_STOPPED);
     225        return device->state;
    271226}
    272227
    273228int main(int argc, char *argv[])
    274229{
    275         int rc;
    276        
    277230        /* Start the module */
    278         rc = netif_module_start(netif_client_connection);
    279         return rc;
     231        return netif_module_start();
    280232}
    281233
Note: See TracChangeset for help on using the changeset viewer.