Changes in / [455241b:b39441a] in mainline

Files:

• boot/arch/riscv64/src/asm.S (modified) (1 diff)
• kernel/arch/riscv64/src/mm/page.c (modified) (1 diff)
• tools/toolchain.sh (modified) (3 diffs)
• uspace/app/shutdown-dlg/shutdown-dlg.c (modified) (12 diffs)
• uspace/app/taskbar/taskbar.sif (modified) (2 diffs)
• uspace/drv/block/virtio-blk/virtio-blk.c (modified) (1 diff)
• uspace/drv/nic/virtio-net/virtio-net.c (modified) (1 diff)
• uspace/lib/ata/src/ata.c (modified) (2 diffs)
• uspace/lib/c/arch/arm32/src/atomic.c (modified) (2 diffs)
• uspace/lib/c/generic/rtld/module.c (modified) (1 diff)
• uspace/lib/c/generic/thread/fibril_synch.c (modified) (1 diff)
• uspace/lib/c/generic/thread/tls.c (modified) (4 diffs)
• uspace/lib/cpp/include/__bits/io/ios.hpp (modified) (1 diff)
• uspace/lib/gfxfont/private/testgc.h (added)
• uspace/lib/gfxfont/src/glyph_bmp.c (modified) (2 diffs)
• uspace/lib/gfxfont/test/font.c (modified) (4 diffs)
• uspace/lib/gfxfont/test/glyph.c (modified) (2 diffs)
• uspace/lib/gfxfont/test/glyph_bmp.c (modified) (2 diffs)
• uspace/lib/gfxfont/test/text.c (modified) (2 diffs)
• uspace/lib/gfxfont/test/tpf.c (modified) (2 diffs)
• uspace/lib/gfxfont/test/typeface.c (modified) (2 diffs)
• uspace/lib/trackmod/protracker.c (modified) (5 diffs)
• uspace/lib/trackmod/xm.c (modified) (3 diffs)
• uspace/lib/ui/include/types/ui/msgdialog.h (modified) (2 diffs)
• uspace/lib/ui/private/testgc.h (added)
• uspace/lib/ui/src/dummygc.c (modified) (1 diff)
• uspace/lib/ui/src/msgdialog.c (modified) (1 diff)
• uspace/lib/ui/test/checkbox.c (modified) (3 diffs)
• uspace/lib/ui/test/label.c (modified) (2 diffs)
• uspace/lib/ui/test/paint.c (modified) (2 diffs)
• uspace/lib/ui/test/pbutton.c (modified) (3 diffs)
• uspace/lib/ui/test/rbutton.c (modified) (3 diffs)
• uspace/lib/ui/test/resource.c (modified) (3 diffs)
• uspace/lib/ui/test/slider.c (modified) (3 diffs)
• uspace/lib/ui/test/wdecor.c (modified) (3 diffs)
• uspace/srv/vfs/vfs_register.c (modified) (1 diff)

boot/arch/riscv64/src/asm.S

@@ -108 +108 @@
         or t0, t0, t1
 
-        csrw sptbr, t0
+        csrw satp, t0
 
         /* Jump to supervisor mode */

kernel/arch/riscv64/src/mm/page.c

@@ -85 +85 @@
 
         asm volatile (
-            "csrw sptbr, %[satp]\n"
-            :: [satp] "r" (satp)
+            "csrw satp, %[satpv]\n"
+            :: [satpv] "r" (satp)
         );
 }

tools/toolchain.sh

@@ -31 +31 @@
 BINUTILS_GDB_GIT="https://github.com/HelenOS/binutils-gdb.git"
 
-BINUTILS_BRANCH="binutils-2_41-helenos"
-BINUTILS_VERSION="2.41"
+BINUTILS_BRANCH="binutils-2_43-helenos"
+BINUTILS_VERSION="2.43"
 
 GDB_BRANCH="gdb-13.2-helenos"
@@ -38 +38 @@
 
 GCC_GIT="https://github.com/HelenOS/gcc.git"
-GCC_BRANCH="13_2_0-helenos"
-GCC_VERSION="13.2"
+GCC_BRANCH="14_2_0-helenos"
+GCC_VERSION="14.2"
 
 BASEDIR="$PWD"
@@ -419 +419 @@
                 --enable-languages=c,c++,go \
                 --enable-lto \
+                --enable-obsolete \
                 --disable-shared \
                 --disable-werror \

uspace/app/shutdown-dlg/shutdown-dlg.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Jiri Svoboda
+ * Copyright (c) 2025 Jiri Svoboda
  * All rights reserved.
  *
@@ -41 +41 @@
 #include <ui/fixed.h>
 #include <ui/label.h>
+#include <ui/msgdialog.h>
 #include <ui/resource.h>
 #include <ui/ui.h>
@@ -48 +49 @@
 static void wnd_close(ui_window_t *, void *);
 static errno_t bg_wnd_paint(ui_window_t *, void *);
