Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4581 → Rev 4582

/branches/network/uspace/srv/net/inet.c
37,6 → 37,7
#include <errno.h>
#include <mem.h>
#include <stdio.h>
#include <string.h>
 
#include "include/in.h"
#include "include/in6.h"
/branches/network/uspace/srv/net/nil/eth/eth.c
39,6 → 39,7
#include <malloc.h>
#include <mem.h>
#include <stdio.h>
#include <string.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
267,12 → 268,12
eth_proto_ref proto;
 
//TODO clear device if off?
rwlock_read_lock( & eth_globals.protos_lock );
fibril_rwlock_read_lock( & eth_globals.protos_lock );
for( index = eth_protos_count( & eth_globals.protos ) - 1; index >= 0; -- index ){
proto = eth_protos_get_index( & eth_globals.protos, index );
if( proto && proto->phone ) il_device_state_msg( proto->phone, device_id, state, proto->service );
}
rwlock_read_unlock( & eth_globals.protos_lock );
fibril_rwlock_read_unlock( & eth_globals.protos_lock );
return EOK;
}
 
279,10 → 280,10
int nil_initialize( int net_phone ){
ERROR_DECLARE;
 
rwlock_initialize( & eth_globals.devices_lock );
rwlock_initialize( & eth_globals.protos_lock );
rwlock_write_lock( & eth_globals.devices_lock );
rwlock_write_lock( & eth_globals.protos_lock );
fibril_rwlock_initialize( & eth_globals.devices_lock );
fibril_rwlock_initialize( & eth_globals.protos_lock );
fibril_rwlock_write_lock( & eth_globals.devices_lock );
fibril_rwlock_write_lock( & eth_globals.protos_lock );
eth_globals.net_phone = net_phone;
eth_globals.broadcast_addr = measured_string_create_bulk( "\xFF\xFF\xFF\xFF\xFF\xFF", CONVERT_SIZE( uint8_t, char, ETH_ADDR ));
if( ! eth_globals.broadcast_addr ) return ENOMEM;
291,8 → 292,8
eth_devices_destroy( & eth_globals.devices );
return ERROR_CODE;
}
rwlock_write_unlock( & eth_globals.protos_lock );
rwlock_write_unlock( & eth_globals.devices_lock );
fibril_rwlock_write_unlock( & eth_globals.protos_lock );
fibril_rwlock_write_unlock( & eth_globals.devices_lock );
return EOK;
}
 
306,13 → 307,13
size_t count = sizeof( names ) / sizeof( measured_string_t );
char * data;
 
rwlock_write_lock( & eth_globals.devices_lock );
fibril_rwlock_write_lock( & eth_globals.devices_lock );
// an existing device?
device = eth_devices_find( & eth_globals.devices, device_id );
if( device ){
if( device->service != service ){
printf( "Device %d already exists\n", device->device_id );
rwlock_write_unlock( & eth_globals.devices_lock );
fibril_rwlock_write_unlock( & eth_globals.devices_lock );
return EEXIST;
}else{
// update mtu
329,7 → 330,7
device->mtu = (( mtu > 0 ) && ( mtu <= ETH_MAX_TAGGED_CONTENT( device->flags ))) ? mtu : ETH_MAX_TAGGED_CONTENT( device->flags );
configuration = & names[ 0 ];
if( ERROR_OCCURRED( net_get_device_conf_req( eth_globals.net_phone, device->device_id, & configuration, count, & data ))){
rwlock_write_unlock( & eth_globals.devices_lock );
fibril_rwlock_write_unlock( & eth_globals.devices_lock );
free( device );
return ERROR_CODE;
}
351,13 → 352,13
// bind the device driver
device->phone = netif_bind_service( device->service, device->device_id, SERVICE_ETHERNET, eth_receiver );
if( device->phone < 0 ){
rwlock_write_unlock( & eth_globals.devices_lock );
fibril_rwlock_write_unlock( & eth_globals.devices_lock );
free( device );
return device->phone;
}
// get hardware address
if( ERROR_OCCURRED( netif_get_addr( device->phone, device->device_id, & device->addr, & device->addr_data ))){
rwlock_write_unlock( & eth_globals.devices_lock );
fibril_rwlock_write_unlock( & eth_globals.devices_lock );
free( device );
return ERROR_CODE;
}
364,7 → 365,7
// add to the cache
index = eth_devices_add( & eth_globals.devices, device->device_id, device );
if( index < 0 ){
rwlock_write_unlock( & eth_globals.devices_lock );
fibril_rwlock_write_unlock( & eth_globals.devices_lock );
free( device->addr );
free( device->addr_data );
free( device );
372,7 → 373,7
}
printf( "New device registered:\n\tid\t= %d\n\tservice\t= %d\n\tMTU\t= %d\n\taddress\t= %X:%X:%X:%X:%X:%X\n\tflags\t= 0x%x\n", device->device_id, device->service, device->mtu, device->addr_data[ 0 ], device->addr_data[ 1 ], device->addr_data[ 2 ], device->addr_data[ 3 ], device->addr_data[ 4 ], device->addr_data[ 5 ], device->flags );
}
rwlock_write_unlock( & eth_globals.devices_lock );
fibril_rwlock_write_unlock( & eth_globals.devices_lock );
return EOK;
}
 
444,15 → 445,15
eth_device_ref device;
int flags;
 
