/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. |