+static void shutdown_progress_destroy(shutdown_progress_t *);
+static errno_t shutdown_confirm_msg_create(shutdown_dlg_t *);
+static errno_t shutdown_failed_msg_create(shutdown_dlg_t *);
+static errno_t shutdown_start(shutdown_dlg_t *);
 
 static ui_window_cb_t bg_window_cb = {
@@ -64 +69 @@
         .shutdown_complete = sd_shutdown_complete,
         .shutdown_failed = sd_shutdown_failed
+};
+
+static void shutdown_confirm_msg_button(ui_msg_dialog_t *, void *, unsigned);
+static void shutdown_confirm_msg_close(ui_msg_dialog_t *, void *);
+
+static ui_msg_dialog_cb_t shutdown_confirm_msg_cb = {
+        .button = shutdown_confirm_msg_button,
+        .close = shutdown_confirm_msg_close
+};
+
+static void shutdown_failed_msg_button(ui_msg_dialog_t *, void *, unsigned);
+static void shutdown_failed_msg_close(ui_msg_dialog_t *, void *);
+
+static ui_msg_dialog_cb_t shutdown_failed_msg_cb = {
+        .button = shutdown_failed_msg_button,
+        .close = shutdown_failed_msg_close
 };
 
@@ -90 +111 @@
 
         ui_lock(sddlg->ui);
-        (void)ui_label_set_text(sddlg->progress->label, "Shutdown failed.");
-        (void)ui_window_paint(sddlg->progress->window);
+        shutdown_progress_destroy(sddlg->progress);
+        sddlg->progress = NULL;
+        ui_window_destroy(sddlg->bgwindow);
+        sddlg->bgwindow = NULL;
+        (void)shutdown_failed_msg_create(sddlg);
         ui_unlock(sddlg->ui);
 }
@@ -135 +159 @@
 
         return EOK;
+}
+
+/** Create shutdown confirmation dialog.
+ *
+ * @param sddlg Shutdown dialog
+ * @return EOK on success or an error code
+ */
+static errno_t shutdown_confirm_msg_create(shutdown_dlg_t *sddlg)
+{
+        ui_msg_dialog_params_t params;
+        ui_msg_dialog_t *dialog;
+        errno_t rc;
+
+        ui_msg_dialog_params_init(&params);
+        params.caption = "Shutdown";
+        params.text = "Do you want to shut the system down?";
+        params.choice = umdc_ok_cancel;
+        params.flags |= umdf_topmost | umdf_center;
+
+        rc = ui_msg_dialog_create(sddlg->ui, &params, &dialog);
+        if (rc != EOK)
+                return rc;
+
+        ui_msg_dialog_set_cb(dialog, &shutdown_confirm_msg_cb, sddlg);
+
+        return EOK;
+}
+
+/** Create 'shutdown failed' message dialog.
+ *
+ * @param sddlg Shutdown dialog
+ * @return EOK on success or an error code
+ */
+static errno_t shutdown_failed_msg_create(shutdown_dlg_t *sddlg)
+{
+        ui_msg_dialog_params_t params;
+        ui_msg_dialog_t *dialog;
+        errno_t rc;
+
+        ui_msg_dialog_params_init(&params);
+        params.caption = "Shutdown failed";
+        params.text = "The system failed to shut down properly.";
+
+        rc = ui_msg_dialog_create(sddlg->ui, &params, &dialog);
+        if (rc != EOK)
+                return rc;
+
+        ui_msg_dialog_set_cb(dialog, &shutdown_failed_msg_cb, sddlg);
+
+        return EOK;
+}
+
+/** Shutdown confirm message dialog button press.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (ui_demo_t *)
+ * @param bnum Button number
+ */
+static void shutdown_confirm_msg_button(ui_msg_dialog_t *dialog,
+    void *arg, unsigned bnum)
+{
+        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+
+        if (bnum == 0)
+                shutdown_start(sddlg);
+        else
+                ui_quit(sddlg->ui);
+}
+
+/** Shutdown confirm message dialog close request.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (ui_demo_t *)
+ */
+static void shutdown_confirm_msg_close(ui_msg_dialog_t *dialog, void *arg)
+{
+        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sddlg->ui);
+}
+
+/** Shutdown faield message dialog button press.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (ui_demo_t *)
+ * @param bnum Button number
+ */
+static void shutdown_failed_msg_button(ui_msg_dialog_t *dialog,
+    void *arg, unsigned bnum)
+{
+        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sddlg->ui);
+}
+
+/** Shutdown failed message dialog close request.
+ *
+ * @param dialog Message dialog
+ * @param arg Argument (ui_demo_t *)
+ */
+static void shutdown_failed_msg_close(ui_msg_dialog_t *dialog, void *arg)
+{
+        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;
+
+        ui_msg_dialog_destroy(dialog);
+        ui_quit(sddlg->ui);
 }
 
@@ -162 +296 @@
                 params.rect.p0.x = 0;
                 params.rect.p0.y = 0;