rwlock_read_lock( & eth_globals.devices_lock );
fibril_rwlock_read_lock( & eth_globals.devices_lock );
device = eth_devices_find( & eth_globals.devices, device_id );
if( ! device ){
rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
return ENOENT;
}
flags = device->flags;
rwlock_read_unlock( & eth_globals.devices_lock );
rwlock_read_lock( & eth_globals.protos_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_lock( & eth_globals.protos_lock );
do{
next = pq_detach( packet );
proto = eth_process_packet( flags, packet );
464,7 → 465,7
}
packet = next;
}while( packet );
rwlock_read_unlock( & eth_globals.protos_lock );
fibril_rwlock_read_unlock( & eth_globals.protos_lock );
return EOK;
}
 
472,14 → 473,14
eth_device_ref device;
 
if( !( addr_len && prefix && content && suffix )) return EBADMEM;
rwlock_read_lock( & eth_globals.devices_lock );
fibril_rwlock_read_lock( & eth_globals.devices_lock );
device = eth_devices_find( & eth_globals.devices, device_id );
if( ! device ){
rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
return ENOENT;
}
* content = device->mtu;
rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
* addr_len = ETH_ADDR;
* prefix = ETH_PREFIX;
* suffix = ETH_MIN_CONTENT + ETH_SUFFIX;
493,14 → 494,14
if( type == ETH_BROADCAST_ADDR ){
* address = eth_globals.broadcast_addr;
}else{
rwlock_read_lock( & eth_globals.devices_lock );
fibril_rwlock_read_lock( & eth_globals.devices_lock );
device = eth_devices_find( & eth_globals.devices, device_id );
if( ! device ){
rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
return ENOENT;
}
* address = device->addr;
rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
}
return ( * address ) ? EOK : ENOENT;
}
512,16 → 513,16
 
protocol = protocol_map( SERVICE_ETHERNET, service );
if( ! protocol ) return ENOENT;
rwlock_write_lock( & eth_globals.protos_lock );
fibril_rwlock_write_lock( & eth_globals.protos_lock );
proto = eth_protos_find( & eth_globals.protos, protocol );
if( proto ){
proto->phone = phone;
rwlock_write_unlock( & eth_globals.protos_lock );
fibril_rwlock_write_unlock( & eth_globals.protos_lock );
return EOK;
}else{
proto = ( eth_proto_ref ) malloc( sizeof( eth_proto_t ));
if( ! proto ){
rwlock_write_unlock( & eth_globals.protos_lock );
fibril_rwlock_write_unlock( & eth_globals.protos_lock );
return ENOMEM;
}
proto->service = service;
529,13 → 530,13
proto->phone = phone;
index = eth_protos_add( & eth_globals.protos, protocol, proto );
if( index < 0 ){
rwlock_write_unlock( & eth_globals.protos_lock );
fibril_rwlock_write_unlock( & eth_globals.protos_lock );
free( proto );
return index;
}
}
printf( "New protocol registered:\n\tprotocol\t= 0x%x\n\tservice\t= %d\n\tphone\t= %d\n", proto->protocol, proto->service, proto->phone );
rwlock_write_unlock( & eth_globals.protos_lock );
fibril_rwlock_write_unlock( & eth_globals.protos_lock );
return EOK;
}
 
608,10 → 609,10
pq_release( eth_globals.net_phone, packet_get_id( packet ));
return EINVAL;
}
rwlock_read_lock( & eth_globals.devices_lock );
fibril_rwlock_read_lock( & eth_globals.devices_lock );
device = eth_devices_find( & eth_globals.devices, device_id );
if( ! device ){
rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
return ENOENT;
}
// process packet queue
631,7 → 632,7
if( packet ){
netif_send_msg( device->phone, device_id, packet, SERVICE_ETHERNET );
}
rwlock_read_unlock( & eth_globals.devices_lock );
fibril_rwlock_read_unlock( & eth_globals.devices_lock );
return EOK;
}
 
/branches/network/uspace/srv/net/nil/eth/eth.h
37,7 → 37,7
#ifndef __NET_ETH_H__
#define __NET_ETH_H__
 
#include <rwlock.h>
#include <fibril_sync.h>
#include <ipc/services.h>
 
#include "../../include/device.h"
130,13 → 130,13
int net_phone;
/** Safety lock for devices.
*/
rwlock_t devices_lock;
fibril_rwlock_t devices_lock;
/** All known Ethernet devices.
*/
eth_devices_t devices;
/** Safety lock for protocols.
*/
rwlock_t protos_lock;
fibril_rwlock_t protos_lock;
/** Protocol map.
* Service phone map for each protocol.
*/
/branches/network/uspace/srv/net/structures/packet/packet.c
38,7 → 38,7
#include <errno.h>
#include <malloc.h>
#include <mem.h>
#include <rwlock.h>
#include <fibril_sync.h>
//#include <stdio.h>
#include <unistd.h>
 
