Subversion Repositories HelenOS

Rev

Rev 4350 | Rev 4698 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3666 mejdrech 1
/*
3912 mejdrech 2
 * Copyright (c) 2009 Lukas Mejdrech
3666 mejdrech 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
3912 mejdrech 29
/** @addtogroup netif
30
 *  @{
3666 mejdrech 31
 */
32
 
33
/** @file
4350 mejdrech 34
 *  Network interface module skeleton implementation.
35
 *  @see netif.h
3666 mejdrech 36
 */
37
 
38
#include <async.h>
4163 mejdrech 39
#include <mem.h>
4582 mejdrech 40
#include <fibril_sync.h>
3666 mejdrech 41
#include <stdio.h>
3846 mejdrech 42
 
3666 mejdrech 43
#include <ipc/ipc.h>
44
#include <ipc/services.h>
45
 
46
#include "../err.h"
47
#include "../messages.h"
48
#include "../modules.h"
49
 
3886 mejdrech 50
#include "../structures/packet/packet.h"
3901 mejdrech 51
#include "../structures/packet/packet_client.h"
4163 mejdrech 52
#include "../structures/measured_strings.h"
3886 mejdrech 53
 
4243 mejdrech 54
#include "../include/device.h"
4307 mejdrech 55
#include "../include/netif_interface.h"
56
#include "../include/nil_interface.h"
4243 mejdrech 57
 
3666 mejdrech 58
#include "netif.h"
4307 mejdrech 59
#include "netif_messages.h"
60
#include "netif_module.h"
3666 mejdrech 61
 
4350 mejdrech 62
/** Network interface module global data.
63
 */
3666 mejdrech 64
extern netif_globals_t netif_globals;
65
 
3846 mejdrech 66
DEVICE_MAP_IMPLEMENT( device_map, device_t )
3666 mejdrech 67
 
4350 mejdrech 68
/** Registers the device notification receiver, the network interface layer module.
69
 *  @param device_id The device identifier. Input parameter.
70
 *  @param phone The network interface layer module phone. Input parameter.
71
 *  @returns EOK on success.
72
 *  @returns ENOENT if there is no such device.
73
 *  @returns ELIMIT if there is another module registered.
74
 */
3846 mejdrech 75
int register_message( device_id_t device_id, int phone );
3666 mejdrech 76
 
4307 mejdrech 77
int netif_probe_req( int netif_phone, device_id_t device_id, int irq, int io ){
4243 mejdrech 78
    int result;
79
 
4582 mejdrech 80
    fibril_rwlock_write_lock( & netif_globals.lock );
4243 mejdrech 81
    result = netif_probe_message( device_id, irq, io );
4582 mejdrech 82
    fibril_rwlock_write_unlock( & netif_globals.lock );
4243 mejdrech 83
    return result;
84
}
85
 
4307 mejdrech 86
int netif_send_msg( int netif_phone, device_id_t device_id, packet_t packet, services_t sender ){
4243 mejdrech 87
    int result;
88
 
4582 mejdrech 89
    fibril_rwlock_write_lock( & netif_globals.lock );
4261 mejdrech 90
    result = netif_send_message( device_id, packet, sender );
4582 mejdrech 91
    fibril_rwlock_write_unlock( & netif_globals.lock );
4243 mejdrech 92
    return result;
93
}
94
 
4307 mejdrech 95
int netif_start_req( int netif_phone, device_id_t device_id ){
4261 mejdrech 96
    ERROR_DECLARE;
97
 
98
    device_ref  device;
4243 mejdrech 99
    int result;
4261 mejdrech 100
    int phone;
4243 mejdrech 101
 
4582 mejdrech 102
    fibril_rwlock_write_lock( & netif_globals.lock );
4261 mejdrech 103
    if( ERROR_OCCURRED( find_device( device_id, & device ))){
4582 mejdrech 104
        fibril_rwlock_write_unlock( & netif_globals.lock );
4261 mejdrech 105
        return ERROR_CODE;
106
    }
107
    result = netif_start_message( device );
108
    if( result > NETIF_NULL ){
109
        phone = device->nil_phone;
4582 mejdrech 110
        fibril_rwlock_write_unlock( & netif_globals.lock );
4261 mejdrech 111
        nil_device_state_msg( phone, device_id, result );
112
        return EOK;
113
    }else{
4582 mejdrech 114
        fibril_rwlock_write_unlock( & netif_globals.lock );
4261 mejdrech 115
    }
4243 mejdrech 116
    return result;
117
}
118
 
