Changes in / [235d31d:759ea0d] in mainline


Ignore:
Files:
45 deleted
62 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r235d31d r759ea0d  
    380380
    381381% FPU support
    382 ! [PLATFORM=ia32|PLATFORM=amd64|PLATFORM=ia64|PLATFORM=ppc32|PLATFORM=sparc64] CONFIG_FPU (y)
     382! [PLATFORM=ia32|PLATFORM=amd64|PLATFORM=ia64|PLATFORM=sparc64] CONFIG_FPU (y)
     383
     384% FPU support
     385! [PLATFORM=ppc32] CONFIG_FPU (n/y)
    383386
    384387## ARMv7 made FPU hardware compulsory
    … …  
    480483
    481484% PC keyboard support
    482 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&(PLATFORM=ia32|PLATFORM=amd64)] CONFIG_PC_KBD (y/n)
     485! [CONFIG_HID_IN=generic&(PLATFORM=ia32|PLATFORM=amd64)] CONFIG_PC_KBD (y/n)
    483486
    484487% PC keyboard support
    … …  
    506509! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&(MACHINE=integratorcp|MACHINE=raspberrypi)] CONFIG_PL011_UART (y/n)
    507510
    508 % Support for NS16550 controller (kernel console)
    509 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=serial|CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&(PLATFORM=ia32|PLATFORM=amd64)] CONFIG_NS16550_KCON (n/y)
    510 
    511 % Use NS16550 controller as serial input (kernel console)
    512 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=serial)&(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_NS16550_KCON=y] CONFIG_NS16550 (y)
    513 
    514 % Use NS16550 controller as dummy serial output (kernel console)
    515 ! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_NS16550_KCON=y] CONFIG_NS16550_OUT (y)
    516 
    517511% Support for Samsung S3C24XX on-chip UART
    518512! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=gta02] CONFIG_S3C24XX_UART (y/n)
    … …  
    555549
    556550% Serial line input module
    557 ! [CONFIG_DSRLNIN=y|(PLATFORM=sparc32)|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=arm32&MACHINE=integratorcp&CONFIG_PL011_UART=y)|(PLATFORM=arm32&MACHINE=beaglebone&CONFIG_OMAP_UART=y)|(PLATFORM=arm32&MACHINE=beagleboardxm&CONFIG_OMAP_UART=y)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)|(PLATFORM=arm32&MACHINE=raspberrypi&CONFIG_PL011_UART=y)|(PLATFORM=ia32&CONFIG_NS16550=y)|(PLATFORM=amd64&CONFIG_NS16550=y)] CONFIG_SRLN (y)
     551! [CONFIG_DSRLNIN=y|(PLATFORM=sparc32)|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=arm32&MACHINE=integratorcp&CONFIG_PL011_UART=y)|(PLATFORM=arm32&MACHINE=beaglebone&CONFIG_OMAP_UART=y)|(PLATFORM=arm32&MACHINE=beagleboardxm&CONFIG_OMAP_UART=y)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)|(PLATFORM=arm32&MACHINE=raspberrypi&CONFIG_PL011_UART=y)] CONFIG_SRLN (y)
    558552
    559553% EGA support

  • boot/Makefile.common

    r235d31d r759ea0d  
    168168
    169169RD_APPS_NON_ESSENTIAL = \
    170         $(USPACE_PATH)/app/barber/barber \
    171170        $(USPACE_PATH)/app/bithenge/bithenge \
    172171        $(USPACE_PATH)/app/blkdump/blkdump \

  • boot/arch/ppc32/_link.ld.in

    r235d31d r759ea0d  
    22
    33SECTIONS {
    4         . = 0x08000000;
     4        . = 0x02000000;
    55        .text : {
    66                *(BOOTSTRAP);

  • boot/arch/ppc32/include/arch.h

    r235d31d r759ea0d  
    3535#define BOOT_OFFSET  0x8000
    3636
    37 #define LOADER_ADDRESS  0x08000000
     37#define LOADER_ADDRESS  0x02000000
    3838
    3939#ifndef __ASM__

  • contrib/qfs/qfs.sh

    r235d31d r759ea0d  
    2929#
    3030
    31 VERSION=2.2.0
     31VERSION=2.1.1
    3232BASENAME=qemu-${VERSION}
    3333BASENAME_MASTER=qemu-master
    … …  
    3636URL=http://wiki.qemu-project.org/download/${TARBALL}
    3737REPO=git://git.qemu.org/qemu.git
    38 MD5="f7a5e2da22d057eb838a91da7aff43c8"
     38MD5="78b1b51bfa2eee424e1bfdf3b66daa64"
    3939
    4040if [ "$1" == "--master" ]; then

  • defaults/arm32/gta02/Makefile.config

    r235d31d r759ea0d  
    44# RAM disk format
    55RDFMT = ext4fs
    6 
    7 # Barebone build with essential binaries only
    8 CONFIG_BAREBONE = y

  • defaults/arm32/raspberrypi/Makefile.config

    r235d31d r759ea0d  
    77#framebuffer
    88CONFIG_FB = n
    9 
    10 # Barebone build with essential binaries only
    11 CONFIG_BAREBONE = y
    12 

  • defaults/ppc32/Makefile.config

    r235d31d r759ea0d  
    77# Compiler
    88COMPILER = gcc_cross
    9 
    10 # Lazy FPU context switching
    11 CONFIG_FPU_LAZY = n
    129
    1310# Debug build
    … …  
    4643# OHCI root hub power switch, ganged is enough
    4744OHCI_POWER_SWITCH = ganged
     45
     46# Barebone build with essential binaries only
     47CONFIG_BAREBONE = y

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

    r235d31d r759ea0d  
    5353#define IRQ_KBD       1
    5454#define IRQ_PIC1      2
    55 /* NS16550 at COM1 */
    56 #define IRQ_NS16550   4
    5755#define IRQ_PIC_SPUR  7
    5856#define IRQ_MOUSE     12

  • kernel/arch/amd64/src/amd64.c

    r235d31d r759ea0d  
    4949#include <genarch/drivers/ega/ega.h>
    5050#include <genarch/drivers/i8042/i8042.h>
    51 #include <genarch/drivers/ns16550/ns16550.h>
    5251#include <genarch/drivers/legacy/ia32/io.h>
    5352#include <genarch/fb/bfb.h>
    5453#include <genarch/kbrd/kbrd.h>
    55 #include <genarch/srln/srln.h>
    5654#include <genarch/multiboot/multiboot.h>
    5755#include <genarch/multiboot/multiboot2.h>
    … …  
    214212        }
    215213#endif
    216 
    217 #if (defined(CONFIG_NS16550) || defined(CONFIG_NS16550_OUT))
    218         /*
    219          * Initialize the ns16550 controller.
    220          */
    221 #ifdef CONFIG_NS16550_OUT
    222         outdev_t *ns16550_out;
    223         outdev_t **ns16550_out_ptr = &ns16550_out;
    224 #else
    225         outdev_t **ns16550_out_ptr = NULL;
    226 #endif
    227         ns16550_instance_t *ns16550_instance
    228             = ns16550_init((ns16550_t *) NS16550_BASE, IRQ_NS16550, NULL, NULL,
    229             ns16550_out_ptr);
    230         if (ns16550_instance) {
    231 #ifdef CONFIG_NS16550
    232                 srln_instance_t *srln_instance = srln_init();
    233                 if (srln_instance) {
    234                         indev_t *sink = stdin_wire();
    235                         indev_t *srln = srln_wire(srln_instance, sink);
    236                         ns16550_wire(ns16550_instance, srln);
    237                         trap_virtual_enable_irqs(1 << IRQ_NS16550);
    238                 }
    239 #endif
    240 #ifdef CONFIG_NS16550_OUT
    241                 if (ns16550_out) {
    242                         stdout_wire(ns16550_out);
    243                 }
    244 #endif
    245         }
    246 #endif
    247214       
    248215        if (irqs_info != NULL)

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

    r235d31d r759ea0d  
    5353#define IRQ_KBD       1
    5454#define IRQ_PIC1      2
    55 /* NS16550 at COM1 */
    56 #define IRQ_NS16550   4
    5755#define IRQ_PIC_SPUR  7
    5856#define IRQ_MOUSE     12

  • kernel/arch/ia32/src/ia32.c

    r235d31d r759ea0d  
    5050#include <genarch/drivers/ega/ega.h>
    5151#include <genarch/drivers/i8042/i8042.h>
    52 #include <genarch/drivers/ns16550/ns16550.h>
    5352#include <genarch/drivers/legacy/ia32/io.h>
    5453#include <genarch/fb/bfb.h>
    5554#include <genarch/kbrd/kbrd.h>
    56 #include <genarch/srln/srln.h>
    5755#include <genarch/multiboot/multiboot.h>
    5856#include <genarch/multiboot/multiboot2.h>
    … …  
    168166        }
    169167#endif
    170 
    171 #if (defined(CONFIG_NS16550) || defined(CONFIG_NS16550_OUT))
    172         /*
    173          * Initialize the ns16550 controller.
    174          */
    175 #ifdef CONFIG_NS16550_OUT
    176         outdev_t *ns16550_out;
    177         outdev_t **ns16550_out_ptr = &ns16550_out;
    178 #else
    179         outdev_t **ns16550_out_ptr = NULL;
    180 #endif
    181         ns16550_instance_t *ns16550_instance
    182             = ns16550_init((ns16550_t *) NS16550_BASE, IRQ_NS16550, NULL, NULL,
    183             ns16550_out_ptr);
    184         if (ns16550_instance) {
    185 #ifdef CONFIG_NS16550
    186                 srln_instance_t *srln_instance = srln_init();
    187                 if (srln_instance) {
    188                         indev_t *sink = stdin_wire();
    189                         indev_t *srln = srln_wire(srln_instance, sink);
    190                         ns16550_wire(ns16550_instance, srln);
    191                         trap_virtual_enable_irqs(1 << IRQ_NS16550);
    192                 }
    193 #endif
    194 #ifdef CONFIG_NS16550_OUT
    195                 if (ns16550_out) {
    196                         stdout_wire(ns16550_out);
    197                 }
    198 #endif
    199         }
    200 #endif
    201168       
    202169        if (irqs_info != NULL)

  • kernel/arch/ia64/src/ia64.c

    r235d31d r759ea0d  
    176176#ifdef CONFIG_NS16550
    177177        ns16550_instance_t *ns16550_instance
    178             = ns16550_init((ns16550_t *) NS16550_BASE, NS16550_IRQ, NULL, NULL,
    179             NULL);
     178            = ns16550_init((ns16550_t *) NS16550_BASE, NS16550_IRQ, NULL, NULL);
    180179        if (ns16550_instance) {
    181180                srln_instance_t *srln_instance = srln_init();

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

    r235d31d r759ea0d  
    5858        asm volatile (
    5959                "mtmsr %[msr]\n"
    60                 "isync\n"
    6160                :: [msr] "r" (msr)
    6261        );
    … …  
    6766        asm volatile (
    6867                "mtsrin %[value], %[sr]\n"
    69                 "sync\n"
    70                 "isync\n"
    7168                :: [value] "r" ((flags << 16) + (asid << 4) + sr),
    7269                   [sr] "r" (sr << 28)

  • kernel/arch/ppc32/src/asm.S

    r235d31d r759ea0d  
    5555        rlwinm r31, r31, 0, 17, 15
    5656        mtmsr r31
    57         isync
    5857       
    5958        /* Set entry point */
    … …  
    8685        rlwinm r31, r31, 0, 17, 15
    8786        mtmsr r31
    88         isync
    8987       
    9088        lwz r0, ISTATE_OFFSET_R0(sp)
    … …  
    144142iret_syscall:
    145143       
     144        /* Reset decrementer */
     145       
     146        li r31, 1000
     147        mtdec r31
     148       
    146149        /* Disable interrupts */
    147150       
    … …  
    149152        rlwinm r31, r31, 0, 17, 15
    150153        mtmsr r31
    151         isync
    152154       
    153155        lwz r0, ISTATE_OFFSET_R0(sp)

  • kernel/arch/ppc32/src/fpu_context.S

    r235d31d r759ea0d  
    119119fpu_context_restore:
    120120        lfd fr0, FPU_CONTEXT_OFFSET_FPSCR(r3)
    121         mtfsf 0xff, fr0
    122        
     121        mtfsf 7, fr0
     122
    123123        FPU_CONTEXT_LOAD r3
    124124       
    … …  
    128128        mfmsr r0
    129129        ori r0, r0, MSR_FP
    130        
     130
    131131        # Disable FPU exceptions
    132132        li r3, MSR_FE0 | MSR_FE1
    133133        andc r0, r0, r3
    134        
     134
    135135        mtmsr r0
    136         isync
    137        
    138136        blr
    139137
    … …  
    142140        ori r0, r0, MSR_FP
    143141        mtmsr r0
    144         isync
    145142        blr
    146143
    … …  
    150147        andc r0, r0, r3
    151148        mtmsr r0
    152         isync
    153149        blr
     150

  • kernel/arch/sparc64/src/drivers/kbd.c

    r235d31d r759ea0d  
    122122       
    123123        ns16550_instance_t *ns16550_instance = ns16550_init(ns16550, inr, cir,
    124             cir_arg, NULL);
     124            cir_arg);
    125125        if (ns16550_instance) {
    126126                kbrd_instance_t *kbrd_instance = kbrd_init();

  • kernel/genarch/include/genarch/drivers/ns16550/ns16550.h

    r235d31d r759ea0d  
    3838#define KERN_NS16550_H_
    3939
    40 #include <ddi/ddi.h>
    4140#include <ddi/irq.h>
    4241#include <typedefs.h>
    … …  
    5150/** NS16550 registers. */
    5251typedef struct {
    53         union {
    54                 ioport8_t rbr;      /**< Receiver Buffer Register (read). */
    55                 ioport8_t thr;      /**< Transmitter Holder Register (write). */
    56         } __attribute__ ((packed));
     52        ioport8_t rbr;      /**< Receiver Buffer Register. */
    5753        ioport8_t ier;      /**< Interrupt Enable Register. */
    5854        union {
    … …  
    6965        irq_t irq;
    7066        ns16550_t *ns16550;
    71         indev_t *input;
    72         outdev_t *output;
    73         parea_t parea;
     67        indev_t *kbrdin;
    7468} ns16550_instance_t;
    7569
    76 extern ns16550_instance_t *ns16550_init(ns16550_t *, inr_t, cir_t, void *,
    77     outdev_t **);
     70extern ns16550_instance_t *ns16550_init(ns16550_t *, inr_t, cir_t, void *);
    7871extern void ns16550_wire(ns16550_instance_t *, indev_t *);
    7972

  • kernel/genarch/src/drivers/ns16550/ns16550.c

    r235d31d r759ea0d  
    4141#include <mm/slab.h>
    4242#include <ddi/device.h>
    43 #include <str.h>
    4443
    4544#define LSR_DATA_READY  0x01
    46 #define LSR_TH_READY    0x20
    4745
    4846static irq_ownership_t ns16550_claim(irq_t *irq)
    … …  
    6462        if (pio_read_8(&dev->lsr) & LSR_DATA_READY) {
    6563                uint8_t data = pio_read_8(&dev->rbr);
    66                 indev_push_character(instance->input, data);
     64                indev_push_character(instance->kbrdin, data);
    6765        }
    6866}
    … …  
    7573}
    7674
    77 static void ns16550_sendb(ns16550_t *dev, uint8_t byte)
    78 {
    79         while (!(pio_read_8(&dev->lsr) & LSR_TH_READY))
    80                 ;
    81         pio_write_8(&dev->thr, byte);
    82 }
    83 
    84 static void ns16550_putchar(outdev_t *dev, wchar_t ch)
    85 {
    86         ns16550_instance_t *instance = (ns16550_instance_t *) dev->data;
    87        
    88         if ((!instance->parea.mapped) || (console_override)) {
    89                 if (ascii_check(ch))
    90                         ns16550_sendb(instance->ns16550, (uint8_t) ch);
    91                 else
    92                         ns16550_sendb(instance->ns16550, U_SPECIAL);
    93         }
    94 }
    95 
    96 static outdev_operations_t ns16550_ops = {
    97         .write = ns16550_putchar,
    98         .redraw = NULL
    99 };
    100 
    10175/** Initialize ns16550.
    10276 *
    10377 * @param dev      Addrress of the beginning of the device in I/O space.
     78 * @param devno    Device number.
    10479 * @param inr      Interrupt number.
    10580 * @param cir      Clear interrupt function.
    10681 * @param cir_arg  First argument to cir.
    107  * @param output   Where to store pointer to the output device
    108  *                 or NULL if the caller is not interested in
    109  *                 writing to the serial port.
    11082 *
    11183 * @return Keyboard instance or NULL on failure.
    11284 *
    11385 */
    114 ns16550_instance_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir,
    115     void *cir_arg, outdev_t **output)
     86ns16550_instance_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir, void *cir_arg)
    11687{
    11788        ns16550_instance_t *instance
    … …  
    11990        if (instance) {
    12091                instance->ns16550 = dev;
    121                 instance->input = NULL;
    122                 instance->output = NULL;
    123                
    124                 if (output) {
    125                         instance->output = malloc(sizeof(outdev_t),
    126                             FRAME_ATOMIC);
    127                         if (!instance->output) {
    128                                 free(instance);
    129                                 return NULL;
    130                         }
    131                        
    132                         outdev_initialize("ns16550", instance->output,
    133                             &ns16550_ops);
    134                         instance->output->data = instance;
    135                         *output = instance->output;
    136                 }
     92                instance->kbrdin = NULL;
    13793               
    13894                irq_initialize(&instance->irq);
    … …  
    144100                instance->irq.cir = cir;
    145101                instance->irq.cir_arg = cir_arg;
    146                
    147                 instance->parea.pbase = (uintptr_t) dev;
    148                 instance->parea.frames = 1;
    149                 instance->parea.unpriv = false;
    150                 instance->parea.mapped = false;
    151                 ddi_parea_register(&instance->parea);
    152102        }
    153103       
    … …  
    155105}
    156106
    157 void ns16550_wire(ns16550_instance_t *instance, indev_t *input)
     107void ns16550_wire(ns16550_instance_t *instance, indev_t *kbrdin)
    158108{
    159109        ASSERT(instance);
    160         ASSERT(input);
     110        ASSERT(kbrdin);
    161111       
    162         instance->input = input;
     112        instance->kbrdin = kbrdin;
    163113        irq_register(&instance->irq);
    164114       

  • kernel/generic/src/sysinfo/stats.c

    r235d31d r759ea0d  
    8080static mutex_t load_lock;
    8181
     82/** Get system uptime
     83 *
     84 * @param item Sysinfo item (unused).
     85 * @param data Unused.
     86 *
     87 * @return System uptime (in secords).
     88 *
     89 */
     90static sysarg_t get_stats_uptime(struct sysinfo_item *item, void *data)
     91{
     92        /* This doesn't have to be very accurate */
     93        return uptime->seconds1;
     94}
     95
    8296/** Get statistics of all CPUs
    8397 *
    … …  
    804818        mutex_initialize(&load_lock, MUTEX_PASSIVE);
    805819       
     820        sysinfo_set_item_gen_val("system.uptime", NULL, get_stats_uptime, NULL);
    806821        sysinfo_set_item_gen_data("system.cpus", NULL, get_stats_cpus, NULL);
    807822        sysinfo_set_item_gen_data("system.physmem", NULL, get_stats_physmem, NULL);

  • release/Makefile

    r235d31d r759ea0d  
    3232SRC_ARCHIVE = HelenOS-$(RELEASE).tar.bz2
    3333
    34 PROFILES = \
    35         amd64 \
    36         arm32/beagleboardxm \
    37         arm32/beaglebone \
    38         arm32/gta02 \
    39         arm32/integratorcp \
    40         arm32/raspberrypi \
    41         ia32 \
    42         ia64/i460GX \
    43         ia64/ski \
    44         mips32/malta-be \
    45         mips32/msim \
    46         ppc32 \
    47         sparc32/leon3 \
    48         sparc64/niagara \
    49         sparc64/ultra
     34PROFILES = amd64 arm32/integratorcp arm32/gta02 arm32/beagleboardxm ia32 \
     35    ia64/i460GX ia64/ski mips32/msim ppc32 sparc64/ultra
    5036
    5137BZR = bzr

  • tools/ew.py

    r235d31d r759ea0d  
    8989                        return 'system-mips', malta_options()
    9090        elif platform == 'ppc32':
    91                 return 'system-ppc', '-m 256'
     91                return 'system-ppc', ''
    9292        elif platform == 'sparc64':
    9393                return 'system-sparc64', ''

  • tools/xtui.py

    r235d31d r759ea0d  
    3939        pid = os.fork()
    4040        if (not pid):
    41                 os.dup2(outdesc, 2)
     41                os.close(2)
     42                os.dup(outdesc)
    4243                os.close(indesc)
    4344               

  • uspace/Makefile

    r235d31d r759ea0d  
    3434
    3535DIRS = \
    36         app/barber \
    3736        app/bdsh \
    3837        app/bithenge \
    … …  
    215214        lib/fmtutil \
    216215        lib/scsi \
    217         lib/compress \
    218216        lib/softint \
    219217        lib/softfloat \

  • uspace/Makefile.common

    r235d31d r759ea0d  
    144144LIBNIC_PREFIX = $(LIB_PREFIX)/nic
    145145LIBMINIX_PREFIX = $(LIB_PREFIX)/minix
    146 LIBCOMPRESS_PREFIX = $(LIB_PREFIX)/compress
    147146
    148147LIBSCSI_PREFIX = $(LIB_PREFIX)/scsi

  • uspace/app/bnchmark/bnchmark.c

    r235d31d r759ea0d  
    6262{
    6363        struct timeval start_time;
    64         gettimeofday(&start_time, NULL);
    65        
    66         int rc = fn(data);
     64        int rc;
     65        rc = gettimeofday(&start_time, NULL);
     66        if (rc != EOK) {
     67                fprintf(stderr, "gettimeofday failed\n");
     68                return rc;
     69        }
     70       
     71        rc = fn(data);
    6772        if (rc != EOK) {
    6873                fprintf(stderr, "measured function failed\n");
    6974                return rc;
    7075        }
    71        
     76
    7277        struct timeval final_time;
    73         gettimeofday(&final_time, NULL);
     78        rc = gettimeofday(&final_time, NULL);
     79        if (rc != EOK) {
     80                fprintf(stderr, "gettimeofday failed\n");
     81                return rc;
     82        }
    7483       
    7584        /* Calculate time difference in milliseconds */
    … …  
    8392        char *path = (char *) data;
    8493        char *buf = malloc(BUFSIZE);
    85        
    86         if (buf == NULL)
     94
     95        if (buf == NULL) {
    8796                return ENOMEM;
     97        }
    8898       
    8999        FILE *file = fopen(path, "r");

  • uspace/app/init/init.c

    r235d31d r759ea0d  
    355355        int rc = compositor(HID_INPUT, HID_COMPOSITOR_SERVER);
    356356        if (rc == EOK) {
    357                 gui_start("/app/barber", HID_COMPOSITOR_SERVER);
    358357                gui_start("/app/vlaunch", HID_COMPOSITOR_SERVER);
    359358                gui_start("/app/vterm", HID_COMPOSITOR_SERVER);

  • uspace/app/modplay/modplay.c

    r235d31d r759ea0d  
    4040#include <stdio.h>
    4141#include <stdlib.h>
     42#include <protracker.h>
    4243#include <trackmod.h>
    4344
    … …  
    8788        con = console_init(stdin, stdout);
    8889
    89         rc = trackmod_module_load(argv[1], &mod);
     90        rc = trackmod_protracker_load(argv[1], &mod);
    9091        if (rc != EOK) {
    9192                printf("Error loading %s.\n", argv[1]);

  • uspace/app/nettest1/nettest1.c

    r235d31d r759ea0d  
    402402       
    403403        struct timeval time_before;
    404         gettimeofday(&time_before, NULL);
     404        rc = gettimeofday(&time_before, NULL);
     405        if (rc != EOK) {
     406                fprintf(stderr, "Get time of day error %d\n", rc);
     407                return rc;
     408        }
    405409       
    406410        nettest1_test(socket_ids,       1,        1);
    … …  
    410414       
    411415        struct timeval time_after;
    412         gettimeofday(&time_after, NULL);
     416        rc = gettimeofday(&time_after, NULL);
     417        if (rc != EOK) {
     418                fprintf(stderr, "Get time of day error %d\n", rc);
     419                return rc;
     420        }
    413421       
    414422        printf("Tested in %ld microseconds\n", tv_sub(&time_after,

  • uspace/app/nettest2/nettest2.c

    r235d31d r759ea0d  
    356356       
    357357        struct timeval time_before;
    358         gettimeofday(&time_before, NULL);
     358        rc = gettimeofday(&time_before, NULL);
     359        if (rc != EOK) {
     360                fprintf(stderr, "Get time of day error %d\n", rc);
     361                return rc;
     362        }
    359363       
    360364        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    … …  
    364368       
    365369        struct timeval time_after;
    366         gettimeofday(&time_after, NULL);
     370        rc = gettimeofday(&time_after, NULL);
     371        if (rc != EOK) {
     372                fprintf(stderr, "Get time of day error %d\n", rc);
     373                return rc;
     374        }
    367375       
    368376        if (verbose)
    … …  
    372380            tv_sub(&time_after, &time_before));
    373381       
    374         gettimeofday(&time_before, NULL);
     382        rc = gettimeofday(&time_before, NULL);
     383        if (rc != EOK) {
     384                fprintf(stderr, "Get time of day error %d\n", rc);
     385                return rc;
     386        }
    375387       
    376388        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    … …  
    384396                return rc;
    385397       
    386         gettimeofday(&time_after, NULL);
     398        rc = gettimeofday(&time_after, NULL);
     399        if (rc != EOK) {
     400                fprintf(stderr, "Get time of day error %d\n", rc);
     401                return rc;
     402        }
    387403       
    388404        if (verbose)

  • uspace/app/stats/stats.c

    r235d31d r759ea0d  
    191191static void print_uptime(void)
    192192{
    193         struct timeval uptime;
    194         getuptime(&uptime);
    195        
    196         printf("%s: Up %ld days, %ld hours, %ld minutes, %ld seconds\n",
    197             NAME, uptime.tv_sec / DAY, (uptime.tv_sec % DAY) / HOUR,
    198             (uptime.tv_sec % HOUR) / MINUTE, uptime.tv_sec % MINUTE);
     193        sysarg_t uptime = stats_get_uptime();
     194        printf("%s: Up %" PRIun " days, %" PRIun " hours, "
     195            "%" PRIun " minutes, %" PRIun " seconds\n", NAME,
     196            uptime / DAY, (uptime % DAY) / HOUR,
     197            (uptime % HOUR) / MINUTE, uptime % MINUTE);
    199198}
    200199

  • uspace/app/tester/float/float2.c

    r235d31d r759ea0d  
    5757const char *test_float2(void)
    5858{
    59         bool fail = false;
    60        
    6159        for (unsigned int i = 0; i < OPERANDS; i++) {
    6260                double res = trunc(arguments[i]);
    … …  
    6563               
    6664                if (res_int != corr_int) {
    67                         TPRINTF("Double truncation failed (%" PRId64 " != %" PRId64
    68                             ", arg %u)\n", res_int, corr_int, i);
    69                         fail = true;
     65                        TPRINTF("Double truncation failed (%" PRId64 " != %" PRId64 ")\n",
     66                            res_int, corr_int);
     67                        return "Double truncation failed";
    7068                }
    7169        }
    … …  
    7775               
    7876                if (res_int != corr_int) {
    79                         TPRINTF("Double sine failed (%" PRId64 " != %" PRId64
    80                             ", arg %u)\n", res_int, corr_int, i);
    81                         fail = true;
     77                        TPRINTF("Double sine failed (%" PRId64 " != %" PRId64 ")\n",
     78                            res_int, corr_int);
     79                        return "Double sine failed";
    8280                }
    8381        }
    … …  
    8987               
    9088                if (res_int != corr_int) {
    91                         TPRINTF("Double cosine failed (%" PRId64 " != %" PRId64
    92                             ", arg %u)\n", res_int, corr_int, i);
    93                         fail = true;
     89                        TPRINTF("Double cosine failed (%" PRId64 " != %" PRId64 ")\n",
     90                            res_int, corr_int);
     91                        return "Double cosine failed";
    9492                }
    9593        }
    9694       
    97         if (fail)
    98                 return "Floating point imprecision";
    99        
    10095        return NULL;
    10196}

  • uspace/app/tester/ipc/ping_pong.c

    r235d31d r759ea0d  
    4343       
    4444        struct timeval start;
    45         gettimeofday(&start, NULL);
     45        if (gettimeofday(&start, NULL) != 0) {
     46                TPRINTF("\n");
     47                return "Failed getting the time";
     48        }
    4649       
    4750        uint64_t count = 0;
    4851        while (true) {
    4952                struct timeval now;
    50                 gettimeofday(&now, NULL);
     53                if (gettimeofday(&now, NULL) != 0) {
     54                        TPRINTF("\n");
     55                        return "Failed getting the time";
     56                }
    5157               
    5258                if (tv_sub(&now, &start) >= DURATION_SECS * 1000000L)

  • uspace/app/tester/ipc/starve.c

    r235d31d r759ea0d  
    4040        const char *err = NULL;
    4141        console_ctrl_t *console = console_init(stdin, stdout);
    42         if (console == NULL)
     42        if (console == NULL) {
    4343                return "Failed to init connection with console.";
     44        }
    4445       
    4546        struct timeval start;
    46         gettimeofday(&start, NULL);
     47        if (gettimeofday(&start, NULL) != 0) {
     48                err = "Failed getting the time";
     49                goto leave;
     50        }
    4751       
    4852        TPRINTF("Intensive computation shall be imagined (for %ds)...\n", DURATION_SECS);
    … …  
    5054        while (true) {
    5155                struct timeval now;
    52                 gettimeofday(&now, NULL);
     56                if (gettimeofday(&now, NULL) != 0) {
     57                        err = "Failed getting the time";
     58                        goto leave;
     59                }
    5360               
    5461                if (tv_sub(&now, &start) >= DURATION_SECS * 1000000L)
    … …  
    6370                }
    6471        }
    65        
     72
    6673        // FIXME - unless a key was pressed, the answer leaked as no one
    6774        // will wait for it.
    6875        // We cannot use async_forget() directly, though. Something like
    6976        // console_forget_pending_kbd_event() shall come here.
    70        
     77
    7178        TPRINTF("Terminating...\n");
    72        
     79
     80leave:
    7381        console_done(console);
    74        
     82
    7583        return err;
    7684}

  • uspace/app/testread/testread.c

    r235d31d r759ea0d  
    123123        struct timeval prev_time;
    124124        struct timeval start_time;
    125         gettimeofday(&start_time, NULL);
     125        int rc;
     126        rc = gettimeofday(&start_time, NULL);
     127        if (rc != EOK) {
     128                printf("gettimeofday failed\n");
     129                fclose(file);
     130                free(buf);
     131                return 1;
     132        }
    126133        prev_time = start_time;
    127134       
    … …  
    148155                if (progress && offset >= next_mark) {
    149156                        struct timeval cur_time;
    150                         gettimeofday(&cur_time, NULL);
    151                        
     157                        rc = gettimeofday(&cur_time, NULL);
     158                        if (rc != EOK) {
     159                                printf("gettimeofday failed\n");
     160                                fclose(file);
     161                                free(buf);
     162                                return 1;
     163                        }
    152164                        uint32_t last_run = cur_time.tv_sec - prev_time.tv_sec;
    153165                        uint32_t total_time = cur_time.tv_sec - start_time.tv_sec;
    … …  
    166178       
    167179        struct timeval final_time;
    168         gettimeofday(&final_time, NULL);
     180        rc = gettimeofday(&final_time, NULL);
     181        if (rc != EOK) {
     182                printf("gettimeofday failed\n");
     183                fclose(file);
     184                free(buf);
     185                return 1;
     186        }
    169187       
    170188        uint32_t total_run_time = final_time.tv_sec - start_time.tv_sec;

  • uspace/app/top/top.c

    r235d31d r759ea0d  
    156156        /* Get current time */
    157157        struct timeval time;
    158         gettimeofday(&time, NULL);
     158        if (gettimeofday(&time, NULL) != EOK)
     159                return "Cannot get time of day";
    159160       
    160161        target->hours = (time.tv_sec % DAY) / HOUR;
    … …  
    163164       
    164165        /* Get uptime */
    165         struct timeval uptime;
    166         getuptime(&uptime);
    167        
    168         target->udays = uptime.tv_sec / DAY;
    169         target->uhours = (uptime.tv_sec % DAY) / HOUR;
    170         target->uminutes = (uptime.tv_sec % HOUR) / MINUTE;
    171         target->useconds = uptime.tv_sec % MINUTE;
     166        sysarg_t uptime = stats_get_uptime();
     167        target->udays = uptime / DAY;
     168        target->uhours = (uptime % DAY) / HOUR;
     169        target->uminutes = (uptime % HOUR) / MINUTE;
     170        target->useconds = uptime % MINUTE;
    172171       
    173172        /* Get load */

  • uspace/app/vlaunch/vlaunch.c

    r235d31d r759ea0d  
    3737#include <stdio.h>
    3838#include <malloc.h>
     39#include <io/pixel.h>
    3940#include <task.h>
     41#include <str.h>
    4042#include <str_error.h>
     43#include <loc.h>
     44#include <fibril_synch.h>
     45#include <io/pixel.h>
     46#include <device/led_dev.h>
    4147
    4248#include <window.h>
    … …  
    5864#define LOGO_HEIGHT  66
    5965
     66#define PERIOD  1000000
     67#define COLORS  7
     68
    6069static char *winreg = NULL;
     70static fibril_timer_t *timer = NULL;
     71static list_t led_devs;
     72
     73static pixel_t colors[COLORS] = {
     74        PIXEL(0xff, 0xff, 0x00, 0x00),
     75        PIXEL(0xff, 0x00, 0xff, 0x00),
     76        PIXEL(0xff, 0x00, 0x00, 0xff),
     77        PIXEL(0xff, 0xff, 0xff, 0x00),
     78        PIXEL(0xff, 0xff, 0x00, 0xff),
     79        PIXEL(0xff, 0x00, 0xff, 0xff),
     80        PIXEL(0xff, 0xff, 0xff, 0xff)
     81};
     82
     83static unsigned int color = 0;
     84
     85typedef struct {
     86        link_t link;
     87        service_id_t svc_id;
     88        async_sess_t *sess;
     89} led_dev_t;
    6190
    6291static int app_launch(const char *app)
    … …  
    100129}
    101130
     131static void timer_callback(void *data)
     132{
     133        pixel_t next_color = colors[color];
     134       
     135        color++;
     136        if (color >= COLORS)
     137                color = 0;
     138       
     139        list_foreach(led_devs, link, led_dev_t, dev) {
     140                if (dev->sess)
     141                        led_dev_color_set(dev->sess, next_color);
     142        }
     143       
     144        fibril_timer_set(timer, PERIOD, timer_callback, NULL);
     145}
     146
     147static void loc_callback(void)
     148{
     149        category_id_t led_cat;
     150        int rc = loc_category_get_id("led", &led_cat, IPC_FLAG_BLOCKING);
     151        if (rc != EOK)
     152                return;
     153       
     154        service_id_t *svcs;
     155        size_t count;
     156        rc = loc_category_get_svcs(led_cat, &svcs, &count);
     157        if (rc != EOK)
     158                return;
     159       
     160        for (size_t i = 0; i < count; i++) {
     161                bool known = false;
     162               
     163                /* Determine whether we already know this device. */
     164                list_foreach(led_devs, link, led_dev_t, dev) {
     165                        if (dev->svc_id == svcs[i]) {
     166                                known = true;
     167                                break;
     168                        }
     169                }
     170               
     171                if (!known) {
     172                        led_dev_t *dev = (led_dev_t *) calloc(1, sizeof(led_dev_t));
     173                        if (!dev)
     174                                continue;
     175                       
     176                        link_initialize(&dev->link);
     177                        dev->svc_id = svcs[i];
     178                        dev->sess = loc_service_connect(EXCHANGE_SERIALIZE, svcs[i], 0);
     179                       
     180                        list_append(&dev->link, &led_devs);
     181                }
     182        }
     183       
     184        // FIXME: Handle LED device removal
     185       
     186        free(svcs);
     187}
     188
    102189int main(int argc, char *argv[])
    103190{
    104191        if (argc < 2) {
    105192                printf("Compositor server not specified.\n");
     193                return 1;
     194        }
     195       
     196        list_initialize(&led_devs);
     197        int rc = loc_register_cat_change_cb(loc_callback);
     198        if (rc != EOK) {
     199                printf("Unable to register callback for device discovery.\n");
     200                return 1;
     201        }
     202       
     203        timer = fibril_timer_create(NULL);
     204        if (!timer) {
     205                printf("Unable to create timer.\n");
    106206                return 1;
    107207        }
    … …  
    162262        window_exec(main_window);
    163263       
     264        fibril_timer_set(timer, PERIOD, timer_callback, NULL);
     265       
    164266        task_retval(0);
    165267        async_manager();

  • uspace/dist/src/c/demos/tetris/shapes.c

    r235d31d r759ea0d  
    6969
    7070const struct shape shapes[] = {
    71         /*  0 */  {  7,  7, { TL, TC, MR }, 0x00aaaa},
    72         /*  1 */  {  8,  8, { TC, TR, ML }, 0x00aa00},
    73         /*  2 */  {  9, 11, { ML, MR, BC }, 0xaa5500},
    74         /*  3 */  {  3,  3, { TL, TC, ML }, 0x0000aa},
    75         /*  4 */  { 12, 14, { ML, BL, MR }, 0xaa00aa},
    76         /*  5 */  { 15, 17, { ML, BR, MR }, 0xffa500},
    77         /*  6 */  { 18, 18, { ML, MR, 2  }, 0xaa0000},  /* sticks out */
    78         /*  7 */  {  0,  0, { TC, ML, BL }, 0x00aaaa},
    79         /*  8 */  {  1,  1, { TC, MR, BR }, 0x00aa00},
    80         /*  9 */  { 10,  2, { TC, MR, BC }, 0xaa5500},
    81         /* 10 */  { 11,  9, { TC, ML, MR }, 0xaa5500},
    82         /* 11 */  {  2, 10, { TC, ML, BC }, 0xaa5500},
    83         /* 12 */  { 13,  4, { TC, BC, BR }, 0xaa00aa},
    84         /* 13 */  { 14, 12, { TR, ML, MR }, 0xaa00aa},
    85         /* 14 */  {  4, 13, { TL, TC, BC }, 0xaa00aa},
    86         /* 15 */  { 16,  5, { TR, TC, BC }, 0xffa500},
    87         /* 16 */  { 17, 15, { TL, MR, ML }, 0xffa500},
    88         /* 17 */  {  5, 16, { TC, BC, BL }, 0xffa500},
    89         /* 18 */  {  6,  6, { TC, BC, 2 * B_COLS }, 0xaa0000}  /* sticks out */
     71        /*  0 */  {  7,  7, { TL, TC, MR }, 0xff042d},
     72        /*  1 */  {  8,  8, { TC, TR, ML }, 0xff9304},
     73        /*  2 */  {  9, 11, { ML, MR, BC }, 0xbeff04},
     74        /*  3 */  {  3,  3, { TL, TC, ML }, 0x63ff04},
     75        /*  4 */  { 12, 14, { ML, BL, MR }, 0xce04ff},
     76        /*  5 */  { 15, 17, { ML, BR, MR }, 0xff04cf},
     77        /*  6 */  { 18, 18, { ML, MR, 2  }, 0x7604ff},  /* sticks out */
     78        /*  7 */  {  0,  0, { TC, ML, BL }, 0xff042d},
     79        /*  8 */  {  1,  1, { TC, MR, BR }, 0xff9304},
     80        /*  9 */  { 10,  2, { TC, MR, BC }, 0xbeff04},
     81        /* 10 */  { 11,  9, { TC, ML, MR }, 0xbeff04},
     82        /* 11 */  {  2, 10, { TC, ML, BC }, 0xbeff04},
     83        /* 12 */  { 13,  4, { TC, BC, BR }, 0xce04ff},
     84        /* 13 */  { 14, 12, { TR, ML, MR }, 0xce04ff},
     85        /* 14 */  {  4, 13, { TL, TC, BC }, 0xce04ff},
     86        /* 15 */  { 16,  5, { TR, TC, BC }, 0xff04cf},
     87        /* 16 */  { 17, 15, { TL, MR, ML }, 0xff04cf},
     88        /* 17 */  {  5, 16, { TC, BC, BL }, 0xff04cf},
     89        /* 18 */  {  6,  6, { TC, BC, 2 * B_COLS }, 0x7604ff}  /* sticks out */
    9090};
    9191

  • uspace/dist/src/c/demos/top/screen.c

    r235d31d r759ea0d  
    3737
    3838#include <stdio.h>
    39 #include <stdlib.h>
    4039#include <io/console.h>
    4140#include <io/style.h>
    … …  
    4443#include <stats.h>
    4544#include <inttypes.h>
    46 #include <macros.h>
    4745#include "screen.h"
    4846#include "top.h"
    … …  
    5048#define USEC_COUNT  1000000
    5149
     50static sysarg_t warn_col = 0;
     51static sysarg_t warn_row = 0;
    5252static suseconds_t timeleft = 0;
    5353
    5454console_ctrl_t *console;
    5555
    56 static sysarg_t warning_col = 0;
    57 static sysarg_t warning_row = 0;
    58 static suseconds_t warning_timeleft = 0;
    59 static char *warning_text = NULL;
    60 
    6156static void screen_style_normal(void)
    6257{
    … …  
    6964        console_flush(console);
    7065        console_set_style(console, STYLE_INVERTED);
    71 }
    72 
    73 static void screen_style_emphasis(void)
    74 {
    75         console_flush(console);
    76         console_set_style(console, STYLE_EMPHASIS);
    7766}
    7867
    … …  
    137126void screen_done(void)
    138127{
    139         free(warning_text);
    140         warning_text = NULL;
    141 
    142128        screen_restart(true);
    143129       
    … …  
    291277}
    292278
    293 static inline void print_help_head(void)
     279static inline void print_tasks_head(void)
    294280{
    295281        screen_style_inverted();
    296         printf("Help");
     282        printf("[taskid] [thrds] [resident] [%%resi] [virtual] [%%virt]"
     283            " [%%user] [%%kern] [name");
    297284        screen_newline();
    298285        screen_style_normal();
    299286}
    300287
    301 static inline void print_help(void)
     288static inline void print_tasks(data_t *data)
    302289{
    303290        sysarg_t cols;
    … …  
    305292        screen_get_size(&cols, &rows);
    306293       
    307         screen_newline();
    308        
    309         printf("Operation modes:");
    310         screen_newline();
    311        
    312         printf(" t .. tasks statistics");
    313         screen_newline();
    314        
    315         printf(" i .. IPC statistics");
    316         screen_newline();
    317        
    318         printf(" e .. exceptions statistics");
    319         screen_newline();
    320        
    321         printf("      a .. toggle display of all/hot exceptions");
    322         screen_newline();
    323 
    324         printf(" h .. toggle this help screen");
    325         screen_newline();
    326 
    327         screen_newline();
    328 
    329         printf("Other keys:");
    330         screen_newline();
    331        
    332         printf(" s .. choose column to sort by");
    333         screen_newline();
    334        
    335         printf(" r .. toggle reversed sorting");
    336         screen_newline();
    337        
    338         printf(" q .. quit");
    339         screen_newline();
    340        
    341294        sysarg_t col;
    342295        sysarg_t row;
    343296        screen_get_pos(&col, &row);
    344297       
     298        size_t i;
     299        for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) {
     300                stats_task_t *task = data->tasks + data->tasks_map[i];
     301                perc_task_t *perc = data->tasks_perc + data->tasks_map[i];
     302               
     303                uint64_t resmem;
     304                const char *resmem_suffix;
     305                bin_order_suffix(task->resmem, &resmem, &resmem_suffix, true);
     306               
     307                uint64_t virtmem;
     308                const char *virtmem_suffix;
     309                bin_order_suffix(task->virtmem, &virtmem, &virtmem_suffix, true);
     310               
     311                printf("%-8" PRIu64 " %7zu %7" PRIu64 "%s ",
     312                    task->task_id, task->threads, resmem, resmem_suffix);
     313                print_percent(perc->resmem, 2);
     314                printf(" %6" PRIu64 "%s ", virtmem, virtmem_suffix);
     315                print_percent(perc->virtmem, 2);
     316                puts(" ");
     317                print_percent(perc->ucycles, 2);
     318                puts(" ");
     319                print_percent(perc->kcycles, 2);
     320                puts(" ");
     321                print_string(task->name);
     322               
     323                screen_newline();
     324        }
     325       
    345326        while (row < rows) {
    346327                screen_newline();
    … …  
    349330}
    350331
    351 static inline void print_table_head(const table_t *table)
     332static inline void print_ipc_head(void)
     333{
     334        screen_style_inverted();
     335        printf("[taskid] [cls snt] [cls rcv] [ans snt]"
     336            " [ans rcv] [irq rcv] [forward] [name");
     337        screen_newline();
     338        screen_style_normal();
     339}
     340
     341static inline void print_ipc(data_t *data)
    352342{
    353343        sysarg_t cols;
    354344        sysarg_t rows;
    355345        screen_get_size(&cols, &rows);
    356 
     346       
     347        sysarg_t col;
     348        sysarg_t row;
     349        screen_get_pos(&col, &row);
     350       
     351        size_t i;
     352        for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) {
     353                uint64_t call_sent;
     354                uint64_t call_received;
     355                uint64_t answer_sent;
     356                uint64_t answer_received;
     357                uint64_t irq_notif_received;
     358                uint64_t forwarded;
     359               
     360                char call_sent_suffix;
     361                char call_received_suffix;
     362                char answer_sent_suffix;
     363                char answer_received_suffix;
     364                char irq_notif_received_suffix;
     365                char forwarded_suffix;
     366               
     367                order_suffix(data->tasks[i].ipc_info.call_sent, &call_sent,
     368                    &call_sent_suffix);
     369                order_suffix(data->tasks[i].ipc_info.call_received,
     370                    &call_received, &call_received_suffix);
     371                order_suffix(data->tasks[i].ipc_info.answer_sent,
     372                    &answer_sent, &answer_sent_suffix);
     373                order_suffix(data->tasks[i].ipc_info.answer_received,
     374                    &answer_received, &answer_received_suffix);
     375                order_suffix(data->tasks[i].ipc_info.irq_notif_received,
     376                    &irq_notif_received, &irq_notif_received_suffix);
     377                order_suffix(data->tasks[i].ipc_info.forwarded, &forwarded,
     378                    &forwarded_suffix);
     379               
     380                printf("%-8" PRIu64 " %8" PRIu64 "%c %8" PRIu64 "%c"
     381                     " %8" PRIu64 "%c %8" PRIu64 "%c %8" PRIu64 "%c"
     382                     " %8" PRIu64 "%c ", data->tasks[i].task_id,
     383                     call_sent, call_sent_suffix,
     384                     call_received, call_received_suffix,
     385                     answer_sent, answer_sent_suffix,
     386                     answer_received, answer_received_suffix,
     387                     irq_notif_received, irq_notif_received_suffix,
     388                     forwarded, forwarded_suffix);
     389                print_string(data->tasks[i].name);
     390               
     391                screen_newline();
     392        }
     393       
     394        while (row < rows) {
     395                screen_newline();
     396                row++;
     397        }
     398}
     399
     400static inline void print_excs_head(void)
     401{
    357402        screen_style_inverted();
    358         for (size_t i = 0; i < table->num_columns; i++) {
    359                 const char *name = table->columns[i].name;
    360                 int width = table->columns[i].width;
    361                 if (i != 0) {
    362                         puts(" ");
    363                 }
    364                 if (width == 0) {
    365                         sysarg_t col;
    366                         sysarg_t row;
    367                         screen_get_pos(&col, &row);
    368                         width = cols - col - 1;
    369                 }
    370                 printf("[%-*.*s]", width - 2, width - 2, name);
    371         }
     403        printf("[exc   ] [count   ] [%%count] [cycles  ] [%%cycles] [description");
    372404        screen_newline();
    373405        screen_style_normal();
    374406}
    375407
    376 static inline void print_table(const table_t *table)
     408static inline void print_excs(data_t *data)
    377409{
    378410        sysarg_t cols;
    … …  
    385417       
    386418        size_t i;
    387         for (i = 0; (i < table->num_fields) && (row < rows); i++) {
    388                 size_t column_index = i % table->num_columns;
    389                 int width = table->columns[column_index].width;
    390                 field_t *field = &table->fields[i];
    391 
    392                 if (column_index != 0) {
    393                         puts(" ");
    394                 }
    395 
    396                 if (width == 0) {
    397                         screen_get_pos(&col, &row);
    398                         width = cols - col - 1;
    399                 }
    400 
    401                 switch (field->type) {
    402                 case FIELD_EMPTY:
    403                         printf("%*s", width, "");
    404                         break;
    405                 case FIELD_UINT:
    406                         printf("%*" PRIu64, width, field->uint);
    407                         break;
    408                 case FIELD_UINT_SUFFIX_BIN: {
    409                         uint64_t val = field->uint;
    410                         const char *suffix;
    411                         width -= 3;
    412                         bin_order_suffix(val, &val, &suffix, true);
    413                         printf("%*" PRIu64 "%s", width, val, suffix);
    414                         break;
    415                 }
    416                 case FIELD_UINT_SUFFIX_DEC: {
    417                         uint64_t val = field->uint;
    418                         char suffix;
    419                         width -= 1;
    420                         order_suffix(val, &val, &suffix);
    421                         printf("%*" PRIu64 "%c", width, val, suffix);
    422                         break;
    423                 }
    424                 case FIELD_PERCENT:
    425                         width -= 5; /* nnn.% */
    426                         if (width > 2) {
    427                                 printf("%*s", width - 2, "");
    428                                 width = 2;
    429                         }
    430                         print_percent(field->fixed, width);
    431                         break;
    432                 case FIELD_STRING:
    433                         printf("%-*.*s", width, width, field->string);
    434                         break;
    435                 }
    436 
    437                 if (column_index == table->num_columns - 1) {
    438                         screen_newline();
    439                         row++;
    440                 }
     419        for (i = 0; (i < data->exceptions_count) && (row < rows); i++) {
     420                /* Filter-out cold exceptions if not instructed otherwise */
     421                if ((!excs_all) && (!data->exceptions[i].hot))
     422                        continue;
     423               
     424                uint64_t count;
     425                uint64_t cycles;
     426               
     427                char count_suffix;
     428                char cycles_suffix;
     429               
     430                order_suffix(data->exceptions[i].count, &count, &count_suffix);
     431                order_suffix(data->exceptions[i].cycles, &cycles, &cycles_suffix);
     432               
     433                printf("%-8u %9" PRIu64 "%c  ",
     434                     data->exceptions[i].id, count, count_suffix);
     435                print_percent(data->exceptions_perc[i].count, 2);
     436                printf(" %9" PRIu64 "%c   ", cycles, cycles_suffix);
     437                print_percent(data->exceptions_perc[i].cycles, 2);
     438                puts(" ");
     439                print_string(data->exceptions[i].desc);
     440               
     441                screen_newline();
     442                row++;
    441443        }
    442444       
    … …  
    447449}
    448450
    449 static inline void print_sort(table_t *table)
     451static void print_help(void)
    450452{
    451453        sysarg_t cols;
    … …  
    456458        sysarg_t row;
    457459        screen_get_pos(&col, &row);
    458 
    459         size_t num = min(table->num_columns, rows - row);
    460         for (size_t i = 0; i < num; i++) {
    461                 printf("%c - %s", table->columns[i].key, table->columns[i].name);
     460       
     461        screen_newline();
     462       
     463        printf("Operation modes:");
     464        screen_newline();
     465       
     466        printf(" t .. tasks statistics");
     467        screen_newline();
     468       
     469        printf(" i .. IPC statistics");
     470        screen_newline();
     471       
     472        printf(" e .. exceptions statistics");
     473        screen_newline();
     474       
     475        printf("      a .. toggle display of all/hot exceptions");
     476        screen_newline();
     477       
     478        row += 6;
     479       
     480        while (row < rows) {
    462481                screen_newline();
    463482                row++;
    464483        }
    465        
    466         while (row < rows) {
    467                 screen_newline();
    468                 row++;
    469         }
    470 }
    471 
    472 static inline void print_warning(void)
    473 {
    474         screen_get_pos(&warning_col, &warning_row);
    475         if (warning_timeleft > 0) {
    476                 screen_style_emphasis();
    477                 print_string(warning_text);
    478                 screen_style_normal();
    479         } else {
    480                 free(warning_text);
    481                 warning_text = NULL;
    482         }
    483         screen_newline();
    484484}
    485485
    … …  
    492492        print_cpu_info(data);
    493493        print_physmem_info(data);
    494         print_warning();
    495        
    496         switch (screen_mode) {
    497         case SCREEN_TABLE:
    498                 print_table_head(&data->table);
    499                 print_table(&data->table);
     494       
     495        /* Empty row for warnings */
     496        screen_get_pos(&warn_col, &warn_row);
     497        screen_newline();
     498       
     499        switch (op_mode) {
     500        case OP_TASKS:
     501                print_tasks_head();
     502                print_tasks(data);
    500503                break;
    501         case SCREEN_SORT:
    502                 print_sort(&data->table);
     504        case OP_IPC:
     505                print_ipc_head();
     506                print_ipc(data);
    503507                break;
    504         case SCREEN_HELP:
    505                 print_help_head();
     508        case OP_EXCS:
     509                print_excs_head();
     510                print_excs(data);
     511                break;
     512        case OP_HELP:
     513                print_tasks_head();
    506514                print_help();
    507515        }
    … …  
    510518}
    511519
    512 void show_warning(const char *fmt, ...)
    513 {
    514         sysarg_t cols;
    515         sysarg_t rows;
    516         screen_get_size(&cols, &rows);
    517 
    518         size_t warning_text_size = 1 + cols * sizeof(*warning_text);
    519         free(warning_text);
    520         warning_text = malloc(warning_text_size);
    521         if (!warning_text)
    522                 return;
    523 
     520void print_warning(const char *fmt, ...)
     521{
     522        screen_moveto(warn_col, warn_row);
     523       
    524524        va_list args;
    525525        va_start(args, fmt);
    526         vsnprintf(warning_text, warning_text_size, fmt, args);
     526        vprintf(fmt, args);
    527527        va_end(args);
    528528       
    529         warning_timeleft = 2 * USEC_COUNT;
    530 
    531         screen_moveto(warning_col, warning_row);
    532         print_warning();
     529        screen_newline();
    533530        console_flush(console);
    534531}
    … …  
    558555                cons_event_t event;
    559556               
    560                 warning_timeleft -= timeleft;
    561557                if (!console_get_event_timeout(console, &event, &timeleft)) {
    562558                        timeleft = 0;
    563559                        return -1;
    564560                }
    565                 warning_timeleft += timeleft;
    566561               
    567562                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)

  • uspace/dist/src/c/demos/top/screen.h

    r235d31d r759ea0d  
    4444extern void screen_done(void);
    4545extern void print_data(data_t *);
    46 extern void show_warning(const char *, ...)
     46extern void print_warning(const char *, ...)
    4747    PRINTF_ATTRIBUTE(1, 2);
    4848

  • uspace/dist/src/c/demos/top/top.c

    r235d31d r759ea0d  
    5555#define MINUTE  60
    5656
    57 typedef enum {
    58         OP_TASKS,
    59         OP_IPC,
    60         OP_EXCS,
    61 } op_mode_t;
    62 
    63 static const column_t task_columns[] = {
    64         {"taskid",   't',  8},
    65         {"thrds",    'h',  7},
    66         {"resident", 'r', 10},
    67         {"%resi",    'R',  7},
    68         {"virtual",  'v',  9},
    69         {"%virt",    'V',  7},
    70         {"%user",    'U',  7},
    71         {"%kern",    'K',  7},
    72         {"name",     'd',  0},
    73 };
    74 
    75 enum {
    76         TASK_COL_ID = 0,
    77         TASK_COL_NUM_THREADS,
    78         TASK_COL_RESIDENT,
    79         TASK_COL_PERCENT_RESIDENT,
    80         TASK_COL_VIRTUAL,
    81         TASK_COL_PERCENT_VIRTUAL,
    82         TASK_COL_PERCENT_USER,
    83         TASK_COL_PERCENT_KERNEL,
    84         TASK_COL_NAME,
    85         TASK_NUM_COLUMNS,
    86 };
    87 
    88 static const column_t ipc_columns[] = {
    89         {"taskid",  't', 8},
    90         {"cls snt", 'c', 9},
    91         {"cls rcv", 'C', 9},
    92         {"ans snt", 'a', 9},
    93         {"ans rcv", 'A', 9},
    94         {"forward", 'f', 9},
    95         {"name",    'd', 0},
    96 };
    97 
    98 enum {
    99         IPC_COL_TASKID = 0,
    100         IPC_COL_CLS_SNT,
    101         IPC_COL_CLS_RCV,
    102         IPC_COL_ANS_SNT,
    103         IPC_COL_ANS_RCV,
    104         IPC_COL_FORWARD,
    105         IPC_COL_NAME,
    106         IPC_NUM_COLUMNS,
    107 };
    108 
    109 static const column_t exception_columns[] = {
    110         {"exc",         'e',  8},
    111         {"count",       'n', 10},
    112         {"%count",      'N',  8},
    113         {"cycles",      'c', 10},
    114         {"%cycles",     'C',  9},
    115         {"description", 'd',  0},
    116 };
    117 
    118 enum {
    119         EXCEPTION_COL_ID = 0,
    120         EXCEPTION_COL_COUNT,
    121         EXCEPTION_COL_PERCENT_COUNT,
    122         EXCEPTION_COL_CYCLES,
    123         EXCEPTION_COL_PERCENT_CYCLES,
    124         EXCEPTION_COL_DESCRIPTION,
    125         EXCEPTION_NUM_COLUMNS,
    126 };
    127 
    128 screen_mode_t screen_mode = SCREEN_TABLE;
    129 static op_mode_t op_mode = OP_TASKS;
    130 static size_t sort_column = TASK_COL_PERCENT_USER;
    131 static int sort_reverse = -1;
    132 static bool excs_all = false;
     57op_mode_t op_mode = OP_TASKS;
     58sort_mode_t sort_mode = SORT_TASK_CYCLES;
     59bool excs_all = false;
    13360
    13461static const char *read_data(data_t *target)
    … …  
    14067        target->tasks = NULL;
    14168        target->tasks_perc = NULL;
     69        target->tasks_map = NULL;
    14270        target->threads = NULL;
    14371        target->exceptions = NULL;
    … …  
    14876        target->ecycles_diff = NULL;
    14977        target->ecount_diff = NULL;
    150         target->table.name = NULL;
    151         target->table.num_columns = 0;
    152         target->table.columns = NULL;
    153         target->table.num_fields = 0;
    154         target->table.fields = NULL;
    15578       
    15679        /* Get current time */
    15780        struct timeval time;
    158         gettimeofday(&time, NULL);
     81        if (gettimeofday(&time, NULL) != EOK)
     82                return "Cannot get time of day";
    15983       
    16084        target->hours = (time.tv_sec % DAY) / HOUR;
    … …  
    16387       
    16488        /* Get uptime */
    165         struct timeval uptime;
    166         getuptime(&uptime);
    167        
    168         target->udays = uptime.tv_sec / DAY;
    169         target->uhours = (uptime.tv_sec % DAY) / HOUR;
    170         target->uminutes = (uptime.tv_sec % HOUR) / MINUTE;
    171         target->useconds = uptime.tv_sec % MINUTE;
     89        sysarg_t uptime = stats_get_uptime();
     90        target->udays = uptime / DAY;
     91        target->uhours = (uptime % DAY) / HOUR;
     92        target->uminutes = (uptime % HOUR) / MINUTE;
     93        target->useconds = uptime % MINUTE;
    17294       
    17395        /* Get load */
    … …  
    195117        if (target->tasks_perc == NULL)
    196118                return "Not enough memory for task utilization";
     119       
     120        target->tasks_map =
     121            (size_t *) calloc(target->tasks_count, sizeof(size_t));
     122        if (target->tasks_map == NULL)
     123                return "Not enough memory for task map";
    197124       
    198125        /* Get threads */
    … …  
    362289static int cmp_data(void *a, void *b, void *arg)
    363290{
    364         field_t *fa = (field_t *)a + sort_column;
    365         field_t *fb = (field_t *)b + sort_column;
    366        
    367         if (fa->type > fb->type)
    368                 return 1 * sort_reverse;
    369 
    370         if (fa->type < fb->type)
    371                 return -1 * sort_reverse;
    372 
    373         switch (fa->type) {
    374         case FIELD_EMPTY:
    375                 return 0;
    376         case FIELD_UINT_SUFFIX_BIN: /* fallthrough */
    377         case FIELD_UINT_SUFFIX_DEC: /* fallthrough */
    378         case FIELD_UINT:
    379                 if (fa->uint > fb->uint)
    380                         return 1 * sort_reverse;
    381                 if (fa->uint < fb->uint)
    382                         return -1 * sort_reverse;
    383                 return 0;
    384         case FIELD_PERCENT:
    385                 if (fa->fixed.upper * fb->fixed.lower
    386                     > fb->fixed.upper * fa->fixed.lower)
    387                         return 1 * sort_reverse;
    388                 if (fa->fixed.upper * fb->fixed.lower
    389                     < fb->fixed.upper * fa->fixed.lower)
    390                         return -1 * sort_reverse;
    391                 return 0;
    392         case FIELD_STRING:
    393                 return str_cmp(fa->string, fb->string) * sort_reverse;
    394         }
    395 
     291        size_t ia = *((size_t *) a);
     292        size_t ib = *((size_t *) b);
     293        data_t *data = (data_t *) arg;
     294       
     295        uint64_t acycles = data->ucycles_diff[ia] + data->kcycles_diff[ia];
     296        uint64_t bcycles = data->ucycles_diff[ib] + data->kcycles_diff[ib];
     297       
     298        if (acycles > bcycles)
     299                return -1;
     300       
     301        if (acycles < bcycles)
     302                return 1;
     303       
    396304        return 0;
    397305}
    398306
    399 static void sort_table(table_t *table)
    400 {
    401         if (sort_column >= table->num_columns)
    402                 sort_column = 0;
    403         /* stable sort is probably best, so we use gsort */
    404         gsort((void *) table->fields, table->num_fields / table->num_columns,
    405             sizeof(field_t) * table->num_columns, cmp_data, NULL);
    406 }
    407 
    408 static const char *fill_task_table(data_t *data)
    409 {
    410         data->table.name = "Tasks";
    411         data->table.num_columns = TASK_NUM_COLUMNS;
    412         data->table.columns = task_columns;
    413         data->table.num_fields = data->tasks_count * TASK_NUM_COLUMNS;
    414         data->table.fields = calloc(data->table.num_fields,
    415             sizeof(field_t));
    416         if (data->table.fields == NULL)
    417                 return "Not enough memory for table fields";
    418 
    419         field_t *field = data->table.fields;
    420         for (size_t i = 0; i < data->tasks_count; i++) {
    421                 stats_task_t *task = &data->tasks[i];
    422                 perc_task_t *perc = &data->tasks_perc[i];
    423                 field[TASK_COL_ID].type = FIELD_UINT;
    424                 field[TASK_COL_ID].uint = task->task_id;
    425                 field[TASK_COL_NUM_THREADS].type = FIELD_UINT;
    426                 field[TASK_COL_NUM_THREADS].uint = task->threads;
    427                 field[TASK_COL_RESIDENT].type = FIELD_UINT_SUFFIX_BIN;
    428                 field[TASK_COL_RESIDENT].uint = task->resmem;
    429                 field[TASK_COL_PERCENT_RESIDENT].type = FIELD_PERCENT;
    430                 field[TASK_COL_PERCENT_RESIDENT].fixed = perc->resmem;
    431                 field[TASK_COL_VIRTUAL].type = FIELD_UINT_SUFFIX_BIN;
    432                 field[TASK_COL_VIRTUAL].uint = task->virtmem;
    433                 field[TASK_COL_PERCENT_VIRTUAL].type = FIELD_PERCENT;
    434                 field[TASK_COL_PERCENT_VIRTUAL].fixed = perc->virtmem;
    435                 field[TASK_COL_PERCENT_USER].type = FIELD_PERCENT;
    436                 field[TASK_COL_PERCENT_USER].fixed = perc->ucycles;
    437                 field[TASK_COL_PERCENT_KERNEL].type = FIELD_PERCENT;
    438                 field[TASK_COL_PERCENT_KERNEL].fixed = perc->kcycles;
    439                 field[TASK_COL_NAME].type = FIELD_STRING;
    440                 field[TASK_COL_NAME].string = task->name;
    441                 field += TASK_NUM_COLUMNS;
    442         }
    443 
    444         return NULL;
    445 }
    446 
    447 static const char *fill_ipc_table(data_t *data)
    448 {
    449         data->table.name = "IPC";
    450         data->table.num_columns = IPC_NUM_COLUMNS;
    451         data->table.columns = ipc_columns;
    452         data->table.num_fields = data->tasks_count * IPC_NUM_COLUMNS;
    453         data->table.fields = calloc(data->table.num_fields,
    454             sizeof(field_t));
    455         if (data->table.fields == NULL)
    456                 return "Not enough memory for table fields";
    457 
    458         field_t *field = data->table.fields;
    459         for (size_t i = 0; i < data->tasks_count; i++) {
    460                 field[IPC_COL_TASKID].type = FIELD_UINT;
    461                 field[IPC_COL_TASKID].uint = data->tasks[i].task_id;
    462                 field[IPC_COL_CLS_SNT].type = FIELD_UINT_SUFFIX_DEC;
    463                 field[IPC_COL_CLS_SNT].uint = data->tasks[i].ipc_info.call_sent;
    464                 field[IPC_COL_CLS_RCV].type = FIELD_UINT_SUFFIX_DEC;
    465                 field[IPC_COL_CLS_RCV].uint = data->tasks[i].ipc_info.call_received;
    466                 field[IPC_COL_ANS_SNT].type = FIELD_UINT_SUFFIX_DEC;
    467                 field[IPC_COL_ANS_SNT].uint = data->tasks[i].ipc_info.answer_sent;
    468                 field[IPC_COL_ANS_RCV].type = FIELD_UINT_SUFFIX_DEC;
    469                 field[IPC_COL_ANS_RCV].uint = data->tasks[i].ipc_info.answer_received;
    470                 field[IPC_COL_FORWARD].type = FIELD_UINT_SUFFIX_DEC;
    471                 field[IPC_COL_FORWARD].uint = data->tasks[i].ipc_info.forwarded;
    472                 field[IPC_COL_NAME].type = FIELD_STRING;
    473                 field[IPC_COL_NAME].string = data->tasks[i].name;
    474                 field += IPC_NUM_COLUMNS;
    475         }
    476 
    477         return NULL;
    478 }
    479 
    480 static const char *fill_exception_table(data_t *data)
    481 {
    482         data->table.name = "Exceptions";
    483         data->table.num_columns = EXCEPTION_NUM_COLUMNS;
    484         data->table.columns = exception_columns;
    485         data->table.num_fields = data->exceptions_count *
    486             EXCEPTION_NUM_COLUMNS;
    487         data->table.fields = calloc(data->table.num_fields, sizeof(field_t));
    488         if (data->table.fields == NULL)
    489                 return "Not enough memory for table fields";
    490 
    491         field_t *field = data->table.fields;
    492         for (size_t i = 0; i < data->exceptions_count; i++) {
    493                 if (!excs_all && !data->exceptions[i].hot)
    494                         continue;
    495                 field[EXCEPTION_COL_ID].type = FIELD_UINT;
    496                 field[EXCEPTION_COL_ID].uint = data->exceptions[i].id;
    497                 field[EXCEPTION_COL_COUNT].type = FIELD_UINT_SUFFIX_DEC;
    498                 field[EXCEPTION_COL_COUNT].uint = data->exceptions[i].count;
    499                 field[EXCEPTION_COL_PERCENT_COUNT].type = FIELD_PERCENT;
    500                 field[EXCEPTION_COL_PERCENT_COUNT].fixed = data->exceptions_perc[i].count;
    501                 field[EXCEPTION_COL_CYCLES].type = FIELD_UINT_SUFFIX_DEC;
    502                 field[EXCEPTION_COL_CYCLES].uint = data->exceptions[i].cycles;
    503                 field[EXCEPTION_COL_PERCENT_CYCLES].type = FIELD_PERCENT;
    504                 field[EXCEPTION_COL_PERCENT_CYCLES].fixed = data->exceptions_perc[i].cycles;
    505                 field[EXCEPTION_COL_DESCRIPTION].type = FIELD_STRING;
    506                 field[EXCEPTION_COL_DESCRIPTION].string = data->exceptions[i].desc;
    507                 field += EXCEPTION_NUM_COLUMNS;
    508         }
    509 
    510         /* in case any cold exceptions were ignored */
    511         data->table.num_fields = field - data->table.fields;
    512 
    513         return NULL;
    514 }
    515 
    516 static const char *fill_table(data_t *data)
    517 {
    518         if (data->table.fields != NULL) {
    519                 free(data->table.fields);
    520                 data->table.fields = NULL;
    521         }
    522 
    523         switch (op_mode) {
    524         case OP_TASKS:
    525                 return fill_task_table(data);
    526         case OP_IPC:
    527                 return fill_ipc_table(data);
    528         case OP_EXCS:
    529                 return fill_exception_table(data);
    530         }
    531         return NULL;
     307static void sort_data(data_t *data)
     308{
     309        size_t i;
     310       
     311        for (i = 0; i < data->tasks_count; i++)
     312                data->tasks_map[i] = i;
     313       
     314        qsort((void *) data->tasks_map, data->tasks_count,
     315            sizeof(size_t), cmp_data, (void *) data);
    532316}
    533317
    … …  
    572356        if (target->ecount_diff != NULL)
    573357                free(target->ecount_diff);
    574 
    575         if (target->table.fields != NULL)
    576                 free(target->table.fields);
    577358}
    578359
    … …  
    586367        printf("Reading initial data...\n");
    587368       
    588         if ((ret = read_data(&data)) != NULL)
     369        if ((ret = read_data(&data_prev)) != NULL)
    589370                goto out;
    590371       
    591372        /* Compute some rubbish to have initialised values */
    592         compute_percentages(&data, &data);
     373        compute_percentages(&data_prev, &data_prev);
    593374       
    594375        /* And paint screen until death */
    595376        while (true) {
    596377                int c = tgetchar(UPDATE_INTERVAL);
    597 
    598                 if (c < 0) { /* timeout */
    599                         data_prev = data;
     378                if (c < 0) {
    600379                        if ((ret = read_data(&data)) != NULL) {
    601                                 free_data(&data_prev);
     380                                free_data(&data);
    602381                                goto out;
    603382                        }
    604383                       
    605384                        compute_percentages(&data_prev, &data);
     385                        sort_data(&data);
     386                        print_data(&data);
    606387                        free_data(&data_prev);
    607 
    608                         c = -1;
    609                 }
    610 
    611                 if (screen_mode == SCREEN_HELP && c >= 0) {
    612                         if (c == 'h' || c == '?')
    613                                 c = -1;
    614                         /* go back to table and handle the key */
    615                         screen_mode = SCREEN_TABLE;
    616                 }
    617 
    618                 if (screen_mode == SCREEN_SORT && c >= 0) {
    619                         for (size_t i = 0; i < data.table.num_columns; i++) {
    620                                 if (data.table.columns[i].key == c) {
    621                                         sort_column = i;
    622                                         screen_mode = SCREEN_TABLE;
     388                        data_prev = data;
     389                       
     390                        continue;
     391                }
     392               
     393                switch (c) {
     394                        case 't':
     395                                print_warning("Showing task statistics");
     396                                op_mode = OP_TASKS;
     397                                break;
     398                        case 'i':
     399                                print_warning("Showing IPC statistics");
     400                                op_mode = OP_IPC;
     401                                break;
     402                        case 'e':
     403                                print_warning("Showing exception statistics");
     404                                op_mode = OP_EXCS;
     405                                break;
     406                        case 'h':
     407                                print_warning("Showing help");
     408                                op_mode = OP_HELP;
     409                                break;
     410                        case 'q':
     411                                goto out;
     412                        case 'a':
     413                                if (op_mode == OP_EXCS) {
     414                                        excs_all = !excs_all;
     415                                        if (excs_all)
     416                                                print_warning("Showing all exceptions");
     417                                        else
     418                                                print_warning("Showing only hot exceptions");
     419                                        break;
    623420                                }
    624                         }
    625 
    626                         c = -1;
    627                 }
    628 
    629                 switch (c) {
    630                 case -1: /* do nothing */
    631                         break;
    632                 case 't':
    633                         op_mode = OP_TASKS;
    634                         break;
    635                 case 'i':
    636                         op_mode = OP_IPC;
    637                         break;
    638                 case 'e':
    639                         op_mode = OP_EXCS;
    640                         break;
    641                 case 's':
    642                         screen_mode = SCREEN_SORT;
    643                         break;
    644                 case 'r':
    645                         sort_reverse = -sort_reverse;
    646                         break;
    647                 case 'h':
    648                 case '?':
    649                         screen_mode = SCREEN_HELP;
    650                         break;
    651                 case 'q':
    652                         goto out;
    653                 case 'a':
    654                         if (op_mode == OP_EXCS) {
    655                                 excs_all = !excs_all;
    656                                 if (excs_all)
    657                                         show_warning("Showing all exceptions");
    658                                 else
    659                                         show_warning("Showing only hot exceptions");
    660                                 break;
    661                         }
    662                         /* fallthrough */
    663                 default:
    664                         show_warning("Unknown command \"%c\", use \"h\" for help", c);
    665                         continue; /* don't redraw */
    666                 }
    667 
    668                 if ((ret = fill_table(&data)) != NULL) {
    669                         goto out;
    670                 }
    671                 sort_table(&data.table);
    672                 print_data(&data);
     421                        default:
     422                                print_warning("Unknown command \"%c\", use \"h\" for help", c);
     423                                break;
     424                }
    673425        }
    674426       
    675427out:
    676428        screen_done();
    677         free_data(&data);
     429        free_data(&data_prev);
    678430       
    679431        if (ret != NULL) {

  • uspace/dist/src/c/demos/top/top.h

    r235d31d r759ea0d  
    5151
    5252typedef enum {
    53         SCREEN_TABLE,
    54         SCREEN_SORT,
    55         SCREEN_HELP,
    56 } screen_mode_t;
     53        OP_TASKS,
     54        OP_IPC,
     55        OP_EXCS,
     56        OP_HELP
     57} op_mode_t;
    5758
    58 extern screen_mode_t screen_mode;
     59typedef enum {
     60        SORT_TASK_CYCLES
     61} sort_mode_t;
     62
     63extern op_mode_t op_mode;
     64extern sort_mode_t sort_mode;
     65extern bool excs_all;
    5966
    6067typedef struct {
    … …  
    8087} perc_exc_t;
    8188
    82 typedef enum {
    83         FIELD_EMPTY, FIELD_UINT, FIELD_UINT_SUFFIX_BIN, FIELD_UINT_SUFFIX_DEC,
    84         FIELD_PERCENT, FIELD_STRING
    85 } field_type_t;
    86 
    87 typedef struct {
    88         field_type_t type;
    89         union {
    90                 fixed_float fixed;
    91                 uint64_t uint;
    92                 const char *string;
    93         };
    94 } field_t;
    95 
    96 typedef struct {
    97         const char *name;
    98         char key;
    99         int width;
    100 } column_t;
    101 
    102 typedef struct {
    103         const char *name;
    104         size_t num_columns;
    105         const column_t *columns;
    106         size_t num_fields;
    107         field_t *fields;
    108 } table_t;
    109 
    11089typedef struct {
    11190        time_t hours;
    … …  
    128107        stats_task_t *tasks;
    129108        perc_task_t *tasks_perc;
     109        size_t *tasks_map;
    130110       
    131111        size_t threads_count;
    … …  
    142122        uint64_t *ecycles_diff;
    143123        uint64_t *ecount_diff;
    144 
    145         table_t table;
    146124} data_t;
    147125

  • uspace/drv/char/i8042/main.c

    r235d31d r759ea0d  
    154154       
    155155        /*
    156          * Alleviate the virtual memory / page table pressure caused by
     156         * Alleviate the virtual memory / page table pressure caused by 
    157157         * interrupt storms when the default large stacks are used.
    158158         */

  • uspace/lib/c/generic/stats.c

    r235d31d r759ea0d  
    291291}
    292292
     293/** Get system uptime
     294 *
     295 * @return System uptime (in seconds).
     296 *
     297 */
     298sysarg_t stats_get_uptime(void)
     299{
     300        sysarg_t uptime;
     301        if (sysinfo_get_value("system.uptime", &uptime) != EOK)
     302                uptime = 0;
     303       
     304        return uptime;
     305}
     306
    293307/** Print load fixed-point value
    294308 *
    … …  
    302316void stats_print_load_fragment(load_t upper, unsigned int dec_length)
    303317{
     318        /* Magic value from BSD */
     319        load_t lower = 65536;
     320       
    304321        /* Print the whole part */
    305         printf("%u.", upper / LOAD_UNIT);
    306        
    307         load_t rest = (upper % LOAD_UNIT) * 10;
     322        printf("%u.", upper / lower);
     323       
     324        load_t rest = (upper % lower) * 10;
    308325       
    309326        unsigned int i;
    310327        for (i = 0; i < dec_length; i++) {
    311                 printf("%u", rest / LOAD_UNIT);
    312                 rest = (rest % LOAD_UNIT) * 10;
     328                printf("%u", rest / lower);
     329                rest = (rest % lower) * 10;
    313330        }
    314331}

  • uspace/lib/c/generic/time.c

    r235d31d r759ea0d  
    5454#include <malloc.h>
    5555
    56 #define ASCTIME_BUF_LEN  26
    57 
    58 #define HOURS_PER_DAY  24
    59 #define MINS_PER_HOUR  60
    60 #define SECS_PER_MIN   60
    61 #define MINS_PER_DAY   (MINS_PER_HOUR * HOURS_PER_DAY)
    62 #define SECS_PER_HOUR  (SECS_PER_MIN * MINS_PER_HOUR)
    63 #define SECS_PER_DAY   (SECS_PER_HOUR * HOURS_PER_DAY)
     56#define ASCTIME_BUF_LEN 26
    6457
    6558/** Pointer to kernel shared variables with time */
    … …  
    7063} *ktime = NULL;
    7164
    72 static async_sess_t *clock_conn = NULL;
    73 
    74 /** Check whether the year is a leap year.
     65/* Helper functions ***********************************************************/
     66
     67#define HOURS_PER_DAY (24)
     68#define MINS_PER_HOUR (60)
     69#define SECS_PER_MIN (60)
     70#define MINS_PER_DAY (MINS_PER_HOUR * HOURS_PER_DAY)
     71#define SECS_PER_HOUR (SECS_PER_MIN * MINS_PER_HOUR)
     72#define SECS_PER_DAY (SECS_PER_HOUR * HOURS_PER_DAY)
     73
     74/**
     75 * Checks whether the year is a leap year.
    7576 *
    7677 * @param year Year since 1900 (e.g. for 1970, the value is 70).
    77  *
    7878 * @return true if year is a leap year, false otherwise
    79  *
    80  */
    81 static bool is_leap_year(time_t year)
     79 */
     80static bool _is_leap_year(time_t year)
    8281{
    8382        year += 1900;
    84        
     83
    8584        if (year % 400 == 0)
    8685                return true;
    87        
    8886        if (year % 100 == 0)
    8987                return false;
    90        
    9188        if (year % 4 == 0)
    9289                return true;
    93        
    9490        return false;
    9591}
    9692
    97 /** How many days there are in the given month
    98  *
    99  * Return how many days there are in the given month of the given year.
     93/**
     94 * Returns how many days there are in the given month of the given year.
    10095 * Note that year is only taken into account if month is February.
    10196 *
    10297 * @param year Year since 1900 (can be negative).
    103  * @param mon  Month of the year. 0 for January, 11 for December.
    104  *
     98 * @param mon Month of the year. 0 for January, 11 for December.
    10599 * @return Number of days in the specified month.
    106  *
    107  */
    108 static int days_in_month(time_t year, time_t mon)
    109 {
    110         assert(mon >= 0);
    111         assert(mon <= 11);
    112        
    113         static int month_days[] = {
    114                 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
    115         };
    116        
     100 */
     101static int _days_in_month(time_t year, time_t mon)
     102{
     103        assert(mon >= 0 && mon <= 11);
     104
     105        static int month_days[] =
     106                { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
     107
    117108        if (mon == 1) {
    118                 /* February */
    119109                year += 1900;
    120                 return is_leap_year(year) ? 29 : 28;
    121         }
    122        
    123         return month_days[mon];
    124 }
    125 
    126 /** Which day of that year it is.
    127  *
    128  * For specified year, month and day of month, return which day of that year
     110                /* february */
     111                return _is_leap_year(year) ? 29 : 28;
     112        } else {
     113                return month_days[mon];
     114        }
     115}
     116
     117/**
     118 * For specified year, month and day of month, returns which day of that year
    129119 * it is.
    130120 *
    131121 * For example, given date 2011-01-03, the corresponding expression is:
    132  * day_of_year(111, 0, 3) == 2
     122 *     _day_of_year(111, 0, 3) == 2
    133123 *
    134124 * @param year Year (year 1900 = 0, can be negative).
    135  * @param mon  Month (January = 0).
     125 * @param mon Month (January = 0).
    136126 * @param mday Day of month (First day is 1).
    137  *
    138127 * @return Day of year (First day is 0).
    139  *
    140  */
    141 static int day_of_year(time_t year, time_t mon, time_t mday)
    142 {
    143         static int mdays[] = {
    144                 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
    145         };
    146        
    147         static int leap_mdays[] = {
    148                 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
    149         };
    150        
    151         return (is_leap_year(year) ? leap_mdays[mon] : mdays[mon]) + mday - 1;
    152 }
    153 
    154 /** Integer division that rounds to negative infinity.
    155  *
    156  * Used by some functions in this module.
     128 */
     129static int _day_of_year(time_t year, time_t mon, time_t mday)
     130{
     131        static int mdays[] =
     132            { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
     133        static int leap_mdays[] =
     134            { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
     135
     136        return (_is_leap_year(year) ? leap_mdays[mon] : mdays[mon]) + mday - 1;
     137}
     138
     139/**
     140 * Integer division that rounds to negative infinity.
     141 * Used by some functions in this file.
    157142 *
    158143 * @param op1 Dividend.
    159144 * @param op2 Divisor.
    160  *
    161145 * @return Rounded quotient.
    162  *
    163  */
    164 static time_t floor_div(time_t op1, time_t op2)
    165 {
    166         if ((op1 >= 0) || (op1 % op2 == 0))
     146 */
     147static time_t _floor_div(time_t op1, time_t op2)
     148{
     149        if (op1 >= 0 || op1 % op2 == 0) {
    167150                return op1 / op2;
    168        
    169         return op1 / op2 - 1;
    170 }
    171 
    172 /** Modulo that rounds to negative infinity.
    173  *
    174  * Used by some functions in this module.
     151        } else {
     152                return op1 / op2 - 1;
     153        }
     154}
     155
     156/**
     157 * Modulo that rounds to negative infinity.
     158 * Used by some functions in this file.
    175159 *
    176160 * @param op1 Dividend.
    177161 * @param op2 Divisor.
    178  *
    179162 * @return Remainder.
    180  *
    181  */
    182 static time_t floor_mod(time_t op1, time_t op2)
    183 {
    184         time_t div = floor_div(op1, op2);
    185        
    186         /*
    187          * (a / b) * b + a % b == a
    188          * Thus: a % b == a - (a / b) * b
    189          */
    190        
    191         time_t result = op1 - div * op2;
    192        
    193         /* Some paranoid checking to ensure there is mistake here. */
     163 */
     164static time_t _floor_mod(time_t op1, time_t op2)
     165{
     166        int div = _floor_div(op1, op2);
     167
     168        /* (a / b) * b + a % b == a */
     169        /* thus, a % b == a - (a / b) * b */
     170
     171        int result = op1 - div * op2;
     172       
     173        /* Some paranoid checking to ensure I didn't make a mistake here. */
    194174        assert(result >= 0);
    195175        assert(result < op2);
    … …  
    199179}
    200180
    201 /** Number of days since the Epoch.
    202  *
     181/**
     182 * Number of days since the Epoch.
    203183 * Epoch is 1970-01-01, which is also equal to day 0.
    204184 *
    205185 * @param year Year (year 1900 = 0, may be negative).
    206  * @param mon  Month (January = 0).
     186 * @param mon Month (January = 0).
    207187 * @param mday Day of month (first day = 1).
    208  *
    209188 * @return Number of days since the Epoch.
    210  *
    211  */
    212 static time_t days_since_epoch(time_t year, time_t mon, time_t mday)
    213 {
    214         return (year - 70) * 365 + floor_div(year - 69, 4) -
    215             floor_div(year - 1, 100) + floor_div(year + 299, 400) +
    216             day_of_year(year, mon, mday);
    217 }
    218 
    219 /** Seconds since the Epoch.
    220  *
    221  * See also days_since_epoch().
    222  *
     189 */
     190static time_t _days_since_epoch(time_t year, time_t mon, time_t mday)
     191{
     192        return (year - 70) * 365 + _floor_div(year - 69, 4) -
     193            _floor_div(year - 1, 100) + _floor_div(year + 299, 400) +
     194            _day_of_year(year, mon, mday);
     195}
     196
     197/**
     198 * Seconds since the Epoch. see also _days_since_epoch().
     199 *
    223200 * @param tm Normalized broken-down time.
    224  *
    225201 * @return Number of seconds since the epoch, not counting leap seconds.
    226  *
    227  */
    228 static time_t secs_since_epoch(const struct tm *tm)
    229 {
    230         return days_since_epoch(tm->tm_year, tm->tm_mon, tm->tm_mday) *
     202 */
     203static time_t _secs_since_epoch(const struct tm *tm)
     204{
     205        return _days_since_epoch(tm->tm_year, tm->tm_mon, tm->tm_mday) *
    231206            SECS_PER_DAY + tm->tm_hour * SECS_PER_HOUR +
    232207            tm->tm_min * SECS_PER_MIN + tm->tm_sec;
    233208}
    234209
    235 /** Which day of week the specified date is.
    236  *
     210/**
     211 * Which day of week the specified date is.
     212 *
    237213 * @param year Year (year 1900 = 0).
    238  * @param mon  Month (January = 0).
     214 * @param mon Month (January = 0).
    239215 * @param mday Day of month (first = 1).
    240  *
    241216 * @return Day of week (Sunday = 0).
    242  *
    243  */
    244 static time_t day_of_week(time_t year, time_t mon, time_t mday)
     217 */
     218static int _day_of_week(time_t year, time_t mon, time_t mday)
    245219{
    246220        /* 1970-01-01 is Thursday */
    247         return floor_mod(days_since_epoch(year, mon, mday) + 4, 7);
    248 }
    249 
    250 /** Normalize the broken-down time.
    251  *
    252  * Optionally add specified amount of seconds.
    253  *
    254  * @param tm      Broken-down time to normalize.
     221        return _floor_mod((_days_since_epoch(year, mon, mday) + 4), 7);
     222}
     223
     224/**
     225 * Normalizes the broken-down time and optionally adds specified amount of
     226 * seconds.
     227 * 
     228 * @param tm Broken-down time to normalize.
    255229 * @param sec_add Seconds to add.
    256  *
    257230 * @return 0 on success, -1 on overflow
    258  *
    259  */
    260 static int normalize_time(struct tm *tm, time_t sec_add)
     231 */
     232static int _normalize_time(struct tm *tm, time_t sec_add)
    261233{
    262234        // TODO: DST correction
    263        
     235
    264236        /* Set initial values. */
    265237        time_t sec = tm->tm_sec + sec_add;
    … …  
    269241        time_t mon = tm->tm_mon;
    270242        time_t year = tm->tm_year;
    271        
     243
    272244        /* Adjust time. */
    273         min += floor_div(sec, SECS_PER_MIN);
    274         sec = floor_mod(sec, SECS_PER_MIN);
    275         hour += floor_div(min, MINS_PER_HOUR);
    276         min = floor_mod(min, MINS_PER_HOUR);
    277         day += floor_div(hour, HOURS_PER_DAY);
    278         hour = floor_mod(hour, HOURS_PER_DAY);
    279        
     245        min += _floor_div(sec, SECS_PER_MIN);
     246        sec = _floor_mod(sec, SECS_PER_MIN);
     247        hour += _floor_div(min, MINS_PER_HOUR);
     248        min = _floor_mod(min, MINS_PER_HOUR);
     249        day += _floor_div(hour, HOURS_PER_DAY);
     250        hour = _floor_mod(hour, HOURS_PER_DAY);
     251
    280252        /* Adjust month. */
    281         year += floor_div(mon, 12);
    282         mon = floor_mod(mon, 12);
    283        
     253        year += _floor_div(mon, 12);
     254        mon = _floor_mod(mon, 12);
     255
    284256        /* Now the difficult part - days of month. */
    285257       
    286258        /* First, deal with whole cycles of 400 years = 146097 days. */
    287         year += floor_div(day, 146097) * 400;
    288         day = floor_mod(day, 146097);
     259        year += _floor_div(day, 146097) * 400;
     260        day = _floor_mod(day, 146097);
    289261       
    290262        /* Then, go in one year steps. */
    … …  
    292264                /* January and February. */
    293265                while (day > 365) {
    294                         day -= is_leap_year(year) ? 366 : 365;
     266                        day -= _is_leap_year(year) ? 366 : 365;
    295267                        year++;
    296268                }
    … …  
    298270                /* Rest of the year. */
    299271                while (day > 365) {
    300                         day -= is_leap_year(year + 1) ? 366 : 365;
     272                        day -= _is_leap_year(year + 1) ? 366 : 365;
    301273                        year++;
    302274                }
    … …  
    304276       
    305277        /* Finally, finish it off month per month. */
    306         while (day >= days_in_month(year, mon)) {
    307                 day -= days_in_month(year, mon);
     278        while (day >= _days_in_month(year, mon)) {
     279                day -= _days_in_month(year, mon);
    308280                mon++;
    309                
    310281                if (mon >= 12) {
    311282                        mon -= 12;
    … …  
    315286       
    316287        /* Calculate the remaining two fields. */
    317         tm->tm_yday = day_of_year(year, mon, day + 1);
    318         tm->tm_wday = day_of_week(year, mon, day + 1);
     288        tm->tm_yday = _day_of_year(year, mon, day + 1);
     289        tm->tm_wday = _day_of_week(year, mon, day + 1);
    319290       
    320291        /* And put the values back to the struct. */
    … …  
    325296        tm->tm_mon = (int) mon;
    326297       
    327         /* Casts to work around POSIX brain-damage. */
    328         if (year > ((int) INT_MAX) || year < ((int) INT_MIN)) {
    329                 tm->tm_year = (year < 0) ? ((int) INT_MIN) : ((int) INT_MAX);
     298        /* Casts to work around libc brain-damage. */
     299        if (year > ((int)INT_MAX) || year < ((int)INT_MIN)) {
     300                tm->tm_year = (year < 0) ? ((int)INT_MIN) : ((int)INT_MAX);
    330301                return -1;
    331302        }
    … …  
    335306}
    336307
    337 /** Which day the week-based year starts on.
    338  *
    339  * Relative to the first calendar day. E.g. if the year starts
    340  * on December 31st, the return value is -1.
     308/**
     309 * Which day the week-based year starts on, relative to the first calendar day.
     310 * E.g. if the year starts on December 31st, the return value is -1.
    341311 *
    342312 * @param Year since 1900.
    343  *
    344313 * @return Offset of week-based year relative to calendar year.
    345  *
    346  */
    347 static int wbyear_offset(int year)
    348 {
    349         int start_wday = day_of_week(year, 0, 1);
    350        
    351         return floor_mod(4 - start_wday, 7) - 3;
    352 }
    353 
    354 /** Week-based year of the specified time.
     314 */
     315static int _wbyear_offset(int year)
     316{
     317        int start_wday = _day_of_week(year, 0, 1);
     318        return _floor_mod(4 - start_wday, 7) - 3;
     319}
     320
     321/**
     322 * Returns week-based year of the specified time.
    355323 *
    356324 * @param tm Normalized broken-down time.
    357  *
    358325 * @return Week-based year.
    359  *
    360  */
    361 static int wbyear(const struct tm *tm)
    362 {
    363         int day = tm->tm_yday - wbyear_offset(tm->tm_year);
    364        
     326 */
     327static int _wbyear(const struct tm *tm)
     328{
     329        int day = tm->tm_yday - _wbyear_offset(tm->tm_year);
    365330        if (day < 0) {
    366331                /* Last week of previous year. */
    367332                return tm->tm_year - 1;
    368333        }
    369        
    370         if (day > 364 + is_leap_year(tm->tm_year)) {
     334        if (day > 364 + _is_leap_year(tm->tm_year)) {
    371335                /* First week of next year. */
    372336                return tm->tm_year + 1;
    373337        }
    374        
    375338        /* All the other days are in the calendar year. */
    376339        return tm->tm_year;
    377340}
    378341
    379 /** Week number of the year (assuming weeks start on Sunday).
    380  *
     342/**
     343 * Week number of the year, assuming weeks start on sunday.
    381344 * The first Sunday of January is the first day of week 1;
    382345 * days in the new year before this are in week 0.
    383346 *
    384347 * @param tm Normalized broken-down time.
    385  *
    386348 * @return The week number (0 - 53).
    387  *
    388  */
    389 static int sun_week_number(const struct tm *tm)
    390 {
    391         int first_day = (7 - day_of_week(tm->tm_year, 0, 1)) % 7;
    392        
     349 */
     350static int _sun_week_number(const struct tm *tm)
     351{
     352        int first_day = (7 - _day_of_week(tm->tm_year, 0, 1)) % 7;
    393353        return (tm->tm_yday - first_day + 7) / 7;
    394354}
    395355
    396 /** Week number of the year (assuming weeks start on Monday).
    397  *
    398  * If the week containing January 1st has four or more days
    399  * in the new year, then it is considered week 1. Otherwise,
    400  * it is the last week of the previous year, and the next week
    401  * is week 1. Both January 4th and the first Thursday
     356/**
     357 * Week number of the year, assuming weeks start on monday.
     358 * If the week containing January 1st has four or more days in the new year,
     359 * then it is considered week 1. Otherwise, it is the last week of the previous
     360 * year, and the next week is week 1. Both January 4th and the first Thursday
    402361 * of January are always in week 1.
    403362 *
    404363 * @param tm Normalized broken-down time.
    405  *
    406364 * @return The week number (1 - 53).
    407  *
    408  */
    409 static int iso_week_number(const struct tm *tm)
    410 {
    411         int day = tm->tm_yday - wbyear_offset(tm->tm_year);
    412        
     365 */
     366static int _iso_week_number(const struct tm *tm)
     367{
     368        int day = tm->tm_yday - _wbyear_offset(tm->tm_year);
    413369        if (day < 0) {
    414370                /* Last week of previous year. */
    415371                return 53;
    416372        }
    417        
    418         if (day > 364 + is_leap_year(tm->tm_year)) {
     373        if (day > 364 + _is_leap_year(tm->tm_year)) {
    419374                /* First week of next year. */
    420375                return 1;
    421376        }
    422        
    423377        /* All the other days give correct answer. */
    424378        return (day / 7 + 1);
    425379}
    426380
    427 /** Week number of the year (assuming weeks start on Monday).
    428  *
     381/**
     382 * Week number of the year, assuming weeks start on monday.
    429383 * The first Monday of January is the first day of week 1;
    430  * days in the new year before this are in week 0.
     384 * days in the new year before this are in week 0. 
    431385 *
    432386 * @param tm Normalized broken-down time.
    433  *
    434387 * @return The week number (0 - 53).
    435  *
    436  */
    437 static int mon_week_number(const struct tm *tm)
    438 {
    439         int first_day = (1 - day_of_week(tm->tm_year, 0, 1)) % 7;
    440        
     388 */
     389static int _mon_week_number(const struct tm *tm)
     390{
     391        int first_day = (1 - _day_of_week(tm->tm_year, 0, 1)) % 7;
    441392        return (tm->tm_yday - first_day + 7) / 7;
    442393}
     394
     395/******************************************************************************/
     396
    443397
    444398/** Add microseconds to given timeval.
    … …  
    514468}
    515469
    516 /** Get time of day.
     470/** Get time of day
    517471 *
    518472 * The time variables are memory mapped (read-only) from kernel which
    … …  
    528482 *
    529483 */
    530 void gettimeofday(struct timeval *tv, struct timezone *tz)
    531 {
     484int gettimeofday(struct timeval *tv, struct timezone *tz)
     485{
     486        int rc;
     487        struct tm t;
     488        category_id_t cat_id;
     489        size_t svc_cnt;
     490        service_id_t *svc_ids = NULL;
     491        service_id_t svc_id;
     492        char *svc_name = NULL;
     493
     494        static async_sess_t *clock_conn = NULL;
     495
    532496        if (tz) {
    533497                tz->tz_minuteswest = 0;
    534498                tz->tz_dsttime = DST_NONE;
    535499        }
    536        
     500
    537501        if (clock_conn == NULL) {
    538                 category_id_t cat_id;
    539                 int rc = loc_category_get_id("clock", &cat_id, IPC_FLAG_BLOCKING);
     502                rc = loc_category_get_id("clock", &cat_id, IPC_FLAG_BLOCKING);
    540503                if (rc != EOK)
    541                         goto fallback;
    542                
    543                 service_id_t *svc_ids;
    544                 size_t svc_cnt;
     504                        goto ret_uptime;
     505
    545506                rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
    546507                if (rc != EOK)
    547                         goto fallback;
    548                
     508                        goto ret_uptime;
     509
    549510                if (svc_cnt == 0)
    550                         goto fallback;
    551                
    552                 char *svc_name;
     511                        goto ret_uptime;
     512
    553513                rc = loc_service_get_name(svc_ids[0], &svc_name);
    554                 free(svc_ids);
    555514                if (rc != EOK)
    556                         goto fallback;
    557                
    558                 service_id_t svc_id;
     515                        goto ret_uptime;
     516
    559517                rc = loc_service_get_id(svc_name, &svc_id, 0);
    560                 free(svc_name);
    561518                if (rc != EOK)
    562                         goto fallback;
    563                
     519                        goto ret_uptime;
     520
    564521                clock_conn = loc_service_connect(EXCHANGE_SERIALIZE,
    565522                    svc_id, IPC_FLAG_BLOCKING);
    566523                if (!clock_conn)
    567                         goto fallback;
    568         }
    569        
    570         struct tm time;
    571         int rc = clock_dev_time_get(clock_conn, &time);
     524                        goto ret_uptime;
     525        }
     526
     527        rc = clock_dev_time_get(clock_conn, &t);
    572528        if (rc != EOK)
    573                 goto fallback;
    574        
     529                goto ret_uptime;
     530
    575531        tv->tv_usec = 0;
    576         tv->tv_sec = mktime(&time);
    577        
    578         return;
    579        
    580 fallback:
    581         getuptime(tv);
    582 }
    583 
    584 void getuptime(struct timeval *tv)
     532        tv->tv_sec = mktime(&t);
     533
     534        free(svc_name);
     535        free(svc_ids);
     536
     537        return EOK;
     538
     539ret_uptime:
     540
     541        free(svc_name);
     542        free(svc_ids);
     543
     544        return getuptime(tv);
     545}
     546
     547int getuptime(struct timeval *tv)
    585548{
    586549        if (ktime == NULL) {
    … …  
    589552                if (rc != EOK) {
    590553                        errno = rc;
    591                         goto fallback;
     554                        return -1;
    592555                }
    593556               
    … …  
    598561                        as_area_destroy(addr);
    599562                        errno = rc;
    600                         goto fallback;
     563                        return -1;
    601564                }
    602565               
    … …  
    617580        } else
    618581                tv->tv_sec = s1;
    619        
    620         return;
    621        
    622 fallback:
    623         tv->tv_sec = 0;
    624         tv->tv_usec = 0;
     582
     583        return 0;
    625584}
    626585
    … …  
    628587{
    629588        struct timeval tv;
    630         gettimeofday(&tv, NULL);
     589        if (gettimeofday(&tv, NULL))
     590                return (time_t) -1;
    631591       
    632592        if (tloc)
    … …  
    671631}
    672632
    673 /** Get time from broken-down time.
    674  *
    675  * First normalize the provided broken-down time
    676  * (moves all values to their proper bounds) and
    677  * then try to calculate the appropriate time_t
    678  * representation.
     633/**
     634 * This function first normalizes the provided broken-down time
     635 * (moves all values to their proper bounds) and then tries to
     636 * calculate the appropriate time_t representation.
    679637 *
    680638 * @param tm Broken-down time.
    681  *
    682  * @return time_t representation of the time.
    683  * @return Undefined value on overflow.
    684  *
     639 * @return time_t representation of the time, undefined value on overflow.
    685640 */
    686641time_t mktime(struct tm *tm)
    … …  
    688643        // TODO: take DST flag into account
    689644        // TODO: detect overflow
    690        
    691         normalize_time(tm, 0);
    692         return secs_since_epoch(tm);
    693 }
    694 
    695 /*
    696  * FIXME: This requires POSIX-correct snprintf.
    697  *        Otherwise it won't work with non-ASCII chars.
    698  */
    699 #define APPEND(...) \
    700         { \
    701                 consumed = snprintf(ptr, remaining, __VA_ARGS__); \
    702                 if (consumed >= remaining) \
    703                         return 0; \
    704                 \
    705                 ptr += consumed; \
    706                 remaining -= consumed; \
    707         }
    708 
    709 #define RECURSE(fmt) \
    710         { \
    711                 consumed = strftime(ptr, remaining, fmt, tm); \
    712                 if (consumed == 0) \
    713                         return 0; \
    714                 \
    715                 ptr += consumed; \
    716                 remaining -= consumed; \
    717         }
    718 
    719 #define TO_12H(hour) \
    720         (((hour) > 12) ? ((hour) - 12) : \
    721             (((hour) == 0) ? 12 : (hour)))
    722 
    723 /** Convert time and date to a string.
    724  *
    725  * @param s       Buffer to write string to.
     645
     646        _normalize_time(tm, 0);
     647        return _secs_since_epoch(tm);
     648}
     649
     650/**
     651 * Convert time and date to a string, based on a specified format and
     652 * current locale.
     653 *
     654 * @param s Buffer to write string to.
    726655 * @param maxsize Size of the buffer.
    727  * @param format  Format of the output.
    728  * @param tm      Broken-down time to format.
    729  *
     656 * @param format Format of the output.
     657 * @param tm Broken-down time to format.
    730658 * @return Number of bytes written.
    731  *
    732659 */
    733660size_t strftime(char *restrict s, size_t maxsize,
    … …  
    737664        assert(format != NULL);
    738665        assert(tm != NULL);
    739        
     666
    740667        // TODO: use locale
    741        
    742668        static const char *wday_abbr[] = {
    743669                "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
    744670        };
    745        
    746671        static const char *wday[] = {
    747672                "Sunday", "Monday", "Tuesday", "Wednesday",
    748673                "Thursday", "Friday", "Saturday"
    749674        };
    750        
    751675        static const char *mon_abbr[] = {
    752676                "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    753677                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    754678        };
    755        
    756679        static const char *mon[] = {
    757680                "January", "February", "March", "April", "May", "June", "July",
    … …  
    759682        };
    760683       
    761         if (maxsize < 1)
     684        if (maxsize < 1) {
    762685                return 0;
     686        }
    763687       
    764688        char *ptr = s;
    … …  
    766690        size_t remaining = maxsize;
    767691       
     692        #define append(...) { \
     693                /* FIXME: this requires POSIX-correct snprintf */ \
     694                /*        otherwise it won't work with non-ascii chars */ \
     695                consumed = snprintf(ptr, remaining, __VA_ARGS__); \
     696                if (consumed >= remaining) { \
     697                        return 0; \
     698                } \
     699                ptr += consumed; \
     700                remaining -= consumed; \
     701        }
     702       
     703        #define recurse(fmt) { \
     704                consumed = strftime(ptr, remaining, fmt, tm); \
     705                if (consumed == 0) { \
     706                        return 0; \
     707                } \
     708                ptr += consumed; \
     709                remaining -= consumed; \
     710        }
     711       
     712        #define TO_12H(hour) (((hour) > 12) ? ((hour) - 12) : \
     713            (((hour) == 0) ? 12 : (hour)))
     714       
    768715        while (*format != '\0') {
    769716                if (*format != '%') {
    770                         APPEND("%c", *format);
     717                        append("%c", *format);
    771718                        format++;
    772719                        continue;
    … …  
    774721               
    775722                format++;
    776                 if ((*format == '0') || (*format == '+')) {
     723                if (*format == '0' || *format == '+') {
    777724                        // TODO: padding
    778725                        format++;
    779726                }
    780                
    781727                while (isdigit(*format)) {
    782728                        // TODO: padding
    783729                        format++;
    784730                }
    785                
    786                 if ((*format == 'O') || (*format == 'E')) {
     731                if (*format == 'O' || *format == 'E') {
    787732                        // TODO: locale's alternative format
    788733                        format++;
    … …  
    791736                switch (*format) {
    792737                case 'a':
    793                         APPEND("%s", wday_abbr[tm->tm_wday]);
    794                         break;
     738                        append("%s", wday_abbr[tm->tm_wday]); break;
    795739                case 'A':
    796                         APPEND("%s", wday[tm->tm_wday]);
    797                         break;
     740                        append("%s", wday[tm->tm_wday]); break;
    798741                case 'b':
    799                         APPEND("%s", mon_abbr[tm->tm_mon]);
    800                         break;
     742                        append("%s", mon_abbr[tm->tm_mon]); break;
    801743                case 'B':
    802                         APPEND("%s", mon[tm->tm_mon]);
    803                         break;
     744                        append("%s", mon[tm->tm_mon]); break;
    804745                case 'c':
    805746                        // TODO: locale-specific datetime format
    806                         RECURSE("%Y-%m-%d %H:%M:%S");
    807                         break;
     747                        recurse("%Y-%m-%d %H:%M:%S"); break;
    808748                case 'C':
    809                         APPEND("%02d", (1900 + tm->tm_year) / 100);
    810                         break;
     749                        append("%02d", (1900 + tm->tm_year) / 100); break;
    811750                case 'd':
    812                         APPEND("%02d", tm->tm_mday);
    813                         break;
     751                        append("%02d", tm->tm_mday); break;
    814752                case 'D':
    815                         RECURSE("%m/%d/%y");
    816                         break;
     753                        recurse("%m/%d/%y"); break;
    817754                case 'e':
    818                         APPEND("%2d", tm->tm_mday);
    819                         break;
     755                        append("%2d", tm->tm_mday); break;
    820756                case 'F':
    821                         RECURSE("%+4Y-%m-%d");
    822                         break;
     757                        recurse("%+4Y-%m-%d"); break;
    823758                case 'g':
    824                         APPEND("%02d", wbyear(tm) % 100);
    825                         break;
     759                        append("%02d", _wbyear(tm) % 100); break;
    826760                case 'G':
    827                         APPEND("%d", wbyear(tm));
    828                         break;
     761                        append("%d", _wbyear(tm)); break;
    829762                case 'h':
    830                         RECURSE("%b");
    831                         break;
     763                        recurse("%b"); break;
    832764                case 'H':
    833                         APPEND("%02d", tm->tm_hour);
    834                         break;
     765                        append("%02d", tm->tm_hour); break;
    835766                case 'I':
    836                         APPEND("%02d", TO_12H(tm->tm_hour));
    837                         break;
     767                        append("%02d", TO_12H(tm->tm_hour)); break;
    838768                case 'j':
    839                         APPEND("%03d", tm->tm_yday);
    840                         break;
     769                        append("%03d", tm->tm_yday); break;
    841770                case 'k':
    842                         APPEND("%2d", tm->tm_hour);
    843                         break;
     771                        append("%2d", tm->tm_hour); break;
    844772                case 'l':
    845                         APPEND("%2d", TO_12H(tm->tm_hour));
    846                         break;
     773                        append("%2d", TO_12H(tm->tm_hour)); break;
    847774                case 'm':
    848                         APPEND("%02d", tm->tm_mon);
    849                         break;
     775                        append("%02d", tm->tm_mon); break;
    850776                case 'M':
    851                         APPEND("%02d", tm->tm_min);
    852                         break;
     777                        append("%02d", tm->tm_min); break;
    853778                case 'n':
    854                         APPEND("\n");
    855                         break;
     779                        append("\n"); break;
    856780                case 'p':
    857                         APPEND("%s", tm->tm_hour < 12 ? "AM" : "PM");
    858                         break;
     781                        append("%s", tm->tm_hour < 12 ? "AM" : "PM"); break;
    859782                case 'P':
    860                         APPEND("%s", tm->tm_hour < 12 ? "am" : "PM");
    861                         break;
     783                        append("%s", tm->tm_hour < 12 ? "am" : "PM"); break;
    862784                case 'r':
    863                         RECURSE("%I:%M:%S %p");
    864                         break;
     785                        recurse("%I:%M:%S %p"); break;
    865786                case 'R':
    866                         RECURSE("%H:%M");
    867                         break;
     787                        recurse("%H:%M"); break;
    868788                case 's':
    869                         APPEND("%ld", secs_since_epoch(tm));
    870                         break;
     789                        append("%ld", _secs_since_epoch(tm)); break;
    871790                case 'S':
    872                         APPEND("%02d", tm->tm_sec);
    873                         break;
     791                        append("%02d", tm->tm_sec); break;
    874792                case 't':
    875                         APPEND("\t");
    876                         break;
     793                        append("\t"); break;
    877794                case 'T':
    878                         RECURSE("%H:%M:%S");
    879                         break;
     795                        recurse("%H:%M:%S"); break;
    880796                case 'u':
    881                         APPEND("%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday);
     797                        append("%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday);
    882798                        break;
    883799                case 'U':
    884                         APPEND("%02d", sun_week_number(tm));
    885                         break;
     800                        append("%02d", _sun_week_number(tm)); break;
    886801                case 'V':
    887                         APPEND("%02d", iso_week_number(tm));
    888                         break;
     802                        append("%02d", _iso_week_number(tm)); break;
    889803                case 'w':
    890                         APPEND("%d", tm->tm_wday);
    891                         break;
     804                        append("%d", tm->tm_wday); break;
    892805                case 'W':
    893                         APPEND("%02d", mon_week_number(tm));
    894                         break;
     806                        append("%02d", _mon_week_number(tm)); break;
    895807                case 'x':
    896808                        // TODO: locale-specific date format
    897                         RECURSE("%Y-%m-%d");
    898                         break;
     809                        recurse("%Y-%m-%d"); break;
    899810                case 'X':
    900811                        // TODO: locale-specific time format
    901                         RECURSE("%H:%M:%S");
    902                         break;
     812                        recurse("%H:%M:%S"); break;
    903813                case 'y':
    904                         APPEND("%02d", tm->tm_year % 100);
    905                         break;
     814                        append("%02d", tm->tm_year % 100); break;
    906815                case 'Y':
    907                         APPEND("%d", 1900 + tm->tm_year);
    908                         break;
     816                        append("%d", 1900 + tm->tm_year); break;
    909817                case 'z':
    910818                        // TODO: timezone
    … …  
    914822                        break;
    915823                case '%':
    916                         APPEND("%%");
     824                        append("%%");
    917825                        break;
    918826                default:
    919827                        /* Invalid specifier, print verbatim. */
    920                         while (*format != '%')
     828                        while (*format != '%') {
    921829                                format--;
    922                        
    923                         APPEND("%%");
     830                        }
     831                        append("%%");
    924832                        break;
    925833                }
    926                
    927834                format++;
    928835        }
    929836       
     837        #undef append
     838        #undef recurse
     839       
    930840        return maxsize - remaining;
    931841}
    932842
    933 /** Convert a time value to a broken-down UTC time/
    934  *
    935  * @param time   Time to convert
    936  * @param result Structure to store the result to
    937  *
    938  * @return EOK or a negative error code
    939  *
     843
     844/** Converts a time value to a broken-down UTC time
     845 *
     846 * @param time    Time to convert
     847 * @param result  Structure to store the result to
     848 *
     849 * @return        EOK or a negative error code
    940850 */
    941851int time_utc2tm(const time_t time, struct tm *restrict result)
    942852{
    943853        assert(result != NULL);
    944        
     854
    945855        /* Set result to epoch. */
    946856        result->tm_sec = 0;
    … …  
    950860        result->tm_mon = 0;
    951861        result->tm_year = 70; /* 1970 */
    952        
    953         if (normalize_time(result, time) == -1)
     862
     863        if (_normalize_time(result, time) == -1)
    954864                return EOVERFLOW;
    955        
     865
    956866        return EOK;
    957867}
    958868
    959 /** Convert a time value to a NULL-terminated string.
    960  *
    961  * The format is "Wed Jun 30 21:49:08 1993\n" expressed in UTC.
    962  *
    963  * @param time Time to convert.
    964  * @param buf  Buffer to store the string to, must be at least
    965  *             ASCTIME_BUF_LEN bytes long.
    966  *
    967  * @return EOK or a negative error code.
    968  *
     869/** Converts a time value to a null terminated string of the form
     870 *  "Wed Jun 30 21:49:08 1993\n" expressed in UTC.
     871 *
     872 * @param time   Time to convert.
     873 * @param buf    Buffer to store the string to, must be at least
     874 *               ASCTIME_BUF_LEN bytes long.
     875 *
     876 * @return       EOK or a negative error code.
    969877 */
    970878int time_utc2str(const time_t time, char *restrict buf)
    971879{
    972         struct tm tm;
    973         int ret = time_utc2tm(time, &tm);
    974         if (ret != EOK)
    975                 return ret;
    976        
    977         time_tm2str(&tm, buf);
     880        struct tm t;
     881        int r;
     882
     883        if ((r = time_utc2tm(time, &t)) != EOK)
     884                return r;
     885
     886        time_tm2str(&t, buf);
    978887        return EOK;
    979888}
    980889
    981 /** Convert broken-down time to a NULL-terminated string.
    982  *
    983  * The format is "Sun Jan 1 00:00:00 1970\n". (Obsolete)
     890
     891/**
     892 * Converts broken-down time to a string in format
     893 * "Sun Jan 1 00:00:00 1970\n". (Obsolete)
    984894 *
    985895 * @param timeptr Broken-down time structure.
    986  * @param buf     Buffer to store string to, must be at least
    987  *                ASCTIME_BUF_LEN bytes long.
    988  *
     896 * @param buf     Buffer to store string to, must be at least ASCTIME_BUF_LEN
     897 *                bytes long.
    989898 */
    990899void time_tm2str(const struct tm *restrict timeptr, char *restrict buf)
    … …  
    992901        assert(timeptr != NULL);
    993902        assert(buf != NULL);
    994        
     903
    995904        static const char *wday[] = {
    996905                "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
    997906        };
    998        
    999907        static const char *mon[] = {
    1000908                "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    1001909                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    1002910        };
    1003        
     911
    1004912        snprintf(buf, ASCTIME_BUF_LEN, "%s %s %2d %02d:%02d:%02d %d\n",
    1005913            wday[timeptr->tm_wday],
    … …  
    1010918}
    1011919
    1012 /** Converts a time value to a broken-down local time.
    1013  *
    1014  * Time is expressed relative to the user's specified timezone.
    1015  *
    1016  * @param timer  Time to convert.
    1017  * @param result Structure to store the result to.
    1018  *
    1019  * @return EOK on success or a negative error code.
    1020  *
     920/**
     921 * Converts a time value to a broken-down local time, expressed relative
     922 * to the user's specified timezone.
     923 *
     924 * @param timer     Time to convert.
     925 * @param result    Structure to store the result to.
     926 *
     927 * @return          EOK on success or a negative error code.
    1021928 */
    1022929int time_local2tm(const time_t time, struct tm *restrict result)
    1023930{
    1024         // TODO: Deal with timezones.
    1025         //       Currently assumes system and all times are in UTC
    1026        
     931        // TODO: deal with timezone
     932        // currently assumes system and all times are in GMT
     933
    1027934        /* Set result to epoch. */
    1028935        result->tm_sec = 0;
    … …  
    1032939        result->tm_mon = 0;
    1033940        result->tm_year = 70; /* 1970 */
    1034        
    1035         if (normalize_time(result, time) == -1)
     941
     942        if (_normalize_time(result, time) == -1)
    1036943                return EOVERFLOW;
    1037        
     944
    1038945        return EOK;
    1039946}
    1040947
    1041 /** Convert the calendar time to a NULL-terminated string.
    1042  *
    1043  * The format is "Wed Jun 30 21:49:08 1993\n" expressed relative to the
     948/**
     949 * Converts the calendar time to a null terminated string
     950 * of the form "Wed Jun 30 21:49:08 1993\n" expressed relative to the
    1044951 * user's specified timezone.
    1045  *
    1046  * @param timer Time to convert.
    1047  * @param buf   Buffer to store the string to. Must be at least
    1048  *              ASCTIME_BUF_LEN bytes long.
    1049  *
    1050  * @return EOK on success or a negative error code.
    1051  *
     952 *
     953 * @param timer  Time to convert.
     954 * @param buf    Buffer to store the string to. Must be at least
     955 *               ASCTIME_BUF_LEN bytes long.
     956 *
     957 * @return       EOK on success or a negative error code.
    1052958 */
    1053959int time_local2str(const time_t time, char *buf)
    1054960{
    1055961        struct tm loctime;
    1056         int ret = time_local2tm(time, &loctime);
    1057         if (ret != EOK)
    1058                 return ret;
    1059        
     962        int r;
     963
     964        if ((r = time_local2tm(time, &loctime)) != EOK)
     965                return r;
     966
    1060967        time_tm2str(&loctime, buf);
     968
    1061969        return EOK;
    1062970}
    1063971
    1064 /** Calculate the difference between two times, in seconds.
    1065  *
     972/**
     973 * Calculate the difference between two times, in seconds.
     974 *
    1066975 * @param time1 First time.
    1067976 * @param time0 Second time.
    1068  *
    1069  * @return Time difference in seconds.
    1070  *
     977 * @return Time in seconds.
    1071978 */
    1072979double difftime(time_t time1, time_t time0)

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

    r235d31d r759ea0d  
    3838#include <libarch/common.h>
    3939
    40 typedef uint32_t fourcc_t;
    41 
    4240#define FOURCC(a, b, c, d) \
    4341        (((UINT32_T) (a)) | (((UINT32_T) (b)) << 8) | \

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

    r235d31d r759ea0d  
    4343#include <abi/sysinfo.h>
    4444
    45 #define LOAD_UNIT  65536
    46 
    4745extern stats_cpu_t *stats_get_cpus(size_t *);
    4846extern stats_physmem_t *stats_get_physmem(void);
    4947extern load_t *stats_get_load(size_t *);
     48extern sysarg_t stats_get_uptime(void);
    5049
    5150extern stats_task_t *stats_get_tasks(size_t *);

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

    r235d31d r759ea0d  
    4242#endif
    4343
    44 #define offsetof(type,member) ((size_t) &(((type *) 0)->member))
    4544
    4645#endif

  • uspace/lib/c/include/sys/time.h

    r235d31d r759ea0d  
    4040#include <sys/types.h>
    4141
    42 #define DST_NONE  0
    43 #define ASCTIME_BUF_LEN  26
     42#define DST_NONE 0
     43#define ASCTIME_BUF_LEN 26
    4444
    4545typedef long time_t;
    … …  
    5050
    5151struct tm {
    52         int tm_sec;    /* Seconds [0,60]. */
    53         int tm_min;    /* Minutes [0,59]. */
    54         int tm_hour;   /* Hour [0,23]. */
    55         int tm_mday;   /* Day of month [1,31]. */
    56         int tm_mon;    /* Month of year [0,11]. */
    57         int tm_year;   /* Years since 1900. */
    58         int tm_wday;   /* Day of week [0,6] (Sunday = 0). */
    59         int tm_yday;   /* Day of year [0,365]. */
    60         int tm_isdst;  /* Daylight Savings flag. */
     52        int tm_sec;         /* Seconds [0,60]. */
     53        int tm_min;         /* Minutes [0,59]. */
     54        int tm_hour;        /* Hour [0,23]. */
     55        int tm_mday;        /* Day of month [1,31]. */
     56        int tm_mon;         /* Month of year [0,11]. */
     57        int tm_year;        /* Years since 1900. */
     58        int tm_wday;        /* Day of week [0,6] (Sunday = 0). */
     59        int tm_yday;        /* Day of year [0,365]. */
     60        int tm_isdst;       /* Daylight Savings flag. */
    6161};
    6262
    … …  
    7171};
    7272
    73 extern void tv_add(struct timeval *, suseconds_t);
    74 extern suseconds_t tv_sub(struct timeval *, struct timeval *);
    75 extern int tv_gt(struct timeval *, struct timeval *);
    76 extern int tv_gteq(struct timeval *, struct timeval *);
    77 extern void gettimeofday(struct timeval *, struct timezone *);
    78 extern void getuptime(struct timeval *);
     73extern void tv_add(struct timeval *tv, suseconds_t usecs);
     74extern suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2);
     75extern int tv_gt(struct timeval *tv1, struct timeval *tv2);
     76extern int tv_gteq(struct timeval *tv1, struct timeval *tv2);
     77extern int gettimeofday(struct timeval *tv, struct timezone *tz);
     78extern int getuptime(struct timeval *tv);
    7979
    8080extern void udelay(useconds_t);
    8181extern int usleep(useconds_t);
    8282
    83 extern time_t mktime(struct tm *);
    84 extern int time_utc2tm(const time_t, struct tm *);
    85 extern int time_utc2str(const time_t, char *);
    86 extern void time_tm2str(const struct tm *, char *);
    87 extern int time_local2tm(const time_t, struct tm *);
    88 extern int time_local2str(const time_t, char *);
    89 extern double difftime(time_t, time_t);
    90 extern size_t strftime(char *restrict, size_t, const char *restrict,
    91     const struct tm *restrict);
     83extern time_t mktime(struct tm *tm);
     84extern int time_utc2tm(const time_t time, struct tm *result);
     85extern int time_utc2str(const time_t time, char *buf);
     86extern void time_tm2str(const struct tm *timeptr, char *buf);
     87extern int time_local2tm(const time_t time, struct tm *result);
     88extern int time_local2str(const time_t time, char *buf);
     89extern double difftime(time_t time1, time_t time0);
     90extern size_t strftime(char *restrict s, size_t maxsize,
     91    const char *restrict format, const struct tm *restrict tm);
    9292
    9393#endif

  • uspace/lib/draw/Makefile

    r235d31d r759ea0d  
    3131SLIBRARY = libdraw.so.0.0
    3232LSONAME = libdraw.so0
    33 EXTRA_CFLAGS += -I$(LIBSOFTREND_PREFIX) -I$(LIBCOMPRESS_PREFIX)
     33EXTRA_CFLAGS += -I$(LIBSOFTREND_PREFIX)
    3434
    3535SOURCES = \
    3636        codec/tga.c \
    37         codec/tga.gz.c \
    38         codec/webp.c \
    3937        cursor/embedded.c \
    4038        font/embedded.c \

  • uspace/lib/draw/codec/tga.c

    r235d31d r759ea0d  
    110110 * @return True on succesful decoding.
    111111 * @return False on failure.
    112  *
    113112 */
    114113static bool decode_tga_header(void *data, size_t size, tga_t *tga)
    … …  
    175174 * @return Newly allocated surface with the decoded content.
    176175 * @return NULL on error or unsupported format.
    177  *
    178176 */
    179177surface_t *decode_tga(void *data, size_t size, surface_flags_t flags)
    … …  
    266264 * @return True on succesful encoding.
    267265 * @return False on failure.
    268  *
    269266 */
    270267bool encode_tga(surface_t *surface, void **pdata, size_t *psize)

  • uspace/lib/math/generic/trunc.c

    r235d31d r759ea0d  
    6868        } else {
    6969                /* Truncate irrelevant fraction bits */
    70                 val.parts.fraction &= ~(UINT64_C(0x000fffffffffffff) >> exp);
     70                val.parts.fraction &= UINT64_C(0x000fffffffffffff) >> exp;
    7171        }
    7272       

  • uspace/lib/trackmod/Makefile

    r235d31d r759ea0d  
    3232SOURCES = \
    3333        protracker.c \
    34         trackmod.c \
    35         xm.c
     34        trackmod.c
    3635
    3736include $(USPACE_PREFIX)/Makefile.common

  • uspace/lib/trackmod/protracker.c

    r235d31d r759ea0d  
    113113}
    114114
    115 
    116 /** Decode pattern cell.
    117  *
    118  * @param pattern Pattern
    119  * @param row     Row number
    120  * @param channel Channel number
    121  * @param cell    Place to store decoded cell
    122  */
    123 static void protracker_decode_cell(uint32_t cdata, trackmod_cell_t *cell)
    124 {
    125         uint32_t code;
    126 
    127         code = uint32_t_be2host(cdata);
    128         cell->period = (code >> (4 * 4)) & 0xfff;
    129         cell->instr = (((code >> (7 * 4)) & 0xf) << 4) |
    130             ((code >> (3 * 4)) & 0xf);
    131         cell->effect = code & 0xfff;
    132 }
    133 
    134 /** Load Protracker patterns.
    135  *
    136  * @param f      File to read from
    137  * @param module Module being loaded to
    138  * @return       EOK on success, ENOMEM if out of memory, EIO on I/O error.
    139  */
    140 static int protracker_load_patterns(FILE *f, trackmod_module_t *module)
    141 {
    142         size_t cells;
    143         size_t i, j;
    144         int rc;
    145         size_t nread;
    146         uint32_t *buf = NULL;
    147 
    148         cells = module->channels * protracker_pattern_rows;
    149         buf = calloc(sizeof(uint32_t), cells);
    150 
    151         if (buf == NULL) {
    152                 rc = ENOMEM;
    153                 goto error;
    154         }
    155 
    156         for (i = 0; i < module->patterns; i++) {
    157                 module->pattern[i].rows = protracker_pattern_rows;
    158                 module->pattern[i].channels = module->channels;
    159                 module->pattern[i].data = calloc(sizeof(trackmod_cell_t), cells);
    160                 if (module->pattern[i].data == NULL) {
    161                         rc = ENOMEM;
    162                         goto error;
    163                 }
    164 
    165                 nread = fread(buf, sizeof(uint32_t), cells, f);
    166                 if (nread != cells) {
    167                         printf("Error reading pattern.\n");
    168                         rc = EIO;
    169                         goto error;
    170                 }
    171 
    172                 /* Decode cells */
    173                 for (j = 0; j < cells; j++) {
    174                         protracker_decode_cell(buf[j],
    175                             &module->pattern[i].data[j]);
    176                 }
    177         }
    178 
    179         free(buf);
    180         return EOK;
    181 error:
    182         free(buf);
    183         return rc;
    184 }
    185 
    186 /** Load protracker samples.
    187  *
    188  * @param f      File being read from
    189  * @param sample Sample header
    190  * @param module Module being loaded to
    191  * @return       EOk on success, ENOMEM if out of memory, EIO on I/O error.
    192  */
    193 static int protracker_load_samples(FILE *f, protracker_smp_t *smp,
    194     trackmod_module_t *module)
    195 {
    196         int rc;
    197         size_t i;
    198         uint8_t ftval;
    199         size_t nread;
    200         trackmod_sample_t *sample;
    201 
    202         for (i = 0; i < module->instrs; i++) {
    203                 module->instr[i].samples = 1;
    204                 module->instr[i].sample = calloc(1, sizeof(trackmod_sample_t));
    205                 if (module->instr[i].sample == NULL) {
    206                         printf("Error allocating sample.\n");
    207                         rc = ENOMEM;
    208                         goto error;
    209                 }
    210 
    211                 sample = &module->instr[i].sample[0];
    212                 sample->length =
    213                     uint16_t_be2host(smp[i].length) * 2;
    214                 sample->bytes_smp = 1;
    215                 sample->data = calloc(1, sample->length);
    216                 if (sample->data == NULL) {
    217                         printf("Error allocating sample.\n");
    218                         rc = ENOMEM;
    219                         goto error;
    220                 }
    221 
    222                 nread = fread(sample->data, 1, sample->length, f);
    223                 if (nread != sample->length) {
    224                         printf("Error reading sample.\n");
    225                         rc = EIO;
    226                         goto error;
    227                 }
    228 
    229                 sample->def_vol = smp[i].def_vol;
    230 
    231                 sample->loop_start =
    232                     uint16_t_be2host(smp[i].loop_start) * 2;
    233                 sample->loop_len =
    234                     uint16_t_be2host(smp[i].loop_len) * 2;
    235                 if (sample->loop_len <= 2)
    236                         sample->loop_type = tl_no_loop;
    237                 else
    238                         sample->loop_type = tl_forward_loop;
    239 
    240                 /* Finetune is a 4-bit signed value. */
    241                 ftval = smp[i].finetune & 0x0f;
    242                 sample->finetune =
    243                         (ftval & 0x8) ? (ftval & 0x7) - 8 : ftval;
    244         }
    245 
    246         return EOK;
    247 error:
    248         return rc;
    249 }
    250 
    251115/** Load protracker module.
    252116 *
    … …  
    264128        protracker_order_list_t *order_list;
    265129        protracker_smp_t *sample;
     130        size_t nread;
    266131        size_t samples;
    267132        size_t channels;
    268133        size_t patterns;
    269         size_t i;
    270         size_t nread;
     134        size_t cells;
     135        size_t i, j;
    271136        int rc;
    272137
    … …  
    327192        module->channels = channels;
    328193
    329         module->instrs = samples;
    330         module->instr = calloc(sizeof(trackmod_instr_t), samples);
    331         if (module->instr == NULL) {
     194        module->samples = samples;
     195        module->sample = calloc(sizeof(trackmod_sample_t), samples);
     196        if (module->sample == NULL) {
    332197                printf("Out of memory.\n");
    333198                rc = ENOMEM;
    … …  
    356221        }
    357222
    358         /* The 'mark' byte may or may not contain a valid restart position */
    359         if (order_list->mark < order_list->order_list_len) {
    360                 module->restart_pos = order_list->mark;
    361         }
    362 
    363223        /* Load patterns */
    364         rc = protracker_load_patterns(f, module);
    365         if (rc != EOK)
    366                 goto error;
     224
     225        cells = channels * protracker_pattern_rows;
     226
     227        for (i = 0; i < patterns; i++) {
     228                module->pattern[i].rows = protracker_pattern_rows;
     229                module->pattern[i].channels = channels;
     230                module->pattern[i].data = calloc(sizeof(uint32_t), cells);
     231
     232                nread = fread(module->pattern[i].data,
     233                    sizeof(uint32_t), cells, f);
     234                if (nread != cells) {
     235                        printf("Error reading pattern.\n");
     236                        rc = EIO;
     237                        goto error;
     238                }
     239
     240                /* Convert byte order */
     241                for (j = 0; j < cells; j++) {
     242                        module->pattern[i].data[j] = uint32_t_be2host(
     243                            module->pattern[i].data[j]);
     244                }
     245        }
    367246
    368247        /* Load samples */
    369         rc = protracker_load_samples(f, sample, module);
    370         if (rc != EOK)
    371                 goto error;
     248        for (i = 0; i < samples; i++) {
     249                module->sample[i].length =
     250                    uint16_t_be2host(sample[i].length) * 2;
     251                module->sample[i].data = calloc(1, module->sample[i].length);
     252                if (module->sample[i].data == NULL) {
     253                        printf("Error allocating sample.\n");
     254                        rc = ENOMEM;
     255                        goto error;
     256                }
     257
     258                nread = fread(module->sample[i].data, 1, module->sample[i].length,
     259                        f);
     260                if (nread != module->sample[i].length) {
     261                        printf("Error reading sample.\n");
     262                        rc = EIO;
     263                        goto error;
     264                }
     265
     266                module->sample[i].def_vol = sample[i].def_vol;
     267                module->sample[i].loop_start =
     268                    uint16_t_be2host(sample[i].loop_start) * 2;
     269                module->sample[i].loop_len =
     270                    uint16_t_be2host(sample[i].loop_len) * 2;
     271                if (module->sample[i].loop_len <= 2)
     272                        module->sample[i].loop_len = 0;
     273        }
    372274
    373275        (void) fclose(f);
    374 
    375         module->def_bpm = protracker_def_bpm;
    376         module->def_tpr = protracker_def_tpr;
    377276
    378277        *rmodule = module;

  • uspace/lib/trackmod/trackmod.c

    r235d31d r759ea0d  
    4040
    4141#include "macros.h"
    42 #include "protracker.h"
    4342#include "trackmod.h"
    44 #include "xm.h"
    4543
    4644/** Tunables */
    … …  
    5452        base_clock = 8363 * 428,
    5553        /** Maximum sample volume */
    56         vol_max = 64,
    57         /** Minimum period */
    58         period_min = 113,
    59         /** Maxium period */
    60         period_max = 856
     54        vol_max = 63,
     55        /** Default TPR */
     56        def_tpr = 6,
     57        /** Default BPM */
     58        def_bpm = 125
    6159};
    6260
    63 /** Table for finetune computation.
    64   *
    65   * Finetune is a number ft in [-8 .. 7]. The pitch should be adjusted by
    66   * ft/8 semitones. To adjust pitch by 1/8 semitone down we can mutiply the
    67   * period by 2^(1/12/8) =. 1.0072, one semitone up: 2^-(1/12/8) =. 0.9928,
    68   * to adjust by ft/8 semitones, multiply by 2^(-ft/12/8).
    69   *
    70   * finetune_factor[ft] := 10000 * 2^(-ft/12/8)
    71   * res_period = clip(period * fineture_factor[ft+8] / 10000)
    72   */
    73 static unsigned finetune_factor[16] = {
    74         10595, 10518, 10443, 10368, 10293, 10219, 10145, 10072,
    75         10000,  9928,  9857,  9786,  9715,  9645,  9576,  9507
    76 };
    77 
    78 static unsigned period_table[12 * 8] = {
    79      907,900,894,887,881,875,868,862,856,850,844,838,832,826,820,814,
    80      808,802,796,791,785,779,774,768,762,757,752,746,741,736,730,725,
    81      720,715,709,704,699,694,689,684,678,675,670,665,660,655,651,646,
    82      640,636,632,628,623,619,614,610,604,601,597,592,588,584,580,575,
    83      570,567,563,559,555,551,547,543,538,535,532,528,524,520,516,513,
    84      508,505,502,498,494,491,487,484,480,477,474,470,467,463,460,457
    85 };
    86 
    8761static size_t trackmod_get_next_ord_idx(trackmod_modplay_t *);
    8862
    … …  
    9670}
    9771
    98 /** Destroy instrument.
    99  *
    100  * @param instr Intrument
    101  */
    102 static void trackmod_instr_destroy(trackmod_instr_t *instr)
     72/** Destroy pattern.
     73 *
     74 * @param pattern Pattern
     75 */
     76static void trackmod_pattern_destroy(trackmod_pattern_t *pattern)
     77{
     78        free(pattern->data);
     79}
     80
     81/** Create new empty module structure.
     82 *
     83 * @return New module
     84 */
     85trackmod_module_t *trackmod_module_new(void)
     86{
     87        return calloc(1, sizeof(trackmod_module_t));
     88}
     89
     90/** Destroy module.
     91 *
     92 * @param module Module
     93 */
     94void trackmod_module_destroy(trackmod_module_t *module)
    10395{
    10496        size_t i;
    10597
    106         for (i = 0; i < instr->samples; i++)
    107                 trackmod_sample_destroy(&instr->sample[i]);
    108 }
    109 
    110 /** Destroy pattern.
    111  *
    112  * @param pattern Pattern
    113  */
    114 static void trackmod_pattern_destroy(trackmod_pattern_t *pattern)
    115 {
    116         free(pattern->data);
    117 }
    118 
    119 /** Create new empty module structure.
    120  *
    121  * @return New module
    122  */
    123 trackmod_module_t *trackmod_module_new(void)
    124 {
    125         return calloc(1, sizeof(trackmod_module_t));
    126 }
    127 
    128 /** Destroy module.
    129  *
    130  * @param module Module
    131  */
    132 void trackmod_module_destroy(trackmod_module_t *module)
    133 {
    134         size_t i;
    135 
    13698        /* Destroy samples */
    137         if (module->instr != NULL) {
    138                 for (i = 0; i < module->instrs; i++)
    139                         trackmod_instr_destroy(&module->instr[i]);
    140                 free(module->instr);
     99        if (module->sample != NULL) {
     100                for (i = 0; i < module->samples; i++)
     101                        trackmod_sample_destroy(&module->sample[i]);
     102                free(module->sample);
    141103        }
    142104
    … …  
    152114}
    153115
    154 int trackmod_module_load(char *fname, trackmod_module_t **rmodule)
    155 {
    156         int rc;
    157 
    158         rc = trackmod_xm_load(fname, rmodule);
    159         if (rc == EOK)
    160                 return EOK;
    161 
    162         rc = trackmod_protracker_load(fname, rmodule);
    163         return rc;
    164 }
    165 
    166 
    167116/** Return current pattern.
    168117 *
    … …  
    188137    size_t row, size_t channel, trackmod_cell_t *cell)
    189138{
    190         *cell = pattern->data[row * pattern->channels + channel];
    191 }
    192 
    193 /** Compute floor(a / b), and the remainder.
    194  *
    195  * Unlike standard integer division this rounds towars negative infinity,
    196  * not towards zero.
    197  *
    198  * @param a Dividend
    199  * @param b Divisor
    200  * @param quot Place to store 'quotient' (floor (a/b))
    201  * @param rem Place to store 'remainder' (a - floor(a/b) * b)
    202  */
    203 static void divmod_floor(int a, int b, int *quot, int *rem)
    204 {
    205         if (b < 0) {
    206                 a = -a;
    207                 b = -b;
    208         }
    209 
    210         if (a >= 0) {
    211                 *quot = a / b;
    212                 *rem = a % b;
    213         } else {
    214                 *quot = - (-a + (b - 1)) / b;
    215                 *rem = a - (*quot * b);
    216         }
    217 }
    218 
    219 /** Process note (period)
     139        uint32_t code;
     140
     141        code = pattern->data[row * pattern->channels + channel];
     142        cell->period = (code >> (4 * 4)) & 0xfff;
     143        cell->sample = (((code >> (7 * 4)) & 0xf) << 4) |
     144            ((code >> (3 * 4)) & 0xf);
     145        cell->effect = code & 0xfff;
     146}
     147
     148/** Process note (period, sample index)
    220149 *
    221150 * @param modplay Module playback
    … …  
    227156{
    228157        trackmod_chan_t *chan = &modplay->chan[i];
    229         int period;
    230         int pitch;
    231         int octave;
    232         int opitch;
    233 
    234         if (chan->sample == NULL)
    235                 return;
    236 
    237         if (cell->period == 0) {
    238                 pitch = 8 * (cell->note + chan->sample->rel_note) +
    239                     chan->sample->finetune;
    240                 divmod_floor(pitch, 8 * 12, &octave, &opitch);
    241 
    242                 if (octave >= 0)
    243                         period = period_table[opitch] * 8 / (1 << octave);
    244                 else
    245                         period = period_table[opitch] * 8 * (1 << (-octave));
    246         } else {
    247                 period = cell->period;
    248                 period = period *
    249                     finetune_factor[chan->sample->finetune + 8] / 10000;
    250                 if (period > period_max)
    251                         period = period_max;
    252                 if (period < period_min)
    253                         period = period_min;
    254         }
    255 
    256         chan->period_new = period;
    257 }
    258 
    259 /** Process instrument number (this is what triggers the note playback)
    260  *
    261  * @param modplay Module playback
    262  * @param i       Channel number
    263  * @param cell    Cell
    264  */
    265 static void trackmod_process_instr(trackmod_modplay_t *modplay, size_t i,
    266     trackmod_cell_t *cell)
    267 {
    268         trackmod_chan_t *chan = &modplay->chan[i];
    269         trackmod_instr_t *instr;
    270         size_t iidx;
    271         size_t sidx;
    272 
    273         if (cell->instr == 0)
    274                 return;
    275 
    276         iidx = (cell->instr - 1) % modplay->module->instrs;
    277         instr = &modplay->module->instr[iidx];
    278         sidx = instr->key_smp[cell->note] % instr->samples;
    279         chan->sample = &instr->sample[sidx];
     158        size_t smpidx;
     159
     160        smpidx = (cell->sample - 1) % modplay->module->samples;
     161        chan->sample = &modplay->module->sample[smpidx];
    280162        chan->smp_pos = 0;
    281163        chan->lsmp = 0;
    282 
     164        chan->period = cell->period;
    283165        chan->volume = modplay->chan[i].sample->def_vol;
    284 }
    285 
    286 /** Process keyoff note
    287  *
    288  * @param modplay Module playback
    289  * @param i       Channel number
    290  * @param cell    Cell
    291  */
    292 static void trackmod_process_keyoff_note(trackmod_modplay_t *modplay, size_t i)
    293 {
    294         trackmod_chan_t *chan = &modplay->chan[i];
    295 
    296         chan->sample = NULL;
    297         chan->period = 0;
    298         chan->smp_pos = 0;
    299         chan->lsmp = 0;
    300166}
    301167
    … …  
    309175    uint8_t param)
    310176{
    311         modplay->chan[chan].volume = param % (vol_max + 1);
     177        modplay->chan[chan].volume = param & vol_max;
    312178}
    313179
    … …  
    323189        size_t next_idx;
    324190        trackmod_pattern_t *next_pat;
    325         unsigned row;
    326 
    327         /* Strangely the parameter is BCD */
    328         row = (param >> 4) * 10 + (param & 0xf);
    329191
    330192        next_idx = trackmod_get_next_ord_idx(modplay);
    … …  
    332194
    333195        modplay->pat_break = true;
    334         modplay->pat_break_row = row % next_pat->rows;
     196        modplay->pat_break_row = param % next_pat->rows;
    335197}
    336198
    … …  
    350212}
    351213
    352 /** Process Fine volume slide down effect.
    353  *
    354  * @param modplay Module playback
    355  * @param chan    Channel number
    356  * @param param   Effect parameter
    357  */
    358 static void trackmod_effect_fine_vol_slide_down(trackmod_modplay_t *modplay,
    359     size_t chan, uint8_t param)
    360 {
    361         int nv;
    362 
    363         nv = modplay->chan[chan].volume - param;
    364         if (nv < 0)
    365                 nv = 0;
    366         modplay->chan[chan].volume = nv;
    367 }
    368 
    369 /** Process Fine volume slide up effect.
    370  *
    371  * @param modplay Module playback
    372  * @param chan    Channel number
    373  * @param param   Effect parameter
    374  */
    375 static void trackmod_effect_fine_vol_slide_up(trackmod_modplay_t *modplay,
    376     size_t chan, uint8_t param)
    377 {
    378         int nv;
    379 
    380         nv = modplay->chan[chan].volume + param;
    381         if (nv > vol_max)
    382                 nv = vol_max;
    383         modplay->chan[chan].volume = nv;
    384 }
    385 
    386 /** Process Volume slide effect.
    387  *
    388  * @param modplay Module playback
    389  * @param chan    Channel number
    390  * @param param   Effect parameter
    391  */
    392 static void trackmod_effect_vol_slide(trackmod_modplay_t *modplay,
    393     size_t chan, uint8_t param)
    394 {
    395         if ((param & 0xf0) != 0)
    396                 modplay->chan[chan].vol_slide = param >> 4;
    397         else
    398                 modplay->chan[chan].vol_slide = -(int)(param & 0xf);
    399 }
    400 
    401 /** Process Volume slide down effect.
    402  *
    403  * @param modplay Module playback
    404  * @param chan    Channel number
    405  * @param param   Effect parameter
    406  */
    407 static void trackmod_effect_vol_slide_down(trackmod_modplay_t *modplay,
    408     size_t chan, uint8_t param4)
    409 {
    410         modplay->chan[chan].vol_slide = -(int)param4;
    411 }
    412 
    413 /** Process Volume slide up effect.
    414  *
    415  * @param modplay Module playback
    416  * @param chan    Channel number
    417  * @param param   Effect parameter
    418  */
    419 static void trackmod_effect_vol_slide_up(trackmod_modplay_t *modplay,
    420     size_t chan, uint8_t param4)
    421 {
    422         modplay->chan[chan].vol_slide = param4;
    423 }
    424 
    425 /** Process Fine portamento down effect.
    426  *
    427  * @param modplay Module playback
    428  * @param chan    Channel number
    429  * @param param   Effect parameter
    430  */
    431 static void trackmod_effect_fine_porta_down(trackmod_modplay_t *modplay,
    432     size_t chan, uint8_t param)
    433 {
    434         int np;
    435 
    436         np = modplay->chan[chan].period + param;
    437         if (np > period_max)
    438                 np = period_max;
    439         modplay->chan[chan].period = np;
    440 }
    441 
    442 /** Process Fine portamento up effect.
    443  *
    444  * @param modplay Module playback
    445  * @param chan    Channel number
    446  * @param param   Effect parameter
    447  */
    448 static void trackmod_effect_fine_porta_up(trackmod_modplay_t *modplay,
    449     size_t chan, uint8_t param)
    450 {
    451         int np;
    452 
    453         np = modplay->chan[chan].period - param;
    454         if (np < period_min)
    455                 np = period_min;
    456         modplay->chan[chan].period = np;
    457 }
    458 
    459 /** Process Portamento down effect.
    460  *
    461  * @param modplay Module playback
    462  * @param chan    Channel number
    463  * @param param   Effect parameter
    464  */
    465 static void trackmod_effect_porta_down(trackmod_modplay_t *modplay,
    466     size_t chan, uint8_t param)
    467 {
    468         modplay->chan[chan].portamento = -(int)param;
    469 }
    470 
    471 /** Process Portamento up effect.
    472  *
    473  * @param modplay Module playback
    474  * @param chan    Channel number
    475  * @param param   Effect parameter
    476  */
    477 static void trackmod_effect_porta_up(trackmod_modplay_t *modplay,
    478     size_t chan, uint8_t param)
    479 {
    480         modplay->chan[chan].portamento = param;
    481 }
    482 
    483 /** Process Tone portamento effect.
    484  *
    485  * @param modplay Module playback
    486  * @param chan    Channel number
    487  * @param param   Effect parameter
    488  */
    489 static void trackmod_effect_tone_porta(trackmod_modplay_t *modplay,
    490     size_t chan, uint8_t param)
    491 {
    492         /* Set up tone portamento effect */
    493         modplay->chan[chan].portamento = param;
    494         if (modplay->chan[chan].period_new != 0)
    495                 modplay->chan[chan].period_tgt = modplay->chan[chan].period_new;
    496 
    497         /* Prevent going directly to new period */
    498         modplay->chan[chan].period_new = 0;
    499 }
    500 
    501 /** Process volume column.
     214/** Process effect.
    502215 *
    503216 * @param modplay Module playback
    … …  
    505218 * @param cell    Cell
    506219 */
    507 static void trackmod_process_volume(trackmod_modplay_t *modplay, size_t chan,
    508     trackmod_cell_t *cell)
    509 {
    510         uint8_t param4;
    511 
    512         if (cell->volume >= 0x10 && cell->volume <= 0x10 + vol_max)
    513                 trackmod_effect_set_volume(modplay, chan, cell->volume - 0x10);
    514 
    515         param4 = cell->volume & 0xf;
    516 
    517         switch (cell->volume & 0xf0) {
    518         case 0x60:
    519                 trackmod_effect_vol_slide_down(modplay, chan, param4);
    520                 break;
    521         case 0x70:
    522                 trackmod_effect_vol_slide_up(modplay, chan, param4);
    523                 break;
    524         case 0x80:
    525                 trackmod_effect_fine_vol_slide_down(modplay, chan, param4);
    526                 break;
    527         case 0x90:
    528                 trackmod_effect_fine_vol_slide_up(modplay, chan, param4);
    529                 break;
    530         case 0xf0:
    531                 trackmod_effect_tone_porta(modplay, chan, param4 << 4);
    532                 break;
    533         default:
    534                 break;
    535         }
    536 }
    537 
    538 /** Process effect.
    539  *
    540  * @param modplay Module playback
    541  * @param chan    Channel number
    542  * @param cell    Cell
    543  */
    544220static void trackmod_process_effect(trackmod_modplay_t *modplay, size_t chan,
    545221    trackmod_cell_t *cell)
    546222{
    547223        uint8_t param8;
    548         uint8_t param4;
    549224
    550225        param8 = cell->effect & 0xff;
    551226
    552227        switch (cell->effect & 0xf00) {
    553         case 0x100:
    554                 trackmod_effect_porta_up(modplay, chan, param8);
    555                 break;
    556         case 0x200:
    557                 trackmod_effect_porta_down(modplay, chan, param8);
    558                 break;
    559         case 0x300:
    560                 trackmod_effect_tone_porta(modplay, chan, param8);
    561                 break;
    562         case 0xa00:
    563                 trackmod_effect_vol_slide(modplay, chan, param8);
    564                 break;
    565228        case 0xc00:
    566229                trackmod_effect_set_volume(modplay, chan, param8);
    … …  
    575238                break;
    576239        }
    577 
    578         param4 = cell->effect & 0xf;
    579 
    580         switch (cell->effect & 0xff0) {
    581         case 0xe10:
    582                 trackmod_effect_fine_porta_up(modplay, chan, param4);
    583                 break;
    584         case 0xe20:
    585                 trackmod_effect_fine_porta_down(modplay, chan, param4);
    586                 break;
    587         case 0xea0:
    588                 trackmod_effect_fine_vol_slide_up(modplay, chan, param4);
    589                 break;
    590         case 0xeb0:
    591                 trackmod_effect_fine_vol_slide_down(modplay, chan, param4);
    592                 break;
    593         }
    594240}
    595241
    … …  
    603249    trackmod_cell_t *cell)
    604250{
    605         modplay->chan[chan].period_new = 0;
    606 
    607         trackmod_process_instr(modplay, chan, cell);
    608 
    609         if (cell->period != 0 || (cell->note != 0 && cell->note != keyoff_note)) {
     251        if (cell->period != 0 && cell->sample != 0)
    610252                trackmod_process_note(modplay, chan, cell);
    611         } else if (cell->note == keyoff_note && cell->instr == 0) {
    612                 trackmod_process_keyoff_note(modplay, chan);
    613         }
    614 
    615         trackmod_process_volume(modplay, chan, cell);
     253
    616254        trackmod_process_effect(modplay, chan, cell);
    617 
    618         if (modplay->chan[chan].period_new != 0)
    619                 modplay->chan[chan].period = modplay->chan[chan].period_new;
    620255}
    621256
    … …  
    632267        pattern = trackmod_cur_pattern(modplay);
    633268
    634         if (modplay->debug)
    635                 printf("%02zx: ", modplay->row);
    636 
    637269        for (i = 0; i < modplay->module->channels; i++) {
    638270                trackmod_pattern_get_cell(pattern, modplay->row, i, &cell);
    639 
    640                 if (modplay->debug) {
    641                         printf("%4d %02x %02x %03x |", cell.period ?
    642                             cell.period : cell.note, cell.instr,
    643                             cell.volume, cell.effect);
    644                 }
    645 
     271                if (modplay->debug)
     272                        printf("%4d %02x %03x |", cell.period, cell.sample, cell.effect);
    646273                trackmod_process_cell(modplay, i, &cell);
    647274        }
    … …  
    662289        ord_idx = modplay->ord_idx + 1;
    663290        if (ord_idx >= modplay->module->ord_list_len)
    664                 ord_idx = modplay->module->restart_pos;
     291                ord_idx = 0; /* XXX */
    665292
    666293        return ord_idx;
    … …  
    686313}
    687314
    688 /** Clear effects at end of row. */
    689 static void trackmod_clear_effects(trackmod_modplay_t *modplay)
    690 {
    691         size_t i;
    692 
    693         for (i = 0; i < modplay->module->channels; i++) {
    694                 modplay->chan[i].vol_slide = 0;
    695                 modplay->chan[i].portamento = 0;
    696         }
    697 }
    698 
    699 /** Process effects at beginning of tick. */
    700 static void trackmod_process_tick(trackmod_modplay_t *modplay)
    701 {
    702         trackmod_chan_t *chan;
    703         size_t i;
    704         int nv;
    705         int np;
    706 
    707         for (i = 0; i < modplay->module->channels; i++) {
    708                 chan = &modplay->chan[i];
    709 
    710                 /* Volume slides */
    711                 nv = (int)chan->volume + chan->vol_slide;
    712                 if (nv < 0)
    713                         nv = 0;
    714                 if (nv > vol_max)
    715                         nv = vol_max;
    716 
    717                 chan->volume = nv;
    718 
    719                 /* Portamentos */
    720                 if (chan->period_tgt == 0) {
    721                         /* Up or down portamento */
    722                         np = (int)chan->period - chan->portamento;
    723                 } else {
    724                         /* Tone portamento */
    725                         if (chan->period_tgt < chan->period)
    726                                 np = max((int)chan->period_tgt, (int)chan->period - chan->portamento);
    727                         else
    728                                 np = min((int)chan->period_tgt, (int)chan->period + chan->portamento);
    729                 }
    730 
    731 /*              if (np < period_min)
    732                         np = period_min;
    733                 if (np > period_max)
    734                         np = period_max;
    735 */
    736                 modplay->chan[i].period = np;
    737         }
    738 }
    739 
    740315/** Advance to next row.
    741316 *
    … …  
    745320{
    746321        trackmod_pattern_t *pattern;
    747 
    748         /* Clear effect state at end of row */
    749         trackmod_clear_effects(modplay);
    750322
    751323        pattern = trackmod_cur_pattern(modplay);
    … …  
    756328                trackmod_next_pattern(modplay);
    757329
    758         trackmod_process_tick(modplay);
    759330        trackmod_process_row(modplay);
    760331}
    … …  
    770341        if (modplay->tick >= modplay->tpr)
    771342                trackmod_next_row(modplay);
    772         else
    773                 trackmod_process_tick(modplay);
    774343}
    775344
    … …  
    797366        modplay->smp = 0;
    798367
    799         modplay->tpr = module->def_tpr;
    800         modplay->bpm = module->def_bpm;
     368        modplay->tpr = def_tpr;
     369        modplay->bpm = def_bpm;
    801370
    802371        modplay->chan = calloc(module->channels,
    … …  
    805374                goto error;
    806375
    807         trackmod_process_tick(modplay);
    808376        trackmod_process_row(modplay);
    809377
    … …  
    848416}
    849417
    850 /** Get sample frame.
    851  *
    852  * Get frame at the specified sample position.
    853  *
    854  * @param sample Sample
    855  * @param pos    Position (frame index)
    856  * @return       Frame value
    857  */
    858 int trackmod_sample_get_frame(trackmod_sample_t *sample, size_t pos)
    859 {
    860         int8_t *i8p;
    861         int16_t *i16p;
    862 
    863         if (sample->bytes_smp == 1) {
    864                 i8p = (int8_t *)sample->data;
    865                 return i8p[pos];
    866         } else {
    867                 /* chan->sample->bytes_smp == 2 */
    868                 i16p = (int16_t *)sample->data;
    869                 return i16p[pos] / 256; /* XXX Retain full precision */
    870         }
    871 }
    872 
    873418/** Advance sample position to next frame.
    874419 *
    … …  
    877422static void chan_smp_next_frame(trackmod_chan_t *chan)
    878423{
    879         chan->lsmp = trackmod_sample_get_frame(chan->sample, chan->smp_pos);
     424        chan->lsmp = chan->sample->data[chan->smp_pos];
    880425        ++chan->smp_pos;
    881426
    882         switch (chan->sample->loop_type) {
    883         case tl_pingpong_loop:
    884                 /** XXX Pingpong loop */
    885         case tl_no_loop:
    886                 /* No loop */
     427        if (chan->sample->loop_len == 0) {
     428                /* No looping */
    887429                if (chan->smp_pos >= chan->sample->length) {
    888430                        chan->sample = NULL;
    889431                        chan->smp_pos = 0;
    890432                }
    891                 break;
    892         case tl_forward_loop:
    893                 /** Forward loop */
     433        } else {
     434                /** Looping */
    894435                if (chan->smp_pos >= chan->sample->loop_start +
    895436                    chan->sample->loop_len) {
    … …  
    914455        trackmod_chan_t *chan = &modplay->chan[cidx];
    915456
    916         if (chan->sample == NULL || chan->period == 0)
     457        if (chan->sample == NULL)
    917458                return 0;
    918459
    … …  
    923464         */
    924465        sl = (int)chan->lsmp * amp_factor * chan->volume / vol_max;
    925         sn = (int)trackmod_sample_get_frame(chan->sample, chan->smp_pos) *
    926             amp_factor * chan->volume / vol_max;
     466        sn = (int)chan->sample->data[chan->smp_pos] * amp_factor *
     467            chan->volume / vol_max;
    927468
    928469        period = (int)chan->period;

  • uspace/lib/trackmod/trackmod.h

    r235d31d r759ea0d  
    4040
    4141extern trackmod_module_t *trackmod_module_new(void);
    42 extern int trackmod_module_load(char *, trackmod_module_t **);
    4342extern void trackmod_module_destroy(trackmod_module_t *);
    4443extern int trackmod_modplay_create(trackmod_module_t *, unsigned,
    … …  
    4645extern void trackmod_modplay_destroy(trackmod_modplay_t *);
    4746extern void trackmod_modplay_get_samples(trackmod_modplay_t *, void *, size_t);
    48 extern int trackmod_sample_get_frame(trackmod_sample_t *, size_t);
    4947
    5048#endif

  • uspace/lib/trackmod/types/protracker.h

    r235d31d r759ea0d  
    4747        protracker_olist_len = 128,
    4848        /** Number of rows in a pattern */
    49         protracker_pattern_rows = 64,
    50         /** Default TPR */
    51         protracker_def_tpr = 6,
    52         /** Default BPM */
    53         protracker_def_bpm = 125
     49        protracker_pattern_rows = 64
    5450};
    5551

  • uspace/lib/trackmod/types/trackmod.h

    r235d31d r759ea0d  
    4141#include <stdint.h>
    4242
    43 enum {
    44         max_key = 96,
    45         keyoff_note = 97
    46 };
    47 
    48 typedef enum {
    49         /** No loop */
    50         tl_no_loop,
    51         /** Forward loop */
    52         tl_forward_loop,
    53         /** Pingpong loop */
    54         tl_pingpong_loop
    55 } trackmod_looptype_t;
    56 
    5743/** Sample */
    5844typedef struct {
    5945        /** Length in frames */
    6046        size_t length;
    61         /** Bytes per sample */
    62         size_t bytes_smp;
    6347        /** Sample data */
    64         void *data;
    65         /** Loop type */
    66         trackmod_looptype_t loop_type;
     48        int8_t *data;
    6749        /** Loop start position in frames */
    6850        size_t loop_start;
    69         /** Loop length in frames (> 0) */
     51        /** Loop length in frames or 0 - no looping */
    7052        size_t loop_len;
    7153        /** Default volume (0..63) */
    7254        uint8_t def_vol;
    73         /** Relative note */
    74         int rel_note;
    75         /** Finetune value (-8..7) in 1/8 semitones */
    76         int finetune;
    7755} trackmod_sample_t;
    78 
    79 /** Instrument */
    80 typedef struct {
    81         /** Number of samples */
    82         size_t samples;
    83         /** Samples */
    84         trackmod_sample_t *sample;
    85         /** Sample index for each key */
    86         int key_smp[max_key];
    87 } trackmod_instr_t;
    88 
    89 /** Pattern cell */
    90 typedef struct {
    91         /** Note */
    92         unsigned note;
    93         /** Sample period */
    94         unsigned period;
    95         /** Instrument number */
    96         unsigned instr;
    97         /** Volume */
    98         uint8_t volume;
    99         /** Effect */
    100         uint16_t effect;
    101 } trackmod_cell_t;
    10256
    10357/** Pattern */
    … …  
    10862        size_t channels;
    10963        /** Pattern data */
    110         trackmod_cell_t *data;
     64        uint32_t *data;
    11165} trackmod_pattern_t;
    11266
    … …  
    11670        size_t channels;
    11771        /** Number of samples */
    118         size_t instrs;
    119         /** Instruments */
    120         trackmod_instr_t *instr;
     72        size_t samples;
     73        /** Samples */
     74        trackmod_sample_t *sample;
    12175        /** Number of patterns */
    12276        size_t patterns;
    … …  
    12781        /** Order list */
    12882        size_t *ord_list;
    129         /** Restart pos */
    130         size_t restart_pos;
    131         /** Default BPM */
    132         unsigned def_bpm;
    133         /** Default TPR */
    134         unsigned def_tpr;
    13583} trackmod_module_t;
    13684
    … …  
    14492        /** Sample position (clock ticks within frame) */
    14593        size_t smp_clk;
    146         /** Current period */
     94        /** Period */
    14795        unsigned period;
    148         /** Period after note was processed, zero if no note */
    149         unsigned period_new;
    15096        /** Volume */
    15197        uint8_t volume;
    152         /** Volume slide amount */
    153         int vol_slide;
    154         /** Portamento amount (positive for tone and up portamento,
    155           * negative for down portamento. */
    156         int portamento;
    157         /** Tone portamento target period. */
    158         unsigned period_tgt;
    15998} trackmod_chan_t;
    16099
    … …  
    193132} trackmod_modplay_t;
    194133
     134/** Pattern cell (decoded) */
     135typedef struct {
     136        /** Sample period */
     137        unsigned period;
     138        /** Sample number */
     139        unsigned sample;
     140        /** Effect */
     141        unsigned effect;
     142} trackmod_cell_t;
     143
    195144#endif
    196145

  • uspace/lib/usbdev/src/hub.c

    r235d31d r759ea0d  
    162162        if (hc_conn == NULL)
    163163                return EINVAL;
    164        
     164
     165        int rc;
    165166        struct timeval start_time;
    166         gettimeofday(&start_time, NULL);
    167        
     167
     168        rc = gettimeofday(&start_time, NULL);
     169        if (rc != EOK) {
     170                return rc;
     171        }
     172
    168173        /* We are gona do a lot of communication better open it in advance. */
    169         int rc = usb_hc_connection_open(hc_conn);
    170         if (rc != EOK)
     174        rc = usb_hc_connection_open(hc_conn);
     175        if (rc != EOK) {
    171176                return rc;
    172        
     177        }
     178
    173179        /* Request a new address. */
    174180        usb_address_t dev_addr =
    … …  
    220226                goto leave_release_default_address;
    221227        }
    222        
     228
    223229        struct timeval end_time;
    224         gettimeofday(&end_time, NULL);
    225        
     230        rc = gettimeofday(&end_time, NULL);
     231        if (rc != EOK) {
     232                goto leave_release_default_address;
     233        }
     234
    226235        /* According to the USB spec part 9.1.2 host allows 100ms time for
    227236         * the insertion process to complete. According to 7.1.7.1 this is the

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    r235d31d r759ea0d  
    109109        {
    110110                .base = 0,
    111                 .size = sizeof(cuda_t)
     111                .size = sizeof(cuda_t) 
    112112        }
    113113};
    … …  
    157157
    158158        printf(NAME ": VIA-CUDA Apple Desktop Bus driver\n");
    159        
    160         /*
    161          * Alleviate the virtual memory / page table pressure caused by
    162          * interrupt storms when the default large stacks are used.
    163          */
    164         async_set_notification_handler_stack_size(PAGE_SIZE);
    165159
    166160        for (i = 0; i < ADB_MAX_ADDR; ++i) {
    … …  
    312306        fibril_mutex_lock(&instance->dev_lock);
    313307
    314         switch (instance->xstate) {
    315         case cx_listen:
    316                 cuda_irq_listen();
    317                 break;
    318         case cx_receive:
    319                 cuda_irq_receive();
    320                 break;
    321         case cx_rcv_end:
    322                 cuda_irq_rcv_end(rbuf, &len);
    323                 handle = true;
    324                 break;
    325         case cx_send_start:
    326                 cuda_irq_send_start();
    327                 break;
    328         case cx_send:
    329                 cuda_irq_send();
    330                 break;
    331         }
    332        
    333308        /* Lower IFR.SR_INT so that CUDA can generate next int by raising it. */
    334309        pio_write_8(&instance->cuda->ifr, SR_INT);
     310
     311        switch (instance->xstate) {
     312        case cx_listen: cuda_irq_listen(); break;
     313        case cx_receive: cuda_irq_receive(); break;
     314        case cx_rcv_end: cuda_irq_rcv_end(rbuf, &len);
     315            handle = true; break;
     316        case cx_send_start: cuda_irq_send_start(); break;
     317        case cx_send: cuda_irq_send(); break;
     318        }
    335319
    336320        fibril_mutex_unlock(&instance->dev_lock);
    … …  
    347331static void cuda_irq_listen(void)
    348332{
    349         uint8_t b = pio_read_8(&dev->b);
    350        
     333        uint8_t b;
     334
     335        b = pio_read_8(&dev->b);
     336
    351337        if ((b & TREQ) != 0) {
    352338                printf("cuda_irq_listen: no TREQ?!\n");
    353339                return;
    354340        }
    355        
    356         pio_write_8(&dev->b, b & ~TIP);
     341
     342        pio_read_8(&dev->sr);
     343        pio_write_8(&dev->b, pio_read_8(&dev->b) & ~TIP);
    357344        instance->xstate = cx_receive;
    358345}
    … …  
    364351static void cuda_irq_receive(void)
    365352{
    366         uint8_t data = pio_read_8(&dev->sr);
     353        uint8_t b, data;
     354
     355        data = pio_read_8(&dev->sr);
    367356        if (instance->bidx < CUDA_RCV_BUF_SIZE)
    368357                instance->rcv_buf[instance->bidx++] = data;
    369        
    370         uint8_t b = pio_read_8(&dev->b);
    371        
     358
     359        b = pio_read_8(&dev->b);
     360
    372361        if ((b & TREQ) == 0) {
    373362                pio_write_8(&dev->b, b ^ TACK);
    … …  
    385374static void cuda_irq_rcv_end(void *buf, size_t *len)
    386375{
    387         uint8_t b = pio_read_8(&dev->b);
     376        uint8_t b;
     377       
     378        b = pio_read_8(&dev->b);
     379        pio_read_8(&dev->sr);
    388380       
    389381        if ((b & TREQ) == 0) {
    … …  
    531523}
    532524
     525
    533526/** @}
    534527 */

  • uspace/srv/klog/klog.c

    r235d31d r759ea0d  
    5353#define NAME       "klog"
    5454
    55 typedef size_t __attribute__ ((aligned(1))) unaligned_size_t;
    56 
    5755typedef struct {
    5856        size_t entry_len;
    … …  
    111109        size_t offset = 0;
    112110        while (offset < len) {
    113                 size_t entry_len = *((unaligned_size_t *) (buffer + offset));
     111                size_t entry_len = *((size_t *) (buffer + offset));
    114112               
    115113                if (offset + entry_len > len || entry_len < sizeof(log_entry_t))

  • version

    r235d31d r759ea0d  
    3636
    3737VERSION = 0
    38 PATCHLEVEL = 6
     38PATCHLEVEL = 5
    3939SUBLEVEL = 0
    4040
    … …  
    4545endif
    4646
    47 NAME = Elastic Horse
     47NAME = Fajtl
    4848COPYRIGHT = Copyright (c) 2001-2014 HelenOS project
     49
Note: See TracChangeset for help on using the changeset viewer.