90,7 → 90,7
static struct{
/** Safety lock.
*/
rwlock_t lock;
fibril_rwlock_t lock;
/** Packet map.
*/
gpm_t packet_map;
106,10 → 106,10
int pm_init( void ){
ERROR_DECLARE;
 
rwlock_initialize( & pm_globals.lock );
rwlock_write_lock( & pm_globals.lock );
fibril_rwlock_initialize( & pm_globals.lock );
fibril_rwlock_write_lock( & pm_globals.lock );
ERROR_PROPAGATE( gpm_initialize( & pm_globals.packet_map ));
rwlock_write_unlock( & pm_globals.lock );
fibril_rwlock_write_unlock( & pm_globals.lock );
return EOK;
}
 
118,18 → 118,18
packet_t packet;
 
if( ! packet_id ) return NULL;
rwlock_read_lock( & pm_globals.lock );
fibril_rwlock_read_lock( & pm_globals.lock );
if( packet_id > PACKET_MAP_SIZE * gpm_count( & pm_globals.packet_map )){
rwlock_read_unlock( & pm_globals.lock );
fibril_rwlock_read_unlock( & pm_globals.lock );
return NULL;
}
map = gpm_get_index( & pm_globals.packet_map, PACKET_MAP_PAGE( packet_id ));
if( ! map ){
rwlock_read_unlock( & pm_globals.lock );
fibril_rwlock_read_unlock( & pm_globals.lock );
return NULL;
}
packet = ( * map )[ PACKET_MAP_INDEX( packet_id ) ];
rwlock_read_unlock( & pm_globals.lock );
fibril_rwlock_read_unlock( & pm_globals.lock );
return packet;
}
 
139,7 → 139,7
packet_map_ref map;
 
if( ! packet_is_valid( packet )) return EINVAL;
rwlock_write_lock( & pm_globals.lock );
fibril_rwlock_write_lock( & pm_globals.lock );
if( PACKET_MAP_PAGE( packet->packet_id ) < gpm_count( & pm_globals.packet_map )){
map = gpm_get_index( & pm_globals.packet_map, PACKET_MAP_PAGE( packet->packet_id ));
}else{
146,12 → 146,12
do{
map = ( packet_map_ref ) malloc( sizeof( packet_map_t ));
if( ! map ){
rwlock_write_unlock( & pm_globals.lock );
fibril_rwlock_write_unlock( & pm_globals.lock );
return ENOMEM;
}
bzero( map, sizeof( packet_map_t ));
if(( ERROR_CODE = gpm_add( & pm_globals.packet_map, map )) < 0 ){
rwlock_write_unlock( & pm_globals.lock );
fibril_rwlock_write_unlock( & pm_globals.lock );
free( map );
return ERROR_CODE;
}
158,7 → 158,7
}while( PACKET_MAP_PAGE( packet->packet_id ) >= gpm_count( & pm_globals.packet_map ));
}
( * map )[ PACKET_MAP_INDEX( packet->packet_id ) ] = packet;
rwlock_write_unlock( & pm_globals.lock );
fibril_rwlock_write_unlock( & pm_globals.lock );
return EOK;
}
 
168,7 → 168,7
packet_map_ref map;
packet_t packet;
 
rwlock_write_lock( & pm_globals.lock );
fibril_rwlock_write_lock( & pm_globals.lock );
count = gpm_count( & pm_globals.packet_map );
while( count > 0 ){
map = gpm_get_index( & pm_globals.packet_map, count - 1 );
/branches/network/uspace/srv/net/structures/packet/packet_server.c
37,7 → 37,7
#include <align.h>
#include <async.h>
#include <errno.h>
#include <futex.h>
#include <fibril_sync.h>
//#include <stdio.h>
#include <unistd.h>
 
72,7 → 72,7
static struct{
/** Safety lock.
*/
futex_t lock;
fibril_mutex_t lock;
/** Free packet queues.
*/
packet_t free[ FREE_QUEUES_COUNT ];
85,7 → 85,7
*/
unsigned int count;
} ps_globals = {
{ 1 },
{ .counter = 1, .waiters = { .prev = & ps_globals.lock.waiters, .next = & ps_globals.lock.waiters, }},
{ NULL, NULL, NULL, NULL, NULL, NULL, NULL },
{ PAGE_SIZE, PAGE_SIZE * 2, PAGE_SIZE * 4, PAGE_SIZE * 8, PAGE_SIZE * 16, PAGE_SIZE * 32, PAGE_SIZE * 64 },
0
208,9 → 208,9
 
packet = pm_find( packet_id );
if( ! packet_is_valid( packet )) return ENOENT;
futex_down( & ps_globals.lock );
fibril_mutex_lock( & ps_globals.lock );
pq_destroy( packet, packet_release );
futex_up( & ps_globals.lock );
fibril_mutex_unlock( & ps_globals.lock );
return EOK;
}
 
227,7 → 227,7
size_t length;
 
length = ALIGN_UP( sizeof( struct packet ) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE );
futex_down( & ps_globals.lock );
fibril_mutex_lock( & ps_globals.lock );
for( index = 0; index < FREE_QUEUES_COUNT - 1; ++ index ){
if( length <= ps_globals.sizes[ index ] ){
packet = ps_globals.free[ index ];
241,13 → 241,13
pq_detach( packet );
}
packet_init( packet, addr_len, max_prefix, max_content, max_suffix );
futex_up( & ps_globals.lock );
fibril_mutex_unlock( & ps_globals.lock );
return packet;
}
}
}
packet = packet_create( length, addr_len, max_prefix, max_content, max_suffix );
futex_up( & ps_globals.lock );
fibril_mutex_unlock( & ps_globals.lock );
return packet;
}
 