-                params.rect.p1.x = 24;
+                params.rect.p1.x = 64;
                 params.rect.p1.y = 5;
         } else {
@@ -245 +379 @@
 static void shutdown_progress_destroy(shutdown_progress_t *progress)
 {
+        if (progress == NULL)
+                return;
+
         ui_window_destroy(progress->window);
         free(progress);
 }
 
+static errno_t shutdown_start(shutdown_dlg_t *sddlg)
+{
+        errno_t rc;
+
+        rc = shutdown_progress_create(sddlg, &sddlg->progress);
+        if (rc != EOK)
+                return rc;
+
+        rc = system_open(SYSTEM_DEFAULT, &sd_system_cb, sddlg, &sddlg->system);
+        if (rc != EOK) {
+                printf("Failed opening system control service.\n");
+                goto error;
+        }
+
+        rc = system_shutdown(sddlg->system);
+        if (rc != EOK) {
+                printf("Failed requesting system shutdown.\n");
+                goto error;
+        }
+
+        return EOK;
+error:
+        return rc;
+}
+
 /** Run shutdown dialog on display. */
 static errno_t shutdown_dlg(const char *display_spec)
 {
         ui_t *ui = NULL;
+        shutdown_dlg_t sddlg;
         ui_wnd_params_t params;
-        ui_window_t *window = NULL;
-        shutdown_dlg_t sddlg;
         errno_t rc;
 
@@ -265 +426 @@
                 goto error;
         }
+
+        sddlg.ui = ui;
 
         ui_wnd_params_init(&params);
@@ -271 +434 @@
         params.placement = ui_wnd_place_full_screen;
         params.flags |= ui_wndf_topmost | ui_wndf_nofocus;
-        if (ui_is_textmode(ui)) {
-                params.rect.p0.x = 0;
-                params.rect.p0.y = 0;
-                params.rect.p1.x = 24;
-                params.rect.p1.y = 5;
+        /*
+         * params.rect.p0.x = 0;
+         * params.rect.p0.y = 0;
+         * params.rect.p1.x = 1;
+         * params.rect.p1.y = 1;
+         */
+
+        rc = ui_window_create(sddlg.ui, &params, &sddlg.bgwindow);
+        if (rc != EOK) {
+                printf("Error creating window.\n");
+                goto error;
+        }
+
+        ui_window_set_cb(sddlg.bgwindow, &bg_window_cb, (void *)&sddlg);
+
+        if (ui_is_textmode(sddlg.ui)) {
+                rc = gfx_color_new_ega(0x17, &sddlg.bg_color);
+                if (rc != EOK) {
+                        printf("Error allocating color.\n");
+                        goto error;
+                }
         } else {
-                params.rect.p0.x = 0;
-                params.rect.p0.y = 0;
-                params.rect.p1.x = 300;
-                params.rect.p1.y = 60;
-        }
-
-        sddlg.ui = ui;
-
-        rc = ui_window_create(ui, &params, &window);
-        if (rc != EOK) {
-                printf("Error creating window.\n");
-                goto error;
-        }
-
-        ui_window_set_cb(window, &bg_window_cb, (void *) &sddlg);
-        sddlg.bgwindow = window;
-
-        rc = gfx_color_new_rgb_i16(0x8000, 0xc800, 0xffff, &sddlg.bg_color);
-        if (rc != EOK) {
-                printf("Error allocating color.\n");
-                goto error;
-        }
-
-        rc = ui_window_paint(window);
+                rc = gfx_color_new_rgb_i16(0x8000, 0xc800, 0xffff, &sddlg.bg_color);
+                if (rc != EOK) {
+                        printf("Error allocating color.\n");
+                        goto error;
+                }
+        }
+
+        rc = ui_window_paint(sddlg.bgwindow);
         if (rc != EOK) {
                 printf("Error painting window.\n");
@@ -306 +469 @@
         }
 
-        rc = shutdown_progress_create(&sddlg, &sddlg.progress);
-        if (rc != EOK)
-                return rc;
-
-        rc = system_open(SYSTEM_DEFAULT, &sd_system_cb, &sddlg, &sddlg.system);
-        if (rc != EOK) {
-                printf("Failed opening system control service.\n");
-                goto error;
-        }
-
-        rc = system_shutdown(sddlg.system);
-        if (rc != EOK) {
-                printf("Failed requesting system shutdown.\n");
-                goto error;
-        }
+        (void)shutdown_confirm_msg_create(&sddlg);
 
         ui_run(ui);
 
         shutdown_progress_destroy(sddlg.progress);
-        ui_window_destroy(window);
-        system_close(sddlg.system);
+        if (sddlg.bgwindow != NULL)
+                ui_window_destroy(sddlg.bgwindow);
+        if (sddlg.system != NULL)
+                system_close(sddlg.system);
         gfx_color_delete(sddlg.bg_color);
         ui_destroy(ui);
@@ -336 +487 @@
         if (sddlg.bg_color != NULL)
                 gfx_color_delete(sddlg.bg_color);
-        if (window != NULL)
-                ui_window_destroy(window);
+        if (sddlg.bgwindow != NULL)
+                ui_window_destroy(sddlg.bgwindow);
         if (ui != NULL)
                 ui_destroy(ui);

uspace/app/taskbar/taskbar.sif

@@ -25 +25 @@
 <entry caption="~D~isplay Configuration" cmd="/app/display-cfg -d %d" terminal="n">
 </entry>
-<entry caption="Ta~s~kbar Configuration" cmd="/app/taskbar-cfg -d %d" terminal="n">
+<entry caption="Taskba~r~ Configuration" cmd="/app/taskbar-cfg -d %d" terminal="n">
 </entry>
 <entry separator="y">
@@ -37 +37 @@
 <entry caption="~A~bout HelenOS" cmd="/app/aboutos -d %d" terminal="n">
 </entry>
+<entry caption="~S~hut Down..." cmd="/app/shutdown-dlg -d %d" terminal="n">
+</entry>
 </entries>
 </sif>

uspace/drv/block/virtio-blk/virtio-blk.c

@@ -365 +365 @@
         }
 
