Ignore:
Timestamp:
2010-03-07T15:13:28Z (14 years ago)
Author:
Lukas Mejdrech <lukasmejdrech@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
936835e
Parents:
aa85487
Message:

Coding style (no functional change)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    raa85487 raadf01e  
    7676        /** Free packet queues.
    7777         */
    78         packet_t free[ FREE_QUEUES_COUNT ];
     78        packet_t free[FREE_QUEUES_COUNT];
    7979        /** Packet length upper bounds of the free packet queues.
    8080         *  The maximal lengths of packets in each queue in the ascending order.
    8181         *  The last queue is not limited.
    8282         */
    83         size_t sizes[ FREE_QUEUES_COUNT ];
     83        size_t sizes[FREE_QUEUES_COUNT];
    8484        /** Total packets allocated.
    8585         */
    … …  
    8989                .counter = 1,
    9090                .waiters = {
    91                         .prev = & ps_globals.lock.waiters,
    92                         .next = & ps_globals.lock.waiters,
     91                        .prev = &ps_globals.lock.waiters,
     92                        .next = &ps_globals.lock.waiters,
    9393                }
    9494        },
    95         .free = { NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    96         .sizes = { PAGE_SIZE, PAGE_SIZE * 2, PAGE_SIZE * 4, PAGE_SIZE * 8, PAGE_SIZE * 16, PAGE_SIZE * 32, PAGE_SIZE * 64 },
     95        .free = {NULL, NULL, NULL, NULL, NULL, NULL, NULL},
     96        .sizes = {PAGE_SIZE, PAGE_SIZE * 2, PAGE_SIZE * 4, PAGE_SIZE * 8, PAGE_SIZE * 16, PAGE_SIZE * 32, PAGE_SIZE * 64},
    9797        .count = 0
    9898};
    … …  
    113113 *  @returns NULL if there is not enough memory left.
    114114 */
    115 packet_t        packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
     115packet_t packet_get(size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix);
    116116
    117117/** Releases the packet queue.
    … …  
    120120 *  @returns ENOENT if there is no such packet.
    121121 */
    122 int     packet_release_wrapper( packet_id_t packet_id );
     122int packet_release_wrapper(packet_id_t packet_id);
    123123
    124124/** Releases the packet and returns it to the appropriate free packet queue.
    … …  
    126126 *  @param[in] packet The packet to be released.
    127127 */
    128 void packet_release( packet_t packet );
     128void packet_release(packet_t packet);
    129129
    130130/** Creates a&nbsp;new packet of dimensions at least as given.
    … …  
    138138 *  @returns NULL if there is not enough memory left.
    139139 */
    140 packet_t        packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
     140packet_t packet_create(size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix);
    141141
    142142/** Clears and initializes the packet according to the given dimensions.
    … …  
    147147 *  @param[in] max_suffix The maximal suffix length in bytes.
    148148 */
    149 void    packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
     149void packet_init(packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix);
    150150
    151151/** Shares the packet memory block.
    … …  
    157157 *  @returns Other error codes as defined for the async_share_in_finalize() function.
    158158 */
    159 int packet_reply( const packet_t packet );
     159int packet_reply(const packet_t packet);
    160160
    161161/*@}*/
    162162
    163 int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ){
    164         if( ! packet ) return EINVAL;
    165         * packet = pm_find( packet_id );
    166         return ( * packet ) ? EOK : ENOENT;
    167 }
    168 
    169 packet_t packet_get_4( int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix ){
    170         return packet_get( addr_len, max_prefix, max_content, max_suffix );
    171 }
    172 
    173 packet_t packet_get_1( int phone, size_t content ){
    174         return packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, content, DEFAULT_SUFFIX );
    175 }
    176 
    177 void pq_release( int phone, packet_id_t packet_id ){
    178         ( void ) packet_release_wrapper( packet_id );
    179 }
    180 
    181 int     packet_server_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
     163int packet_translate(int phone, packet_ref packet, packet_id_t packet_id){
     164        if(! packet){
     165                return EINVAL;
     166        }
     167        *packet = pm_find(packet_id);
     168        return (*packet) ? EOK : ENOENT;
     169}
     170
     171packet_t packet_get_4(int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix){
     172        return packet_get(addr_len, max_prefix, max_content, max_suffix);
     173}
     174
     175packet_t packet_get_1(int phone, size_t content){
     176        return packet_get(DEFAULT_ADDR_LEN, DEFAULT_PREFIX, content, DEFAULT_SUFFIX);
     177}
     178
     179void pq_release(int phone, packet_id_t packet_id){
     180        (void) packet_release_wrapper(packet_id);
     181}
     182
     183int packet_server_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    182184        packet_t packet;
    183185
    184         * answer_count = 0;
    185         switch( IPC_GET_METHOD( * call )){
     186        *answer_count = 0;
     187        switch(IPC_GET_METHOD(*call)){
    186188                case IPC_M_PHONE_HUNGUP:
    187189                        return EOK;
    188190                case NET_PACKET_CREATE_1:
    189                         packet = packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, IPC_GET_CONTENT( call ), DEFAULT_SUFFIX );
    190                         if( ! packet ) return ENOMEM;
    191                         * answer_count = 2;
    192                         IPC_SET_ARG1( * answer, packet->packet_id );
    193                         IPC_SET_ARG2( * answer, packet->length );
     191                        packet = packet_get(DEFAULT_ADDR_LEN, DEFAULT_PREFIX, IPC_GET_CONTENT(call), DEFAULT_SUFFIX);
     192                        if(! packet){
     193                                return ENOMEM;
     194                        }
     195                        *answer_count = 2;
     196                        IPC_SET_ARG1(*answer, packet->packet_id);
     197                        IPC_SET_ARG2(*answer, packet->length);
    194198                        return EOK;
    195199                case NET_PACKET_CREATE_4:
    196                         packet = packet_get((( DEFAULT_ADDR_LEN < IPC_GET_ADDR_LEN( call )) ? IPC_GET_ADDR_LEN( call ) : DEFAULT_ADDR_LEN ), DEFAULT_PREFIX + IPC_GET_PREFIX( call ), IPC_GET_CONTENT( call ), DEFAULT_SUFFIX + IPC_GET_SUFFIX( call ));
    197                         if( ! packet ) return ENOMEM;
    198                         * answer_count = 2;
    199                         IPC_SET_ARG1( * answer, packet->packet_id );
    200                         IPC_SET_ARG2( * answer, packet->length );
     200                        packet = packet_get(((DEFAULT_ADDR_LEN < IPC_GET_ADDR_LEN(call)) ? IPC_GET_ADDR_LEN(call) : DEFAULT_ADDR_LEN), DEFAULT_PREFIX + IPC_GET_PREFIX(call), IPC_GET_CONTENT(call), DEFAULT_SUFFIX + IPC_GET_SUFFIX(call));
     201                        if(! packet){
     202                                return ENOMEM;
     203                        }
     204                        *answer_count = 2;
     205                        IPC_SET_ARG1(*answer, packet->packet_id);
     206                        IPC_SET_ARG2(*answer, packet->length);
    201207                        return EOK;
    202208                case NET_PACKET_GET:
    203                         packet = pm_find( IPC_GET_ID( call ));
    204                         if( ! packet_is_valid( packet )) return ENOENT;
    205                         return packet_reply( packet );
     209                        packet = pm_find(IPC_GET_ID(call));
     210                        if(! packet_is_valid(packet)){
     211                                return ENOENT;
     212                        }
     213                        return packet_reply(packet);
    206214                case NET_PACKET_GET_SIZE:
    207                         packet = pm_find( IPC_GET_ID( call ));
    208                         if( ! packet_is_valid( packet )) return ENOENT;
    209                         IPC_SET_ARG1( * answer, packet->length );
    210                         * answer_count = 1;
     215                        packet = pm_find(IPC_GET_ID(call));
     216                        if(! packet_is_valid(packet)){
     217                                return ENOENT;
     218                        }
     219                        IPC_SET_ARG1(*answer, packet->length);
     220                        *answer_count = 1;
    211221                        return EOK;
    212222                case NET_PACKET_RELEASE:
    213                         return packet_release_wrapper( IPC_GET_ID( call ));
     223                        return packet_release_wrapper(IPC_GET_ID(call));
    214224        }
    215225        return ENOTSUP;
    216226}
    217227
    218 int packet_release_wrapper( packet_id_t packet_id ){
    219         packet_t        packet;
    220 
    221         packet = pm_find( packet_id );
    222         if( ! packet_is_valid( packet )) return ENOENT;
    223         fibril_mutex_lock( & ps_globals.lock );
    224         pq_destroy( packet, packet_release );
    225         fibril_mutex_unlock( & ps_globals.lock );
     228int packet_release_wrapper(packet_id_t packet_id){
     229        packet_t packet;
     230
     231        packet = pm_find(packet_id);
     232        if(! packet_is_valid(packet)){
     233                return ENOENT;
     234        }
     235        fibril_mutex_lock(&ps_globals.lock);
     236        pq_destroy(packet, packet_release);
     237        fibril_mutex_unlock(&ps_globals.lock);
    226238        return EOK;
    227239}
    228240
    229 void packet_release( packet_t packet ){
     241void packet_release(packet_t packet){
    230242        int index;
    231243        int result;
    232244
    233245        // remove debug dump
    234 //      printf( "packet %d released\n", packet->packet_id );
    235         for( index = 0; ( index < FREE_QUEUES_COUNT - 1 ) && ( packet->length > ps_globals.sizes[ index ] ); ++ index );
    236         result = pq_add( & ps_globals.free[ index ], packet, packet->length, packet->length );
    237         assert( result == EOK );
    238 }
    239 
    240 packet_t packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
     246//      printf("packet %d released\n", packet->packet_id);
     247        for(index = 0; (index < FREE_QUEUES_COUNT - 1) && (packet->length > ps_globals.sizes[index]); ++ index);
     248        result = pq_add(&ps_globals.free[index], packet, packet->length, packet->length);
     249        assert(result == EOK);
     250}
     251
     252packet_t packet_get(size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
    241253        int index;
    242254        packet_t packet;
    243255        size_t length;
    244256
    245         length = ALIGN_UP( sizeof( struct packet ) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE );
    246         fibril_mutex_lock( & ps_globals.lock );
    247         for( index = 0; index < FREE_QUEUES_COUNT - 1; ++ index ){
    248                 if( length <= ps_globals.sizes[ index ] ){
    249                         packet = ps_globals.free[ index ];
    250                         while( packet_is_valid( packet ) && ( packet->length < length )){
    251                                 packet = pm_find( packet->next );
    252                         }
    253                         if( packet_is_valid( packet )){
    254                                 if( packet == ps_globals.free[ index ] ){
    255                                         ps_globals.free[ index ] = pq_detach( packet );
     257        length = ALIGN_UP(sizeof(struct packet) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE);
     258        fibril_mutex_lock(&ps_globals.lock);
     259        for(index = 0; index < FREE_QUEUES_COUNT - 1; ++ index){
     260                if(length <= ps_globals.sizes[index]){
     261                        packet = ps_globals.free[index];
     262                        while(packet_is_valid(packet) && (packet->length < length)){
     263                                packet = pm_find(packet->next);
     264                        }
     265                        if(packet_is_valid(packet)){
     266                                if(packet == ps_globals.free[index]){
     267                                        ps_globals.free[index] = pq_detach(packet);
    256268                                }else{
    257                                         pq_detach( packet );
     269                                        pq_detach(packet);
    258270                                }
    259                                 packet_init( packet, addr_len, max_prefix, max_content, max_suffix );
    260                                 fibril_mutex_unlock( & ps_globals.lock );
     271                                packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
     272                                fibril_mutex_unlock(&ps_globals.lock);
    261273                                // remove debug dump
    262 //                              printf( "packet %d got\n", packet->packet_id );
     274//                              printf("packet %d got\n", packet->packet_id);
    263275                                return packet;
    264276                        }
    265277                }
    266278        }
    267         packet = packet_create( length, addr_len, max_prefix, max_content, max_suffix );
    268         fibril_mutex_unlock( & ps_globals.lock );
     279        packet = packet_create(length, addr_len, max_prefix, max_content, max_suffix);
     280        fibril_mutex_unlock(&ps_globals.lock);
    269281        // remove debug dump
    270 //      printf( "packet %d created\n", packet->packet_id );
     282//      printf("packet %d created\n", packet->packet_id);
    271283        return packet;
    272284}
    273285
    274 packet_t packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
     286packet_t packet_create(size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
    275287        ERROR_DECLARE;
    276288
    277         packet_t        packet;
     289        packet_t packet;
    278290
    279291        // already locked
    280         packet = ( packet_t ) mmap( NULL, length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 );
    281         if( packet == MAP_FAILED ) return NULL;
     292        packet = (packet_t) mmap(NULL, length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
     293        if(packet == MAP_FAILED){
     294                return NULL;
     295        }
    282296        ++ ps_globals.count;
    283297        packet->packet_id = ps_globals.count;
    284298        packet->length = length;
    285         packet_init( packet, addr_len, max_prefix, max_content, max_suffix );
     299        packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
    286300        packet->magic_value = PACKET_MAGIC_VALUE;
    287         if( ERROR_OCCURRED( pm_add( packet ))){
    288                 munmap( packet, packet->length );
     301        if(ERROR_OCCURRED(pm_add(packet))){
     302                munmap(packet, packet->length);
    289303                return NULL;
    290304        }
    … …  
    292306}
    293307
    294 void packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
     308void packet_init(packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
    295309        // clear the packet content
    296         bzero((( void * ) packet ) + sizeof( struct packet ), packet->length - sizeof( struct packet ));
     310        bzero(((void *) packet) + sizeof(struct packet), packet->length - sizeof(struct packet));
    297311        // clear the packet header
    298312        packet->order = 0;
    … …  
    301315        packet->next = 0;
    302316        packet->addr_len = 0;
    303         packet->src_addr = sizeof( struct packet );
     317        packet->src_addr = sizeof(struct packet);
    304318        packet->dest_addr = packet->src_addr + addr_len;
    305319        packet->max_prefix = max_prefix;
    … …  
    309323}
    310324
    311 int packet_reply( const packet_t packet ){
    312         ipc_callid_t    callid;
    313         size_t                  size;
    314 
    315         if( ! packet_is_valid( packet )) return EINVAL;
    316         if( async_share_in_receive( & callid, & size ) <= 0 ) return EINVAL;
    317         if( size != packet->length ) return ENOMEM;
    318         return async_share_in_finalize( callid, packet, PROTO_READ | PROTO_WRITE );
     325int packet_reply(const packet_t packet){
     326        ipc_callid_t callid;
     327        size_t size;
     328
     329        if(! packet_is_valid(packet)){
     330                return EINVAL;
     331        }
     332        if(async_share_in_receive(&callid, &size) <= 0) return EINVAL;
     333        if(size != packet->length){
     334                return ENOMEM;
     335        }
     336        return async_share_in_finalize(callid, packet, PROTO_READ | PROTO_WRITE);
    319337}
    320338
Note: See TracChangeset for help on using the changeset viewer.