/branches/network/uspace/srv/net/net/net.c
40,6 → 40,7
#include <errno.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
/branches/network/uspace/srv/net/socket/socket_client.c
38,7 → 38,7
 
#include <assert.h>
#include <async.h>
//#include <fibril_sync.h>
#include <fibril_sync.h>
 
#include <ipc/services.h>
 
62,11 → 62,11
services_t service;
int max_content;
int received;
// fibril_mutex_t receive_lock;
// fibril_condvar_t receive_signal;
fibril_mutex_t receive_lock;
fibril_condvar_t receive_signal;
int accepted;
// fibril_mutex_t accept_lock;
// fibril_condvar_t accept_signal;
fibril_mutex_t accept_lock;
fibril_condvar_t accept_signal;
};
 
INT_MAP_DECLARE( sockets, socket_t );
118,10 → 118,10
socket->service = service;
socket->received = 0;
socket->accepted = 0;
// fibril_mutex_initialize( & socket->receive_lock );
// fibril_condvar_initialize( & socket->receive_signal );
// fibril_mutex_initialize( & socket->accept_lock );
// fibril_condvar_initialize( & socket->accept_signal );
fibril_mutex_initialize( & socket->receive_lock );
fibril_condvar_initialize( & socket->receive_signal );
fibril_mutex_initialize( & socket->accept_lock );
fibril_condvar_initialize( & socket->accept_signal );
}
 
