Changes in uspace/lib/net/netif/netif_local.c [46d4d9f:14f1db0] in mainline
- File:
-
- 1 edited
-
uspace/lib/net/netif/netif_local.c (modified) (18 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/net/netif/netif_local.c
r46d4d9f r14f1db0 27 27 */ 28 28 29 /** @addtogroup libnet29 /** @addtogroup netif 30 30 * @{ 31 31 */ … … 42 42 #include <ipc/ipc.h> 43 43 #include <ipc/services.h> 44 #include <ipc/netif.h> 45 #include < errno.h>46 47 #include < generic.h>48 #include < net/modules.h>49 #include < net/packet.h>50 #include <packet _client.h>44 45 #include <net_err.h> 46 #include <net_messages.h> 47 #include <net_modules.h> 48 #include <packet/packet.h> 49 #include <packet/packet_client.h> 50 #include <packet/packet_server.h> 51 51 #include <packet_remote.h> 52 52 #include <adt/measured_strings.h> 53 #include <net /device.h>53 #include <net_device.h> 54 54 #include <nil_interface.h> 55 55 #include <netif_local.h> 56 #include <netif_messages.h> 56 57 #include <netif_interface.h> 57 58 58 59 DEVICE_MAP_IMPLEMENT(netif_device_map, netif_device_t); 59 60 60 /** Network interface global data. */ 61 /** Network interface global data. 62 */ 61 63 netif_globals_t netif_globals; 62 64 … … 64 66 * 65 67 * @param[in] netif_phone The network interface phone. 66 * @param[in] device_id 67 * @param[in] irq 68 * @param[in] io 69 * @return EOK on success.70 * @return Other error codes as defined for the71 * 72 * /73 int 74 netif_probe_req_local(int netif_phone, device_id_t device_id, int irq, int io)68 * @param[in] device_id The device identifier. 69 * @param[in] irq The device interrupt number. 70 * @param[in] io The device input/output address. 71 * 72 * @return EOK on success. 73 * @return Other errro codes as defined for the netif_probe_message(). 74 * 75 */ 76 int netif_probe_req_local(int netif_phone, device_id_t device_id, int irq, int io) 75 77 { 76 78 fibril_rwlock_write_lock(&netif_globals.lock); … … 84 86 * 85 87 * @param[in] netif_phone The network interface phone. 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. 88 * @param[in] device_id The device identifier. 89 * @param[in] packet The packet queue. 90 * @param[in] sender The sending module service. 91 * 92 * @return EOK on success. 93 * @return Other error codes as defined for the generic_send_msg() function. 94 * 92 95 */ 93 96 int netif_send_msg_local(int netif_phone, device_id_t device_id, 94 packet_t *packet, services_t sender)97 packet_t packet, services_t sender) 95 98 { 96 99 fibril_rwlock_write_lock(&netif_globals.lock); … … 104 107 * 105 108 * @param[in] netif_phone The network interface phone. 106 * @param[in] device_id 107 * @return EOK on success.108 * @return Other error codes as defined for the find_device()109 * 110 * @return Other error codes as defined for the111 * netif_start_message() function.109 * @param[in] device_id The device identifier. 110 * 111 * @return EOK on success. 112 * @return Other error codes as defined for the find_device() function. 113 * @return Other error codes as defined for the netif_start_message() function. 114 * 112 115 */ 113 116 int netif_start_req_local(int netif_phone, device_id_t device_id) 114 117 { 115 int rc;118 ERROR_DECLARE; 116 119 117 120 fibril_rwlock_write_lock(&netif_globals.lock); 118 121 119 122 netif_device_t *device; 120 rc = find_device(device_id, &device); 121 if (rc != EOK) { 123 if (ERROR_OCCURRED(find_device(device_id, &device))) { 122 124 fibril_rwlock_write_unlock(&netif_globals.lock); 123 return rc;125 return ERROR_CODE; 124 126 } 125 127 … … 140 142 * 141 143 * @param[in] netif_phone The network interface phone. 142 * @param[in] device_id 143 * @return EOK on success.144 * @return Other error codes as defined for the find_device()145 * 146 * @return Other error codes as defined for the147 * netif_stop_message() function.144 * @param[in] device_id The device identifier. 145 * 146 * @return EOK on success. 147 * @return Other error codes as defined for the find_device() function. 148 * @return Other error codes as defined for the netif_stop_message() function. 149 * 148 150 */ 149 151 int netif_stop_req_local(int netif_phone, device_id_t device_id) 150 152 { 151 int rc;153 ERROR_DECLARE; 152 154 153 155 fibril_rwlock_write_lock(&netif_globals.lock); 154 156 155 157 netif_device_t *device; 156 rc = find_device(device_id, &device); 157 if (rc != EOK) { 158 if (ERROR_OCCURRED(find_device(device_id, &device))) { 158 159 fibril_rwlock_write_unlock(&netif_globals.lock); 159 return rc;160 return ERROR_CODE; 160 161 } 161 162 … … 175 176 /** Return the device usage statistics. 176 177 * 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 * @return EOK on success. 178 * @param[in] netif_phone The network interface phone. 179 * @param[in] device_id The device identifier. 180 * @param[out] stats The device usage statistics. 181 * 182 * @return EOK on success. 183 * 181 184 */ 182 185 int netif_stats_req_local(int netif_phone, device_id_t device_id, 183 device_stats_ t *stats)186 device_stats_ref stats) 184 187 { 185 188 fibril_rwlock_read_lock(&netif_globals.lock); … … 192 195 /** Return the device local hardware address. 193 196 * 194 * @param[in] netif_phone The network interface phone. 195 * @param[in] device_id The device identifier. 196 * @param[out] address The device local hardware address. 197 * @param[out] data The address data. 198 * @return EOK on success. 199 * @return EBADMEM if the address parameter is NULL. 200 * @return ENOENT if there no such device. 201 * @return Other error codes as defined for the 202 * netif_get_addr_message() function. 197 * @param[in] netif_phone The network interface phone. 198 * @param[in] device_id The device identifier. 199 * @param[out] address The device local hardware address. 200 * @param[out] data The address data. 201 * 202 * @return EOK on success. 203 * @return EBADMEM if the address parameter is NULL. 204 * @return ENOENT if there no such device. 205 * @return Other error codes as defined for the netif_get_addr_message() 206 * function. 207 * 203 208 */ 204 209 int netif_get_addr_req_local(int netif_phone, device_id_t device_id, 205 measured_string_ t **address, char **data)206 { 207 int rc;208 209 if ( !address || !data)210 measured_string_ref *address, char **data) 211 { 212 ERROR_DECLARE; 213 214 if ((!address) || (!data)) 210 215 return EBADMEM; 211 216 … … 213 218 214 219 measured_string_t translation; 215 rc = netif_get_addr_message(device_id, &translation); 216 if (rc == EOK) { 220 if (!ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))) { 217 221 *address = measured_string_copy(&translation); 218 rc= (*address) ? EOK : ENOMEM;222 ERROR_CODE = (*address) ? EOK : ENOMEM; 219 223 } 220 224 … … 223 227 *data = (**address).value; 224 228 225 return rc; 229 return ERROR_CODE; 230 } 231 232 /** Create bidirectional connection with the network interface module and registers the message receiver. 233 * 234 * @param[in] service The network interface module service. 235 * @param[in] device_id The device identifier. 236 * @param[in] me The requesting module service. 237 * @param[in] receiver The message receiver. 238 * 239 * @return The phone of the needed service. 240 * @return EOK on success. 241 * @return Other error codes as defined for the bind_service() function. 242 * 243 */ 244 int netif_bind_service_local(services_t service, device_id_t device_id, 245 services_t me, async_client_conn_t receiver) 246 { 247 return EOK; 226 248 } 227 249 228 250 /** Find the device specific data. 229 251 * 230 * @param[in] device_id The device identifier. 231 * @param[out] device The device specific data. 232 * @return EOK on success. 233 * @return ENOENT if device is not found. 234 * @return EPERM if the device is not initialized. 252 * @param[in] device_id The device identifier. 253 * @param[out] device The device specific data. 254 * 255 * @return EOK on success. 256 * @return ENOENT if device is not found. 257 * @return EPERM if the device is not initialized. 258 * 235 259 */ 236 260 int find_device(device_id_t device_id, netif_device_t **device) … … 251 275 /** Clear the usage statistics. 252 276 * 253 * @param[in] stats The usage statistics. 254 */ 255 void null_device_stats(device_stats_t *stats) 277 * @param[in] stats The usage statistics. 278 * 279 */ 280 void null_device_stats(device_stats_ref stats) 256 281 { 257 282 bzero(stats, sizeof(device_stats_t)); … … 260 285 /** Initialize the netif module. 261 286 * 262 * @param[in] client_connection The client connection functio to be registered. 263 * @return EOK on success. 264 * @return Other error codes as defined for each specific module 265 * message function. 287 * @param[in] client_connection The client connection functio to be 288 * registered. 289 * 290 * @return EOK on success. 291 * @return Other error codes as defined for each specific module 292 * message function. 293 * 266 294 */ 267 295 int netif_init_module(async_client_conn_t client_connection) 268 296 { 269 int rc;297 ERROR_DECLARE; 270 298 271 299 async_set_client_connection(client_connection); … … 274 302 netif_device_map_initialize(&netif_globals.device_map); 275 303 276 rc = pm_init(); 277 if (rc != EOK) 278 return rc; 304 ERROR_PROPAGATE(pm_init()); 279 305 280 306 fibril_rwlock_initialize(&netif_globals.lock); 281 282 rc = netif_initialize(); 283 if (rc != EOK) { 307 if (ERROR_OCCURRED(netif_initialize())) { 284 308 pm_destroy(); 285 return rc;309 return ERROR_CODE; 286 310 } 287 311 … … 293 317 * Prepared for future optimization. 294 318 * 295 * @param[in] packet_id The packet identifier. 319 * @param[in] packet_id The packet identifier. 320 * 296 321 */ 297 322 void netif_pq_release(packet_id_t packet_id) … … 302 327 /** Allocate new packet to handle the given content size. 303 328 * 304 * @param[in] content The minimum content size. 305 * @return The allocated packet. 306 * @return NULL if there is an error. 307 * 308 */ 309 packet_t *netif_packet_get_1(size_t content) 329 * @param[in] content The minimum content size. 330 * 331 * @return The allocated packet. 332 * @return NULL if there is an error. 333 * 334 */ 335 packet_t netif_packet_get_1(size_t content) 310 336 { 311 337 return packet_get_1_remote(netif_globals.net_phone, content); 312 338 } 313 339 314 /** Register the device notification receiver, the network interface layer 315 * module. 316 * 317 * @param[in] name Module name. 318 * @param[in] device_id The device identifier. 319 * @param[in] phone The network interface layer module phone. 320 * @return EOK on success. 321 * @return ENOENT if there is no such device. 322 * @return ELIMIT if there is another module registered. 340 /** Register the device notification receiver, the network interface layer module. 341 * 342 * @param[in] name Module name. 343 * @param[in] device_id The device identifier. 344 * @param[in] phone The network interface layer module phone. 345 * 346 * @return EOK on success. 347 * @return ENOENT if there is no such device. 348 * @return ELIMIT if there is another module registered. 349 * 323 350 */ 324 351 static int register_message(const char *name, device_id_t device_id, int phone) 325 352 { 353 ERROR_DECLARE; 354 326 355 netif_device_t *device; 327 int rc; 328 329 rc = find_device(device_id, &device); 330 if (rc != EOK) 331 return rc; 332 333 if (device->nil_phone > 0) 356 ERROR_PROPAGATE(find_device(device_id, &device)); 357 if(device->nil_phone > 0) 334 358 return ELIMIT; 335 359 … … 342 366 /** Process the netif module messages. 343 367 * 344 * @param[in] nameModule name.345 * @param[in] callidThe message identifier.346 * @param[in] callThe message parameters.347 * @param[out] answer 348 * @param[out] answer_count The last parameter for the actual answer in the349 * 350 * @return EOK on success.351 * @return ENOTSUP if the message is not known.352 * @return Other error codes as defined for each specific module353 * 368 * @param[in] name Module name. 369 * @param[in] callid The message identifier. 370 * @param[in] call The message parameters. 371 * @param[out] answer The message answer parameters. 372 * @param[out] answer_count The last parameter for the actual answer 373 * in the answer parameter. 374 * 375 * @return EOK on success. 376 * @return ENOTSUP if the message is not known. 377 * @return Other error codes as defined for each specific module message function. 354 378 * 355 379 * @see IS_NET_NETIF_MESSAGE() … … 359 383 ipc_call_t *call, ipc_call_t *answer, int *answer_count) 360 384 { 385 ERROR_DECLARE; 386 361 387 size_t length; 362 388 device_stats_t stats; 363 packet_t *packet;389 packet_t packet; 364 390 measured_string_t address; 365 int rc;366 391 367 392 *answer_count = 0; 368 393 switch (IPC_GET_METHOD(*call)) { 369 case IPC_M_PHONE_HUNGUP:370 return EOK;371 372 case NET_NETIF_PROBE:373 return netif_probe_req_local(0, IPC_GET_DEVICE(call),374 NETIF_GET_IRQ(call), NETIF_GET_IO(call));375 376 case IPC_M_CONNECT_TO_ME:377 fibril_rwlock_write_lock(&netif_globals.lock);378 rc = register_message(name, IPC_GET_DEVICE(call),379 IPC_GET_PHONE(call));380 fibril_rwlock_write_unlock(&netif_globals.lock);381 return rc;382 383 case NET_NETIF_SEND:384 rc = packet_translate_remote(netif_globals.net_phone, &packet,385 IPC_GET_PACKET(call));386 if (rc != EOK)387 return rc;388 return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,389 IPC_GET_SENDER(call));390 391 case NET_NETIF_START:392 return netif_start_req_local(0, IPC_GET_DEVICE(call));393 394 case NET_NETIF_STATS:395 fibril_rwlock_read_lock(&netif_globals.lock);396 397 rc = async_data_read_receive(&callid, &length);398 if (rc != EOK) {394 case IPC_M_PHONE_HUNGUP: 395 return EOK; 396 case NET_NETIF_PROBE: 397 return netif_probe_req_local(0, IPC_GET_DEVICE(call), 398 NETIF_GET_IRQ(call), NETIF_GET_IO(call)); 399 case IPC_M_CONNECT_TO_ME: 400 fibril_rwlock_write_lock(&netif_globals.lock); 401 ERROR_CODE = register_message(name, IPC_GET_DEVICE(call), 402 IPC_GET_PHONE(call)); 403 fibril_rwlock_write_unlock(&netif_globals.lock); 404 return ERROR_CODE; 405 case NET_NETIF_SEND: 406 ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone, 407 &packet, IPC_GET_PACKET(call))); 408 return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet, 409 IPC_GET_SENDER(call)); 410 case NET_NETIF_START: 411 return netif_start_req_local(0, IPC_GET_DEVICE(call)); 412 case NET_NETIF_STATS: 413 fibril_rwlock_read_lock(&netif_globals.lock); 414 if (!ERROR_OCCURRED(async_data_read_receive(&callid, &length))) { 415 if (length < sizeof(device_stats_t)) 416 ERROR_CODE = EOVERFLOW; 417 else { 418 if (!ERROR_OCCURRED(netif_get_device_stats( 419 IPC_GET_DEVICE(call), &stats))) 420 ERROR_CODE = async_data_read_finalize(callid, &stats, 421 sizeof(device_stats_t)); 422 } 423 } 399 424 fibril_rwlock_read_unlock(&netif_globals.lock); 400 return rc; 401 } 402 if (length < sizeof(device_stats_t)) { 425 return ERROR_CODE; 426 case NET_NETIF_STOP: 427 return netif_stop_req_local(0, IPC_GET_DEVICE(call)); 428 case NET_NETIF_GET_ADDR: 429 fibril_rwlock_read_lock(&netif_globals.lock); 430 if (!ERROR_OCCURRED(netif_get_addr_message(IPC_GET_DEVICE(call), 431 &address))) 432 ERROR_CODE = measured_strings_reply(&address, 1); 403 433 fibril_rwlock_read_unlock(&netif_globals.lock); 404 return EOVERFLOW; 405 } 406 407 rc = netif_get_device_stats(IPC_GET_DEVICE(call), &stats); 408 if (rc == EOK) { 409 rc = async_data_read_finalize(callid, &stats, 410 sizeof(device_stats_t)); 411 } 412 413 fibril_rwlock_read_unlock(&netif_globals.lock); 414 return rc; 415 416 case NET_NETIF_STOP: 417 return netif_stop_req_local(0, IPC_GET_DEVICE(call)); 418 419 case NET_NETIF_GET_ADDR: 420 fibril_rwlock_read_lock(&netif_globals.lock); 421 rc = netif_get_addr_message(IPC_GET_DEVICE(call), &address); 422 if (rc == EOK) 423 rc = measured_strings_reply(&address, 1); 424 fibril_rwlock_read_unlock(&netif_globals.lock); 425 return rc; 434 return ERROR_CODE; 426 435 } 427 436 … … 431 440 /** Start the network interface module. 432 441 * 433 * Initialize the client connection serving function, initialize the module, 434 * registers the module service and start the async manager, processing IPC 435 * messages in an infinite loop. 436 * 437 * @param[in] client_connection The client connection processing function. 438 * The module skeleton propagates its own one. 439 * @return EOK on success. 440 * @return Other error codes as defined for each specific module 441 * message function. 442 * Initialize the client connection serving function, initialize 443 * the module, registers the module service and start the async 444 * manager, processing IPC messages in an infinite loop. 445 * 446 * @param[in] client_connection The client connection processing 447 * function. The module skeleton propagates 448 * its own one. 449 * 450 * @return EOK on success. 451 * @return Other error codes as defined for each specific module message 452 * function. 453 * 442 454 */ 443 455 int netif_module_start_standalone(async_client_conn_t client_connection) 444 456 { 445 int rc; 446 447 rc = netif_init_module(client_connection); 448 if (rc != EOK) 449 return rc; 457 ERROR_DECLARE; 458 459 ERROR_PROPAGATE(netif_init_module(client_connection)); 450 460 451 461 async_manager();
Note:
See TracChangeset
for help on using the changeset viewer.
