Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/structures/packet/packet.c

    r31c80a5 r1e2e0c1e  
    5959 *  @param[in] packet_id The packet identifier.
    6060 */
    61 #define PACKET_MAP_PAGE(packet_id)      (((packet_id) - 1) / PACKET_MAP_SIZE)
     61#define PACKET_MAP_PAGE( packet_id )    ((( packet_id ) - 1 ) / PACKET_MAP_SIZE )
    6262
    6363/** Returns the packet index in the corresponding packet map page.
    6464 *  @param[in] packet_id The packet identifier.
    6565 */
    66 #define PACKET_MAP_INDEX(packet_id)     (((packet_id) - 1) % PACKET_MAP_SIZE)
     66#define PACKET_MAP_INDEX( packet_id )   ((( packet_id ) - 1 ) % PACKET_MAP_SIZE )
    6767
    6868/** Type definition of the packet map page.
    6969 */
    70 typedef packet_t packet_map_t[PACKET_MAP_SIZE];
     70typedef packet_t packet_map_t[ PACKET_MAP_SIZE ];
    7171/** Type definition of the packet map page pointer.
    7272 */
    … …  
    7777 *  @see generic_field.h
    7878 */
    79 GENERIC_FIELD_DECLARE(gpm, packet_map_t);
     79GENERIC_FIELD_DECLARE( gpm, packet_map_t );
    8080
    8181/** Releases the packet.
    … …  
    8484 *  @returns EINVAL if the packet is not valid.
    8585 */
    86 int packet_destroy(packet_t packet);
     86int packet_destroy( packet_t packet );
    8787
    8888/** Packet map global data.
    … …  
    9191        /** Safety lock.
    9292         */
    93         fibril_rwlock_t lock;
     93        fibril_rwlock_t lock;
    9494        /** Packet map.
    9595         */
    96         gpm_t packet_map;
     96        gpm_t   packet_map;
    9797} pm_globals;
    9898
    99 GENERIC_FIELD_IMPLEMENT(gpm, packet_map_t);
    100 
    101 int packet_destroy(packet_t packet){
    102         if(! packet_is_valid(packet)){
    103                 return EINVAL;
    104         }
    105         return munmap(packet, packet->length);
    106 }
    107 
    108 int pm_init(void){
     99GENERIC_FIELD_IMPLEMENT( gpm, packet_map_t );
     100
     101int packet_destroy( packet_t packet ){
     102        if( ! packet_is_valid( packet )) return EINVAL;
     103        return munmap( packet, packet->length );
     104}
     105
     106int pm_init( void ){
    109107        ERROR_DECLARE;
    110108
    111         fibril_rwlock_initialize(&pm_globals.lock);
    112         fibril_rwlock_write_lock(&pm_globals.lock);
    113         ERROR_PROPAGATE(gpm_initialize(&pm_globals.packet_map));
    114         fibril_rwlock_write_unlock(&pm_globals.lock);
    115         return EOK;
    116 }
    117 
    118 packet_t pm_find(packet_id_t packet_id){
     109        fibril_rwlock_initialize( & pm_globals.lock );
     110        fibril_rwlock_write_lock( & pm_globals.lock );
     111        ERROR_PROPAGATE( gpm_initialize( & pm_globals.packet_map ));
     112        fibril_rwlock_write_unlock( & pm_globals.lock );
     113        return EOK;
     114}
     115
     116packet_t pm_find( packet_id_t packet_id ){
    119117        packet_map_ref map;
    120118        packet_t packet;
    121119
    122         if(! packet_id){
     120        if( ! packet_id ) return NULL;
     121        fibril_rwlock_read_lock( & pm_globals.lock );
     122        if( packet_id > PACKET_MAP_SIZE * gpm_count( & pm_globals.packet_map )){
     123                fibril_rwlock_read_unlock( & pm_globals.lock );
    123124                return NULL;
    124125        }
    125         fibril_rwlock_read_lock(&pm_globals.lock);
    126         if(packet_id > PACKET_MAP_SIZE * gpm_count(&pm_globals.packet_map)){
    127                 fibril_rwlock_read_unlock(&pm_globals.lock);
     126        map = gpm_get_index( & pm_globals.packet_map, PACKET_MAP_PAGE( packet_id ));
     127        if( ! map ){
     128                fibril_rwlock_read_unlock( & pm_globals.lock );
    128129                return NULL;
    129130        }
    130         map = gpm_get_index(&pm_globals.packet_map, PACKET_MAP_PAGE(packet_id));
    131         if(! map){
    132                 fibril_rwlock_read_unlock(&pm_globals.lock);
    133                 return NULL;
    134         }
    135         packet = (*map)[PACKET_MAP_INDEX(packet_id)];
    136         fibril_rwlock_read_unlock(&pm_globals.lock);
     131        packet = ( * map )[ PACKET_MAP_INDEX( packet_id ) ];
     132        fibril_rwlock_read_unlock( & pm_globals.lock );
    137133        return packet;
    138134}
    139135
    140 int pm_add(packet_t packet){
     136int pm_add( packet_t packet ){
    141137        ERROR_DECLARE;
    142138
    143139        packet_map_ref map;
    144140
    145         if(! packet_is_valid(packet)){
    146                 return EINVAL;
    147         }
    148         fibril_rwlock_write_lock(&pm_globals.lock);
    149         if(PACKET_MAP_PAGE(packet->packet_id) < gpm_count(&pm_globals.packet_map)){
    150                 map = gpm_get_index(&pm_globals.packet_map, PACKET_MAP_PAGE(packet->packet_id));
     141        if( ! packet_is_valid( packet )) return EINVAL;
     142        fibril_rwlock_write_lock( & pm_globals.lock );
     143        if( PACKET_MAP_PAGE( packet->packet_id ) < gpm_count( & pm_globals.packet_map )){
     144                map = gpm_get_index( & pm_globals.packet_map, PACKET_MAP_PAGE( packet->packet_id ));
    151145        }else{
    152146                do{
    153                         map = (packet_map_ref) malloc(sizeof(packet_map_t));
    154                         if(! map){
    155                                 fibril_rwlock_write_unlock(&pm_globals.lock);
     147                        map = ( packet_map_ref ) malloc( sizeof( packet_map_t ));
     148                        if( ! map ){
     149                                fibril_rwlock_write_unlock( & pm_globals.lock );
    156150                                return ENOMEM;
    157151                        }
    158                         bzero(map, sizeof(packet_map_t));
    159                         if((ERROR_CODE = gpm_add(&pm_globals.packet_map, map)) < 0){
    160                                 fibril_rwlock_write_unlock(&pm_globals.lock);
    161                                 free(map);
     152                        bzero( map, sizeof( packet_map_t ));
     153                        if(( ERROR_CODE = gpm_add( & pm_globals.packet_map, map )) < 0 ){
     154                                fibril_rwlock_write_unlock( & pm_globals.lock );
     155                                free( map );
    162156                                return ERROR_CODE;
    163157                        }
    164                 }while(PACKET_MAP_PAGE(packet->packet_id) >= gpm_count(&pm_globals.packet_map));
    165         }
    166         (*map)[PACKET_MAP_INDEX(packet->packet_id)] = packet;
    167         fibril_rwlock_write_unlock(&pm_globals.lock);
    168         return EOK;
    169 }
    170 
    171 void pm_destroy(void){
     158                }while( PACKET_MAP_PAGE( packet->packet_id ) >= gpm_count( & pm_globals.packet_map ));
     159        }
     160        ( * map )[ PACKET_MAP_INDEX( packet->packet_id ) ] = packet;
     161        fibril_rwlock_write_unlock( & pm_globals.lock );
     162        return EOK;
     163}
     164
     165void pm_destroy( void ){
    172166        int count;
    173167        int index;
    … …  
    175169        packet_t packet;
    176170
    177         fibril_rwlock_write_lock(&pm_globals.lock);
    178         count = gpm_count(&pm_globals.packet_map);
    179         while(count > 0){
    180                 map = gpm_get_index(&pm_globals.packet_map, count - 1);
    181                 for(index = PACKET_MAP_SIZE - 1; index >= 0; -- index){
    182                         packet = (*map)[index];
    183                         if(packet_is_valid(packet)){
    184                                 munmap(packet, packet->length);
     171        fibril_rwlock_write_lock( & pm_globals.lock );
     172        count = gpm_count( & pm_globals.packet_map );
     173        while( count > 0 ){
     174                map = gpm_get_index( & pm_globals.packet_map, count - 1 );
     175                for( index = PACKET_MAP_SIZE - 1; index >= 0; -- index ){
     176                        packet = ( * map )[ index ];
     177                        if( packet_is_valid( packet )){
     178                                munmap( packet, packet->length );
    185179                        }
    186180                }
    187181        }
    188         gpm_destroy(&pm_globals.packet_map);
     182        gpm_destroy( & pm_globals.packet_map );
    189183        // leave locked
    190184}
    191185
    192 int pq_add(packet_t * first, packet_t packet, size_t order, size_t metric){
    193         packet_t item;
    194 
    195         if((! first) || (! packet_is_valid(packet))){
    196                 return EINVAL;
    197         }
    198         pq_set_order(packet, order, metric);
    199         if(packet_is_valid(*first)){
     186int pq_add( packet_t * first, packet_t packet, size_t order, size_t metric ){
     187        packet_t        item;
     188
     189        if(( ! first ) || ( ! packet_is_valid( packet ))) return EINVAL;
     190        pq_set_order( packet, order, metric );
     191        if( packet_is_valid( * first )){
    200192                item = * first;
    201193                do{
    202                         if(item->order < order){
    203                                 if(item->next){
    204                                         item = pm_find(item->next);
     194                        if( item->order < order ){
     195                                if( item->next ){
     196                                        item = pm_find( item->next );
    205197                                }else{
    206198                                        item->next = packet->packet_id;
    … …  
    212204                                packet->next = item->packet_id;
    213205                                item->previous = packet->packet_id;
    214                                 item = pm_find(packet->previous);
    215                                 if(item){
     206                                item = pm_find( packet->previous );
     207                                if( item ){
    216208                                        item->next = packet->packet_id;
    217209                                }else{
    218                                         *first = packet;
     210                                        * first = packet;
    219211                                }
    220212                                return EOK;
    221213                        }
    222                 }while(packet_is_valid(item));
    223         }
    224         *first = packet;
    225         return EOK;
    226 }
    227 
    228 packet_t pq_find(packet_t packet, size_t order){
    229         packet_t item;
    230 
    231         if(! packet_is_valid(packet)){
    232                 return NULL;
    233         }
    234         item = packet;
    235         do{
    236                 if(item->order == order){
     214                }while( packet_is_valid( item ));
     215        }
     216        * first = packet;
     217        return EOK;
     218}
     219
     220packet_t pq_find( packet_t packet, size_t order ){
     221        packet_t        item;
     222
     223        if( ! packet_is_valid( packet )) return NULL;
     224        if( packet->order == order ) return packet;
     225        item = pm_find( packet->next );
     226        while( item && ( item != packet )){
     227                item = pm_find( item->next );
     228                if( item->order == order ){
    237229                        return item;
    238230                }
    239                 item = pm_find(item->next);
    240         }while(item && (item != packet) && packet_is_valid(item));
     231        }
    241232        return NULL;
    242233}
    243234
    244 int pq_insert_after(packet_t packet, packet_t new_packet){
    245         packet_t item;
    246 
    247         if(!(packet_is_valid(packet) && packet_is_valid(new_packet))){
    248                 return EINVAL;
    249         }
     235int     pq_insert_after( packet_t packet, packet_t new_packet ){
     236        packet_t        item;
     237
     238        if( !( packet_is_valid( packet ) && packet_is_valid( new_packet ))) return EINVAL;
    250239        new_packet->previous = packet->packet_id;
    251240        new_packet->next = packet->next;
    252         item = pm_find(packet->next);
    253         if(item){
    254                 item->previous = new_packet->packet_id;
    255         }
     241        item = pm_find( packet->next );
     242        if( item ) item->previous = new_packet->packet_id;
    256243        packet->next = new_packet->packet_id;
    257244        return EOK;
    258245}
    259246
    260 packet_t pq_detach(packet_t packet){
     247packet_t pq_detach( packet_t packet ){
    261248        packet_t next;
    262249        packet_t previous;
    263250
    264         if(! packet_is_valid(packet)){
    265                 return NULL;
    266         }
    267         next = pm_find(packet->next);
    268         if(next){
     251        if( ! packet_is_valid( packet )) return NULL;
     252        next = pm_find( packet->next );
     253        if( next ){
    269254                next->previous = packet->previous;
    270                 previous = pm_find(next->previous);
    271                 if(previous){
     255                previous = pm_find( next->previous );
     256                if( previous ){
    272257                        previous->next = next->packet_id;
    273258                }
    … …  
    278263}
    279264
    280 int pq_set_order(packet_t packet, size_t order, size_t metric){
    281         if(! packet_is_valid(packet)){
    282                 return EINVAL;
    283         }
     265int pq_set_order( packet_t packet, size_t order, size_t metric ){
     266        if( ! packet_is_valid( packet )) return EINVAL;
    284267        packet->order = order;
    285268        packet->metric = metric;
    … …  
    287270}
    288271
    289 int pq_get_order(packet_t packet, size_t * order, size_t * metric){
    290         if(! packet_is_valid(packet)){
    291                 return EINVAL;
    292         }
    293         if(order){
    294                 *order = packet->order;
    295         }
    296         if(metric){
    297                 *metric = packet->metric;
    298         }
    299         return EOK;
    300 }
    301 
    302 void pq_destroy(packet_t first, void (*packet_release)(packet_t packet)){
    303         packet_t actual;
    304         packet_t next;
     272int pq_get_order( packet_t packet, size_t * order, size_t * metric ){
     273        if( ! packet_is_valid( packet )) return EINVAL;
     274        if( order ) * order = packet->order;
     275        if( metric ) * metric = packet->metric;
     276        return EOK;
     277}
     278
     279void pq_destroy( packet_t first, void ( * packet_release )( packet_t packet )){
     280        packet_t        actual;
     281        packet_t        next;
    305282
    306283        actual = first;
    307         while(packet_is_valid(actual)){
    308                 next = pm_find(actual->next);
     284        while( packet_is_valid( actual )){
     285                next = pm_find( actual->next );
    309286                actual->next = 0;
    310287                actual->previous = 0;
    311                 if(packet_release){
    312                         packet_release(actual);
    313                 }
     288                if( packet_release ) packet_release( actual );
    314289                actual = next;
    315290        }
    316291}
    317292
    318 packet_t pq_next(packet_t packet){
    319         if(! packet_is_valid(packet)){
    320                 return NULL;
    321         }
    322         return pm_find(packet->next);
    323 }
    324 
    325 packet_t pq_previous(packet_t packet){
    326         if(! packet_is_valid(packet)){
    327                 return NULL;
    328         }
    329         return pm_find(packet->previous);
     293packet_t pq_next( packet_t packet ){
     294        if( ! packet_is_valid( packet )) return NULL;
     295        return pm_find( packet->next );
     296}
     297
     298packet_t pq_previous( packet_t packet ){
     299        if( ! packet_is_valid( packet )) return NULL;
     300        return pm_find( packet->previous );
    330301}
    331302
Note: See TracChangeset for help on using the changeset viewer.