void socket_connection( ipc_callid_t iid, ipc_call_t * icall ){
142,10 → 142,10
ERROR_CODE = ENOTSOCK;
break;
}
// fibril_mutex_lock( & socket->receive_lock );
fibril_mutex_lock( & socket->receive_lock );
++ socket->received;
// fibril_condvar_signal( & socket->receive_signal );
// fibril_mutex_unlock( & socket->receive_lock );
fibril_condvar_signal( & socket->receive_signal );
fibril_mutex_unlock( & socket->receive_lock );
ERROR_CODE = EOK;
break;
case NET_SOCKET_ACCEPTED:
154,7 → 154,7
ERROR_CODE = ENOTSOCK;
break;
}
// fibril_mutex_lock( & socket->accept_lock );
fibril_mutex_lock( & socket->accept_lock );
new_socket = ( socket_ref ) malloc( sizeof( socket_t ));
if( ! new_socket ){
ERROR_CODE = ENOMEM;
165,8 → 165,8
break;
}
++ socket->accepted;
// fibril_condvar_signal( & socket->accept_signal );
// fibril_mutex_unlock( & socket->accept_lock );
fibril_condvar_signal( & socket->accept_signal );
fibril_mutex_unlock( & socket->accept_lock );
break;
/* case NET_SOCKET_MTU:
socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( & call ));
277,9 → 277,9
if( ! addrlen ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// fibril_mutex_lock( & socket->accept_lock );
fibril_mutex_lock( & socket->accept_lock );
while( socket->accepted <= 0 ){
// fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
}
message_id = async_send_3( socket->phone, NET_SOCKET_ACCEPT, socket->socket_id, 0, socket->service, NULL );
ipc_data_read_start( socket->phone, cliaddr, * addrlen );
287,7 → 287,7
if( result > 0 ){
-- socket->accepted;
}
// fibril_mutex_unlock( & socket->accept_lock );
fibril_mutex_unlock( & socket->accept_lock );
return ( int ) result;
}
 
335,9 → 335,9
if( ! datalength ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// fibril_mutex_lock( & socket->receive_lock );
fibril_mutex_lock( & socket->receive_lock );
while( socket->received <= 0 ){
// fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
}
message_id = async_send_3( socket->phone, NET_SOCKET_RECV, socket->socket_id, flags, socket->service, NULL );
ipc_data_read_start( socket->phone, data, datalength );
345,7 → 345,7
if( result > 0 ){
-- socket->received;
}
// fibril_mutex_unlock( & socket->receive_lock );
fibril_mutex_unlock( & socket->receive_lock );
return ( int ) result;
}
 
360,9 → 360,9
if( ! datalength ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// fibril_mutex_lock( & socket->receive_lock );
fibril_mutex_lock( & socket->receive_lock );
while( socket->received <= 0 ){
// fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
}
message_id = async_send_3( socket->phone, NET_SOCKET_RECVFROM, socket->socket_id, flags, socket->service, NULL );
if( ipc_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK ){
372,7 → 372,7
if( result > 0 ){
-- socket->received;
}
// fibril_mutex_unlock( & socket->receive_lock );
fibril_mutex_unlock( & socket->receive_lock );
return ( int ) result;
}
 
/branches/network/uspace/srv/net/Makefile.module
38,7 → 38,7
CHECK_CFLAGS = -fsyntax-only -Wextra -Wno-div-by-zero -Wsystem-headers -Wfloat-equal -Wdeclaration-after-statement -Wundef -Wno-endif-labels -Wshadow -Wlarger-than-1500 -Wpointer-arith -Wbad-function-cast -Wcast-qual -Wcast-align -Wwrite-strings -Wconversion -Wsign-compare -Waggregate-return -Wstrict-prototypes -Wold-style-definition -Wmissing-prototypes -Wmissing-declarations -Wmissing-field-initializers -Wmissing-noreturn -Wmissing-format-attribute -Wno-multichar -Wno-deprecated-declarations -Wpacked -Wpadded -Wredundant-decls -Wnested-externs -Wunreachable-code -Winline -Winvalid-pch -Wlong-long -Wvariadic-macros -Wdisabled-optimization -Wno-pointer-sign
#-Wtraditional
 
LIBS = $(LIBC_PREFIX)/libc.a
LIBS += $(LIBC_PREFIX)/libc.a
 
DEFS += $(NET_DEFS)
 
55,7 → 55,7
-include Makefile.depend
 
clean:
-rm -f $(OUTPUT) $(OUTPUT).map $(addsuffix .map,$(basename $(SOURCES))) $(DISASMS) Makefile.depend
-rm -f $(OUTPUT) $(LIB) $(OUTPUT).map $(addsuffix .map,$(basename $(SOURCES))) $(DISASMS) Makefile.depend
 
depend:
$(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
/branches/network/uspace/srv/net/il/arp/arp.c
38,7 → 38,7
#include <async.h>
#include <malloc.h>
#include <mem.h>
#include <rwlock.h>
#include <fibril_sync.h>
#include <stdio.h>
#include <string.h>
#include <task.h>
140,15 → 140,15
int arp_clear_device_req( int arp_phone, device_id_t device_id ){
arp_device_ref device;
 
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
device = arp_cache_find( & arp_globals.cache, device_id );
if( ! device ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return ENOENT;
}
clear_device( device );
printf( "Device %d cleared\n", device_id );
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EOK;
}
 
156,7 → 156,7
int count;
arp_device_ref device;
 
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
for( count = arp_cache_count( & arp_globals.cache ) - 1; count >= 0; -- count ){
device = arp_cache_get_index( & arp_globals.cache, count );
if( device ){
166,7 → 166,7
}
}
arp_cache_clear( & arp_globals.cache );
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
printf( "Cache cleaned\n" );
return EOK;
}
187,11 → 187,11
int arp_translate_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data ){
measured_string_ref tmp;
 
rwlock_read_lock( & arp_globals.lock );
fibril_rwlock_read_lock( & arp_globals.lock );
tmp = arp_translate_message( device_id, protocol, address );
if( tmp ){
* translation = measured_string_copy( tmp );
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
if( * translation ){
* data = ( ** translation ).value;
return EOK;
199,7 → 199,7
return ENOMEM;
}
}else{
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
return ENOENT;
}
}
207,11 → 207,11
int arp_initialize( async_client_conn_t client_connection ){
ERROR_DECLARE;
 
rwlock_initialize( & arp_globals.lock );
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_initialize( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
arp_globals.client_connection = client_connection;
ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EOK;
}
 
238,13 → 238,13
int index;
hw_type_t hardware;
 
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
// an existing device?
device = arp_cache_find( & arp_globals.cache, device_id );
if( device ){
if( device->service != service ){
printf( "Device %d already exists\n", device->device_id );
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EEXIST;
}
proto = arp_protos_find( & device->protos, protocol );
255,12 → 255,12
proto->addr_data = address->value;
}else{
if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return ERROR_CODE;
}
index = arp_protos_add( & device->protos, proto->service, proto );
if( index < 0 ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( proto );
return index;
}
272,7 → 272,7
// create a new device
device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
if( ! device ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return ENOMEM;
}
device->hardware = hardware;
279,13 → 279,13
device->device_id = device_id;
if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))
|| ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( device );
return ERROR_CODE;
}
index = arp_protos_add( & device->protos, proto->service, proto );
if( index < 0 ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return index;
294,7 → 294,7
// bind the new one
device->phone = bind_service( device->service, ( ipcarg_t ) device->device_id, SERVICE_ARP, 0, arp_globals.client_connection );
if( device->phone < 0 ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return EREFUSED;
301,7 → 301,7
}
// get packet dimensions
if( ERROR_OCCURRED( nil_packet_size_req( device->phone, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return ERROR_CODE;
308,7 → 308,7
}
// get hardware address
if( ERROR_OCCURRED( nil_get_addr( device->phone, device_id, & device->addr, & device->addr_data ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return ERROR_CODE;
315,7 → 315,7
}
// get broadcast address
if( ERROR_OCCURRED( nil_get_broadcast_addr( device->phone, device_id, & device->broadcast_addr, & device->broadcast_data ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( device->addr );
free( device->addr_data );
arp_protos_destroy( & device->protos );
323,7 → 323,7
return ERROR_CODE;
}
if( ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( device->addr );
free( device->addr_data );
free( device->broadcast_addr );
334,7 → 334,7
}
printf( "New device registered:\n\tid\t= %d\n\ttype\t= 0x%x\n\tservice\t= %d\n\tproto\t= %d\n", device->device_id, device->hardware, device->service, protocol );
}
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EOK;
}
 
488,16 → 488,16
return ERROR_CODE;
case NET_ARP_TRANSLATE:
ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
rwlock_read_lock( & arp_globals.lock );
fibril_rwlock_read_lock( & arp_globals.lock );
translation = arp_translate_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), address );
free( address );
free( data );
if( ! translation ){
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
return ENOENT;
}
ERROR_CODE = measured_strings_reply( translation, 1 );
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
return ERROR_CODE;
case NET_ARP_CLEAR_DEVICE:
return arp_clear_device_req( 0, IPC_GET_DEVICE( call ));
508,7 → 508,7
return EOK;
case NET_IL_RECEIVED:
if( ! ERROR_OCCURRED( packet_translate( arp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
rwlock_read_lock( & arp_globals.lock );
fibril_rwlock_read_lock( & arp_globals.lock );
do{
next = pq_detach( packet );
ERROR_CODE = arp_receive_message( IPC_GET_DEVICE( call ), packet );
515,7 → 515,7
if( ERROR_CODE != 1 ) pq_release( arp_globals.net_phone, packet_get_id( packet ));
packet = next;
}while( packet );
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
}
return ERROR_CODE;
}
/branches/network/uspace/srv/net/il/arp/arp.h
37,7 → 37,7
#ifndef __NET_ARP_H__
#define __NET_ARP_H__
 
#include <rwlock.h>
#include <fibril_sync.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
164,7 → 164,7
int net_phone;
/** Safety lock.
*/
rwlock_t lock;
fibril_rwlock_t lock;
/** ARP address cache.
*/
arp_cache_t cache;
/branches/network/uspace/srv/net/il/ip/ip.c
35,7 → 35,7
 
