Changeset 24ab58b3 in mainline for uspace/srv/net/nil


Ignore:
Timestamp:
2010-04-06T11:41:48Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
14f1db0
Parents:
4dd8529
Message:

more compact network startup messages (usually one line instead of multiple lines)
pass module name as an argument to nil_message() and friends
deeper cstyle changes (replace forward prototypes with proper extern declarations and static functions, change doxygen comments, stick more closely to the 80-column rule, no argument names in header files, spacing, comments, etc.)

Location:
uspace/srv/net/nil
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/nil/eth/eth.c

    r4dd8529 r24ab58b3  
    6060#include <adt/measured_strings.h>
    6161#include <packet/packet_client.h>
     62#include <nil_module.h>
    6263
    6364#include "eth.h"
    … …  
    6667/** The module name.
    6768 */
    68 #define NAME    "Ethernet protocol"
     69#define NAME  "eth"
    6970
    7071/** Reserved packet prefix length.
    … …  
    401402                        return index;
    402403                }
    403                 printf("New device registered:\n\tid\t= %d\n\tservice\t= %d\n\tMTU\t= %d\n\taddress\t= %X:%X:%X:%X:%X:%X\n\tflags\t= 0x%x\n", device->device_id, device->service, device->mtu, device->addr_data[0], device->addr_data[1], device->addr_data[2], device->addr_data[3], device->addr_data[4], device->addr_data[5], device->flags);
     404                printf("%s: Device registered (id: %d, service: %d: mtu: %d, "
     405                    "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n",
     406                    NAME, device->device_id, device->service, device->mtu,
     407                    device->addr_data[0], device->addr_data[1],
     408                    device->addr_data[2], device->addr_data[3],
     409                    device->addr_data[4], device->addr_data[5], device->flags);
    404410        }
    405411        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    … …  
    571577                }
    572578        }
    573         printf("New protocol registered:\n\tprotocol\t= 0x%x\n\tservice\t= %d\n\tphone\t= %d\n", proto->protocol, proto->service, proto->phone);
     579       
     580        printf("%s: Protocol registered (protocol: %d, service: %d, phone: %d)\n",
     581            NAME, proto->protocol, proto->service, proto->phone);
     582       
    574583        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    575584        return EOK;
    … …  
    704713}
    705714
    706 int nil_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     715int nil_message(const char *name, ipc_callid_t callid, ipc_call_t *call,
     716    ipc_call_t *answer, int *answer_count)
     717{
    707718        ERROR_DECLARE;
    708 
     719       
    709720        measured_string_ref address;
    710721        packet_t packet;
    … …  
    713724        size_t suffix;
    714725        size_t content;
    715 
    716 //      printf("message %d - %d\n", IPC_GET_METHOD(*call), NET_NIL_FIRST);
     726       
    717727        *answer_count = 0;
    718         switch(IPC_GET_METHOD(*call)){
     728        switch (IPC_GET_METHOD(*call)) {
    719729                case IPC_M_PHONE_HUNGUP:
    720730                        return EOK;
    721731                case NET_NIL_DEVICE:
    722                         return eth_device_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), IPC_GET_MTU(call));
     732                        return eth_device_message(IPC_GET_DEVICE(call),
     733                            IPC_GET_SERVICE(call), IPC_GET_MTU(call));
    723734                case NET_NIL_SEND:
    724                         ERROR_PROPAGATE(packet_translate(eth_globals.net_phone, &packet, IPC_GET_PACKET(call)));
    725                         return eth_send_message(IPC_GET_DEVICE(call), packet, IPC_GET_SERVICE(call));
     735                        ERROR_PROPAGATE(packet_translate(eth_globals.net_phone, &packet,
     736                            IPC_GET_PACKET(call)));
     737                        return eth_send_message(IPC_GET_DEVICE(call), packet,
     738                            IPC_GET_SERVICE(call));
    726739                case NET_NIL_PACKET_SPACE:
    727                         ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call), &addrlen, &prefix, &content, &suffix));
     740                        ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call),
     741                            &addrlen, &prefix, &content, &suffix));
    728742                        IPC_SET_ADDR(answer, addrlen);
    729743                        IPC_SET_PREFIX(answer, prefix);
    … …  
    733747                        return EOK;
    734748                case NET_NIL_ADDR:
    735                         ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), ETH_LOCAL_ADDR, &address));
     749                        ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
     750                            ETH_LOCAL_ADDR, &address));
    736751                        return measured_strings_reply(address, 1);
    737752                case NET_NIL_BROADCAST_ADDR:
    738                         ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), ETH_BROADCAST_ADDR, &address));
     753                        ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
     754                            ETH_BROADCAST_ADDR, &address));
    739755                        return measured_strings_reply(address, 1);
    740756                case IPC_M_CONNECT_TO_ME:
    741                         return eth_register_message(NIL_GET_PROTO(call), IPC_GET_PHONE(call));
    742         }
     757                        return eth_register_message(NIL_GET_PROTO(call),
     758                            IPC_GET_PHONE(call));
     759        }
     760       
    743761        return ENOTSUP;
    744762}
    … …  
    799817               
    800818                /* Process the message */
    801                 int res = nil_module_message(callid, &call, &answer, &answer_count);
     819                int res = nil_module_message(NAME, callid, &call, &answer,
     820                    &answer_count);
    802821               
    803822                /* End if said to either by the message or the processing result */
    … …  
    823842        ERROR_DECLARE;
    824843       
    825         /* Print the module label */
    826         printf("Task %d - %s\n", task_get_id(), NAME);
    827        
    828844        /* Start the module */
    829         if (ERROR_OCCURRED(nil_module_start(nil_client_connection))) {
    830                 printf(" - ERROR %i\n", ERROR_CODE);
     845        if (ERROR_OCCURRED(nil_module_start(nil_client_connection)))
    831846                return ERROR_CODE;
    832         }
    833847       
    834848        return EOK;

  • uspace/srv/net/nil/eth/eth.h

    r4dd8529 r24ab58b3  
    147147};
    148148
    149 /** Module initialization.
    150  *  Is called by the module_start() function.
    151  *  @param[in] net_phone The networking moduel phone.
    152  *  @returns EOK on success.
    153  *  @returns Other error codes as defined for each specific module initialize function.
    154  */
    155 extern int nil_initialize(int net_phone);
    156 
    157 /** Message processing function.
    158  *  @param[in] callid The message identifier.
    159  *  @param[in] call The message parameters.
    160  *  @param[out] answer The message answer parameters.
    161  *  @param[out] answer_count The last parameter for the actual answer in the answer parameter.
    162  *  @returns EOK on success.
    163  *  @returns ENOTSUP if the message is not known.
    164  *  @returns Other error codes as defined for each specific module message function.
    165  *  @see nil_interface.h
    166  *  @see IS_NET_NIL_MESSAGE()
    167  */
    168 extern int nil_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
    169 
    170149#endif
    171150

  • uspace/srv/net/nil/eth/eth_module.c

    r4dd8529 r24ab58b3  
    4646#include <net_interface.h>
    4747#include <packet/packet.h>
     48#include <nil_module.h>
    4849#include <nil_standalone.h>
    4950
    … …  
    7980}
    8081
    81 /** Passes the parameters to the module specific nil_message() function.
    82  *  @param[in] callid The message identifier.
    83  *  @param[in] call The message parameters.
    84  *  @param[out] answer The message answer parameters.
    85  *  @param[out] answer_count The last parameter for the actual answer in the answer parameter.
    86  *  @returns EOK on success.
    87  *  @returns ENOTSUP if the message is not known.
    88  *  @returns Other error codes as defined for each specific module message function.
     82/** Pass the parameters to the module specific nil_message() function.
     83 *
     84 * @param[in]  name         Module name.
     85 * @param[in]  callid       The message identifier.
     86 * @param[in]  call         The message parameters.
     87 * @param[out] answer       The message answer parameters.
     88 * @param[out] answer_count The last parameter for the actual answer
     89 *                          in the answer parameter.
     90 *
     91 * @return EOK on success.
     92 * @return ENOTSUP if the message is not known.
     93 * @return Other error codes as defined for each
     94 *         specific module message function.
     95 *
    8996 */
    90 int nil_module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    91         return nil_message(callid, call, answer, answer_count);
     97int nil_module_message(const char *name, ipc_callid_t callid, ipc_call_t *call,
     98    ipc_call_t *answer, int *answer_count)
     99{
     100        return nil_message(name, callid, call, answer, answer_count);
    92101}
    93102

  • uspace/srv/net/nil/nildummy/nildummy.c

    r4dd8529 r24ab58b3  
    6060/** The module name.
    6161 */
    62 #define NAME    "Dummy nil protocol"
     62#define NAME  "nildummy"
    6363
    6464/** Default maximum transmission unit.
    … …  
    228228                        return index;
    229229                }
    230                 printf("New device registered:\n\tid\t= %d\n\tservice\t= %d\n\tMTU\t= %d\n", device->device_id, device->service, device->mtu);
     230                printf("%s: Device registered (id: %d, service: %d, mtu: %d)\n",
     231                    NAME, device->device_id, device->service, device->mtu);
    231232        }
    232233        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    … …  
    290291        nildummy_globals.proto.service = service;
    291292        nildummy_globals.proto.phone = phone;
    292         printf("New protocol registered:\n\tservice\t= %d\n\tphone\t= %d\n", nildummy_globals.proto.service, nildummy_globals.proto.phone);
     293       
     294        printf("%s: Protocol registered (service: %d, phone: %d)\n",
     295            NAME, nildummy_globals.proto.service, nildummy_globals.proto.phone);
     296       
    293297        fibril_rwlock_write_unlock(&nildummy_globals.protos_lock);
    294298        return EOK;
    … …  
    312316}
    313317
    314 int nil_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     318int nil_message(const char *name, ipc_callid_t callid, ipc_call_t *call,
     319    ipc_call_t *answer, int *answer_count)
     320{
    315321        ERROR_DECLARE;
    316 
     322       
    317323        measured_string_ref address;
    318324        packet_t packet;
    … …  
    321327        size_t suffix;
    322328        size_t content;
    323 
    324 //      printf("message %d - %d\n", IPC_GET_METHOD(*call), NET_NIL_FIRST);
     329       
    325330        *answer_count = 0;
    326         switch(IPC_GET_METHOD(*call)){
     331        switch (IPC_GET_METHOD(*call)) {
    327332                case IPC_M_PHONE_HUNGUP:
    328333                        return EOK;
    329334                case NET_NIL_DEVICE:
    330                         return nildummy_device_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), IPC_GET_MTU(call));
     335                        return nildummy_device_message(IPC_GET_DEVICE(call),
     336                            IPC_GET_SERVICE(call), IPC_GET_MTU(call));
    331337                case NET_NIL_SEND:
    332                         ERROR_PROPAGATE(packet_translate(nildummy_globals.net_phone, &packet, IPC_GET_PACKET(call)));
    333                         return nildummy_send_message(IPC_GET_DEVICE(call), packet, IPC_GET_SERVICE(call));
     338                        ERROR_PROPAGATE(packet_translate(nildummy_globals.net_phone,
     339                            &packet, IPC_GET_PACKET(call)));
     340                        return nildummy_send_message(IPC_GET_DEVICE(call), packet,
     341                            IPC_GET_SERVICE(call));
    334342                case NET_NIL_PACKET_SPACE:
    335                         ERROR_PROPAGATE(nildummy_packet_space_message(IPC_GET_DEVICE(call), &addrlen, &prefix, &content, &suffix));
     343                        ERROR_PROPAGATE(nildummy_packet_space_message(IPC_GET_DEVICE(call),
     344                            &addrlen, &prefix, &content, &suffix));
    336345                        IPC_SET_ADDR(answer, addrlen);
    337346                        IPC_SET_PREFIX(answer, prefix);
    … …  
    341350                        return EOK;
    342351                case NET_NIL_ADDR:
    343                         ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call), &address));
     352                        ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call),
     353                            &address));
    344354                        return measured_strings_reply(address, 1);
    345355                case IPC_M_CONNECT_TO_ME:
    346                         return nildummy_register_message(NIL_GET_PROTO(call), IPC_GET_PHONE(call));
    347         }
     356                        return nildummy_register_message(NIL_GET_PROTO(call),
     357                            IPC_GET_PHONE(call));
     358        }
     359       
    348360        return ENOTSUP;
    349361}
    … …  
    404416               
    405417                /* Process the message */
    406                 int res = nil_module_message(callid, &call, &answer, &answer_count);
     418                int res = nil_module_message(NAME, callid, &call, &answer,
     419                    &answer_count);
    407420               
    408421                /* End if said to either by the message or the processing result */
    … …  
    428441        ERROR_DECLARE;
    429442       
    430         /* Print the module label */
    431         printf("Task %d - %s\n", task_get_id(), NAME);
    432        
    433443        /* Start the module */
    434         if (ERROR_OCCURRED(nil_module_start(nil_client_connection))) {
    435                 printf(" - ERROR %i\n", ERROR_CODE);
     444        if (ERROR_OCCURRED(nil_module_start(nil_client_connection)))
    436445                return ERROR_CODE;
    437         }
    438446       
    439447        return EOK;

  • uspace/srv/net/nil/nildummy/nildummy_module.c

    r4dd8529 r24ab58b3  
    5151#include "nildummy.h"
    5252
    53 /** Starts the dummy nil module.
    54  *  Initializes the client connection serving function, initializes the module, registers the module service and starts the async manager, processing IPC messages in an infinite loop.
    55  *  @param[in] client_connection The client connection processing function. The module skeleton propagates its own one.
    56  *  @returns EOK on success.
    57  *  @returns Other error codes as defined for the pm_init() function.
    58  *  @returns Other error codes as defined for the nil_initialize() function.
    59  *  @returns Other error codes as defined for the REGISTER_ME() macro function.
     53/** Start the dummy nil module.
     54 *
     55 * Initialize the client connection serving function, initialize
     56 * the module, register the module service and start the async
     57 * manager, processing IPC messages in an infinite loop.
     58 *
     59 * @param[in] client_connection The client connection processing
     60 *                              function. The module skeleton propagates
     61 *                              its own one.
     62 *
     63 * @return EOK on success.
     64 * @return Other error codes as defined for the pm_init() function.
     65 * @return Other error codes as defined for the nil_initialize() function.
     66 * @return Other error codes as defined for the REGISTER_ME() macro function.
     67 *
    6068 */
    61 int nil_module_start(async_client_conn_t client_connection){
     69int nil_module_start(async_client_conn_t client_connection)
     70{
    6271        ERROR_DECLARE;
    63 
     72       
     73        async_set_client_connection(client_connection);
     74        int net_phone = net_connect_module(SERVICE_NETWORKING);
     75        ERROR_PROPAGATE(pm_init());
     76       
    6477        ipcarg_t phonehash;
    65         int net_phone;
    66 
    67         async_set_client_connection(client_connection);
    68         net_phone = net_connect_module(SERVICE_NETWORKING);
    69         ERROR_PROPAGATE(pm_init());
    70         if(ERROR_OCCURRED(nil_initialize(net_phone))
    71                 || ERROR_OCCURRED(REGISTER_ME(SERVICE_NILDUMMY, &phonehash))){
     78        if (ERROR_OCCURRED(nil_initialize(net_phone))
     79            || ERROR_OCCURRED(REGISTER_ME(SERVICE_NILDUMMY, &phonehash))){
    7280                pm_destroy();
    7381                return ERROR_CODE;
    7482        }
    75 
     83       
    7684        async_manager();
    77 
     85       
    7886        pm_destroy();
    7987        return EOK;
    8088}
    8189
    82 /** Passes the parameters to the module specific nil_message() function.
    83  *  @param[in] callid The message identifier.
    84  *  @param[in] call The message parameters.
    85  *  @param[out] answer The message answer parameters.
    86  *  @param[out] answer_count The last parameter for the actual answer in the answer parameter.
    87  *  @returns EOK on success.
    88  *  @returns ENOTSUP if the message is not known.
    89  *  @returns Other error codes as defined for each specific module message function.
     90/** Pass the parameters to the module specific nil_message() function.
     91 *
     92 * @param[in]  name         Module name.
     93 * @param[in]  callid       The message identifier.
     94 * @param[in]  call         The message parameters.
     95 * @param[out] answer       The message answer parameters.
     96 * @param[out] answer_count The last parameter for the actual answer
     97 *                          in the answer parameter.
     98 *
     99 * @return EOK on success.
     100 * @return ENOTSUP if the message is not known.
     101 * @return Other error codes as defined for each specific
     102 *          module message function.
     103 *
    90104 */
    91 int nil_module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    92         return nil_message(callid, call, answer, answer_count);
     105int nil_module_message(const char *name, ipc_callid_t callid,
     106    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
     107{
     108        return nil_message(name, callid, call, answer, answer_count);
    93109}
    94110
Note: See TracChangeset for help on using the changeset viewer.