Changeset dfda6a1 in mainline for uspace/lib/net/netif/netif_local.c


Ignore:
Timestamp:
2010-10-23T20:28:55Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
cc8d91a
Parents:
33dbbd2 (diff), 018d79b8 (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 from lp:~jakub/helenos/net.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/net/netif/netif_local.c

    r33dbbd2 rdfda6a1  
    2727 */
    2828
    29 /** @addtogroup netif
     29/** @addtogroup libnet
    3030 * @{
    3131 */
     
    5858DEVICE_MAP_IMPLEMENT(netif_device_map, netif_device_t);
    5959
    60 /** Network interface global data.
    61  */
     60/** Network interface global data. */
    6261netif_globals_t netif_globals;
    6362
     
    6564 *
    6665 * @param[in] netif_phone The network interface phone.
    67  * @param[in] device_id   The device identifier.
    68  * @param[in] irq         The device interrupt number.
    69  * @param[in] io          The device input/output address.
    70  *
    71  * @return EOK on success.
    72  * @return Other errro codes as defined for the netif_probe_message().
    73  *
    74  */
    75 int netif_probe_req_local(int netif_phone, device_id_t device_id, int irq, int io)
     66 * @param[in] device_id The device identifier.
     67 * @param[in] irq       The device interrupt number.
     68 * @param[in] io        The device input/output address.
     69 * @return              EOK on success.
     70 * @return              Other error codes as defined for the
     71 *                      netif_probe_message().
     72 */
     73int
     74netif_probe_req_local(int netif_phone, device_id_t device_id, int irq, int io)
    7675{
    7776        fibril_rwlock_write_lock(&netif_globals.lock);
     
    8584 *
    8685 * @param[in] netif_phone The network interface phone.
    87  * @param[in] device_id   The device identifier.
    88  * @param[in] packet      The packet queue.
    89  * @param[in] sender      The sending module service.
    90  *
    91  * @return EOK on success.
    92  * @return Other error codes as defined for the generic_send_msg() function.
    93  *
     86 * @param[in] device_id The device identifier.
     87 * @param[in] packet    The packet queue.
     88 * @param[in] sender    The sending module service.
     89 * @return              EOK on success.
     90 * @return              Other error codes as defined for the generic_send_msg()
     91 *                      function.
    9492 */
    9593int netif_send_msg_local(int netif_phone, device_id_t device_id,
     
    106104 *
    107105 * @param[in] netif_phone The network interface phone.
    108  * @param[in] device_id   The device identifier.
    109  *
    110  * @return EOK on success.
    111  * @return Other error codes as defined for the find_device() function.
    112  * @return Other error codes as defined for the netif_start_message() function.
    113  *
     106 * @param[in] device_id The device identifier.
     107 * @return              EOK on success.
     108 * @return              Other error codes as defined for the find_device()
     109 *                      function.
     110 * @return              Other error codes as defined for the
     111 *                      netif_start_message() function.
    114112 */
    115113int netif_start_req_local(int netif_phone, device_id_t device_id)
     
    141139 *
    142140 * @param[in] netif_phone The network interface phone.
    143  * @param[in] device_id   The device identifier.
    144  *
    145  * @return EOK on success.
    146  * @return Other error codes as defined for the find_device() function.
    147  * @return Other error codes as defined for the netif_stop_message() function.
    148  *
     141 * @param[in] device_id The device identifier.
     142 * @return              EOK on success.
     143 * @return              Other error codes as defined for the find_device()
     144 *                      function.
     145 * @return              Other error codes as defined for the
     146 *                      netif_stop_message() function.
    149147 */
    150148int netif_stop_req_local(int netif_phone, device_id_t device_id)
     
    175173/** Return the device usage statistics.
    176174 *
    177  * @param[in]  netif_phone The network interface phone.
    178  * @param[in]  device_id   The device identifier.
    179  * @param[out] stats       The device usage statistics.
    180  *
     175 * @param[in] netif_phone The network interface phone.
     176 * @param[in] device_id The device identifier.
     177 * @param[out] stats    The device usage statistics.
    181178 * @return EOK on success.
    182  *
    183179 */
    184180int netif_stats_req_local(int netif_phone, device_id_t device_id,
     
    194190/** Return the device local hardware address.
    195191 *
    196  * @param[in]  netif_phone The network interface phone.
    197  * @param[in]  device_id   The device identifier.
    198  * @param[out] address     The device local hardware address.
    199  * @param[out] data        The address data.
    200  *
    201  * @return EOK on success.
    202  * @return EBADMEM if the address parameter is NULL.
    203  * @return ENOENT if there no such device.
    204  * @return Other error codes as defined for the netif_get_addr_message()
    205  *         function.
    206  *
     192 * @param[in] netif_phone The network interface phone.
     193 * @param[in] device_id The device identifier.
     194 * @param[out] address  The device local hardware address.
     195 * @param[out] data     The address data.
     196 * @return              EOK on success.
     197 * @return              EBADMEM if the address parameter is NULL.
     198 * @return              ENOENT if there no such device.
     199 * @return              Other error codes as defined for the
     200 *                      netif_get_addr_message() function.
    207201 */
    208202int netif_get_addr_req_local(int netif_phone, device_id_t device_id,
     
    211205        ERROR_DECLARE;
    212206       
    213         if ((!address) || (!data))
     207        if (!address || !data)
    214208                return EBADMEM;
    215209       
     
    231225/** Find the device specific data.
    232226 *
    233  * @param[in]  device_id The device identifier.
    234  * @param[out] device    The device specific data.
    235  *
    236  * @return EOK on success.
    237  * @return ENOENT if device is not found.
    238  * @return EPERM if the device is not initialized.
    239  *
     227 * @param[in] device_id The device identifier.
     228 * @param[out] device   The device specific data.
     229 * @return              EOK on success.
     230 * @return              ENOENT if device is not found.
     231 * @return              EPERM if the device is not initialized.
    240232 */
    241233int find_device(device_id_t device_id, netif_device_t **device)
     
    256248/** Clear the usage statistics.
    257249 *
    258  * @param[in] stats The usage statistics.
    259  *
     250 * @param[in] stats     The usage statistics.
    260251 */
    261252void null_device_stats(device_stats_ref stats)
     
    266257/** Initialize the netif module.
    267258 *
    268  *  @param[in] client_connection The client connection functio to be
    269  *                               registered.
    270  *
    271  *  @return EOK on success.
    272  *  @return Other error codes as defined for each specific module
    273  *          message function.
    274  *
     259 * @param[in] client_connection The client connection functio to be registered.
     260 * @return              EOK on success.
     261 * @return              Other error codes as defined for each specific module
     262 *                      message function.
    275263 */
    276264int netif_init_module(async_client_conn_t client_connection)
     
    298286 * Prepared for future optimization.
    299287 *
    300  * @param[in] packet_id The packet identifier.
    301  *
     288 * @param[in] packet_id The packet identifier.
    302289 */
    303290void netif_pq_release(packet_id_t packet_id)
     
    308295/** Allocate new packet to handle the given content size.
    309296 *
    310  * @param[in] content The minimum content size.
    311  *
    312  * @return The allocated packet.
    313  * @return NULL if there is an error.
     297 * @param[in] content   The minimum content size.
     298 * @return              The allocated packet.
     299 * @return              NULL if there is an error.
    314300 *
    315301 */
     
    319305}
    320306
    321 /** Register the device notification receiver, the network interface layer module.
    322  *
    323  * @param[in] name      Module name.
    324  * @param[in] device_id The device identifier.
    325  * @param[in] phone     The network interface layer module phone.
    326  *
    327  * @return EOK on success.
    328  * @return ENOENT if there is no such device.
    329  * @return ELIMIT if there is another module registered.
    330  *
     307/** Register the device notification receiver, the network interface layer
     308 * module.
     309 *
     310 * @param[in] name      Module name.
     311 * @param[in] device_id The device identifier.
     312 * @param[in] phone     The network interface layer module phone.
     313 * @return              EOK on success.
     314 * @return              ENOENT if there is no such device.
     315 * @return              ELIMIT if there is another module registered.
    331316 */
    332317static int register_message(const char *name, device_id_t device_id, int phone)
     
    347332/** Process the netif module messages.
    348333 *
    349  * @param[in]  name         Module name.
    350  * @param[in]  callid       The message identifier.
    351  * @param[in]  call         The message parameters.
    352  * @param[out] answer       The message answer parameters.
    353  * @param[out] answer_count The last parameter for the actual answer
    354  *                          in the answer parameter.
    355  *
    356  * @return EOK on success.
    357  * @return ENOTSUP if the message is not known.
    358  * @return Other error codes as defined for each specific module message function.
     334 * @param[in] name      Module name.
     335 * @param[in] callid    The message identifier.
     336 * @param[in] call      The message parameters.
     337 * @param[out] answer   The message answer parameters.
     338 * @param[out] answer_count The last parameter for the actual answer in the
     339 *                      answer parameter.
     340 * @return              EOK on success.
     341 * @return              ENOTSUP if the message is not known.
     342 * @return              Other error codes as defined for each specific module
     343 *                      message function.
    359344 *
    360345 * @see IS_NET_NETIF_MESSAGE()
     
    373358        *answer_count = 0;
    374359        switch (IPC_GET_METHOD(*call)) {
    375                 case IPC_M_PHONE_HUNGUP:
    376                         return EOK;
    377                 case NET_NETIF_PROBE:
    378                         return netif_probe_req_local(0, IPC_GET_DEVICE(call),
    379                             NETIF_GET_IRQ(call), NETIF_GET_IO(call));
    380                 case IPC_M_CONNECT_TO_ME:
    381                         fibril_rwlock_write_lock(&netif_globals.lock);
    382                         ERROR_CODE = register_message(name, IPC_GET_DEVICE(call),
    383                             IPC_GET_PHONE(call));
    384                         fibril_rwlock_write_unlock(&netif_globals.lock);
    385                         return ERROR_CODE;
    386                 case NET_NETIF_SEND:
    387                         ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone,
    388                             &packet, IPC_GET_PACKET(call)));
    389                         return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,
    390                             IPC_GET_SENDER(call));
    391                 case NET_NETIF_START:
    392                         return netif_start_req_local(0, IPC_GET_DEVICE(call));
    393                 case NET_NETIF_STATS:
    394                         fibril_rwlock_read_lock(&netif_globals.lock);
    395                         if (!ERROR_OCCURRED(async_data_read_receive(&callid, &length))) {
    396                                 if (length < sizeof(device_stats_t))
    397                                         ERROR_CODE = EOVERFLOW;
    398                                 else {
    399                                         if (!ERROR_OCCURRED(netif_get_device_stats(
    400                                             IPC_GET_DEVICE(call), &stats)))
    401                                                 ERROR_CODE = async_data_read_finalize(callid, &stats,
    402                                                     sizeof(device_stats_t));
    403                                 }
    404                         }
     360        case IPC_M_PHONE_HUNGUP:
     361                return EOK;
     362       
     363        case NET_NETIF_PROBE:
     364                return netif_probe_req_local(0, IPC_GET_DEVICE(call),
     365                    NETIF_GET_IRQ(call), NETIF_GET_IO(call));
     366                   
     367        case IPC_M_CONNECT_TO_ME:
     368                fibril_rwlock_write_lock(&netif_globals.lock);
     369                ERROR_CODE = register_message(name, IPC_GET_DEVICE(call),
     370                    IPC_GET_PHONE(call));
     371                fibril_rwlock_write_unlock(&netif_globals.lock);
     372                return ERROR_CODE;
     373               
     374        case NET_NETIF_SEND:
     375                ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone,
     376                    &packet, IPC_GET_PACKET(call)));
     377                return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,
     378                    IPC_GET_SENDER(call));
     379                   
     380        case NET_NETIF_START:
     381                return netif_start_req_local(0, IPC_GET_DEVICE(call));
     382               
     383        case NET_NETIF_STATS:
     384                fibril_rwlock_read_lock(&netif_globals.lock);
     385
     386                if (ERROR_OCCURRED(async_data_read_receive(&callid, &length))) {
    405387                        fibril_rwlock_read_unlock(&netif_globals.lock);
    406388                        return ERROR_CODE;
    407                 case NET_NETIF_STOP:
    408                         return netif_stop_req_local(0, IPC_GET_DEVICE(call));
    409                 case NET_NETIF_GET_ADDR:
    410                         fibril_rwlock_read_lock(&netif_globals.lock);
    411                         if (!ERROR_OCCURRED(netif_get_addr_message(IPC_GET_DEVICE(call),
    412                             &address)))
    413                                 ERROR_CODE = measured_strings_reply(&address, 1);
     389                }
     390                if (length < sizeof(device_stats_t)) {
    414391                        fibril_rwlock_read_unlock(&netif_globals.lock);
    415                         return ERROR_CODE;
     392                        return EOVERFLOW;
     393                }
     394
     395                if (ERROR_NONE(netif_get_device_stats(IPC_GET_DEVICE(call),
     396                    &stats))) {
     397                        ERROR_CODE = async_data_read_finalize(callid, &stats,
     398                            sizeof(device_stats_t));
     399                }
     400
     401                fibril_rwlock_read_unlock(&netif_globals.lock);
     402                return ERROR_CODE;
     403
     404        case NET_NETIF_STOP:
     405                return netif_stop_req_local(0, IPC_GET_DEVICE(call));
     406               
     407        case NET_NETIF_GET_ADDR:
     408                fibril_rwlock_read_lock(&netif_globals.lock);
     409                if (ERROR_NONE(netif_get_addr_message(IPC_GET_DEVICE(call),
     410                    &address)))
     411                        ERROR_CODE = measured_strings_reply(&address, 1);
     412                fibril_rwlock_read_unlock(&netif_globals.lock);
     413                return ERROR_CODE;
    416414        }
    417415       
     
    421419/** Start the network interface module.
    422420 *
    423  * Initialize the client connection serving function, initialize
    424  * the module, registers the module service and start the async
    425  * manager, processing IPC messages in an infinite loop.
    426  *
    427  * @param[in] client_connection The client connection processing
    428  *                              function. The module skeleton propagates
    429  *                              its own one.
    430  *
    431  * @return EOK on success.
    432  * @return Other error codes as defined for each specific module message
    433  *         function.
    434  *
     421 * Initialize the client connection serving function, initialize the module,
     422 * registers the module service and start the async manager, processing IPC
     423 * messages in an infinite loop.
     424 *
     425 * @param[in] client_connection The client connection processing function.
     426 *                      The module skeleton propagates its own one.
     427 * @return              EOK on success.
     428 * @return              Other error codes as defined for each specific module
     429 *                      message function.
    435430 */
    436431int netif_module_start_standalone(async_client_conn_t client_connection)
Note: See TracChangeset for help on using the changeset viewer.