#include <async.h>
#include <errno.h>
#include <rwlock.h>
#include <fibril_sync.h>
#include <stdio.h>
#include <string.h>
 
146,10 → 146,10
int ip_initialize( async_client_conn_t client_connection ){
ERROR_DECLARE;
 
rwlock_initialize( & ip_globals.lock );
rwlock_write_lock( & ip_globals.lock );
rwlock_initialize( & ip_globals.protos_lock );
rwlock_initialize( & ip_globals.netifs_lock );
fibril_rwlock_initialize( & ip_globals.lock );
fibril_rwlock_write_lock( & ip_globals.lock );
fibril_rwlock_initialize( & ip_globals.protos_lock );
fibril_rwlock_initialize( & ip_globals.netifs_lock );
ip_globals.packet_counter = 0;
ip_globals.gateway.address.s_addr = 0;
ip_globals.gateway.netmask.s_addr = 0;
160,7 → 160,7
ip_globals.client_connection = client_connection;
ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));
rwlock_write_unlock( & ip_globals.lock );
fibril_rwlock_write_unlock( & ip_globals.lock );
return EOK;
}
 
181,9 → 181,9
ip_netif->device_id = device_id;
ip_netif->service = netif;
ip_netif->state = NETIF_STOPPED;
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
ip_routes_destroy( & ip_netif->routes );
free( ip_netif );
return ERROR_CODE;
215,7 → 215,7
printf( "\tdns2\t= %s\n", data );
free( data );
}
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return EOK;
}
 