-        vdev->queues = calloc(sizeof(virtq_t), num_queues);
+        vdev->queues = calloc(num_queues, sizeof(virtq_t));
         if (!vdev->queues) {
                 rc = ENOMEM;

uspace/drv/nic/virtio-net/virtio-net.c

@@ -221 +221 @@
         }
 
-        vdev->queues = calloc(sizeof(virtq_t), num_queues);
+        vdev->queues = calloc(num_queues, sizeof(virtq_t));
         if (!vdev->queues) {
                 rc = ENOMEM;

uspace/lib/ata/src/ata.c

@@ -260 +260 @@
                 if (rc != EOK) {
                         ata_msg_error(chan, "Unable to remove device %d.", i);
-                        break;
+                        fibril_mutex_unlock(&chan->lock);
+                        return rc;
                 }
         }
@@ -266 +267 @@
         ata_bd_fini_irq(chan);
         fibril_mutex_unlock(&chan->lock);
+        free(chan);
 
         return rc;

uspace/lib/c/arch/arm32/src/atomic.c

@@ -86 +86 @@
 }
 
+unsigned char __atomic_exchange_1(volatile void *mem0, unsigned char val,
+    int model)
+{
+        volatile unsigned char *mem = mem0;
+
+        (void) model;
+
+        unsigned ret;
+
+        /*
+         * The following instructions between labels 1 and 2 constitute a
+         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
+         * the kernel will restart it.
+         */
+        asm volatile (
+            "1:\n"
+            "   adr %[ret], 1b\n"
+            "   str %[ret], %[rp0]\n"
+            "   adr %[ret], 2f\n"
+            "   str %[ret], %[rp1]\n"
+            "   ldrb %[ret], %[addr]\n"
+            "   strb %[imm], %[addr]\n"
+            "2:\n"
+            : [ret] "=&r" (ret),
+              [rp0] "=m" (ras_page[0]),
+              [rp1] "=m" (ras_page[1]),
+              [addr] "+m" (*mem)
+            : [imm] "r" (val)
+        );
+
+        ras_page[0] = 0;
+        ras_page[1] = 0xffffffff;
+
+        return ret;
+}
+
+unsigned short __atomic_exchange_2(volatile void *mem0, unsigned short val,
+    int model)
+{
+        volatile unsigned short *mem = mem0;
+
+        (void) model;
+
+        unsigned ret;
+
+        /*
+         * The following instructions between labels 1 and 2 constitute a
+         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
+         * the kernel will restart it.
+         */
+        asm volatile (
+            "1:\n"
+            "   adr %[ret], 1b\n"
+            "   str %[ret], %[rp0]\n"
+            "   adr %[ret], 2f\n"
+            "   str %[ret], %[rp1]\n"
+            "   ldrh %[ret], %[addr]\n"
+            "   strh %[imm], %[addr]\n"
+            "2:\n"
+            : [ret] "=&r" (ret),
+              [rp0] "=m" (ras_page[0]),
+              [rp1] "=m" (ras_page[1]),
+              [addr] "+m" (*mem)
+            : [imm] "r" (val)
+        );
+
+        ras_page[0] = 0;
+        ras_page[1] = 0xffffffff;
+
+        return ret;
+}
+
+unsigned __atomic_exchange_4(volatile void *mem0, unsigned val, int model)
+{
+        volatile unsigned *mem = mem0;
+
+        (void) model;
+
+        unsigned ret;
+
+        /*
+         * The following instructions between labels 1 and 2 constitute a
+         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
+         * the kernel will restart it.
+         */
+        asm volatile (
+            "1:\n"
+            "   adr %[ret], 1b\n"
+            "   str %[ret], %[rp0]\n"
+            "   adr %[ret], 2f\n"
+            "   str %[ret], %[rp1]\n"
+            "   ldr %[ret], %[addr]\n"
+            "   str %[imm], %[addr]\n"
+            "2:\n"
+            : [ret] "=&r" (ret),
+              [rp0] "=m" (ras_page[0]),
+              [rp1] "=m" (ras_page[1]),
+              [addr] "+m" (*mem)
+            : [imm] "r" (val)
+        );
+
+        ras_page[0] = 0;
+        ras_page[1] = 0xffffffff;
+
+        return ret;
+}
+
 unsigned short __atomic_fetch_add_2(volatile void *mem0, unsigned short val,
     int model)
