Changes in / [bdbb6f6:0864122] in mainline


Ignore:
Files:
5 added
4 deleted
17 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    rbdbb6f6 r0864122  
    528528! [PLATFORM=sparc64&MACHINE=generic] CONFIG_AOUT_ISOFS_B (y)
    529529
    530 % Run devman on startup
    531 ! CONFIG_START_DEVMAN (y/n)
    532 
    533 % Launch (devman) test drivers
    534 ! [CONFIG_START_DEVMAN=y&CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (y/n)
    535 
    536530% Load disk drivers on startup
    537531! CONFIG_START_BD (n/y)
    … …  
    554548% Line debugging information
    555549! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)
     550
     551% Launch (devman) test drivers
     552! [CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (y/n)
     553

  • kernel/generic/src/mm/backend_elf.c

    rbdbb6f6 r0864122  
    9191        if (!as_area_check_access(area, access))
    9292                return AS_PF_FAULT;
    93        
    94         if (addr < ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE))
    95                 return AS_PF_FAULT;
    96        
    97         if (addr >= entry->p_vaddr + entry->p_memsz)
    98                 return AS_PF_FAULT;
    99        
     93
     94        ASSERT((addr >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) &&
     95            (addr < entry->p_vaddr + entry->p_memsz));
    10096        i = (addr - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
    10197        base = (uintptr_t)

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

    rbdbb6f6 r0864122  
    3838#include <dirent.h>
    3939#include <fcntl.h>
    40 #include <getopt.h>
    4140#include <sys/types.h>
    4241#include <sys/stat.h>
    4342#include <str.h>
    44 #include <sort.h>
    4543
    4644#include "errors.h"
    … …  
    4846#include "util.h"
    4947#include "entry.h"
     48#include "ls.h"
    5049#include "cmds.h"
    51 
    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  */
    62 struct dir_elem_t {
    63         char *name;
    64         struct stat s;
    65 };
    6650
    6751static const char *cmdname = "ls";
    6852
    69 static struct option const long_options[] = {
    70         { "help", no_argument, 0, 'h' },
    71         { "unsort", no_argument, 0, 'u' },
    72         { 0, 0, 0, 0 }
    73 };
     53static void ls_scan_dir(const char *d, DIR *dirp)
     54{
     55        struct dirent *dp;
     56        char *buff;
    7457
    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
     58        if (! dirp)
     59                return;
     60
     61        buff = (char *)malloc(PATH_MAX);
     62        if (NULL == buff) {
     63                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     64                return;
     65        }
     66
     67        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
     75        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
    7982 * some sort of ls_options structure that controls how each
    8083 * entry is printed and what is printed about it.
    8184 *
    82  * Now we just print basic DOS style lists.
    83  *
    84  * @param de            Directory element.
    85  */
    86 static void ls_print(struct dir_elem_t *de)
     85 * Now we just print basic DOS style lists */
     86
     87static void ls_print(const char *name, const char *pathname)
    8788{
    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 }
     89        struct stat s;
     90        int rc;
    9591
    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  */
    109 static 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  */
    131 static 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;
    141         struct dirent *dp;
    142        
    143         if (!dirp)
    144                 return;
    145 
    146         buff = (char *) malloc(PATH_MAX);
    147         if (!buff) {
    148                 cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     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);
    14997                return;
    15098        }
    15199       
    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        
    159         while ((dp = readdir(dirp))) {
    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';
     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);
    182106
    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        
    201 out:
    202         for(i = 0; i < nbdirs; i++)
    203                 free(tosort[i].name);
    204         free(tosort);
    205         free(buff);
     107        return;
    206108}
    207109
    … …  
    212114        } else {
    213115                help_cmd_ls(HELP_SHORT);
    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);
     116                printf("  `%s' [path], if no path is given the current "
     117                                "working directory is used.\n", cmdname);
    221118        }
    222119
    … …  
    227124{
    228125        unsigned int argc;
    229         struct dir_elem_t de;
     126        struct stat s;
     127        char *buff;
    230128        DIR *dirp;
    231         int c, opt_ind;
    232         int sort = 1;
    233129
    234130        argc = cli_count_args(argv);
    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) {
     131
     132        buff = (char *) malloc(PATH_MAX);
     133        if (NULL == buff) {
    252134                cli_error(CL_ENOMEM, "%s: ", cmdname);
    253135                return CMD_FAILURE;
    254136        }
    255         memset(de.name, 0, sizeof(PATH_MAX));
    256        
    257         if (argc == 0)
    258                 getcwd(de.name, PATH_MAX);
     137        memset(buff, 0, sizeof(buff));
     138
     139        if (argc == 1)
     140                getcwd(buff, PATH_MAX);
    259141        else
    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);
     142                str_cpy(buff, PATH_MAX, argv[1]);
     143
     144        if (stat(buff, &s)) {
     145                cli_error(CL_ENOENT, buff);
     146                free(buff);
    265147                return CMD_FAILURE;
    266148        }
    267149
    268         if (de.s.is_file) {
    269                 ls_print(&de);
     150        if (s.is_file) {
     151                ls_print(buff, buff);
    270152        } else {
    271                 dirp = opendir(de.name);
     153                dirp = opendir(buff);
    272154                if (!dirp) {
    273155                        /* May have been deleted between scoping it and opening it */
    274                         cli_error(CL_EFAIL, "Could not stat %s", de.name);
    275                         free(de.name);
     156                        cli_error(CL_EFAIL, "Could not stat %s", buff);
     157                        free(buff);
    276158                        return CMD_FAILURE;
    277159                }
    278                 ls_scan_dir(de.name, dirp, sort);
     160                ls_scan_dir(buff, dirp);
    279161                closedir(dirp);
    280162        }
    281163
    282         free(de.name);
     164        free(buff);
    283165
    284166        return CMD_SUCCESS;

  • uspace/app/init/init.c

    rbdbb6f6 r0864122  
    272272        mount_tmpfs();
    273273       
    274 #ifdef CONFIG_START_DEVMAN
    275         spawn("/srv/devman");
    276 #endif
    277274        spawn("/srv/apic");
    278275        spawn("/srv/i8259");

  • uspace/drv/isa/isa.c

    rbdbb6f6 r0864122  
    5353
    5454#include <ddf/driver.h>
    55 #include <ddf/log.h>
    5655#include <ops/hw_res.h>
    5756
    … …  
    135134        fd = open(conf_path, O_RDONLY);
    136135        if (fd < 0) {
    137                 ddf_msg(LVL_ERROR, "Unable to open %s\n", conf_path);
     136                printf(NAME ": unable to open %s\n", conf_path);
    138137                goto cleanup;
    139138        }
    … …  
    142141
    143142        len = lseek(fd, 0, SEEK_END);
    144         lseek(fd, 0, SEEK_SET);
     143        lseek(fd, 0, SEEK_SET); 
    145144        if (len == 0) {
    146                 ddf_msg(LVL_ERROR, "Configuration file '%s' is empty.\n",
    147                     conf_path);
     145                printf(NAME ": fun_conf_read error: configuration file '%s' "
     146                    "is empty.\n", conf_path);
    148147                goto cleanup;
    149148        }
    … …  
    151150        buf = malloc(len + 1);
    152151        if (buf == NULL) {
    153                 ddf_msg(LVL_ERROR, "Memory allocation failed.\n");
     152                printf(NAME ": fun_conf_read error: memory allocation failed.\n");
    154153                goto cleanup;
    155154        }
    156155
    157156        if (0 >= read(fd, buf, len)) {
    158                 ddf_msg(LVL_ERROR, "Unable to read file '%s'.\n", conf_path);
     157                printf(NAME ": fun_conf_read error: unable to read file '%s'.\n",
     158                    conf_path);
    159159                goto cleanup;
    160160        }
    … …  
    252252                fun->hw_resources.count++;
    253253
    254                 ddf_msg(LVL_NOTE, "Added irq 0x%x to function %s\n", irq,
     254                printf(NAME ": added irq 0x%x to function %s\n", irq,
    255255                    fun->fnode->name);
    256256        }
    … …  
    270270                fun->hw_resources.count++;
    271271
    272                 ddf_msg(LVL_NOTE, "Added io range (addr=0x%x, size=0x%x) to "
     272                printf(NAME ": added io range (addr=0x%x, size=0x%x) to "
    273273                    "function %s\n", (unsigned int) addr, (unsigned int) len,
    274274                    fun->fnode->name);
    … …  
    331331        score = (int)strtol(val, &end, 10);
    332332        if (val == end) {
    333                 ddf_msg(LVL_ERROR, "Cannot read match score for function "
    334                     "%s.\n", fun->fnode->name);
     333                printf(NAME " : error - could not read match score for "
     334                    "function %s.\n", fun->fnode->name);
    335335                return;
    336336        }
    … …  
    339339        get_match_id(&id, val);
    340340        if (id == NULL) {
    341                 ddf_msg(LVL_ERROR, "Cannot read match ID for function %s.\n",
    342                     fun->fnode->name);
     341                printf(NAME " : error - could not read match id for "
     342                    "function %s.\n", fun->fnode->name);
    343343                return;
    344344        }
    345345
    346         ddf_msg(LVL_DEBUG, "Adding match id '%s' with score %d to "
    347             "function %s\n", id, score, fun->fnode->name);
     346        printf(NAME ": adding match id '%s' with score %d to function %s\n", id,
     347            score, fun->fnode->name);
    348348
    349349        rc = ddf_fun_add_match_id(fun->fnode, id, score);
    350         if (rc != EOK) {
    351                 ddf_msg(LVL_ERROR, "Failed adding match ID: %s\n",
    352                     str_error(rc));
    353         }
     350        if (rc != EOK)
     351                printf(NAME ": error adding match ID: %s\n", str_error(rc));
    354352}
    355353
    … …  
    377375        if (!prop_parse(fun, line, "io_range", &fun_parse_io_range) &&
    378376            !prop_parse(fun, line, "irq", &fun_parse_irq) &&
    379             !prop_parse(fun, line, "match", &fun_parse_match_id)) {
    380 
    381                 ddf_msg(LVL_ERROR, "Undefined device property at line '%s'\n",
    382                     line);
     377            !prop_parse(fun, line, "match", &fun_parse_match_id))
     378        {
     379            printf(NAME " error undefined device property at line '%s'\n",
     380                line);
    383381        }
    384382}
    … …  
    441439        fun->fnode->ops = &isa_fun_ops;
    442440
    443         ddf_msg(LVL_DEBUG, "Binding function %s.\n", fun->fnode->name);
     441        printf(NAME ": Binding function %s.\n", fun->fnode->name);
    444442
    445443        /* XXX Handle error */
    … …  
    469467static int isa_add_device(ddf_dev_t *dev)
    470468{
    471         ddf_msg(LVL_DEBUG, "isa_add_device, device handle = %d\n",
     469        printf(NAME ": isa_add_device, device handle = %d\n",
    472470            (int) dev->handle);
    473471
    474472        /* Make the bus device more visible. Does not do anything. */
    475         ddf_msg(LVL_DEBUG, "Adding a 'ctl' function\n");
     473        printf(NAME ": adding a 'ctl' function\n");
    476474
    477475        ddf_fun_t *ctl = ddf_fun_create(dev, fun_exposed, "ctl");
    478476        if (ctl == NULL) {
    479                 ddf_msg(LVL_ERROR, "Failed creating control function.\n");
     477                printf(NAME ": Error creating control function.\n");
    480478                return EXDEV;
    481479        }
    482480
    483481        if (ddf_fun_bind(ctl) != EOK) {
    484                 ddf_msg(LVL_ERROR, "Failed binding control function.\n");
     482                printf(NAME ": Error binding control function.\n");
    485483                return EXDEV;
    486484        }
    … …  
    488486        /* Add functions as specified in the configuration file. */
    489487        isa_functions_add(dev);
    490         ddf_msg(LVL_NOTE, "Finished enumerating legacy functions\n");
     488        printf(NAME ": finished the enumeration of legacy functions\n");
    491489
    492490        return EOK;
    … …  
    495493static void isa_init()
    496494{
    497         ddf_log_init(NAME, LVL_ERROR);
    498495        isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
    499496}

  • uspace/drv/ns8250/ns8250.c

    rbdbb6f6 r0864122  
    5555#include <ddf/driver.h>
    5656#include <ddf/interrupt.h>
    57 #include <ddf/log.h>
    5857#include <ops/char_dev.h>
    5958
    … …  
    276275static bool ns8250_pio_enable(ns8250_t *ns)
    277276{
    278         ddf_msg(LVL_DEBUG, "ns8250_pio_enable %s\n", ns->dev->name);
     277        printf(NAME ": ns8250_pio_enable %s\n", ns->dev->name);
    279278       
    280279        /* Gain control over port's registers. */
    281280        if (pio_enable((void *)(uintptr_t) ns->io_addr, REG_COUNT,
    282281            (void **) &ns->port)) {
    283                 ddf_msg(LVL_ERROR, "Cannot map the port %#" PRIx32
    284                     " for device %s.\n", ns->io_addr, ns->dev->name);
     282                printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
     283                    "%s.\n", ns->io_addr, ns->dev->name);
    285284                return false;
    286285        }
    … …  
    296295static bool ns8250_dev_probe(ns8250_t *ns)
    297296{
    298         ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s\n", ns->dev->name);
     297        printf(NAME ": ns8250_dev_probe %s\n", ns->dev->name);
    299298       
    300299        ioport8_t *port_addr = ns->port;
    … …  
    314313        pio_write_8(port_addr + 4, olddata);
    315314       
    316         if (!res) {
    317                 ddf_msg(LVL_DEBUG, "Device %s is not present.\n",
    318                     ns->dev->name);
    319         }
     315        if (!res)
     316                printf(NAME ": device %s is not present.\n", ns->dev->name);
    320317       
    321318        return res;
    … …  
    329326static int ns8250_dev_initialize(ns8250_t *ns)
    330327{
    331         ddf_msg(LVL_DEBUG, "ns8250_dev_initialize %s\n", ns->dev->name);
     328        printf(NAME ": ns8250_dev_initialize %s\n", ns->dev->name);
    332329       
    333330        int ret = EOK;
    … …  
    340337            IPC_FLAG_BLOCKING);
    341338        if (ns->dev->parent_phone < 0) {
    342                 ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
     339                printf(NAME ": failed to connect to the parent driver of the "
    343340                    "device %s.\n", ns->dev->name);
    344341                ret = ns->dev->parent_phone;
    … …  
    349346        ret = hw_res_get_resource_list(ns->dev->parent_phone, &hw_resources);
    350347        if (ret != EOK) {
    351                 ddf_msg(LVL_ERROR, "Failed to get HW resources for device "
     348                printf(NAME ": failed to get hw resources for the device "
    352349                    "%s.\n", ns->dev->name);
    353350                goto failed;
    … …  
    365362                        ns->irq = res->res.interrupt.irq;
    366363                        irq = true;
    367                         ddf_msg(LVL_NOTE, "Device %s was asigned irq = 0x%x.\n",
     364                        printf(NAME ": the %s device was asigned irq = 0x%x.\n",
    368365                            ns->dev->name, ns->irq);
    369366                        break;
    … …  
    372369                        ns->io_addr = res->res.io_range.address;
    373370                        if (res->res.io_range.size < REG_COUNT) {
    374                                 ddf_msg(LVL_ERROR, "I/O range assigned to "
    375                                     "device %s is too small.\n", ns->dev->name);
     371                                printf(NAME ": i/o range assigned to the device "
     372                                    "%s is too small.\n", ns->dev->name);
    376373                                ret = ELIMIT;
    377374                                goto failed;
    378375                        }
    379376                        ioport = true;
    380                         ddf_msg(LVL_NOTE, "Device %s was asigned I/O address = "
     377                        printf(NAME ": the %s device was asigned i/o address = "
    381378                            "0x%x.\n", ns->dev->name, ns->io_addr);
    382379                        break;
    … …  
    388385       
    389386        if (!irq || !ioport) {
    390                 ddf_msg(LVL_ERROR, "Missing HW resource(s) for device %s.\n",
     387                printf(NAME ": missing hw resource(s) for the device %s.\n",
    391388                    ns->dev->name);
    392389                ret = ENOENT;
    … …  
    473470       
    474471        if (baud_rate < 50 || MAX_BAUD_RATE % baud_rate != 0) {
    475                 ddf_msg(LVL_ERROR, "Invalid baud rate %d requested.\n",
    476                     baud_rate);
     472                printf(NAME ": error - somebody tried to set invalid baud rate "
     473                    "%d\n", baud_rate);
    477474                return EINVAL;
    478475        }
    … …  
    657654                        if (ns->client_connected) {
    658655                                if (!buf_push_back(&ns->input_buffer, val)) {
    659                                         ddf_msg(LVL_WARN, "Buffer overflow on "
     656                                        printf(NAME ": buffer overflow on "
    660657                                            "%s.\n", ns->dev->name);
    661658                                } else {
    662                                         ddf_msg(LVL_DEBUG2, "Character %c saved "
     659                                        printf(NAME ": the character %c saved "
    663660                                            "to the buffer of %s.\n",
    664661                                            val, ns->dev->name);
    … …  
    717714        int rc;
    718715       
    719         ddf_msg(LVL_DEBUG, "ns8250_add_device %s (handle = %d)\n",
     716        printf(NAME ": ns8250_add_device %s (handle = %d)\n",
    720717            dev->name, (int) dev->handle);
    721718       
    … …  
    752749        /* Register interrupt handler. */
    753750        if (ns8250_register_interrupt_handler(ns) != EOK) {
    754                 ddf_msg(LVL_ERROR, "Failed to register interrupt handler.\n");
     751                printf(NAME ": failed to register interrupt handler.\n");
    755752                rc = EADDRNOTAVAIL;
    756753                goto fail;
    … …  
    760757        rc = ns8250_interrupt_enable(ns);
    761758        if (rc != EOK) {
    762                 ddf_msg(LVL_ERROR, "Failed to enable the interrupt. Error code = "
     759                printf(NAME ": failed to enable the interrupt. Error code = "
    763760                    "%d.\n", rc);
    764761                goto fail;
    … …  
    767764        fun = ddf_fun_create(dev, fun_exposed, "a");
    768765        if (fun == NULL) {
    769                 ddf_msg(LVL_ERROR, "Failed creating function.\n");
     766                printf(NAME ": error creating function.\n");
    770767                goto fail;
    771768        }
    … …  
    775772        rc = ddf_fun_bind(fun);
    776773        if (rc != EOK) {
    777                 ddf_msg(LVL_ERROR, "Failed binding function.\n");
     774                printf(NAME ": error binding function.\n");
    778775                goto fail;
    779776        }
    … …  
    783780        ddf_fun_add_to_class(fun, "serial");
    784781       
    785         ddf_msg(LVL_NOTE, "Device %s successfully initialized.\n",
     782        printf(NAME ": the %s device has been successfully initialized.\n",
    786783            dev->name);
    787784       
    … …  
    865862        fibril_mutex_unlock(&data->mutex);
    866863       
    867         ddf_msg(LVL_DEBUG, "ns8250_get_props: baud rate %d, parity 0x%x, word "
     864        printf(NAME ": ns8250_get_props: baud rate %d, parity 0x%x, word "
    868865            "length %d, stop bits %d\n", *baud_rate, *parity, *word_length,
    869866            *stop_bits);
    … …  
    882879    unsigned int parity, unsigned int word_length, unsigned int stop_bits)
    883880{
    884         ddf_msg(LVL_DEBUG, "ns8250_set_props: baud rate %d, parity 0x%x, word "
     881        printf(NAME ": ns8250_set_props: baud rate %d, parity 0x%x, word "
    885882            "length %d, stop bits %d\n", baud_rate, parity, word_length,
    886883            stop_bits);
    … …  
    943940static void ns8250_init(void)
    944941{
    945         ddf_log_init(NAME, LVL_ERROR);
    946        
    947942        ns8250_dev_ops.open = &ns8250_open;
    948943        ns8250_dev_ops.close = &ns8250_close;

  • uspace/drv/pciintel/pci.c

    rbdbb6f6 r0864122  
    4848
    4949#include <ddf/driver.h>
    50 #include <ddf/log.h>
    5150#include <devman.h>
    5251#include <ipc/devman.h>
    … …  
    226225
    227226        if (match_id_str == NULL) {
    228                 ddf_msg(LVL_ERROR, "Out of memory creating match ID.\n");
     227                printf(NAME ": out of memory creating match ID.\n");
    229228                return;
    230229        }
    … …  
    232231        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 90);
    233232        if (rc != EOK) {
    234                 ddf_msg(LVL_ERROR, "Failed adding match ID: %s\n",
     233                printf(NAME ": error adding match ID: %s\n",
    235234                    str_error(rc));
    236235        }
    … …  
    324323       
    325324        if (range_addr != 0) {
    326                 ddf_msg(LVL_DEBUG, "Function %s : address = %" PRIx64
    327                     ", size = %x\n", fun->fnode->name, range_addr,
    328                     (unsigned int) range_size);
     325                printf(NAME ": function %s : ", fun->fnode->name);
     326                printf("address = %" PRIx64, range_addr);
     327                printf(", size = %x\n", (unsigned int) range_size);
    329328        }
    330329       
    … …  
    351350        hw_res_list->count++;
    352351       
    353         ddf_msg(LVL_NOTE, "Function %s uses irq %x.\n", fun->fnode->name, irq);
     352        printf(NAME ": function %s uses irq %x.\n", fun->fnode->name, irq);
    354353}
    355354
    … …  
    407406                        char *fun_name = pci_fun_create_name(fun);
    408407                        if (fun_name == NULL) {
    409                                 ddf_msg(LVL_ERROR, "Out of memory.\n");
     408                                printf(NAME ": out of memory.\n");
    410409                                return;
    411410                        }
    … …  
    413412                        fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name);
    414413                        if (fnode == NULL) {
    415                                 ddf_msg(LVL_ERROR, "Failed creating function.\n");
     414                                printf(NAME ": error creating function.\n");
    416415                                return;
    417416                        }
    … …  
    427426                        fnode->driver_data = fun;
    428427                       
    429                         ddf_msg(LVL_DEBUG, "Adding new function %s.\n",
     428                        printf(NAME ": adding new function %s.\n",
    430429                            fnode->name);
    431430                       
    … …  
    444443                                child_bus = pci_conf_read_8(fun,
    445444                                    PCI_BRIDGE_SEC_BUS_NUM);
    446                                 ddf_msg(LVL_DEBUG, "Device is pci-to-pci "
    447                                     "bridge, secondary bus number = %d.\n",
    448                                     bus_num);
     445                                printf(NAME ": device is pci-to-pci bridge, "
     446                                    "secondary bus number = %d.\n", bus_num);
    449447                                if (child_bus > bus_num)
    450448                                        pci_bus_scan(bus, child_bus);
    … …  
    468466        int rc;
    469467       
    470         ddf_msg(LVL_DEBUG, "pci_add_device\n");
     468        printf(NAME ": pci_add_device\n");
    471469        dnode->parent_phone = -1;
    472470       
    473471        bus = pci_bus_new();
    474472        if (bus == NULL) {
    475                 ddf_msg(LVL_ERROR, "pci_add_device allocation failed.\n");
     473                printf(NAME ": pci_add_device allocation failed.\n");
    476474                rc = ENOMEM;
    477475                goto fail;
    … …  
    483481            IPC_FLAG_BLOCKING);
    484482        if (dnode->parent_phone < 0) {
    485                 ddf_msg(LVL_ERROR, "pci_add_device failed to connect to the "
     483                printf(NAME ": pci_add_device failed to connect to the "
    486484                    "parent's driver.\n");
    487485                rc = dnode->parent_phone;
    … …  
    493491        rc = hw_res_get_resource_list(dnode->parent_phone, &hw_resources);
    494492        if (rc != EOK) {
    495                 ddf_msg(LVL_ERROR, "pci_add_device failed to get hw resources "
    496                     "for the device.\n");
     493                printf(NAME ": pci_add_device failed to get hw resources for "
     494                    "the device.\n");
    497495                goto fail;
    498496        }
    499497        got_res = true;
    500498       
    501         ddf_msg(LVL_DEBUG, "conf_addr = %" PRIx64 ".\n",
     499        printf(NAME ": conf_addr = %" PRIx64 ".\n",
    502500            hw_resources.resources[0].res.io_range.address);
    503501       
    … …  
    511509        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8,
    512510            &bus->conf_addr_port)) {
    513                 ddf_msg(LVL_ERROR, "Failed to enable configuration ports.\n");
     511                printf(NAME ": failed to enable configuration ports.\n");
    514512                rc = EADDRNOTAVAIL;
    515513                goto fail;
    … …  
    518516       
    519517        /* Make the bus device more visible. It has no use yet. */
    520         ddf_msg(LVL_DEBUG, "Adding a 'ctl' function\n");
     518        printf(NAME ": adding a 'ctl' function\n");
    521519       
    522520        ctl = ddf_fun_create(bus->dnode, fun_exposed, "ctl");
    … …  
    534532       
    535533        /* Enumerate functions. */
    536         ddf_msg(LVL_DEBUG, "Scanning the bus\n");
     534        printf(NAME ": scanning the bus\n");
    537535        pci_bus_scan(bus, 0);
    538536       
    … …  
    556554static void pciintel_init(void)
    557555{
    558         ddf_log_init(NAME, LVL_ERROR);
    559556        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
    560557}

  • uspace/drv/root/root.c

    rbdbb6f6 r0864122  
    5252
    5353#include <ddf/driver.h>
    54 #include <ddf/log.h>
    5554#include <devman.h>
    5655#include <ipc/devman.h>
    … …  
    9089        int rc;
    9190
    92         ddf_msg(LVL_DEBUG, "Adding new function for virtual devices. "
    93             "Function node is `%s' (%d %s)\n", name,
     91        printf(NAME ": adding new function for virtual devices.\n");
     92        printf(NAME ":   function node is `%s' (%d %s)\n", name,
    9493            VIRTUAL_FUN_MATCH_SCORE, VIRTUAL_FUN_MATCH_ID);
    9594
    9695        fun = ddf_fun_create(dev, fun_inner, name);
    9796        if (fun == NULL) {
    98                 ddf_msg(LVL_ERROR, "Failed creating function %s\n", name);
     97                printf(NAME ": error creating function %s\n", name);
    9998                return ENOMEM;
    10099        }
    … …  
    103102            VIRTUAL_FUN_MATCH_SCORE);
    104103        if (rc != EOK) {
    105                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s\n", name);
     104                printf(NAME ": error adding match IDs to function %s\n", name);
    106105                ddf_fun_destroy(fun);
    107106                return rc;
    … …  
    110109        rc = ddf_fun_bind(fun);
    111110        if (rc != EOK) {
    112                 ddf_msg(LVL_ERROR, "Failed binding function %s: %s\n", name,
     111                printf(NAME ": error binding function %s: %s\n", name,
    113112                    str_error(rc));
    114113                ddf_fun_destroy(fun);
    … …  
    137136        platform = sysinfo_get_data("platform", &platform_size);
    138137        if (platform == NULL) {
    139                 ddf_msg(LVL_ERROR, "Failed to obtain platform name.\n");
     138                printf(NAME ": Failed to obtain platform name.\n");
    140139                return ENOENT;
    141140        }
    … …  
    144143        platform = realloc(platform, platform_size + 1);
    145144        if (platform == NULL) {
    146                 ddf_msg(LVL_ERROR, "Memory allocation failed.\n");
     145                printf(NAME ": Memory allocation failed.\n");
    147146                return ENOMEM;
    148147        }
    … …  
    152151        /* Construct match ID. */
    153152        if (asprintf(&match_id, PLATFORM_FUN_MATCH_ID_FMT, platform) == -1) {
    154                 ddf_msg(LVL_ERROR, "Memory allocation failed.\n");
     153                printf(NAME ": Memory allocation failed.\n");
    155154                return ENOMEM;
    156155        }
    157156
    158157        /* Add function. */
    159         ddf_msg(LVL_DEBUG, "Adding platform function. Function node is `%s' "
    160             " (%d %s)\n", PLATFORM_FUN_NAME, PLATFORM_FUN_MATCH_SCORE,
    161             match_id);
     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);
    162161
    163162        fun = ddf_fun_create(dev, fun_inner, name);
    164163        if (fun == NULL) {
    165                 ddf_msg(LVL_ERROR, "Error creating function %s\n", name);
     164                printf(NAME ": error creating function %s\n", name);
    166165                return ENOMEM;
    167166        }
    … …  
    169168        rc = ddf_fun_add_match_id(fun, match_id, PLATFORM_FUN_MATCH_SCORE);
    170169        if (rc != EOK) {
    171                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s\n",
    172                     name);
     170                printf(NAME ": error adding match IDs to function %s\n", name);
    173171                ddf_fun_destroy(fun);
    174172                return rc;
    … …  
    177175        rc = ddf_fun_bind(fun);
    178176        if (rc != EOK) {
    179                 ddf_msg(LVL_ERROR, "Failed binding function %s: %s\n", name,
     177                printf(NAME ": error binding function %s: %s\n", name,
    180178                    str_error(rc));
    181179                ddf_fun_destroy(fun);
    … …  
    193191static int root_add_device(ddf_dev_t *dev)
    194192{
    195         ddf_msg(LVL_DEBUG, "root_add_device, device handle=%" PRIun "\n",
     193        printf(NAME ": root_add_device, device handle=%" PRIun "\n",
    196194            dev->handle);
    197195
    … …  
    206204        int res = add_platform_fun(dev);
    207205        if (EOK != res)
    208                 ddf_msg(LVL_ERROR, "Failed adding child device for platform.\n");
     206                printf(NAME ": failed to add child device for platform.\n");
    209207
    210208        return res;
    … …  
    214212{
    215213        printf(NAME ": HelenOS root device driver\n");
    216 
    217         ddf_log_init(NAME, LVL_ERROR);
    218214        return ddf_driver_main(&root_driver);
    219215}

  • uspace/drv/rootpc/rootpc.c

    rbdbb6f6 r0864122  
    4747
    4848#include <ddf/driver.h>
    49 #include <ddf/log.h>
    5049#include <devman.h>
    5150#include <ipc/devman.h>
    … …  
    120119    rootpc_fun_t *fun)
    121120{
    122         ddf_msg(LVL_DEBUG, "Adding new function '%s'.\n", name);
     121        printf(NAME ": adding new function '%s'.\n", name);
    123122       
    124123        ddf_fun_t *fnode = NULL;
    … …  
    146145        /* Register function. */
    147146        if (ddf_fun_bind(fnode) != EOK) {
    148                 ddf_msg(LVL_ERROR, "Failed binding function %s.\n", name);
     147                printf(NAME ": error binding function %s.\n", name);
    149148                goto failure;
    150149        }
    … …  
    159158                ddf_fun_destroy(fnode);
    160159       
    161         ddf_msg(LVL_ERROR, "Failed adding function '%s'.\n", name);
     160        printf(NAME ": failed to add function '%s'.\n", name);
    162161       
    163162        return false;
    … …  
    177176static int rootpc_add_device(ddf_dev_t *dev)
    178177{
    179         ddf_msg(LVL_DEBUG, "rootpc_add_device, device handle = %d\n",
     178        printf(NAME ": rootpc_add_device, device handle = %d\n",
    180179            (int)dev->handle);
    181180       
    182181        /* Register functions. */
    183182        if (!rootpc_add_functions(dev)) {
    184                 ddf_msg(LVL_ERROR, "Failed to add functions for PC platform.\n");
     183                printf(NAME ": failed to add functions for PC platform.\n");
    185184        }
    186185       
    … …  
    190189static void root_pc_init(void)
    191190{
    192         ddf_log_init(NAME, LVL_ERROR);
    193191        rootpc_fun_ops.interfaces[HW_RES_DEV_IFACE] = &fun_hw_res_ops;
    194192}

  • uspace/drv/rootvirt/rootvirt.c

    rbdbb6f6 r0864122  
    4040#include <str_error.h>
    4141#include <ddf/driver.h>
    42 #include <ddf/log.h>
    4342
    4443#define NAME "rootvirt"
    … …  
    8483        int rc;
    8584
    86         ddf_msg(LVL_DEBUG, "Registering function `%s' (match \"%s\")\n",
     85        printf(NAME ": registering function `%s' (match \"%s\")\n",
    8786            vfun->name, vfun->match_id);
    8887
    8988        fun = ddf_fun_create(vdev, fun_inner, vfun->name);
    9089        if (fun == NULL) {
    91                 ddf_msg(LVL_ERROR, "Failed creating function %s\n", vfun->name);
     90                printf(NAME ": error creating function %s\n", vfun->name);
    9291                return ENOMEM;
    9392        }
    … …  
    9594        rc = ddf_fun_add_match_id(fun, vfun->match_id, 10);
    9695        if (rc != EOK) {
    97                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s\n",
     96                printf(NAME ": error adding match IDs to function %s\n",
    9897                    vfun->name);
    9998                ddf_fun_destroy(fun);
    … …  
    103102        rc = ddf_fun_bind(fun);
    104103        if (rc != EOK) {
    105                 ddf_msg(LVL_ERROR, "Failed binding function %s: %s\n", vfun->name,
     104                printf(NAME ": error binding function %s: %s\n", vfun->name,
    106105                    str_error(rc));
    107106                ddf_fun_destroy(fun);
    … …  
    109108        }
    110109
    111         ddf_msg(LVL_NOTE, "Registered child device `%s'\n", vfun->name);
     110        printf(NAME ": registered child device `%s'\n", vfun->name);
    112111        return EOK;
    113112}
    … …  
    125124        }
    126125
    127         ddf_msg(LVL_DEBUG, "add_device(handle=%d)\n", (int)dev->handle);
     126        printf(NAME ": add_device(handle=%d)\n", (int)dev->handle);
    128127
    129128        /*
    … …  
    143142{
    144143        printf(NAME ": HelenOS virtual devices root driver\n");
    145 
    146         ddf_log_init(NAME, LVL_ERROR);
    147144        return ddf_driver_main(&rootvirt_driver);
    148145}

  • uspace/drv/test1/test1.c

    rbdbb6f6 r0864122  
    3535#include <str_error.h>
    3636#include <ddf/driver.h>
    37 #include <ddf/log.h>
    3837
    3938#include "test1.h"
    … …  
    6564        int rc;
    6665
    67         ddf_msg(LVL_DEBUG, "Registering function `%s': %s.\n", name, message);
     66        printf(NAME ": registering function `%s': %s.\n", name, message);
    6867
    6968        fun = ddf_fun_create(parent, fun_inner, name);
    7069        if (fun == NULL) {
    71                 ddf_msg(LVL_ERROR, "Failed creating function %s\n", name);
     70                printf(NAME ": error creating function %s\n", name);
    7271                rc = ENOMEM;
    7372                goto leave;
    … …  
    7675        rc = ddf_fun_add_match_id(fun, str_dup(match_id), match_score);
    7776        if (rc != EOK) {
    78                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s\n",
    79                     name);
     77                printf(NAME ": error adding match IDs to function %s\n", name);
    8078                goto leave;
    8179        }
    … …  
    8381        rc = ddf_fun_bind(fun);
    8482        if (rc != EOK) {
    85                 ddf_msg(LVL_ERROR, "Failed binding function %s: %s\n", name,
     83                printf(NAME ": error binding function %s: %s\n", name,
    8684                    str_error(rc));
    8785                goto leave;
    8886        }
    8987
    90         ddf_msg(LVL_NOTE, "Registered child device `%s'\n", name);
     88        printf(NAME ": registered child device `%s'\n", name);
    9189        rc = EOK;
     90
    9291
    9392leave:
    9493        if (rc != expected_rc) {
    9594                fprintf(stderr,
    96                     NAME ": Unexpected error registering function `%s'.\n"
     95                    NAME ": Unexpected error registering function `%s'.\n" \
    9796                    NAME ":     Expected \"%s\" but got \"%s\".\n",
    9897                    name, str_error(expected_rc), str_error(rc));
    … …  
    128127        int rc;
    129128
    130         ddf_msg(LVL_DEBUG, "add_device(name=\"%s\", handle=%d)\n",
     129        printf(NAME ": add_device(name=\"%s\", handle=%d)\n",
    131130            dev->name, (int) dev->handle);
    132131
    133132        fun_a = ddf_fun_create(dev, fun_exposed, "a");
    134133        if (fun_a == NULL) {
    135                 ddf_msg(LVL_ERROR, "Failed creating function 'a'.\n");
     134                printf(NAME ": error creating function 'a'.\n");
    136135                return ENOMEM;
    137136        }
    … …  
    139138        rc = ddf_fun_bind(fun_a);
    140139        if (rc != EOK) {
    141                 ddf_msg(LVL_ERROR, "Failed binding function 'a'.\n");
     140                printf(NAME ": error binding function 'a'.\n");
    142141                return rc;
    143142        }
    … …  
    161160        }
    162161
    163         ddf_msg(LVL_DEBUG, "Device `%s' accepted.\n", dev->name);
     162        printf(NAME ": device `%s' accepted.\n", dev->name);
    164163
    165164        return EOK;
    … …  
    169168{
    170169        printf(NAME ": HelenOS test1 virtual device driver\n");
    171         ddf_log_init(NAME, LVL_ERROR);
    172170        return ddf_driver_main(&test1_driver);
    173171}

  • uspace/drv/test2/test2.c

    rbdbb6f6 r0864122  
    3636#include <str_error.h>
    3737#include <ddf/driver.h>
    38 #include <ddf/log.h>
    3938
    4039#define NAME "test2"
    … …  
    6564        int rc;
    6665
    67         ddf_msg(LVL_DEBUG, "Registering function `%s': %s.\n", name, message);
     66        printf(NAME ": registering function `%s': %s.\n", name, message);
    6867
    6968        fun = ddf_fun_create(parent, fun_inner, name);
    7069        if (fun == NULL) {
    71                 ddf_msg(LVL_ERROR, "Failed creating function %s\n", name);
     70                printf(NAME ": error creating function %s\n", name);
    7271                return ENOMEM;
    7372        }
    … …  
    7574        rc = ddf_fun_add_match_id(fun, match_id, match_score);
    7675        if (rc != EOK) {
    77                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s\n",
    78                     name);
     76                printf(NAME ": error adding match IDs to function %s\n", name);
    7977                ddf_fun_destroy(fun);
    8078                return rc;
    … …  
    8381        rc = ddf_fun_bind(fun);
    8482        if (rc != EOK) {
    85                 ddf_msg(LVL_ERROR, "Failed binding function %s: %s\n", name,
     83                printf(NAME ": error binding function %s: %s\n", name,
    8684                    str_error(rc));
    8785                ddf_fun_destroy(fun);
    … …  
    8987        }
    9088
    91         ddf_msg(LVL_NOTE, "Registered child device `%s'\n", name);
     89        printf(NAME ": registered child device `%s'\n", name);
    9290        return EOK;
    9391}
    … …  
    113111        fun_a = ddf_fun_create(dev, fun_exposed, "a");
    114112        if (fun_a == NULL) {
    115                 ddf_msg(LVL_ERROR, "Failed creating function 'a'.\n");
     113                printf(NAME ": error creating function 'a'.\n");
    116114                return ENOMEM;
    117115        }
    … …  
    119117        rc = ddf_fun_bind(fun_a);
    120118        if (rc != EOK) {
    121                 ddf_msg(LVL_ERROR, "Failed binding function 'a'.\n");
     119                printf(NAME ": error binding function 'a'.\n");
    122120                return rc;
    123121        }
    … …  
    130128static int test2_add_device(ddf_dev_t *dev)
    131129{
    132         ddf_msg(LVL_DEBUG, "test2_add_device(name=\"%s\", handle=%d)\n",
     130        printf(NAME ": test2_add_device(name=\"%s\", handle=%d)\n",
    133131            dev->name, (int) dev->handle);
    134132
    … …  
    136134                fid_t postpone = fibril_create(postponed_birth, dev);
    137135                if (postpone == 0) {
    138                         ddf_msg(LVL_ERROR, "fibril_create() failed.\n");
     136                        printf(NAME ": fibril_create() error\n");
    139137                        return ENOMEM;
    140138                }
    … …  
    151149{
    152150        printf(NAME ": HelenOS test2 virtual device driver\n");
    153         ddf_log_init(NAME, LVL_ERROR);
    154151        return ddf_driver_main(&test2_driver);
    155152}

  • uspace/lib/c/Makefile

    rbdbb6f6 r0864122  
    7676        generic/io/io.c \
    7777        generic/io/printf.c \
    78         generic/io/log.c \
    7978        generic/io/klog.c \
    8079        generic/io/snprintf.c \

  • uspace/lib/drv/Makefile

    rbdbb6f6 r0864122  
    3535        generic/driver.c \
    3636        generic/dev_iface.c \
    37         generic/log.c \
    3837        generic/remote_hw_res.c \
    3938        generic/remote_char_dev.c

  • uspace/lib/drv/generic/driver.c

    rbdbb6f6 r0864122  
    273273       
    274274        res = driver->driver_ops->add_device(dev);
    275         if (res != EOK)
     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);
    276281                delete_device(dev);
     282        }
    277283       
    278284        async_answer_0(iid, res);

  • uspace/srv/devman/devman.c

    rbdbb6f6 r0864122  
    3434#include <fcntl.h>
    3535#include <sys/stat.h>
    36 #include <io/log.h>
    3736#include <ipc/driver.h>
    3837#include <ipc/devman.h>
    … …  
    147146        fibril_mutex_unlock(&drivers_list->drivers_mutex);
    148147
    149         log_msg(LVL_NOTE, "Driver `%s' was added to the list of available "
     148        printf(NAME": the '%s' driver was added to the list of available "
    150149            "drivers.\n", drv->name);
    151150}
    … …  
    238237bool read_match_ids(const char *conf_path, match_id_list_t *ids)
    239238{
    240         log_msg(LVL_DEBUG, "read_match_ids(conf_path=\"%s\")\n", conf_path);
     239        printf(NAME ": read_match_ids conf_path = %s.\n", conf_path);
    241240       
    242241        bool suc = false;
    … …  
    248247        fd = open(conf_path, O_RDONLY);
    249248        if (fd < 0) {
    250                 log_msg(LVL_ERROR, "Unable to open `%s' for reading: %s.\n",
    251                     conf_path, str_error(fd));
     249                printf(NAME ": unable to open %s\n", conf_path);
    252250                goto cleanup;
    253251        }
    … …  
    257255        lseek(fd, 0, SEEK_SET);
    258256        if (len == 0) {
    259                 log_msg(LVL_ERROR, "Configuration file '%s' is empty.\n",
    260                     conf_path);
     257                printf(NAME ": configuration file '%s' is empty.\n", conf_path);
    261258                goto cleanup;
    262259        }
    … …  
    264261        buf = malloc(len + 1);
    265262        if (buf == NULL) {
    266                 log_msg(LVL_ERROR, "Memory allocation failed when parsing file "
     263                printf(NAME ": memory allocation failed when parsing file "
    267264                    "'%s'.\n", conf_path);
    268265                goto cleanup;
    … …  
    271268        ssize_t read_bytes = safe_read(fd, buf, len);
    272269        if (read_bytes <= 0) {
    273                 log_msg(LVL_ERROR, "Unable to read file '%s'.\n", conf_path);
     270                printf(NAME ": unable to read file '%s'.\n", conf_path);
    274271                goto cleanup;
    275272        }
    … …  
    309306bool get_driver_info(const char *base_path, const char *name, driver_t *drv)
    310307{
    311         log_msg(LVL_DEBUG, "get_driver_info(base_path=\"%s\", name=\"%s\")\n",
     308        printf(NAME ": get_driver_info base_path = %s, name = %s.\n",
    312309            base_path, name);
    313310       
    … …  
    341338        struct stat s;
    342339        if (stat(drv->binary_path, &s) == ENOENT) { /* FIXME!! */
    343                 log_msg(LVL_ERROR, "Driver not found at path `%s'.",
    344                     drv->binary_path);
     340                printf(NAME ": driver not found at path %s.", drv->binary_path);
    345341                goto cleanup;
    346342        }
    … …  
    369365int lookup_available_drivers(driver_list_t *drivers_list, const char *dir_path)
    370366{
    371         log_msg(LVL_DEBUG, "lookup_available_drivers(dir=\"%s\")\n", dir_path);
     367        printf(NAME ": lookup_available_drivers, dir = %s \n", dir_path);
    372368       
    373369        int drv_cnt = 0;
    … …  
    403399        dev_node_t *dev;
    404400       
    405         log_msg(LVL_DEBUG, "create_root_nodes()\n");
     401        printf(NAME ": create_root_nodes\n");
    406402       
    407403        fibril_rwlock_write_lock(&tree->rwlock);
    … …  
    488484void attach_driver(dev_node_t *dev, driver_t *drv)
    489485{
    490         log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")\n",
    491             dev->pfun->pathname, drv->name);
     486        printf(NAME ": attach_driver %s to device %s\n",
     487            drv->name, dev->pfun->pathname);
    492488       
    493489        fibril_mutex_lock(&drv->driver_mutex);
    … …  
    511507        assert(fibril_mutex_is_locked(&drv->driver_mutex));
    512508       
    513         log_msg(LVL_DEBUG, "start_driver(drv=\"%s\")\n", drv->name);
     509        printf(NAME ": start_driver '%s'\n", drv->name);
    514510       
    515511        rc = task_spawnl(NULL, drv->binary_path, drv->binary_path, NULL);
    516512        if (rc != EOK) {
    517                 log_msg(LVL_ERROR, "Spawning driver `%s' (%s) failed: %s.\n",
    518                     drv->name, drv->binary_path, str_error(rc));
     513                printf(NAME ": error spawning %s (%s)\n",
     514                    drv->name, str_error(rc));
    519515                return false;
    520516        }
    … …  
    578574        int phone;
    579575
    580         log_msg(LVL_DEBUG, "pass_devices_to_driver(driver=\"%s\")\n",
    581             driver->name);
     576        printf(NAME ": pass_devices_to_driver(`%s')\n", driver->name);
    582577
    583578        fibril_mutex_lock(&driver->driver_mutex);
    … …  
    646641         * immediately and possibly started here as well.
    647642         */
    648         log_msg(LVL_DEBUG, "Driver `%s' enters running state.\n", driver->name);
     643        printf(NAME ": driver %s goes into running state.\n", driver->name);
    649644        driver->state = DRIVER_RUNNING;
    650645
    … …  
    663658void initialize_running_driver(driver_t *driver, dev_tree_t *tree)
    664659{
    665         log_msg(LVL_DEBUG, "initialize_running_driver(driver=\"%s\")\n",
    666             driver->name);
     660        printf(NAME ": initialize_running_driver (`%s')\n", driver->name);
    667661       
    668662        /*
    … …  
    754748         * access any structures that would affect driver_t.
    755749         */
    756         log_msg(LVL_DEBUG, "add_device(drv=\"%s\", dev=\"%s\")\n",
    757             drv->name, dev->pfun->name);
     750        printf(NAME ": add_device (driver `%s', device `%s')\n", drv->name,
     751            dev->pfun->name);
    758752       
    759753        sysarg_t rc;
    … …  
    816810        driver_t *drv = find_best_match_driver(drivers_list, dev);
    817811        if (drv == NULL) {
    818                 log_msg(LVL_ERROR, "No driver found for device `%s'.\n",
     812                printf(NAME ": no driver found for device '%s'.\n",
    819813                    dev->pfun->pathname);
    820814                return false;
    … …  
    854848bool init_device_tree(dev_tree_t *tree, driver_list_t *drivers_list)
    855849{
    856         log_msg(LVL_DEBUG, "init_device_tree()\n");
     850        printf(NAME ": init_device_tree.\n");
    857851       
    858852        tree->current_handle = 0;
    … …  
    10331027        fun->pathname = (char *) malloc(pathsize);
    10341028        if (fun->pathname == NULL) {
    1035                 log_msg(LVL_ERROR, "Failed to allocate device path.\n");
     1029                printf(NAME ": failed to allocate device path.\n");
    10361030                return false;
    10371031        }
    … …  
    10641058        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10651059       
    1066         log_msg(LVL_DEBUG, "insert_dev_node(dev=%p, pfun=%p [\"%s\"])\n",
    1067             dev, pfun, pfun->pathname);
    1068 
    10691060        /* Add the node to the handle-to-node map. */
    10701061        dev->handle = ++tree->current_handle;
    … …  
    10731064
    10741065        /* Add the node to the list of its parent's children. */
     1066        printf("insert_dev_node: dev=%p, dev->pfun := %p\n", dev, pfun);
    10751067        dev->pfun = pfun;
    10761068        pfun->child = dev;

  • uspace/srv/devman/main.c

    rbdbb6f6 r0864122  
    4343#include <stdio.h>
    4444#include <errno.h>
    45 #include <str_error.h>
    4645#include <bool.h>
    4746#include <fibril_synch.h>
    … …  
    5251#include <sys/stat.h>
    5352#include <ctype.h>
    54 #include <io/log.h>
    5553#include <ipc/devman.h>
    5654#include <ipc/driver.h>
    … …  
    7371        driver_t *driver = NULL;
    7472
    75         log_msg(LVL_DEBUG, "devman_driver_register\n");
     73        printf(NAME ": devman_driver_register \n");
    7674       
    7775        iid = async_get_call(&icall);
    … …  
    9088        }
    9189
    92         log_msg(LVL_DEBUG, "The `%s' driver is trying to register.\n",
     90        printf(NAME ": the %s driver is trying to register by the service.\n",
    9391            drv_name);
    9492       
    … …  
    9795       
    9896        if (driver == NULL) {
    99                 log_msg(LVL_ERROR, "No driver named `%s' was found.\n", drv_name);
     97                printf(NAME ": no driver named %s was found.\n", drv_name);
    10098                free(drv_name);
    10199                drv_name = NULL;
    … …  
    108106       
    109107        /* Create connection to the driver. */
    110         log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.\n",
    111             driver->name);
     108        printf(NAME ":  creating connection to the %s driver.\n", driver->name);
    112109        ipc_call_t call;
    113110        ipc_callid_t callid = async_get_call(&call);
    … …  
    121118        set_driver_phone(driver, IPC_GET_ARG5(call));
    122119       
    123         log_msg(LVL_NOTE,
    124             "The `%s' driver was successfully registered as running.\n",
     120        printf(NAME ": the %s driver was successfully registered as running.\n",
    125121            driver->name);
    126122       
    … …  
    146142        callid = async_get_call(&call);
    147143        if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    148                 log_msg(LVL_ERROR,
    149                     "Invalid protocol when trying to receive match id.\n");
     144                printf(NAME ": ERROR: devman_receive_match_id - invalid "
     145                    "protocol.\n");
    150146                async_answer_0(callid, EINVAL);
    151147                delete_match_id(match_id);
    … …  
    154150       
    155151        if (match_id == NULL) {
    156                 log_msg(LVL_ERROR, "Failed to allocate match id.\n");
     152                printf(NAME ": ERROR: devman_receive_match_id - failed to "
     153                    "allocate match id.\n");
    157154                async_answer_0(callid, ENOMEM);
    158155                return ENOMEM;
    … …  
    168165        if (rc != EOK) {
    169166                delete_match_id(match_id);
    170                 log_msg(LVL_ERROR, "Failed to receive match id string: %s.\n",
    171                     str_error(rc));
     167                printf(NAME ": devman_receive_match_id - failed to receive "
     168                    "match id string.\n");
    172169                return rc;
    173170        }
    … …  
    175172        list_append(&match_id->link, &match_ids->ids);
    176173       
    177         log_msg(LVL_DEBUG, "Received match id `%s', score %d.\n",
     174        printf(NAME ": received match id '%s', score = %d \n",
    178175            match_id->id, match_id->score);
    179176        return rc;
    … …  
    231228        if (ftype != fun_inner && ftype != fun_exposed) {
    232229                /* Unknown function type */
    233                 log_msg(LVL_ERROR,
    234                     "Unknown function type %d provided by driver.\n",
    235                     (int) ftype);
     230                printf(NAME ": Error, unknown function type provided by driver!\n");
    236231
    237232                fibril_rwlock_write_unlock(&tree->rwlock);
    … …  
    280275        fibril_rwlock_write_unlock(&tree->rwlock);
    281276       
    282         log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")\n", fun->pathname);
     277        printf(NAME ": devman_add_function %s\n", fun->pathname);
    283278       
    284279        devman_receive_match_ids(match_count, &fun->match_ids);
    … …  
    362357        devmap_register_class_dev(class_info);
    363358       
    364         log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.\n",
    365             fun->pathname, class_name, class_info->dev_name);
     359        printf(NAME ": function'%s' added to class '%s', class name '%s' was "
     360            "asigned to it\n", fun->pathname, class_name, class_info->dev_name);
    366361
    367362        async_answer_0(callid, EOK);
    … …  
    378373       
    379374        initialize_running_driver(driver, &device_tree);
    380         log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.\n",
     375        printf(NAME ": the %s driver was successfully initialized. \n",
    381376            driver->name);
    382377        return 0;
    … …  
    400395        fid_t fid = fibril_create(init_running_drv, driver);
    401396        if (fid == 0) {
    402                 log_msg(LVL_ERROR, "Failed to create initialization fibril " \
    403                     "for driver `%s' .\n", driver->name);
     397                printf(NAME ": Error creating fibril for the initialization of "
     398                    "the newly registered running driver.\n");
    404399                return;
    405400        }
    … …  
    536531         */
    537532        if (dev == NULL) {
    538                 log_msg(LVL_ERROR, "IPC forwarding failed - no device or "
    539                     "function with handle %" PRIun " was found.\n", handle);
     533                printf(NAME ": devman_forward error - no device or function with "
     534                    "handle %" PRIun " was found.\n", handle);
    540535                async_answer_0(iid, ENOENT);
    541536                return;
    … …  
    543538
    544539        if (fun == NULL && !drv_to_parent) {
    545                 log_msg(LVL_ERROR, NAME ": devman_forward error - cannot "
    546                     "connect to handle %" PRIun ", refers to a device.\n",
    547                     handle);
     540                printf(NAME ": devman_forward error - cannot connect to "
     541                    "handle %" PRIun ", refers to a device.\n", handle);
    548542                async_answer_0(iid, ENOENT);
    549543                return;
    … …  
    566560       
    567561        if (driver == NULL) {
    568                 log_msg(LVL_ERROR, "IPC forwarding refused - " \
    569                     "the device %" PRIun " is not in usable state.\n", handle);
     562                printf(NAME ": devman_forward error - the device is not in %" PRIun
     563                    " usable state.\n", handle);
    570564                async_answer_0(iid, ENOENT);
    571565                return;
    … …  
    579573       
    580574        if (driver->phone <= 0) {
    581                 log_msg(LVL_ERROR,
    582                     "Could not forward to driver `%s' (phone is %d).\n",
    583                     driver->name, (int) driver->phone);
     575                printf(NAME ": devman_forward: cound not forward to driver %s ",
     576                    driver->name);
     577                printf("the driver's phone is %" PRIun ").\n", driver->phone);
    584578                async_answer_0(iid, EINVAL);
    585579                return;
    … …  
    587581
    588582        if (fun != NULL) {
    589                 log_msg(LVL_DEBUG,
    590                     "Forwarding request for `%s' function to driver `%s'.\n",
    591                     fun->pathname, driver->name);
     583                printf(NAME ": devman_forward: forward connection to function %s to "
     584                    "driver %s.\n", fun->pathname, driver->name);
    592585        } else {
    593                 log_msg(LVL_DEBUG,
    594                     "Forwarding request for `%s' device to driver `%s'.\n",
    595                     dev->pfun->pathname, driver->name);
     586                printf(NAME ": devman_forward: forward connection to device %s to "
     587                    "driver %s.\n", dev->pfun->pathname, driver->name);
    596588        }
    597589
    … …  
    625617        async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0,
    626618            IPC_FF_NONE);
    627         log_msg(LVL_DEBUG,
    628             "Forwarding devmapper request for `%s' function to driver `%s'.\n",
    629             fun->pathname, dev->drv->name);
     619        printf(NAME ": devman_connection_devmapper: forwarded connection to "
     620            "device %s to driver %s.\n", fun->pathname, dev->drv->name);
    630621}
    631622
    … …  
    662653static bool devman_init(void)
    663654{
    664         log_msg(LVL_DEBUG, "devman_init - looking for available drivers.\n");
     655        printf(NAME ": devman_init - looking for available drivers.\n");
    665656       
    666657        /* Initialize list of available drivers. */
    … …  
    668659        if (lookup_available_drivers(&drivers_list,
    669660            DRIVER_DEFAULT_STORE) == 0) {
    670                 log_msg(LVL_FATAL, "no drivers found.");
     661                printf(NAME " no drivers found.");
    671662                return false;
    672663        }
    673664
    674         log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.\n");
     665        printf(NAME ": devman_init - list of drivers has been initialized.\n");
    675666
    676667        /* Create root device node. */
    677668        if (!init_device_tree(&device_tree, &drivers_list)) {
    678                 log_msg(LVL_FATAL, "Failed to initialize device tree.");
     669                printf(NAME " failed to initialize device tree.");
    679670                return false;
    680671        }
    … …  
    697688        printf(NAME ": HelenOS Device Manager\n");
    698689
    699         if (log_init(NAME, LVL_ERROR) != EOK) {
    700                 printf(NAME ": Error initializing logging subsystem.\n");
    701                 return -1;
    702         }
    703 
    704690        if (!devman_init()) {
    705                 log_msg(LVL_ERROR, "Error while initializing service.\n");
     691                printf(NAME ": Error while initializing service\n");
    706692                return -1;
    707693        }
    … …  
    711697
    712698        /* Register device manager at naming service. */
    713         if (service_register(SERVICE_DEVMAN) != EOK) {
    714                 log_msg(LVL_ERROR, "Failed registering as a service.\n");
     699        if (service_register(SERVICE_DEVMAN) != EOK)
    715700                return -1;
    716         }
    717 
    718         printf(NAME ": Accepting connections.\n");
     701
     702        printf(NAME ": Accepting connections\n");
    719703        async_manager();
    720704
Note: See TracChangeset for help on using the changeset viewer.