Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -47,4 +47,5 @@ app/klog \ app/loc \ + app/logset \ app/mkfat \ app/mkexfat \ @@ -77,4 +78,5 @@ srv/clipboard \ srv/locsrv \ + srv/logger \ srv/devman \ srv/loader \ Index: uspace/app/logset/Makefile =================================================================== --- uspace/app/logset/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/app/logset/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,35 @@ +# +# Copyright (c) 2012 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +BINARY = logset + +SOURCES = \ + main.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/logset/main.c =================================================================== --- uspace/app/logset/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/app/logset/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup logset + * @{ + */ +/** @file Change logger behavior. + */ +#include +#include +#include +#include +#include + +static log_level_t parse_log_level_or_die(const char *log_level) +{ + log_level_t result; + int rc = log_level_from_str(log_level, &result); + if (rc != EOK) { + fprintf(stderr, "Unrecognised log level '%s': %s.\n", + log_level, str_error(rc)); + exit(2); + } + return result; +} + +static void usage(const char *progname) +{ + fprintf(stderr, "Usage:\n"); + fprintf(stderr, " %s \n", progname); + fprintf(stderr, " %s \n", progname); +} + +int main(int argc, char *argv[]) +{ + if (argc == 2) { + log_level_t new_default_level = parse_log_level_or_die(argv[1]); + int rc = logctl_set_default_level(new_default_level); + + if (rc != EOK) { + fprintf(stderr, "Failed to change default logging level: %s.\n", + str_error(rc)); + return 2; + } + } else if (argc == 3) { + log_level_t new_level = parse_log_level_or_die(argv[2]); + const char *logname = argv[1]; + int rc = logctl_set_log_level(logname, new_level); + + if (rc != EOK) { + fprintf(stderr, "Failed to change logging level: %s.\n", + str_error(rc)); + return 2; + } + } else { + usage(argv[0]); + return 1; + } + + return 0; +} + +/** @} + */ Index: uspace/app/tester/Makefile =================================================================== --- uspace/app/tester/Makefile (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/app/tester/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -45,4 +45,6 @@ stdio/stdio1.c \ stdio/stdio2.c \ + stdio/logger1.c \ + stdio/logger2.c \ fault/fault1.c \ fault/fault2.c \ Index: uspace/app/tester/stdio/logger1.c =================================================================== --- uspace/app/tester/stdio/logger1.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/app/tester/stdio/logger1.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include "../tester.h" + +const char *test_logger1(void) +{ + for (log_level_t level = 0; level < LVL_LIMIT; level++) { + log_msg(LOG_DEFAULT, level, "Testing logger, level %d.", (int) level); + } + + return NULL; +} Index: uspace/app/tester/stdio/logger1.def =================================================================== --- uspace/app/tester/stdio/logger1.def (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/app/tester/stdio/logger1.def (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,6 @@ +{ + "logger1", + "Logger printing test", + &test_logger1, + true +}, Index: uspace/app/tester/stdio/logger2.c =================================================================== --- uspace/app/tester/stdio/logger2.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/app/tester/stdio/logger2.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include "../tester.h" + +const char *test_logger2(void) +{ + log_t log_alpha = log_create("alpha", LOG_DEFAULT); + log_t log_bravo = log_create("bravo", log_alpha); + + TPRINTF("Alpha is %" PRIlogctx ".\n", log_alpha); + TPRINTF("Bravo is %" PRIlogctx ".\n", log_bravo); + + while (true) { + /* + * Intentionally skipping FATAL to allow muting + * the output completely by setting visible level to FATAL. + */ + for (log_level_t level = LVL_ERROR; level < LVL_LIMIT; level++) { + log_msg(LOG_DEFAULT, level, "Printing level %d (%s).", + (int) level, log_level_str(level)); + log_msg(log_alpha, level, + "Printing level %d (%s) into alpha log.", + (int) level, log_level_str(level)); + log_msg(log_bravo, level, + "Printing level %d (%s) into bravo sub-log.", + (int) level, log_level_str(level)); + async_usleep(1000 * 100); + } + } + + return NULL; +} Index: uspace/app/tester/stdio/logger2.def =================================================================== --- uspace/app/tester/stdio/logger2.def (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/app/tester/stdio/logger2.def (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,6 @@ +{ + "logger2", + "Logger endless test", + &test_logger2, + false +}, Index: uspace/app/tester/tester.c =================================================================== --- uspace/app/tester/tester.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/app/tester/tester.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -39,4 +39,5 @@ #include #include +#include #include "tester.h" @@ -55,4 +56,6 @@ #include "stdio/stdio1.def" #include "stdio/stdio2.def" +#include "stdio/logger1.def" +#include "stdio/logger2.def" #include "fault/fault1.def" #include "fault/fault2.def" @@ -140,4 +143,6 @@ } + log_init("tester"); + test_quiet = false; test_argc = argc - 2; Index: uspace/app/tester/tester.h =================================================================== --- uspace/app/tester/tester.h (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/app/tester/tester.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -88,4 +88,6 @@ extern const char *test_stdio1(void); extern const char *test_stdio2(void); +extern const char *test_logger1(void); +extern const char *test_logger2(void); extern const char *test_fault1(void); extern const char *test_fault2(void); Index: uspace/app/vuhid/main.c =================================================================== --- uspace/app/vuhid/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/app/vuhid/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -155,5 +155,5 @@ int rc; - usb_log_enable(USB_LOG_LEVEL_DEBUG2, "vusbhid"); + log_init("vuhid"); fibril_mutex_initialize(&vuhid_data.iface_count_mutex); Index: uspace/drv/block/ahci/ahci.c =================================================================== --- uspace/drv/block/ahci/ahci.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/block/ahci/ahci.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -1340,5 +1340,5 @@ { printf("%s: HelenOS AHCI device driver\n", NAME); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); fibril_mutex_initialize(&sata_devices_count_lock); return ddf_driver_main(&ahci_driver); Index: uspace/drv/bus/isa/isa.c =================================================================== --- uspace/drv/bus/isa/isa.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/isa/isa.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -712,5 +712,5 @@ static void isa_init() { - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops; } Index: uspace/drv/bus/pci/pciintel/pci.c =================================================================== --- uspace/drv/bus/pci/pciintel/pci.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/pci/pciintel/pci.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -729,5 +729,5 @@ static void pciintel_init(void) { - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops; pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops; Index: uspace/drv/bus/usb/ehci/main.c =================================================================== --- uspace/drv/bus/usb/ehci/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/ehci/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -132,5 +132,5 @@ int main(int argc, char *argv[]) { - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return ddf_driver_main(&ehci_driver); } Index: uspace/drv/bus/usb/ohci/main.c =================================================================== --- uspace/drv/bus/usb/ohci/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/ohci/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -83,5 +83,5 @@ int main(int argc, char *argv[]) { - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return ddf_driver_main(&ohci_driver); } Index: uspace/drv/bus/usb/uhci/main.c =================================================================== --- uspace/drv/bus/usb/uhci/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/uhci/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -87,5 +87,5 @@ { printf(NAME ": HelenOS UHCI driver.\n"); - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return ddf_driver_main(&uhci_driver); Index: uspace/drv/bus/usb/uhcirh/main.c =================================================================== --- uspace/drv/bus/usb/uhcirh/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/uhcirh/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -73,5 +73,5 @@ { printf(NAME ": HelenOS UHCI root hub driver.\n"); - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return ddf_driver_main(&uhci_rh_driver); } Index: uspace/drv/bus/usb/usbflbk/main.c =================================================================== --- uspace/drv/bus/usb/usbflbk/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/usbflbk/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -110,5 +110,5 @@ int main(int argc, char *argv[]) { - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return usb_driver_main(&usbfallback_driver); Index: uspace/drv/bus/usb/usbhid/main.c =================================================================== --- uspace/drv/bus/usb/usbhid/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/usbhid/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -172,5 +172,5 @@ printf(NAME ": HelenOS USB HID driver.\n"); - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return usb_driver_main(&usb_hid_driver); Index: uspace/drv/bus/usb/usbhub/main.c =================================================================== --- uspace/drv/bus/usb/usbhub/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/usbhub/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -79,5 +79,5 @@ { printf(NAME ": HelenOS USB hub driver.\n"); - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return usb_driver_main(&usb_hub_driver); Index: uspace/drv/bus/usb/usbmast/main.c =================================================================== --- uspace/drv/bus/usb/usbmast/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/usbmast/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -383,5 +383,5 @@ int main(int argc, char *argv[]) { - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return usb_driver_main(&usbmast_driver); Index: uspace/drv/bus/usb/usbmid/main.c =================================================================== --- uspace/drv/bus/usb/usbmid/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/usbmid/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -180,5 +180,5 @@ printf(NAME ": USB multi interface device driver.\n"); - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); return usb_driver_main(&mid_driver); Index: uspace/drv/bus/usb/vhc/Makefile =================================================================== --- uspace/drv/bus/usb/vhc/Makefile (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/vhc/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -32,6 +32,6 @@ $(LIBUSBDEV_PREFIX)/libusbdev.a \ $(LIBUSBHOST_PREFIX)/libusbhost.a \ + $(LIBUSBVIRT_PREFIX)/libusbvirt.a \ $(LIBUSB_PREFIX)/libusb.a \ - $(LIBUSBVIRT_PREFIX)/libusbvirt.a \ $(LIBDRV_PREFIX)/libdrv.a Index: uspace/drv/bus/usb/vhc/main.c =================================================================== --- uspace/drv/bus/usb/vhc/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/bus/usb/vhc/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -138,5 +138,5 @@ int main(int argc, char * argv[]) { - usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME); + log_init(NAME); printf(NAME ": virtual USB host controller driver.\n"); Index: uspace/drv/char/i8042/i8042.c =================================================================== --- uspace/drv/char/i8042/i8042.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/char/i8042/i8042.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -302,5 +302,5 @@ const bool enabled = hw_res_enable_interrupt(parent_sess); if (!enabled) { - log_msg(LVL_ERROR, "Failed to enable interrupts: %s.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to enable interrupts: %s.", ddf_dev_get_name(ddf_dev)); rc = EIO; Index: uspace/drv/char/i8042/main.c =================================================================== --- uspace/drv/char/i8042/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/char/i8042/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -151,5 +151,5 @@ { printf("%s: HelenOS PS/2 driver.\n", NAME); - ddf_log_init(NAME, LVL_NOTE); + ddf_log_init(NAME); return ddf_driver_main(&i8042_driver); } Index: uspace/drv/char/ns8250/ns8250.c =================================================================== --- uspace/drv/char/ns8250/ns8250.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/char/ns8250/ns8250.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -1084,5 +1084,5 @@ static void ns8250_init(void) { - ddf_log_init(NAME, LVL_WARN); + ddf_log_init(NAME); ns8250_dev_ops.open = &ns8250_open; Index: uspace/drv/char/ps2mouse/main.c =================================================================== --- uspace/drv/char/ps2mouse/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/char/ps2mouse/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -69,5 +69,5 @@ { printf(NAME ": HelenOS ps/2 mouse driver.\n"); - ddf_log_init(NAME, LVL_NOTE); + ddf_log_init(NAME); return ddf_driver_main(&mouse_driver); } Index: uspace/drv/char/xtkbd/main.c =================================================================== --- uspace/drv/char/xtkbd/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/char/xtkbd/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -69,5 +69,5 @@ { printf(NAME ": HelenOS XT keyboard driver.\n"); - ddf_log_init(NAME, LVL_NOTE); + ddf_log_init(NAME); return ddf_driver_main(&kbd_driver); } Index: uspace/drv/infrastructure/root/root.c =================================================================== --- uspace/drv/infrastructure/root/root.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/infrastructure/root/root.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -237,5 +237,5 @@ printf(NAME ": HelenOS root device driver\n"); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); return ddf_driver_main(&root_driver); } Index: uspace/drv/infrastructure/rootmac/rootmac.c =================================================================== --- uspace/drv/infrastructure/rootmac/rootmac.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/infrastructure/rootmac/rootmac.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -179,5 +179,5 @@ { printf("%s: HelenOS Mac platform driver\n", NAME); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); rootmac_fun_ops.interfaces[HW_RES_DEV_IFACE] = &fun_hw_res_ops; return ddf_driver_main(&rootmac_driver); Index: uspace/drv/infrastructure/rootpc/rootpc.c =================================================================== --- uspace/drv/infrastructure/rootpc/rootpc.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/infrastructure/rootpc/rootpc.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -195,5 +195,5 @@ static void root_pc_init(void) { - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); rootpc_fun_ops.interfaces[HW_RES_DEV_IFACE] = &fun_hw_res_ops; } Index: uspace/drv/infrastructure/rootvirt/rootvirt.c =================================================================== --- uspace/drv/infrastructure/rootvirt/rootvirt.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/infrastructure/rootvirt/rootvirt.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -240,5 +240,5 @@ printf(NAME ": HelenOS virtual devices root driver\n"); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); return ddf_driver_main(&rootvirt_driver); } Index: uspace/drv/nic/e1k/e1k.c =================================================================== --- uspace/drv/nic/e1k/e1k.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/nic/e1k/e1k.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -2381,5 +2381,5 @@ &e1000_nic_iface); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); ddf_msg(LVL_NOTE, "HelenOS E1000 driver started"); return ddf_driver_main(&e1000_driver); Index: uspace/drv/nic/rtl8139/driver.c =================================================================== --- uspace/drv/nic/rtl8139/driver.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/nic/rtl8139/driver.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -2187,5 +2187,5 @@ &rtl8139_driver_ops, &rtl8139_dev_ops, &rtl8139_nic_iface); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); ddf_msg(LVL_NOTE, "HelenOS RTL8139 driver started"); return ddf_driver_main(&rtl8139_driver); Index: uspace/drv/test/test1/test1.c =================================================================== --- uspace/drv/test/test1/test1.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/test/test1/test1.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -306,5 +306,5 @@ { printf(NAME ": HelenOS test1 virtual device driver\n"); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); return ddf_driver_main(&test1_driver); } Index: uspace/drv/test/test2/test2.c =================================================================== --- uspace/drv/test/test2/test2.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/test/test2/test2.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -308,5 +308,5 @@ { printf(NAME ": HelenOS test2 virtual device driver\n"); - ddf_log_init(NAME, LVL_NOTE); + ddf_log_init(NAME); return ddf_driver_main(&test2_driver); } Index: uspace/drv/test/test3/test3.c =================================================================== --- uspace/drv/test/test3/test3.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/drv/test/test3/test3.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -193,5 +193,5 @@ { printf(NAME ": HelenOS test3 virtual device driver\n"); - ddf_log_init(NAME, LVL_ERROR); + ddf_log_init(NAME); return ddf_driver_main(&test3_driver); } Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/c/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -101,4 +101,5 @@ generic/io/printf.c \ generic/io/log.c \ + generic/io/logctl.c \ generic/io/klog.c \ generic/io/snprintf.c \ Index: uspace/lib/c/generic/io/log.c =================================================================== --- uspace/lib/c/generic/io/log.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/c/generic/io/log.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -38,58 +38,190 @@ #include #include - +#include #include - -/** Serialization mutex for logging functions. */ -static FIBRIL_MUTEX_INITIALIZE(log_serializer); - -/** Current log level. */ -static log_level_t log_level; - -static FILE *log_stream; - +#include +#include + +/** Id of the first log we create at logger. */ +static sysarg_t default_log_id; + +/** Log messages are printed under this name. */ static const char *log_prog_name; -/** Prefixes for individual logging levels. */ +/** Names of individual log levels. */ static const char *log_level_names[] = { - [LVL_FATAL] = "Fatal error", - [LVL_ERROR] = "Error", - [LVL_WARN] = "Warning", - [LVL_NOTE] = "Note", - [LVL_DEBUG] = "Debug", - [LVL_DEBUG2] = "Debug2" + "fatal", + "error", + "warn", + "note", + "debug", + "debug2", + NULL }; +/** IPC session with the logger service. */ +static async_sess_t *logger_session; + +/** Maximum length of a single log message (in bytes). */ +#define MESSAGE_BUFFER_SIZE 4096 + +/** Send formatted message to the logger service. + * + * @param session Initialized IPC session with the logger. + * @param log Log to use. + * @param level Verbosity level of the message. + * @param message The actual message. + * @return Error code of the conversion or EOK on success. + */ +static int logger_message(async_sess_t *session, log_t log, log_level_t level, char *message) +{ + async_exch_t *exchange = async_exchange_begin(session); + if (exchange == NULL) { + return ENOMEM; + } + if (log == LOG_DEFAULT) + log = default_log_id; + + // FIXME: remove when all USB drivers use libc logging explicitly + str_rtrim(message, '\n'); + + aid_t reg_msg = async_send_2(exchange, LOGGER_WRITER_MESSAGE, + log, level, NULL); + int rc = async_data_write_start(exchange, message, str_size(message)); + sysarg_t reg_msg_rc; + async_wait_for(reg_msg, ®_msg_rc); + + async_exchange_end(exchange); + + /* + * Getting ENAK means no-one wants our message. That is not an + * error at all. + */ + if (rc == ENAK) + rc = EOK; + + if (rc != EOK) { + return rc; + } + + return reg_msg_rc; +} + +/** Get name of the log level. + * + * @param level The log level. + * @return String name or "unknown". + */ +const char *log_level_str(log_level_t level) +{ + if (level >= LVL_LIMIT) + return "unknown"; + else + return log_level_names[level]; +} + +/** Convert log level name to the enum. + * + * @param[in] name Log level name or log level number. + * @param[out] level_out Where to store the result (set to NULL to ignore). + * @return Error code of the conversion or EOK on success. + */ +int log_level_from_str(const char *name, log_level_t *level_out) +{ + log_level_t level = LVL_FATAL; + + while (log_level_names[level] != NULL) { + if (str_cmp(name, log_level_names[level]) == 0) { + if (level_out != NULL) + *level_out = level; + return EOK; + } + level++; + } + + /* Maybe user specified number directly. */ + char *end_ptr; + int level_int = strtol(name, &end_ptr, 0); + if ((end_ptr == name) || (str_length(end_ptr) != 0)) + return EINVAL; + if (level_int < 0) + return ERANGE; + if (level_int >= (int) LVL_LIMIT) + return ERANGE; + + if (level_out != NULL) + *level_out = (log_level_t) level_int; + + return EOK; +} + /** Initialize the logging system. * - * @param prog_name Program name, will be printed as part of message - * @param level Minimum message level to print - */ -int log_init(const char *prog_name, log_level_t level) -{ - assert(level < LVL_LIMIT); - log_level = level; - - log_stream = stdout; + * @param prog_name Program name, will be printed as part of message + */ +int log_init(const char *prog_name) +{ log_prog_name = str_dup(prog_name); if (log_prog_name == NULL) return ENOMEM; + logger_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_WRITER, 0); + if (logger_session == NULL) { + return ENOMEM; + } + + default_log_id = log_create(prog_name, LOG_NO_PARENT); + return EOK; } +/** Create a new (sub-) log. + * + * This function always returns a valid log_t. In case of errors, + * @c parent is returned and errors are silently ignored. + * + * @param name Log name under which message will be reported (appended to parents name). + * @param parent Parent log. + * @return Opaque identifier of the newly created log. + */ +log_t log_create(const char *name, log_t parent) +{ + async_exch_t *exchange = async_exchange_begin(logger_session); + if (exchange == NULL) + return parent; + + if (parent == LOG_DEFAULT) + parent = default_log_id; + + ipc_call_t answer; + aid_t reg_msg = async_send_1(exchange, LOGGER_WRITER_CREATE_LOG, + parent, &answer); + int rc = async_data_write_start(exchange, name, str_size(name)); + sysarg_t reg_msg_rc; + async_wait_for(reg_msg, ®_msg_rc); + + async_exchange_end(exchange); + + if ((rc != EOK) || (reg_msg_rc != EOK)) + return parent; + + return IPC_GET_ARG1(answer); +} + /** Write an entry to the log. * - * @param level Message verbosity level. Message is only printed - * if verbosity is less than or equal to current - * reporting level. - * @param fmt Format string (no traling newline). - */ -void log_msg(log_level_t level, const char *fmt, ...) + * The message is printed only if the verbosity level is less than or + * equal to currently set reporting level of the log. + * + * @param ctx Log to use (use LOG_DEFAULT if you have no idea what it means). + * @param level Severity level of the message. + * @param fmt Format string in printf-like format (without trailing newline). + */ +void log_msg(log_t ctx, log_level_t level, const char *fmt, ...) { va_list args; va_start(args, fmt); - log_msgv(level, fmt, args); + log_msgv(ctx, level, fmt, args); va_end(args); } @@ -97,25 +229,20 @@ /** Write an entry to the log (va_list variant). * - * @param level Message verbosity level. Message is only printed - * if verbosity is less than or equal to current - * reporting level. - * @param fmt Format string (no trailing newline) - */ -void log_msgv(log_level_t level, const char *fmt, va_list args) + * @param ctx Log to use (use LOG_DEFAULT if you have no idea what it means). + * @param level Severity level of the message. + * @param fmt Format string in printf-like format (without trailing newline). + * @param args Arguments. + */ +void log_msgv(log_t ctx, log_level_t level, const char *fmt, va_list args) { assert(level < LVL_LIMIT); - /* Higher number means higher verbosity. */ - if (level <= log_level) { - fibril_mutex_lock(&log_serializer); - - fprintf(log_stream, "%s: %s: ", log_prog_name, - log_level_names[level]); - vfprintf(log_stream, fmt, args); - fputc('\n', log_stream); - fflush(log_stream); - - fibril_mutex_unlock(&log_serializer); - } + char *message_buffer = malloc(MESSAGE_BUFFER_SIZE); + if (message_buffer == NULL) { + return; + } + + vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args); + logger_message(logger_session, ctx, level, message_buffer); } Index: uspace/lib/c/generic/io/logctl.c =================================================================== --- uspace/lib/c/generic/io/logctl.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/lib/c/generic/io/logctl.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/** IPC session with the logger service. */ +static async_sess_t *logger_session = NULL; + +static int start_logger_exchange(async_exch_t **exchange_out) +{ + assert(exchange_out != NULL); + + if (logger_session == NULL) { + logger_session = service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_LOGGER, LOGGER_INTERFACE_CONTROL, 0); + if (logger_session == NULL) + return ENOMEM; + } + + assert(logger_session != NULL); + + async_exch_t *exchange = async_exchange_begin(logger_session); + if (exchange == NULL) + return ENOMEM; + + *exchange_out = exchange; + + return EOK; +} + +/** Set default reported log level (global setting). + * + * This setting affects all logger clients whose reporting level was + * not yet changed. + * + * If logging level of client A is changed with logctl_set_log_level() + * to some level, this call will have no effect at that client's reporting + * level. Even if the actual value of the reporting level of client A is + * the same as current (previous) default log level. + * + * @param new_level New reported logging level. + * @return Error code of the conversion or EOK on success. + */ +int logctl_set_default_level(log_level_t new_level) +{ + async_exch_t *exchange = NULL; + int rc = start_logger_exchange(&exchange); + if (rc != EOK) + return rc; + + rc = (int) async_req_1_0(exchange, + LOGGER_CONTROL_SET_DEFAULT_LEVEL, new_level); + + async_exchange_end(exchange); + + return rc; +} + +/** Set reported log level of a single log. + * + * @see logctl_set_default_level + * + * @param logname Log name. + * @param new_level New reported logging level. + * @return Error code of the conversion or EOK on success. + */ +int logctl_set_log_level(const char *logname, log_level_t new_level) +{ + async_exch_t *exchange = NULL; + int rc = start_logger_exchange(&exchange); + if (rc != EOK) + return rc; + + aid_t reg_msg = async_send_1(exchange, LOGGER_CONTROL_SET_LOG_LEVEL, + new_level, NULL); + rc = async_data_write_start(exchange, logname, str_size(logname)); + sysarg_t reg_msg_rc; + async_wait_for(reg_msg, ®_msg_rc); + + async_exchange_end(exchange); + + if (rc != EOK) + return rc; + + return (int) reg_msg_rc; +} + +/** @} + */ Index: uspace/lib/c/include/io/log.h =================================================================== --- uspace/lib/c/include/io/log.h (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/c/include/io/log.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -36,12 +36,20 @@ #include +#include #include +/** Log message level. */ typedef enum { + /** Fatal error, program is not able to recover at all. */ LVL_FATAL, + /** Serious error but the program can recover from it. */ LVL_ERROR, + /** Easily recoverable problem. */ LVL_WARN, + /** Information message that ought to be printed by default. */ LVL_NOTE, + /** Debugging purpose message. */ LVL_DEBUG, + /** More detailed debugging message. */ LVL_DEBUG2, @@ -50,8 +58,24 @@ } log_level_t; -extern int log_init(const char *, log_level_t); -extern void log_msg(log_level_t, const char *, ...) - PRINTF_ATTRIBUTE(2, 3); -extern void log_msgv(log_level_t, const char *, va_list); +/** Log itself (logging target). */ +typedef sysarg_t log_t; +/** Formatting directive for printing log_t. */ +#define PRIlogctx PRIxn + +/** Default log (target). */ +#define LOG_DEFAULT ((log_t) -1) + +/** Use when creating new top-level log. */ +#define LOG_NO_PARENT ((log_t) 0) + +extern const char *log_level_str(log_level_t); +extern int log_level_from_str(const char *, log_level_t *); + +extern int log_init(const char *); +extern log_t log_create(const char *, log_t); + +extern void log_msg(log_t, log_level_t, const char *, ...) + PRINTF_ATTRIBUTE(3, 4); +extern void log_msgv(log_t, log_level_t, const char *, va_list); #endif Index: uspace/lib/c/include/io/logctl.h =================================================================== --- uspace/lib/c/include/io/logctl.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/lib/c/include/io/logctl.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2011-2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ + +#ifndef LIBC_IO_LOGCTL_H_ +#define LIBC_IO_LOGCTL_H_ + +#include + +extern int logctl_set_default_level(log_level_t); +extern int logctl_set_log_level(const char *, log_level_t); + +#endif + +/** @} + */ Index: uspace/lib/c/include/ipc/logger.h =================================================================== --- uspace/lib/c/include/ipc/logger.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/lib/c/include/ipc/logger.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ + +#ifndef LIBC_IPC_LOGGER_H_ +#define LIBC_IPC_LOGGER_H_ + +#include + +typedef enum { + /** Set (global) default displayed logging level. + * + * Arguments: new log level. + * Returns: error code + */ + LOGGER_CONTROL_SET_DEFAULT_LEVEL = IPC_FIRST_USER_METHOD, + /** Set displayed level for given log. + * + * Arguments: new log level. + * Returns: error code + * Followed by: string with full log name. + */ + LOGGER_CONTROL_SET_LOG_LEVEL +} logger_control_request_t; + +typedef enum { + /** Create new log. + * + * Arguments: parent log id (0 for top-level log). + * Returns: error code, log id + * Followed by: string with log name. + */ + LOGGER_WRITER_CREATE_LOG = IPC_FIRST_USER_METHOD, + /** Write a message to a given log. + * + * Arguments: log id, message severity level (log_level_t) + * Returns: error code + * Followed by: string with the message. + */ + LOGGER_WRITER_MESSAGE +} logger_writer_request_t; + +typedef enum { + /** Interface for controlling logger behavior. */ + LOGGER_INTERFACE_CONTROL, + /** Interface for servers writing to the log. */ + LOGGER_INTERFACE_WRITER +} logger_interface_t; + +#endif + +/** @} + */ Index: uspace/lib/c/include/ipc/services.h =================================================================== --- uspace/lib/c/include/ipc/services.h (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/c/include/ipc/services.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -45,4 +45,5 @@ SERVICE_VFS = FOURCC('v', 'f', 's', ' '), SERVICE_LOC = FOURCC('l', 'o', 'c', ' '), + SERVICE_LOGGER = FOURCC('l', 'o', 'g', 'g'), SERVICE_DEVMAN = FOURCC('d', 'e', 'v', 'n'), SERVICE_IRC = FOURCC('i', 'r', 'c', ' '), Index: uspace/lib/drv/generic/log.c =================================================================== --- uspace/lib/drv/generic/log.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/drv/generic/log.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -38,10 +38,9 @@ * * @param drv_name Driver name, will be printed as part of message - * @param level Minimum message level to print * */ -int ddf_log_init(const char *drv_name, log_level_t level) +int ddf_log_init(const char *drv_name) { - return log_init(drv_name, level); + return log_init(drv_name); } @@ -59,5 +58,5 @@ va_start(args, fmt); - log_msgv(level, fmt, args); + log_msgv(LOG_DEFAULT, level, fmt, args); va_end(args); } Index: uspace/lib/drv/include/ddf/log.h =================================================================== --- uspace/lib/drv/include/ddf/log.h (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/drv/include/ddf/log.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -37,5 +37,5 @@ #include -extern int ddf_log_init(const char *, log_level_t); +extern int ddf_log_init(const char *); extern void ddf_msg(log_level_t, const char *, ...) PRINTF_ATTRIBUTE(2, 3); Index: uspace/lib/usb/include/usb/debug.h =================================================================== --- uspace/lib/usb/include/usb/debug.h (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/usb/include/usb/debug.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -38,4 +38,5 @@ #include #include +#include #include @@ -43,52 +44,13 @@ const uint8_t *, size_t); -/** Logging level. */ -typedef enum { - /** Fatal, unrecoverable, error. - * Such error prevents the driver from working at all. - */ - USB_LOG_LEVEL_FATAL, +#define USB_LOG_LEVEL_FATAL LVL_FATAL +#define USB_LOG_LEVEL_ERROR LVL_ERROR +#define USB_LOG_LEVEL_WARNING LVL_WARN +#define USB_LOG_LEVEL_INFO LVL_NOTE +#define USB_LOG_LEVEL_DEBUG LVL_DEBUG +#define USB_LOG_LEVEL_DEBUG2 LVL_DEBUG2 - /** Serious but recoverable error - * Shall be used for errors fatal for single device but not for - * driver itself. - */ - USB_LOG_LEVEL_ERROR, - - /** Warning. - * Problems from which the driver is able to recover gracefully. - */ - USB_LOG_LEVEL_WARNING, - - /** Information message. - * This should be the last level that is printed by default to - * the screen. - * Typical usage is to inform that new device was found and what - * are its capabilities. - * Do not use for repetitive actions (such as device polling). - */ - USB_LOG_LEVEL_INFO, - - /** Debugging message. */ - USB_LOG_LEVEL_DEBUG, - - /** More detailed debugging message. */ - USB_LOG_LEVEL_DEBUG2, - - /** Terminating constant for logging levels. */ - USB_LOG_LEVEL_MAX -} usb_log_level_t; - -/** Default log level. */ -#ifdef CONFIG_USB_VERBOSE - #define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG -#else - #define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_INFO -#endif - -void usb_log_enable(usb_log_level_t, const char *); - -void usb_log_printf(usb_log_level_t, const char *, ...) - PRINTF_ATTRIBUTE(2, 3); +#define usb_log_printf(level, format, ...) \ + log_msg(LOG_DEFAULT, level, format, ##__VA_ARGS__) /** Log fatal error. */ Index: uspace/lib/usb/src/debug.c =================================================================== --- uspace/lib/usb/src/debug.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/lib/usb/src/debug.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -40,115 +40,4 @@ #include #include - -/** Level of logging messages. */ -static usb_log_level_t log_level = USB_LOG_LEVEL_WARNING; - -/** Prefix for logging messages. */ -static const char *log_prefix = "usb"; - -/** Serialization mutex for logging functions. */ -static FIBRIL_MUTEX_INITIALIZE(log_serializer); - -/** File where to store the log. */ -static FILE *log_stream = NULL; - - -/** Enable logging. - * - * @param level Maximal enabled level (including this one). - * @param message_prefix Prefix for each printed message. - */ -void usb_log_enable(usb_log_level_t level, const char *message_prefix) -{ - log_prefix = message_prefix; - log_level = level; - if (log_stream == NULL) { - char *fname; - int rc = asprintf(&fname, "/log/%s", message_prefix); - if (rc > 0) { - log_stream = fopen(fname, "w"); - if (log_stream != NULL) - setvbuf(log_stream, NULL, _IOFBF, BUFSIZ); - - free(fname); - } - } -} - -/** Get log level name prefix. - * - * @param level Log level. - * @return String prefix for the message. - */ -static const char *log_level_name(usb_log_level_t level) -{ - switch (level) { - case USB_LOG_LEVEL_FATAL: - return " FATAL"; - case USB_LOG_LEVEL_ERROR: - return " ERROR"; - case USB_LOG_LEVEL_WARNING: - return " WARN"; - case USB_LOG_LEVEL_INFO: - return " info"; - default: - return ""; - } -} - -/** Print logging message. - * - * @param level Verbosity level of the message. - * @param format Formatting directive. - */ -void usb_log_printf(usb_log_level_t level, const char *format, ...) -{ - FILE *screen_stream = NULL; - switch (level) { - case USB_LOG_LEVEL_FATAL: - case USB_LOG_LEVEL_ERROR: - screen_stream = stderr; - break; - default: - screen_stream = stdout; - break; - } - assert(screen_stream != NULL); - - va_list args; - - /* - * Serialize access to log files. - * Print to screen only messages with higher level than the one - * specified during logging initialization. - * Print also to file, to it print one more (lower) level as well. - */ - fibril_mutex_lock(&log_serializer); - - const char *level_name = log_level_name(level); - - if ((log_stream != NULL) && (level <= log_level + 1)) { - va_start(args, format); - - fprintf(log_stream, "[%s]%s: ", log_prefix, level_name); - vfprintf(log_stream, format, args); - fflush(log_stream); - - va_end(args); - } - - if (level <= log_level) { - va_start(args, format); - - fprintf(screen_stream, "[%s]%s: ", log_prefix, level_name); - vfprintf(screen_stream, format, args); - fflush(screen_stream); - - va_end(args); - } - - fibril_mutex_unlock(&log_serializer); -} - #define REMAINDER_STR_FMT " (%zu)..." Index: uspace/srv/devman/devman.c =================================================================== --- uspace/srv/devman/devman.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/devman/devman.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -151,5 +151,5 @@ fibril_mutex_unlock(&drivers_list->drivers_mutex); - log_msg(LVL_NOTE, "Driver `%s' was added to the list of available " + log_msg(LOG_DEFAULT, LVL_NOTE, "Driver `%s' was added to the list of available " "drivers.", drv->name); } @@ -242,5 +242,5 @@ bool read_match_ids(const char *conf_path, match_id_list_t *ids) { - log_msg(LVL_DEBUG, "read_match_ids(conf_path=\"%s\")", conf_path); + log_msg(LOG_DEFAULT, LVL_DEBUG, "read_match_ids(conf_path=\"%s\")", conf_path); bool suc = false; @@ -252,5 +252,5 @@ fd = open(conf_path, O_RDONLY); if (fd < 0) { - log_msg(LVL_ERROR, "Unable to open `%s' for reading: %s.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Unable to open `%s' for reading: %s.", conf_path, str_error(fd)); goto cleanup; @@ -261,5 +261,5 @@ lseek(fd, 0, SEEK_SET); if (len == 0) { - log_msg(LVL_ERROR, "Configuration file '%s' is empty.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Configuration file '%s' is empty.", conf_path); goto cleanup; @@ -268,5 +268,5 @@ buf = malloc(len + 1); if (buf == NULL) { - log_msg(LVL_ERROR, "Memory allocation failed when parsing file " + log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed when parsing file " "'%s'.", conf_path); goto cleanup; @@ -275,5 +275,5 @@ ssize_t read_bytes = read_all(fd, buf, len); if (read_bytes <= 0) { - log_msg(LVL_ERROR, "Unable to read file '%s' (%zd).", conf_path, + log_msg(LOG_DEFAULT, LVL_ERROR, "Unable to read file '%s' (%zd).", conf_path, read_bytes); goto cleanup; @@ -314,5 +314,5 @@ bool get_driver_info(const char *base_path, const char *name, driver_t *drv) { - log_msg(LVL_DEBUG, "get_driver_info(base_path=\"%s\", name=\"%s\")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "get_driver_info(base_path=\"%s\", name=\"%s\")", base_path, name); @@ -346,5 +346,5 @@ struct stat s; if (stat(drv->binary_path, &s) == ENOENT) { /* FIXME!! */ - log_msg(LVL_ERROR, "Driver not found at path `%s'.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Driver not found at path `%s'.", drv->binary_path); goto cleanup; @@ -374,5 +374,5 @@ int lookup_available_drivers(driver_list_t *drivers_list, const char *dir_path) { - log_msg(LVL_DEBUG, "lookup_available_drivers(dir=\"%s\")", dir_path); + log_msg(LOG_DEFAULT, LVL_DEBUG, "lookup_available_drivers(dir=\"%s\")", dir_path); int drv_cnt = 0; @@ -408,5 +408,5 @@ dev_node_t *dev; - log_msg(LVL_DEBUG, "create_root_nodes()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "create_root_nodes()"); fibril_rwlock_write_lock(&tree->rwlock); @@ -495,5 +495,5 @@ void attach_driver(dev_tree_t *tree, dev_node_t *dev, driver_t *drv) { - log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")", dev->pfun->pathname, drv->name); @@ -520,5 +520,5 @@ assert(drv != NULL); - log_msg(LVL_DEBUG, "detach_driver(dev=\"%s\",drv=\"%s\")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "detach_driver(dev=\"%s\",drv=\"%s\")", dev->pfun->pathname, drv->name); @@ -545,9 +545,9 @@ assert(fibril_mutex_is_locked(&drv->driver_mutex)); - log_msg(LVL_DEBUG, "start_driver(drv=\"%s\")", drv->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "start_driver(drv=\"%s\")", drv->name); rc = task_spawnl(NULL, drv->binary_path, drv->binary_path, NULL); if (rc != EOK) { - log_msg(LVL_ERROR, "Spawning driver `%s' (%s) failed: %s.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Spawning driver `%s' (%s) failed: %s.", drv->name, drv->binary_path, str_error(rc)); return false; @@ -594,5 +594,5 @@ link_t *link; - log_msg(LVL_DEBUG, "pass_devices_to_driver(driver=\"%s\")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "pass_devices_to_driver(driver=\"%s\")", driver->name); @@ -614,5 +614,5 @@ } - log_msg(LVL_DEBUG, "pass_devices_to_driver: dev->refcnt=%d\n", + log_msg(LOG_DEFAULT, LVL_DEBUG, "pass_devices_to_driver: dev->refcnt=%d\n", (int)atomic_get(&dev->refcnt)); dev_add_ref(dev); @@ -650,5 +650,5 @@ * immediately and possibly started here as well. */ - log_msg(LVL_DEBUG, "Driver `%s' enters running state.", driver->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Driver `%s' enters running state.", driver->name); driver->state = DRIVER_RUNNING; @@ -667,5 +667,5 @@ void initialize_running_driver(driver_t *driver, dev_tree_t *tree) { - log_msg(LVL_DEBUG, "initialize_running_driver(driver=\"%s\")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "initialize_running_driver(driver=\"%s\")", driver->name); @@ -761,5 +761,5 @@ * access any structures that would affect driver_t. */ - log_msg(LVL_DEBUG, "add_device(drv=\"%s\", dev=\"%s\")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "add_device(drv=\"%s\", dev=\"%s\")", drv->name, dev->pfun->name); @@ -827,5 +827,5 @@ driver_t *drv = find_best_match_driver(drivers_list, dev); if (drv == NULL) { - log_msg(LVL_ERROR, "No driver found for device `%s'.", + log_msg(LOG_DEFAULT, LVL_ERROR, "No driver found for device `%s'.", dev->pfun->pathname); return false; @@ -867,5 +867,5 @@ assert(dev != NULL); - log_msg(LVL_DEBUG, "driver_dev_remove(%p)", dev); + log_msg(LOG_DEFAULT, LVL_DEBUG, "driver_dev_remove(%p)", dev); fibril_rwlock_read_lock(&tree->rwlock); @@ -890,5 +890,5 @@ assert(dev != NULL); - log_msg(LVL_DEBUG, "driver_dev_gone(%p)", dev); + log_msg(LOG_DEFAULT, LVL_DEBUG, "driver_dev_gone(%p)", dev); fibril_rwlock_read_lock(&tree->rwlock); @@ -911,5 +911,5 @@ devman_handle_t handle; - log_msg(LVL_DEBUG, "driver_fun_online(%p)", fun); + log_msg(LOG_DEFAULT, LVL_DEBUG, "driver_fun_online(%p)", fun); fibril_rwlock_read_lock(&tree->rwlock); @@ -939,5 +939,5 @@ devman_handle_t handle; - log_msg(LVL_DEBUG, "driver_fun_offline(%p)", fun); + log_msg(LOG_DEFAULT, LVL_DEBUG, "driver_fun_offline(%p)", fun); fibril_rwlock_read_lock(&tree->rwlock); @@ -970,5 +970,5 @@ bool init_device_tree(dev_tree_t *tree, driver_list_t *drivers_list) { - log_msg(LVL_DEBUG, "init_device_tree()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "init_device_tree()"); tree->current_handle = 0; @@ -1261,5 +1261,5 @@ fun->pathname = (char *) malloc(pathsize); if (fun->pathname == NULL) { - log_msg(LVL_ERROR, "Failed to allocate device path."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate device path."); return false; } @@ -1289,5 +1289,5 @@ assert(fibril_rwlock_is_write_locked(&tree->rwlock)); - log_msg(LVL_DEBUG, "insert_dev_node(dev=%p, pfun=%p [\"%s\"])", + log_msg(LOG_DEFAULT, LVL_DEBUG, "insert_dev_node(dev=%p, pfun=%p [\"%s\"])", dev, pfun, pfun->pathname); @@ -1313,5 +1313,5 @@ assert(fibril_rwlock_is_write_locked(&tree->rwlock)); - log_msg(LVL_DEBUG, "remove_dev_node(dev=%p)", dev); + log_msg(LOG_DEFAULT, LVL_DEBUG, "remove_dev_node(dev=%p)", dev); /* Remove node from the handle-to-node map. */ Index: uspace/srv/devman/main.c =================================================================== --- uspace/srv/devman/main.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/devman/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -73,5 +73,5 @@ char *drv_name = NULL; - log_msg(LVL_DEBUG, "devman_driver_register"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_driver_register"); /* Get driver name. */ @@ -82,5 +82,5 @@ } - log_msg(LVL_DEBUG, "The `%s' driver is trying to register.", + log_msg(LOG_DEFAULT, LVL_DEBUG, "The `%s' driver is trying to register.", drv_name); @@ -88,5 +88,5 @@ driver = find_driver(&drivers_list, drv_name); if (driver == NULL) { - log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name); + log_msg(LOG_DEFAULT, LVL_ERROR, "No driver named `%s' was found.", drv_name); free(drv_name); drv_name = NULL; @@ -102,5 +102,5 @@ if (driver->sess) { /* We already have a connection to the driver. */ - log_msg(LVL_ERROR, "Driver '%s' already started.\n", + log_msg(LOG_DEFAULT, LVL_ERROR, "Driver '%s' already started.\n", driver->name); fibril_mutex_unlock(&driver->driver_mutex); @@ -112,5 +112,5 @@ case DRIVER_NOT_STARTED: /* Somebody started the driver manually. */ - log_msg(LVL_NOTE, "Driver '%s' started manually.\n", + log_msg(LOG_DEFAULT, LVL_NOTE, "Driver '%s' started manually.\n", driver->name); driver->state = DRIVER_STARTING; @@ -125,5 +125,5 @@ /* Create connection to the driver. */ - log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Creating connection to the `%s' driver.", driver->name); driver->sess = async_callback_receive(EXCHANGE_PARALLEL); @@ -136,5 +136,5 @@ async_sess_args_set(driver->sess, DRIVER_DEVMAN, 0, 0); - log_msg(LVL_NOTE, + log_msg(LOG_DEFAULT, LVL_NOTE, "The `%s' driver was successfully registered as running.", driver->name); @@ -147,5 +147,5 @@ fid_t fid = fibril_create(init_running_drv, driver); if (fid == 0) { - log_msg(LVL_ERROR, "Failed to create initialization fibril " \ + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to create initialization fibril " \ "for driver `%s'.", driver->name); fibril_mutex_unlock(&driver->driver_mutex); @@ -176,5 +176,5 @@ callid = async_get_call(&call); if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) { - log_msg(LVL_ERROR, + log_msg(LOG_DEFAULT, LVL_ERROR, "Invalid protocol when trying to receive match id."); async_answer_0(callid, EINVAL); @@ -184,5 +184,5 @@ if (match_id == NULL) { - log_msg(LVL_ERROR, "Failed to allocate match id."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate match id."); async_answer_0(callid, ENOMEM); return ENOMEM; @@ -198,5 +198,5 @@ if (rc != EOK) { delete_match_id(match_id); - log_msg(LVL_ERROR, "Failed to receive match id string: %s.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to receive match id string: %s.", str_error(rc)); return rc; @@ -205,5 +205,5 @@ list_append(&match_id->link, &match_ids->ids); - log_msg(LVL_DEBUG, "Received match id `%s', score %d.", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Received match id `%s', score %d.", match_id->id, match_id->score); return rc; @@ -248,5 +248,5 @@ if (fun->state == FUN_ON_LINE) { fibril_rwlock_write_unlock(&device_tree.rwlock); - log_msg(LVL_WARN, "Function %s is already on line.", + log_msg(LOG_DEFAULT, LVL_WARN, "Function %s is already on line.", fun->pathname); return EOK; @@ -264,5 +264,5 @@ } - log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname); + log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname); if (fun->ftype == fun_inner) { @@ -282,5 +282,5 @@ fid_t assign_fibril = fibril_create(assign_driver_fibril, dev); if (assign_fibril == 0) { - log_msg(LVL_ERROR, "Failed to create fibril for " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to create fibril for " "assigning driver."); /* XXX Cleanup */ @@ -305,5 +305,5 @@ if (fun->state == FUN_OFF_LINE) { fibril_rwlock_write_unlock(&device_tree.rwlock); - log_msg(LVL_WARN, "Function %s is already off line.", + log_msg(LOG_DEFAULT, LVL_WARN, "Function %s is already off line.", fun->pathname); return EOK; @@ -311,5 +311,5 @@ if (fun->ftype == fun_inner) { - log_msg(LVL_DEBUG, "Offlining inner function %s.", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Offlining inner function %s.", fun->pathname); @@ -359,5 +359,5 @@ if (rc != EOK) { fibril_rwlock_write_unlock(&device_tree.rwlock); - log_msg(LVL_ERROR, "Failed unregistering tree service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unregistering tree service."); return EIO; } @@ -391,5 +391,5 @@ if (ftype != fun_inner && ftype != fun_exposed) { /* Unknown function type */ - log_msg(LVL_ERROR, + log_msg(LOG_DEFAULT, LVL_ERROR, "Unknown function type %d provided by driver.", (int) ftype); @@ -507,8 +507,8 @@ if (rc == EOK) { loc_service_add_to_cat(fun->service_id, cat_id); - log_msg(LVL_NOTE, "Function `%s' added to category `%s'.", + log_msg(LOG_DEFAULT, LVL_NOTE, "Function `%s' added to category `%s'.", fun->pathname, cat_name); } else { - log_msg(LVL_ERROR, "Failed adding function `%s' to category " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding function `%s' to category " "`%s'.", fun->pathname, cat_name); } @@ -529,5 +529,5 @@ int rc; - log_msg(LVL_DEBUG, "devman_drv_fun_online()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_drv_fun_online()"); fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall)); @@ -620,5 +620,5 @@ fibril_rwlock_write_lock(&tree->rwlock); - log_msg(LVL_DEBUG, "devman_remove_function(fun='%s')", fun->pathname); + log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function(fun='%s')", fun->pathname); /* Check function state */ @@ -653,5 +653,5 @@ /* Verify that driver succeeded and removed all functions */ if (gone_rc != EOK || !list_empty(&dev->functions)) { - log_msg(LVL_ERROR, "Driver did not remove " + log_msg(LOG_DEFAULT, LVL_ERROR, "Driver did not remove " "functions for device that is gone. " "Device node is now defunct."); @@ -692,5 +692,5 @@ rc = loc_service_unregister(fun->service_id); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed unregistering tree " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unregistering tree " "service."); fibril_rwlock_write_unlock(&tree->rwlock); @@ -712,5 +712,5 @@ fun_del_ref(fun); - log_msg(LVL_DEBUG, "devman_remove_function() succeeded."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function() succeeded."); async_answer_0(callid, EOK); } @@ -726,5 +726,5 @@ initialize_running_driver(driver, &device_tree); - log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.", + log_msg(LOG_DEFAULT, LVL_DEBUG, "The `%s` driver was successfully initialized.", driver->name); return 0; @@ -742,5 +742,5 @@ client = async_get_client_data(); if (client == NULL) { - log_msg(LVL_ERROR, "Failed to allocate client data."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate client data."); return; } @@ -1229,5 +1229,5 @@ */ if (dev == NULL) { - log_msg(LVL_ERROR, "IPC forwarding failed - no device or " + log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding failed - no device or " "function with handle %" PRIun " was found.", handle); async_answer_0(iid, ENOENT); @@ -1236,5 +1236,5 @@ if (fun == NULL && !drv_to_parent) { - log_msg(LVL_ERROR, NAME ": devman_forward error - cannot " + log_msg(LOG_DEFAULT, LVL_ERROR, NAME ": devman_forward error - cannot " "connect to handle %" PRIun ", refers to a device.", handle); @@ -1264,5 +1264,5 @@ if (driver == NULL) { - log_msg(LVL_ERROR, "IPC forwarding refused - " \ + log_msg(LOG_DEFAULT, LVL_ERROR, "IPC forwarding refused - " \ "the device %" PRIun " is not in usable state.", handle); async_answer_0(iid, ENOENT); @@ -1277,5 +1277,5 @@ if (!driver->sess) { - log_msg(LVL_ERROR, + log_msg(LOG_DEFAULT, LVL_ERROR, "Could not forward to driver `%s'.", driver->name); async_answer_0(iid, EINVAL); @@ -1284,9 +1284,9 @@ if (fun != NULL) { - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Forwarding request for `%s' function to driver `%s'.", fun->pathname, driver->name); } else { - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Forwarding request for `%s' device to driver `%s'.", dev->pfun->pathname, driver->name); @@ -1320,5 +1320,5 @@ if (fun == NULL || fun->dev == NULL || fun->dev->drv == NULL) { - log_msg(LVL_WARN, "devman_connection_loc(): function " + log_msg(LOG_DEFAULT, LVL_WARN, "devman_connection_loc(): function " "not found.\n"); fibril_rwlock_read_unlock(&device_tree.rwlock); @@ -1338,5 +1338,5 @@ async_exchange_end(exch); - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Forwarding loc service request for `%s' function to driver `%s'.", fun->pathname, driver->name); @@ -1394,5 +1394,5 @@ static bool devman_init(void) { - log_msg(LVL_DEBUG, "devman_init - looking for available drivers."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_init - looking for available drivers."); /* Initialize list of available drivers. */ @@ -1400,13 +1400,13 @@ if (lookup_available_drivers(&drivers_list, DRIVER_DEFAULT_STORE) == 0) { - log_msg(LVL_FATAL, "No drivers found."); + log_msg(LOG_DEFAULT, LVL_FATAL, "No drivers found."); return false; } - log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_init - list of drivers has been initialized."); /* Create root device node. */ if (!init_device_tree(&device_tree, &drivers_list)) { - log_msg(LVL_FATAL, "Failed to initialize device tree."); + log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to initialize device tree."); return false; } @@ -1428,5 +1428,5 @@ printf("%s: HelenOS Device Manager\n", NAME); - int rc = log_init(NAME, LVL_WARN); + int rc = log_init(NAME); if (rc != EOK) { printf("%s: Error initializing logging subsystem.\n", NAME); @@ -1440,5 +1440,5 @@ if (!devman_init()) { - log_msg(LVL_ERROR, "Error while initializing service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Error while initializing service."); return -1; } @@ -1447,5 +1447,5 @@ rc = service_register(SERVICE_DEVMAN); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering as a service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering as a service."); return rc; } Index: uspace/srv/fs/udf/udf.c =================================================================== --- uspace/srv/fs/udf/udf.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/fs/udf/udf.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -61,6 +61,6 @@ int main(int argc, char *argv[]) { - log_init(NAME, LVL_NOTE); - log_msg(LVL_NOTE, "HelenOS UDF 1.02 file system server"); + log_init(NAME); + log_msg(LOG_DEFAULT, LVL_NOTE, "HelenOS UDF 1.02 file system server"); if (argc == 3) { @@ -68,5 +68,5 @@ udf_vfs_info.instance = strtol(argv[2], NULL, 10); else { - log_msg(LVL_FATAL, "Unrecognized parameters"); + log_msg(LOG_DEFAULT, LVL_FATAL, "Unrecognized parameters"); return 1; } @@ -76,5 +76,5 @@ service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_VFS, 0, 0); if (!vfs_sess) { - log_msg(LVL_FATAL, "Failed to connect to VFS"); + log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to connect to VFS"); return 2; } @@ -89,5 +89,5 @@ goto err; - log_msg(LVL_NOTE, "Accepting connections"); + log_msg(LOG_DEFAULT, LVL_NOTE, "Accepting connections"); task_retval(0); async_manager(); @@ -97,5 +97,5 @@ err: - log_msg(LVL_FATAL, "Failed to register file system (%d)", rc); + log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to register file system (%d)", rc); return rc; } Index: uspace/srv/fs/udf/udf_file.c =================================================================== --- uspace/srv/fs/udf/udf_file.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/fs/udf/udf_file.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -71,5 +71,5 @@ FLE32(exd->extent_location.lblock_num); - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Extended allocator: start=%d, block_num=%d, len=%d", start, FLE32(exd->extent_location.lblock_num), FLE32(exd->info_length)); @@ -100,5 +100,5 @@ switch (icb_flag) { case UDF_SHORT_AD: - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: sequence of allocation descriptors - icbflag = short_ad_t"); @@ -167,5 +167,5 @@ case UDF_LONG_AD: - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: sequence of allocation descriptors - icbflag = long_ad_t"); @@ -203,10 +203,10 @@ case UDF_EXTENDED_AD: - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: sequence of allocation descriptors - icbflag = extended_ad_t"); break; case UDF_DATA_AD: - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: sequence of allocation descriptors - icbflag = 3, node contains data itself"); @@ -253,5 +253,5 @@ switch (FLE16(data->id)) { case UDF_FILE_ENTRY: - log_msg(LVL_DEBUG, "ICB: File entry descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: File entry descriptor found"); udf_file_entry_descriptor_t *file = @@ -267,5 +267,5 @@ case UDF_EFILE_ENTRY: - log_msg(LVL_DEBUG, "ICB: Extended file entry descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: Extended file entry descriptor found"); udf_extended_file_entry_descriptor_t *efile = @@ -281,5 +281,5 @@ case UDF_ICB_TERMINAL: - log_msg(LVL_DEBUG, "ICB: Terminal entry descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: Terminal entry descriptor found"); block_put(block); return EOK; Index: uspace/srv/fs/udf/udf_ops.c =================================================================== --- uspace/srv/fs/udf/udf_ops.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/fs/udf/udf_ops.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -311,5 +311,5 @@ rc = udf_volume_recongnition(service_id); if (rc != EOK) { - log_msg(LVL_NOTE, "VRS failed"); + log_msg(LOG_DEFAULT, LVL_NOTE, "VRS failed"); fs_instance_destroy(service_id); free(instance); @@ -322,5 +322,5 @@ rc = udf_get_anchor_volume_descriptor(service_id, &avd); if (rc != EOK) { - log_msg(LVL_NOTE, "Anchor read failed"); + log_msg(LOG_DEFAULT, LVL_NOTE, "Anchor read failed"); fs_instance_destroy(service_id); free(instance); @@ -329,12 +329,12 @@ } - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Anchor volume descriptor found. Sector size=%" PRIu32, instance->sector_size); - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Anchor: main sequence [length=%" PRIu32 " (bytes), start=%" PRIu32 " (sector)]", avd.main_extent.length, avd.main_extent.location); - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Anchor: reserve sequence [length=%" PRIu32 " (bytes), start=%" PRIu32 " (sector)]", avd.reserve_extent.length, @@ -353,5 +353,5 @@ rc = udf_read_volume_descriptor_sequence(service_id, avd.main_extent); if (rc != EOK) { - log_msg(LVL_NOTE, "Volume Descriptor Sequence read failed"); + log_msg(LOG_DEFAULT, LVL_NOTE, "Volume Descriptor Sequence read failed"); fs_instance_destroy(service_id); free(instance); @@ -364,5 +364,5 @@ rc = udf_node_get(&rfn, service_id, instance->volumes[DEFAULT_VOL].root_dir); if (rc != EOK) { - log_msg(LVL_NOTE, "Can't create root node"); + log_msg(LOG_DEFAULT, LVL_NOTE, "Can't create root node"); fs_instance_destroy(service_id); free(instance); Index: uspace/srv/fs/udf/udf_volume.c =================================================================== --- uspace/srv/fs/udf/udf_volume.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/fs/udf/udf_volume.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -63,5 +63,5 @@ fs_index_t udf_long_ad_to_pos(udf_instance_t *instance, udf_long_ad_t *long_ad) { - log_msg(LVL_DEBUG, "Long_Ad to Pos: " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Long_Ad to Pos: " "partition_num=%" PRIu16 ", partition_block=%" PRIu32, FLE16(long_ad->location.partition_num), @@ -130,10 +130,10 @@ (str_lcmp(VRS_NSR3, (char *) vd->identifier, VRS_ID_LEN) == 0)) { nsr_found = true; - log_msg(LVL_DEBUG, "VRS: NSR found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "VRS: NSR found"); continue; } if (str_lcmp(VRS_END, (char *) vd->identifier, VRS_ID_LEN) == 0) { - log_msg(LVL_DEBUG, "VRS: end found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "VRS: end found"); break; } @@ -382,5 +382,5 @@ switch (FLE16(desc->id)) { case UDF_FILE_ENTRY: - log_msg(LVL_DEBUG, "ICB: File entry descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: File entry descriptor found"); udf_file_entry_descriptor_t *fed = @@ -394,5 +394,5 @@ case UDF_EFILE_ENTRY: - log_msg(LVL_DEBUG, "ICB: Extended file entry descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ICB: Extended file entry descriptor found"); udf_extended_file_entry_descriptor_t *efed = @@ -514,5 +514,5 @@ &instance->partitions[j]; - log_msg(LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] " "found and filled", i, pm1->partition_map_type); @@ -531,5 +531,5 @@ (udf_metadata_partition_map_t *) idx; - log_msg(LVL_DEBUG, "Metadata file location=%u", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Metadata file location=%u", FLE32(metadata->metadata_fileloc)); @@ -569,8 +569,8 @@ &instance->partitions[j]; - log_msg(LVL_DEBUG, "Virtual partition: num=%d, start=%d", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Virtual partition: num=%d, start=%d", instance->partitions[j].number, instance->partitions[j].start); - log_msg(LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] " "found and filled", i, pm2->partition_map_type); @@ -583,5 +583,5 @@ udf_general_type_t *pm = (udf_general_type_t *) idx; - log_msg(LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume[%" PRIun "]: partition [type %u] " "found and skipped", i, pm->partition_map_type); @@ -657,5 +657,5 @@ /* One sector size descriptors */ case UDF_TAG_PVD: - log_msg(LVL_DEBUG, "Volume: Primary volume descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Primary volume descriptor found"); if (!udf_check_prevailing_pvd(pvd, pvd_cnt, &vol->volume)) { @@ -669,10 +669,10 @@ case UDF_TAG_VDP: - log_msg(LVL_DEBUG, "Volume: Volume descriptor pointer found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Volume descriptor pointer found"); pos++; break; case UDF_TAG_IUVD: - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Implementation use volume descriptor found"); pos++; @@ -680,9 +680,9 @@ case UDF_TAG_PD: - log_msg(LVL_DEBUG, "Volume: Partition descriptor found"); - log_msg(LVL_DEBUG, "Partition number: %u, contents: '%.6s', " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Partition descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Partition number: %u, contents: '%.6s', " "access type: %" PRIu32, FLE16(vol->partition.number), vol->partition.contents.id, FLE32(vol->partition.access_type)); - log_msg(LVL_DEBUG, "Partition start: %" PRIu32 " (sector), " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Partition start: %" PRIu32 " (sector), " "size: %" PRIu32 " (sectors)", FLE32(vol->partition.starting_location), @@ -698,5 +698,5 @@ (udf_partition_header_descriptor_t *) vol->partition.contents_use; if (FLE32(phd->unallocated_space_table.length)) { - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "space table: length=%" PRIu32 ", pos=%" PRIu32, FLE32(phd->unallocated_space_table.length), @@ -712,5 +712,5 @@ if (FLE32(phd->unallocated_space_bitmap.length)) { - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "space bitmap: length=%" PRIu32 ", pos=%" PRIu32, FLE32(phd->unallocated_space_bitmap.length), @@ -730,5 +730,5 @@ /* Relative size descriptors */ case UDF_TAG_LVD: - log_msg(LVL_DEBUG, "Volume: Logical volume descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Logical volume descriptor found"); aoff64_t sct = @@ -743,8 +743,8 @@ &vol->logical.charset); - log_msg(LVL_DEBUG, "Logical Volume ID: '%s', " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Logical Volume ID: '%s', " "logical block size: %" PRIu32 " (bytes)", tmp, FLE32(vol->logical.logical_block_size)); - log_msg(LVL_DEBUG, "Map table size: %" PRIu32 " (bytes), " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Map table size: %" PRIu32 " (bytes), " "number of partition maps: %" PRIu32, FLE32(vol->logical.map_table_length), @@ -761,5 +761,5 @@ case UDF_TAG_USD: - log_msg(LVL_DEBUG, "Volume: Unallocated space descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Unallocated space descriptor found"); sct = ALL_UP((sizeof(udf_unallocated_space_descriptor_t) + @@ -780,5 +780,5 @@ case UDF_TAG_LVID: - log_msg(LVL_DEBUG, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Logical volume integrity descriptor found"); @@ -787,5 +787,5 @@ case UDF_TAG_TD: - log_msg(LVL_DEBUG, "Volume: Terminating descriptor found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Volume: Terminating descriptor found"); /* Found terminating descriptor. Exiting */ @@ -823,5 +823,5 @@ udf_descriptor_tag_t *desc = block->data; - log_msg(LVL_DEBUG, "First tag ID=%" PRIu16, desc->id); + log_msg(LOG_DEFAULT, LVL_DEBUG, "First tag ID=%" PRIu16, desc->id); if (desc->checksum != udf_tag_checksum((uint8_t *) desc)) { Index: uspace/srv/logger/Makefile =================================================================== --- uspace/srv/logger/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/Makefile (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,41 @@ +# +# Copyright (c) 2012 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +BINARY = logger +STATIC_NEEDED = y + +SOURCES = \ + ctl.c \ + initlvl.c \ + level.c \ + logs.c \ + main.c \ + writer.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/logger/ctl.c =================================================================== --- uspace/srv/logger/ctl.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/ctl.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @addtogroup logger + * @{ + */ + +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include "logger.h" + +static int handle_log_level_change(sysarg_t new_level) +{ + void *full_name; + int rc = async_data_write_accept(&full_name, true, 0, 0, 0, NULL); + if (rc != EOK) { + return rc; + } + + logger_log_t *log = find_log_by_name_and_lock(full_name); + free(full_name); + if (log == NULL) + return ENOENT; + + log->logged_level = new_level; + + log_unlock(log); + + return EOK; +} + +void logger_connection_handler_control(ipc_callid_t callid) +{ + async_answer_0(callid, EOK); + logger_log("control: new client.\n"); + + while (true) { + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) + break; + + switch (IPC_GET_IMETHOD(call)) { + case LOGGER_CONTROL_SET_DEFAULT_LEVEL: { + int rc = set_default_logging_level(IPC_GET_ARG1(call)); + async_answer_0(callid, rc); + break; + } + case LOGGER_CONTROL_SET_LOG_LEVEL: { + int rc = handle_log_level_change(IPC_GET_ARG1(call)); + async_answer_0(callid, rc); + break; + } + default: + async_answer_0(callid, EINVAL); + break; + } + } + + logger_log("control: client terminated.\n"); +} + + +/** + * @} + */ Index: uspace/srv/logger/initlvl.c =================================================================== --- uspace/srv/logger/initlvl.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/initlvl.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @addtogroup logger + * @{ + */ + +/** @file + */ +#include +#include +#include +#include +#include "logger.h" + +static void parse_single_level_setting(char *setting) +{ + char *tmp; + char *key = strtok_r(setting, "=", &tmp); + char *value = strtok_r(NULL, "=", &tmp); + if (key == NULL) + return; + if (value == NULL) { + log_level_t level; + int rc = log_level_from_str(key, &level); + if (rc != EOK) + return; + set_default_logging_level(level); + return; + } + + + log_level_t level; + int rc = log_level_from_str(value, &level); + if (rc != EOK) + return; + + logger_log_t *log = find_or_create_log_and_lock(key, 0); + if (log == NULL) + return; + + log->logged_level = level; + log->ref_counter++; + + log_unlock(log); +} + +void parse_level_settings(char *settings) +{ + char *tmp; + char *single_setting = strtok_r(settings, " ", &tmp); + while (single_setting != NULL) { + parse_single_level_setting(single_setting); + single_setting = strtok_r(NULL, " ", &tmp); + } +} + +void parse_initial_settings(void) +{ + size_t argument_size; + void *argument = sysinfo_get_data("init_args.logger", &argument_size); + if (argument == NULL) + return; + + char level_str[200]; + str_cpy(level_str, 200, (const char *) argument); + + parse_level_settings(level_str); +} + +/** + * @} + */ Index: uspace/srv/logger/level.c =================================================================== --- uspace/srv/logger/level.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/level.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @addtogroup logger + * @{ + */ + +/** @file + */ + +#include +#include "logger.h" + +log_level_t default_logging_level = LVL_NOTE; +static FIBRIL_MUTEX_INITIALIZE(default_logging_level_guard); + +log_level_t get_default_logging_level(void) +{ + fibril_mutex_lock(&default_logging_level_guard); + log_level_t result = default_logging_level; + fibril_mutex_unlock(&default_logging_level_guard); + return result; +} + +int set_default_logging_level(log_level_t new_level) +{ + if (new_level >= LVL_LIMIT) + return ERANGE; + fibril_mutex_lock(&default_logging_level_guard); + default_logging_level = new_level; + fibril_mutex_unlock(&default_logging_level_guard); + return EOK; +} + +/** + * @} + */ Index: uspace/srv/logger/logger.h =================================================================== --- uspace/srv/logger/logger.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/logger.h (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup logger + * @{ + */ +/** @file Common logger service definitions. + */ + +#ifndef LOGGER_H_ +#define LOGGER_H_ + +#include +#include +#include +#include +#include +#include +#include + +#define NAME "logger" +#define LOG_LEVEL_USE_DEFAULT (LVL_LIMIT + 1) + +#ifdef LOGGER_LOG +#define logger_log(fmt, ...) printf(NAME ": " fmt, ##__VA_ARGS__) +#else +#define logger_log(fmt, ...) (void)0 +#endif + +typedef struct logger_log logger_log_t; + +typedef struct { + fibril_mutex_t guard; + char *filename; + FILE *logfile; +} logger_dest_t; + +struct logger_log { + link_t link; + + size_t ref_counter; + + fibril_mutex_t guard; + + char *name; + char *full_name; + logger_log_t *parent; + log_level_t logged_level; + logger_dest_t *dest; +}; + +#define MAX_REFERENCED_LOGS_PER_CLIENT 100 + +typedef struct { + size_t logs_count; + logger_log_t *logs[MAX_REFERENCED_LOGS_PER_CLIENT]; +} logger_registered_logs_t; + +logger_log_t *find_log_by_name_and_lock(const char *name); +logger_log_t *find_or_create_log_and_lock(const char *, sysarg_t); +logger_log_t *find_log_by_id_and_lock(sysarg_t); +bool shall_log_message(logger_log_t *, log_level_t); +void log_unlock(logger_log_t *); +void write_to_log(logger_log_t *, log_level_t, const char *); +void log_release(logger_log_t *); + +void registered_logs_init(logger_registered_logs_t *); +bool register_log(logger_registered_logs_t *, logger_log_t *); +void unregister_logs(logger_registered_logs_t *); + +log_level_t get_default_logging_level(void); +int set_default_logging_level(log_level_t); + + +void logger_connection_handler_control(ipc_callid_t); +void logger_connection_handler_writer(ipc_callid_t); + +void parse_initial_settings(void); +void parse_level_settings(char *); + +#endif + +/** @} + */ Index: uspace/srv/logger/logs.c =================================================================== --- uspace/srv/logger/logs.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/logs.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,336 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup logger + * @{ + */ +#include +#include +#include +#include +#include +#include "logger.h" + + +static FIBRIL_MUTEX_INITIALIZE(log_list_guard); +static LIST_INITIALIZE(log_list); + + +static logger_log_t *find_log_by_name_and_parent_no_list_lock(const char *name, logger_log_t *parent) +{ + list_foreach(log_list, it) { + logger_log_t *log = list_get_instance(it, logger_log_t, link); + if ((parent == log->parent) && (str_cmp(log->name, name) == 0)) + return log; + } + + return NULL; +} + +static int create_dest(const char *name, logger_dest_t **dest) +{ + logger_dest_t *result = malloc(sizeof(logger_dest_t)); + if (result == NULL) + return ENOMEM; + int rc = asprintf(&result->filename, "/log/%s", name); + if (rc < 0) { + free(result); + return ENOMEM; + } + result->logfile = NULL; + fibril_mutex_initialize(&result->guard); + *dest = result; + return EOK; +} + +static logger_log_t *create_log_no_locking(const char *name, logger_log_t *parent) +{ + logger_log_t *result = calloc(1, sizeof(logger_log_t)); + if (result == NULL) + return NULL; + + result->name = str_dup(name); + if (result->name == NULL) + goto error; + + /* + * Notice that we create new dest as the last + * operation that can fail and thus there is no code + * to deallocate dest. + */ + if (parent == NULL) { + result->full_name = str_dup(name); + if (result->full_name == NULL) + goto error; + int rc = create_dest(name, &result->dest); + if (rc != EOK) + goto error; + } else { + int rc = asprintf(&result->full_name, "%s/%s", + parent->full_name, name); + if (rc < 0) + goto error; + result->dest = parent->dest; + } + + /* Following initializations cannot fail. */ + result->logged_level = LOG_LEVEL_USE_DEFAULT; + fibril_mutex_initialize(&result->guard); + link_initialize(&result->link); + result->parent = parent; + + return result; + +error: + free(result->name); + free(result->full_name); + free(result); + return NULL; + +} + +logger_log_t *find_or_create_log_and_lock(const char *name, sysarg_t parent_id) +{ + logger_log_t *result = NULL; + logger_log_t *parent = (logger_log_t *) parent_id; + + fibril_mutex_lock(&log_list_guard); + + result = find_log_by_name_and_parent_no_list_lock(name, parent); + if (result == NULL) { + result = create_log_no_locking(name, parent); + if (result == NULL) + goto leave; + list_append(&result->link, &log_list); + if (result->parent != NULL) { + fibril_mutex_lock(&result->parent->guard); + result->parent->ref_counter++; + fibril_mutex_unlock(&result->parent->guard); + } + } + + fibril_mutex_lock(&result->guard); + +leave: + fibril_mutex_unlock(&log_list_guard); + + return result; +} + +logger_log_t *find_log_by_name_and_lock(const char *name) +{ + logger_log_t *result = NULL; + + fibril_mutex_lock(&log_list_guard); + list_foreach(log_list, it) { + logger_log_t *log = list_get_instance(it, logger_log_t, link); + if (str_cmp(log->full_name, name) == 0) { + fibril_mutex_lock(&log->guard); + result = log; + break; + } + } + fibril_mutex_unlock(&log_list_guard); + + return result; +} + +logger_log_t *find_log_by_id_and_lock(sysarg_t id) +{ + logger_log_t *result = NULL; + + fibril_mutex_lock(&log_list_guard); + list_foreach(log_list, it) { + logger_log_t *log = list_get_instance(it, logger_log_t, link); + if ((sysarg_t) log == id) { + fibril_mutex_lock(&log->guard); + result = log; + break; + } + } + fibril_mutex_unlock(&log_list_guard); + + return result; +} + +static log_level_t get_actual_log_level(logger_log_t *log) +{ + /* Find recursively proper log level. */ + if (log->logged_level == LOG_LEVEL_USE_DEFAULT) { + if (log->parent == NULL) + return get_default_logging_level(); + else + return get_actual_log_level(log->parent); + } + return log->logged_level; +} + +bool shall_log_message(logger_log_t *log, log_level_t level) +{ + fibril_mutex_lock(&log_list_guard); + bool result = level <= get_actual_log_level(log); + fibril_mutex_unlock(&log_list_guard); + return result; +} + +void log_unlock(logger_log_t *log) +{ + assert(fibril_mutex_is_locked(&log->guard)); + fibril_mutex_unlock(&log->guard); +} + +/** Decreases reference counter on the log and destory the log if + * necessary. + * + * Precondition: log is locked. + * + * @param log Log to release from using by the caller. + */ +void log_release(logger_log_t *log) +{ + assert(fibril_mutex_is_locked(&log->guard)); + assert(log->ref_counter > 0); + + /* We are definitely not the last ones. */ + if (log->ref_counter > 1) { + log->ref_counter--; + fibril_mutex_unlock(&log->guard); + return; + } + + /* + * To prevent deadlock, we need to get the list lock first. + * Deadlock scenario: + * Us: LOCKED(log), want to LOCK(list) + * Someone else calls find_log_by_name_and_lock(log->fullname) -> + * LOCKED(list), wants to LOCK(log) + */ + fibril_mutex_unlock(&log->guard); + + /* Ensuring correct locking order. */ + fibril_mutex_lock(&log_list_guard); + /* + * The reference must be still valid because we have not decreased + * the reference counter. + */ + fibril_mutex_lock(&log->guard); + assert(log->ref_counter > 0); + log->ref_counter--; + + if (log->ref_counter > 0) { + /* + * Meanwhile, someone else increased the ref counter. + * No big deal, we just return immediatelly. + */ + fibril_mutex_unlock(&log->guard); + fibril_mutex_unlock(&log_list_guard); + return; + } + + /* + * Here we are on a destroy path. We need to + * - remove ourselves from the list + * - decrease reference of the parent (if not top-level log) + * - we must do that after we relaase list lock to prevent + * deadlock with ourselves + * - destroy dest (if top-level log) + */ + assert(log->ref_counter == 0); + + list_remove(&log->link); + fibril_mutex_unlock(&log_list_guard); + fibril_mutex_unlock(&log->guard); + + if (log->parent == NULL) { + fclose(log->dest->logfile); + free(log->dest->filename); + free(log->dest); + } else { + fibril_mutex_lock(&log->parent->guard); + log_release(log->parent); + } + + logger_log("Destroyed log %s.\n", log->full_name); + + free(log->name); + free(log->full_name); + + free(log); +} + + +void write_to_log(logger_log_t *log, log_level_t level, const char *message) +{ + assert(fibril_mutex_is_locked(&log->guard)); + assert(log->dest != NULL); + fibril_mutex_lock(&log->dest->guard); + if (log->dest->logfile == NULL) + log->dest->logfile = fopen(log->dest->filename, "a"); + + if (log->dest->logfile != NULL) { + fprintf(log->dest->logfile, "[%s] %s: %s\n", + log->full_name, log_level_str(level), + (const char *) message); + fflush(log->dest->logfile); + } + + fibril_mutex_unlock(&log->dest->guard); +} + +void registered_logs_init(logger_registered_logs_t *logs) +{ + logs->logs_count = 0; +} + +bool register_log(logger_registered_logs_t *logs, logger_log_t *new_log) +{ + if (logs->logs_count >= MAX_REFERENCED_LOGS_PER_CLIENT) { + return false; + } + + assert(fibril_mutex_is_locked(&new_log->guard)); + new_log->ref_counter++; + + logs->logs[logs->logs_count] = new_log; + logs->logs_count++; + + return true; +} + +void unregister_logs(logger_registered_logs_t *logs) +{ + for (size_t i = 0; i < logs->logs_count; i++) { + logger_log_t *log = logs->logs[i]; + fibril_mutex_lock(&log->guard); + log_release(log); + } +} + +/** + * @} + */ Index: uspace/srv/logger/main.c =================================================================== --- uspace/srv/logger/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/main.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @defgroup logger Logging service. + * @brief HelenOS logging service. + * @{ + */ + +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "logger.h" + +static void connection_handler(ipc_callid_t iid, ipc_call_t *icall, void *arg) +{ + logger_interface_t iface = IPC_GET_ARG1(*icall); + + switch (iface) { + case LOGGER_INTERFACE_CONTROL: + logger_connection_handler_control(iid); + break; + case LOGGER_INTERFACE_WRITER: + logger_connection_handler_writer(iid); + break; + default: + async_answer_0(iid, EINVAL); + break; + } +} + +int main(int argc, char *argv[]) +{ + printf(NAME ": HelenOS Logging Service\n"); + + parse_initial_settings(); + for (int i = 1; i < argc; i++) { + parse_level_settings(argv[i]); + } + + async_set_client_connection(connection_handler); + + int rc = service_register(SERVICE_LOGGER); + if (rc != EOK) { + printf(NAME ": failed to register: %s.\n", str_error(rc)); + return -1; + } + + printf(NAME ": Accepting connections\n"); + async_manager(); + + /* Never reached */ + return 0; +} + +/** + * @} + */ Index: uspace/srv/logger/writer.c =================================================================== --- uspace/srv/logger/writer.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) +++ uspace/srv/logger/writer.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @defgroup logger Logging service. + * @brief HelenOS logging service. + * @{ + */ + +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "logger.h" + + +static logger_log_t *handle_create_log(sysarg_t parent) +{ + void *name; + int rc = async_data_write_accept(&name, true, 1, 0, 0, NULL); + if (rc != EOK) + return NULL; + + logger_log_t *log = find_or_create_log_and_lock(name, parent); + + free(name); + + return log; +} + +static int handle_receive_message(sysarg_t log_id, sysarg_t level) +{ + logger_log_t *log = find_log_by_id_and_lock(log_id); + if (log == NULL) + return ENOENT; + + void *message = NULL; + int rc = async_data_write_accept(&message, true, 1, 0, 0, NULL); + if (rc != EOK) + goto leave; + + if (!shall_log_message(log, level)) { + rc = EOK; + goto leave; + } + + printf("[%s] %s: %s\n", + log->full_name, log_level_str(level), + (const char *) message); + write_to_log(log, level, message); + + rc = EOK; + +leave: + log_unlock(log); + free(message); + + return rc; +} + +void logger_connection_handler_writer(ipc_callid_t callid) +{ + /* Acknowledge the connection. */ + async_answer_0(callid, EOK); + + logger_log("writer: new client.\n"); + + logger_registered_logs_t registered_logs; + registered_logs_init(®istered_logs); + + while (true) { + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) + break; + + switch (IPC_GET_IMETHOD(call)) { + case LOGGER_WRITER_CREATE_LOG: { + logger_log_t *log = handle_create_log(IPC_GET_ARG1(call)); + if (log == NULL) { + async_answer_0(callid, ENOMEM); + break; + } + if (!register_log(®istered_logs, log)) { + log_unlock(log); + async_answer_0(callid, ELIMIT); + break; + } + log_unlock(log); + async_answer_1(callid, EOK, (sysarg_t) log); + break; + } + case LOGGER_WRITER_MESSAGE: { + int rc = handle_receive_message(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + async_answer_0(callid, rc); + break; + } + default: + async_answer_0(callid, EINVAL); + break; + } + } + + unregister_logs(®istered_logs); + logger_log("writer: client terminated.\n"); +} + + +/** + * @} + */ Index: uspace/srv/net/ethip/arp.c =================================================================== --- uspace/srv/net/ethip/arp.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/ethip/arp.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -59,5 +59,5 @@ ethip_link_addr_t *laddr; - log_msg(LVL_DEBUG, "arp_received()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_received()"); rc = arp_pdu_decode(frame->data, frame->size, &packet); @@ -65,10 +65,10 @@ return; - log_msg(LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x", + log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x", packet.opcode, packet.target_proto_addr.ipv4); laddr = ethip_nic_addr_find(nic, &packet.target_proto_addr); if (laddr != NULL) { - log_msg(LVL_DEBUG, "Request/reply to my address"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address"); (void) atrans_add(&packet.sender_proto_addr, @@ -122,5 +122,5 @@ size_t fsize; - log_msg(LVL_DEBUG, "arp_send_packet()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_send_packet()"); rc = arp_pdu_encode(packet, &pdata, &psize); Index: uspace/srv/net/ethip/ethip.c =================================================================== --- uspace/srv/net/ethip/ethip.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/ethip/ethip.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -77,5 +77,5 @@ int rc = loc_server_register(NAME); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering server."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server."); return rc; } @@ -96,5 +96,5 @@ char *svc_name = NULL; - log_msg(LVL_DEBUG, "ethip_iplink_init()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_iplink_init()"); iplink_srv_init(&nic->iplink); @@ -104,5 +104,5 @@ rc = asprintf(&svc_name, "net/eth%u", ++link_num); if (rc < 0) { - log_msg(LVL_ERROR, "Out of memory."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory."); goto error; } @@ -110,5 +110,5 @@ rc = loc_service_register(svc_name, &sid); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering service %s.", svc_name); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.", svc_name); goto error; } @@ -118,5 +118,5 @@ rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed resolving category 'iplink'."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'."); goto error; } @@ -124,5 +124,5 @@ rc = loc_service_add_to_cat(sid, iplink_cat); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed adding %s to category.", svc_name); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.", svc_name); goto error; } @@ -142,8 +142,8 @@ sid = (service_id_t)IPC_GET_ARG1(*icall); - log_msg(LVL_DEBUG, "ethip_client_conn(%u)", (unsigned)sid); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_client_conn(%u)", (unsigned)sid); nic = ethip_nic_find_by_iplink_sid(sid); if (nic == NULL) { - log_msg(LVL_WARN, "Uknown service ID."); + log_msg(LOG_DEFAULT, LVL_WARN, "Uknown service ID."); return; } @@ -154,5 +154,5 @@ static int ethip_open(iplink_srv_t *srv) { - log_msg(LVL_DEBUG, "ethip_open()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_open()"); return EOK; } @@ -160,5 +160,5 @@ static int ethip_close(iplink_srv_t *srv) { - log_msg(LVL_DEBUG, "ethip_close()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_close()"); return EOK; } @@ -173,9 +173,9 @@ int rc; - log_msg(LVL_DEBUG, "ethip_send()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()"); rc = arp_translate(nic, &sdu->lsrc, &sdu->ldest, &dest_mac_addr); if (rc != EOK) { - log_msg(LVL_WARN, "Failed to look up IP address 0x%" PRIx32, + log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IP address 0x%" PRIx32, sdu->ldest.ipv4); return rc; @@ -200,5 +200,5 @@ int ethip_received(iplink_srv_t *srv, void *data, size_t size) { - log_msg(LVL_DEBUG, "ethip_received(): srv=%p", srv); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received(): srv=%p", srv); ethip_nic_t *nic = (ethip_nic_t *)srv->arg; eth_frame_t frame; @@ -206,10 +206,10 @@ int rc; - log_msg(LVL_DEBUG, "ethip_received()"); - - log_msg(LVL_DEBUG, " - eth_pdu_decode"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received()"); + + log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode"); rc = eth_pdu_decode(data, size, &frame); if (rc != EOK) { - log_msg(LVL_DEBUG, " - eth_pdu_decode failed"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode failed"); return rc; } @@ -220,14 +220,14 @@ break; case ETYPE_IP: - log_msg(LVL_DEBUG, " - construct SDU"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU"); sdu.lsrc.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 1; sdu.ldest.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 4; sdu.data = frame.data; sdu.size = frame.size; - log_msg(LVL_DEBUG, " - call iplink_ev_recv"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv"); rc = iplink_ev_recv(&nic->iplink, &sdu); break; default: - log_msg(LVL_DEBUG, "Unknown ethertype 0x%" PRIx16, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Unknown ethertype 0x%" PRIx16, frame.etype_len); } @@ -239,5 +239,5 @@ static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu) { - log_msg(LVL_DEBUG, "ethip_get_mtu()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_get_mtu()"); *mtu = 1500; return EOK; @@ -248,5 +248,5 @@ ethip_nic_t *nic = (ethip_nic_t *)srv->arg; - log_msg(LVL_DEBUG, "ethip_addr_add(0x%" PRIx32 ")", addr->ipv4); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_add(0x%" PRIx32 ")", addr->ipv4); return ethip_nic_addr_add(nic, addr); } @@ -256,5 +256,5 @@ ethip_nic_t *nic = (ethip_nic_t *)srv->arg; - log_msg(LVL_DEBUG, "ethip_addr_remove(0x%" PRIx32 ")", addr->ipv4); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_remove(0x%" PRIx32 ")", addr->ipv4); return ethip_nic_addr_add(nic, addr); } @@ -266,5 +266,5 @@ printf(NAME ": HelenOS IP over Ethernet service\n"); - if (log_init(NAME, LVL_WARN) != EOK) { + if (log_init(NAME) != EOK) { printf(NAME ": Failed to initialize logging.\n"); return 1; Index: uspace/srv/net/ethip/ethip_nic.c =================================================================== --- uspace/srv/net/ethip/ethip_nic.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/ethip/ethip_nic.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -68,5 +68,5 @@ rc = loc_category_get_id("nic", &iplink_cat, IPC_FLAG_BLOCKING); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed resolving category 'nic'."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'nic'."); fibril_mutex_unlock(ðip_discovery_lock); return ENOENT; @@ -75,5 +75,5 @@ rc = loc_category_get_svcs(iplink_cat, &svcs, &count); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed getting list of IP links."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of IP links."); fibril_mutex_unlock(ðip_discovery_lock); return EIO; @@ -93,9 +93,9 @@ if (!already_known) { - log_msg(LVL_DEBUG, "Found NIC '%lu'", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Found NIC '%lu'", (unsigned long) svcs[i]); rc = ethip_nic_open(svcs[i]); if (rc != EOK) - log_msg(LVL_ERROR, "Could not open NIC."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Could not open NIC."); } } @@ -110,5 +110,5 @@ if (nic == NULL) { - log_msg(LVL_ERROR, "Failed allocating NIC structure. " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC structure. " "Out of memory."); return NULL; @@ -126,5 +126,5 @@ if (laddr == NULL) { - log_msg(LVL_ERROR, "Failed allocating NIC address structure. " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC address structure. " "Out of memory."); return NULL; @@ -153,5 +153,5 @@ nic_address_t nic_address; - log_msg(LVL_DEBUG, "ethip_nic_open()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_open()"); ethip_nic_t *nic = ethip_nic_new(); if (nic == NULL) @@ -160,5 +160,5 @@ int rc = loc_service_get_name(sid, &nic->svc_name); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed getting service name."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting service name."); goto error; } @@ -166,5 +166,5 @@ nic->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0); if (nic->sess == NULL) { - log_msg(LVL_ERROR, "Failed connecting '%s'", nic->svc_name); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting '%s'", nic->svc_name); goto error; } @@ -174,10 +174,10 @@ rc = nic_callback_create(nic->sess, ethip_nic_cb_conn, nic); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed creating callback connection " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating callback connection " "from '%s'", nic->svc_name); goto error; } - log_msg(LVL_DEBUG, "Opened NIC '%s'", nic->svc_name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened NIC '%s'", nic->svc_name); list_append(&nic->nic_list, ðip_nic_list); in_list = true; @@ -189,5 +189,5 @@ rc = nic_get_address(nic->sess, &nic_address); if (rc != EOK) { - log_msg(LVL_ERROR, "Error getting MAC address of NIC '%s'.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Error getting MAC address of NIC '%s'.", nic->svc_name); goto error; @@ -198,10 +198,10 @@ rc = nic_set_state(nic->sess, NIC_STATE_ACTIVE); if (rc != EOK) { - log_msg(LVL_ERROR, "Error activating NIC '%s'.", + log_msg(LOG_DEFAULT, LVL_ERROR, "Error activating NIC '%s'.", nic->svc_name); goto error; } - log_msg(LVL_DEBUG, "Initialized IP link service, MAC = 0x%" PRIx64, + log_msg(LOG_DEFAULT, LVL_DEBUG, "Initialized IP link service, MAC = 0x%" PRIx64, nic->mac_addr.addr); @@ -225,5 +225,5 @@ ipc_call_t *call) { - log_msg(LVL_DEBUG, "ethip_nic_addr_changed()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_changed()"); async_answer_0(callid, ENOTSUP); } @@ -236,21 +236,21 @@ size_t size; - log_msg(LVL_DEBUG, "ethip_nic_received() nic=%p", nic); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() nic=%p", nic); rc = async_data_write_accept(&data, false, 0, 0, 0, &size); if (rc != EOK) { - log_msg(LVL_DEBUG, "data_write_accept() failed"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "data_write_accept() failed"); return; } - log_msg(LVL_DEBUG, "Ethernet PDU contents (%zu bytes)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Ethernet PDU contents (%zu bytes)", size); - log_msg(LVL_DEBUG, "call ethip_received"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "call ethip_received"); rc = ethip_received(&nic->iplink, data, size); - log_msg(LVL_DEBUG, "free data"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "free data"); free(data); - log_msg(LVL_DEBUG, "ethip_nic_received() done, rc=%d", rc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_received() done, rc=%d", rc); async_answer_0(callid, rc); } @@ -259,5 +259,5 @@ ipc_call_t *call) { - log_msg(LVL_DEBUG, "ethip_nic_device_state()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_device_state()"); async_answer_0(callid, ENOTSUP); } @@ -267,5 +267,5 @@ ethip_nic_t *nic = (ethip_nic_t *)arg; - log_msg(LVL_DEBUG, "ethnip_nic_cb_conn()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethnip_nic_cb_conn()"); while (true) { @@ -298,5 +298,5 @@ int rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering callback for NIC " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for NIC " "discovery (%d).", rc); return rc; @@ -308,19 +308,19 @@ ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t iplink_sid) { - log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid(%u)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid(%u)", (unsigned) iplink_sid); list_foreach(ethip_nic_list, link) { - log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid - element"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - element"); ethip_nic_t *nic = list_get_instance(link, ethip_nic_t, nic_list); if (nic->iplink_sid == iplink_sid) { - log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid - found %p", nic); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - found %p", nic); return nic; } } - log_msg(LVL_DEBUG, "ethip_nic_find_by_iplink_sid - not found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - not found"); return NULL; } @@ -329,7 +329,7 @@ { int rc; - log_msg(LVL_DEBUG, "ethip_nic_send(size=%zu)", size); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_send(size=%zu)", size); rc = nic_send_frame(nic->sess, data, size); - log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "nic_send_frame -> %d", rc); return rc; } @@ -339,5 +339,5 @@ ethip_link_addr_t *laddr; - log_msg(LVL_DEBUG, "ethip_nic_addr_add()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()"); laddr = ethip_nic_addr_new(addr); if (laddr == NULL) @@ -352,5 +352,5 @@ ethip_link_addr_t *laddr; - log_msg(LVL_DEBUG, "ethip_nic_addr_remove()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()"); laddr = ethip_nic_addr_find(nic, addr); @@ -366,5 +366,5 @@ iplink_srv_addr_t *addr) { - log_msg(LVL_DEBUG, "ethip_nic_addr_find()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()"); list_foreach(nic->addr_list, link) { Index: uspace/srv/net/ethip/pdu.c =================================================================== --- uspace/srv/net/ethip/pdu.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/ethip/pdu.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -69,8 +69,8 @@ frame->size); - log_msg(LVL_DEBUG, "Encoding Ethernet frame " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoding Ethernet frame " "src=%" PRIx64 " dest=%" PRIx64 " etype=%x", frame->src.addr, frame->dest.addr, frame->etype_len); - log_msg(LVL_DEBUG, "Encoded Ethernet frame (%zu bytes)", size); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoded Ethernet frame (%zu bytes)", size); *rdata = data; @@ -84,8 +84,8 @@ eth_header_t *hdr; - log_msg(LVL_DEBUG, "eth_pdu_decode()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "eth_pdu_decode()"); if (size < sizeof(eth_header_t)) { - log_msg(LVL_DEBUG, "PDU too short (%zu)", size); + log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size); return EINVAL; } @@ -105,8 +105,8 @@ frame->size); - log_msg(LVL_DEBUG, "Decoding Ethernet frame " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoding Ethernet frame " "src=%" PRIx64 " dest=%" PRIx64 " etype=%x", frame->src.addr, frame->dest.addr, frame->etype_len); - log_msg(LVL_DEBUG, "Decoded Ethernet frame payload (%zu bytes)", frame->size); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoded Ethernet frame payload (%zu bytes)", frame->size); return EOK; @@ -145,5 +145,5 @@ uint16_t fopcode; - log_msg(LVL_DEBUG, "arp_pdu_encode()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_pdu_encode()"); size = sizeof(arp_eth_packet_fmt_t); @@ -185,8 +185,8 @@ arp_eth_packet_fmt_t *pfmt; - log_msg(LVL_DEBUG, "arp_pdu_decode()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_pdu_decode()"); if (size < sizeof(arp_eth_packet_fmt_t)) { - log_msg(LVL_DEBUG, "ARP PDU too short (%zu)", size); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU too short (%zu)", size); return EINVAL; } @@ -195,5 +195,5 @@ if (uint16_t_be2host(pfmt->hw_addr_space) != AHRD_ETHERNET) { - log_msg(LVL_DEBUG, "HW address space != %u (%" PRIu16 ")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "HW address space != %u (%" PRIu16 ")", AHRD_ETHERNET, uint16_t_be2host(pfmt->hw_addr_space)); return EINVAL; @@ -201,5 +201,5 @@ if (uint16_t_be2host(pfmt->proto_addr_space) != 0x0800) { - log_msg(LVL_DEBUG, "Proto address space != %u (%" PRIu16 ")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Proto address space != %u (%" PRIu16 ")", ETYPE_IP, uint16_t_be2host(pfmt->proto_addr_space)); return EINVAL; @@ -207,5 +207,5 @@ if (pfmt->hw_addr_size != ETH_ADDR_SIZE) { - log_msg(LVL_DEBUG, "HW address size != %zu (%zu)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "HW address size != %zu (%zu)", (size_t)ETH_ADDR_SIZE, (size_t)pfmt->hw_addr_size); return EINVAL; @@ -213,5 +213,5 @@ if (pfmt->proto_addr_size != IPV4_ADDR_SIZE) { - log_msg(LVL_DEBUG, "Proto address size != %zu (%zu)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Proto address size != %zu (%zu)", (size_t)IPV4_ADDR_SIZE, (size_t)pfmt->proto_addr_size); return EINVAL; @@ -222,5 +222,5 @@ case AOP_REPLY: packet->opcode = aop_reply; break; default: - log_msg(LVL_DEBUG, "Invalid ARP opcode (%" PRIu16 ")", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Invalid ARP opcode (%" PRIu16 ")", uint16_t_be2host(pfmt->opcode)); return EINVAL; @@ -233,5 +233,5 @@ packet->target_proto_addr.ipv4 = uint32_t_be2host(pfmt->target_proto_addr); - log_msg(LVL_DEBUG, "packet->tpa = %x\n", pfmt->target_proto_addr); + log_msg(LOG_DEFAULT, LVL_DEBUG, "packet->tpa = %x\n", pfmt->target_proto_addr); return EOK; Index: uspace/srv/net/inetsrv/addrobj.c =================================================================== --- uspace/srv/net/inetsrv/addrobj.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/addrobj.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -59,5 +59,5 @@ if (addr == NULL) { - log_msg(LVL_ERROR, "Failed allocating address object. " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating address object. " "Out of memory."); return NULL; @@ -114,5 +114,5 @@ uint32_t mask; - log_msg(LVL_DEBUG, "inet_addrobj_find(%x)", (unsigned)addr->ipv4); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find(%x)", (unsigned)addr->ipv4); fibril_mutex_lock(&addr_list_lock); @@ -125,5 +125,5 @@ if ((naddr->naddr.ipv4 & mask) == (addr->ipv4 & mask)) { fibril_mutex_unlock(&addr_list_lock); - log_msg(LVL_DEBUG, "inet_addrobj_find: found %p", + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p", naddr); return naddr; @@ -131,5 +131,5 @@ } - log_msg(LVL_DEBUG, "inet_addrobj_find: Not found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: Not found"); fibril_mutex_unlock(&addr_list_lock); @@ -147,5 +147,5 @@ assert(fibril_mutex_is_locked(&addr_list_lock)); - log_msg(LVL_DEBUG, "inet_addrobj_find_by_name_locked('%s', '%s')", + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked('%s', '%s')", name, ilink->svc_name); @@ -155,5 +155,5 @@ if (naddr->ilink == ilink && str_cmp(naddr->name, name) == 0) { - log_msg(LVL_DEBUG, "inet_addrobj_find_by_name_locked: found %p", + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: found %p", naddr); return naddr; @@ -161,5 +161,5 @@ } - log_msg(LVL_DEBUG, "inet_addrobj_find_by_name_locked: Not found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name_locked: Not found"); return NULL; @@ -177,5 +177,5 @@ inet_addrobj_t *aobj; - log_msg(LVL_DEBUG, "inet_addrobj_find_by_name('%s', '%s')", + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find_by_name('%s', '%s')", name, ilink->svc_name); @@ -194,5 +194,5 @@ inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t id) { - log_msg(LVL_DEBUG, "inet_addrobj_get_by_id(%zu)", (size_t)id); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_get_by_id(%zu)", (size_t)id); fibril_mutex_lock(&addr_list_lock); Index: uspace/srv/net/inetsrv/icmp.c =================================================================== --- uspace/srv/net/inetsrv/icmp.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/icmp.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -57,5 +57,5 @@ uint8_t type; - log_msg(LVL_DEBUG, "icmp_recv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv()"); if (dgram->size < 1) @@ -84,5 +84,5 @@ int rc; - log_msg(LVL_DEBUG, "icmp_recv_echo_request()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_request()"); if (dgram->size < sizeof(icmp_echo_t)) @@ -124,5 +124,5 @@ uint16_t ident; - log_msg(LVL_DEBUG, "icmp_recv_echo_reply()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()"); if (dgram->size < sizeof(icmp_echo_t)) Index: uspace/srv/net/inetsrv/inet_link.c =================================================================== --- uspace/srv/net/inetsrv/inet_link.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/inet_link.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -64,14 +64,14 @@ int rc; - log_msg(LVL_DEBUG, "inet_iplink_recv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()"); rc = inet_pdu_decode(sdu->data, sdu->size, &packet); if (rc != EOK) { - log_msg(LVL_DEBUG, "failed decoding PDU"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "failed decoding PDU"); return rc; } - log_msg(LVL_DEBUG, "call inet_recv_packet()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet()"); rc = inet_recv_packet(&packet); - log_msg(LVL_DEBUG, "call inet_recv_packet -> %d", rc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet -> %d", rc); free(packet.data); @@ -91,5 +91,5 @@ rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed resolving category 'iplink'."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'."); fibril_mutex_unlock(&inet_discovery_lock); return ENOENT; @@ -98,5 +98,5 @@ rc = loc_category_get_svcs(iplink_cat, &svcs, &count); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed getting list of IP links."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of IP links."); fibril_mutex_unlock(&inet_discovery_lock); return EIO; @@ -116,9 +116,9 @@ if (!already_known) { - log_msg(LVL_DEBUG, "Found IP link '%lu'", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Found IP link '%lu'", (unsigned long) svcs[i]); rc = inet_link_open(svcs[i]); if (rc != EOK) - log_msg(LVL_ERROR, "Could not open IP link."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Could not open IP link."); } } @@ -133,5 +133,5 @@ if (ilink == NULL) { - log_msg(LVL_ERROR, "Failed allocating link structure. " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating link structure. " "Out of memory."); return NULL; @@ -156,5 +156,5 @@ int rc; - log_msg(LVL_DEBUG, "inet_link_open()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_link_open()"); ilink = inet_link_new(); if (ilink == NULL) @@ -166,5 +166,5 @@ rc = loc_service_get_name(sid, &ilink->svc_name); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed getting service name."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting service name."); goto error; } @@ -172,5 +172,5 @@ ilink->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0); if (ilink->sess == NULL) { - log_msg(LVL_ERROR, "Failed connecting '%s'", ilink->svc_name); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting '%s'", ilink->svc_name); goto error; } @@ -178,5 +178,5 @@ rc = iplink_open(ilink->sess, &inet_iplink_ev_ops, &ilink->iplink); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed opening IP link '%s'", + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed opening IP link '%s'", ilink->svc_name); goto error; @@ -185,10 +185,10 @@ rc = iplink_get_mtu(ilink->iplink, &ilink->def_mtu); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed determinning MTU of link '%s'", + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed determinning MTU of link '%s'", ilink->svc_name); goto error; } - log_msg(LVL_DEBUG, "Opened IP link '%s'", ilink->svc_name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened IP link '%s'", ilink->svc_name); list_append(&ilink->link_list, &inet_link_list); @@ -209,5 +209,5 @@ rc = inet_addrobj_add(addr); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed setting IP address on internet link."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link."); inet_addrobj_delete(addr); /* XXX Roll back */ @@ -218,5 +218,5 @@ rc = iplink_addr_add(ilink->iplink, &iaddr); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed setting IP address on internet link."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link."); inet_addrobj_remove(addr); inet_addrobj_delete(addr); @@ -245,5 +245,5 @@ rc = loc_register_cat_change_cb(inet_link_cat_change_cb); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering callback for IP link " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for IP link " "discovery (%d).", rc); return rc; Index: uspace/srv/net/inetsrv/inetcfg.c =================================================================== --- uspace/srv/net/inetsrv/inetcfg.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/inetcfg.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -61,5 +61,5 @@ ilink = inet_link_get_by_id(link_id); if (ilink == NULL) { - log_msg(LVL_DEBUG, "Link %lu not found.", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %lu not found.", (unsigned long) link_id); return ENOENT; @@ -77,5 +77,5 @@ rc = inet_addrobj_add(addr); if (rc != EOK) { - log_msg(LVL_DEBUG, "Duplicate address name '%s'.", addr->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Duplicate address name '%s'.", addr->name); inet_addrobj_delete(addr); return rc; @@ -85,5 +85,5 @@ rc = iplink_addr_add(ilink->iplink, &iaddr); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed setting IP address on internet link."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link."); inet_addrobj_remove(addr); inet_addrobj_delete(addr); @@ -130,5 +130,5 @@ ilink = inet_link_get_by_id(link_id); if (ilink == NULL) { - log_msg(LVL_DEBUG, "Link %zu not found.", (size_t) link_id); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %zu not found.", (size_t) link_id); return ENOENT; } @@ -136,5 +136,5 @@ addr = inet_addrobj_find_by_name(name, ilink); if (addr == NULL) { - log_msg(LVL_DEBUG, "Address '%s' not found.", name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Address '%s' not found.", name); return ENOENT; } @@ -228,5 +228,5 @@ sroute = inet_sroute_find_by_name(name); if (sroute == NULL) { - log_msg(LVL_DEBUG, "Static route '%s' not found.", name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Static route '%s' not found.", name); return ENOENT; } @@ -245,5 +245,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_addr_create_static_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()"); rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN, @@ -269,5 +269,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_addr_delete_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_delete_srv()"); addr_id = IPC_GET_ARG1(*call); @@ -287,5 +287,5 @@ addr_id = IPC_GET_ARG1(*call); - log_msg(LVL_DEBUG, "inetcfg_addr_get_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()"); ainfo.naddr.ipv4 = 0; @@ -321,5 +321,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_addr_get_id_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_id_srv()"); link_id = IPC_GET_ARG1(*call); @@ -348,5 +348,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_get_addr_list_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_addr_list_srv()"); if (!async_data_read_receive(&rcallid, &max_size)) { @@ -382,5 +382,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_get_link_list_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_link_list_srv()"); if (!async_data_read_receive(&rcallid, &max_size)) { @@ -415,5 +415,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_get_sroute_list_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_get_sroute_list_srv()"); if (!async_data_read_receive(&rcallid, &max_size)) { @@ -449,5 +449,5 @@ link_id = IPC_GET_ARG1(*call); - log_msg(LVL_DEBUG, "inetcfg_link_get_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_get_srv()"); linfo.name = NULL; @@ -482,5 +482,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_sroute_create_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()"); rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN, @@ -506,5 +506,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_sroute_delete_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_delete_srv()"); sroute_id = IPC_GET_ARG1(*call); @@ -524,5 +524,5 @@ sroute_id = IPC_GET_ARG1(*call); - log_msg(LVL_DEBUG, "inetcfg_sroute_get_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()"); srinfo.dest.ipv4 = 0; @@ -557,5 +557,5 @@ int rc; - log_msg(LVL_DEBUG, "inetcfg_sroute_get_id_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_id_srv()"); rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN, @@ -574,5 +574,5 @@ void inet_cfg_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg) { - log_msg(LVL_DEBUG, "inet_cfg_conn()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_cfg_conn()"); /* Accept the connection */ Index: uspace/srv/net/inetsrv/inetping.c =================================================================== --- uspace/srv/net/inetsrv/inetping.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/inetping.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -76,5 +76,5 @@ client = inetping_client_find(ident); if (client == NULL) { - log_msg(LVL_DEBUG, "Unknown ICMP ident. Dropping."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Unknown ICMP ident. Dropping."); return ENOENT; } @@ -107,5 +107,5 @@ int rc; - log_msg(LVL_DEBUG, "inetping_send_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()"); rc = async_data_write_accept((void **) &sdu.data, false, 0, 0, 0, @@ -133,5 +133,5 @@ int rc; - log_msg(LVL_DEBUG, "inetping_get_srcaddr_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()"); remote.ipv4 = IPC_GET_ARG1(*call); @@ -192,5 +192,5 @@ int rc; - log_msg(LVL_DEBUG, "inetping_conn()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()"); /* Accept the connection */ Index: uspace/srv/net/inetsrv/inetsrv.c =================================================================== --- uspace/srv/net/inetsrv/inetsrv.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/inetsrv.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -66,5 +66,5 @@ static int inet_init(void) { - log_msg(LVL_DEBUG, "inet_init()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_init()"); async_set_client_connection(inet_client_conn); @@ -72,5 +72,5 @@ int rc = loc_server_register(NAME); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering server (%d).", rc); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server (%d).", rc); return EEXIST; } @@ -80,5 +80,5 @@ INET_PORT_DEFAULT); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering service (%d).", rc); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc); return EEXIST; } @@ -87,5 +87,5 @@ INET_PORT_CFG); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering service (%d).", rc); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc); return EEXIST; } @@ -94,5 +94,5 @@ INET_PORT_PING); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering service (%d).", rc); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc); return EEXIST; } @@ -108,5 +108,5 @@ ipc_call_t *call) { - log_msg(LVL_DEBUG, "inet_callback_create_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_callback_create_srv()"); async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE); @@ -143,5 +143,5 @@ if (dir->aobj == NULL) { - log_msg(LVL_DEBUG, "inet_send: No route to destination."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send: No route to destination."); return ENOENT; } @@ -194,5 +194,5 @@ int rc; - log_msg(LVL_DEBUG, "inet_get_srcaddr_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()"); remote.ipv4 = IPC_GET_ARG1(*call); @@ -212,5 +212,5 @@ int rc; - log_msg(LVL_DEBUG, "inet_send_srv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()"); dgram.src.ipv4 = IPC_GET_ARG1(*call); @@ -238,5 +238,5 @@ proto = IPC_GET_ARG1(*call); - log_msg(LVL_DEBUG, "inet_set_proto_srv(%lu)", (unsigned long) proto); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_set_proto_srv(%lu)", (unsigned long) proto); if (proto > UINT8_MAX) { @@ -272,5 +272,5 @@ inet_client_t client; - log_msg(LVL_DEBUG, "inet_default_conn()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_default_conn()"); /* Accept the connection */ @@ -378,5 +378,5 @@ inet_client_t *client; - log_msg(LVL_DEBUG, "inet_recv_dgram_local()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_recv_dgram_local()"); /* ICMP messages are handled internally */ @@ -386,5 +386,5 @@ client = inet_client_find(proto); if (client == NULL) { - log_msg(LVL_DEBUG, "No client found for protocol 0x%" PRIx8, + log_msg(LOG_DEFAULT, LVL_DEBUG, "No client found for protocol 0x%" PRIx8, proto); return ENOENT; @@ -428,5 +428,5 @@ printf(NAME ": HelenOS Internet Protocol service\n"); - if (log_init(NAME, LVL_WARN) != EOK) { + if (log_init(NAME) != EOK) { printf(NAME ": Failed to initialize logging.\n"); return 1; Index: uspace/srv/net/inetsrv/pdu.c =================================================================== --- uspace/srv/net/inetsrv/pdu.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/pdu.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -204,8 +204,8 @@ uint16_t foff; - log_msg(LVL_DEBUG, "inet_pdu_decode()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()"); if (size < sizeof(ip_header_t)) { - log_msg(LVL_DEBUG, "PDU too short (%zu)", size); + log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size); return EINVAL; } @@ -216,5 +216,5 @@ hdr->ver_ihl); if (version != 4) { - log_msg(LVL_DEBUG, "Version (%d) != 4", version); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Version (%d) != 4", version); return EINVAL; } @@ -222,10 +222,10 @@ tot_len = uint16_t_be2host(hdr->tot_len); if (tot_len < sizeof(ip_header_t)) { - log_msg(LVL_DEBUG, "Total Length too small (%zu)", tot_len); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length too small (%zu)", tot_len); return EINVAL; } if (tot_len > size) { - log_msg(LVL_DEBUG, "Total Length = %zu > PDU size = %zu", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length = %zu > PDU size = %zu", tot_len, size); return EINVAL; @@ -256,5 +256,5 @@ packet->data = calloc(packet->size, 1); if (packet->data == NULL) { - log_msg(LVL_WARN, "Out of memory."); + log_msg(LOG_DEFAULT, LVL_WARN, "Out of memory."); return ENOMEM; } Index: uspace/srv/net/inetsrv/reass.c =================================================================== --- uspace/srv/net/inetsrv/reass.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/reass.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -86,5 +86,5 @@ int rc; - log_msg(LVL_DEBUG, "inet_reass_queue_packet()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_reass_queue_packet()"); fibril_mutex_lock(&reass_dgram_map_lock); @@ -95,5 +95,5 @@ /* Only happens when we are out of memory */ fibril_mutex_unlock(&reass_dgram_map_lock); - log_msg(LVL_DEBUG, "Allocation failed, packet dropped."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Allocation failed, packet dropped."); return ENOMEM; } Index: uspace/srv/net/inetsrv/sroute.c =================================================================== --- uspace/srv/net/inetsrv/sroute.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/inetsrv/sroute.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -57,5 +57,5 @@ if (sroute == NULL) { - log_msg(LVL_ERROR, "Failed allocating static route object. " + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating static route object. " "Out of memory."); return NULL; @@ -100,5 +100,5 @@ inet_sroute_t *best; - log_msg(LVL_DEBUG, "inet_sroute_find(%x)", (unsigned)addr->ipv4); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find(%x)", (unsigned)addr->ipv4); fibril_mutex_lock(&sroute_list_lock); @@ -117,5 +117,5 @@ if ((sroute->dest.ipv4 & mask) == (addr->ipv4 & mask)) { fibril_mutex_unlock(&sroute_list_lock); - log_msg(LVL_DEBUG, "inet_sroute_find: found %p", + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found %p", sroute); return sroute; @@ -123,5 +123,5 @@ } - log_msg(LVL_DEBUG, "inet_sroute_find: Not found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found"); fibril_mutex_unlock(&sroute_list_lock); @@ -136,5 +136,5 @@ inet_sroute_t *inet_sroute_find_by_name(const char *name) { - log_msg(LVL_DEBUG, "inet_sroute_find_by_name('%s')", + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find_by_name('%s')", name); @@ -147,5 +147,5 @@ if (str_cmp(sroute->name, name) == 0) { fibril_mutex_unlock(&sroute_list_lock); - log_msg(LVL_DEBUG, "inet_sroute_find_by_name: found %p", + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find_by_name: found %p", sroute); return sroute; @@ -153,5 +153,5 @@ } - log_msg(LVL_DEBUG, "inet_sroute_find_by_name: Not found"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find_by_name: Not found"); fibril_mutex_unlock(&sroute_list_lock); @@ -166,5 +166,5 @@ inet_sroute_t *inet_sroute_get_by_id(sysarg_t id) { - log_msg(LVL_DEBUG, "inet_sroute_get_by_id(%zu)", (size_t)id); + log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_get_by_id(%zu)", (size_t)id); fibril_mutex_lock(&sroute_list_lock); Index: uspace/srv/net/loopip/loopip.c =================================================================== --- uspace/srv/net/loopip/loopip.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/loopip/loopip.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -75,5 +75,5 @@ { while (true) { - log_msg(LVL_DEBUG, "loopip_recv_fibril(): Wait for one item"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_recv_fibril(): Wait for one item"); link_t *link = prodcons_consume(&loopip_rcv_queue); rqueue_entry_t *rqe = list_get_instance(link, rqueue_entry_t, link); @@ -96,5 +96,5 @@ rc = loc_server_register(NAME); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering server."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server."); return rc; } @@ -108,5 +108,5 @@ rc = loc_service_register(svc_name, &sid); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed registering service %s.", svc_name); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.", svc_name); return rc; } @@ -114,5 +114,5 @@ rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed resolving category 'iplink'."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'."); return rc; } @@ -120,5 +120,5 @@ rc = loc_service_add_to_cat(sid, iplink_cat); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed adding %s to category.", svc_name); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.", svc_name); return rc; } @@ -135,5 +135,5 @@ static void loopip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg) { - log_msg(LVL_DEBUG, "loopip_client_conn()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_client_conn()"); iplink_conn(iid, icall, &loopip_iplink); } @@ -141,5 +141,5 @@ static int loopip_open(iplink_srv_t *srv) { - log_msg(LVL_DEBUG, "loopip_open()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_open()"); return EOK; } @@ -147,5 +147,5 @@ static int loopip_close(iplink_srv_t *srv) { - log_msg(LVL_DEBUG, "loopip_close()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_close()"); return EOK; } @@ -155,5 +155,5 @@ rqueue_entry_t *rqe; - log_msg(LVL_DEBUG, "loopip_send()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_send()"); rqe = calloc(1, sizeof(rqueue_entry_t)); @@ -184,5 +184,5 @@ static int loopip_get_mtu(iplink_srv_t *srv, size_t *mtu) { - log_msg(LVL_DEBUG, "loopip_get_mtu()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_get_mtu()"); *mtu = 1500; return EOK; @@ -191,5 +191,5 @@ static int loopip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr) { - log_msg(LVL_DEBUG, "loopip_addr_add(0x%" PRIx32 ")", addr->ipv4); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_add(0x%" PRIx32 ")", addr->ipv4); return EOK; } @@ -197,5 +197,5 @@ static int loopip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr) { - log_msg(LVL_DEBUG, "loopip_addr_remove(0x%" PRIx32 ")", addr->ipv4); + log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_remove(0x%" PRIx32 ")", addr->ipv4); return EOK; } @@ -207,5 +207,5 @@ printf(NAME ": HelenOS loopback IP link provider\n"); - if (log_init(NAME, LVL_WARN) != EOK) { + if (log_init(NAME) != EOK) { printf(NAME ": Failed to initialize logging.\n"); return 1; Index: uspace/srv/net/tcp/conn.c =================================================================== --- uspace/srv/net/tcp/conn.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/conn.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -164,5 +164,5 @@ static void tcp_conn_free(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn); tcp_tqueue_fini(&conn->retransmit); @@ -184,5 +184,5 @@ void tcp_conn_addref(tcp_conn_t *conn) { - log_msg(LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn); + log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn); atomic_inc(&conn->refcnt); } @@ -196,5 +196,5 @@ void tcp_conn_delref(tcp_conn_t *conn) { - log_msg(LVL_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn); + log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn); if (atomic_predec(&conn->refcnt) == 0) @@ -211,5 +211,5 @@ void tcp_conn_delete(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn); assert(conn->deleted == false); @@ -245,5 +245,5 @@ tcp_cstate_t old_state; - log_msg(LVL_DEBUG, "tcp_conn_state_set(%p)", conn); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set(%p)", conn); old_state = conn->cstate; @@ -253,8 +253,8 @@ /* Run user callback function */ if (conn->cstate_cb != NULL) { - log_msg(LVL_DEBUG, "tcp_conn_state_set() - run user CB"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - run user CB"); conn->cstate_cb(conn, conn->cstate_cb_arg); } else { - log_msg(LVL_DEBUG, "tcp_conn_state_set() - no user CB"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - no user CB"); } @@ -293,13 +293,13 @@ case st_syn_received: case st_established: - log_msg(LVL_DEBUG, "%s: FIN sent -> Fin-Wait-1", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN sent -> Fin-Wait-1", conn->name); tcp_conn_state_set(conn, st_fin_wait_1); break; case st_close_wait: - log_msg(LVL_DEBUG, "%s: FIN sent -> Last-Ack", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN sent -> Last-Ack", conn->name); tcp_conn_state_set(conn, st_last_ack); break; default: - log_msg(LVL_ERROR, "%s: Connection state %d", conn->name, + log_msg(LOG_DEFAULT, LVL_ERROR, "%s: Connection state %d", conn->name, conn->cstate); assert(false); @@ -312,5 +312,5 @@ static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt) { - log_msg(LVL_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))", + log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))", sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port); @@ -323,5 +323,5 @@ return false; - log_msg(LVL_DEBUG2, " -> match"); + log_msg(LOG_DEFAULT, LVL_DEBUG2, " -> match"); return true; @@ -331,5 +331,5 @@ static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern) { - log_msg(LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern); + log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern); if (!tcp_socket_match(&sp->local, &pattern->local)) @@ -353,5 +353,5 @@ tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *sp) { - log_msg(LVL_DEBUG, "tcp_conn_find_ref(%p)", sp); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp); fibril_mutex_lock(&conn_list_lock); @@ -360,5 +360,5 @@ tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link); tcp_sockpair_t *csp = &conn->ident; - log_msg(LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))", + log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))", csp->foreign.addr.ipv4, csp->foreign.port, csp->local.addr.ipv4, csp->local.port); @@ -380,5 +380,5 @@ static void tcp_conn_reset(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "%s: tcp_conn_reset()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_reset()", conn->name); tcp_conn_state_set(conn, st_closed); conn->reset = true; @@ -398,5 +398,5 @@ { /* TODO */ - log_msg(LVL_DEBUG, "%s: tcp_reset_signal()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_reset_signal()", conn->name); } @@ -422,5 +422,5 @@ return true; case st_closed: - log_msg(LVL_WARN, "state=%d", (int) conn->cstate); + log_msg(LOG_DEFAULT, LVL_WARN, "state=%d", (int) conn->cstate); assert(false); } @@ -436,13 +436,13 @@ static void tcp_conn_sa_listen(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "tcp_conn_sa_listen(%p, %p)", conn, seg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_listen(%p, %p)", conn, seg); if ((seg->ctrl & CTL_RST) != 0) { - log_msg(LVL_DEBUG, "Ignoring incoming RST."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Ignoring incoming RST."); return; } if ((seg->ctrl & CTL_ACK) != 0) { - log_msg(LVL_DEBUG, "Incoming ACK, send acceptable RST."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Incoming ACK, send acceptable RST."); tcp_reply_rst(&conn->ident, seg); return; @@ -450,9 +450,9 @@ if ((seg->ctrl & CTL_SYN) == 0) { - log_msg(LVL_DEBUG, "SYN not present. Ignoring segment."); - return; - } - - log_msg(LVL_DEBUG, "Got SYN, sending SYN, ACK."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "SYN not present. Ignoring segment."); + return; + } + + log_msg(LOG_DEFAULT, LVL_DEBUG, "Got SYN, sending SYN, ACK."); conn->rcv_nxt = seg->seq + 1; @@ -460,8 +460,8 @@ - log_msg(LVL_DEBUG, "rcv_nxt=%u", conn->rcv_nxt); + log_msg(LOG_DEFAULT, LVL_DEBUG, "rcv_nxt=%u", conn->rcv_nxt); if (seg->len > 1) - log_msg(LVL_WARN, "SYN combined with data, ignoring data."); + log_msg(LOG_DEFAULT, LVL_WARN, "SYN combined with data, ignoring data."); /* XXX select ISS */ @@ -493,15 +493,15 @@ static void tcp_conn_sa_syn_sent(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "tcp_conn_sa_syn_sent(%p, %p)", conn, seg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_syn_sent(%p, %p)", conn, seg); if ((seg->ctrl & CTL_ACK) != 0) { - log_msg(LVL_DEBUG, "snd_una=%u, seg.ack=%u, snd_nxt=%u", + log_msg(LOG_DEFAULT, LVL_DEBUG, "snd_una=%u, seg.ack=%u, snd_nxt=%u", conn->snd_una, seg->ack, conn->snd_nxt); if (!seq_no_ack_acceptable(conn, seg->ack)) { if ((seg->ctrl & CTL_RST) == 0) { - log_msg(LVL_WARN, "ACK not acceptable, send RST"); + log_msg(LOG_DEFAULT, LVL_WARN, "ACK not acceptable, send RST"); tcp_reply_rst(&conn->ident, seg); } else { - log_msg(LVL_WARN, "RST,ACK not acceptable, drop"); + log_msg(LOG_DEFAULT, LVL_WARN, "RST,ACK not acceptable, drop"); } return; @@ -512,5 +512,5 @@ /* If we get here, we have either an acceptable ACK or no ACK */ if ((seg->ctrl & CTL_ACK) != 0) { - log_msg(LVL_DEBUG, "%s: Connection reset. -> Closed", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Connection reset. -> Closed", conn->name); /* Reset connection */ @@ -518,5 +518,5 @@ return; } else { - log_msg(LVL_DEBUG, "%s: RST without ACK, drop", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: RST without ACK, drop", conn->name); return; @@ -527,5 +527,5 @@ if ((seg->ctrl & CTL_SYN) == 0) { - log_msg(LVL_DEBUG, "No SYN bit, ignoring segment."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "No SYN bit, ignoring segment."); return; } @@ -544,5 +544,5 @@ } - log_msg(LVL_DEBUG, "Sent SYN, got SYN."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Sent SYN, got SYN."); /* @@ -551,5 +551,5 @@ * will always be accepted as new window setting. */ - log_msg(LVL_DEBUG, "SND.WND := %" PRIu32 ", SND.WL1 := %" PRIu32 ", " + log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.WND := %" PRIu32 ", SND.WL1 := %" PRIu32 ", " "SND.WL2 = %" PRIu32, seg->wnd, seg->seq, seg->seq); conn->snd_wnd = seg->wnd; @@ -558,9 +558,9 @@ if (seq_no_syn_acked(conn)) { - log_msg(LVL_DEBUG, "%s: syn acked -> Established", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: syn acked -> Established", conn->name); tcp_conn_state_set(conn, st_established); tcp_tqueue_ctrl_seg(conn, CTL_ACK /* XXX */); } else { - log_msg(LVL_DEBUG, "%s: syn not acked -> Syn-Received", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: syn not acked -> Syn-Received", conn->name); tcp_conn_state_set(conn, st_syn_received); @@ -582,9 +582,9 @@ tcp_segment_t *pseg; - log_msg(LVL_DEBUG, "tcp_conn_sa_seq(%p, %p)", conn, seg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_seq(%p, %p)", conn, seg); /* Discard unacceptable segments ("old duplicates") */ if (!seq_no_segment_acceptable(conn, seg)) { - log_msg(LVL_DEBUG, "Replying ACK to unacceptable segment."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Replying ACK to unacceptable segment."); tcp_tqueue_ctrl_seg(conn, CTL_ACK); tcp_segment_delete(seg); @@ -682,5 +682,5 @@ assert(seq_no_in_rcv_wnd(conn, seg->seq)); - log_msg(LVL_WARN, "SYN is in receive window, should send reset. XXX"); + log_msg(LOG_DEFAULT, LVL_WARN, "SYN is in receive window, should send reset. XXX"); /* @@ -705,5 +705,5 @@ if (!seq_no_ack_acceptable(conn, seg->ack)) { /* ACK is not acceptable, send RST. */ - log_msg(LVL_WARN, "Segment ACK not acceptable, sending RST."); + log_msg(LOG_DEFAULT, LVL_WARN, "Segment ACK not acceptable, sending RST."); tcp_reply_rst(&conn->ident, seg); tcp_segment_delete(seg); @@ -711,5 +711,5 @@ } - log_msg(LVL_DEBUG, "%s: SYN ACKed -> Established", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: SYN ACKed -> Established", conn->name); tcp_conn_state_set(conn, st_established); @@ -730,14 +730,14 @@ static cproc_t tcp_conn_seg_proc_ack_est(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "tcp_conn_seg_proc_ack_est(%p, %p)", conn, seg); - - log_msg(LVL_DEBUG, "SEG.ACK=%u, SND.UNA=%u, SND.NXT=%u", + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_seg_proc_ack_est(%p, %p)", conn, seg); + + log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.ACK=%u, SND.UNA=%u, SND.NXT=%u", (unsigned)seg->ack, (unsigned)conn->snd_una, (unsigned)conn->snd_nxt); if (!seq_no_ack_acceptable(conn, seg->ack)) { - log_msg(LVL_DEBUG, "ACK not acceptable."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "ACK not acceptable."); if (!seq_no_ack_duplicate(conn, seg->ack)) { - log_msg(LVL_WARN, "Not acceptable, not duplicate. " + log_msg(LOG_DEFAULT, LVL_WARN, "Not acceptable, not duplicate. " "Send ACK and drop."); /* Not acceptable, not duplicate. Send ACK and drop. */ @@ -746,5 +746,5 @@ return cp_done; } else { - log_msg(LVL_DEBUG, "Ignoring duplicate ACK."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Ignoring duplicate ACK."); } } else { @@ -758,5 +758,5 @@ conn->snd_wl2 = seg->ack; - log_msg(LVL_DEBUG, "Updating send window, SND.WND=%" PRIu32 + log_msg(LOG_DEFAULT, LVL_DEBUG, "Updating send window, SND.WND=%" PRIu32 ", SND.WL1=%" PRIu32 ", SND.WL2=%" PRIu32, conn->snd_wnd, conn->snd_wl1, conn->snd_wl2); @@ -785,5 +785,5 @@ if (conn->fin_is_acked) { - log_msg(LVL_DEBUG, "%s: FIN acked -> Fin-Wait-2", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Fin-Wait-2", conn->name); tcp_conn_state_set(conn, st_fin_wait_2); } @@ -850,5 +850,5 @@ if (conn->fin_is_acked) { - log_msg(LVL_DEBUG, "%s: FIN acked -> Closed", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Closed", conn->name); tcp_conn_remove(conn); tcp_conn_state_set(conn, st_closed); @@ -881,9 +881,9 @@ static cproc_t tcp_conn_seg_proc_ack(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_ack(%p, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_ack(%p, %p)", conn->name, conn, seg); if ((seg->ctrl & CTL_ACK) == 0) { - log_msg(LVL_WARN, "Segment has no ACK. Dropping."); + log_msg(LOG_DEFAULT, LVL_WARN, "Segment has no ACK. Dropping."); tcp_segment_delete(seg); return cp_done; @@ -940,5 +940,5 @@ size_t xfer_size; - log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_text(%p, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_text(%p, %p)", conn->name, conn, seg); @@ -982,5 +982,5 @@ fibril_condvar_broadcast(&conn->rcv_buf_cv); - log_msg(LVL_DEBUG, "Received %zu bytes of data.", xfer_size); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Received %zu bytes of data.", xfer_size); /* Advance RCV.NXT */ @@ -998,5 +998,5 @@ tcp_conn_trim_seg_to_wnd(conn, seg); } else { - log_msg(LVL_DEBUG, "%s: Nothing left in segment, dropping " + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Nothing left in segment, dropping " "(xfer_size=%zu, SEG.LEN=%" PRIu32 ", seg->ctrl=%u)", conn->name, xfer_size, seg->len, (unsigned int) seg->ctrl); @@ -1018,12 +1018,12 @@ static cproc_t tcp_conn_seg_proc_fin(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_fin(%p, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_fin(%p, %p)", conn->name, conn, seg); - log_msg(LVL_DEBUG, " seg->len=%zu, seg->ctl=%u", (size_t) seg->len, + log_msg(LOG_DEFAULT, LVL_DEBUG, " seg->len=%zu, seg->ctl=%u", (size_t) seg->len, (unsigned) seg->ctrl); /* Only process FIN if no text is left in segment. */ if (tcp_segment_text_size(seg) == 0 && (seg->ctrl & CTL_FIN) != 0) { - log_msg(LVL_DEBUG, " - FIN found in segment."); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - FIN found in segment."); /* Send ACK */ @@ -1042,15 +1042,15 @@ case st_syn_received: case st_established: - log_msg(LVL_DEBUG, "%s: FIN received -> Close-Wait", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Close-Wait", conn->name); tcp_conn_state_set(conn, st_close_wait); break; case st_fin_wait_1: - log_msg(LVL_DEBUG, "%s: FIN received -> Closing", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Closing", conn->name); tcp_conn_state_set(conn, st_closing); break; case st_fin_wait_2: - log_msg(LVL_DEBUG, "%s: FIN received -> Time-Wait", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Time-Wait", conn->name); tcp_conn_state_set(conn, st_time_wait); @@ -1091,5 +1091,5 @@ static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "tcp_conn_seg_process(%p, %p)", conn, seg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_seg_process(%p, %p)", conn, seg); tcp_segment_dump(seg); @@ -1097,5 +1097,5 @@ /* XXX Permit valid ACKs, URGs and RSTs */ /* if (!seq_no_segment_acceptable(conn, seg)) { - log_msg(LVL_WARN, "Segment not acceptable, dropping."); + log_msg(LOG_DEFAULT, LVL_WARN, "Segment not acceptable, dropping."); if ((seg->ctrl & CTL_RST) == 0) { tcp_tqueue_ctrl_seg(conn, CTL_ACK); @@ -1131,5 +1131,5 @@ */ if (seg->len > 0) { - log_msg(LVL_DEBUG, "Re-insert segment %p. seg->len=%zu", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Re-insert segment %p. seg->len=%zu", seg, (size_t) seg->len); tcp_iqueue_insert_seg(&conn->incoming, seg); @@ -1146,5 +1146,5 @@ void tcp_conn_segment_arrived(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "%s: tcp_conn_segment_arrived(%p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_segment_arrived(%p)", conn->name, seg); @@ -1165,5 +1165,5 @@ tcp_conn_sa_queue(conn, seg); break; case st_closed: - log_msg(LVL_DEBUG, "state=%d", (int) conn->cstate); + log_msg(LOG_DEFAULT, LVL_DEBUG, "state=%d", (int) conn->cstate); assert(false); } @@ -1178,10 +1178,10 @@ tcp_conn_t *conn = (tcp_conn_t *) arg; - log_msg(LVL_DEBUG, "tw_timeout_func(%p)", conn); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tw_timeout_func(%p)", conn); fibril_mutex_lock(&conn->lock); if (conn->cstate == st_closed) { - log_msg(LVL_DEBUG, "Connection already closed."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed."); fibril_mutex_unlock(&conn->lock); tcp_conn_delref(conn); @@ -1189,5 +1189,5 @@ } - log_msg(LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name); tcp_conn_remove(conn); tcp_conn_state_set(conn, st_closed); @@ -1240,5 +1240,5 @@ void tcp_unexpected_segment(tcp_sockpair_t *sp, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, seg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, seg); if ((seg->ctrl & CTL_RST) == 0) @@ -1268,5 +1268,5 @@ tcp_segment_t *rseg; - log_msg(LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg); rseg = tcp_segment_make_rst(seg); Index: uspace/srv/net/tcp/iqueue.c =================================================================== --- uspace/srv/net/tcp/iqueue.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/iqueue.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -67,9 +67,9 @@ tcp_iqueue_entry_t *qe; link_t *link; - log_msg(LVL_DEBUG, "tcp_iqueue_insert_seg()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_iqueue_insert_seg()"); iqe = calloc(1, sizeof(tcp_iqueue_entry_t)); if (iqe == NULL) { - log_msg(LVL_ERROR, "Failed allocating IQE."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating IQE."); return; } @@ -108,9 +108,9 @@ link_t *link; - log_msg(LVL_DEBUG, "tcp_get_ready_seg()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_get_ready_seg()"); link = list_first(&iqueue->list); if (link == NULL) { - log_msg(LVL_DEBUG, "iqueue is empty"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "iqueue is empty"); return ENOENT; } @@ -119,5 +119,5 @@ while (!seq_no_segment_acceptable(iqueue->conn, iqe->seg)) { - log_msg(LVL_DEBUG, "Skipping unacceptable segment (RCV.NXT=%" + log_msg(LOG_DEFAULT, LVL_DEBUG, "Skipping unacceptable segment (RCV.NXT=%" PRIu32 ", RCV.NXT+RCV.WND=%" PRIu32 ", SEG.SEQ=%" PRIu32 ", SEG.LEN=%" PRIu32 ")", iqueue->conn->rcv_nxt, @@ -130,5 +130,5 @@ link = list_first(&iqueue->list); if (link == NULL) { - log_msg(LVL_DEBUG, "iqueue is empty"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "iqueue is empty"); return ENOENT; } @@ -139,5 +139,5 @@ /* Do not return segments that are not ready for processing */ if (!seq_no_segment_ready(iqueue->conn, iqe->seg)) { - log_msg(LVL_DEBUG, "Next segment not ready: SEG.SEQ=%u, " + log_msg(LOG_DEFAULT, LVL_DEBUG, "Next segment not ready: SEG.SEQ=%u, " "RCV.NXT=%u, SEG.LEN=%u", iqe->seg->seq, iqueue->conn->rcv_nxt, iqe->seg->len); @@ -145,5 +145,5 @@ } - log_msg(LVL_DEBUG, "Returning ready segment %p", iqe->seg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Returning ready segment %p", iqe->seg); list_remove(&iqe->link); *seg = iqe->seg; Index: uspace/srv/net/tcp/ncsim.c =================================================================== --- uspace/srv/net/tcp/ncsim.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/ncsim.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -74,5 +74,5 @@ link_t *link; - log_msg(LVL_DEBUG, "tcp_ncsim_bounce_seg()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_bounce_seg()"); tcp_rqueue_bounce_seg(sp, seg); return; @@ -80,5 +80,5 @@ if (0 /*random() % 4 == 3*/) { /* Drop segment */ - log_msg(LVL_ERROR, "NCSim dropping segment"); + log_msg(LOG_DEFAULT, LVL_ERROR, "NCSim dropping segment"); tcp_segment_delete(seg); return; @@ -87,5 +87,5 @@ sqe = calloc(1, sizeof(tcp_squeue_entry_t)); if (sqe == NULL) { - log_msg(LVL_ERROR, "Failed allocating SQE."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating SQE."); return; } @@ -126,5 +126,5 @@ int rc; - log_msg(LVL_DEBUG, "tcp_ncsim_fibril()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril()"); @@ -139,5 +139,5 @@ sqe = list_get_instance(link, tcp_squeue_entry_t, link); - log_msg(LVL_DEBUG, "NCSim - Sleep"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "NCSim - Sleep"); rc = fibril_condvar_wait_timeout(&sim_queue_cv, &sim_queue_lock, sqe->delay); @@ -147,5 +147,5 @@ fibril_mutex_unlock(&sim_queue_lock); - log_msg(LVL_DEBUG, "NCSim - End Sleep"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "NCSim - End Sleep"); tcp_rqueue_bounce_seg(&sqe->sp, sqe->seg); free(sqe); @@ -161,9 +161,9 @@ fid_t fid; - log_msg(LVL_DEBUG, "tcp_ncsim_fibril_start()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril_start()"); fid = fibril_create(tcp_ncsim_fibril, NULL); if (fid == 0) { - log_msg(LVL_ERROR, "Failed creating ncsim fibril."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating ncsim fibril."); return; } Index: uspace/srv/net/tcp/rqueue.c =================================================================== --- uspace/srv/net/tcp/rqueue.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/rqueue.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -74,5 +74,5 @@ tcp_sockpair_t rident; - log_msg(LVL_DEBUG, "tcp_rqueue_bounce_seg()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_bounce_seg()"); #ifdef BOUNCE_TRANSCODE @@ -81,10 +81,10 @@ if (tcp_pdu_encode(sp, seg, &pdu) != EOK) { - log_msg(LVL_WARN, "Not enough memory. Segment dropped."); + log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped."); return; } if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) { - log_msg(LVL_WARN, "Not enough memory. Segment dropped."); + log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped."); return; } @@ -112,5 +112,5 @@ { tcp_rqueue_entry_t *rqe; - log_msg(LVL_DEBUG, "tcp_rqueue_insert_seg()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_insert_seg()"); tcp_segment_dump(seg); @@ -118,5 +118,5 @@ rqe = calloc(1, sizeof(tcp_rqueue_entry_t)); if (rqe == NULL) { - log_msg(LVL_ERROR, "Failed allocating RQE."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating RQE."); return; } @@ -134,5 +134,5 @@ tcp_rqueue_entry_t *rqe; - log_msg(LVL_DEBUG, "tcp_rqueue_fibril()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_fibril()"); while (true) { @@ -152,9 +152,9 @@ fid_t fid; - log_msg(LVL_DEBUG, "tcp_rqueue_fibril_start()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_fibril_start()"); fid = fibril_create(tcp_rqueue_fibril, NULL); if (fid == 0) { - log_msg(LVL_ERROR, "Failed creating rqueue fibril."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating rqueue fibril."); return; } Index: uspace/srv/net/tcp/segment.c =================================================================== --- uspace/srv/net/tcp/segment.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/segment.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -248,11 +248,11 @@ void tcp_segment_dump(tcp_segment_t *seg) { - log_msg(LVL_DEBUG2, "Segment dump:"); - log_msg(LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl); - log_msg(LVL_DEBUG2, " - seq = %" PRIu32, seg->seq); - log_msg(LVL_DEBUG2, " - ack = %" PRIu32, seg->ack); - log_msg(LVL_DEBUG2, " - len = %" PRIu32, seg->len); - log_msg(LVL_DEBUG2, " - wnd = %" PRIu32, seg->wnd); - log_msg(LVL_DEBUG2, " - up = %" PRIu32, seg->up); + log_msg(LOG_DEFAULT, LVL_DEBUG2, "Segment dump:"); + log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl); + log_msg(LOG_DEFAULT, LVL_DEBUG2, " - seq = %" PRIu32, seg->seq); + log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ack = %" PRIu32, seg->ack); + log_msg(LOG_DEFAULT, LVL_DEBUG2, " - len = %" PRIu32, seg->len); + log_msg(LOG_DEFAULT, LVL_DEBUG2, " - wnd = %" PRIu32, seg->wnd); + log_msg(LOG_DEFAULT, LVL_DEBUG2, " - up = %" PRIu32, seg->up); } Index: uspace/srv/net/tcp/sock.c =================================================================== --- uspace/srv/net/tcp/sock.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/sock.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -91,5 +91,5 @@ static void tcp_sock_notify_data(socket_core_t *sock_core) { - log_msg(LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id); async_exch_t *exch = async_exchange_begin(sock_core->sess); async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id, @@ -100,5 +100,5 @@ static void tcp_sock_notify_aconn(socket_core_t *lsock_core) { - log_msg(LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id); async_exch_t *exch = async_exchange_begin(lsock_core->sess); async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id, @@ -111,5 +111,5 @@ tcp_sockdata_t *sock; - log_msg(LVL_DEBUG, "tcp_sock_create()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_create()"); *rsock = NULL; @@ -133,5 +133,5 @@ static void tcp_sock_uncreate(tcp_sockdata_t *sock) { - log_msg(LVL_DEBUG, "tcp_sock_uncreate()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_uncreate()"); free(sock); } @@ -142,5 +142,5 @@ int rc; - log_msg(LVL_DEBUG, "tcp_sock_finish_setup()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_finish_setup()"); sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock); @@ -171,5 +171,5 @@ ipc_call_t answer; - log_msg(LVL_DEBUG, "tcp_sock_socket()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_socket()"); rc = tcp_sock_create(client, &sock); @@ -208,6 +208,6 @@ tcp_sockdata_t *socket; - log_msg(LVL_DEBUG, "tcp_sock_bind()"); - log_msg(LVL_DEBUG, " - async_data_write_accept"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_bind()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept"); rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len); if (rc != EOK) { @@ -216,5 +216,5 @@ } - log_msg(LVL_DEBUG, " - call socket_bind"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind"); rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call), addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, @@ -225,5 +225,5 @@ } - log_msg(LVL_DEBUG, " - call socket_cores_find"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find"); sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call)); if (sock_core != NULL) { @@ -233,5 +233,5 @@ } - log_msg(LVL_DEBUG, " - success"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - success"); async_answer_0(callid, EOK); } @@ -250,5 +250,5 @@ int i; - log_msg(LVL_DEBUG, "tcp_sock_listen()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()"); socket_id = SOCKET_GET_SOCKET_ID(call); @@ -284,5 +284,5 @@ } - log_msg(LVL_DEBUG, " - open connections"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections"); lsocket.addr.ipv4 = TCP_IPV4_ANY; @@ -337,5 +337,5 @@ tcp_sock_t fsocket; - log_msg(LVL_DEBUG, "tcp_sock_connect()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()"); rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len); @@ -377,5 +377,5 @@ fibril_mutex_unlock(&socket->lock); async_answer_0(callid, rc); - log_msg(LVL_DEBUG, "tcp_sock_connect: Failed to " + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect: Failed to " "determine local address."); return; @@ -383,5 +383,5 @@ socket->laddr.ipv4 = loc_addr.ipv4; - log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4); } @@ -431,5 +431,5 @@ int rc; - log_msg(LVL_DEBUG, "tcp_sock_accept()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept()"); socket_id = SOCKET_GET_SOCKET_ID(call); @@ -445,5 +445,5 @@ fibril_mutex_lock(&socket->lock); - log_msg(LVL_DEBUG, " - verify socket->conn"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - verify socket->conn"); if (socket->conn != NULL) { fibril_mutex_unlock(&socket->lock); @@ -498,5 +498,5 @@ asocket->conn = conn; - log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept():create asocket\n"); rc = tcp_sock_finish_setup(asocket, &asock_id); @@ -510,5 +510,5 @@ fibril_add_ready(asocket->recv_fibril); - log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): find acore\n"); SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE); @@ -521,5 +521,5 @@ /* Push one fragment notification to client's queue */ - log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): notify data\n"); fibril_mutex_unlock(&socket->lock); } @@ -539,5 +539,5 @@ int rc; - log_msg(LVL_DEBUG, "tcp_sock_send()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_send()"); socket_id = SOCKET_GET_SOCKET_ID(call); fragments = SOCKET_GET_DATA_FRAGMENTS(call); @@ -611,5 +611,5 @@ static void tcp_sock_sendto(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "tcp_sock_sendto()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_sendto()"); async_answer_0(callid, ENOTSUP); } @@ -629,5 +629,5 @@ int rc; - log_msg(LVL_DEBUG, "%p: tcp_sock_recv[from]()", client); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: tcp_sock_recv[from]()", client); socket_id = SOCKET_GET_SOCKET_ID(call); @@ -651,13 +651,13 @@ (void)flags; - log_msg(LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock"); fibril_mutex_lock(&socket->recv_buffer_lock); while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) { - log_msg(LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0"); fibril_condvar_wait(&socket->recv_buffer_cv, &socket->recv_buffer_lock); } - log_msg(LVL_DEBUG, "Got data in sock recv_buffer"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer"); data_len = socket->recv_buffer_used; @@ -679,5 +679,5 @@ } - log_msg(LVL_DEBUG, "**** recv result -> %d", rc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv result -> %d", rc); if (rc != EOK) { fibril_mutex_unlock(&socket->recv_buffer_lock); @@ -694,5 +694,5 @@ addr.sin_port = host2uint16_t_be(rsock->port); - log_msg(LVL_DEBUG, "addr read receive"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive"); if (!async_data_read_receive(&rcallid, &addr_length)) { fibril_mutex_unlock(&socket->recv_buffer_lock); @@ -705,5 +705,5 @@ addr_length = sizeof(addr); - log_msg(LVL_DEBUG, "addr read finalize"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize"); rc = async_data_read_finalize(rcallid, &addr, addr_length); if (rc != EOK) { @@ -715,5 +715,5 @@ } - log_msg(LVL_DEBUG, "data read receive"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive"); if (!async_data_read_receive(&rcallid, &length)) { fibril_mutex_unlock(&socket->recv_buffer_lock); @@ -726,9 +726,9 @@ length = data_len; - log_msg(LVL_DEBUG, "data read finalize"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize"); rc = async_data_read_finalize(rcallid, socket->recv_buffer, length); socket->recv_buffer_used -= length; - log_msg(LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer", + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer", socket->recv_buffer_used); if (socket->recv_buffer_used > 0) { @@ -758,5 +758,5 @@ int rc; - log_msg(LVL_DEBUG, "tcp_sock_close()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()"); socket_id = SOCKET_GET_SOCKET_ID(call); @@ -798,5 +798,5 @@ static void tcp_sock_getsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "tcp_sock_getsockopt()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_getsockopt()"); async_answer_0(callid, ENOTSUP); } @@ -804,5 +804,5 @@ static void tcp_sock_setsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "tcp_sock_setsockopt()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_setsockopt()"); async_answer_0(callid, ENOTSUP); } @@ -815,5 +815,5 @@ tcp_sockdata_t *socket = lconn->socket; - log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb()"); fibril_mutex_lock(&socket->lock); assert(conn == lconn->conn); @@ -828,5 +828,5 @@ list_append(&lconn->ready_list, &socket->ready); - log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept"); /* Push one accept notification to client's queue */ @@ -842,10 +842,10 @@ tcp_error_t trc; - log_msg(LVL_DEBUG, "tcp_sock_recv_fibril()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recv_fibril()"); fibril_mutex_lock(&sock->recv_buffer_lock); while (true) { - log_msg(LVL_DEBUG, "call tcp_uc_receive()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "call tcp_uc_receive()"); while (sock->recv_buffer_used != 0 && sock->sock_core != NULL) fibril_condvar_wait(&sock->recv_buffer_cv, @@ -863,5 +863,5 @@ } - log_msg(LVL_DEBUG, "got data - broadcast recv_buffer_cv"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "got data - broadcast recv_buffer_cv"); sock->recv_buffer_used = data_len; @@ -895,5 +895,5 @@ break; - log_msg(LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n", + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n", (int)IPC_GET_IMETHOD(call)); @@ -940,5 +940,5 @@ /* Clean up */ - log_msg(LVL_DEBUG, "tcp_sock_connection: Clean up"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: Clean up"); async_hangup(client.sess); socket_cores_release(NULL, &client.sockets, &gsock, tcp_free_sock_data); Index: uspace/srv/net/tcp/tcp.c =================================================================== --- uspace/srv/net/tcp/tcp.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/tcp.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -69,5 +69,5 @@ size_t pdu_raw_size; - log_msg(LVL_DEBUG, "tcp_inet_ev_recv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_inet_ev_recv()"); pdu_raw = dgram->data; @@ -76,5 +76,5 @@ /* Split into header and payload. */ - log_msg(LVL_DEBUG, "tcp_inet_ev_recv() - split header/payload"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_inet_ev_recv() - split header/payload"); tcp_pdu_t *pdu; @@ -84,5 +84,5 @@ if (pdu_raw_size < sizeof(tcp_header_t)) { - log_msg(LVL_WARN, "pdu_raw_size = %zu < sizeof(tcp_header_t) = %zu", + log_msg(LOG_DEFAULT, LVL_WARN, "pdu_raw_size = %zu < sizeof(tcp_header_t) = %zu", pdu_raw_size, sizeof(tcp_header_t)); return EINVAL; @@ -96,5 +96,5 @@ if (pdu_raw_size < hdr_size) { - log_msg(LVL_WARN, "pdu_raw_size = %zu < hdr_size = %zu", + log_msg(LOG_DEFAULT, LVL_WARN, "pdu_raw_size = %zu < hdr_size = %zu", pdu_raw_size, hdr_size); return EINVAL; @@ -102,14 +102,14 @@ if (hdr_size < sizeof(tcp_header_t)) { - log_msg(LVL_WARN, "hdr_size = %zu < sizeof(tcp_header_t) = %zu", + log_msg(LOG_DEFAULT, LVL_WARN, "hdr_size = %zu < sizeof(tcp_header_t) = %zu", hdr_size, sizeof(tcp_header_t)); return EINVAL; } - log_msg(LVL_DEBUG, "pdu_raw_size=%zu, hdr_size=%zu", + log_msg(LOG_DEFAULT, LVL_DEBUG, "pdu_raw_size=%zu, hdr_size=%zu", pdu_raw_size, hdr_size); pdu = tcp_pdu_create(pdu_raw, hdr_size, pdu_raw + hdr_size, pdu_raw_size - hdr_size); if (pdu == NULL) { - log_msg(LVL_WARN, "Failed creating PDU. Dropped."); + log_msg(LOG_DEFAULT, LVL_WARN, "Failed creating PDU. Dropped."); return ENOMEM; } @@ -117,5 +117,5 @@ pdu->src_addr.ipv4 = dgram->src.ipv4; pdu->dest_addr.ipv4 = dgram->dest.ipv4; - log_msg(LVL_DEBUG, "src: 0x%08x, dest: 0x%08x", + log_msg(LOG_DEFAULT, LVL_DEBUG, "src: 0x%08x, dest: 0x%08x", pdu->src_addr.ipv4, pdu->dest_addr.ipv4); @@ -137,5 +137,5 @@ pdu_raw = malloc(pdu_raw_size); if (pdu_raw == NULL) { - log_msg(LVL_ERROR, "Failed to transmit PDU. Out of memory."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU. Out of memory."); return; } @@ -153,5 +153,5 @@ rc = inet_send(&dgram, INET_TTL_MAX, 0); if (rc != EOK) - log_msg(LVL_ERROR, "Failed to transmit PDU."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU."); } @@ -162,8 +162,8 @@ tcp_sockpair_t rident; - log_msg(LVL_DEBUG, "tcp_received_pdu()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_received_pdu()"); if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) { - log_msg(LVL_WARN, "Not enough memory. PDU dropped."); + log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. PDU dropped."); return; } @@ -177,5 +177,5 @@ int rc; - log_msg(LVL_DEBUG, "tcp_init()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_init()"); tcp_rqueue_init(); @@ -189,5 +189,5 @@ rc = inet_init(IP_PROTO_TCP, &tcp_inet_ev_ops); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed connecting to internet service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting to internet service."); return ENOENT; } @@ -195,5 +195,5 @@ rc = tcp_sock_init(); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed initializing socket service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service."); return ENOENT; } @@ -208,5 +208,5 @@ printf(NAME ": TCP (Transmission Control Protocol) network module\n"); - rc = log_init(NAME, LVL_WARN); + rc = log_init(NAME); if (rc != EOK) { printf(NAME ": Failed to initialize log.\n"); Index: uspace/srv/net/tcp/tqueue.c =================================================================== --- uspace/srv/net/tcp/tqueue.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/tqueue.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -88,5 +88,5 @@ tcp_segment_t *seg; - log_msg(LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl); seg = tcp_segment_make_ctrl(ctrl); @@ -99,5 +99,5 @@ tcp_tqueue_entry_t *tqe; - log_msg(LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn, + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn, seg); @@ -109,5 +109,5 @@ rt_seg = tcp_segment_dup(seg); if (rt_seg == NULL) { - log_msg(LVL_ERROR, "Memory allocation failed."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed."); /* XXX Handle properly */ return; @@ -116,5 +116,5 @@ tqe = calloc(1, sizeof(tcp_tqueue_entry_t)); if (tqe == NULL) { - log_msg(LVL_ERROR, "Memory allocation failed."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed."); /* XXX Handle properly */ return; @@ -165,5 +165,5 @@ tcp_segment_t *seg; - log_msg(LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name); /* Number of free sequence numbers in send window */ @@ -172,5 +172,5 @@ xfer_seqlen = min(snd_buf_seqlen, avail_wnd); - log_msg(LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %" PRIu32 ", " + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %" PRIu32 ", " "xfer_seqlen = %zu", conn->name, snd_buf_seqlen, conn->snd_wnd, xfer_seqlen); @@ -185,5 +185,5 @@ if (send_fin) { - log_msg(LVL_DEBUG, "%s: Sending out FIN.", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Sending out FIN.", conn->name); /* We are sending out FIN */ ctrl = CTL_FIN; @@ -194,5 +194,5 @@ seg = tcp_segment_make_data(ctrl, conn->snd_buf, data_size); if (seg == NULL) { - log_msg(LVL_ERROR, "Memory allocation failure."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failure."); return; } @@ -223,5 +223,5 @@ link_t *cur, *next; - log_msg(LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name, + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name, conn); @@ -239,6 +239,6 @@ if ((tqe->seg->ctrl & CTL_FIN) != 0) { - log_msg(LVL_DEBUG, "Fin has been acked"); - log_msg(LVL_DEBUG, "SND.UNA=%" PRIu32 + log_msg(LOG_DEFAULT, LVL_DEBUG, "Fin has been acked"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.UNA=%" PRIu32 " SEG.SEQ=%" PRIu32 " SEG.LEN=%" PRIu32, conn->snd_una, tqe->seg->seq, tqe->seg->len); @@ -267,5 +267,5 @@ void tcp_conn_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)", conn->name, conn, seg); @@ -282,9 +282,9 @@ void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg) { - log_msg(LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)", sp->foreign.addr.ipv4, sp->foreign.port, sp->local.addr.ipv4, sp->local.port, seg); - log_msg(LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32, + log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32, seg->seq, seg->wnd); @@ -300,5 +300,5 @@ if (tcp_pdu_encode(sp, seg, &pdu) != EOK) { - log_msg(LVL_WARN, "Not enough memory. Segment dropped."); + log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped."); return; } @@ -315,10 +315,10 @@ link_t *link; - log_msg(LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn); + log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn); fibril_mutex_lock(&conn->lock); if (conn->cstate == st_closed) { - log_msg(LVL_DEBUG, "Connection already closed."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed."); fibril_mutex_unlock(&conn->lock); tcp_conn_delref(conn); @@ -328,5 +328,5 @@ link = list_first(&conn->retransmit.list); if (link == NULL) { - log_msg(LVL_DEBUG, "Nothing to retransmit"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Nothing to retransmit"); fibril_mutex_unlock(&conn->lock); tcp_conn_delref(conn); @@ -338,5 +338,5 @@ rt_seg = tcp_segment_dup(tqe->seg); if (rt_seg == NULL) { - log_msg(LVL_ERROR, "Memory allocation failed."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed."); fibril_mutex_unlock(&conn->lock); tcp_conn_delref(conn); @@ -345,5 +345,5 @@ } - log_msg(LVL_DEBUG, "### %s: retransmitting segment", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmitting segment", conn->name); tcp_conn_transmit_segment(tqe->conn, rt_seg); @@ -358,5 +358,5 @@ static void tcp_tqueue_timer_set(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name); /* Clear first to make sure we update refcnt correctly */ @@ -371,5 +371,5 @@ static void tcp_tqueue_timer_clear(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name); if (fibril_timer_clear(conn->retransmit.timer) == fts_active) Index: uspace/srv/net/tcp/ucall.c =================================================================== --- uspace/srv/net/tcp/ucall.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/tcp/ucall.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -70,5 +70,5 @@ tcp_conn_t *nconn; - log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)", lsock, fsock, acpass == ap_active ? "active" : "passive", oflags == tcp_open_nonblock ? "nonblock" : "none", conn); @@ -88,5 +88,5 @@ /* Wait for connection to be established or reset */ - log_msg(LVL_DEBUG, "tcp_uc_open: Wait for connection."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Wait for connection."); fibril_mutex_lock(&nconn->lock); while (nconn->cstate == st_listen || @@ -97,5 +97,5 @@ if (nconn->cstate != st_established) { - log_msg(LVL_DEBUG, "tcp_uc_open: Connection was reset."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was reset."); assert(nconn->cstate == st_closed); fibril_mutex_unlock(&nconn->lock); @@ -104,8 +104,8 @@ fibril_mutex_unlock(&nconn->lock); - log_msg(LVL_DEBUG, "tcp_uc_open: Connection was established."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was established."); *conn = nconn; - log_msg(LVL_DEBUG, "tcp_uc_open -> %p", nconn); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open -> %p", nconn); return TCP_EOK; } @@ -118,5 +118,5 @@ size_t xfer_size; - log_msg(LVL_DEBUG, "%s: tcp_uc_send()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_send()", conn->name); fibril_mutex_lock(&conn->lock); @@ -141,5 +141,5 @@ buf_free = conn->snd_buf_size - conn->snd_buf_used; while (buf_free == 0 && !conn->reset) { - log_msg(LVL_DEBUG, "%s: buf_free == 0, waiting.", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: buf_free == 0, waiting.", conn->name); fibril_condvar_wait(&conn->snd_buf_cv, &conn->lock); @@ -175,5 +175,5 @@ size_t xfer_size; - log_msg(LVL_DEBUG, "%s: tcp_uc_receive()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_receive()", conn->name); fibril_mutex_lock(&conn->lock); @@ -186,5 +186,5 @@ /* Wait for data to become available */ while (conn->rcv_buf_used == 0 && !conn->rcv_buf_fin && !conn->reset) { - log_msg(LVL_DEBUG, "tcp_uc_receive() - wait for data"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_receive() - wait for data"); fibril_condvar_wait(&conn->rcv_buf_cv, &conn->lock); } @@ -223,5 +223,5 @@ tcp_tqueue_ctrl_seg(conn, CTL_ACK); - log_msg(LVL_DEBUG, "%s: tcp_uc_receive() - returning %zu bytes", + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_receive() - returning %zu bytes", conn->name, xfer_size); @@ -234,5 +234,5 @@ tcp_error_t tcp_uc_close(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "%s: tcp_uc_close()", conn->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_close()", conn->name); fibril_mutex_lock(&conn->lock); @@ -258,5 +258,5 @@ void tcp_uc_abort(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "tcp_uc_abort()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_abort()"); } @@ -264,5 +264,5 @@ void tcp_uc_status(tcp_conn_t *conn, tcp_conn_status_t *cstatus) { - log_msg(LVL_DEBUG, "tcp_uc_status()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_status()"); cstatus->cstate = conn->cstate; } @@ -276,5 +276,5 @@ void tcp_uc_delete(tcp_conn_t *conn) { - log_msg(LVL_DEBUG, "tcp_uc_delete()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_delete()"); tcp_conn_delete(conn); } @@ -282,5 +282,5 @@ void tcp_uc_set_cstate_cb(tcp_conn_t *conn, tcp_cstate_cb_t cb, void *arg) { - log_msg(LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)", conn, cb, arg); @@ -298,5 +298,5 @@ tcp_conn_t *conn; - log_msg(LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))", + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))", sp->foreign.addr.ipv4, sp->foreign.port, sp->local.addr.ipv4, sp->local.port); @@ -304,5 +304,5 @@ conn = tcp_conn_find_ref(sp); if (conn == NULL) { - log_msg(LVL_WARN, "No connection found."); + log_msg(LOG_DEFAULT, LVL_WARN, "No connection found."); tcp_unexpected_segment(sp, seg); return; @@ -312,5 +312,5 @@ if (conn->cstate == st_closed) { - log_msg(LVL_WARN, "Connection is closed."); + log_msg(LOG_DEFAULT, LVL_WARN, "Connection is closed."); tcp_unexpected_segment(sp, seg); fibril_mutex_unlock(&conn->lock); @@ -339,5 +339,5 @@ void tcp_to_user(void) { - log_msg(LVL_DEBUG, "tcp_to_user()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_to_user()"); } Index: uspace/srv/net/udp/assoc.c =================================================================== --- uspace/srv/net/udp/assoc.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/udp/assoc.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -104,5 +104,5 @@ static void udp_assoc_free(udp_assoc_t *assoc) { - log_msg(LVL_DEBUG, "%s: udp_assoc_free(%p)", assoc->name, assoc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_assoc_free(%p)", assoc->name, assoc); while (!list_empty(&assoc->rcv_queue)) { @@ -127,5 +127,5 @@ void udp_assoc_addref(udp_assoc_t *assoc) { - log_msg(LVL_DEBUG, "%s: upd_assoc_addref(%p)", assoc->name, assoc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: upd_assoc_addref(%p)", assoc->name, assoc); atomic_inc(&assoc->refcnt); } @@ -139,5 +139,5 @@ void udp_assoc_delref(udp_assoc_t *assoc) { - log_msg(LVL_DEBUG, "%s: udp_assoc_delref(%p)", assoc->name, assoc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_assoc_delref(%p)", assoc->name, assoc); if (atomic_predec(&assoc->refcnt) == 0) @@ -154,5 +154,5 @@ void udp_assoc_delete(udp_assoc_t *assoc) { - log_msg(LVL_DEBUG, "%s: udp_assoc_delete(%p)", assoc->name, assoc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_assoc_delete(%p)", assoc->name, assoc); assert(assoc->deleted == false); @@ -192,5 +192,5 @@ void udp_assoc_set_foreign(udp_assoc_t *assoc, udp_sock_t *fsock) { - log_msg(LVL_DEBUG, "udp_assoc_set_foreign(%p, %p)", assoc, fsock); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_foreign(%p, %p)", assoc, fsock); fibril_mutex_lock(&assoc->lock); assoc->ident.foreign = *fsock; @@ -205,5 +205,5 @@ void udp_assoc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock) { - log_msg(LVL_DEBUG, "udp_assoc_set_local(%p, %p)", assoc, lsock); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %p)", assoc, lsock); fibril_mutex_lock(&assoc->lock); assoc->ident.local = *lsock; @@ -228,5 +228,5 @@ int rc; - log_msg(LVL_DEBUG, "udp_assoc_send(%p, %p, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send(%p, %p, %p)", assoc, fsock, msg); @@ -261,13 +261,13 @@ udp_rcv_queue_entry_t *rqe; - log_msg(LVL_DEBUG, "udp_assoc_recv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv()"); fibril_mutex_lock(&assoc->lock); while (list_empty(&assoc->rcv_queue)) { - log_msg(LVL_DEBUG, "udp_assoc_recv() - waiting"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - waiting"); fibril_condvar_wait(&assoc->rcv_queue_cv, &assoc->lock); } - log_msg(LVL_DEBUG, "udp_assoc_recv() - got a message"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - got a message"); link = list_first(&assoc->rcv_queue); rqe = list_get_instance(link, udp_rcv_queue_entry_t, link); @@ -291,9 +291,9 @@ int rc; - log_msg(LVL_DEBUG, "udp_assoc_received(%p, %p)", rsp, msg); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_received(%p, %p)", rsp, msg); assoc = udp_assoc_find_ref(rsp); if (assoc == NULL) { - log_msg(LVL_DEBUG, "No association found. Message dropped."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "No association found. Message dropped."); /* XXX Generate ICMP error. */ /* XXX Might propagate error directly by error return. */ @@ -303,5 +303,5 @@ rc = udp_assoc_queue_msg(assoc, rsp, msg); if (rc != EOK) { - log_msg(LVL_DEBUG, "Out of memory. Message dropped."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Out of memory. Message dropped."); /* XXX Generate ICMP error? */ } @@ -313,5 +313,5 @@ udp_rcv_queue_entry_t *rqe; - log_msg(LVL_DEBUG, "udp_assoc_queue_msg(%p, %p, %p)", + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_queue_msg(%p, %p, %p)", assoc, sp, msg); @@ -336,5 +336,5 @@ static bool udp_socket_match(udp_sock_t *sock, udp_sock_t *patt) { - log_msg(LVL_DEBUG, "udp_socket_match(sock=(%x,%u), pat=(%x,%u))", + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_socket_match(sock=(%x,%u), pat=(%x,%u))", sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port); @@ -347,5 +347,5 @@ return false; - log_msg(LVL_DEBUG, " -> match"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " -> match"); return true; @@ -355,5 +355,5 @@ static bool udp_sockpair_match(udp_sockpair_t *sp, udp_sockpair_t *pattern) { - log_msg(LVL_DEBUG, "udp_sockpair_match(%p, %p)", sp, pattern); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sockpair_match(%p, %p)", sp, pattern); if (!udp_socket_match(&sp->local, &pattern->local)) @@ -363,5 +363,5 @@ return false; - log_msg(LVL_DEBUG, "Socket pair matched."); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Socket pair matched."); return true; } @@ -379,5 +379,5 @@ static udp_assoc_t *udp_assoc_find_ref(udp_sockpair_t *sp) { - log_msg(LVL_DEBUG, "udp_assoc_find_ref(%p)", sp); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_find_ref(%p)", sp); fibril_mutex_lock(&assoc_list_lock); @@ -386,5 +386,5 @@ udp_assoc_t *assoc = list_get_instance(link, udp_assoc_t, link); udp_sockpair_t *asp = &assoc->ident; - log_msg(LVL_DEBUG, "compare with assoc (f:(%x,%u), l:(%x,%u))", + log_msg(LOG_DEFAULT, LVL_DEBUG, "compare with assoc (f:(%x,%u), l:(%x,%u))", asp->foreign.addr.ipv4, asp->foreign.port, asp->local.addr.ipv4, asp->local.port); @@ -395,5 +395,5 @@ if (udp_sockpair_match(sp, asp)) { - log_msg(LVL_DEBUG, "Returning assoc %p", assoc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Returning assoc %p", assoc); udp_assoc_addref(assoc); fibril_mutex_unlock(&assoc_list_lock); Index: uspace/srv/net/udp/sock.c =================================================================== --- uspace/srv/net/udp/sock.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/udp/sock.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -88,5 +88,5 @@ static void udp_sock_notify_data(socket_core_t *sock_core) { - log_msg(LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id); async_exch_t *exch = async_exchange_begin(sock_core->sess); async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id, @@ -103,5 +103,5 @@ ipc_call_t answer; - log_msg(LVL_DEBUG, "udp_sock_socket()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_socket()"); sock = calloc(1, sizeof(udp_sockdata_t)); if (sock == NULL) { @@ -167,6 +167,6 @@ udp_error_t urc; - log_msg(LVL_DEBUG, "udp_sock_bind()"); - log_msg(LVL_DEBUG, " - async_data_write_accept"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_bind()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept"); addr = NULL; @@ -178,5 +178,5 @@ } - log_msg(LVL_DEBUG, " - call socket_bind"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind"); rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call), addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, @@ -192,5 +192,5 @@ } - log_msg(LVL_DEBUG, " - call socket_cores_find"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find"); sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call)); if (sock_core == NULL) { @@ -222,5 +222,5 @@ } - log_msg(LVL_DEBUG, " - success"); + log_msg(LOG_DEFAULT, LVL_DEBUG, " - success"); async_answer_0(callid, rc); out: @@ -231,5 +231,5 @@ static void udp_sock_listen(udp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "udp_sock_listen()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_listen()"); async_answer_0(callid, ENOTSUP); } @@ -237,5 +237,5 @@ static void udp_sock_connect(udp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "udp_sock_connect()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connect()"); async_answer_0(callid, ENOTSUP); } @@ -243,5 +243,5 @@ static void udp_sock_accept(udp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "udp_sock_accept()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_accept()"); async_answer_0(callid, ENOTSUP); } @@ -264,5 +264,5 @@ int rc; - log_msg(LVL_DEBUG, "udp_sock_send()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()"); addr = NULL; @@ -323,5 +323,5 @@ fibril_mutex_unlock(&socket->lock); async_answer_0(callid, rc); - log_msg(LVL_DEBUG, "udp_sock_sendto: Failed to " + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_sendto: Failed to " "determine local address."); return; @@ -329,5 +329,5 @@ socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4; - log_msg(LVL_DEBUG, "Local IP address is %x", + log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x", socket->assoc->ident.local.addr.ipv4); } @@ -405,5 +405,5 @@ int rc; - log_msg(LVL_DEBUG, "%p: udp_sock_recv[from]()", client); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: udp_sock_recv[from]()", client); socket_id = SOCKET_GET_SOCKET_ID(call); @@ -427,13 +427,13 @@ (void)flags; - log_msg(LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock"); fibril_mutex_lock(&socket->recv_buffer_lock); while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) { - log_msg(LVL_DEBUG, "udp_sock_recvfrom(): wait for cv"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv"); fibril_condvar_wait(&socket->recv_buffer_cv, &socket->recv_buffer_lock); } - log_msg(LVL_DEBUG, "Got data in sock recv_buffer"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer"); rsock = socket->recv_fsock; @@ -441,5 +441,5 @@ urc = socket->recv_error; - log_msg(LVL_DEBUG, "**** recv data_len=%zu", data_len); + log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len); switch (urc) { @@ -458,5 +458,5 @@ } - log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc); + log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc); if (rc != EOK) { fibril_mutex_unlock(&socket->recv_buffer_lock); @@ -472,5 +472,5 @@ addr.sin_port = host2uint16_t_be(rsock.port); - log_msg(LVL_DEBUG, "addr read receive"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive"); if (!async_data_read_receive(&rcallid, &addr_length)) { fibril_mutex_unlock(&socket->recv_buffer_lock); @@ -483,5 +483,5 @@ addr_length = sizeof(addr); - log_msg(LVL_DEBUG, "addr read finalize"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize"); rc = async_data_read_finalize(rcallid, &addr, addr_length); if (rc != EOK) { @@ -493,5 +493,5 @@ } - log_msg(LVL_DEBUG, "data read receive"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive"); if (!async_data_read_receive(&rcallid, &length)) { fibril_mutex_unlock(&socket->recv_buffer_lock); @@ -504,5 +504,5 @@ length = data_len; - log_msg(LVL_DEBUG, "data read finalize"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize"); rc = async_data_read_finalize(rcallid, socket->recv_buffer, length); @@ -510,5 +510,5 @@ rc = EOVERFLOW; - log_msg(LVL_DEBUG, "read_data_length <- %zu", length); + log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length); IPC_SET_ARG2(answer, 0); SOCKET_SET_READ_DATA_LENGTH(answer, length); @@ -531,5 +531,5 @@ int rc; - log_msg(LVL_DEBUG, "tcp_sock_close()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()"); socket_id = SOCKET_GET_SOCKET_ID(call); @@ -557,5 +557,5 @@ static void udp_sock_getsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "udp_sock_getsockopt()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_getsockopt()"); async_answer_0(callid, ENOTSUP); } @@ -563,5 +563,5 @@ static void udp_sock_setsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call) { - log_msg(LVL_DEBUG, "udp_sock_setsockopt()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_setsockopt()"); async_answer_0(callid, ENOTSUP); } @@ -574,8 +574,8 @@ size_t rcvd; - log_msg(LVL_DEBUG, "udp_sock_recv_fibril()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril()"); while (true) { - log_msg(LVL_DEBUG, "[] wait for rcv buffer empty()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()"); fibril_mutex_lock(&sock->recv_buffer_lock); while (sock->recv_buffer_used != 0) { @@ -584,5 +584,5 @@ } - log_msg(LVL_DEBUG, "[] call udp_uc_receive()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()"); urc = udp_uc_receive(sock->assoc, sock->recv_buffer, UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock); @@ -597,5 +597,5 @@ } - log_msg(LVL_DEBUG, "[] got data - broadcast recv_buffer_cv"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "[] got data - broadcast recv_buffer_cv"); sock->recv_buffer_used = rcvd; @@ -622,10 +622,10 @@ while (true) { - log_msg(LVL_DEBUG, "udp_sock_connection: wait"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: wait"); callid = async_get_call(&call); if (!IPC_GET_IMETHOD(call)) break; - log_msg(LVL_DEBUG, "udp_sock_connection: METHOD=%d", + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: METHOD=%d", (int)IPC_GET_IMETHOD(call)); @@ -670,5 +670,5 @@ /* Clean up */ - log_msg(LVL_DEBUG, "udp_sock_connection: Clean up"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: Clean up"); async_hangup(client.sess); socket_cores_release(NULL, &client.sockets, &gsock, udp_free_sock_data); Index: uspace/srv/net/udp/ucall.c =================================================================== --- uspace/srv/net/udp/ucall.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/udp/ucall.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -47,5 +47,5 @@ udp_assoc_t *nassoc; - log_msg(LVL_DEBUG, "udp_uc_create()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_create()"); nassoc = udp_assoc_new(NULL, NULL); if (nassoc == NULL) @@ -59,5 +59,5 @@ udp_error_t udp_uc_set_foreign(udp_assoc_t *assoc, udp_sock_t *fsock) { - log_msg(LVL_DEBUG, "udp_uc_set_foreign(%p, %p)", assoc, fsock); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_foreign(%p, %p)", assoc, fsock); udp_assoc_set_foreign(assoc, fsock); @@ -67,5 +67,5 @@ udp_error_t udp_uc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock) { - log_msg(LVL_DEBUG, "udp_uc_set_local(%p, %p)", assoc, lsock); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %p)", assoc, lsock); udp_assoc_set_local(assoc, lsock); @@ -79,5 +79,5 @@ udp_msg_t msg; - log_msg(LVL_DEBUG, "%s: udp_uc_send()", assoc->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_uc_send()", assoc->name); msg.data = data; @@ -103,5 +103,5 @@ int rc; - log_msg(LVL_DEBUG, "%s: udp_uc_receive()", assoc->name); + log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: udp_uc_receive()", assoc->name); rc = udp_assoc_recv(assoc, &msg, fsock); switch (rc) { @@ -118,5 +118,5 @@ void udp_uc_status(udp_assoc_t *assoc, udp_assoc_status_t *astatus) { - log_msg(LVL_DEBUG, "udp_uc_status()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_status()"); // cstatus->cstate = conn->cstate; } @@ -124,5 +124,5 @@ void udp_uc_destroy(udp_assoc_t *assoc) { - log_msg(LVL_DEBUG, "udp_uc_destroy()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_destroy()"); udp_assoc_remove(assoc); udp_assoc_delete(assoc); Index: uspace/srv/net/udp/udp.c =================================================================== --- uspace/srv/net/udp/udp.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/udp/udp.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -50,9 +50,9 @@ int rc; - log_msg(LVL_DEBUG, "udp_init()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_init()"); rc = udp_inet_init(); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed connecting to internet service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting to internet service."); return ENOENT; } @@ -60,5 +60,5 @@ rc = udp_sock_init(); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed initializing socket service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service."); return ENOENT; } @@ -73,5 +73,5 @@ printf(NAME ": UDP (User Datagram Protocol) service\n"); - rc = log_init(NAME, LVL_DEBUG); + rc = log_init(NAME); if (rc != EOK) { printf(NAME ": Failed to initialize log.\n"); Index: uspace/srv/net/udp/udp_inet.c =================================================================== --- uspace/srv/net/udp/udp_inet.c (revision b6636dc773461c14eb97c06b1348bbbf0b6499b1) +++ uspace/srv/net/udp/udp_inet.c (revision 54a00703af50587df45bbb8f85be4f05097154f1) @@ -61,5 +61,5 @@ udp_pdu_t *pdu; - log_msg(LVL_DEBUG, "udp_inet_ev_recv()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_inet_ev_recv()"); pdu = udp_pdu_new(); @@ -69,5 +69,5 @@ pdu->src.ipv4 = dgram->src.ipv4; pdu->dest.ipv4 = dgram->dest.ipv4; - log_msg(LVL_DEBUG, "src: 0x%08x, dest: 0x%08x", + log_msg(LOG_DEFAULT, LVL_DEBUG, "src: 0x%08x, dest: 0x%08x", pdu->src.ipv4, pdu->dest.ipv4); @@ -84,5 +84,5 @@ inet_dgram_t dgram; - log_msg(LVL_DEBUG, "udp_transmit_pdu()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_transmit_pdu()"); dgram.src.ipv4 = pdu->src.ipv4; @@ -94,5 +94,5 @@ rc = inet_send(&dgram, INET_TTL_MAX, 0); if (rc != EOK) - log_msg(LVL_ERROR, "Failed to transmit PDU."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU."); return rc; @@ -105,8 +105,8 @@ udp_sockpair_t rident; - log_msg(LVL_DEBUG, "udp_received_pdu()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_received_pdu()"); if (udp_pdu_decode(pdu, &rident, &dmsg) != EOK) { - log_msg(LVL_WARN, "Not enough memory. PDU dropped."); + log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. PDU dropped."); return; } @@ -124,9 +124,9 @@ int rc; - log_msg(LVL_DEBUG, "udp_inet_init()"); + log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_inet_init()"); rc = inet_init(IP_PROTO_UDP, &udp_inet_ev_ops); if (rc != EOK) { - log_msg(LVL_ERROR, "Failed connecting to internet service."); + log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting to internet service."); return ENOENT; }