Subversion Repositories HelenOS

Rev

Rev 3886 | Rev 3914 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3886 Rev 3901
Line 25... Line 25...
25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 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.
 26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
 */
 27 
 */
28 
 
 28 
 
29 
/** @addtogroup net
 29 
/** @addtogroup net
30 
 * @{
 30 
 *  @{
31 
 */
 31 
 */
32 
 
 32 
 
33 
/** @file
 33 
/** @file
34 
 */
 34 
 */
35 
 
 35 
 
36 
#include <errno.h>
 36 
#include <errno.h>
37 
#include <unistd.h>
 37 
#include <malloc.h>
- 
 
 38 
//#include <stdio.h>
38 
#include <string.h>
 39 
#include <string.h>
39 
 
 40 
 
40 
#include <ipc/ipc.h>
 - 
 
41 
#include <sys/mman.h>
 41 
#include <sys/mman.h>
42 
 
 42 
 
43 
#include "../../err.h"
 43 
#include "../../err.h"
44 
 
 44 
 
- 
 
 45 
#include "../generic_field.h"
- 
 
 46 
 
- 
 
 47 
#include "packet_header.h"
45 
#include "packet.h"
 48 
#include "packet.h"
46 
 
 49 
 
- 
 
 50 
// TODO power of 2 aritmetic => div and mod speedup?
47 
#define PACKET_MAGIC_VALUE  0x11227788
 51 
#define PACKET_MAP_SIZE 100
48 
 
 52 
 
49 
struct packet{
 - 
 
50 
    size_t  length;
 - 
 
51 
    size_t  max_prefix;
 - 
 
52 
    size_t  max_content;
 - 
 
53 
    size_t  data_start;
 - 
 
54 
    size_t  data_end;
 - 
 
55 
    int magic_value;
 - 
 
56 
};
 - 
 
57 
 
 - 
 
58 
int packet_is_valid( packet_t packet );
 - 
 
59 
 
 - 
 
60 
packet_t packet_create( size_t max_prefix, size_t max_content, size_t max_sufix ){
 53 
#define PACKET_MAP_PAGE( packet_id )    ((( packet_id ) - 1 ) / PACKET_MAP_SIZE )
61 
    size_t      length;
 - 
 
62 
    packet_t    packet;
 - 
 
63 
 
 - 
 
64 
    length = max_prefix + max_content + max_sufix;
 - 
 
65 
    packet = ( packet_t ) mmap( NULL, sizeof( struct packet ) + length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 );
 - 
 
66 
    if( packet == MAP_FAILED ) return NULL;
 - 
 
67 
    packet->length = length;
 - 
 
68 
    packet->max_prefix = max_prefix;
 - 
 
69 
    packet->max_content = max_content;
 - 
 
70 
    packet->data_start = sizeof( struct packet ) + packet->max_prefix;
 54 
#define PACKET_MAP_INDEX( packet_id )   ((( packet_id ) - 1 ) % PACKET_MAP_SIZE )
71 
    packet->data_end = packet->data_start;
 - 
 
72 
    packet->magic_value = PACKET_MAGIC_VALUE;
 - 
 
73 
    return packet;
 - 
 
74 
}
 - 
 
75 
 
 55 
 
76 
int packet_is_valid( packet_t packet ){
 - 
 
77 
    return packet && ( packet->magic_value == PACKET_MAGIC_VALUE );
 - 
 
78 
}
 - 
 
79 
 
 56 
 
80 
packet_t packet_copy( packet_t packet ){
 57 
int packet_destroy( packet_t packet );
81 
    packet_t    new;
 - 
 
82 
 
 58 
 
83 
    if( ! packet_is_valid( packet )) return NULL;
 59 
typedef packet_t packet_map_t[ PACKET_MAP_SIZE ];
84 
    new = ( packet_t ) mmap( NULL, packet->length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 );
 - 
 
85 
    if( new == MAP_FAILED ) return NULL;
 60 
typedef packet_map_t * packet_map_ref;
- 
 
 61 
 
86 
    memcpy( new, packet, packet->length );
 62 
GENERIC_FIELD_DECLARE( gpm, packet_map_t );
87 
    return new;
 - 
 
88 
}
 63 
 
- 
 
 64 
GENERIC_FIELD_IMPLEMENT( gpm, packet_map_t );
89 
 
 65 
 
- 
 
 66 
static struct{
- 
 
 67 
    // TODO lock
- 
 
 68 
    gpm_t map;
- 
 
 69 
} pm_globals;
- 
 
 70 
 