333,16 → 333,16
*/
ip_netif_ref netif;
 
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
netif->state = state;
// TODO state
printf( "ip - device %d changed state to %d\n\n", device_id, state );
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
// if( netif->arp ){
/* address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
406,15 → 406,15
proto->service = service;
proto->phone = phone;
proto->received_msg = received_msg;
rwlock_write_lock( & ip_globals.protos_lock );
fibril_rwlock_write_lock( & ip_globals.protos_lock );
index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
if( index < 0 ){
rwlock_write_unlock( & ip_globals.protos_lock );
fibril_rwlock_write_unlock( & ip_globals.protos_lock );
free( proto );
return index;
}
printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );
rwlock_write_unlock( & ip_globals.protos_lock );
fibril_rwlock_write_unlock( & ip_globals.protos_lock );
return EOK;
}
 
439,7 → 439,7
pq_release( ip_globals.net_phone, packet_get_id( packet ));
return EINVAL;
}
rwlock_read_lock( & ip_globals.netifs_lock );
fibril_rwlock_read_lock( & ip_globals.netifs_lock );
// device specified?
// dest.s_addr = ntohl( dest.s_addr );
if( device_id > 0 ){
451,7 → 451,7
netif = route ? route->netif : NULL;
}
if( !( netif && route )){
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
pq_release( ip_globals.net_phone, packet_get_id( packet ));
return ENOENT;
}
458,13 → 458,13
// to me?
if( route->address.s_addr == dest->s_addr ){
// TODO loopback deliver
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return ip_deliver_local( -1, packet, ( ip_header_ref ) packet_get_data( packet ));
}
 
src = ip_netif_addr( netif );
if( ! src ){
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
pq_release( ip_globals.net_phone, packet_get_id( packet ));
return ENOENT;
}
471,7 → 471,7
if( ERROR_OCCURRED( ip_send_route( packet, netif, route, src, * dest ))){
pq_release( ip_globals.net_phone, packet_get_id( packet ));
}
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return ERROR_CODE;
}
 
496,7 → 496,7
destination.value = route->gateway.s_addr ? ( char * ) & route->gateway.s_addr : ( char * ) & dest.s_addr;
destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );
if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){
usleep( 200000 );
sleep( 1 );
ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
}
// TODO unreachable
552,10 → 552,10
header->fragment_offset = 0;
if( source ) header->source_address = source->s_addr;
header->destination_address = dest.s_addr;
rwlock_write_lock( & ip_globals.lock );
fibril_rwlock_write_lock( & ip_globals.lock );
++ ip_globals.packet_counter;
header->identification = htons( ip_globals.packet_counter );
rwlock_write_unlock( & ip_globals.lock );
fibril_rwlock_write_unlock( & ip_globals.lock );
header->header_checksum = 0;
// unnecessary for all protocols
header->header_checksum = IP_HEADER_CHECKSUM( header );
603,7 → 603,7
 
if( !( addr_len && prefix && content && suffix )) return EBADMEM;
* content = IP_MAX_CONTENT - IP_PREFIX;
rwlock_read_lock( & ip_globals.netifs_lock );
fibril_rwlock_read_lock( & ip_globals.netifs_lock );
if( device_id < 0 ){
* addr_len = IP_ADDR;
* prefix = 0;
621,7 → 621,7
}else{
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
* addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
628,7 → 628,7
* prefix = netif->prefix + IP_PREFIX;
* suffix = netif->suffix + IP_SUFFIX;
}
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return EOK;
}
 
637,15 → 637,15
ip_netif_ref netif;
int index;
 
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
if( ! route ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOMEM;
}
route->address.s_addr = address.s_addr;
654,7 → 654,7
route->netif = netif;
index = ip_routes_add( & netif->routes, route );
if( index < 0 ) free( route );
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return index;
}
 
695,10 → 695,10
int ip_set_gateway_req( int ip_phone, device_id_t device_id, in_addr_t gateway ){
ip_netif_ref netif;
 
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
ip_globals.gateway.address.s_addr = 0;
705,7 → 705,7
ip_globals.gateway.netmask.s_addr = 0;
ip_globals.gateway.gateway.s_addr = gateway.s_addr;
ip_globals.gateway.netif = netif;
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return EOK;
}
 
915,10 → 915,10
return ENOTSUP;
}else{
ERROR_PROPAGATE( packet_set_addr( packet, ( uint8_t * ) & header->source_address, ( uint8_t * ) & header->destination_address, IP_ADDR ));
rwlock_read_lock( & ip_globals.protos_lock );
fibril_rwlock_read_lock( & ip_globals.protos_lock );
proto = ip_protos_find( & ip_globals.protos, header->protocol );
if( ! proto ){
rwlock_read_unlock( & ip_globals.protos_lock );
fibril_rwlock_read_unlock( & ip_globals.protos_lock );
return ENOENT;
}
if( proto->received_msg ){
926,7 → 926,7
}else{
ERROR_CODE = tl_received_msg( proto->phone, device_id, packet, proto->service );
}
rwlock_read_unlock( & ip_globals.protos_lock );
fibril_rwlock_read_unlock( & ip_globals.protos_lock );
return ERROR_CODE;
}
}
/branches/network/uspace/srv/net/il/ip/ip.h
37,7 → 37,7
#ifndef __NET_IP_H__
#define __NET_IP_H__
 
#include <rwlock.h>
#include <fibril_sync.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
111,14 → 111,14
struct ip_globals{
int net_phone;
ip_netifs_t netifs;
rwlock_t netifs_lock;
fibril_rwlock_t netifs_lock;
ip_protos_t protos;
rwlock_t protos_lock;
fibril_rwlock_t protos_lock;
ip_route_t gateway;
modules_t modules;
async_client_conn_t client_connection;
uint16_t packet_counter;
rwlock_t lock;
fibril_rwlock_t lock;
};
 
#endif
/branches/network/uspace/srv/net/netif/netif.c
37,7 → 37,7
 
#include <async.h>
#include <mem.h>
#include <rwlock.h>
#include <fibril_sync.h>
#include <stdio.h>
 
#include <ipc/ipc.h>
77,9 → 77,9
int netif_probe_req( int netif_phone, device_id_t device_id, int irq, int io ){
int result;
 
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
result = netif_probe_message( device_id, irq, io );
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return result;
}
 
86,9 → 86,9
int netif_send_msg( int netif_phone, device_id_t device_id, packet_t packet, services_t sender ){
int result;
 
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
result = netif_send_message( device_id, packet, sender );
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return result;
}
 
99,19 → 99,19
int result;
int phone;
 
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
if( ERROR_OCCURRED( find_device( device_id, & device ))){
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return ERROR_CODE;
}
result = netif_start_message( device );
if( result > NETIF_NULL ){
phone = device->nil_phone;
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
nil_device_state_msg( phone, device_id, result );
return EOK;
}else{
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
}
return result;
}
123,19 → 123,19
int result;
int phone;
 
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
if( ERROR_OCCURRED( find_device( device_id, & device ))){
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return ERROR_CODE;
}
result = netif_stop_message( device );
if( result > NETIF_NULL ){
phone = device->nil_phone;
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
nil_device_state_msg( phone, device_id, result );
return EOK;
}else{
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
}
return result;
}
146,12 → 146,12
measured_string_t translation;
 
if( !( address && data )) return EBADMEM;
rwlock_read_lock( & netif_globals.lock );
fibril_rwlock_read_lock( & netif_globals.lock );
if( ! ERROR_OCCURRED( netif_get_addr_message( device_id, & translation ))){
* address = measured_string_copy( & translation );
ERROR_CODE = ( * address ) ? EOK : ENOMEM;
}
rwlock_read_unlock( & netif_globals.lock );
fibril_rwlock_read_unlock( & netif_globals.lock );
* data = ( ** address ).value;
return ERROR_CODE;
}
198,16 → 198,16
case IPC_M_PHONE_HUNGUP:
return EOK;
case NET_NETIF_PROBE_AUTO:
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
ERROR_CODE = netif_probe_auto_message();
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return ERROR_CODE;
case NET_NETIF_PROBE:
return netif_probe_req( 0, IPC_GET_DEVICE( call ), NETIF_GET_IRQ( call ), NETIF_GET_IO( call ));
case IPC_M_CONNECT_TO_ME:
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
ERROR_CODE = register_message( IPC_GET_DEVICE( call ), IPC_GET_PHONE( call ));
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return ERROR_CODE;
case NET_NETIF_SEND:
case NET_NIL_SEND:
216,7 → 216,7
case NET_NETIF_START:
return netif_start_req( 0, IPC_GET_DEVICE( call ));
case NET_NETIF_STATS:
rwlock_read_lock( & netif_globals.lock );
fibril_rwlock_read_lock( & netif_globals.lock );
if( ! ERROR_OCCURRED( ipc_data_read_receive( & callid, & length ))){
if( length < sizeof( device_stats_t )){
ERROR_CODE = EOVERFLOW;
226,17 → 226,17
}
}
}
rwlock_read_unlock( & netif_globals.lock );
fibril_rwlock_read_unlock( & netif_globals.lock );
return ERROR_CODE;
case NET_NETIF_STOP:
return netif_stop_req( 0, IPC_GET_DEVICE( call ));
case NET_NETIF_GET_ADDR:
case NET_NIL_ADDR:
rwlock_read_lock( & netif_globals.lock );
fibril_rwlock_read_lock( & netif_globals.lock );
if( ! ERROR_OCCURRED( netif_get_addr_message( IPC_GET_DEVICE( call ), & address ))){
ERROR_CODE = measured_strings_reply( & address, 1 );
}
rwlock_read_unlock( & netif_globals.lock );
fibril_rwlock_read_unlock( & netif_globals.lock );
return ERROR_CODE;
}
return netif_specific_message( callid, call, answer, answer_count );
249,7 → 249,7
netif_globals.net_phone = connect_to_service( SERVICE_NETWORKING );
device_map_initialize( & netif_globals.device_map );
ERROR_PROPAGATE( pm_init());
rwlock_initialize( & netif_globals.lock );
fibril_rwlock_initialize( & netif_globals.lock );
if( ERROR_OCCURRED( netif_initialize())){
pm_destroy();
return ERROR_CODE;
/branches/network/uspace/srv/net/netif/dp8390/dp8390_module.c
145,14 → 145,14
int phone;
 
device_id = IRQ_GET_DEVICE( call );
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
if( find_device( device_id, & device ) != EOK ){
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return;
}
dep = ( dpeth_t * ) device->specific;
if ( dep->de_mode != DEM_ENABLED){
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
return;
}
assert( dep->de_flags & DEF_ENABLED);
164,7 → 164,7
received = dep->received_queue;
phone = device->nil_phone;
dep->received_queue = NULL;
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
// TODO remove debug dump:
uint8_t * data;
data = packet_get_data( received );
171,7 → 171,7
printf( "Receiving packet:\n\tid\t= %d\n\tlength\t= %d\n\tdata\t= %.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX\n\t\t%.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX\n", packet_get_id( received ), packet_get_data_length( received ), data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ], data[ 6 ], data[ 7 ], data[ 8 ], data[ 9 ], data[ 10 ], data[ 11 ], data[ 12 ], data[ 13 ], data[ 14 ], data[ 15 ], data[ 16 ], data[ 17 ], data[ 18 ], data[ 19 ], data[ 20 ], data[ 21 ], data[ 22 ], data[ 23 ], data[ 24 ], data[ 25 ], data[ 26 ], data[ 27 ], data[ 28 ], data[ 29 ], data[ 30 ], data[ 31 ], data[ 32 ], data[ 33 ], data[ 34 ], data[ 35 ], data[ 36 ], data[ 37 ], data[ 38 ], data[ 39 ], data[ 40 ], data[ 41 ], data[ 42 ], data[ 43 ], data[ 44 ], data[ 45 ], data[ 46 ], data[ 47 ], data[ 48 ], data[ 49 ], data[ 50 ], data[ 51 ], data[ 52 ], data[ 53 ], data[ 54 ], data[ 55 ], data[ 56 ], data[ 57 ], data[ 58 ], data[ 59 ] );
nil_received_msg( phone, device_id, received, NULL );
}else{
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
}
ipc_answer_0( iid, EOK );
}
/branches/network/uspace/srv/net/netif/lo/lo.c
37,6 → 37,7
#include <async.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
240,9 → 241,9
next = pq_next( next );
}while( next );
phone = device->nil_phone;
rwlock_write_unlock( & netif_globals.lock );
fibril_rwlock_write_unlock( & netif_globals.lock );
nil_received_msg( phone, device_id, packet, sender );
rwlock_write_lock( & netif_globals.lock );
fibril_rwlock_write_lock( & netif_globals.lock );
return EOK;
}
 
/branches/network/uspace/srv/net/netif/netif.h
40,7 → 40,7
#define __NET_NETIF_H__
 
#include <async.h>
#include <rwlock.h>
#include <fibril_sync.h>
 
#include <ipc/ipc.h>
 
98,7 → 98,7
device_map_t device_map;
/** Safety lock.
*/
rwlock_t lock;
fibril_rwlock_t lock;
};
 
/** Finds the device specific data.