Changes in / [73aec008:917a8c8] in mainline


Ignore:
Files:
4 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r73aec008 r917a8c8  
    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

  • uspace/app/init/init.c

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    3535#include <str_error.h>
    3636#include <ddf/driver.h>
    37 #include <ddf/log.h>
    3837
    3938#include "test1.h"
    … …  
    6463        int rc;
    6564
    66         ddf_msg(LVL_DEBUG, "Registering function `%s': %s.\n", name, message);
     65        printf(NAME ": registering function `%s': %s.\n", name, message);
    6766
    6867        fun = ddf_fun_create(parent, fun_inner, name);
    6968        if (fun == NULL) {
    70                 ddf_msg(LVL_ERROR, "Failed creating function %s\n", name);
     69                printf(NAME ": error creating function %s\n", name);
    7170                return ENOMEM;
    7271        }
    … …  
    7473        rc = ddf_fun_add_match_id(fun, match_id, match_score);
    7574        if (rc != EOK) {
    76                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s\n",
    77                     name);
     75                printf(NAME ": error adding match IDs to function %s\n", name);
    7876                ddf_fun_destroy(fun);
    7977                return rc;
    … …  
    8280        rc = ddf_fun_bind(fun);
    8381        if (rc != EOK) {
    84                 ddf_msg(LVL_ERROR, "Failed binding function %s: %s\n", name,
     82                printf(NAME ": error binding function %s: %s\n", name,
    8583                    str_error(rc));
    8684                ddf_fun_destroy(fun);
    … …  
    8886        }
    8987
    90         ddf_msg(LVL_NOTE, "Registered child device `%s'\n", name);
     88        printf(NAME ": registered child device `%s'\n", name);
    9189        return EOK;
    9290}
    … …  
    114112        int rc;
    115113
    116         ddf_msg(LVL_DEBUG, "add_device(name=\"%s\", handle=%d)\n",
     114        printf(NAME ": add_device(name=\"%s\", handle=%d)\n",
    117115            dev->name, (int) dev->handle);
    118116
    119117        fun_a = ddf_fun_create(dev, fun_exposed, "a");
    120118        if (fun_a == NULL) {
    121                 ddf_msg(LVL_ERROR, "Failed creating function 'a'.\n");
     119                printf(NAME ": error creating function 'a'.\n");
    122120                return ENOMEM;
    123121        }
    … …  
    125123        rc = ddf_fun_bind(fun_a);
    126124        if (rc != EOK) {
    127                 ddf_msg(LVL_ERROR, "Failed binding function 'a'.\n");
     125                printf(NAME ": error binding function 'a'.\n");
    128126                return rc;
    129127        }
    … …  
    142140        }
    143141
    144         ddf_msg(LVL_DEBUG, "Device `%s' accepted.\n", dev->name);
     142        printf(NAME ": device `%s' accepted.\n", dev->name);
    145143
    146144        return EOK;
    … …  
    150148{
    151149        printf(NAME ": HelenOS test1 virtual device driver\n");
    152         ddf_log_init(NAME, LVL_ERROR);
    153150        return ddf_driver_main(&test1_driver);
    154151}

  • uspace/drv/test2/test2.c

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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

    r73aec008 r917a8c8  
    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);
    … …  
    270265        fibril_rwlock_write_unlock(&tree->rwlock);
    271266       
    272         log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")\n", fun->pathname);
     267        printf(NAME ": devman_add_function %s\n", fun->pathname);
    273268       
    274269        devman_receive_match_ids(match_count, &fun->match_ids);
    … …  
    352347        devmap_register_class_dev(class_info);
    353348       
    354         log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.\n",
    355             fun->pathname, class_name, class_info->dev_name);
     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);
    356351
    357352        async_answer_0(callid, EOK);
    … …  
    368363       
    369364        initialize_running_driver(driver, &device_tree);
    370         log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.\n",
     365        printf(NAME ": the %s driver was successfully initialized. \n",
    371366            driver->name);
    372367        return 0;
    … …  
    390385        fid_t fid = fibril_create(init_running_drv, driver);
    391386        if (fid == 0) {
    392                 log_msg(LVL_ERROR, "Failed to create initialization fibril " \
    393                     "for driver `%s' .\n", driver->name);
     387                printf(NAME ": Error creating fibril for the initialization of "
     388                    "the newly registered running driver.\n");
    394389                return;
    395390        }
    … …  
    489484         */
    490485        if (dev == NULL) {
    491                 log_msg(LVL_ERROR, "IPC forwarding failed - no device or "
    492                     "function with handle %" PRIun " was found.\n", handle);
     486                printf(NAME ": devman_forward error - no device or function with "
     487                    "handle %" PRIun " was found.\n", handle);
    493488                async_answer_0(iid, ENOENT);
    494489                return;
    … …  
    496491
    497492        if (fun == NULL && !drv_to_parent) {
    498                 log_msg(LVL_ERROR, NAME ": devman_forward error - cannot "
    499                     "connect to handle %" PRIun ", refers to a device.\n",
    500                     handle);
     493                printf(NAME ": devman_forward error - cannot connect to "
     494                    "handle %" PRIun ", refers to a device.\n", handle);
    501495                async_answer_0(iid, ENOENT);
    502496                return;
    … …  
    519513       
    520514        if (driver == NULL) {
    521                 log_msg(LVL_ERROR, "IPC forwarding refused - " \
    522                     "the device %" PRIun " is not in usable state.\n", handle);
     515                printf(NAME ": devman_forward error - the device is not in %" PRIun
     516                    " usable state.\n", handle);
    523517                async_answer_0(iid, ENOENT);
    524518                return;
    … …  
    532526       
    533527        if (driver->phone <= 0) {
    534                 log_msg(LVL_ERROR,
    535                     "Could not forward to driver `%s' (phone is %d).\n",
    536                     driver->name, (int) driver->phone);
     528                printf(NAME ": devman_forward: cound not forward to driver %s ",
     529                    driver->name);
     530                printf("the driver's phone is %" PRIun ").\n", driver->phone);
    537531                async_answer_0(iid, EINVAL);
    538532                return;
    … …  
    540534
    541535        if (fun != NULL) {
    542                 log_msg(LVL_DEBUG,
    543                     "Forwarding request for `%s' function to driver `%s'.\n",
    544                     fun->pathname, driver->name);
     536                printf(NAME ": devman_forward: forward connection to function %s to "
     537                    "driver %s.\n", fun->pathname, driver->name);
    545538        } else {
    546                 log_msg(LVL_DEBUG,
    547                     "Forwarding request for `%s' device to driver `%s'.\n",
    548                     dev->pfun->pathname, driver->name);
     539                printf(NAME ": devman_forward: forward connection to device %s to "
     540                    "driver %s.\n", dev->pfun->pathname, driver->name);
    549541        }
    550542
    … …  
    578570        async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0,
    579571            IPC_FF_NONE);
    580         log_msg(LVL_DEBUG,
    581             "Forwarding devmapper request for `%s' function to driver `%s'.\n",
    582             fun->pathname, dev->drv->name);
     572        printf(NAME ": devman_connection_devmapper: forwarded connection to "
     573            "device %s to driver %s.\n", fun->pathname, dev->drv->name);
    583574}
    584575
    … …  
    615606static bool devman_init(void)
    616607{
    617         log_msg(LVL_DEBUG, "devman_init - looking for available drivers.\n");
     608        printf(NAME ": devman_init - looking for available drivers.\n");
    618609       
    619610        /* Initialize list of available drivers. */
    … …  
    621612        if (lookup_available_drivers(&drivers_list,
    622613            DRIVER_DEFAULT_STORE) == 0) {
    623                 log_msg(LVL_FATAL, "no drivers found.");
     614                printf(NAME " no drivers found.");
    624615                return false;
    625616        }
    626617
    627         log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.\n");
     618        printf(NAME ": devman_init - list of drivers has been initialized.\n");
    628619
    629620        /* Create root device node. */
    630621        if (!init_device_tree(&device_tree, &drivers_list)) {
    631                 log_msg(LVL_FATAL, "Failed to initialize device tree.");
     622                printf(NAME " failed to initialize device tree.");
    632623                return false;
    633624        }
    … …  
    650641        printf(NAME ": HelenOS Device Manager\n");
    651642
    652         if (log_init(NAME, LVL_ERROR) != EOK) {
    653                 printf(NAME ": Error initializing logging subsystem.\n");
    654                 return -1;
    655         }
    656 
    657643        if (!devman_init()) {
    658                 log_msg(LVL_ERROR, "Error while initializing service.\n");
     644                printf(NAME ": Error while initializing service\n");
    659645                return -1;
    660646        }
    … …  
    664650
    665651        /* Register device manager at naming service. */
    666         if (service_register(SERVICE_DEVMAN) != EOK) {
    667                 log_msg(LVL_ERROR, "Failed registering as a service.\n");
     652        if (service_register(SERVICE_DEVMAN) != EOK)
    668653                return -1;
    669         }
    670 
    671         printf(NAME ": Accepting connections.\n");
     654
     655        printf(NAME ": Accepting connections\n");
    672656        async_manager();
    673657
Note: See TracChangeset for help on using the changeset viewer.