90 
int packet_copy_data( packet_t packet, void * data, size_t length ){
 71 
int packet_destroy( packet_t packet ){
91 
    if( ! packet_is_valid( packet )) return EINVAL;
 72 
    if( ! packet_is_valid( packet )) return EINVAL;
92 
    if( packet->data_start + length >= (( size_t ) packet ) + packet->length ) return ENOMEM;
 - 
 
93 
    memcpy( packet + packet->data_start, data, length );
 73 
    return munmap( packet, packet->length );
94 
    if( packet->data_start + length > packet->data_end ){
 - 
 
95 
        packet->data_end = packet->data_start + length;
 - 
 
96 
    }
 - 
 
97 
    return EOK;
 - 
 
98 
}
 74 
}
99 
 
 75 
 
100 
void * packet_prepend( packet_t packet, size_t length ){
 - 
 
101 
    if(( ! packet_is_valid( packet )) || ( packet->data_start - sizeof( struct packet ) < length )) return NULL;
 - 
 
102 
    packet->data_start -= length;
 - 
 
103 
    return packet + packet->data_start;
 - 
 
104 
}
 - 
 
105 
 
 - 
 
106 
void * packet_append( packet_t packet, size_t length ){
 - 
 
107 
    if(( ! packet_is_valid( packet )) || ( packet->data_end + length >= (( size_t ) packet ) + packet->length )) return NULL;
 - 
 
108 
    packet->data_end += length;
 76 
int pm_init( void ){
109 
    return packet + packet->data_end - length;
 77 
    return gpm_initialize( & pm_globals.map );
110 
}
 - 
 
111 
 
 - 
 
112 
int packet_trim( packet_t packet, size_t prefix, size_t sufix ){
 - 
 
113 
    if(( ! packet_is_valid( packet )) || ( prefix + sufix > packet->data_end - packet->data_start )) return EINVAL;
 - 
 
114 
    packet->data_start += prefix;
 - 
 
115 
    packet->data_end -= sufix;
 - 
 
116 
    return EOK;
 - 
 
117 
}
 78 
}
118 
 
 79 
 
119 
int packet_send( packet_t packet, int phone ){
 80 
packet_t pm_find( packet_id_t packet_id ){
- 
 
 81 
    packet_map_ref map;
- 
 
 82 
 
120 
    if( ! packet_is_valid( packet )) return EINVAL;
 83 
    if( ! packet_id ) return NULL;
- 
 
 84 
    if( packet_id > PACKET_MAP_SIZE * gpm_count( & pm_globals.map )) return NULL;
121 
    return ipc_share_out_start( phone, packet, PROTO_READ | PROTO_WRITE );
 85 
    map = gpm_get_index( & pm_globals.map, PACKET_MAP_PAGE( packet_id ));
- 
 
 86 
    if( ! map ) return NULL;
- 
 
 87 
    return ( * map )[ PACKET_MAP_INDEX( packet_id ) ];
122 
}
 88 
}
123 
 
 89 
 
124 
int packet_receive( packet_ref packet ){
 90 
int pm_add( packet_t packet ){
125 
    ERROR_DECLARE;
 91 
    ERROR_DECLARE;
126 
 
 92 
 
127 
    ipc_callid_t    callid;
 93 
    packet_map_ref map;
128 
    size_t      size;
 - 
 
129 
    int     flags;
 - 
 
130 
 
 94 
 
131 
    if( ! packet ) return EINVAL;
 95 
    if(( ! packet_is_valid( packet )) || ( gpm_count( & pm_globals.map ) < -1 )) return EINVAL;
132 
    if( ! ipc_share_out_receive( & callid, & size, & flags )) return EINVAL;
 96 
    if( PACKET_MAP_PAGE( packet->packet_id ) < gpm_count( & pm_globals.map )){
- 
 
 97 
        map = gpm_get_index( & pm_globals.map, PACKET_MAP_PAGE( packet->packet_id ));
- 
 
 98 
    }else{
- 
 
 99 
        do{
133 
    * packet = ( packet_t ) as_get_mappable_page( size );
 100 
            map = ( packet_map_ref ) malloc( sizeof( packet_map_t ));
134 
    if( !( * packet )) return ENOMEM;
 101 
            if( ! map ) return ENOMEM;
- 
 
 102 
            memset( map, 0, sizeof( packet_map_t ));
135 
    if( ERROR_OCCURED( ipc_share_out_finalize( callid, * packet ))){
 103 
            if(( ERROR_CODE = gpm_add( & pm_globals.map, map )) < 0 ){
136 
        munmap( * packet, size );
 104 
                free( map );
137 
        return ERROR_CODE;
 105 
                return ERROR_CODE;
- 
 
 106 
            }
- 
 
 107 
        }while( PACKET_MAP_PAGE( packet->packet_id ) >= gpm_count( & pm_globals.map ));
138 
    }
 108 
    }
- 
 
 109 
    ( * map )[ PACKET_MAP_INDEX( packet->packet_id ) ] = packet;
139 
    return EOK;
 110 
    return EOK;
140 
}
 111 
}
141 
 
 112 
 
