uspace/srv/net/ethip/ethip_nic.c

   1 /*
   2  * Copyright (c) 2012 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup ethip
  30  * @{
  31  */
  32 /**
  33  * @file
  34  * @brief
  35  */
  36
  37 #include <adt/list.h>
  38 #include <async.h>
  39 #include <stdbool.h>
  40 #include <errno.h>
  41 #include <fibril_synch.h>
  42 #include <inet/iplink_srv.h>
  43 #include <io/log.h>
  44 #include <loc.h>
  45 #include <device/nic.h>
  46 #include <stdlib.h>
  47
  48 #include "ethip.h"
  49 #include "ethip_nic.h"
  50 #include "pdu.h"
  51
  52 static int ethip_nic_open(service_id_t sid);
  53 static void ethip_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
  54
  55 static LIST_INITIALIZE(ethip_nic_list);
  56 static FIBRIL_MUTEX_INITIALIZE(ethip_discovery_lock);
  57
  58 static int ethip_nic_check_new(void)
  59 {
  60         bool already_known;
  61         category_id_t iplink_cat;
  62         service_id_t *svcs;
  63         size_t count, i;
  64         int rc;
  65
  66         fibril_mutex_lock(&ethip_discovery_lock);
  67
  68         rc = loc_category_get_id("nic", &iplink_cat, IPC_FLAG_BLOCKING);
  69         if (rc != EOK) {
  70                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'nic'.");
  71                 fibril_mutex_unlock(&ethip_discovery_lock);
  72                 return ENOENT;
  73         }
  74
  75         rc = loc_category_get_svcs(iplink_cat, &svcs, &count);
  76         if (rc != EOK) {
  77                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of IP links.");
  78                 fibril_mutex_unlock(&ethip_discovery_lock);
  79                 return EIO;
  80         }
  81
  82         for (i = 0; i < count; i++) {
  83                 already_known = false;
  84
  85                 list_foreach(ethip_nic_list, nic_link) {
  86                         ethip_nic_t *nic = list_get_instance(nic_link,
  87                             ethip_nic_t, nic_list);
  88                         if (nic->svc_id == svcs[i]) {
  89                                 already_known = true;
  90                                 break;
  91                         }
  92                 }
  93
  94                 if (!already_known) {
  95                         log_msg(LOG_DEFAULT, LVL_DEBUG, "Found NIC '%lu'",
  96                             (unsigned long) svcs[i]);
  97                         rc = ethip_nic_open(svcs[i]);
  98                         if (rc != EOK)
  99                                 log_msg(LOG_DEFAULT, LVL_ERROR, "Could not open NIC.");
 100                 }
 101         }
 102
 103         fibril_mutex_unlock(&ethip_discovery_lock);
 104         return EOK;
 105 }
 106
 107 static ethip_nic_t *ethip_nic_new(void)
 108 {
 109         ethip_nic_t *nic = calloc(1, sizeof(ethip_nic_t));
 110
 111         if (nic == NULL) {
 112                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC structure. "
 113                     "Out of memory.");
 114                 return NULL;
 115         }
 116
 117         link_initialize(&nic->nic_list);
 118         list_initialize(&nic->addr_list);
 119
 120         return nic;
 121 }
 122
 123 static ethip_link_addr_t *ethip_nic_addr_new(uint32_t addr)
 124 {
 125         ethip_link_addr_t *laddr = calloc(1, sizeof(ethip_link_addr_t));
 126         if (laddr == NULL) {
 127                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC address structure. "
 128                     "Out of memory.");
 129                 return NULL;
 130         }
 131
 132         link_initialize(&laddr->addr_list);
 133         laddr->addr = addr;
 134
 135         return laddr;
 136 }
 137
 138 static void ethip_nic_delete(ethip_nic_t *nic)
 139 {
 140         if (nic->svc_name != NULL)
 141                 free(nic->svc_name);
 142         free(nic);
 143 }
 144
 145 static void ethip_link_addr_delete(ethip_link_addr_t *laddr)
 146 {
 147         free(laddr);
 148 }
 149
 150 static int ethip_nic_open(service_id_t sid)
 151 {
 152         bool in_list = false;
 153         nic_address_t nic_address;
 154
 155         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_open()");
 156         ethip_nic_t *nic = ethip_nic_new();
 157         if (nic == NULL)
 158                 return ENOMEM;
 159
 160         int rc = loc_service_get_name(sid, &nic->svc_name);
 161         if (rc != EOK) {
 162                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting service name.");
 163                 goto error;
 164         }
 165
 166         nic->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
 167         if (nic->sess == NULL) {
 168                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting '%s'", nic->svc_name);
 169                 goto error;
 170         }
 171
 172         nic->svc_id = sid;
 173
 174         rc = nic_callback_create(nic->sess, ethip_nic_cb_conn, nic);
 175         if (rc != EOK) {
 176                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating callback connection "
 177                     "from '%s'", nic->svc_name);
 178                 goto error;
 179         }
 180
 181         log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened NIC '%s'", nic->svc_name);
 182         list_append(&nic->nic_list, &ethip_nic_list);
 183         in_list = true;
 184
 185         rc = ethip_iplink_init(nic);
 186         if (rc != EOK)
 187                 goto error;
 188
 189         rc = nic_get_address(nic->sess, &nic_address);
 190         if (rc != EOK) {
 191                 log_msg(LOG_DEFAULT, LVL_ERROR, "Error getting MAC address of NIC '%s'.",
 192                     nic->svc_name);
 193                 goto error;
 194         }
 195
 196         mac48_decode(nic_address.address, &nic->mac_addr);
 197
 198         rc = nic_set_state(nic->sess, NIC_STATE_ACTIVE);
 199         if (rc != EOK) {
 200                 log_msg(LOG_DEFAULT, LVL_ERROR, "Error activating NIC '%s'.",
 201                     nic->svc_name);
 202                 goto error;
 203         }
 204
 205         log_msg(LOG_DEFAULT, LVL_DEBUG, "Initialized IP link service, MAC = 0x%" PRIx64,
 206             nic->mac_addr.addr);
 207
 208         return EOK;
 209
 210 error:
 211         if (in_list)
 212                 list_remove(&nic->nic_list);
 213         if (nic->sess != NULL)
 214                 async_hangup(nic->sess);
 215         ethip_nic_delete(nic);
 216         return rc;
 217 }
 218
 219 static void ethip_nic_cat_change_cb(void)
 220 {
 221         (void) ethip_nic_check_new();
 222 }
 223
 224 static void ethip_nic_addr_changed(ethip_nic_t *nic, ipc_callid_t callid,
 225     ipc_call_t *call)
 226 {
 227         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_changed()");
 228         async_answer_0(callid, ENOTSUP);
 229 }
 230
 231 static void ethip_nic_received(ethip_nic_t *nic, ipc_callid_t callid,
 232     ipc_call_t *call)
 233 {
 234         int rc;
 235         void *data;
 236         size_t size;
 237
 238         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() nic=%p", nic);
 239
 240         rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
 241         if (rc != EOK) {
 242                 log_msg(LOG_DEFAULT, LVL_DEBUG, "data_write_accept() failed");
 243                 return;
 244         }
 245
 246         log_msg(LOG_DEFAULT, LVL_DEBUG, "Ethernet PDU contents (%zu bytes)",
 247             size);
 248
 249         log_msg(LOG_DEFAULT, LVL_DEBUG, "call ethip_received");
 250         rc = ethip_received(&nic->iplink, data, size);
 251         log_msg(LOG_DEFAULT, LVL_DEBUG, "free data");
 252         free(data);
 253
 254         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() done, rc=%d", rc);
 255         async_answer_0(callid, rc);
 256 }
 257
 258 static void ethip_nic_device_state(ethip_nic_t *nic, ipc_callid_t callid,
 259     ipc_call_t *call)
 260 {
 261         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_device_state()");
 262         async_answer_0(callid, ENOTSUP);
 263 }
 264
 265 static void ethip_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 266 {
 267         ethip_nic_t *nic = (ethip_nic_t *)arg;
 268
 269         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethnip_nic_cb_conn()");
 270
 271         while (true) {
 272                 ipc_call_t call;
 273                 ipc_callid_t callid = async_get_call(&call);
 274
 275                 if (!IPC_GET_IMETHOD(call)) {
 276                         /* TODO: Handle hangup */
 277                         return;
 278                 }
 279
 280                 switch (IPC_GET_IMETHOD(call)) {
 281                 case NIC_EV_ADDR_CHANGED:
 282                         ethip_nic_addr_changed(nic, callid, &call);
 283                         break;
 284                 case NIC_EV_RECEIVED:
 285                         ethip_nic_received(nic, callid, &call);
 286                         break;
 287                 case NIC_EV_DEVICE_STATE:
 288                         ethip_nic_device_state(nic, callid, &call);
 289                         break;
 290                 default:
 291                         async_answer_0(callid, ENOTSUP);
 292                 }
 293         }
 294 }
 295
 296 int ethip_nic_discovery_start(void)
 297 {
 298         int rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
 299         if (rc != EOK) {
 300                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for NIC "
 301                     "discovery (%d).", rc);
 302                 return rc;
 303         }
 304
 305         return ethip_nic_check_new();
 306 }
 307
 308 ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t iplink_sid)
 309 {
 310         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid(%u)",
 311             (unsigned) iplink_sid);
 312
 313         list_foreach(ethip_nic_list, link) {
 314                 log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - element");
 315                 ethip_nic_t *nic = list_get_instance(link, ethip_nic_t,
 316                     nic_list);
 317
 318                 if (nic->iplink_sid == iplink_sid) {
 319                         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - found %p", nic);
 320                         return nic;
 321                 }
 322         }
 323
 324         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - not found");
 325         return NULL;
 326 }
 327
 328 int ethip_nic_send(ethip_nic_t *nic, void *data, size_t size)
 329 {
 330         int rc;
 331         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_send(size=%zu)", size);
 332         rc = nic_send_frame(nic->sess, data, size);
 333         log_msg(LOG_DEFAULT, LVL_DEBUG, "nic_send_frame -> %d", rc);
 334         return rc;
 335 }
 336
 337 int ethip_nic_addr_add(ethip_nic_t *nic, uint32_t addr)
 338 {
 339         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()");
 340
 341         ethip_link_addr_t *laddr = ethip_nic_addr_new(addr);
 342         if (laddr == NULL)
 343                 return ENOMEM;
 344
 345         list_append(&laddr->addr_list, &nic->addr_list);
 346         return EOK;
 347 }
 348
 349 int ethip_nic_addr_remove(ethip_nic_t *nic, uint32_t addr)
 350 {
 351         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()");
 352
 353         ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, addr);
 354         if (laddr == NULL)
 355                 return ENOENT;
 356
 357         list_remove(&laddr->addr_list);
 358         ethip_link_addr_delete(laddr);
 359         return EOK;
 360 }
 361
 362 ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *nic,
 363     uint32_t addr)
 364 {
 365         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()");
 366
 367         list_foreach(nic->addr_list, link) {
 368                 ethip_link_addr_t *laddr = list_get_instance(link,
 369                     ethip_link_addr_t, addr_list);
 370
 371                 if (addr == laddr->addr)
 372                         return laddr;
 373         }
 374
 375         return NULL;
 376 }
 377
 378 /** @}
 379  */