4307 mejdrech 119
int netif_stop_req( int netif_phone, device_id_t device_id ){
4261 mejdrech 120
    ERROR_DECLARE;
121
 
122
    device_ref  device;
4243 mejdrech 123
    int result;
4261 mejdrech 124
    int phone;
4243 mejdrech 125
 
4582 mejdrech 126
    fibril_rwlock_write_lock( & netif_globals.lock );
4261 mejdrech 127
    if( ERROR_OCCURRED( find_device( device_id, & device ))){
4582 mejdrech 128
        fibril_rwlock_write_unlock( & netif_globals.lock );
4261 mejdrech 129
        return ERROR_CODE;
130
    }
131
    result = netif_stop_message( device );
132
    if( result > NETIF_NULL ){
133
        phone = device->nil_phone;
4582 mejdrech 134
        fibril_rwlock_write_unlock( & netif_globals.lock );
4261 mejdrech 135
        nil_device_state_msg( phone, device_id, result );
136
        return EOK;
137
    }else{
4582 mejdrech 138
        fibril_rwlock_write_unlock( & netif_globals.lock );
4261 mejdrech 139
    }
4243 mejdrech 140
    return result;
141
}
142
 
4307 mejdrech 143
int netif_get_addr( int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data ){
4243 mejdrech 144
    ERROR_DECLARE;
145
 
146
    measured_string_t   translation;
147
 
4261 mejdrech 148
    if( !( address && data )) return EBADMEM;
4582 mejdrech 149
    fibril_rwlock_read_lock( & netif_globals.lock );
4243 mejdrech 150
    if( ! ERROR_OCCURRED( netif_get_addr_message( device_id, & translation ))){
4271 mejdrech 151
        * address = measured_string_copy( & translation );
152
        ERROR_CODE = ( * address ) ? EOK : ENOMEM;
4243 mejdrech 153
    }
4582 mejdrech 154
    fibril_rwlock_read_unlock( & netif_globals.lock );
4307 mejdrech 155
    * data = ( ** address ).value;
4243 mejdrech 156
    return ERROR_CODE;
157
}
158
 
4307 mejdrech 159
int netif_bind_service( services_t service, device_id_t device_id, services_t me, async_client_conn_t receiver ){
160
    return EOK;
161
}
162
 
3846 mejdrech 163
int find_device( device_id_t device_id, device_ref * device ){
4163 mejdrech 164
    if( ! device ) return EBADMEM;
3846 mejdrech 165
    * device = device_map_find( & netif_globals.device_map, device_id );
3666 mejdrech 166
    if( ! * device ) return ENOENT;
3685 mejdrech 167
    if(( ** device ).state == NETIF_NULL ) return EPERM;
3666 mejdrech 168
    return EOK;
169
}
170
 
3846 mejdrech 171
void null_device_stats( device_stats_ref stats ){
4163 mejdrech 172
    bzero( stats, sizeof( device_stats_t ));
3666 mejdrech 173
}
174
 
3846 mejdrech 175
int register_message( device_id_t device_id, int phone ){
3666 mejdrech 176
    ERROR_DECLARE;
177
 
3846 mejdrech 178
    device_ref  device;
179
 
180
    ERROR_PROPAGATE( find_device( device_id, & device ));
4163 mejdrech 181
    if( device->nil_phone > 0 ) return ELIMIT;
3846 mejdrech 182
    device->nil_phone = phone;
4307 mejdrech 183
    printf( "New receiver of the device %d registered:\n\tphone\t= %d\n", device->device_id, device->nil_phone );
3846 mejdrech 184
    return EOK;
185
}
186
 
187
int netif_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
188
    ERROR_DECLARE;
189
 
4163 mejdrech 190
    size_t              length;
4192 mejdrech 191
    device_stats_t      stats;
4163 mejdrech 192
    packet_t            packet;
4192 mejdrech 193
    measured_string_t   address;
3666 mejdrech 194
 
4307 mejdrech 195
//  printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_NETIF_FIRST );
3846 mejdrech 196
    * answer_count = 0;