@@ -164 +271 @@
 }
 
+bool __atomic_test_and_set(volatile void *ptr, int memorder)
+{
+        volatile unsigned char *b = ptr;
+
+        unsigned char orig = __atomic_exchange_n(b, (unsigned char) true, memorder);
+        return orig != 0;
+}
+
 void __sync_synchronize(void)
 {

uspace/lib/c/generic/rtld/module.c

@@ -398 +398 @@
          * be correct, "zero" offset (i.e. the total size) must be aligned
          * to the strictest alignment present.
-         * Note that the padding is actually in front of the TLS data,
-         * not after it.
          */
         rtld->tls_size = ALIGN_UP(rtld->tls_size, rtld->tls_align);
 
-        /* Space for the TCB. */
+        /*
+         * Space for the TCB.
+         * Later, the TLS zero offset is equal to the pointer to tcb_t, so
+         * adding the sizeof(tcb_t) block AFTER we calculated the alignment
+         * of the remainder above is correct.
+         */
         rtld->tls_size += sizeof(tcb_t);
 #endif

uspace/lib/c/generic/thread/fibril_synch.c

@@ -263 +263 @@
         futex_lock(&fibril_synch_futex);
 
-        if (!frw->writers) {
+        if (!frw->writers && list_empty(&frw->waiters)) {
                 /* Consider the first reader the owner. */
                 if (frw->readers++ == 0)

uspace/lib/c/generic/thread/tls.c

@@ -59 +59 @@
 #endif
 
-static ptrdiff_t _tcb_data_offset(void)
+static ptrdiff_t _tcb_data_offset(const void *elf)
 {
         const elf_segment_header_t *tls =
-            elf_get_phdr(__progsymbols.elfstart, PT_TLS);
+            elf_get_phdr(elf, PT_TLS);
 
         size_t tls_align = tls ? tls->p_align : 1;
@@ -80 +80 @@
         assert(runtime_env == NULL);
 #endif
-        return (uint8_t *)__tcb_get() + _tcb_data_offset();
+        return (uint8_t *)__tcb_get() + _tcb_data_offset(__progsymbols.elfstart);
 }
 
 static tcb_t *tls_make_generic(const void *elf, void *(*alloc)(size_t, size_t))
 {
+        /*
+         * See also rtld/module.c -> modules_process_tls(), where we have less
+         * messy code for the dynamic-linking version of this.
+         */
         assert(!elf_get_phdr(elf, PT_DYNAMIC));
 #ifdef CONFIG_RTLD
@@ -100 +104 @@
         assert(tls_align <= PAGE_SIZE);
 
+        /*
+         * FIXME: the calculation of alloc_size shouldn't include the alignment
+         * of tcb_t (at least in Variant II)
+         * See https://github.com/HelenOS/helenos/pull/240/files/4ef27ebf98a0656e09889b7d00efdec03343f1aa#r1929592924
+         * (you will also need to fix _tcb_data_offset)
+         */
+
 #ifdef CONFIG_TLS_VARIANT_1
         size_t alloc_size =
@@ -114 +125 @@
 #ifdef CONFIG_TLS_VARIANT_1
         tcb_t *tcb = area;
-        uint8_t *data = (uint8_t *)tcb + _tcb_data_offset();
+        uint8_t *data = (uint8_t *)tcb + _tcb_data_offset(elf);
         memset(tcb, 0, sizeof(*tcb));
 #else
         uint8_t *data = area;
-        tcb_t *tcb = (tcb_t *) (data - _tcb_data_offset());
+        tcb_t *tcb = (tcb_t *) (data - _tcb_data_offset(elf));
         memset(tcb, 0, sizeof(tcb_t));
         tcb->self = tcb;

uspace/lib/cpp/include/__bits/io/ios.hpp

@@ -403 +403 @@
                 delete[] parray_;
                 parray_size_ = rhs.parray_size_;
-                parray_ = new long[parray_size_];
+                parray_ = new void *[parray_size_];
 
                 for (size_t i = 0; i < parray_size_; ++i)

uspace/lib/gfxfont/src/glyph_bmp.c

@@ -293 +293 @@
 
         /* Allocate new pixel array */
-        npixels = calloc(sizeof(int), 1);
+        npixels = calloc(1, sizeof(int));
         if (npixels == NULL)
                 return ENOMEM;
@@ -332 +332 @@
 
         /* Allocate new pixel array */
-        npixels = calloc(sizeof(int), (nrect.p1.x - nrect.p0.x) *
-            (nrect.p1.y - nrect.p0.y));
+        npixels = calloc((nrect.p1.x - nrect.p0.x) *
+            (nrect.p1.y - nrect.p0.y), sizeof(int));
         if (npixels == NULL)
                 return ENOMEM;

uspace/lib/gfxfont/test/font.c

@@ -34 +34 @@
 #include "../private/font.h"
 #include "../private/typeface.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(font);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t test_ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 /** Test creating and destroying font */
@@ -509 +478 @@
         height = 10;
 
-        pixels = calloc(sizeof(uint32_t), width * height);
+        pixels = calloc(width * height, sizeof(uint32_t));
         PCUT_ASSERT_NOT_NULL(pixels);
 
@@ -556 +525 @@
         }
 
-        pixels = calloc(sizeof(uint32_t), width * height);
+        pixels = calloc(width * height, sizeof(uint32_t));
         PCUT_ASSERT_NOT_NULL(pixels);
 
@@ -572 +541 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    tbm->alloc.pitch * (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        return EOK;
-}
-
 PCUT_EXPORT(font);

uspace/lib/gfxfont/test/glyph.c

@@ -38 +38 @@
 #include <str.h>
 #include "../private/glyph.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(glyph);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t test_ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 /** Test creating and destroying glyph */
@@ -571 +540 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    tbm->alloc.pitch * (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        return EOK;
-}
-
 PCUT_EXPORT(glyph);

uspace/lib/gfxfont/test/glyph_bmp.c

@@ -34 +34 @@
 #include <pcut/pcut.h>
 #include "../private/glyph_bmp.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(glyph_bmp);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t test_ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 /** Test opening and closing glyph bitmap */
@@ -585 +554 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    tbm->alloc.pitch * (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        return EOK;
-}
-
 PCUT_EXPORT(glyph_bmp);

uspace/lib/gfxfont/test/text.c

@@ -36 +36 @@
 #include "../private/font.h"
 #include "../private/typeface.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(text);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t test_ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 /** Test text width computation with a dummy font */
@@ -454 +423 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    tbm->alloc.pitch * (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        return EOK;
-}
-
 PCUT_EXPORT(text);

uspace/lib/gfxfont/test/tpf.c

@@ -36 +36 @@
 #include "../private/font.h"
 #include "../private/typeface.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(tpf);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t test_ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 static const gfx_font_flags_t test_font_flags = gff_bold_italic;
@@ -211 +180 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    tbm->alloc.pitch * (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        return EOK;
-}
-
 PCUT_EXPORT(tpf);

uspace/lib/gfxfont/test/typeface.c

@@ -32 +32 @@
 #include <pcut/pcut.h>
 #include "../private/typeface.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(typeface);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t test_ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 /** Test creating and destroying typeface */
@@ -98 +67 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    tbm->alloc.pitch * (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        return EOK;
-}
-
 PCUT_EXPORT(typeface);

uspace/lib/trackmod/protracker.c

@@ -146 +146 @@
 
         cells = module->channels * protracker_pattern_rows;
-        buf = calloc(sizeof(uint32_t), cells);
+        buf = calloc(cells, sizeof(uint32_t));
 
         if (buf == NULL) {
@@ -156 +156 @@
                 module->pattern[i].rows = protracker_pattern_rows;
                 module->pattern[i].channels = module->channels;
-                module->pattern[i].data = calloc(sizeof(trackmod_cell_t), cells);
+                module->pattern[i].data = calloc(cells, sizeof(trackmod_cell_t));
                 if (module->pattern[i].data == NULL) {
                         rc = ENOMEM;
@@ -326 +326 @@
 
         module->instrs = samples;
-        module->instr = calloc(sizeof(trackmod_instr_t), samples);
+        module->instr = calloc(samples, sizeof(trackmod_instr_t));
         if (module->instr == NULL) {
                 printf("Out of memory.\n");
@@ -334 +334 @@
 
         module->patterns = patterns;
-        module->pattern = calloc(sizeof(trackmod_pattern_t), patterns);
+        module->pattern = calloc(patterns, sizeof(trackmod_pattern_t));
         if (module->pattern == NULL) {
                 printf("Out of memory.\n");
@@ -343 +343 @@
         /* Order list */
         module->ord_list_len = order_list->order_list_len;
-        module->ord_list = calloc(sizeof(size_t), module->ord_list_len);
+        module->ord_list = calloc(module->ord_list_len, sizeof(size_t));
         if (module->ord_list == NULL) {
                 printf("Out of memory.\n");

uspace/lib/trackmod/xm.c

@@ -66 +66 @@
         }
 
-        module->ord_list = calloc(sizeof(size_t), module->ord_list_len);
+        module->ord_list = calloc(module->ord_list_len, sizeof(size_t));
         if (module->ord_list == NULL) {
                 printf("Out of memory.\n");
@@ -176 +176 @@
         int ret;
 
-        module->pattern = calloc(sizeof(trackmod_pattern_t), module->patterns);
+        module->pattern = calloc(module->patterns, sizeof(trackmod_pattern_t));
         if (module->pattern == NULL) {
                 rc = ENOMEM;
@@ -208 +208 @@
                 module->pattern[i].rows = rows;
                 module->pattern[i].channels = module->channels;
-                module->pattern[i].data = calloc(sizeof(trackmod_cell_t),
-                    rows * module->channels);
+                module->pattern[i].data = calloc(rows * module->channels,
+                    sizeof(trackmod_cell_t));
 
                 if (module->pattern[i].data == NULL) {

uspace/lib/ui/include/types/ui/msgdialog.h

@@ -58 +58 @@
 } ui_msg_dialog_choice_t;
 
+/** Message dialog flags */
+typedef enum {
+        /** Topmost window */
+        umdf_topmost = 0x1,
+        /** Place to the center of the screen */
+        umdf_center = 0x2
+} ui_msg_dialog_flags_t;
+
 /** Message dialog parameters */
 typedef struct {
@@ -66 +74 @@
         /** The choice that the user is given */
         ui_msg_dialog_choice_t choice;
+        /** Flags */
+        ui_msg_dialog_flags_t flags;
 } ui_msg_dialog_params_t;
 

uspace/lib/ui/src/dummygc.c

@@ -181 +181 @@
                     sizeof(uint32_t);
                 tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
+                tbm->alloc.pixels = calloc(
                     (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
+                    (params->rect.p1.y - params->rect.p0.y),
+                    sizeof(uint32_t));
                 tbm->myalloc = true;
                 if (tbm->alloc.pixels == NULL) {

uspace/lib/ui/src/msgdialog.c

@@ -111 +111 @@
         ui_wnd_params_init(&wparams);
         wparams.caption = params->caption;
+        if ((params->flags & umdf_topmost) != 0)
+                wparams.flags |= wndf_topmost;
+        if ((params->flags & umdf_center) != 0)
+                wparams.placement = ui_wnd_place_center;
 
         /* FIXME: Auto layout */

uspace/lib/ui/test/checkbox.c

@@ -36 +36 @@
 #include <ui/resource.h>
 #include "../private/checkbox.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(checkbox);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_update(void *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .update = testgc_update,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
 
 static void test_checkbox_switched(ui_checkbox_t *, void *, bool);
@@ -70 +50 @@
 static ui_checkbox_cb_t dummy_checkbox_cb = {
 };
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 typedef struct {
@@ -549 +512 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        (void) arg;
-        (void) color;
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_update(void *arg)
-{
-        (void) arg;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 static void test_checkbox_switched(ui_checkbox_t *checkbox, void *arg,
     bool checked)

uspace/lib/ui/test/label.c

@@ -36 +36 @@
 #include <ui/resource.h>
 #include "../private/label.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(label);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_update(void *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .update = testgc_update,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 typedef struct {
@@ -213 +176 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        (void) arg;
-        (void) color;
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_update(void *arg)
-{
-        (void) arg;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 PCUT_EXPORT(label);

uspace/lib/ui/test/paint.c

@@ -34 +34 @@
 #include <ui/paint.h>
 #include <ui/resource.h>
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(paint);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 /** Test box characters */
@@ -591 +556 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        (void) arg;
-        (void) color;
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 PCUT_EXPORT(paint);

uspace/lib/ui/test/pbutton.c

@@ -36 +36 @@
 #include <ui/resource.h>
 #include "../private/pbutton.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(pbutton);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_update(void *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .update = testgc_update,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
 
 static void test_pbutton_clicked(ui_pbutton_t *, void *);
@@ -74 +54 @@
 static ui_pbutton_cb_t dummy_pbutton_cb = {
 };
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 typedef struct {
@@ -625 +588 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        (void) arg;
-        (void) color;
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_update(void *arg)
-{
-        (void) arg;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 static void test_pbutton_clicked(ui_pbutton_t *pbutton, void *arg)
 {

uspace/lib/ui/test/rbutton.c

@@ -36 +36 @@
 #include <ui/resource.h>
 #include "../private/rbutton.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(rbutton);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_update(void *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .update = testgc_update,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
 
 static void test_rbutton_select(ui_rbutton_group_t *, void *, void *);
@@ -70 +50 @@
 static ui_rbutton_group_cb_t dummy_rbutton_group_cb = {
 };
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 typedef struct {
@@ -592 +555 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        (void) arg;
-        (void) color;
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_update(void *arg)
-{
-        (void) arg;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 static void test_rbutton_select(ui_rbutton_group_t *group, void *arg,
     void *barg)

uspace/lib/ui/test/resource.c

@@ -33 +33 @@
 #include <ui/resource.h>
 #include "../private/resource.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
@@ -38 +39 @@
 PCUT_TEST_SUITE(resource);
 
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
 static void test_expose(void *);
-
-static gfx_context_ops_t ops = {
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 typedef struct {
@@ -240 +211 @@
 }
 
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 static void test_expose(void *arg)
 {

uspace/lib/ui/test/slider.c

@@ -36 +36 @@
 #include <ui/resource.h>
 #include "../private/slider.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(slider);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_update(void *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .update = testgc_update,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
 
 static void test_slider_moved(ui_slider_t *, void *, gfx_coord_t);
@@ -70 +50 @@
 static ui_slider_cb_t dummy_slider_cb = {
 };
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 typedef struct {
@@ -462 +425 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        (void) arg;
-        (void) color;
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_update(void *arg)
-{
-        (void) arg;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 static void test_slider_moved(ui_slider_t *slider, void *arg, gfx_coord_t pos)
 {

uspace/lib/ui/test/wdecor.c

@@ -37 +37 @@
 #include <ui/wdecor.h>
 #include "../private/wdecor.h"
+#include "../private/testgc.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(wdecor);
-
-static errno_t testgc_set_clip_rect(void *, gfx_rect_t *);
-static errno_t testgc_set_color(void *, gfx_color_t *);
-static errno_t testgc_fill_rect(void *, gfx_rect_t *);
-static errno_t testgc_update(void *);
-static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *,
-    gfx_bitmap_alloc_t *, void **);
-static errno_t testgc_bitmap_destroy(void *);
-static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
-static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
-
-static gfx_context_ops_t ops = {
-        .set_clip_rect = testgc_set_clip_rect,
-        .set_color = testgc_set_color,
-        .fill_rect = testgc_fill_rect,
-        .update = testgc_update,
-        .bitmap_create = testgc_bitmap_create,
-        .bitmap_destroy = testgc_bitmap_destroy,
-        .bitmap_render = testgc_bitmap_render,
-        .bitmap_get_alloc = testgc_bitmap_get_alloc
-};
 
 static void test_wdecor_sysmenu_open(ui_wdecor_t *, void *, sysarg_t);
@@ -93 +73 @@
 static ui_wdecor_cb_t dummy_wdecor_cb = {
 };
-
-typedef struct {
-        bool bm_created;
-        bool bm_destroyed;
-        gfx_bitmap_params_t bm_params;
-        void *bm_pixels;
-        gfx_rect_t bm_srect;
-        gfx_coord2_t bm_offs;
-        bool bm_rendered;
-        bool bm_got_alloc;
-} test_gc_t;
-
-typedef struct {
-        test_gc_t *tgc;
-        gfx_bitmap_alloc_t alloc;
-        bool myalloc;
-} testgc_bitmap_t;
 
 typedef struct {
@@ -1567 +1530 @@
 }
 
-static errno_t testgc_set_clip_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_set_color(void *arg, gfx_color_t *color)
-{
-        (void) arg;
-        (void) color;
-        return EOK;
-}
-
-static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect)
-{
-        (void) arg;
-        (void) rect;
-        return EOK;
-}
-
-static errno_t testgc_update(void *arg)
-{
-        (void) arg;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
-    gfx_bitmap_alloc_t *alloc, void **rbm)
-{
-        test_gc_t *tgc = (test_gc_t *) arg;
-        testgc_bitmap_t *tbm;
-
-        tbm = calloc(1, sizeof(testgc_bitmap_t));
-        if (tbm == NULL)
-                return ENOMEM;
-
-        if (alloc == NULL) {
-                tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) *
-                    sizeof(uint32_t);
-                tbm->alloc.off0 = 0;
-                tbm->alloc.pixels = calloc(sizeof(uint32_t),
-                    (params->rect.p1.x - params->rect.p0.x) *
-                    (params->rect.p1.y - params->rect.p0.y));
-                tbm->myalloc = true;
-                if (tbm->alloc.pixels == NULL) {
-                        free(tbm);
-                        return ENOMEM;
-                }
-        } else {
-                tbm->alloc = *alloc;
-        }
-
-        tbm->tgc = tgc;
-        tgc->bm_created = true;
-        tgc->bm_params = *params;
-        tgc->bm_pixels = tbm->alloc.pixels;
-        *rbm = (void *)tbm;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_destroy(void *bm)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        if (tbm->myalloc)
-                free(tbm->alloc.pixels);
-        tbm->tgc->bm_destroyed = true;
-        free(tbm);
-        return EOK;
-}
-
-static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect,
-    gfx_coord2_t *offs)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        tbm->tgc->bm_rendered = true;
-        tbm->tgc->bm_srect = *srect;
-        tbm->tgc->bm_offs = *offs;
-        return EOK;
-}
-
-static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
-{
-        testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm;
-        *alloc = tbm->alloc;
-        tbm->tgc->bm_got_alloc = true;
-        return EOK;
-}
-
 static void test_wdecor_sysmenu_open(ui_wdecor_t *wdecor, void *arg,
     sysarg_t idev_id)

uspace/srv/vfs/vfs_register.c

@@ -369 +369 @@
         }
 
-        fstypes->fstypes = calloc(sizeof(char *), count);
+        fstypes->fstypes = calloc(count, sizeof(char *));
         if (fstypes->fstypes == NULL) {
                 free(fstypes->buf);