Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/netif/netif.c

    raadf01e r21580dd  
    6464extern netif_globals_t netif_globals;
    6565
    66 DEVICE_MAP_IMPLEMENT(device_map, device_t)
     66DEVICE_MAP_IMPLEMENT( device_map, device_t )
    6767
    6868/** @name Message processing functions
    … …  
    7777 *  @returns ELIMIT if there is another module registered.
    7878 */
    79 int register_message(device_id_t device_id, int phone);
     79int     register_message( device_id_t device_id, int phone );
    8080
    8181/*@}*/
    8282
    83 int netif_probe_req(int netif_phone, device_id_t device_id, int irq, int io){
    84         int result;
    85 
    86         fibril_rwlock_write_lock(&netif_globals.lock);
    87         result = netif_probe_message(device_id, irq, io);
    88         fibril_rwlock_write_unlock(&netif_globals.lock);
    89         return result;
    90 }
    91 
    92 int netif_send_msg(int netif_phone, device_id_t device_id, packet_t packet, services_t sender){
    93         int result;
    94 
    95         fibril_rwlock_write_lock(&netif_globals.lock);
    96         result = netif_send_message(device_id, packet, sender);
    97         fibril_rwlock_write_unlock(&netif_globals.lock);
    98         return result;
    99 }
    100 
    101 int netif_start_req(int netif_phone, device_id_t device_id){
    102         ERROR_DECLARE;
    103 
    104         device_ref device;
    105         int result;
    106         int phone;
    107 
    108         fibril_rwlock_write_lock(&netif_globals.lock);
    109         if(ERROR_OCCURRED(find_device(device_id, &device))){
    110                 fibril_rwlock_write_unlock(&netif_globals.lock);
     83int     netif_probe_req( int netif_phone, device_id_t device_id, int irq, int io ){
     84        int     result;
     85
     86        fibril_rwlock_write_lock( & netif_globals.lock );
     87        result = netif_probe_message( device_id, irq, io );
     88        fibril_rwlock_write_unlock( & netif_globals.lock );
     89        return result;
     90}
     91
     92int     netif_send_msg( int netif_phone, device_id_t device_id, packet_t packet, services_t sender ){
     93        int     result;
     94
     95        fibril_rwlock_write_lock( & netif_globals.lock );
     96        result = netif_send_message( device_id, packet, sender );
     97        fibril_rwlock_write_unlock( & netif_globals.lock );
     98        return result;
     99}
     100
     101int     netif_start_req( int netif_phone, device_id_t device_id ){
     102        ERROR_DECLARE;
     103
     104        device_ref      device;
     105        int     result;
     106        int     phone;
     107
     108        fibril_rwlock_write_lock( & netif_globals.lock );
     109        if( ERROR_OCCURRED( find_device( device_id, & device ))){
     110                fibril_rwlock_write_unlock( & netif_globals.lock );
    111111                return ERROR_CODE;
    112112        }
    113         result = netif_start_message(device);
    114         if(result > NETIF_NULL){
     113        result = netif_start_message( device );
     114        if( result > NETIF_NULL ){
    115115                phone = device->nil_phone;
    116                 fibril_rwlock_write_unlock(&netif_globals.lock);
    117                 nil_device_state_msg(phone, device_id, result);
     116                fibril_rwlock_write_unlock( & netif_globals.lock );
     117                nil_device_state_msg( phone, device_id, result );
    118118                return EOK;
    119119        }else{
    120                 fibril_rwlock_write_unlock(&netif_globals.lock);
    121         }
    122         return result;
    123 }
    124 
    125 int netif_stop_req(int netif_phone, device_id_t device_id){
    126         ERROR_DECLARE;
    127 
    128         device_ref device;
    129         int result;
    130         int phone;
    131 
    132         fibril_rwlock_write_lock(&netif_globals.lock);
    133         if(ERROR_OCCURRED(find_device(device_id, &device))){
    134                 fibril_rwlock_write_unlock(&netif_globals.lock);
     120                fibril_rwlock_write_unlock( & netif_globals.lock );
     121        }
     122        return result;
     123}
     124
     125int     netif_stop_req( int netif_phone, device_id_t device_id ){
     126        ERROR_DECLARE;
     127
     128        device_ref      device;
     129        int     result;
     130        int     phone;
     131
     132        fibril_rwlock_write_lock( & netif_globals.lock );
     133        if( ERROR_OCCURRED( find_device( device_id, & device ))){
     134                fibril_rwlock_write_unlock( & netif_globals.lock );
    135135                return ERROR_CODE;
    136136        }
    137         result = netif_stop_message(device);
    138         if(result > NETIF_NULL){
     137        result = netif_stop_message( device );
     138        if( result > NETIF_NULL ){
    139139                phone = device->nil_phone;
    140                 fibril_rwlock_write_unlock(&netif_globals.lock);
    141                 nil_device_state_msg(phone, device_id, result);
     140                fibril_rwlock_write_unlock( & netif_globals.lock );
     141                nil_device_state_msg( phone, device_id, result );
    142142                return EOK;
    143143        }else{
    144                 fibril_rwlock_write_unlock(&netif_globals.lock);
    145         }
    146         return result;
    147 }
    148 
    149 int netif_stats_req(int netif_phone, device_id_t device_id, device_stats_ref stats){
     144                fibril_rwlock_write_unlock( & netif_globals.lock );
     145        }
     146        return result;
     147}
     148
     149int     netif_stats_req( int netif_phone, device_id_t device_id, device_stats_ref stats ){
    150150        int res;
    151151
    152         fibril_rwlock_read_lock(&netif_globals.lock);
    153         res = netif_get_device_stats(device_id, stats);
    154         fibril_rwlock_read_unlock(&netif_globals.lock);
     152        fibril_rwlock_read_lock( & netif_globals.lock );
     153        res = netif_get_device_stats( device_id, stats );
     154        fibril_rwlock_read_unlock( & netif_globals.lock );
    155155        return res;
    156156}
    157157
    158 int netif_get_addr_req(int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data){
    159         ERROR_DECLARE;
    160 
    161         measured_string_t translation;
    162 
    163         if(!(address && data)){
    164                 return EBADMEM;
    165         }
    166         fibril_rwlock_read_lock(&netif_globals.lock);
    167         if(! ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))){
    168                 *address = measured_string_copy(&translation);
    169                 ERROR_CODE = (*address) ? EOK : ENOMEM;
    170         }
    171         fibril_rwlock_read_unlock(&netif_globals.lock);
    172         *data = (** address).value;
     158int     netif_get_addr_req( int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data ){
     159        ERROR_DECLARE;
     160
     161        measured_string_t       translation;
     162
     163        if( !( address && data )) return EBADMEM;
     164        fibril_rwlock_read_lock( & netif_globals.lock );
     165        if( ! ERROR_OCCURRED( netif_get_addr_message( device_id, & translation ))){
     166                * address = measured_string_copy( & translation );
     167                ERROR_CODE = ( * address ) ? EOK : ENOMEM;
     168        }
     169        fibril_rwlock_read_unlock( & netif_globals.lock );
     170        * data = ( ** address ).value;
    173171        return ERROR_CODE;
    174172}
    175173
    176 int netif_bind_service(services_t service, device_id_t device_id, services_t me, async_client_conn_t receiver){
    177         return EOK;
    178 }
    179 
    180 int find_device(device_id_t device_id, device_ref * device){
    181         if(! device){
    182                 return EBADMEM;
    183         }
    184         *device = device_map_find(&netif_globals.device_map, device_id);
    185         if(! * device){
    186                 return ENOENT;
    187         }
    188         if((** device).state == NETIF_NULL) return EPERM;
    189         return EOK;
    190 }
    191 
    192 void null_device_stats(device_stats_ref stats){
    193         bzero(stats, sizeof(device_stats_t));
    194 }
    195 
    196 int register_message(device_id_t device_id, int phone){
    197         ERROR_DECLARE;
    198 
    199         device_ref device;
    200 
    201         ERROR_PROPAGATE(find_device(device_id, &device));
    202         if(device->nil_phone > 0){
    203                 return ELIMIT;
    204         }
     174int netif_bind_service( services_t service, device_id_t device_id, services_t me, async_client_conn_t receiver ){
     175        return EOK;
     176}
     177
     178int find_device( device_id_t device_id, device_ref * device ){
     179        if( ! device ) return EBADMEM;
     180        * device = device_map_find( & netif_globals.device_map, device_id );
     181        if( ! * device ) return ENOENT;
     182        if(( ** device ).state == NETIF_NULL ) return EPERM;
     183        return EOK;
     184}
     185
     186void null_device_stats( device_stats_ref stats ){
     187        bzero( stats, sizeof( device_stats_t ));
     188}
     189
     190int register_message( device_id_t device_id, int phone ){
     191        ERROR_DECLARE;
     192
     193        device_ref      device;
     194
     195        ERROR_PROPAGATE( find_device( device_id, & device ));
     196        if( device->nil_phone > 0 ) return ELIMIT;
    205197        device->nil_phone = phone;
    206         printf("New receiver of the device %d registered:\n\tphone\t= %d\n", device->device_id, device->nil_phone);
    207         return EOK;
    208 }
    209 
    210 int netif_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    211         ERROR_DECLARE;
    212 
    213         size_t length;
    214         device_stats_t stats;
    215         packet_t packet;
    216         measured_string_t address;
    217 
    218 //      printf("message %d - %d\n", IPC_GET_METHOD(*call), NET_NETIF_FIRST);
    219         *answer_count = 0;
    220         switch(IPC_GET_METHOD(*call)){
     198        printf( "New receiver of the device %d registered:\n\tphone\t= %d\n", device->device_id, device->nil_phone );
     199        return EOK;
     200}
     201
     202int netif_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
     203        ERROR_DECLARE;
     204
     205        size_t                          length;
     206        device_stats_t          stats;
     207        packet_t                        packet;
     208        measured_string_t       address;
     209
     210//      printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_NETIF_FIRST );
     211        * answer_count = 0;
     212        switch( IPC_GET_METHOD( * call )){
    221213                case IPC_M_PHONE_HUNGUP:
    222214                        return EOK;
    223215                case NET_NETIF_PROBE:
    224                         return netif_probe_req(0, IPC_GET_DEVICE(call), NETIF_GET_IRQ(call), NETIF_GET_IO(call));
     216                        return netif_probe_req( 0, IPC_GET_DEVICE( call ), NETIF_GET_IRQ( call ), NETIF_GET_IO( call ));
    225217                case IPC_M_CONNECT_TO_ME:
    226                         fibril_rwlock_write_lock(&netif_globals.lock);
    227                         ERROR_CODE = register_message(IPC_GET_DEVICE(call), IPC_GET_PHONE(call));
    228                         fibril_rwlock_write_unlock(&netif_globals.lock);
     218                        fibril_rwlock_write_lock( & netif_globals.lock );
     219                        ERROR_CODE = register_message( IPC_GET_DEVICE( call ), IPC_GET_PHONE( call ));
     220                        fibril_rwlock_write_unlock( & netif_globals.lock );
    229221                        return ERROR_CODE;
    230222                case NET_NETIF_SEND:
    231                         ERROR_PROPAGATE(packet_translate(netif_globals.net_phone, &packet, IPC_GET_PACKET(call)));
    232                         return netif_send_msg(0, IPC_GET_DEVICE(call), packet, IPC_GET_SENDER(call));
     223                        ERROR_PROPAGATE( packet_translate( netif_globals.net_phone, & packet, IPC_GET_PACKET( call )));
     224                        return netif_send_msg( 0, IPC_GET_DEVICE( call ), packet, IPC_GET_SENDER( call ));
    233225                case NET_NETIF_START:
    234                         return netif_start_req(0, IPC_GET_DEVICE(call));
     226                        return netif_start_req( 0, IPC_GET_DEVICE( call ));
    235227                case NET_NETIF_STATS:
    236                         fibril_rwlock_read_lock(&netif_globals.lock);
    237                         if(! ERROR_OCCURRED(async_data_read_receive(&callid, &length))){
    238                                 if(length < sizeof(device_stats_t)){
     228                        fibril_rwlock_read_lock( & netif_globals.lock );
     229                        if( ! ERROR_OCCURRED( async_data_read_receive( & callid, & length ))){
     230                                if( length < sizeof( device_stats_t )){
    239231                                        ERROR_CODE = EOVERFLOW;
    240232                                }else{
    241                                         if(! ERROR_OCCURRED(netif_get_device_stats(IPC_GET_DEVICE(call), &stats))){
    242                                                 ERROR_CODE = async_data_read_finalize(callid, &stats, sizeof(device_stats_t));
     233                                        if( ! ERROR_OCCURRED( netif_get_device_stats( IPC_GET_DEVICE( call ), & stats ))){
     234                                                ERROR_CODE = async_data_read_finalize( callid, & stats, sizeof( device_stats_t ));
    243235                                        }
    244236                                }
    245237                        }
    246                         fibril_rwlock_read_unlock(&netif_globals.lock);
     238                        fibril_rwlock_read_unlock( & netif_globals.lock );
    247239                        return ERROR_CODE;
    248240                case NET_NETIF_STOP:
    249                         return netif_stop_req(0, IPC_GET_DEVICE(call));
     241                        return netif_stop_req( 0, IPC_GET_DEVICE( call ));
    250242                case NET_NETIF_GET_ADDR:
    251                         fibril_rwlock_read_lock(&netif_globals.lock);
    252                         if(! ERROR_OCCURRED(netif_get_addr_message(IPC_GET_DEVICE(call), &address))){
    253                                 ERROR_CODE = measured_strings_reply(&address, 1);
     243                        fibril_rwlock_read_lock( & netif_globals.lock );
     244                        if( ! ERROR_OCCURRED( netif_get_addr_message( IPC_GET_DEVICE( call ), & address ))){
     245                                ERROR_CODE = measured_strings_reply( & address, 1 );
    254246                        }
    255                         fibril_rwlock_read_unlock(&netif_globals.lock);
     247                        fibril_rwlock_read_unlock( & netif_globals.lock );
    256248                        return ERROR_CODE;
    257249        }
    258         return netif_specific_message(callid, call, answer, answer_count);
    259 }
    260 
    261 int netif_init_module(async_client_conn_t client_connection){
    262         ERROR_DECLARE;
    263 
    264         async_set_client_connection(client_connection);
    265         netif_globals.net_phone = connect_to_service(SERVICE_NETWORKING);
    266         device_map_initialize(&netif_globals.device_map);
    267         ERROR_PROPAGATE(pm_init());
    268         fibril_rwlock_initialize(&netif_globals.lock);
    269         if(ERROR_OCCURRED(netif_initialize())){
     250        return netif_specific_message( callid, call, answer, answer_count );
     251}
     252
     253int netif_init_module( async_client_conn_t client_connection ){
     254        ERROR_DECLARE;
     255
     256        async_set_client_connection( client_connection );
     257        netif_globals.net_phone = connect_to_service( SERVICE_NETWORKING );
     258        device_map_initialize( & netif_globals.device_map );
     259        ERROR_PROPAGATE( pm_init());
     260        fibril_rwlock_initialize( & netif_globals.lock );
     261        if( ERROR_OCCURRED( netif_initialize())){
    270262                pm_destroy();
    271263                return ERROR_CODE;
    … …  
    274266}
    275267
    276 int netif_run_module(void){
     268int netif_run_module( void ){
    277269        async_manager();
    278270
    … …  
    281273}
    282274
    283 void netif_pq_release(packet_id_t packet_id){
    284         pq_release(netif_globals.net_phone, packet_id);
    285 }
    286 
    287 packet_t netif_packet_get_1(size_t content){
    288         return packet_get_1(netif_globals.net_phone, content);
     275void netif_pq_release( packet_id_t packet_id ){
     276        pq_release( netif_globals.net_phone, packet_id );
     277}
     278
     279packet_t netif_packet_get_1( size_t content ){
     280        return packet_get_1( netif_globals.net_phone, content );
    289281}
    290282
Note: See TracChangeset for help on using the changeset viewer.