Changeset c6ba274 in mainline


Ignore:
Timestamp:
2011-04-02T12:49:33Z (14 years ago)
Author:
Matus Dekanek <smekideki@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8123695a
Parents:
a9c7c6f (diff), 969585f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge with usb/development

Files:
6 added
1 deleted
24 edited

Legend:

Unmodified
Added
Removed
  • HelenOS.config

    ra9c7c6f rc6ba274  
    528528! [PLATFORM=sparc64&MACHINE=generic] CONFIG_AOUT_ISOFS_B (y)
    529529
     530% Run devman on startup
     531! CONFIG_START_DEVMAN (y)
     532
     533% Launch (devman) test drivers
     534! [CONFIG_START_DEVMAN=y&CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (y/n)
     535
    530536% Load disk drivers on startup
    531537! CONFIG_START_BD (n/y)
     
    549555! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)
    550556
    551 % Launch (devman) test drivers
    552 ! [CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (n/y)
    553 
    554557% Start virtual USB host controller
    555558! CONFIG_RUN_VIRTUAL_USB_HC (n/y)
     
    560563% Run devman in kconsole (not recommended)
    561564! CONFIG_DEVMAN_EARLY_LAUNCH (n/y)
    562 
  • uspace/app/bdsh/cmds/modules/ls/ls.c

    ra9c7c6f rc6ba274  
    3838#include <dirent.h>
    3939#include <fcntl.h>
     40#include <getopt.h>
    4041#include <sys/types.h>
    4142#include <sys/stat.h>
    4243#include <str.h>
     44#include <sort.h>
    4345
    4446#include "errors.h"
     
    4648#include "util.h"
    4749#include "entry.h"
    48 #include "ls.h"
    4950#include "cmds.h"
    5051
     52/* Various values that can be returned by ls_scope() */
     53#define LS_BOGUS 0
     54#define LS_FILE  1
     55#define LS_DIR   2
     56
     57/** Structure to represent a directory entry.
     58 *
     59 * Useful to keep together important information
     60 * for sorting directory entries.
     61 */
     62struct dir_elem_t {
     63        char *name;
     64        struct stat s;
     65};
     66
    5167static const char *cmdname = "ls";
    5268
    53 static void ls_scan_dir(const char *d, DIR *dirp)
    54 {
     69static struct option const long_options[] = {
     70        { "help", no_argument, 0, 'h' },
     71        { "unsort", no_argument, 0, 'u' },
     72        { 0, 0, 0, 0 }
     73};
     74
     75/** Print an entry.
     76 *
     77 * ls_print currently does nothing more than print the entry.
     78 * In the future, we will likely pass the absolute path, and
     79 * some sort of ls_options structure that controls how each
     80 * entry is printed and what is printed about it.
     81 *
     82 * Now we just print basic DOS style lists.
     83 *
     84 * @param de            Directory element.
     85 */
     86static void ls_print(struct dir_elem_t *de)
     87{
     88        if (de->s.is_file)
     89                printf("%-40s\t%llu\n", de->name, (long long) de->s.size);
     90        else if (de->s.is_directory)
     91                printf("%-40s\t<dir>\n", de->name);
     92        else
     93                printf("%-40s\n", de->name);
     94}
     95
     96
     97/** Compare 2 directory elements.
     98 *
     99 * It compares 2 elements of a directory : a file is considered
     100 * as bigger than a directory, and if they have the same type,
     101 * they are compared alphabetically.
     102 *
     103 * @param a             Pointer to the structure of the first element.
     104 * @param b             Pointer to the structure of the second element.
     105 * @param arg           Pointer for an other and optionnal argument.
     106 *
     107 * @return              -1 if a < b, 1 otherwise.
     108 */
     109static int ls_cmp(void *a, void *b, void *arg)
     110{
     111        struct dir_elem_t *da = a;
     112        struct dir_elem_t *db = b;
     113       
     114        if ((da->s.is_directory && db->s.is_file) ||
     115            ((da->s.is_directory == db->s.is_directory) &&
     116            str_cmp(da->name, db->name) < 0))
     117                return -1;
     118        else
     119                return 1;
     120}
     121
     122/** Scan a directory.
     123 *
     124 * Scan the content of a directory and print it.
     125 *
     126 * @param d             Name of the directory.
     127 * @param dirp  Directory stream.
     128 * @param sort  1 if the output must be sorted,
     129 *                              0 otherwise.
     130 */
     131static void ls_scan_dir(const char *d, DIR *dirp, int sort)
     132{
     133        int alloc_blocks = 20;
     134        int i;
     135        int nbdirs = 0;
     136        int rc;
     137        int len;
     138        char *buff;
     139        struct dir_elem_t *tmp;
     140        struct dir_elem_t *tosort;
    55141        struct dirent *dp;
    56         char *buff;
    57 
    58         if (! dirp)
     142       
     143        if (!dirp)
    59144                return;
    60145
    61         buff = (char *)malloc(PATH_MAX);
    62         if (NULL == buff) {
     146        buff = (char *) malloc(PATH_MAX);
     147        if (!buff) {
    63148                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
    64149                return;
    65150        }
    66 
     151       
     152        tosort = (struct dir_elem_t *) malloc(alloc_blocks * sizeof(*tosort));
     153        if (!tosort) {
     154                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     155                free(buff);
     156                return;
     157        }
     158       
    67159        while ((dp = readdir(dirp))) {
    68                 memset(buff, 0, sizeof(buff));
    69                 /* Don't worry if inserting a double slash, this will be fixed by
    70                  * absolutize() later with subsequent calls to open() or readdir() */
    71                 snprintf(buff, PATH_MAX - 1, "%s/%s", d, dp->d_name);
    72                 ls_print(dp->d_name, buff);
    73         }
    74 
     160                if (nbdirs + 1 > alloc_blocks) {
     161                        alloc_blocks += alloc_blocks;
     162                       
     163                        tmp = (struct dir_elem_t *) realloc(tosort,
     164                            alloc_blocks * sizeof(struct dir_elem_t));
     165                        if (!tmp) {
     166                                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     167                                goto out;
     168                        }
     169                        tosort = tmp;
     170                }
     171               
     172                /* fill the name field */
     173                tosort[nbdirs].name = (char *) malloc(str_length(dp->d_name) + 1);
     174                if (!tosort[nbdirs].name) {
     175                        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     176                        goto out;
     177                }
     178               
     179                str_cpy(tosort[nbdirs].name, str_length(dp->d_name) + 1, dp->d_name);
     180                len = snprintf(buff, PATH_MAX - 1, "%s/%s", d, tosort[nbdirs].name);
     181                buff[len] = '\0';
     182
     183                rc = stat(buff, &tosort[nbdirs++].s);
     184                if (rc != 0) {
     185                        printf("ls: skipping bogus node %s\n", buff);
     186                        printf("rc=%d\n", rc);
     187                        goto out;
     188                }
     189        }
     190       
     191        if (sort) {
     192                if (!qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t),
     193                    ls_cmp, NULL)) {
     194                        printf("Sorting error.\n");
     195                }
     196        }
     197       
     198        for (i = 0; i < nbdirs; i++)
     199                ls_print(&tosort[i]);
     200       
     201out:
     202        for(i = 0; i < nbdirs; i++)
     203                free(tosort[i].name);
     204        free(tosort);
    75205        free(buff);
    76 
    77         return;
    78 }
    79 
    80 /* ls_print currently does nothing more than print the entry.
    81  * in the future, we will likely pass the absolute path, and
    82  * some sort of ls_options structure that controls how each
    83  * entry is printed and what is printed about it.
    84  *
    85  * Now we just print basic DOS style lists */
    86 
    87 static void ls_print(const char *name, const char *pathname)
    88 {
    89         struct stat s;
    90         int rc;
    91 
    92         rc = stat(pathname, &s);
    93         if (rc != 0) {
    94                 /* Odd chance it was deleted from the time readdir() found it */
    95                 printf("ls: skipping bogus node %s\n", pathname);
    96                 printf("rc=%d\n", rc);
    97                 return;
    98         }
    99        
    100         if (s.is_file)
    101                 printf("%-40s\t%llu\n", name, (long long) s.size);
    102         else if (s.is_directory)
    103                 printf("%-40s\t<dir>\n", name);
    104         else
    105                 printf("%-40s\n", name);
    106 
    107         return;
    108206}
    109207
     
    114212        } else {
    115213                help_cmd_ls(HELP_SHORT);
    116                 printf("  `%s' [path], if no path is given the current "
    117                                 "working directory is used.\n", cmdname);
     214                printf(
     215                "Usage:  %s [options] [path]\n"
     216                "If not path is given, the current working directory is used.\n"
     217                "Options:\n"
     218                "  -h, --help       A short option summary\n"
     219                "  -u, --unsort     Do not sort directory entries\n",
     220                cmdname);
    118221        }
    119222
     
    124227{
    125228        unsigned int argc;
    126         struct stat s;
    127         char *buff;
     229        struct dir_elem_t de;
    128230        DIR *dirp;
     231        int c, opt_ind;
     232        int sort = 1;
    129233
    130234        argc = cli_count_args(argv);
    131 
    132         buff = (char *) malloc(PATH_MAX);
    133         if (NULL == buff) {
     235       
     236        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
     237                c = getopt_long(argc, argv, "hu", long_options, &opt_ind);
     238                switch (c) {
     239                case 'h':
     240                        help_cmd_ls(HELP_LONG);
     241                        return CMD_SUCCESS;
     242                case 'u':
     243                        sort = 0;
     244                        break;
     245                }
     246        }
     247       
     248        argc -= optind;
     249       
     250        de.name = (char *) malloc(PATH_MAX);
     251        if (!de.name) {
    134252                cli_error(CL_ENOMEM, "%s: ", cmdname);
    135253                return CMD_FAILURE;
    136254        }
    137         memset(buff, 0, sizeof(buff));
    138 
    139         if (argc == 1)
    140                 getcwd(buff, PATH_MAX);
     255        memset(de.name, 0, sizeof(PATH_MAX));
     256       
     257        if (argc == 0)
     258                getcwd(de.name, PATH_MAX);
    141259        else
    142                 str_cpy(buff, PATH_MAX, argv[1]);
    143 
    144         if (stat(buff, &s)) {
    145                 cli_error(CL_ENOENT, buff);
    146                 free(buff);
     260                str_cpy(de.name, PATH_MAX, argv[optind]);
     261       
     262        if (stat(de.name, &de.s)) {
     263                cli_error(CL_ENOENT, de.name);
     264                free(de.name);
    147265                return CMD_FAILURE;
    148266        }
    149267
    150         if (s.is_file) {
    151                 ls_print(buff, buff);
     268        if (de.s.is_file) {
     269                ls_print(&de);
    152270        } else {
    153                 dirp = opendir(buff);
     271                dirp = opendir(de.name);
    154272                if (!dirp) {
    155273                        /* May have been deleted between scoping it and opening it */
    156                         cli_error(CL_EFAIL, "Could not stat %s", buff);
    157                         free(buff);
     274                        cli_error(CL_EFAIL, "Could not stat %s", de.name);
     275                        free(de.name);
    158276                        return CMD_FAILURE;
    159277                }
    160                 ls_scan_dir(buff, dirp);
     278                ls_scan_dir(de.name, dirp, sort);
    161279                closedir(dirp);
    162280        }
    163281
    164         free(buff);
     282        free(de.name);
    165283
    166284        return CMD_SUCCESS;
  • uspace/app/init/init.c

    ra9c7c6f rc6ba274  
    314314        getterm("term/vc6", "/app/klog", false);
    315315
     316#ifdef CONFIG_START_DEVMAN
     317
    316318#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
    317319        spawn("/srv/devman");
     
    320322#endif
    321323
     324#endif
     325
    322326        return 0;
    323327}
  • uspace/app/tester/Makefile

    ra9c7c6f rc6ba274  
    5454        mm/malloc1.c \
    5555        mm/mapping1.c \
     56        devs/devman1.c \
    5657        hw/misc/virtchar1.c \
    5758        hw/serial/serial1.c
  • uspace/app/tester/tester.c

    ra9c7c6f rc6ba274  
    6666#include "adt/usbaddrkeep.def"
    6767#include "hw/misc/virtchar1.def"
     68#include "devs/devman1.def"
    6869        {NULL, NULL, NULL, false}
    6970};
  • uspace/app/tester/tester.h

    ra9c7c6f rc6ba274  
    8282extern const char *test_usbaddrkeep(void);
    8383extern const char *test_virtchar1(void);
     84extern const char *test_devman1(void);
    8485
    8586extern test_t tests[];
  • uspace/drv/isa/isa.c

    ra9c7c6f rc6ba274  
    5353
    5454#include <ddf/driver.h>
     55#include <ddf/log.h>
    5556#include <ops/hw_res.h>
    5657
     
    134135        fd = open(conf_path, O_RDONLY);
    135136        if (fd < 0) {
    136                 printf(NAME ": unable to open %s\n", conf_path);
     137                ddf_msg(LVL_ERROR, "Unable to open %s", conf_path);
    137138                goto cleanup;
    138139        }
     
    141142
    142143        len = lseek(fd, 0, SEEK_END);
    143         lseek(fd, 0, SEEK_SET); 
     144        lseek(fd, 0, SEEK_SET);
    144145        if (len == 0) {
    145                 printf(NAME ": fun_conf_read error: configuration file '%s' "
    146                     "is empty.\n", conf_path);
     146                ddf_msg(LVL_ERROR, "Configuration file '%s' is empty.",
     147                    conf_path);
    147148                goto cleanup;
    148149        }
     
    150151        buf = malloc(len + 1);
    151152        if (buf == NULL) {
    152                 printf(NAME ": fun_conf_read error: memory allocation failed.\n");
     153                ddf_msg(LVL_ERROR, "Memory allocation failed.");
    153154                goto cleanup;
    154155        }
    155156
    156157        if (0 >= read(fd, buf, len)) {
    157                 printf(NAME ": fun_conf_read error: unable to read file '%s'.\n",
    158                     conf_path);
     158                ddf_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
    159159                goto cleanup;
    160160        }
     
    252252                fun->hw_resources.count++;
    253253
    254                 printf(NAME ": added irq 0x%x to function %s\n", irq,
     254                ddf_msg(LVL_NOTE, "Added irq 0x%x to function %s", irq,
    255255                    fun->fnode->name);
    256256        }
     
    270270                fun->hw_resources.count++;
    271271
    272                 printf(NAME ": added io range (addr=0x%x, size=0x%x) to "
    273                     "function %s\n", (unsigned int) addr, (unsigned int) len,
     272                ddf_msg(LVL_NOTE, "Added io range (addr=0x%x, size=0x%x) to "
     273                    "function %s", (unsigned int) addr, (unsigned int) len,
    274274                    fun->fnode->name);
    275275        }
     
    331331        score = (int)strtol(val, &end, 10);
    332332        if (val == end) {
    333                 printf(NAME " : error - could not read match score for "
    334                     "function %s.\n", fun->fnode->name);
     333                ddf_msg(LVL_ERROR, "Cannot read match score for function "
     334                    "%s.", fun->fnode->name);
    335335                return;
    336336        }
     
    339339        get_match_id(&id, val);
    340340        if (id == NULL) {
    341                 printf(NAME " : error - could not read match id for "
    342                     "function %s.\n", fun->fnode->name);
     341                ddf_msg(LVL_ERROR, "Cannot read match ID for function %s.",
     342                    fun->fnode->name);
    343343                return;
    344344        }
    345345
    346         printf(NAME ": adding match id '%s' with score %d to function %s\n", id,
    347             score, fun->fnode->name);
     346        ddf_msg(LVL_DEBUG, "Adding match id '%s' with score %d to "
     347            "function %s", id, score, fun->fnode->name);
    348348
    349349        rc = ddf_fun_add_match_id(fun->fnode, id, score);
    350         if (rc != EOK)
    351                 printf(NAME ": error adding match ID: %s\n", str_error(rc));
     350        if (rc != EOK) {
     351                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
     352                    str_error(rc));
     353        }
    352354}
    353355
     
    375377        if (!prop_parse(fun, line, "io_range", &fun_parse_io_range) &&
    376378            !prop_parse(fun, line, "irq", &fun_parse_irq) &&
    377             !prop_parse(fun, line, "match", &fun_parse_match_id))
    378         {
    379             printf(NAME " error undefined device property at line '%s'\n",
    380                 line);
     379            !prop_parse(fun, line, "match", &fun_parse_match_id)) {
     380
     381                ddf_msg(LVL_ERROR, "Undefined device property at line '%s'",
     382                    line);
    381383        }
    382384}
     
    439441        fun->fnode->ops = &isa_fun_ops;
    440442
    441         printf(NAME ": Binding function %s.\n", fun->fnode->name);
     443        ddf_msg(LVL_DEBUG, "Binding function %s.", fun->fnode->name);
    442444
    443445        /* XXX Handle error */
     
    467469static int isa_add_device(ddf_dev_t *dev)
    468470{
    469         printf(NAME ": isa_add_device, device handle = %d\n",
     471        ddf_msg(LVL_DEBUG, "isa_add_device, device handle = %d",
    470472            (int) dev->handle);
    471473
    472474        /* Make the bus device more visible. Does not do anything. */
    473         printf(NAME ": adding a 'ctl' function\n");
     475        ddf_msg(LVL_DEBUG, "Adding a 'ctl' function");
    474476
    475477        ddf_fun_t *ctl = ddf_fun_create(dev, fun_exposed, "ctl");
    476478        if (ctl == NULL) {
    477                 printf(NAME ": Error creating control function.\n");
     479                ddf_msg(LVL_ERROR, "Failed creating control function.");
    478480                return EXDEV;
    479481        }
    480482
    481483        if (ddf_fun_bind(ctl) != EOK) {
    482                 printf(NAME ": Error binding control function.\n");
     484                ddf_msg(LVL_ERROR, "Failed binding control function.");
    483485                return EXDEV;
    484486        }
     
    486488        /* Add functions as specified in the configuration file. */
    487489        isa_functions_add(dev);
    488         printf(NAME ": finished the enumeration of legacy functions\n");
     490        ddf_msg(LVL_NOTE, "Finished enumerating legacy functions");
    489491
    490492        return EOK;
     
    493495static void isa_init()
    494496{
     497        ddf_log_init(NAME, LVL_ERROR);
    495498        isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
    496499}
  • uspace/drv/ns8250/ns8250.c

    ra9c7c6f rc6ba274  
    5555#include <ddf/driver.h>
    5656#include <ddf/interrupt.h>
     57#include <ddf/log.h>
    5758#include <ops/char_dev.h>
    5859
     
    275276static bool ns8250_pio_enable(ns8250_t *ns)
    276277{
    277         printf(NAME ": ns8250_pio_enable %s\n", ns->dev->name);
     278        ddf_msg(LVL_DEBUG, "ns8250_pio_enable %s", ns->dev->name);
    278279       
    279280        /* Gain control over port's registers. */
    280281        if (pio_enable((void *)(uintptr_t) ns->io_addr, REG_COUNT,
    281282            (void **) &ns->port)) {
    282                 printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
    283                     "%s.\n", ns->io_addr, ns->dev->name);
     283                ddf_msg(LVL_ERROR, "Cannot map the port %#" PRIx32
     284                    " for device %s.", ns->io_addr, ns->dev->name);
    284285                return false;
    285286        }
     
    295296static bool ns8250_dev_probe(ns8250_t *ns)
    296297{
    297         printf(NAME ": ns8250_dev_probe %s\n", ns->dev->name);
     298        ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ns->dev->name);
    298299       
    299300        ioport8_t *port_addr = ns->port;
     
    313314        pio_write_8(port_addr + 4, olddata);
    314315       
    315         if (!res)
    316                 printf(NAME ": device %s is not present.\n", ns->dev->name);
     316        if (!res) {
     317                ddf_msg(LVL_DEBUG, "Device %s is not present.",
     318                    ns->dev->name);
     319        }
    317320       
    318321        return res;
     
    326329static int ns8250_dev_initialize(ns8250_t *ns)
    327330{
    328         printf(NAME ": ns8250_dev_initialize %s\n", ns->dev->name);
     331        ddf_msg(LVL_DEBUG, "ns8250_dev_initialize %s", ns->dev->name);
    329332       
    330333        int ret = EOK;
     
    337340            IPC_FLAG_BLOCKING);
    338341        if (ns->dev->parent_phone < 0) {
    339                 printf(NAME ": failed to connect to the parent driver of the "
    340                     "device %s.\n", ns->dev->name);
     342                ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
     343                    "device %s.", ns->dev->name);
    341344                ret = ns->dev->parent_phone;
    342345                goto failed;
     
    346349        ret = hw_res_get_resource_list(ns->dev->parent_phone, &hw_resources);
    347350        if (ret != EOK) {
    348                 printf(NAME ": failed to get hw resources for the device "
    349                     "%s.\n", ns->dev->name);
     351                ddf_msg(LVL_ERROR, "Failed to get HW resources for device "
     352                    "%s.", ns->dev->name);
    350353                goto failed;
    351354        }
     
    362365                        ns->irq = res->res.interrupt.irq;
    363366                        irq = true;
    364                         printf(NAME ": the %s device was asigned irq = 0x%x.\n",
     367                        ddf_msg(LVL_NOTE, "Device %s was asigned irq = 0x%x.",
    365368                            ns->dev->name, ns->irq);
    366369                        break;
     
    369372                        ns->io_addr = res->res.io_range.address;
    370373                        if (res->res.io_range.size < REG_COUNT) {
    371                                 printf(NAME ": i/o range assigned to the device "
    372                                     "%s is too small.\n", ns->dev->name);
     374                                ddf_msg(LVL_ERROR, "I/O range assigned to "
     375                                    "device %s is too small.", ns->dev->name);
    373376                                ret = ELIMIT;
    374377                                goto failed;
    375378                        }
    376379                        ioport = true;
    377                         printf(NAME ": the %s device was asigned i/o address = "
    378                             "0x%x.\n", ns->dev->name, ns->io_addr);
    379                         break;
     380                        ddf_msg(LVL_NOTE, "Device %s was asigned I/O address = "
     381                            "0x%x.", ns->dev->name, ns->io_addr);
     382                        break;
    380383                       
    381384                default:
     
    385388       
    386389        if (!irq || !ioport) {
    387                 printf(NAME ": missing hw resource(s) for the device %s.\n",
     390                ddf_msg(LVL_ERROR, "Missing HW resource(s) for device %s.",
    388391                    ns->dev->name);
    389392                ret = ENOENT;
     
    470473       
    471474        if (baud_rate < 50 || MAX_BAUD_RATE % baud_rate != 0) {
    472                 printf(NAME ": error - somebody tried to set invalid baud rate "
    473                     "%d\n", baud_rate);
     475                ddf_msg(LVL_ERROR, "Invalid baud rate %d requested.",
     476                    baud_rate);
    474477                return EINVAL;
    475478        }
     
    654657                        if (ns->client_connected) {
    655658                                if (!buf_push_back(&ns->input_buffer, val)) {
    656                                         printf(NAME ": buffer overflow on "
    657                                             "%s.\n", ns->dev->name);
     659                                        ddf_msg(LVL_WARN, "Buffer overflow on "
     660                                            "%s.", ns->dev->name);
    658661                                } else {
    659                                         printf(NAME ": the character %c saved "
    660                                             "to the buffer of %s.\n",
     662                                        ddf_msg(LVL_DEBUG2, "Character %c saved "
     663                                            "to the buffer of %s.",
    661664                                            val, ns->dev->name);
    662665                                }
     
    714717        int rc;
    715718       
    716         printf(NAME ": ns8250_add_device %s (handle = %d)\n",
     719        ddf_msg(LVL_DEBUG, "ns8250_add_device %s (handle = %d)",
    717720            dev->name, (int) dev->handle);
    718721       
     
    749752        /* Register interrupt handler. */
    750753        if (ns8250_register_interrupt_handler(ns) != EOK) {
    751                 printf(NAME ": failed to register interrupt handler.\n");
     754                ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
    752755                rc = EADDRNOTAVAIL;
    753756                goto fail;
     
    757760        rc = ns8250_interrupt_enable(ns);
    758761        if (rc != EOK) {
    759                 printf(NAME ": failed to enable the interrupt. Error code = "
    760                     "%d.\n", rc);
     762                ddf_msg(LVL_ERROR, "Failed to enable the interrupt. Error code = "
     763                    "%d.", rc);
    761764                goto fail;
    762765        }
     
    764767        fun = ddf_fun_create(dev, fun_exposed, "a");
    765768        if (fun == NULL) {
    766                 printf(NAME ": error creating function.\n");
     769                ddf_msg(LVL_ERROR, "Failed creating function.");
    767770                goto fail;
    768771        }
     
    772775        rc = ddf_fun_bind(fun);
    773776        if (rc != EOK) {
    774                 printf(NAME ": error binding function.\n");
     777                ddf_msg(LVL_ERROR, "Failed binding function.");
    775778                goto fail;
    776779        }
     
    780783        ddf_fun_add_to_class(fun, "serial");
    781784       
    782         printf(NAME ": the %s device has been successfully initialized.\n",
     785        ddf_msg(LVL_NOTE, "Device %s successfully initialized.",
    783786            dev->name);
    784787       
     
    862865        fibril_mutex_unlock(&data->mutex);
    863866       
    864         printf(NAME ": ns8250_get_props: baud rate %d, parity 0x%x, word "
    865             "length %d, stop bits %d\n", *baud_rate, *parity, *word_length,
     867        ddf_msg(LVL_DEBUG, "ns8250_get_props: baud rate %d, parity 0x%x, word "
     868            "length %d, stop bits %d", *baud_rate, *parity, *word_length,
    866869            *stop_bits);
    867870}
     
    879882    unsigned int parity, unsigned int word_length, unsigned int stop_bits)
    880883{
    881         printf(NAME ": ns8250_set_props: baud rate %d, parity 0x%x, word "
    882             "length %d, stop bits %d\n", baud_rate, parity, word_length,
     884        ddf_msg(LVL_DEBUG, "ns8250_set_props: baud rate %d, parity 0x%x, word "
     885            "length %d, stop bits %d", baud_rate, parity, word_length,
    883886            stop_bits);
    884887       
     
    940943static void ns8250_init(void)
    941944{
     945        ddf_log_init(NAME, LVL_ERROR);
     946       
    942947        ns8250_dev_ops.open = &ns8250_open;
    943948        ns8250_dev_ops.close = &ns8250_close;
  • uspace/drv/pciintel/pci.c

    ra9c7c6f rc6ba274  
    4848
    4949#include <ddf/driver.h>
     50#include <ddf/log.h>
    5051#include <devman.h>
    5152#include <ipc/devman.h>
     
    325326
    326327        if (match_id_str == NULL) {
    327                 printf(NAME ": out of memory creating match ID.\n");
     328                ddf_msg(LVL_ERROR, "Out of memory creating match ID.");
    328329                return;
    329330        }
     
    331332        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 90);
    332333        if (rc != EOK) {
    333                 printf(NAME ": error adding match ID: %s\n",
     334                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
    334335                    str_error(rc));
    335336        }
     
    428429       
    429430        if (range_addr != 0) {
    430                 printf(NAME ": function %s : ", fun->fnode->name);
    431                 printf("address = %" PRIx64, range_addr);
    432                 printf(", size = %x\n", (unsigned int) range_size);
     431                ddf_msg(LVL_DEBUG, "Function %s : address = %" PRIx64
     432                    ", size = %x", fun->fnode->name, range_addr,
     433                    (unsigned int) range_size);
    433434        }
    434435       
     
    455456        hw_res_list->count++;
    456457       
    457         printf(NAME ": function %s uses irq %x.\n", fun->fnode->name, irq);
     458        ddf_msg(LVL_NOTE, "Function %s uses irq %x.", fun->fnode->name, irq);
    458459}
    459460
     
    511512                        char *fun_name = pci_fun_create_name(fun);
    512513                        if (fun_name == NULL) {
    513                                 printf(NAME ": out of memory.\n");
     514                                ddf_msg(LVL_ERROR, "Out of memory.");
    514515                                return;
    515516                        }
     
    517518                        fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name);
    518519                        if (fnode == NULL) {
    519                                 printf(NAME ": error creating function.\n");
     520                                ddf_msg(LVL_ERROR, "Failed creating function.");
    520521                                return;
    521522                        }
     
    531532                        fnode->driver_data = fun;
    532533                       
    533                         printf(NAME ": adding new function %s.\n",
     534                        ddf_msg(LVL_DEBUG, "Adding new function %s.",
    534535                            fnode->name);
    535536                       
     
    548549                                child_bus = pci_conf_read_8(fun,
    549550                                    PCI_BRIDGE_SEC_BUS_NUM);
    550                                 printf(NAME ": device is pci-to-pci bridge, "
    551                                     "secondary bus number = %d.\n", bus_num);
     551                                ddf_msg(LVL_DEBUG, "Device is pci-to-pci "
     552                                    "bridge, secondary bus number = %d.",
     553                                    bus_num);
    552554                                if (child_bus > bus_num)
    553555                                        pci_bus_scan(bus, child_bus);
     
    571573        int rc;
    572574       
    573         printf(NAME ": pci_add_device\n");
     575        ddf_msg(LVL_DEBUG, "pci_add_device");
    574576        dnode->parent_phone = -1;
    575577       
    576578        bus = pci_bus_new();
    577579        if (bus == NULL) {
    578                 printf(NAME ": pci_add_device allocation failed.\n");
     580                ddf_msg(LVL_ERROR, "pci_add_device allocation failed.");
    579581                rc = ENOMEM;
    580582                goto fail;
     
    586588            IPC_FLAG_BLOCKING);
    587589        if (dnode->parent_phone < 0) {
    588                 printf(NAME ": pci_add_device failed to connect to the "
    589                     "parent's driver.\n");
     590                ddf_msg(LVL_ERROR, "pci_add_device failed to connect to the "
     591                    "parent's driver.");
    590592                rc = dnode->parent_phone;
    591593                goto fail;
     
    596598        rc = hw_res_get_resource_list(dnode->parent_phone, &hw_resources);
    597599        if (rc != EOK) {
    598                 printf(NAME ": pci_add_device failed to get hw resources for "
    599                     "the device.\n");
     600                ddf_msg(LVL_ERROR, "pci_add_device failed to get hw resources "
     601                    "for the device.");
    600602                goto fail;
    601603        }
    602604        got_res = true;
    603605       
    604         printf(NAME ": conf_addr = %" PRIx64 ".\n",
     606        ddf_msg(LVL_DEBUG, "conf_addr = %" PRIx64 ".",
    605607            hw_resources.resources[0].res.io_range.address);
    606608       
     
    614616        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8,
    615617            &bus->conf_addr_port)) {
    616                 printf(NAME ": failed to enable configuration ports.\n");
     618                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
    617619                rc = EADDRNOTAVAIL;
    618620                goto fail;
     
    621623       
    622624        /* Make the bus device more visible. It has no use yet. */
    623         printf(NAME ": adding a 'ctl' function\n");
     625        ddf_msg(LVL_DEBUG, "Adding a 'ctl' function");
    624626       
    625627        ctl = ddf_fun_create(bus->dnode, fun_exposed, "ctl");
    626628        if (ctl == NULL) {
    627                 printf(NAME ": error creating control function.\n");
     629                ddf_msg(LVL_ERROR, "Failed creating control function.");
    628630                rc = ENOMEM;
    629631                goto fail;
     
    632634        rc = ddf_fun_bind(ctl);
    633635        if (rc != EOK) {
    634                 printf(NAME ": error binding control function.\n");
     636                ddf_msg(LVL_ERROR, "Failed binding control function.");
    635637                goto fail;
    636638        }
    637639       
    638640        /* Enumerate functions. */
    639         printf(NAME ": scanning the bus\n");
     641        ddf_msg(LVL_DEBUG, "Scanning the bus");
    640642        pci_bus_scan(bus, 0);
    641643       
     
    659661static void pciintel_init(void)
    660662{
     663        ddf_log_init(NAME, LVL_ERROR);
    661664        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
    662665        pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
     
    738741int main(int argc, char *argv[])
    739742{
    740         printf(NAME ": HelenOS pci bus driver (intel method 1).\n");
     743        printf(NAME ": HelenOS PCI bus driver (Intel method 1).\n");
    741744        pciintel_init();
    742745        return ddf_driver_main(&pci_driver);
  • uspace/drv/root/root.c

    ra9c7c6f rc6ba274  
    5252
    5353#include <ddf/driver.h>
     54#include <ddf/log.h>
    5455#include <devman.h>
    5556#include <ipc/devman.h>
     
    8990        int rc;
    9091
    91         printf(NAME ": adding new function for virtual devices.\n");
    92         printf(NAME ":   function node is `%s' (%d %s)\n", name,
     92        ddf_msg(LVL_DEBUG, "Adding new function for virtual devices. "
     93            "Function node is `%s' (%d %s)", name,
    9394            VIRTUAL_FUN_MATCH_SCORE, VIRTUAL_FUN_MATCH_ID);
    9495
    9596        fun = ddf_fun_create(dev, fun_inner, name);
    9697        if (fun == NULL) {
    97                 printf(NAME ": error creating function %s\n", name);
     98                ddf_msg(LVL_ERROR, "Failed creating function %s", name);
    9899                return ENOMEM;
    99100        }
     
    102103            VIRTUAL_FUN_MATCH_SCORE);
    103104        if (rc != EOK) {
    104                 printf(NAME ": error adding match IDs to function %s\n", name);
     105                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
     106                    name);
    105107                ddf_fun_destroy(fun);
    106108                return rc;
     
    109111        rc = ddf_fun_bind(fun);
    110112        if (rc != EOK) {
    111                 printf(NAME ": error binding function %s: %s\n", name,
     113                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
    112114                    str_error(rc));
    113115                ddf_fun_destroy(fun);
     
    136138        platform = sysinfo_get_data("platform", &platform_size);
    137139        if (platform == NULL) {
    138                 printf(NAME ": Failed to obtain platform name.\n");
     140                ddf_msg(LVL_ERROR, "Failed to obtain platform name.");
    139141                return ENOENT;
    140142        }
     
    143145        platform = realloc(platform, platform_size + 1);
    144146        if (platform == NULL) {
    145                 printf(NAME ": Memory allocation failed.\n");
     147                ddf_msg(LVL_ERROR, "Memory allocation failed.");
    146148                return ENOMEM;
    147149        }
     
    151153        /* Construct match ID. */
    152154        if (asprintf(&match_id, PLATFORM_FUN_MATCH_ID_FMT, platform) == -1) {
    153                 printf(NAME ": Memory allocation failed.\n");
     155                ddf_msg(LVL_ERROR, "Memory allocation failed.");
    154156                return ENOMEM;
    155157        }
    156158
    157159        /* Add function. */
    158         printf(NAME ": adding platform function\n");
    159         printf(NAME ":   function node is `%s' (%d %s)\n", PLATFORM_FUN_NAME,
    160             PLATFORM_FUN_MATCH_SCORE, match_id);
     160        ddf_msg(LVL_DEBUG, "Adding platform function. Function node is `%s' "
     161            " (%d %s)", PLATFORM_FUN_NAME, PLATFORM_FUN_MATCH_SCORE,
     162            match_id);
    161163
    162164        fun = ddf_fun_create(dev, fun_inner, name);
    163165        if (fun == NULL) {
    164                 printf(NAME ": error creating function %s\n", name);
     166                ddf_msg(LVL_ERROR, "Error creating function %s", name);
    165167                return ENOMEM;
    166168        }
     
    168170        rc = ddf_fun_add_match_id(fun, match_id, PLATFORM_FUN_MATCH_SCORE);
    169171        if (rc != EOK) {
    170                 printf(NAME ": error adding match IDs to function %s\n", name);
     172                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
     173                    name);
    171174                ddf_fun_destroy(fun);
    172175                return rc;
     
    175178        rc = ddf_fun_bind(fun);
    176179        if (rc != EOK) {
    177                 printf(NAME ": error binding function %s: %s\n", name,
     180                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
    178181                    str_error(rc));
    179182                ddf_fun_destroy(fun);
     
    191194static int root_add_device(ddf_dev_t *dev)
    192195{
    193         printf(NAME ": root_add_device, device handle=%" PRIun "\n",
     196        ddf_msg(LVL_DEBUG, "root_add_device, device handle=%" PRIun,
    194197            dev->handle);
    195198
     
    204207        int res = add_platform_fun(dev);
    205208        if (EOK != res)
    206                 printf(NAME ": failed to add child device for platform.\n");
     209                ddf_msg(LVL_ERROR, "Failed adding child device for platform.");
    207210
    208211        return res;
     
    212215{
    213216        printf(NAME ": HelenOS root device driver\n");
     217
     218        ddf_log_init(NAME, LVL_ERROR);
    214219        return ddf_driver_main(&root_driver);
    215220}
  • uspace/drv/rootpc/rootpc.c

    ra9c7c6f rc6ba274  
    4747
    4848#include <ddf/driver.h>
     49#include <ddf/log.h>
    4950#include <devman.h>
    5051#include <ipc/devman.h>
     
    119120    rootpc_fun_t *fun)
    120121{
    121         printf(NAME ": adding new function '%s'.\n", name);
     122        ddf_msg(LVL_DEBUG, "Adding new function '%s'.", name);
    122123       
    123124        ddf_fun_t *fnode = NULL;
     
    145146        /* Register function. */
    146147        if (ddf_fun_bind(fnode) != EOK) {
    147                 printf(NAME ": error binding function %s.\n", name);
     148                ddf_msg(LVL_ERROR, "Failed binding function %s.", name);
    148149                goto failure;
    149150        }
     
    158159                ddf_fun_destroy(fnode);
    159160       
    160         printf(NAME ": failed to add function '%s'.\n", name);
     161        ddf_msg(LVL_ERROR, "Failed adding function '%s'.", name);
    161162       
    162163        return false;
     
    176177static int rootpc_add_device(ddf_dev_t *dev)
    177178{
    178         printf(NAME ": rootpc_add_device, device handle = %d\n",
     179        ddf_msg(LVL_DEBUG, "rootpc_add_device, device handle = %d",
    179180            (int)dev->handle);
    180181       
    181182        /* Register functions. */
    182183        if (!rootpc_add_functions(dev)) {
    183                 printf(NAME ": failed to add functions for PC platform.\n");
     184                ddf_msg(LVL_ERROR, "Failed to add functions for PC platform.");
    184185        }
    185186       
     
    189190static void root_pc_init(void)
    190191{
     192        ddf_log_init(NAME, LVL_ERROR);
    191193        rootpc_fun_ops.interfaces[HW_RES_DEV_IFACE] = &fun_hw_res_ops;
    192194}
  • uspace/drv/rootvirt/rootvirt.c

    ra9c7c6f rc6ba274  
    4040#include <str_error.h>
    4141#include <ddf/driver.h>
     42#include <ddf/log.h>
    4243
    4344#define NAME "rootvirt"
     
    8384        int rc;
    8485
    85         printf(NAME ": registering function `%s' (match \"%s\")\n",
     86        ddf_msg(LVL_DEBUG, "Registering function `%s' (match \"%s\")",
    8687            vfun->name, vfun->match_id);
    8788
    8889        fun = ddf_fun_create(vdev, fun_inner, vfun->name);
    8990        if (fun == NULL) {
    90                 printf(NAME ": error creating function %s\n", vfun->name);
     91                ddf_msg(LVL_ERROR, "Failed creating function %s", vfun->name);
    9192                return ENOMEM;
    9293        }
     
    9495        rc = ddf_fun_add_match_id(fun, vfun->match_id, 10);
    9596        if (rc != EOK) {
    96                 printf(NAME ": error adding match IDs to function %s\n",
     97                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
    9798                    vfun->name);
    9899                ddf_fun_destroy(fun);
     
    102103        rc = ddf_fun_bind(fun);
    103104        if (rc != EOK) {
    104                 printf(NAME ": error binding function %s: %s\n", vfun->name,
    105                     str_error(rc));
     105                ddf_msg(LVL_ERROR, "Failed binding function %s: %s",
     106                    vfun->name, str_error(rc));
    106107                ddf_fun_destroy(fun);
    107108                return rc;
    108109        }
    109110
    110         printf(NAME ": registered child device `%s'\n", vfun->name);
     111        ddf_msg(LVL_NOTE, "Registered child device `%s'", vfun->name);
    111112        return EOK;
    112113}
     
    124125        }
    125126
    126         printf(NAME ": add_device(handle=%d)\n", (int)dev->handle);
     127        ddf_msg(LVL_DEBUG, "add_device(handle=%d)", (int)dev->handle);
    127128
    128129        /*
     
    142143{
    143144        printf(NAME ": HelenOS virtual devices root driver\n");
     145
     146        ddf_log_init(NAME, LVL_ERROR);
    144147        return ddf_driver_main(&rootvirt_driver);
    145148}
  • uspace/drv/test1/test1.c

    ra9c7c6f rc6ba274  
    3535#include <str_error.h>
    3636#include <ddf/driver.h>
     37#include <ddf/log.h>
    3738
    3839#include "test1.h"
     
    5859 */
    5960static int register_fun_verbose(ddf_dev_t *parent, const char *message,
    60     const char *name, const char *match_id, int match_score)
     61    const char *name, const char *match_id, int match_score,
     62    int expected_rc)
    6163{
    62         ddf_fun_t *fun;
     64        ddf_fun_t *fun = NULL;
    6365        int rc;
    6466
    65         printf(NAME ": registering function `%s': %s.\n", name, message);
     67        ddf_msg(LVL_DEBUG, "Registering function `%s': %s.", name, message);
    6668
    6769        fun = ddf_fun_create(parent, fun_inner, name);
    6870        if (fun == NULL) {
    69                 printf(NAME ": error creating function %s\n", name);
    70                 return ENOMEM;
     71                ddf_msg(LVL_ERROR, "Failed creating function %s", name);
     72                rc = ENOMEM;
     73                goto leave;
    7174        }
    7275
    73         rc = ddf_fun_add_match_id(fun, match_id, match_score);
     76        rc = ddf_fun_add_match_id(fun, str_dup(match_id), match_score);
    7477        if (rc != EOK) {
    75                 printf(NAME ": error adding match IDs to function %s\n", name);
    76                 ddf_fun_destroy(fun);
    77                 return rc;
     78                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
     79                    name);
     80                goto leave;
    7881        }
    7982
    8083        rc = ddf_fun_bind(fun);
    8184        if (rc != EOK) {
    82                 printf(NAME ": error binding function %s: %s\n", name,
     85                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
    8386                    str_error(rc));
    84                 ddf_fun_destroy(fun);
    85                 return rc;
     87                goto leave;
    8688        }
    8789
    88         printf(NAME ": registered child device `%s'\n", name);
    89         return EOK;
     90        ddf_msg(LVL_NOTE, "Registered child device `%s'", name);
     91        rc = EOK;
     92
     93leave:
     94        if (rc != expected_rc) {
     95                fprintf(stderr,
     96                    NAME ": Unexpected error registering function `%s'.\n"
     97                    NAME ":     Expected \"%s\" but got \"%s\".\n",
     98                    name, str_error(expected_rc), str_error(rc));
     99        }
     100
     101        if ((rc != EOK) && (fun != NULL)) {
     102                ddf_fun_destroy(fun);
     103        }
     104
     105        return rc;
    90106}
    91107
     
    112128        int rc;
    113129
    114         printf(NAME ": add_device(name=\"%s\", handle=%d)\n",
     130        ddf_msg(LVL_DEBUG, "add_device(name=\"%s\", handle=%d)",
    115131            dev->name, (int) dev->handle);
    116132
    117133        fun_a = ddf_fun_create(dev, fun_exposed, "a");
    118134        if (fun_a == NULL) {
    119                 printf(NAME ": error creating function 'a'.\n");
     135                ddf_msg(LVL_ERROR, "Failed creating function 'a'.");
    120136                return ENOMEM;
    121137        }
     
    123139        rc = ddf_fun_bind(fun_a);
    124140        if (rc != EOK) {
    125                 printf(NAME ": error binding function 'a'.\n");
     141                ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
    126142                return rc;
    127143        }
     
    133149                ddf_fun_add_to_class(fun_a, "virt-null");
    134150        } else if (str_cmp(dev->name, "test1") == 0) {
    135                 (void) register_fun_verbose(dev, "cloning myself ;-)", "clone",
    136                     "virtual&test1", 10);
     151                (void) register_fun_verbose(dev,
     152                    "cloning myself ;-)", "clone",
     153                    "virtual&test1", 10, EOK);
     154                (void) register_fun_verbose(dev,
     155                    "cloning myself twice ;-)", "clone",
     156                    "virtual&test1", 10, EEXISTS);
    137157        } else if (str_cmp(dev->name, "clone") == 0) {
    138                 (void) register_fun_verbose(dev, "run by the same task", "child",
    139                     "virtual&test1&child", 10);
     158                (void) register_fun_verbose(dev,
     159                    "run by the same task", "child",
     160                    "virtual&test1&child", 10, EOK);
    140161        }
    141162
    142         printf(NAME ": device `%s' accepted.\n", dev->name);
     163        ddf_msg(LVL_DEBUG, "Device `%s' accepted.", dev->name);
    143164
    144165        return EOK;
     
    148169{
    149170        printf(NAME ": HelenOS test1 virtual device driver\n");
     171        ddf_log_init(NAME, LVL_ERROR);
    150172        return ddf_driver_main(&test1_driver);
    151173}
  • uspace/drv/test2/test2.c

    ra9c7c6f rc6ba274  
    3636#include <str_error.h>
    3737#include <ddf/driver.h>
     38#include <ddf/log.h>
    3839
    3940#define NAME "test2"
     
    6465        int rc;
    6566
    66         printf(NAME ": registering function `%s': %s.\n", name, message);
     67        ddf_msg(LVL_DEBUG, "Registering function `%s': %s.", name, message);
    6768
    6869        fun = ddf_fun_create(parent, fun_inner, name);
    6970        if (fun == NULL) {
    70                 printf(NAME ": error creating function %s\n", name);
     71                ddf_msg(LVL_ERROR, "Failed creating function %s", name);
    7172                return ENOMEM;
    7273        }
     
    7475        rc = ddf_fun_add_match_id(fun, match_id, match_score);
    7576        if (rc != EOK) {
    76                 printf(NAME ": error adding match IDs to function %s\n", name);
     77                ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
     78                    name);
    7779                ddf_fun_destroy(fun);
    7880                return rc;
     
    8183        rc = ddf_fun_bind(fun);
    8284        if (rc != EOK) {
    83                 printf(NAME ": error binding function %s: %s\n", name,
     85                ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
    8486                    str_error(rc));
    8587                ddf_fun_destroy(fun);
     
    8789        }
    8890
    89         printf(NAME ": registered child device `%s'\n", name);
     91        ddf_msg(LVL_NOTE, "Registered child device `%s'", name);
    9092        return EOK;
    9193}
     
    111113        fun_a = ddf_fun_create(dev, fun_exposed, "a");
    112114        if (fun_a == NULL) {
    113                 printf(NAME ": error creating function 'a'.\n");
     115                ddf_msg(LVL_ERROR, "Failed creating function 'a'.");
    114116                return ENOMEM;
    115117        }
     
    117119        rc = ddf_fun_bind(fun_a);
    118120        if (rc != EOK) {
    119                 printf(NAME ": error binding function 'a'.\n");
     121                ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
    120122                return rc;
    121123        }
     
    128130static int test2_add_device(ddf_dev_t *dev)
    129131{
    130         printf(NAME ": test2_add_device(name=\"%s\", handle=%d)\n",
     132        ddf_msg(LVL_DEBUG, "test2_add_device(name=\"%s\", handle=%d)",
    131133            dev->name, (int) dev->handle);
    132134
     
    134136                fid_t postpone = fibril_create(postponed_birth, dev);
    135137                if (postpone == 0) {
    136                         printf(NAME ": fibril_create() error\n");
     138                        ddf_msg(LVL_ERROR, "fibril_create() failed.");
    137139                        return ENOMEM;
    138140                }
     
    149151{
    150152        printf(NAME ": HelenOS test2 virtual device driver\n");
     153        ddf_log_init(NAME, LVL_ERROR);
    151154        return ddf_driver_main(&test2_driver);
    152155}
  • uspace/lib/c/Makefile

    ra9c7c6f rc6ba274  
    7777        generic/io/io.c \
    7878        generic/io/printf.c \
     79        generic/io/log.c \
    7980        generic/io/klog.c \
    8081        generic/io/snprintf.c \
  • uspace/lib/c/generic/devman.c

    ra9c7c6f rc6ba274  
    147147                ret = devman_send_match_id(phone, match_id);
    148148                if (ret != EOK) {
    149                         printf("Driver failed to send match id, error %d\n",
    150                             ret);
    151149                        return ret;
    152150                }
     
    195193        }
    196194       
    197         devman_send_match_ids(phone, match_ids);
    198        
    199         async_wait_for(req, &retval);
    200        
    201         async_serialize_end();
    202        
     195        int match_ids_rc = devman_send_match_ids(phone, match_ids);
     196       
     197        async_wait_for(req, &retval);
     198       
     199        async_serialize_end();
     200       
     201        /* Prefer the answer to DEVMAN_ADD_FUNCTION in case of errors. */
     202        if ((match_ids_rc != EOK) && (retval == EOK)) {
     203                retval = match_ids_rc;
     204        }
     205
    203206        if (retval == EOK)
    204207                fun_handle = (int) IPC_GET_ARG1(answer);
     
    326329}
    327330
     331int devman_device_get_handle_by_class(const char *classname,
     332    const char *devname, devman_handle_t *handle, unsigned int flags)
     333{
     334        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
     335
     336        if (phone < 0)
     337                return phone;
     338
     339        async_serialize_start();
     340
     341        ipc_call_t answer;
     342        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
     343            flags, &answer);
     344
     345        sysarg_t retval = async_data_write_start(phone, classname,
     346            str_size(classname));
     347        if (retval != EOK) {
     348                async_wait_for(req, NULL);
     349                async_serialize_end();
     350                return retval;
     351        }
     352        retval = async_data_write_start(phone, devname,
     353            str_size(devname));
     354        if (retval != EOK) {
     355                async_wait_for(req, NULL);
     356                async_serialize_end();
     357                return retval;
     358        }
     359
     360        async_wait_for(req, &retval);
     361
     362        async_serialize_end();
     363
     364        if (retval != EOK) {
     365                if (handle != NULL)
     366                        *handle = (devman_handle_t) -1;
     367                return retval;
     368        }
     369
     370        if (handle != NULL)
     371                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
     372
     373        return retval;
     374}
     375
    328376
    329377/** @}
  • uspace/lib/c/include/devman.h

    ra9c7c6f rc6ba274  
    5353extern int devman_device_get_handle(const char *, devman_handle_t *,
    5454    unsigned int);
     55extern int devman_device_get_handle_by_class(const char *, const char *,
     56    devman_handle_t *, unsigned int);
    5557
    5658extern int devman_add_device_to_class(devman_handle_t, const char *);
  • uspace/lib/c/include/ipc/devman.h

    ra9c7c6f rc6ba274  
    148148
    149149typedef enum {
    150         DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD
     150        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
     151        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS
    151152} client_to_devman_t;
    152153
  • uspace/lib/drv/Makefile

    ra9c7c6f rc6ba274  
    3636        generic/dev_iface.c \
    3737        generic/remote_char_dev.c \
     38        generic/log.c \
    3839        generic/remote_hw_res.c \
    3940        generic/remote_usb.c \
  • uspace/lib/drv/generic/driver.c

    ra9c7c6f rc6ba274  
    273273       
    274274        res = driver->driver_ops->add_device(dev);
    275         if (res == EOK) {
    276                 printf("%s: new device with handle=%" PRIun " was added.\n",
    277                     driver->name, dev_handle);
    278         } else {
    279                 printf("%s: failed to add a new device with handle = %" PRIun ".\n",
    280                     driver->name, dev_handle);
     275        if (res != EOK)
    281276                delete_device(dev);
    282         }
    283277       
    284278        async_answer_0(iid, res);
  • uspace/srv/devman/devman.c

    ra9c7c6f rc6ba274  
    3434#include <fcntl.h>
    3535#include <sys/stat.h>
     36#include <io/log.h>
    3637#include <ipc/driver.h>
    3738#include <ipc/devman.h>
     
    146147        fibril_mutex_unlock(&drivers_list->drivers_mutex);
    147148
    148         printf(NAME": the '%s' driver was added to the list of available "
    149             "drivers.\n", drv->name);
    150 
    151         printf(NAME ": match ids:");
    152         link_t *cur;
    153         for (cur = drv->match_ids.ids.next; cur != &drv->match_ids.ids; cur = cur->next) {
    154                 match_id_t *match_id = list_get_instance(cur, match_id_t, link);
    155                 printf(" %d:%s", match_id->score, match_id->id);
    156         }
    157         printf("\n");
     149        log_msg(LVL_NOTE, "Driver `%s' was added to the list of available "
     150            "drivers.", drv->name);
    158151}
    159152
     
    245238bool read_match_ids(const char *conf_path, match_id_list_t *ids)
    246239{
    247         printf(NAME ": read_match_ids conf_path = %s.\n", conf_path);
     240        log_msg(LVL_DEBUG, "read_match_ids(conf_path=\"%s\")", conf_path);
    248241       
    249242        bool suc = false;
     
    255248        fd = open(conf_path, O_RDONLY);
    256249        if (fd < 0) {
    257                 printf(NAME ": unable to open %s\n", conf_path);
     250                log_msg(LVL_ERROR, "Unable to open `%s' for reading: %s.",
     251                    conf_path, str_error(fd));
    258252                goto cleanup;
    259253        }
     
    263257        lseek(fd, 0, SEEK_SET);
    264258        if (len == 0) {
    265                 printf(NAME ": configuration file '%s' is empty.\n", conf_path);
     259                log_msg(LVL_ERROR, "Configuration file '%s' is empty.",
     260                    conf_path);
    266261                goto cleanup;
    267262        }
     
    269264        buf = malloc(len + 1);
    270265        if (buf == NULL) {
    271                 printf(NAME ": memory allocation failed when parsing file "
    272                     "'%s'.\n", conf_path);
     266                log_msg(LVL_ERROR, "Memory allocation failed when parsing file "
     267                    "'%s'.", conf_path);
    273268                goto cleanup;
    274269        }
     
    276271        ssize_t read_bytes = safe_read(fd, buf, len);
    277272        if (read_bytes <= 0) {
    278                 printf(NAME ": unable to read file '%s'.\n", conf_path);
     273                log_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
    279274                goto cleanup;
    280275        }
     
    314309bool get_driver_info(const char *base_path, const char *name, driver_t *drv)
    315310{
    316         printf(NAME ": get_driver_info base_path = %s, name = %s.\n",
     311        log_msg(LVL_DEBUG, "get_driver_info(base_path=\"%s\", name=\"%s\")",
    317312            base_path, name);
    318313       
     
    346341        struct stat s;
    347342        if (stat(drv->binary_path, &s) == ENOENT) { /* FIXME!! */
    348                 printf(NAME ": driver not found at path %s.", drv->binary_path);
     343                log_msg(LVL_ERROR, "Driver not found at path `%s'.",
     344                    drv->binary_path);
    349345                goto cleanup;
    350346        }
     
    373369int lookup_available_drivers(driver_list_t *drivers_list, const char *dir_path)
    374370{
    375         printf(NAME ": lookup_available_drivers, dir = %s \n", dir_path);
     371        log_msg(LVL_DEBUG, "lookup_available_drivers(dir=\"%s\")", dir_path);
    376372       
    377373        int drv_cnt = 0;
     
    407403        dev_node_t *dev;
    408404       
    409         printf(NAME ": create_root_nodes\n");
     405        log_msg(LVL_DEBUG, "create_root_nodes()");
    410406       
    411407        fibril_rwlock_write_lock(&tree->rwlock);
     
    492488void attach_driver(dev_node_t *dev, driver_t *drv)
    493489{
    494         printf(NAME ": attach_driver %s to device %s\n",
    495             drv->name, dev->pfun->pathname);
     490        log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")",
     491            dev->pfun->pathname, drv->name);
    496492       
    497493        fibril_mutex_lock(&drv->driver_mutex);
     
    515511        assert(fibril_mutex_is_locked(&drv->driver_mutex));
    516512       
    517         printf(NAME ": start_driver '%s'\n", drv->name);
     513        log_msg(LVL_DEBUG, "start_driver(drv=\"%s\")", drv->name);
    518514       
    519515        rc = task_spawnl(NULL, drv->binary_path, drv->binary_path, NULL);
    520516        if (rc != EOK) {
    521                 printf(NAME ": error spawning %s (%s)\n",
    522                     drv->name, str_error(rc));
     517                log_msg(LVL_ERROR, "Spawning driver `%s' (%s) failed: %s.",
     518                    drv->name, drv->binary_path, str_error(rc));
    523519                return false;
    524520        }
     
    582578        int phone;
    583579
    584         printf(NAME ": pass_devices_to_driver(`%s')\n", driver->name);
     580        log_msg(LVL_DEBUG, "pass_devices_to_driver(driver=\"%s\")",
     581            driver->name);
    585582
    586583        fibril_mutex_lock(&driver->driver_mutex);
     
    649646         * immediately and possibly started here as well.
    650647         */
    651         printf(NAME ": driver %s goes into running state.\n", driver->name);
     648        log_msg(LVL_DEBUG, "Driver `%s' enters running state.", driver->name);
    652649        driver->state = DRIVER_RUNNING;
    653650
     
    666663void initialize_running_driver(driver_t *driver, dev_tree_t *tree)
    667664{
    668         printf(NAME ": initialize_running_driver (`%s')\n", driver->name);
     665        log_msg(LVL_DEBUG, "initialize_running_driver(driver=\"%s\")",
     666            driver->name);
    669667       
    670668        /*
     
    756754         * access any structures that would affect driver_t.
    757755         */
    758         printf(NAME ": add_device (driver `%s', device `%s')\n", drv->name,
    759             dev->pfun->name);
     756        log_msg(LVL_DEBUG, "add_device(drv=\"%s\", dev=\"%s\")",
     757            drv->name, dev->pfun->name);
    760758       
    761759        sysarg_t rc;
     
    818816        driver_t *drv = find_best_match_driver(drivers_list, dev);
    819817        if (drv == NULL) {
    820                 printf(NAME ": no driver found for device '%s'.\n",
     818                log_msg(LVL_ERROR, "No driver found for device `%s'.",
    821819                    dev->pfun->pathname);
    822820                return false;
     
    856854bool init_device_tree(dev_tree_t *tree, driver_list_t *drivers_list)
    857855{
    858         printf(NAME ": init_device_tree.\n");
     856        log_msg(LVL_DEBUG, "init_device_tree()");
    859857       
    860858        tree->current_handle = 0;
     
    10351033        fun->pathname = (char *) malloc(pathsize);
    10361034        if (fun->pathname == NULL) {
    1037                 printf(NAME ": failed to allocate device path.\n");
     1035                log_msg(LVL_ERROR, "Failed to allocate device path.");
    10381036                return false;
    10391037        }
     
    10661064        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10671065       
     1066        log_msg(LVL_DEBUG, "insert_dev_node(dev=%p, pfun=%p [\"%s\"])",
     1067            dev, pfun, pfun->pathname);
     1068
    10681069        /* Add the node to the handle-to-node map. */
    10691070        dev->handle = ++tree->current_handle;
     
    10721073
    10731074        /* Add the node to the list of its parent's children. */
    1074         printf("insert_dev_node: dev=%p, dev->pfun := %p\n", dev, pfun);
    10751075        dev->pfun = pfun;
    10761076        pfun->child = dev;
     
    11731173}
    11741174
     1175/** Find function with a specified name belonging to given device.
     1176 *
     1177 * Device tree rwlock should be held at least for reading.
     1178 *
     1179 * @param dev Device the function belongs to.
     1180 * @param name Function name (not path).
     1181 * @return Function node.
     1182 * @retval NULL No function with given name.
     1183 */
     1184fun_node_t *find_fun_node_in_device(dev_node_t *dev, const char *name)
     1185{
     1186        assert(dev != NULL);
     1187        assert(name != NULL);
     1188
     1189        fun_node_t *fun;
     1190        link_t *link;
     1191
     1192        for (link = dev->functions.next;
     1193            link != &dev->functions;
     1194            link = link->next) {
     1195                fun = list_get_instance(link, fun_node_t, dev_functions);
     1196
     1197                if (str_cmp(name, fun->name) == 0)
     1198                        return fun;
     1199        }
     1200
     1201        return NULL;
     1202}
     1203
     1204/** Find function node by its class name and index. */
     1205fun_node_t *find_fun_node_by_class(class_list_t *class_list,
     1206    const char *class_name, const char *dev_name)
     1207{
     1208        assert(class_list != NULL);
     1209        assert(class_name != NULL);
     1210        assert(dev_name != NULL);
     1211
     1212        fibril_rwlock_read_lock(&class_list->rwlock);
     1213
     1214        dev_class_t *cl = find_dev_class_no_lock(class_list, class_name);
     1215        if (cl == NULL) {
     1216                fibril_rwlock_read_unlock(&class_list->rwlock);
     1217                return NULL;
     1218        }
     1219
     1220        dev_class_info_t *dev = find_dev_in_class(cl, dev_name);
     1221        if (dev == NULL) {
     1222                fibril_rwlock_read_unlock(&class_list->rwlock);
     1223                return NULL;
     1224        }
     1225
     1226        fun_node_t *fun = dev->fun;
     1227
     1228        fibril_rwlock_read_unlock(&class_list->rwlock);
     1229
     1230        return fun;
     1231}
     1232
     1233
    11751234/** Find child function node with a specified name.
    11761235 *
     
    11831242fun_node_t *find_node_child(fun_node_t *pfun, const char *name)
    11841243{
    1185         fun_node_t *fun;
    1186         link_t *link;
    1187        
    1188         link = pfun->child->functions.next;
    1189        
    1190         while (link != &pfun->child->functions) {
    1191                 fun = list_get_instance(link, fun_node_t, dev_functions);
    1192                
    1193                 if (str_cmp(name, fun->name) == 0)
    1194                         return fun;
    1195                
    1196                 link = link->next;
    1197         }
    1198        
    1199         return NULL;
     1244        return find_fun_node_in_device(pfun->child, name);
    12001245}
    12011246
     
    13591404}
    13601405
     1406dev_class_info_t *find_dev_in_class(dev_class_t *dev_class, const char *dev_name)
     1407{
     1408        assert(dev_class != NULL);
     1409        assert(dev_name != NULL);
     1410
     1411        link_t *link;
     1412        for (link = dev_class->devices.next;
     1413            link != &dev_class->devices;
     1414            link = link->next) {
     1415                dev_class_info_t *dev = list_get_instance(link,
     1416                    dev_class_info_t, link);
     1417
     1418                if (str_cmp(dev->dev_name, dev_name) == 0) {
     1419                        return dev;
     1420                }
     1421        }
     1422
     1423        return NULL;
     1424}
     1425
    13611426void init_class_list(class_list_t *class_list)
    13621427{
  • uspace/srv/devman/devman.h

    ra9c7c6f rc6ba274  
    338338extern fun_node_t *find_fun_node(dev_tree_t *tree, devman_handle_t handle);
    339339extern fun_node_t *find_fun_node_by_path(dev_tree_t *, char *);
     340extern fun_node_t *find_fun_node_in_device(dev_node_t *, const char *);
     341extern fun_node_t *find_fun_node_by_class(class_list_t *, const char *, const char *);
    340342
    341343/* Device tree */
     
    359361extern dev_class_t *get_dev_class(class_list_t *, char *);
    360362extern dev_class_t *find_dev_class_no_lock(class_list_t *, const char *);
     363extern dev_class_info_t *find_dev_in_class(dev_class_t *, const char *);
    361364extern void add_dev_class_no_lock(class_list_t *, dev_class_t *);
    362365
  • uspace/srv/devman/main.c

    ra9c7c6f rc6ba274  
    4343#include <stdio.h>
    4444#include <errno.h>
     45#include <str_error.h>
    4546#include <bool.h>
    4647#include <fibril_synch.h>
     
    5152#include <sys/stat.h>
    5253#include <ctype.h>
     54#include <io/log.h>
    5355#include <ipc/devman.h>
    5456#include <ipc/driver.h>
     
    7173        driver_t *driver = NULL;
    7274
    73         printf(NAME ": devman_driver_register \n");
     75        log_msg(LVL_DEBUG, "devman_driver_register");
    7476       
    7577        iid = async_get_call(&icall);
     
    8890        }
    8991
    90         printf(NAME ": the %s driver is trying to register by the service.\n",
     92        log_msg(LVL_DEBUG, "The `%s' driver is trying to register.",
    9193            drv_name);
    9294       
     
    9597       
    9698        if (driver == NULL) {
    97                 printf(NAME ": no driver named %s was found.\n", drv_name);
     99                log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
    98100                free(drv_name);
    99101                drv_name = NULL;
     
    106108       
    107109        /* Create connection to the driver. */
    108         printf(NAME ":  creating connection to the %s driver.\n", driver->name);
     110        log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
     111            driver->name);
    109112        ipc_call_t call;
    110113        ipc_callid_t callid = async_get_call(&call);
     
    118121        set_driver_phone(driver, IPC_GET_ARG5(call));
    119122       
    120         printf(NAME ": the %s driver was successfully registered as running.\n",
     123        log_msg(LVL_NOTE,
     124            "The `%s' driver was successfully registered as running.",
    121125            driver->name);
    122126       
     
    142146        callid = async_get_call(&call);
    143147        if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    144                 printf(NAME ": ERROR: devman_receive_match_id - invalid "
    145                     "protocol.\n");
     148                log_msg(LVL_ERROR,
     149                    "Invalid protocol when trying to receive match id.");
    146150                async_answer_0(callid, EINVAL);
    147151                delete_match_id(match_id);
     
    150154       
    151155        if (match_id == NULL) {
    152                 printf(NAME ": ERROR: devman_receive_match_id - failed to "
    153                     "allocate match id.\n");
     156                log_msg(LVL_ERROR, "Failed to allocate match id.");
    154157                async_answer_0(callid, ENOMEM);
    155158                return ENOMEM;
     
    165168        if (rc != EOK) {
    166169                delete_match_id(match_id);
    167                 printf(NAME ": devman_receive_match_id - failed to receive "
    168                     "match id string.\n");
     170                log_msg(LVL_ERROR, "Failed to receive match id string: %s.",
     171                    str_error(rc));
    169172                return rc;
    170173        }
     
    172175        list_append(&match_id->link, &match_ids->ids);
    173176       
    174         printf(NAME ": received match id '%s', score = %d \n",
     177        log_msg(LVL_DEBUG, "Received match id `%s', score %d.",
    175178            match_id->id, match_id->score);
    176179        return rc;
     
    228231        if (ftype != fun_inner && ftype != fun_exposed) {
    229232                /* Unknown function type */
    230                 printf(NAME ": Error, unknown function type provided by driver!\n");
     233                log_msg(LVL_ERROR,
     234                    "Unknown function type %d provided by driver.",
     235                    (int) ftype);
    231236
    232237                fibril_rwlock_write_unlock(&tree->rwlock);
     
    243248        }
    244249       
     250        /* Check that function with same name is not there already. */
     251        if (find_fun_node_in_device(pdev, fun_name) != NULL) {
     252                fibril_rwlock_write_unlock(&tree->rwlock);
     253                async_answer_0(callid, EEXISTS);
     254                printf(NAME ": Warning, driver tried to register `%s' twice.\n",
     255                    fun_name);
     256                free(fun_name);
     257                return;
     258        }
     259
    245260        fun_node_t *fun = create_fun_node();
    246261        if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
     
    265280        fibril_rwlock_write_unlock(&tree->rwlock);
    266281       
    267         printf(NAME ": devman_add_function %s\n", fun->pathname);
     282        log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname);
    268283       
    269284        devman_receive_match_ids(match_count, &fun->match_ids);
     
    347362        devmap_register_class_dev(class_info);
    348363       
    349         printf(NAME ": function'%s' added to class '%s', class name '%s' was "
    350             "asigned to it\n", fun->pathname, class_name, class_info->dev_name);
     364        log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.",
     365            fun->pathname, class_name, class_info->dev_name);
    351366
    352367        async_answer_0(callid, EOK);
     
    363378       
    364379        initialize_running_driver(driver, &device_tree);
    365         printf(NAME ": the %s driver was successfully initialized. \n",
     380        log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.",
    366381            driver->name);
    367382        return 0;
     
    385400        fid_t fid = fibril_create(init_running_drv, driver);
    386401        if (fid == 0) {
    387                 printf(NAME ": Error creating fibril for the initialization of "
    388                     "the newly registered running driver.\n");
     402                log_msg(LVL_ERROR, "Failed to create initialization fibril " \
     403                    "for driver `%s'.", driver->name);
    389404                return;
    390405        }
     
    438453}
    439454
     455/** Find handle for the device instance identified by device class name. */
     456static void devman_function_get_handle_by_class(ipc_callid_t iid,
     457    ipc_call_t *icall)
     458{
     459        char *classname;
     460        char *devname;
     461
     462        int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0);
     463        if (rc != EOK) {
     464                async_answer_0(iid, rc);
     465                return;
     466        }
     467        rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0);
     468        if (rc != EOK) {
     469                free(classname);
     470                async_answer_0(iid, rc);
     471                return;
     472        }
     473
     474
     475        fun_node_t *fun = find_fun_node_by_class(&class_list,
     476            classname, devname);
     477
     478        free(classname);
     479        free(devname);
     480
     481        if (fun == NULL) {
     482                async_answer_0(iid, ENOENT);
     483                return;
     484        }
     485
     486        async_answer_1(iid, EOK, fun->handle);
     487}
     488
    440489
    441490/** Function for handling connections from a client to the device manager. */
     
    457506                        devman_function_get_handle(callid, &call);
    458507                        break;
     508                case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS:
     509                        devman_function_get_handle_by_class(callid, &call);
     510                        break;
    459511                default:
    460512                        async_answer_0(callid, ENOENT);
     
    484536         */
    485537        if (dev == NULL) {
    486                 printf(NAME ": devman_forward error - no device or function with "
    487                     "handle %" PRIun " was found.\n", handle);
     538                log_msg(LVL_ERROR, "IPC forwarding failed - no device or "
     539                    "function with handle %" PRIun " was found.", handle);
    488540                async_answer_0(iid, ENOENT);
    489541                return;
     
    491543
    492544        if (fun == NULL && !drv_to_parent) {
    493                 printf(NAME ": devman_forward error - cannot connect to "
    494                     "handle %" PRIun ", refers to a device.\n", handle);
     545                log_msg(LVL_ERROR, NAME ": devman_forward error - cannot "
     546                    "connect to handle %" PRIun ", refers to a device.",
     547                    handle);
    495548                async_answer_0(iid, ENOENT);
    496549                return;
     
    513566       
    514567        if (driver == NULL) {
    515                 printf(NAME ": devman_forward error - the device %" PRIun \
    516                     " (%s) is not in usable state.\n",
     568                log_msg(LVL_ERROR, "IPC forwarding refused - " \
     569                    "the device %" PRIun "(%s) is not in usable state.",
    517570                    handle, dev->pfun->pathname);
    518571                async_answer_0(iid, ENOENT);
     
    527580       
    528581        if (driver->phone <= 0) {
    529                 printf(NAME ": devman_forward: cound not forward to driver %s ",
    530                     driver->name);
    531                 printf("the driver's phone is %" PRIun ").\n", driver->phone);
     582                log_msg(LVL_ERROR,
     583                    "Could not forward to driver `%s' (phone is %d).",
     584                    driver->name, (int) driver->phone);
    532585                async_answer_0(iid, EINVAL);
    533586                return;
     
    535588
    536589        if (fun != NULL) {
    537                 printf(NAME ": devman_forward: forward connection to function %s to "
    538                     "driver %s.\n", fun->pathname, driver->name);
     590                log_msg(LVL_DEBUG,
     591                    "Forwarding request for `%s' function to driver `%s'.",
     592                    fun->pathname, driver->name);
    539593        } else {
    540                 printf(NAME ": devman_forward: forward connection to device %s to "
    541                     "driver %s.\n", dev->pfun->pathname, driver->name);
     594                log_msg(LVL_DEBUG,
     595                    "Forwarding request for `%s' device to driver `%s'.",
     596                    dev->pfun->pathname, driver->name);
    542597        }
    543598
     
    571626        async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0,
    572627            IPC_FF_NONE);
    573         printf(NAME ": devman_connection_devmapper: forwarded connection to "
    574             "device %s to driver %s.\n", fun->pathname, dev->drv->name);
     628        log_msg(LVL_DEBUG,
     629            "Forwarding devmapper request for `%s' function to driver `%s'.",
     630            fun->pathname, dev->drv->name);
    575631}
    576632
     
    607663static bool devman_init(void)
    608664{
    609         printf(NAME ": devman_init - looking for available drivers.\n");
     665        log_msg(LVL_DEBUG, "devman_init - looking for available drivers.");
    610666       
    611667        /* Initialize list of available drivers. */
     
    613669        if (lookup_available_drivers(&drivers_list,
    614670            DRIVER_DEFAULT_STORE) == 0) {
    615                 printf(NAME " no drivers found.");
     671                log_msg(LVL_FATAL, "No drivers found.");
    616672                return false;
    617673        }
    618674
    619         printf(NAME ": devman_init  - list of drivers has been initialized.\n");
     675        log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.");
    620676
    621677        /* Create root device node. */
    622678        if (!init_device_tree(&device_tree, &drivers_list)) {
    623                 printf(NAME " failed to initialize device tree.");
     679                log_msg(LVL_FATAL, "Failed to initialize device tree.");
    624680                return false;
    625681        }
     
    642698        printf(NAME ": HelenOS Device Manager\n");
    643699
     700        if (log_init(NAME, LVL_ERROR) != EOK) {
     701                printf(NAME ": Error initializing logging subsystem.\n");
     702                return -1;
     703        }
     704
    644705        if (!devman_init()) {
    645                 printf(NAME ": Error while initializing service\n");
     706                log_msg(LVL_ERROR, "Error while initializing service.");
    646707                return -1;
    647708        }
     
    651712
    652713        /* Register device manager at naming service. */
    653         if (service_register(SERVICE_DEVMAN) != EOK)
     714        if (service_register(SERVICE_DEVMAN) != EOK) {
     715                log_msg(LVL_ERROR, "Failed registering as a service.");
    654716                return -1;
    655 
    656         printf(NAME ": Accepting connections\n");
     717        }
     718
     719        printf(NAME ": Accepting connections.\n");
    657720        async_manager();
    658721
  • uspace/srv/devmap/devmap.c

    ra9c7c6f rc6ba274  
    551551        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
    552552                printf("%s: Device '%s/%s' already registered\n", NAME,
    553                     device->namespace->name, device->name);
     553                    namespace->name, device->name);
    554554                devmap_namespace_destroy(namespace);
    555555                fibril_mutex_unlock(&devices_list_mutex);
Note: See TracChangeset for help on using the changeset viewer.