197
    switch( IPC_GET_METHOD( * call )){
3666 mejdrech 198
        case IPC_M_PHONE_HUNGUP:
199
            return EOK;
200
        case NET_NETIF_PROBE_AUTO:
4582 mejdrech 201
            fibril_rwlock_write_lock( & netif_globals.lock );
4243 mejdrech 202
            ERROR_CODE = netif_probe_auto_message();
4582 mejdrech 203
            fibril_rwlock_write_unlock( & netif_globals.lock );
4192 mejdrech 204
            return ERROR_CODE;
3666 mejdrech 205
        case NET_NETIF_PROBE:
4307 mejdrech 206
            return netif_probe_req( 0, IPC_GET_DEVICE( call ), NETIF_GET_IRQ( call ), NETIF_GET_IO( call ));
3846 mejdrech 207
        case IPC_M_CONNECT_TO_ME:
4582 mejdrech 208
            fibril_rwlock_write_lock( & netif_globals.lock );
4261 mejdrech 209
            ERROR_CODE = register_message( IPC_GET_DEVICE( call ), IPC_GET_PHONE( call ));
4582 mejdrech 210
            fibril_rwlock_write_unlock( & netif_globals.lock );
4192 mejdrech 211
            return ERROR_CODE;
3666 mejdrech 212
        case NET_NETIF_SEND:
4261 mejdrech 213
        case NET_NIL_SEND:
4307 mejdrech 214
            ERROR_PROPAGATE( packet_translate( netif_globals.net_phone, & packet, IPC_GET_PACKET( call )));
215
            return netif_send_msg( 0, IPC_GET_DEVICE( call ), packet, IPC_GET_SENDER( call ));
3666 mejdrech 216
        case NET_NETIF_START:
4307 mejdrech 217
            return netif_start_req( 0, IPC_GET_DEVICE( call ));
3666 mejdrech 218
        case NET_NETIF_STATS:
4582 mejdrech 219
            fibril_rwlock_read_lock( & netif_globals.lock );
4192 mejdrech 220
            if( ! ERROR_OCCURRED( ipc_data_read_receive( & callid, & length ))){
221
                if( length < sizeof( device_stats_t )){
222
                    ERROR_CODE = EOVERFLOW;
223
                }else{
4261 mejdrech 224
                    if( ! ERROR_OCCURRED( netif_get_device_stats( IPC_GET_DEVICE( call ), & stats ))){
4192 mejdrech 225
                        ERROR_CODE = ipc_data_read_finalize( callid, & stats, sizeof( device_stats_t ));
226
                    }
227
                }
228
            }
4582 mejdrech 229
            fibril_rwlock_read_unlock( & netif_globals.lock );
4192 mejdrech 230
            return ERROR_CODE;
3666 mejdrech 231
        case NET_NETIF_STOP:
4307 mejdrech 232
            return netif_stop_req( 0, IPC_GET_DEVICE( call ));
4163 mejdrech 233
        case NET_NETIF_GET_ADDR:
4261 mejdrech 234
        case NET_NIL_ADDR:
4582 mejdrech 235
            fibril_rwlock_read_lock( & netif_globals.lock );
4261 mejdrech 236
            if( ! ERROR_OCCURRED( netif_get_addr_message( IPC_GET_DEVICE( call ), & address ))){
4192 mejdrech 237
                ERROR_CODE = measured_strings_reply( & address, 1 );
238
            }
4582 mejdrech 239
            fibril_rwlock_read_unlock( & netif_globals.lock );
4192 mejdrech 240
            return ERROR_CODE;
3666 mejdrech 241
    }
4243 mejdrech 242
    return netif_specific_message( callid, call, answer, answer_count );
3666 mejdrech 243
}
244
 
4307 mejdrech 245
int netif_init_module( async_client_conn_t client_connection ){
3846 mejdrech 246
    ERROR_DECLARE;
3666 mejdrech 247
 
3846 mejdrech 248
    async_set_client_connection( client_connection );
4307 mejdrech 249
    netif_globals.net_phone = connect_to_service( SERVICE_NETWORKING );
3846 mejdrech 250
    device_map_initialize( & netif_globals.device_map );
3912 mejdrech 251
    ERROR_PROPAGATE( pm_init());
4582 mejdrech 252
    fibril_rwlock_initialize( & netif_globals.lock );
4243 mejdrech 253
    if( ERROR_OCCURRED( netif_initialize())){
3914 mejdrech 254
        pm_destroy();
255
        return ERROR_CODE;
256
    }
4307 mejdrech 257
    return EOK;
258
}
3912 mejdrech 259
 
4307 mejdrech 260
int netif_run_module( void ){
3846 mejdrech 261
    async_manager();
262
 
3912 mejdrech 263
    pm_destroy();
3846 mejdrech 264
    return EOK;
3666 mejdrech 265
}
266
 
4192 mejdrech 267
void netif_pq_release( packet_id_t packet_id ){
4307 mejdrech 268
    pq_release( netif_globals.net_phone, packet_id );
4192 mejdrech 269
}
270
 
271
packet_t netif_packet_get_1( size_t content ){
4307 mejdrech 272
    return packet_get_1( netif_globals.net_phone, content );
4192 mejdrech 273
}
274
 
3666 mejdrech 275
/** @}
276
 */