Changes in / [ec7f8b1:c4a8e4a] in mainline


Ignore:
Files:
1 added
4 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/include/asm.h

    rec7f8b1 rc4a8e4a  
    4141#include <trace.h>
    4242
    43 #define IO_SPACE_BOUNDARY       ((void *) (64 * 1024))
    44 
    4543/** Return base address of current stack.
    4644 *
    … …  
    7977}
    8078
     79#define IO_SPACE_BOUNDARY       ((void *) (64 * 1024))
     80
    8181/** Byte from port
    8282 *
    … …  
    9191        if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
    9292                uint8_t val;
    93                
    9493                asm volatile (
    9594                        "inb %w[port], %b[val]\n"
    … …  
    9796                        : [port] "d" (port)
    9897                );
    99                
    10098                return val;
    101         } else
     99        } else {
    102100                return (uint8_t) *port;
     101        }
    103102}
    104103
    … …  
    115114        if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
    116115                uint16_t val;
    117                
    118116                asm volatile (
    119117                        "inw %w[port], %w[val]\n"
    … …  
    121119                        : [port] "d" (port)
    122120                );
    123                
    124121                return val;
    125         } else
     122        } else {
    126123                return (uint16_t) *port;
     124        }
    127125}
    128126
    … …  
    139137        if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
    140138                uint32_t val;
    141                
    142139                asm volatile (
    143140                        "inl %w[port], %[val]\n"
    … …  
    145142                        : [port] "d" (port)
    146143                );
    147                
    148144                return val;
    149         } else
     145        } else {
    150146                return (uint32_t) *port;
     147        }
    151148}
    152149
    … …  
    166163                        :: [val] "a" (val), [port] "d" (port)
    167164                );     
    168         } else
     165        } else {
    169166                *port = val;
     167        }
    170168}
    171169
    … …  
    185183                        :: [val] "a" (val), [port] "d" (port)
    186184                );
    187         } else
     185        } else {
    188186                *port = val;
     187        }
    189188}
    190189
    … …  
    204203                        :: [val] "a" (val), [port] "d" (port)
    205204                );
    206         } else
     205        } else {
    207206                *port = val;
     207        }
    208208}
    209209

  • kernel/arch/ia32/include/asm.h

    rec7f8b1 rc4a8e4a  
    118118                        :: [val] "a" (val), [port] "d" (port)
    119119                );     
    120         } else
     120        } else {
    121121                *port = val;
     122        }
    122123}
    123124
    … …  
    137138                        :: [val] "a" (val), [port] "d" (port)
    138139                );
    139         } else
     140        } else {
    140141                *port = val;
     142        }
    141143}
    142144
    … …  
    156158                        :: [val] "a" (val), [port] "d" (port)
    157159                );
    158         } else
     160        } else {
    159161                *port = val;
     162        }
    160163}
    161164
    … …  
    172175        if (((void *)port) < IO_SPACE_BOUNDARY) {
    173176                uint8_t val;
    174                
    175177                asm volatile (
    176178                        "inb %w[port], %b[val]\n"
    … …  
    178180                        : [port] "d" (port)
    179181                );
    180                
    181182                return val;
    182         } else
     183        } else {
    183184                return (uint8_t) *port;
     185        }
    184186}
    185187
    … …  
    196198        if (((void *)port) < IO_SPACE_BOUNDARY) {
    197199                uint16_t val;
    198                
    199200                asm volatile (
    200201                        "inw %w[port], %w[val]\n"
    … …  
    202203                        : [port] "d" (port)
    203204                );
    204                
    205205                return val;
    206         } else
     206        } else {
    207207                return (uint16_t) *port;
     208        }
    208209}
    209210
    … …  
    220221        if (((void *)port) < IO_SPACE_BOUNDARY) {
    221222                uint32_t val;
    222                
    223223                asm volatile (
    224224                        "inl %w[port], %[val]\n"
    … …  
    226226                        : [port] "d" (port)
    227227                );
    228                
    229228                return val;
    230         } else
     229        } else {
    231230                return (uint32_t) *port;
     231        }
    232232}
    233233

  • uspace/Makefile

    rec7f8b1 rc4a8e4a  
    176176        lib/block \
    177177        lib/clui \
    178         lib/fmtutil \
    179178        lib/scsi \
    180179        lib/softint \

  • uspace/Makefile.common

    rec7f8b1 rc4a8e4a  
    112112LIBIMGMAP_PREFIX = $(LIB_PREFIX)/imgmap
    113113LIBCLUI_PREFIX = $(LIB_PREFIX)/clui
    114 LIBFMTUTIL_PREFIX = $(LIB_PREFIX)/fmtutil
    115114
    116115LIBEXT2_PREFIX = $(LIB_PREFIX)/ext2

  • uspace/app/bdsh/Makefile

    rec7f8b1 rc4a8e4a  
    2929
    3030USPACE_PREFIX = ../..
    31 LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBCLUI_PREFIX)/libclui.a \
    32         $(LIBFMTUTIL_PREFIX)/libfmtutil.a
    33 EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCLUI_PREFIX) \
    34         -I$(LIBFMTUTIL_PREFIX) -I. -Icmds/ -Icmds/builtins -Icmds/modules
     31LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBCLUI_PREFIX)/libclui.a
     32EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCLUI_PREFIX) -I. -Icmds/ \
     33        -Icmds/builtins -Icmds/modules
    3534BINARY = bdsh
    3635

  • uspace/app/bdsh/cmds/modules/help/help.c

    rec7f8b1 rc4a8e4a  
    11/*
    22 * Copyright (c) 2008 Tim Post
    3  * Copyright (c) 2011 Martin Sucha
    43 * All rights reserved.
    54 *
    … …  
    3130#include <stdlib.h>
    3231#include <str.h>
    33 #include <fmtutil.h>
    3432
    3533#include "config.h"
    … …  
    130128static void help_survival(void)
    131129{
    132         print_wrapped_console(
    133             "Don't panic!\n\n"
     130        printf("Don't panic!\n\n");
    134131
    135             "This is Bdsh, the Brain dead shell, currently "
     132        printf("This is Bdsh, the Brain dead shell, currently "
    136133            "the primary user interface to HelenOS. Bdsh allows you to enter "
    137134            "commands and supports history (Up, Down arrow keys), "
    138135            "line editing (Left Arrow, Right Arrow, Home, End, Backspace), "
    139136            "selection (Shift + movement keys), copy and paste (Ctrl-C, "
    140             "Ctrl-V), similar to common desktop environments.\n\n"
     137            "Ctrl-V), similar to common desktop environments.\n\n");
    141138
    142             "The most basic filesystem commands are Bdsh builtins. Type "
     139        printf("The most basic filesystem commands are Bdsh builtins. Type "
    143140            "'help commands' [Enter] to see the list of Bdsh builtin commands. "
    144141            "Other commands are external executables located in the /app and "
    145142            "/srv directories. Type 'ls /app' [Enter] and 'ls /srv' [Enter] "
    146143            "to see their list. You can execute an external command simply "
    147             "by entering its name (e.g. type 'tetris' [Enter]).\n\n"
     144            "by entering its name (e.g. type 'tetris' [Enter]).\n\n");
    148145
    149             "HelenOS has virtual consoles (VCs). You can switch between "
    150             "these using the F1-F11 keys.\n\n"
     146        printf("HelenOS has virtual consoles (VCs). You can switch between "
     147            "these using the F1-F11 keys.\n\n");
    151148
    152             "This is but a small glimpse of what you can do with HelenOS. "
     149        printf("This is but a small glimpse of what you can do with HelenOS. "
    153150            "To learn more please point your browser to the HelenOS User's "
    154             "Guide: http://trac.helenos.org/wiki/UsersGuide\n\n",
    155             ALIGN_LEFT);
     151            "Guide: http://trac.helenos.org/trac.fcgi/wiki/UsersGuide\n\n");
    156152}
    157153

  • uspace/app/bdsh/compl.c

    rec7f8b1 rc4a8e4a  
    9090{
    9191        compl_t *cs = NULL;
     92        size_t pref_size;
    9293        char *stext = NULL;
    9394        char *prefix = NULL;
    9495        char *dirname = NULL;
    95         int retval;
    96        
    97         token_t *tokens = calloc(WORD_MAX, sizeof(token_t));
    98         if (tokens == NULL) {
    99                 retval = ENOMEM;
    100                 goto error;
    101         }
    102        
    103         size_t pref_size;
    10496        char *rpath_sep;
    10597        static const char *dirlist_arg[] = { ".", NULL };
     98        int retval;
    10699        tokenizer_t tok;
    107         ssize_t current_token;
     100        token_t tokens[WORD_MAX];
     101        unsigned int current_token;
    108102        size_t tokens_length;
    109        
     103
    110104        cs = calloc(1, sizeof(compl_t));
    111105        if (!cs) {
    … …  
    113107                goto error;
    114108        }
    115        
     109
    116110        /* Convert text buffer to string */
    117111        stext = wstr_to_astr(text);
    … …  
    133127       
    134128        /* Find the current token */
    135         for (current_token = 0; current_token < (ssize_t) tokens_length;
    136             current_token++) {
     129        for (current_token = 0; current_token < tokens_length; current_token++) {
    137130                token_t *t = &tokens[current_token];
    138131                size_t end = t->char_start + t->char_length;
    139                
    140                 /*
    141                  * Check if the caret lies inside the token or immediately
     132                /* Check if the caret lies inside the token or immediately
    142133                 * after it
    143134                 */
    … …  
    147138        }
    148139       
    149         if (tokens_length == 0)
    150                 current_token = -1;
    151        
    152         if ((current_token >= 0) && (tokens[current_token].type != TOKTYPE_SPACE))
     140        if (tokens[current_token].type != TOKTYPE_SPACE) {
    153141                *cstart = tokens[current_token].char_start;
    154         else
     142        }
     143        else {
    155144                *cstart = pos;
    156        
    157         /*
    158          * Extract the prefix being completed
     145        }
     146       
     147        /* Extract the prefix being completed
    159148         * XXX: handle strings, etc.
    160149         */
    … …  
    165154                goto error;
    166155        }
    167         prefix[pref_size] = 0;
    168 
    169         if (current_token >= 0) {
    170                 str_ncpy(prefix, pref_size + 1, stext +
    171                     tokens[current_token].byte_start, pref_size);
    172         }
     156
     157        str_ncpy(prefix, pref_size + 1, stext +
     158            tokens[current_token].byte_start, pref_size);
    173159
    174160        /*
    … …  
    179165
    180166        /* Skip any whitespace before current token */
    181         ssize_t prev_token = current_token - 1;
    182         if ((prev_token >= 0) && (tokens[prev_token].type == TOKTYPE_SPACE))
     167        int prev_token = current_token - 1;
     168        if (prev_token != -1 && tokens[prev_token].type == TOKTYPE_SPACE) {
    183169                prev_token--;
    184        
     170        }
     171
    185172        /*
    186173         * It is a command if it is the first token or if it immediately
    187174         * follows a pipe token.
    188175         */
    189         if ((prev_token < 0) || (tokens[prev_token].type == TOKTYPE_SPACE))
     176        if (prev_token == -1 || tokens[prev_token].type == TOKTYPE_SPACE)
    190177                cs->is_command = true;
    191178        else
    … …  
    262249        if (cs != NULL)
    263250                free(cs);
    264         if (tokens != NULL)
    265                 free(tokens);
    266251
    267252        return retval;

  • uspace/app/bdsh/input.c

    rec7f8b1 rc4a8e4a  
    6767int process_input(cliuser_t *usr)
    6868{
    69         token_t *tokens = calloc(WORD_MAX, sizeof(token_t));
    70         if (tokens == NULL)
    71                 return ENOMEM;
    72        
    7369        char *cmd[WORD_MAX];
     70        token_t tokens_space[WORD_MAX];
     71        token_t *tokens = tokens_space;
    7472        int rc = 0;
    7573        tokenizer_t tok;
    … …  
    7977        char *redir_to = NULL;
    8078
    81         if (usr->line == NULL) {
    82                 free(tokens);
     79        if (NULL == usr->line)
    8380                return CL_EFAIL;
    84         }
    8581
    8682        rc = tok_init(&tok, usr->line, tokens, WORD_MAX);
    … …  
    213209        }
    214210        tok_fini(&tok);
    215         free(tokens);
    216211
    217212        return rc;

  • uspace/app/tester/stdio/stdio1.c

    rec7f8b1 rc4a8e4a  
    3939{
    4040        FILE *file;
    41         const char *file_name = "/textdemo";
     41        const char *file_name = "/readme";
    4242       
    4343        TPRINTF("Open file \"%s\"...", file_name);

  • uspace/dist/src/sysel/demos/htxtfile.sy

    rec7f8b1 rc4a8e4a  
    3535                var out_file : TextFile;
    3636
    37                 name = "/textdemo";
     37                name = "/readme";
    3838
    3939                in_file = new TextFile();

  • uspace/lib/c/arch/ia32/include/ddi.h

    rec7f8b1 rc4a8e4a  
    4343        if (port < (ioport8_t *) IO_SPACE_BOUNDARY) {
    4444                uint8_t val;
    45                
    4645                asm volatile (
    4746                        "inb %w[port], %b[val]\n"
    … …  
    4948                        : [port] "d" (port)
    5049                );
    51                
    5250                return val;
    53         } else
     51        } else {
    5452                return (uint8_t) *port;
     53        }
    5554}
    5655
    … …  
    5958        if (port < (ioport16_t *) IO_SPACE_BOUNDARY) {
    6059                uint16_t val;
    61                
    6260                asm volatile (
    6361                        "inw %w[port], %w[val]\n"
    … …  
    6563                        : [port] "d" (port)
    6664                );
    67                
    6865                return val;
    69         } else
     66        } else {
    7067                return (uint16_t) *port;
     68        }
    7169}
    7270
    … …  
    7573        if (port < (ioport32_t *) IO_SPACE_BOUNDARY) {
    7674                uint32_t val;
    77                
    7875                asm volatile (
    7976                        "inl %w[port], %[val]\n"
    … …  
    8178                        : [port] "d" (port)
    8279                );
    83                
    8480                return val;
    85         } else
     81        } else {
    8682                return (uint32_t) *port;
     83        }
    8784}
    8885
    … …  
    9491                        :: [val] "a" (val), [port] "d" (port)
    9592                );     
    96         } else
     93        } else {
    9794                *port = val;
     95        }
    9896}
    9997
    … …  
    105103                        :: [val] "a" (val), [port] "d" (port)
    106104                );
    107         } else
     105        } else {
    108106                *port = val;
     107        }
    109108}
    110109
    … …  
    116115                        :: [val] "a" (val), [port] "d" (port)
    117116                );
    118         } else
     117        } else {
    119118                *port = val;
     119        }
    120120}
    121121

  • uspace/lib/c/generic/async.c

    rec7f8b1 rc4a8e4a  
    16561656       
    16571657        return sess;
    1658 }
    1659 
    1660 /** Set arguments for new connections.
    1661  *
    1662  * FIXME This is an ugly hack to work around the problem that parallel
    1663  * exchanges are implemented using parallel connections. When we create
    1664  * a callback session, the framework does not know arguments for the new
    1665  * connections.
    1666  *
    1667  * The proper solution seems to be to implement parallel exchanges using
    1668  * tagging.
    1669  */
    1670 void async_sess_args_set(async_sess_t *sess, sysarg_t arg1, sysarg_t arg2,
    1671     sysarg_t arg3)
    1672 {
    1673         sess->arg1 = arg1;
    1674         sess->arg2 = arg2;
    1675         sess->arg3 = arg3;
    16761658}
    16771659

  • uspace/lib/c/generic/devman.c

    rec7f8b1 rc4a8e4a  
    8989                        if (devman_driver_block_sess == NULL)
    9090                                devman_driver_block_sess =
    91                                     service_connect_blocking(EXCHANGE_PARALLEL,
     91                                    service_connect_blocking(EXCHANGE_SERIALIZE,
    9292                                    SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
    9393                }
    … …  
    138138                if (devman_driver_sess == NULL)
    139139                        devman_driver_sess =
    140                             service_connect(EXCHANGE_PARALLEL, SERVICE_DEVMAN,
     140                            service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
    141141                            DEVMAN_DRIVER, 0);
    142142               

  • uspace/lib/c/generic/ns.c

    rec7f8b1 rc4a8e4a  
    5656        async_exchange_end(exch);
    5757       
    58         /*
    59          * FIXME Ugly hack to work around limitation of implementing
    60          * parallel exchanges using multiple connections. Shift out
    61          * first argument for non-initial connections.
    62          */
    63         async_sess_args_set(sess, arg2, arg3, 0);
    64        
    6558        return sess;
    6659}
    … …  
    7366            async_connect_me_to_blocking(mgmt, exch, service, arg2, arg3);
    7467        async_exchange_end(exch);
    75        
    76         /*
    77          * FIXME Ugly hack to work around limitation of implementing
    78          * parallel exchanges using multiple connections. Shift out
    79          * first argument for non-initial connections.
    80          */
    81         async_sess_args_set(sess, arg2, arg3, 0);
    8268       
    8369        return sess;

  • uspace/lib/c/generic/str.c

    rec7f8b1 rc4a8e4a  
    22 * Copyright (c) 2005 Martin Decky
    33 * Copyright (c) 2008 Jiri Svoboda
    4  * Copyright (c) 2011 Martin Sucha
    54 * All rights reserved.
    65 *
    … …  
    719718
    720719        dest[dlen - 1] = '\0';
    721 }
    722 
    723 /** Convert string to wide string.
    724  *
    725  * Convert string @a src to wide string. A new wide NULL-terminated
    726  * string will be allocated on the heap.
    727  *
    728  * @param src   Source string.
    729  */
    730 wchar_t *str_to_awstr(const char *str)
    731 {
    732         size_t len = str_length(str);
    733        
    734         wchar_t *wstr = calloc(len+1, sizeof(wchar_t));
    735         if (wstr == NULL)
    736                 return NULL;
    737        
    738         str_to_wstr(wstr, len + 1, str);
    739         return wstr;
    740720}
    741721

  • uspace/lib/c/include/async.h

    rec7f8b1 rc4a8e4a  
    337337
    338338/*
    339  * FIXME These functions just work around problems with parallel exchange
    340  * management. Proper solution needs to be implemented.
    341  */
    342 void async_sess_args_set(async_sess_t *sess, sysarg_t, sysarg_t, sysarg_t);
    343 
    344 /*
    345339 * User-friendly wrappers for async_share_in_start().
    346340 */

  • uspace/lib/c/include/str.h

    rec7f8b1 rc4a8e4a  
    8383extern char *wstr_to_astr(const wchar_t *src);
    8484extern void str_to_wstr(wchar_t *dest, size_t dlen, const char *src);
    85 extern wchar_t *str_to_awstr(const char *src);
    8685
    8786extern char *str_chr(const char *str, wchar_t ch);

  • uspace/srv/devman/devman.h

    rec7f8b1 rc4a8e4a  
    6363typedef struct fun_node fun_node_t;
    6464
    65 typedef struct {
    66         fibril_mutex_t mutex;
    67         struct driver *driver;
    68 } client_t;
    69 
    7065typedef enum {
    7166        /** Driver has not been started. */

  • uspace/srv/devman/main.c

    rec7f8b1 rc4a8e4a  
    6565static dev_tree_t device_tree;
    6666
    67 static int init_running_drv(void *drv);
    68 
    6967/** Register running driver. */
    70 static driver_t *devman_driver_register(ipc_callid_t callid, ipc_call_t *call)
    71 {
     68static driver_t *devman_driver_register(void)
     69{
     70        ipc_call_t icall;
     71        ipc_callid_t iid;
    7272        driver_t *driver = NULL;
     73
     74        log_msg(LVL_DEBUG, "devman_driver_register");
     75       
     76        iid = async_get_call(&icall);
     77        if (IPC_GET_IMETHOD(icall) != DEVMAN_DRIVER_REGISTER) {
     78                async_answer_0(iid, EREFUSED);
     79                return NULL;
     80        }
     81       
    7382        char *drv_name = NULL;
    74 
    75         log_msg(LVL_DEBUG, "devman_driver_register");
    7683       
    7784        /* Get driver name. */
    7885        int rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
    7986        if (rc != EOK) {
    80                 async_answer_0(callid, rc);
     87                async_answer_0(iid, rc);
    8188                return NULL;
    8289        }
    … …  
    9198                free(drv_name);
    9299                drv_name = NULL;
    93                 async_answer_0(callid, ENOENT);
     100                async_answer_0(iid, ENOENT);
    94101                return NULL;
    95102        }
    … …  
    105112                    driver->name);
    106113                fibril_mutex_unlock(&driver->driver_mutex);
    107                 async_answer_0(callid, EEXISTS);
     114                async_answer_0(iid, EEXISTS);
    108115                return NULL;
    109116        }
    … …  
    127134        log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
    128135            driver->name);
    129         driver->sess = async_callback_receive(EXCHANGE_PARALLEL);
     136        driver->sess = async_callback_receive(EXCHANGE_SERIALIZE);
    130137        if (!driver->sess) {
    131138                fibril_mutex_unlock(&driver->driver_mutex);
    132                 async_answer_0(callid, ENOTSUP);
     139                async_answer_0(iid, ENOTSUP);
    133140                return NULL;
    134141        }
    135         /* FIXME: Work around problem with callback sessions */
    136         async_sess_args_set(driver->sess, DRIVER_DEVMAN, 0, 0);
     142       
     143        fibril_mutex_unlock(&driver->driver_mutex);
    137144       
    138145        log_msg(LVL_NOTE,
    … …  
    140147            driver->name);
    141148       
    142         /*
    143          * Initialize the driver as running (e.g. pass assigned devices to it)
    144          * in a separate fibril; the separate fibril is used to enable the
    145          * driver to use devman service during the driver's initialization.
    146          */
    147         fid_t fid = fibril_create(init_running_drv, driver);
    148         if (fid == 0) {
    149                 log_msg(LVL_ERROR, "Failed to create initialization fibril " \
    150                     "for driver `%s'.", driver->name);
    151                 fibril_mutex_unlock(&driver->driver_mutex);
    152                 async_answer_0(callid, ENOMEM);
    153                 return NULL;
    154         }
    155        
    156         fibril_add_ready(fid);
    157         fibril_mutex_unlock(&driver->driver_mutex);
    158        
    159         async_answer_0(callid, EOK);
     149        async_answer_0(iid, EOK);
     150       
    160151        return driver;
    161152}
    … …  
    438429static void devman_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
    439430{
    440         client_t *client;
    441         driver_t *driver;
    442        
    443431        /* Accept the connection. */
    444432        async_answer_0(iid, EOK);
    445433       
    446         client = async_get_client_data();
    447         if (client == NULL) {
    448                 log_msg(LVL_ERROR, "Failed to allocate client data.");
    449                 return;
    450         }
     434        driver_t *driver = devman_driver_register();
     435        if (driver == NULL)
     436                return;
     437       
     438        /*
     439         * Initialize the driver as running (e.g. pass assigned devices to it)
     440         * in a separate fibril; the separate fibril is used to enable the
     441         * driver to use devman service during the driver's initialization.
     442         */
     443        fid_t fid = fibril_create(init_running_drv, driver);
     444        if (fid == 0) {
     445                log_msg(LVL_ERROR, "Failed to create initialization fibril " \
     446                    "for driver `%s'.", driver->name);
     447                return;
     448        }
     449        fibril_add_ready(fid);
    451450       
    452451        while (true) {
    … …  
    457456                        break;
    458457               
    459                 if (IPC_GET_IMETHOD(call) != DEVMAN_DRIVER_REGISTER) {
    460                         fibril_mutex_lock(&client->mutex);
    461                         driver = client->driver;
    462                         fibril_mutex_unlock(&client->mutex);
    463                         if (driver == NULL) {
    464                                 /* First call must be to DEVMAN_DRIVER_REGISTER */
    465                                 async_answer_0(callid, ENOTSUP);
    466                                 continue;
    467                         }
    468                 }
    469                
    470458                switch (IPC_GET_IMETHOD(call)) {
    471                 case DEVMAN_DRIVER_REGISTER:
    472                         fibril_mutex_lock(&client->mutex);
    473                         if (client->driver != NULL) {
    474                                 fibril_mutex_unlock(&client->mutex);
    475                                 async_answer_0(callid, EINVAL);
    476                                 continue;
    477                         }
    478                         client->driver = devman_driver_register(callid, &call);
    479                         fibril_mutex_unlock(&client->mutex);
    480                         break;
    481459                case DEVMAN_ADD_FUNCTION:
    482460                        devman_add_function(callid, &call);
    … …  
    836814static void devman_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    837815{
    838         /* Select port. */
     816        /* Select interface. */
    839817        switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
    840818        case DEVMAN_DRIVER:
    … …  
    862840}
    863841
    864 static void *devman_client_data_create(void)
    865 {
    866         client_t *client;
    867        
    868         client = calloc(1, sizeof(client_t));
    869         if (client == NULL)
    870                 return NULL;
    871        
    872         fibril_mutex_initialize(&client->mutex);
    873         return client;
    874 }
    875 
    876 static void devman_client_data_destroy(void *data)
    877 {
    878         free(data);
    879 }
    880 
    881842/** Initialize device manager internal structures. */
    882843static bool devman_init(void)
    … …  
    925886        }
    926887       
    927         /* Set handlers for incoming connections. */
    928         async_set_client_data_constructor(devman_client_data_create);
    929         async_set_client_data_destructor(devman_client_data_destroy);
     888        /* Set a handler of incomming connections. */
    930889        async_set_client_connection(devman_connection);
    931890
Note: See TracChangeset for help on using the changeset viewer.