142 
int packet_destroy( packet_t packet ){
 113 
void pm_destroy( void ){
- 
 
 114 
    int count;
- 
 
 115 
    int index;
- 
 
 116 
    packet_map_ref map;
- 
 
 117 
    packet_t packet;
- 
 
 118 
 
- 
 
 119 
    count = gpm_count( & pm_globals.map );
- 
 
 120 
    while( count > 0 ){
- 
 
 121 
        map = gpm_get_index( & pm_globals.map, count - 1 );
- 
 
 122 
        for( index = PACKET_MAP_SIZE - 1; index >= 0; -- index ){
- 
 
 123 
            packet = ( * map )[ index ];
143 
    if( ! packet_is_valid( packet )) return EINVAL;
 124 
            if( packet_is_valid( packet )){
144 
    return munmap( packet, sizeof( struct packet ) + packet->length );
 125 
                munmap( packet, packet->length );
- 
 
 126 
            }
- 
 
 127 
        }
- 
 
 128 
    }
- 
 
 129 
    gpm_destroy( & pm_globals.map );
145 
}
 130 
}
146 
 
 131 
 
147 
size_t packet_get_data_length( packet_t packet ){
 132 
packet_t pq_add( packet_t first, packet_t packet, int order, size_t metric ){
- 
 
 133 
    packet_t    item;
- 
 
 134 
 
148 
    if( ! packet_is_valid( packet )) return 0;
 135 
    if( ! packet_is_valid( packet )) return NULL;
- 
 
 136 
    pq_set( packet, order, metric );
- 
 
 137 
    if( packet_is_valid( first )){
- 
 
 138 
        item = first;
- 
 
 139 
        do{
- 
 
 140 
            if( item->order < order ){
- 
 
 141 
                if( item->next ){
- 
 
 142 
                    item = pm_find( item->next );
- 
 
 143 
                }else{
- 
 
 144 
                    item->next = packet->packet_id;
149 
    return packet->data_end - packet->data_start;
 145 
                    packet->previous = item->packet_id;
- 
 
 146 
                    return first;
- 
 
 147 
                }
- 
 
 148 
            }else{
- 
 
 149 
                packet->previous = item->previous;
- 
 
 150 
                packet->next = item->packet_id;
- 
 
 151 
                item->previous = packet->packet_id;
- 
 
 152 
                item = pm_find( packet->previous );
- 
 
 153 
                if( item ) item->next = packet->packet_id;
- 
 
 154 
                return item;
- 
 
 155 
            }
- 
 
 156 
        }while( packet_is_valid( item ));
- 
 
 157 
    }
- 
 
 158 
    return packet;
150 
}
 159 
}
151 
 
 160 
 
152 
void * packet_get_data( packet_t packet ){
 161 
packet_t pq_detach( packet_t packet ){
- 
 
 162 
    packet_t next;
- 
 
 163 
    packet_t previous;
- 
 
 164 
 
153 
    if( ! packet_is_valid( packet )) return NULL;
 165 
    if( ! packet_is_valid( packet )) return NULL;
154 
    return packet + packet->data_start;
 166 
    next = pm_find( packet->next );
- 
 
 167 
    if( next ){
- 
 
 168 
        next->previous = packet->previous;
- 
 
 169 
        previous = pm_find( next->previous );
- 
 
 170 
        if( previous ){
- 
 
 171 
            previous->next = next->packet_id;
- 
 
 172 
        }
- 
 
 173 
    }
- 
 
 174 
    packet->previous = 0;
- 
 
 175 
    packet->next = 0;
- 
 
 176 
    return next;
- 
 
 177 
}
- 
 
 178 
 
- 
 
 179 
int pq_set( packet_t packet, int order, size_t metric ){
- 
 
 180 
    if( ! packet_is_valid( packet )) return EINVAL;
- 
 
 181 
    packet->order = order;
- 
 
 182 
    packet->metric = metric;
- 
 
 183 
    return EOK;
- 
 
 184 
}
- 
 
 185 
 
- 
 
 186 
void pq_destroy( packet_t first, void ( * packet_release )( packet_t packet )){
- 
 
 187 
    packet_t    actual;
- 
 
 188 
    packet_t    next;
- 
 
 189 
 
- 
 
 190 
    actual = first;
- 
 
 191 
    while( packet_is_valid( actual )){
- 
 
 192 
        next = pm_find( actual->next );
- 
 
 193 
        actual->next = 0;
- 
 
 194 
        actual->previous = 0;
- 
 
 195 
        if( packet_release ) packet_release( actual );
- 
 
 196 
        actual = next;
- 
 
 197 
    }
155 
}
 198 
}
156 
 
 199 
 
157 
/** @}
 200 
/** @}
158 
 */
 201 
 */