Changeset 79ae36dd in mainline for uspace/app


Ignore:
Timestamp:
2011-06-08T19:01:55Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0eff68e
Parents:
764d71e
Message:

new async framework with integrated exchange tracking

  • strict isolation between low-level IPC and high-level async framework with integrated exchange tracking
    • each IPC connection is represented by an async_sess_t structure
    • each IPC exchange is represented by an async_exch_t structure
    • exchange management is either based on atomic messages (EXCHANGE_ATOMIC), locking (EXCHANGE_SERIALIZE) or connection cloning (EXCHANGE_CLONE)
  • async_obsolete: temporary compatibility layer to keep old async clients working (several pieces of code are currently broken, but only non-essential functionality)
  • IPC_M_PHONE_HANGUP is now method no. 0 (for elegant boolean evaluation)
  • IPC_M_DEBUG_ALL has been renamed to IPC_M_DEBUG
  • IPC_M_PING has been removed (VFS protocol now has VFS_IN_PING)
  • console routines in libc have been rewritten for better abstraction
  • additional use for libc-private header files (FILE structure opaque to the client)
  • various cstyle changes (typos, indentation, missing externs in header files, improved comments, etc.)
Location:
uspace/app
Files:
4 deleted
34 edited

Legend:

Unmodified
Added
Removed

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

    r764d71e r79ae36dd  
    102102        }
    103103
    104         rc = block_init(handle, 2048);
     104        rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
    105105        if (rc != EOK)  {
    106106                printf("%s: Error initializing libblock.\n", cmdname);

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

    r764d71e r79ae36dd  
    6464static sysarg_t console_rows = 0;
    6565static bool should_quit = false;
     66
     67static console_ctrl_t *console = NULL;
    6668
    6769static struct option const long_options[] = {
    … …  
    102104static void waitprompt()
    103105{
    104         console_set_pos(fphone(stdout), 0, console_rows-1);
    105         console_set_color(fphone(stdout), COLOR_BLUE, COLOR_WHITE, 0);
     106        console_set_pos(console, 0, console_rows-1);
     107        console_set_color(console, COLOR_BLUE, COLOR_WHITE, 0);
     108       
    106109        printf("ENTER/SPACE/PAGE DOWN - next page, "
    107110               "ESC/Q - quit, C - continue unpaged");
    108111        fflush(stdout);
    109         console_set_style(fphone(stdout), STYLE_NORMAL);
     112       
     113        console_set_style(console, STYLE_NORMAL);
    110114}
    111115
    112116static void waitkey()
    113117{
    114         console_event_t ev;
     118        kbd_event_t ev;
    115119       
    116120        while (true) {
    117                 if (!console_get_event(fphone(stdin), &ev)) {
     121                if (!console_get_kbd_event(console, &ev)) {
    118122                        return;
    119123                }
    … …  
    138142static void newpage()
    139143{
    140         console_clear(fphone(stdout));
     144        console_clear(console);
    141145        chars_remaining = console_cols;
    142         lines_remaining = console_rows-1;
     146        lines_remaining = console_rows - 1;
    143147}
    144148
    … …  
    238242        console_rows = 0;
    239243        should_quit = false;
     244        console = console_init(stdin, stdout);
    240245
    241246        argc = cli_count_args(argv);
    … …  
    280285       
    281286        if (more) {
    282                 rc = console_get_size(fphone(stdout), &cols, &rows);
     287                rc = console_get_size(console, &cols, &rows);
    283288                if (rc != EOK) {
    284289                        printf("%s - cannot get console size\n", cmdname);

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

    r764d71e r79ae36dd  
    3232#include <stdlib.h>
    3333#include <io/console.h>
    34 #include <vfs/vfs.h>
    3534#include "config.h"
    3635#include "util.h"
    … …  
    4241static const char *cmdname = "kcon";
    4342
    44 /* Dispays help for kcon in various levels */
     43/* Display help for kcon in various levels */
    4544void help_cmd_kcon(unsigned int level)
    4645{
    4746        printf("`kcon' switches to the kernel debug console.\n");
    48 
    49         if (level != HELP_SHORT) {
    50                 printf("Usage:  %s\n", cmdname);
    51         }
    52 
     47       
     48        if (level != HELP_SHORT)
     49                printf("Usage: %s\n", cmdname);
     50       
    5351        return;
    5452}
    … …  
    5755int cmd_kcon(char **argv)
    5856{
    59         unsigned int argc;
    60 
    61         argc = cli_count_args(argv);
    62 
     57        unsigned int argc = cli_count_args(argv);
     58       
    6359        if (argc != 1) {
    6460                printf("%s - incorrect number of arguments. Try `%s --help'\n",
    65                         cmdname, cmdname);
     61                    cmdname, cmdname);
    6662                return CMD_FAILURE;
    6763        }
    68 
    69         console_kcon_enable(fphone(stdout));
    70 
    71         return CMD_SUCCESS;
     64       
     65        if (console_kcon())
     66                return CMD_SUCCESS;
     67        else
     68                return CMD_FAILURE;
    7269}
    73 

  • uspace/app/bdsh/input.c

    r764d71e r79ae36dd  
    110110        char *str;
    111111        int rc;
    112 
    113         fflush(stdout);
    114         console_set_style(fphone(stdout), STYLE_EMPHASIS);
     112       
     113        console_flush(tinput->console);
     114        console_set_style(tinput->console, STYLE_EMPHASIS);
    115115        printf("%s", usr->prompt);
    116         fflush(stdout);
    117         console_set_style(fphone(stdout), STYLE_NORMAL);
     116        console_flush(tinput->console);
     117        console_set_style(tinput->console, STYLE_NORMAL);
    118118
    119119        rc = tinput_read(tinput, &str);

  • uspace/app/blkdump/blkdump.c

    r764d71e r79ae36dd  
    134134        }
    135135
    136         rc = block_init(handle, 2048);
     136        rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
    137137        if (rc != EOK)  {
    138138                printf(NAME ": Error initializing libblock.\n");

  • uspace/app/edit/edit.c

    r764d71e r79ae36dd  
    9494} doc_t;
    9595
    96 static int con;
     96static console_ctrl_t *con;
    9797static doc_t doc;
    9898static bool done;
    … …  
    115115static void cursor_setvis(bool visible);
    116116
    117 static void key_handle_unmod(console_event_t const *ev);
    118 static void key_handle_ctrl(console_event_t const *ev);
    119 static void key_handle_shift(console_event_t const *ev);
     117static void key_handle_unmod(kbd_event_t const *ev);
     118static void key_handle_ctrl(kbd_event_t const *ev);
     119static void key_handle_shift(kbd_event_t const *ev);
    120120static void key_handle_movement(unsigned int key, bool shift);
    121121
    … …  
    158158int main(int argc, char *argv[])
    159159{
    160         console_event_t ev;
     160        kbd_event_t ev;
    161161        coord_t coord;
    162162        bool new_file;
    … …  
    164164        spt_t pt;
    165165
    166         con = fphone(stdout);
     166        con = console_init(stdin, stdout);
    167167        console_clear(con);
    168168
    … …  
    219219
    220220        while (!done) {
    221                 console_get_event(con, &ev);
     221                console_get_kbd_event(con, &ev);
    222222                pane.rflags = 0;
    223223
    … …  
    277277
    278278/** Handle key without modifier. */
    279 static void key_handle_unmod(console_event_t const *ev)
     279static void key_handle_unmod(kbd_event_t const *ev)
    280280{
    281281        switch (ev->key) {
    … …  
    320320
    321321/** Handle Shift-key combination. */
    322 static void key_handle_shift(console_event_t const *ev)
     322static void key_handle_shift(kbd_event_t const *ev)
    323323{
    324324        switch (ev->key) {
    … …  
    344344
    345345/** Handle Ctrl-key combination. */
    346 static void key_handle_ctrl(console_event_t const *ev)
     346static void key_handle_ctrl(kbd_event_t const *ev)
    347347{
    348348        switch (ev->key) {
    … …  
    497497static char *filename_prompt(char const *prompt, char const *init_value)
    498498{
    499         console_event_t ev;
     499        kbd_event_t ev;
    500500        char *str;
    501501        wchar_t buffer[INFNAME_MAX_LEN + 1];
    … …  
    517517
    518518        while (!done) {
    519                 console_get_event(con, &ev);
     519                console_get_kbd_event(con, &ev);
    520520
    521521                if (ev.type == KEY_PRESS) {
    … …  
    531531                                        if (nc > 0) {
    532532                                                putchar('\b');
    533                                                 fflush(stdout);
     533                                                console_flush(con);
    534534                                                --nc;
    535535                                        }
    … …  
    541541                                        if (ev.c >= 32 && nc < max_len) {
    542542                                                putchar(ev.c);
    543                                                 fflush(stdout);
     543                                                console_flush(con);
    544544                                                buffer[nc++] = ev.c;
    545545                                        }
    … …  
    689689                for (j = 0; j < scr_columns; ++j)
    690690                        putchar(' ');
    691                 fflush(stdout);
     691                console_flush(con);
    692692        }
    693693
    … …  
    757757                if (coord_cmp(&csel_start, &rbc) <= 0 &&
    758758                    coord_cmp(&rbc, &csel_end) < 0) {
    759                         fflush(stdout);
     759                        console_flush(con);
    760760                        console_set_style(con, STYLE_SELECTED);
    761                         fflush(stdout);
     761                        console_flush(con);
    762762                }
    763763
    … …  
    768768                while (pos < size) {
    769769                        if ((csel_start.row == rbc.row) && (csel_start.column == s_column)) {
    770                                 fflush(stdout);
     770                                console_flush(con);
    771771                                console_set_style(con, STYLE_SELECTED);
    772                                 fflush(stdout);
     772                                console_flush(con);
    773773                        }
    774774       
    775775                        if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
    776                                 fflush(stdout);
     776                                console_flush(con);
    777777                                console_set_style(con, STYLE_NORMAL);
    778                                 fflush(stdout);
     778                                console_flush(con);
    779779                        }
    780780       
    … …  
    794794
    795795                if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) {
    796                         fflush(stdout);
     796                        console_flush(con);
    797797                        console_set_style(con, STYLE_NORMAL);
    798                         fflush(stdout);
     798                        console_flush(con);
    799799                }
    800800
    … …  
    808808                for (j = 0; j < fill; ++j)
    809809                        putchar(' ');
    810                 fflush(stdout);
     810                console_flush(con);
    811811                console_set_style(con, STYLE_NORMAL);
    812812        }
    … …  
    833833        int pos = scr_columns - 1 - n;
    834834        printf("%*s", pos, "");
    835         fflush(stdout);
     835        console_flush(con);
    836836        console_set_style(con, STYLE_NORMAL);
    837837
    … …  
    11581158        int pos = -(scr_columns - 3);
    11591159        printf(" %*s ", pos, str);
    1160         fflush(stdout);
     1160        console_flush(con);
    11611161        console_set_style(con, STYLE_NORMAL);
    11621162

  • uspace/app/init/init.c

    r764d71e r79ae36dd  
    176176static void console(const char *dev)
    177177{
    178         char hid_in[DEVMAP_NAME_MAXLEN];
    179         int rc;
    180        
    181         snprintf(hid_in, DEVMAP_NAME_MAXLEN, "%s/%s", DEVFS_MOUNT_POINT, dev);
    182        
    183         printf("%s: Spawning %s %s\n", NAME, SRV_CONSOLE, hid_in);
     178        printf("%s: Spawning %s %s\n", NAME, SRV_CONSOLE, dev);
    184179       
    185180        /* Wait for the input device to be ready */
    186181        devmap_handle_t handle;
    187         rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
    188         if (rc != EOK) {
    189                 printf("%s: Error waiting on %s (%s)\n", NAME, hid_in,
    190                     str_error(rc));
    191                 return;
    192         }
    193        
    194         rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, hid_in, NULL);
     182        int rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
     183        if (rc != EOK) {
     184                printf("%s: Error waiting on %s (%s)\n", NAME, dev,
     185                    str_error(rc));
     186                return;
     187        }
     188       
     189        rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, dev, NULL);
    195190        if (rc != EOK) {
    196191                printf("%s: Error spawning %s %s (%s)\n", NAME, SRV_CONSOLE,
    197                     hid_in, str_error(rc));
     192                    dev, str_error(rc));
    198193        }
    199194}

  • uspace/app/mkbd/main.c

    r764d71e r79ae36dd  
    4545#include <devmap.h>
    4646#include <usb/dev/hub.h>
    47 //#include <usb/host.h>
    48 //#include <usb/driver.h>
    4947#include <usb/hid/iface.h>
    5048#include <usb/dev/pipes.h>
    … …  
    5856#define NAME "mkbd"
    5957
    60 static int dev_phone = -1;
    61 
    62 static int initialize_report_parser(int dev_phone, usb_hid_report_t **report)
    63 {
    64         *report = (usb_hid_report_t *)malloc(sizeof(usb_hid_report_t));
    65         if (*report == NULL) {
    66                 return ENOMEM;
    67         }
     58static async_sess_t *dev_sess = NULL;
     59
     60static int initialize_report_parser(async_sess_t *dev_sess,
     61    usb_hid_report_t **report)
     62{
     63        *report = (usb_hid_report_t *) malloc(sizeof(usb_hid_report_t));
     64        if (*report == NULL)
     65                return ENOMEM;
    6866       
    6967        int rc = usb_hid_report_init(*report);
    … …  
    7169                usb_hid_free_report(*report);
    7270                *report = NULL;
    73                 //printf("usb_hid_report_init() failed.\n");
    74                 return rc;
    75         }
    76        
    77         // get the report descriptor length from the device
     71                return rc;
     72        }
     73       
     74        /* Get the report descriptor length from the device */
    7875        size_t report_desc_size;
    79         rc = usbhid_dev_get_report_descriptor_length(
    80             dev_phone, &report_desc_size);
    81         if (rc != EOK) {
    82                 usb_hid_free_report(*report);
    83                 *report = NULL;
    84                 //printf("usbhid_dev_get_report_descriptor_length() failed.\n");
     76        rc = usbhid_dev_get_report_descriptor_length(dev_sess,
     77            &report_desc_size);
     78        if (rc != EOK) {
     79                usb_hid_free_report(*report);
     80                *report = NULL;
    8581                return rc;
    8682        }
    … …  
    8985                usb_hid_free_report(*report);
    9086                *report = NULL;
    91                 //printf("usbhid_dev_get_report_descriptor_length() returned 0.\n");
    92                 return EINVAL;  // TODO: other error code?
    93         }
    94        
    95         uint8_t *desc = (uint8_t *)malloc(report_desc_size);
     87                // TODO: other error code?
     88                return EINVAL;
     89        }
     90       
     91        uint8_t *desc = (uint8_t *) malloc(report_desc_size);
    9692        if (desc == NULL) {
    9793                usb_hid_free_report(*report);
    … …  
    10096        }
    10197       
    102         // get the report descriptor from the device
     98        /* Get the report descriptor from the device */
    10399        size_t actual_size;
    104         rc = usbhid_dev_get_report_descriptor(dev_phone, desc, report_desc_size,
     100        rc = usbhid_dev_get_report_descriptor(dev_sess, desc, report_desc_size,
    105101            &actual_size);
    106102        if (rc != EOK) {
    … …  
    108104                *report = NULL;
    109105                free(desc);
    110                 //printf("usbhid_dev_get_report_descriptor() failed.\n");
    111106                return rc;
    112107        }
    … …  
    116111                *report = NULL;
    117112                free(desc);
    118 //              printf("usbhid_dev_get_report_descriptor() returned wrong size:"
    119 //                  " %zu, expected: %zu.\n", actual_size, report_desc_size);
    120                 return EINVAL;  // TODO: other error code?
    121         }
    122        
    123         // initialize the report parser
     113                // TODO: other error code?
     114                return EINVAL;
     115        }
     116       
     117        /* Initialize the report parser */
    124118       
    125119        rc = usb_hid_parse_report_descriptor(*report, desc, report_desc_size);
    … …  
    128122        if (rc != EOK) {
    129123                free(desc);
    130 //              printf("usb_hid_parse_report_descriptor() failed.\n");
    131124                return rc;
    132125        }
    … …  
    140133        assert(report != NULL);
    141134       
    142 //      printf("Calling usb_hid_parse_report() with size %zu and "
    143 //          "buffer: \n", size);
    144 //      for (size_t i = 0; i < size; ++i) {
    145 //              printf(" %X ", buffer[i]);
    146 //      }
    147 //      printf("\n");
    148        
    149135        uint8_t report_id;
    150136        int rc = usb_hid_parse_report(report, buffer, size, &report_id);
    151         if (rc != EOK) {
    152 //              printf("Error parsing report: %s\n", str_error(rc));
     137        if (rc != EOK)
    153138                return;
    154         }
    155139       
    156140        usb_hid_report_path_t *path = usb_hid_report_path();
    … …  
    164148
    165149        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    166             report, NULL, path, USB_HID_PATH_COMPARE_END 
    167             | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
     150            report, NULL, path, USB_HID_PATH_COMPARE_END
     151            | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    168152            USB_HID_REPORT_TYPE_INPUT);
    169153       
    170 //      printf("Field: %p\n", field);
    171        
    172154        while (field != NULL) {
    173 //              printf("Field usage: %u, field value: %d\n", field->usage,
    174 //                  field->value);
    175155                if (field->value != 0) {
    176156                        const char *key_str =
    … …  
    183163                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    184164                    USB_HID_REPORT_TYPE_INPUT);
    185 //              printf("Next field: %p\n", field);
    186165        }
    187166       
    … …  
    194173{
    195174#define _INDENT "      "
    196 
    197        printf(NAME ": Print out what multimedia keys were pressed.\n\n");
    198        printf("Usage: %s device\n", app_name);
    199        printf(_INDENT "The device is a devman path to the device.\n");
    200 
     175        printf(NAME ": Print out what multimedia keys were pressed.\n\n");
     176        printf("Usage: %s device\n", app_name);
     177        printf(_INDENT "The device is a devman path to the device.\n");
    201178#undef _OPTION
    202179#undef _INDENT
    … …  
    223200        }
    224201       
    225         rc = devman_device_connect(dev_handle, 0);
    226         if (rc < 0) {
     202        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE,
     203            dev_handle, 0);
     204        if (!sess) {
    227205                printf(NAME ": failed to connect to the device (handle %"
    228                        PRIun "): %s.\n", dev_handle, str_error(rc));
    229                 return rc;
    230         }
    231        
    232         dev_phone = rc;
    233 //      printf("Got phone to the device: %d\n", dev_phone);
     206                       PRIun "): %s.\n", dev_handle, str_error(errno));
     207                return errno;
     208        }
     209       
     210        dev_sess = sess;
    234211       
    235212        char path[MAX_PATH_LENGTH];
    … …  
    243220       
    244221        usb_hid_report_t *report = NULL;
    245         rc = initialize_report_parser(dev_phone, &report);
     222        rc = initialize_report_parser(dev_sess, &report);
    246223        if (rc != EOK) {
    247224                printf("Failed to initialize report parser: %s\n",
    … …  
    253230       
    254231        size_t size;
    255         rc = usbhid_dev_get_event_length(dev_phone, &size);
     232        rc = usbhid_dev_get_event_length(dev_sess, &size);
    256233        if (rc != EOK) {
    257234                printf("Failed to get event length: %s.\n", str_error(rc));
    … …  
    259236        }
    260237       
    261 //      printf("Event length: %zu\n", size);
    262238        uint8_t *event = (uint8_t *)malloc(size);
    263239        if (event == NULL) {
    264                 // hangup phone?
    265                 return ENOMEM;
    266         }
    267        
    268 //      printf("Event length: %zu\n", size);
     240                // TODO: hangup phone?
     241                return ENOMEM;
     242        }
    269243       
    270244        size_t actual_size;
    271245        int event_nr;
    272246       
    273         while (1) {
    274                 // get event from the driver
    275 //              printf("Getting event from the driver.\n");
    276                
     247        while (true) {
    277248                /** @todo Try blocking call. */
    278                 rc = usbhid_dev_get_event(dev_phone, event, size, &actual_size,
     249                rc = usbhid_dev_get_event(dev_sess, event, size, &actual_size,
    279250                    &event_nr, 0);
    280251                if (rc != EOK) {
    281                         // hangup phone?
     252                        // TODO: hangup phone?
    282253                        printf("Error in getting event from the HID driver:"
    283254                            "%s.\n", str_error(rc));
    … …  
    285256                }
    286257               
    287 //              printf("Got buffer: %p, size: %zu, max size: %zu\n", event,
    288 //                  actual_size, size);
    289                
    290 //              printf("Event number: %d, my actual event: %d\n", event_nr,
    291 //                  act_event);
    292258                if (event_nr > act_event) {
    293259                        print_key(event, size, report);
    … …  
    301267}
    302268
    303 
    304269/** @}
    305270 */

  • uspace/app/mkfat/mkfat.c

    r764d71e r79ae36dd  
    144144        }
    145145
    146         rc = block_init(handle, 2048);
     146        rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
    147147        if (rc != EOK)  {
    148148                printf(NAME ": Error initializing libblock.\n");

  • uspace/app/ping/ping.c

    r764d71e r79ae36dd  
    3636
    3737#include <async.h>
     38#include <async_obsolete.h>
    3839#include <stdio.h>
    3940#include <str.h>
    … …  
    355356                            str_error(ret));
    356357                       
    357                         async_hangup(icmp_phone);
     358                        async_obsolete_hangup(icmp_phone);
    358359                        return ret;
    359360                }
    … …  
    370371                            str_error(ret));
    371372                       
    372                         async_hangup(icmp_phone);
     373                        async_obsolete_hangup(icmp_phone);
    373374                        return ret;
    374375                }
    … …  
    390391        }
    391392       
    392         async_hangup(icmp_phone);
     393        async_obsolete_hangup(icmp_phone);
    393394       
    394395        return 0;

  • uspace/app/taskdump/elf_core.c

    r764d71e r79ae36dd  
    6262#include "include/elf_core.h"
    6363
    64 static off64_t align_foff_up(off64_t foff, uintptr_t vaddr, size_t page_size);
    65 static int write_all(int fd, void *data, size_t len);
    66 static int write_mem_area(int fd, as_area_info_t *area, int phoneid);
     64static off64_t align_foff_up(off64_t, uintptr_t, size_t);
     65static int write_all(int, void *, size_t);
     66static int write_mem_area(int, as_area_info_t *, async_sess_t *);
    6767
    6868#define BUFFER_SIZE 0x1000
    … …  
    7171/** Save ELF core file.
    7272 *
    73  * @param file_name     Name of file to save to.
    74  * @param ainfo         Array of @a n memory area info structures.
    75  * @param n             Number of memory areas.
    76  * @param phoneid       Debugging phone.
    77  *
    78  * @return              EOK on sucess, ENOENT if file cannot be created,
    79  *                      ENOMEM on out of memory, EIO on write error.
    80  */
    81 int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n, int phoneid)
     73 * @param file_name Name of file to save to.
     74 * @param ainfo     Array of @a n memory area info structures.
     75 * @param n         Number of memory areas.
     76 * @param sess      Debugging session.
     77 *
     78 * @return EOK on sucess.
     79 * @return ENOENT if file cannot be created.
     80 * @return ENOMEM on out of memory.
     81 * @return EIO on write error.
     82 *
     83 */
     84int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n,
     85    async_sess_t *sess)
    8286{
    8387        elf_header_t elf_hdr;
    … …  
    189193                        return EIO;
    190194                }
    191                 if (write_mem_area(fd, &ainfo[i], phoneid) != EOK) {
     195                if (write_mem_area(fd, &ainfo[i], sess) != EOK) {
    192196                        printf("Failed writing memory data.\n");
    193197                        free(p_hdr);
    … …  
    215219/** Write memory area from application to core file.
    216220 *
    217  * @param fd            File to write to.
    218  * @param area          Memory area info structure.
    219  * @param phoneid       Debugging phone.
    220  *
    221  * @return              EOK on success, EIO on failure.
    222  */
    223 static int write_mem_area(int fd, as_area_info_t *area, int phoneid)
     221 * @param fd   File to write to.
     222 * @param area Memory area info structure.
     223 * @param sess Debugging session.
     224 *
     225 * @return EOK on success, EIO on failure.
     226 *
     227 */
     228static int write_mem_area(int fd, as_area_info_t *area, async_sess_t *sess)
    224229{
    225230        size_t to_copy;
    … …  
    233238        while (total < area->size) {
    234239                to_copy = min(area->size - total, BUFFER_SIZE);
    235                 rc = udebug_mem_read(phoneid, buffer, addr, to_copy);
     240                rc = udebug_mem_read(sess, buffer, addr, to_copy);
    236241                if (rc < 0) {
    237242                        printf("Failed reading task memory.\n");

  • uspace/app/taskdump/include/elf_core.h

    r764d71e r79ae36dd  
    3636#define ELF_CORE_H_
    3737
    38 int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n, int phoneid);
     38#include <async.h>
     39
     40extern int elf_core_save(const char *, as_area_info_t *, unsigned int,
     41    async_sess_t *);
    3942
    4043#endif

  • uspace/app/taskdump/taskdump.c

    r764d71e r79ae36dd  
    5454#define LINE_BYTES 16
    5555
    56 static int phoneid;
     56static async_sess_t *sess;
    5757static task_id_t task_id;
    5858static bool write_core_file;
    … …  
    104104                printf("Failed dumping address space areas.\n");
    105105
    106         udebug_end(phoneid);
    107         async_hangup(phoneid);
     106        udebug_end(sess);
     107        async_hangup(sess);
    108108
    109109        return 0;
    … …  
    112112static int connect_task(task_id_t task_id)
    113113{
    114         int rc;
    115 
    116         rc = async_connect_kbox(task_id);
    117 
    118         if (rc == ENOTSUP) {
    119                 printf("You do not have userspace debugging support "
    120                     "compiled in the kernel.\n");
    121                 printf("Compile kernel with 'Support for userspace debuggers' "
    122                     "(CONFIG_UDEBUG) enabled.\n");
    123                 return rc;
    124         }
    125 
    126         if (rc < 0) {
     114        async_sess_t *ksess = async_connect_kbox(task_id);
     115       
     116        if (!ksess) {
     117                if (errno == ENOTSUP) {
     118                        printf("You do not have userspace debugging support "
     119                            "compiled in the kernel.\n");
     120                        printf("Compile kernel with 'Support for userspace debuggers' "
     121                            "(CONFIG_UDEBUG) enabled.\n");
     122                        return errno;
     123                }
     124               
    127125                printf("Error connecting\n");
    128                 printf("async_connect_kbox(%" PRIu64 ") -> %d ", task_id, rc);
    129                 return rc;
    130         }
    131 
    132         phoneid = rc;
    133 
    134         rc = udebug_begin(phoneid);
     126                printf("async_connect_kbox(%" PRIu64 ") -> %d ", task_id, errno);
     127                return errno;
     128        }
     129       
     130        int rc = udebug_begin(ksess);
    135131        if (rc < 0) {
    136132                printf("udebug_begin() -> %d\n", rc);
    137133                return rc;
    138134        }
    139 
     135       
     136        sess = ksess;
    140137        return 0;
    141138}
    … …  
    213210
    214211        /* TODO: See why NULL does not work. */
    215         rc = udebug_thread_read(phoneid, &dummy_buf, 0, &copied, &needed);
     212        rc = udebug_thread_read(sess, &dummy_buf, 0, &copied, &needed);
    216213        if (rc < 0) {
    217214                printf("udebug_thread_read() -> %d\n", rc);
    … …  
    227224        thash_buf = malloc(buf_size);
    228225
    229         rc = udebug_thread_read(phoneid, thash_buf, buf_size, &copied, &needed);
     226        rc = udebug_thread_read(sess, thash_buf, buf_size, &copied, &needed);
    230227        if (rc < 0) {
    231228                printf("udebug_thread_read() -> %d\n", rc);
    … …  
    262259        int rc;
    263260
    264         rc = udebug_areas_read(phoneid, &dummy_buf, 0, &copied, &needed);
     261        rc = udebug_areas_read(sess, &dummy_buf, 0, &copied, &needed);
    265262        if (rc < 0) {
    266263                printf("udebug_areas_read() -> %d\n", rc);
    … …  
    271268        ainfo_buf = malloc(buf_size);
    272269
    273         rc = udebug_areas_read(phoneid, ainfo_buf, buf_size, &copied, &needed);
     270        rc = udebug_areas_read(sess, ainfo_buf, buf_size, &copied, &needed);
    274271        if (rc < 0) {
    275272                printf("udebug_areas_read() -> %d\n", rc);
    … …  
    296293        if (write_core_file) {
    297294                printf("Writing core file '%s'\n", core_file_name);
    298                 rc = elf_core_save(core_file_name, ainfo_buf, n_areas, phoneid);
     295                rc = elf_core_save(core_file_name, ainfo_buf, n_areas, sess);
    299296                if (rc != EOK) {
    300297                        printf("Failed writing core file.\n");
    … …  
    316313        int rc;
    317314
    318         rc = udebug_regs_read(phoneid, thash, &istate);
     315        rc = udebug_regs_read(sess, thash, &istate);
    319316        if (rc < 0) {
    320317                printf("Failed reading registers (%d).\n", rc);
    … …  
    359356        (void) arg;
    360357
    361         rc = udebug_mem_read(phoneid, &data, addr, sizeof(data));
     358        rc = udebug_mem_read(sess, &data, addr, sizeof(data));
    362359        if (rc < 0) {
    363360                printf("Warning: udebug_mem_read() failed.\n");
    … …  
    430427        int rc;
    431428
    432         rc = udebug_name_read(phoneid, &dummy_buf, 0, &copied, &needed);
     429        rc = udebug_name_read(sess, &dummy_buf, 0, &copied, &needed);
    433430        if (rc < 0)
    434431                return NULL;
    … …  
    436433        name_size = needed;
    437434        name = malloc(name_size + 1);
    438         rc = udebug_name_read(phoneid, name, name_size, &copied, &needed);
     435        rc = udebug_name_read(sess, name, name_size, &copied, &needed);
    439436        if (rc < 0) {
    440437                free(name);

  • uspace/app/tester/console/console1.c

    r764d71e r79ae36dd  
    5050{
    5151        if (!test_quiet) {
     52                console_ctrl_t *console = console_init(stdin, stdout);
     53               
    5254                printf("Style test: ");
    53                 fflush(stdout);
    54                 console_set_style(fphone(stdout), STYLE_NORMAL);
     55                console_flush(console);
     56                console_set_style(console, STYLE_NORMAL);
    5557                printf(" normal ");
    56                 fflush(stdout);
    57                 console_set_style(fphone(stdout), STYLE_EMPHASIS);
     58                console_flush(console);
     59                console_set_style(console, STYLE_EMPHASIS);
    5860                printf(" emphasized ");
    59                 fflush(stdout);
    60                 console_set_style(fphone(stdout), STYLE_INVERTED);
     61                console_flush(console);
     62                console_set_style(console, STYLE_INVERTED);
    6163                printf(" inverted ");
    62                 fflush(stdout);
    63                 console_set_style(fphone(stdout), STYLE_SELECTED);
     64                console_flush(console);
     65                console_set_style(console, STYLE_SELECTED);
    6466                printf(" selected ");
    65                 fflush(stdout);
    66                 console_set_style(fphone(stdout), STYLE_NORMAL);
     67                console_flush(console);
     68                console_set_style(console, STYLE_NORMAL);
    6769                printf("\n");
    6870               
    … …  
    7375                for (j = 0; j < 2; j++) {
    7476                        for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) {
    75                                 fflush(stdout);
    76                                 console_set_color(fphone(stdout), i, COLOR_WHITE,
     77                                console_flush(console);
     78                                console_set_color(console, i, COLOR_WHITE,
    7779                                    j ? CATTR_BRIGHT : 0);
    7880                                printf(" %s ", color_name[i]);
    7981                        }
    80                         fflush(stdout);
    81                         console_set_style(fphone(stdout), STYLE_NORMAL);
     82                        console_flush(console);
     83                        console_set_style(console, STYLE_NORMAL);
    8284                        putchar('\n');
    8385                }
    … …  
    8688                for (j = 0; j < 2; j++) {
    8789                        for (i = COLOR_BLACK; i <= COLOR_WHITE; i++) {
    88                                 fflush(stdout);
    89                                 console_set_color(fphone(stdout), COLOR_WHITE, i,
     90                                console_flush(console);
     91                                console_set_color(console, COLOR_WHITE, i,
    9092                                    j ? CATTR_BRIGHT : 0);
    9193                                printf(" %s ", color_name[i]);
    9294                        }
    93                         fflush(stdout);
    94                         console_set_style(fphone(stdout), STYLE_NORMAL);
     95                        console_flush(console);
     96                        console_set_style(console, STYLE_NORMAL);
    9597                        putchar('\n');
    9698                }
    … …  
    99101               
    100102                for (i = 0; i < 255; i += 16) {
    101                         fflush(stdout);
    102                         console_set_rgb_color(fphone(stdout), (255 - i) << 16, i << 16);
     103                        console_flush(console);
     104                        console_set_rgb_color(console, (255 - i) << 16, i << 16);
    103105                        putchar('X');
    104106                }
    105                 fflush(stdout);
    106                 console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     107                console_flush(console);
     108                console_set_color(console, COLOR_BLACK, COLOR_WHITE, 0);
    107109                putchar('\n');
    108110               
    109111                for (i = 0; i < 255; i += 16) {
    110                         fflush(stdout);
    111                         console_set_rgb_color(fphone(stdout), (255 - i) << 8, i << 8);
     112                        console_flush(console);
     113                        console_set_rgb_color(console, (255 - i) << 8, i << 8);
    112114                        putchar('X');
    113115                }
    114                 fflush(stdout);
    115                 console_set_color(fphone(stdout), COLOR_BLACK, COLOR_WHITE, 0);
     116                console_flush(console);
     117                console_set_color(console, COLOR_BLACK, COLOR_WHITE, 0);
    116118                putchar('\n');
    117119               
    118120                for (i = 0; i < 255; i += 16) {
    119                         fflush(stdout);
    120                         console_set_rgb_color(fphone(stdout), 255 - i, i);
     121                        console_flush(console);
     122                        console_set_rgb_color(console, 255 - i, i);
    121123                        putchar('X');
    122124                }
    123                 fflush(stdout);
    124                 console_set_style(fphone(stdout), STYLE_NORMAL);
     125                console_flush(console);
     126                console_set_style(console, STYLE_NORMAL);
    125127                putchar('\n');
    126128        }

  • uspace/app/tester/devs/devman2.c

    r764d71e r79ae36dd  
    4242#include <devman.h>
    4343#include <str.h>
     44#include <async.h>
    4445#include <vfs/vfs.h>
     46#include <vfs/vfs_sess.h>
    4547#include <sys/stat.h>
    4648#include <fcntl.h>
    … …  
    6870                        continue;
    6971                }
    70                 int phone = fd_phone(fd);
     72                async_sess_t *sess = fd_session(EXCHANGE_SERIALIZE, fd);
    7173                close(fd);
    72                 if (phone < 0) {
    73                         TPRINTF("Failed opening phone: %s.\n", str_error(phone));
    74                         rc = phone;
     74                if (sess == NULL) {
     75                        TPRINTF("Failed opening phone: %s.\n", str_error(errno));
     76                        rc = errno;
    7577                        err_msg = "Failed opening file descriptor phone";
    7678                        continue;
    7779                }
    78                 async_hangup(phone);
     80                async_hangup(sess);
    7981                TPRINTF("Path `%s' okay.\n", path);
    8082                free(path);
    … …  
    8385        }
    8486       
    85         if (path != NULL) {
     87        if (path != NULL)
    8688                free(path);
    87         }
    88 
     89       
    8990        return err_msg;
    9091}

  • uspace/app/tester/hw/misc/virtchar1.c

    r764d71e r79ae36dd  
    4343#include <str.h>
    4444#include <vfs/vfs.h>
     45#include <vfs/vfs_sess.h>
    4546#include <sys/stat.h>
    4647#include <fcntl.h>
    … …  
    6667        TPRINTF("   ...file handle %d\n", fd);
    6768
    68         TPRINTF(" Asking for phone...\n");
    69         int phone = fd_phone(fd);
    70         if (phone < 0) {
     69        TPRINTF(" Asking for session...\n");
     70        async_sess_t *sess = fd_session(EXCHANGE_SERIALIZE, fd);
     71        if (!sess) {
    7172                close(fd);
    72                 TPRINTF("   ...error: %s\n", str_error(phone));
    73                 return "Failed to get phone to device";
     73                TPRINTF("   ...error: %s\n", str_error(errno));
     74                return "Failed to get session to device";
    7475        }
    75         TPRINTF("   ...phone is %d\n", phone);
     76        TPRINTF("   ...session is %p\n", sess);
    7677       
    7778        TPRINTF(" Will try to read...\n");
    7879        size_t i;
    7980        char buffer[BUFFER_SIZE];
    80         char_dev_read(phone, buffer, BUFFER_SIZE);
     81        char_dev_read(sess, buffer, BUFFER_SIZE);
    8182        TPRINTF(" ...verifying that we read zeroes only...\n");
    8283        for (i = 0; i < BUFFER_SIZE; i++) {
    … …  
    8889       
    8990        /* Clean-up. */
    90         TPRINTF(" Closing phones and file descriptors\n");
    91         async_hangup(phone);
     91        TPRINTF(" Closing session and file descriptor\n");
     92        async_hangup(sess);
    9293        close(fd);
    9394       

  • uspace/app/tester/hw/serial/serial1.c

    r764d71e r79ae36dd  
    7171                }
    7272       
    73         int res = devman_get_phone(DEVMAN_CLIENT, IPC_FLAG_BLOCKING);
    74        
    7573        devman_handle_t handle;
    76         res = devman_device_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
     74        int res = devman_device_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
    7775            IPC_FLAG_BLOCKING);
    7876        if (res != EOK)
    7977                return "Could not get serial device handle";
    8078       
    81         int phone = devman_device_connect(handle, IPC_FLAG_BLOCKING);
    82         if (phone < 0) {
    83                 devman_hangup_phone(DEVMAN_CLIENT);
     79        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
     80            IPC_FLAG_BLOCKING);
     81        if (!sess)
    8482                return "Unable to connect to serial device";
    85         }
    8683       
    8784        char *buf = (char *) malloc(cnt + 1);
    8885        if (buf == NULL) {
    89                 async_hangup(phone);
    90                 devman_hangup_phone(DEVMAN_CLIENT);
     86                async_hangup(sess);
    9187                return "Failed to allocate input buffer";
    9288        }
    … …  
    9793        sysarg_t old_word_size;
    9894       
    99         res = async_req_0_4(phone, SERIAL_GET_COM_PROPS, &old_baud,
     95        async_exch_t *exch = async_exchange_begin(sess);
     96        res = async_req_0_4(exch, SERIAL_GET_COM_PROPS, &old_baud,
    10097            &old_par, &old_word_size, &old_stop);
     98        async_exchange_end(exch);
     99       
    101100        if (res != EOK) {
    102101                free(buf);
    103                 async_hangup(phone);
    104                 devman_hangup_phone(DEVMAN_CLIENT);
     102                async_hangup(sess);
    105103                return "Failed to get old serial communication parameters";
    106104        }
    107105       
    108         res = async_req_4_0(phone, SERIAL_SET_COM_PROPS, 1200,
     106        exch = async_exchange_begin(sess);
     107        res = async_req_4_0(exch, SERIAL_SET_COM_PROPS, 1200,
    109108            SERIAL_NO_PARITY, 8, 1);
     109        async_exchange_end(exch);
     110       
    110111        if (EOK != res) {
    111112                free(buf);
    112                 async_hangup(phone);
    113                 devman_hangup_phone(DEVMAN_CLIENT);
     113                async_hangup(sess);
    114114                return "Failed to set serial communication parameters";
    115115        }
    … …  
    120120        size_t total = 0;
    121121        while (total < cnt) {
    122                 ssize_t read = char_dev_read(phone, buf, cnt - total);
     122                ssize_t read = char_dev_read(sess, buf, cnt - total);
    123123               
    124124                if (read < 0) {
    125                         async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     125                        exch = async_exchange_begin(sess);
     126                        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
    126127                            old_par, old_word_size, old_stop);
     128                        async_exchange_end(exch);
     129                       
    127130                        free(buf);
    128                         async_hangup(phone);
    129                         devman_hangup_phone(DEVMAN_CLIENT);
     131                        async_hangup(sess);
    130132                        return "Failed read from serial device";
    131133                }
    132134               
    133135                if ((size_t) read > cnt - total) {
    134                         async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     136                        exch = async_exchange_begin(sess);
     137                        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
    135138                            old_par, old_word_size, old_stop);
     139                        async_exchange_end(exch);
     140                       
    136141                        free(buf);
    137                         async_hangup(phone);
    138                         devman_hangup_phone(DEVMAN_CLIENT);
     142                        async_hangup(sess);
    139143                        return "Read more data than expected";
    140144                }
    … …  
    151155                         * direction of data transfer.
    152156                         */
    153                         ssize_t written = char_dev_write(phone, buf, read);
     157                        ssize_t written = char_dev_write(sess, buf, read);
    154158                       
    155159                        if (written < 0) {
    156                                 async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     160                                exch = async_exchange_begin(sess);
     161                                async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
    157162                                    old_par, old_word_size, old_stop);
     163                                async_exchange_end(exch);
     164                               
    158165                                free(buf);
    159                                 async_hangup(phone);
    160                                 devman_hangup_phone(DEVMAN_CLIENT);
     166                                async_hangup(sess);
    161167                                return "Failed write to serial device";
    162168                        }
    163169                       
    164170                        if (written != read) {
    165                                 async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     171                                exch = async_exchange_begin(sess);
     172                                async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
    166173                                    old_par, old_word_size, old_stop);
     174                                async_exchange_end(exch);
     175                               
    167176                                free(buf);
    168                                 async_hangup(phone);
    169                                 devman_hangup_phone(DEVMAN_CLIENT);
     177                                async_hangup(sess);
    170178                                return "Written less data than read from serial device";
    171179                        }
    … …  
    180188       
    181189        size_t eot_size = str_size(EOT);
    182         ssize_t written = char_dev_write(phone, (void *) EOT, eot_size);
    183        
    184         async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     190        ssize_t written = char_dev_write(sess, (void *) EOT, eot_size);
     191       
     192        exch = async_exchange_begin(sess);
     193        async_req_4_0(exch, SERIAL_SET_COM_PROPS, old_baud,
    185194            old_par, old_word_size, old_stop);
     195        async_exchange_end(exch);
     196       
    186197        free(buf);
    187         async_hangup(phone);
    188         devman_hangup_phone(DEVMAN_CLIENT);
     198        async_hangup(sess);
    189199       
    190200        if (written < 0)

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

    r764d71e r79ae36dd  
    3030#include <stdlib.h>
    3131#include <sys/time.h>
    32 #include <ipc/ns.h>
     32#include <ns.h>
    3333#include <async.h>
    3434#include <errno.h>
    … …  
    6161                size_t i;
    6262                for (i = 0; i < COUNT_GRANULARITY; i++) {
    63                         int retval = async_req_0_0(PHONE_NS, NS_PING);
     63                        int retval = ns_ping();
    6464                       
    6565                        if (retval != EOK) {

  • uspace/app/tetris/Makefile

    r764d71e r79ae36dd  
    3434        shapes.c \
    3535        scores.c \
    36         input.c \
    3736        tetris.c \
    3837        screen.c

  • uspace/app/tetris/scores.c

    r764d71e r79ae36dd  
    1 /*      $OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray Exp $ */
    2 /*      $NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd Exp $   */
    3 
    4 /*-
    5  * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * This code is derived from software contributed to Berkeley by
    9  * Chris Torek and Darren F. Provine.
     1/*
     2 * Copyright (c) 2011 Martin Decky
     3 * All rights reserved.
    104 *
    115 * Redistribution and use in source and binary forms, with or without
    126 * modification, are permitted provided that the following conditions
    137 * are met:
    14  * 1. Redistributions of source code must retain the above copyright
    15  *    notice, this list of conditions and the following disclaimer.
    16  * 2. Redistributions in binary form must reproduce the above copyright
    17  *    notice, this list of conditions and the following disclaimer in the
    18  *    documentation and/or other materials provided with the distribution.
    19  * 3. Neither the name of the University nor the names of its contributors
    20  *    may be used to endorse or promote products derived from this software
    21  *    without specific prior written permission.
    22  *
    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33  * SUCH DAMAGE.
    34  *
    35  *      @(#)scores.c    8.1 (Berkeley) 5/31/93
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
     28
     29/** Attributations
     30 *
     31 * scores.c 8.1 (Berkeley) 5/31/93
     32 * NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd
     33 * OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray
     34 *
     35 * Based upon BSD Tetris
     36 *
     37 * Copyright (c) 1992, 1993
     38 *      The Regents of the University of California.
     39 *      Distributed under BSD license.
     40 *
     41 * This code is derived from software contributed to Berkeley by
     42 * Chris Torek and Darren F. Provine.
     43 *
    3644 */
    3745
    … …  
    6068#include <err.h>
    6169#include <time.h>
    62 
    6370#include "screen.h"
    6471#include "tetris.h"
    … …  
    118125        int j;
    119126        size_t off;
    120         console_event_t ev;
     127        kbd_event_t ev;
    121128       
    122129        clear_screen();
    … …  
    133140       
    134141        while (1) {
    135                 fflush(stdout);
    136                 if (!console_get_event(fphone(stdin), &ev))
     142                console_flush(console);
     143                if (!console_get_kbd_event(console, &ev))
    137144                        exit(1);
    138145               

  • uspace/app/tetris/scores.h

    r764d71e r79ae36dd  
    1 /*      $OpenBSD: scores.h,v 1.5 2003/06/03 03:01:41 millert Exp $      */
    2 /*      $NetBSD: scores.h,v 1.2 1995/04/22 07:42:40 cgd Exp $   */
     1/*
     2 * Copyright (c) 2011 Martin Decky
     3 * All rights reserved.
     4 *
     5 * Redistribution and use in source and binary forms, with or without
     6 * modification, are permitted provided that the following conditions
     7 * are met:
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
    328
    4 /*-
     29/** Attributations
     30 *
     31 * scores.h 8.1 (Berkeley) 5/31/93
     32 * NetBSD: scores.h,v 1.2 1995/04/22 07:42:40 cgd
     33 * OpenBSD: scores.h,v 1.5 2003/06/03 03:01:41 millert
     34 *
     35 * Based upon BSD Tetris
     36 *
    537 * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
     38 *      The Regents of the University of California.
     39 *      Distributed under BSD license.
    740 *
    841 * This code is derived from software contributed to Berkeley by
    942 * Chris Torek and Darren F. Provine.
    1043 *
    11  * Redistribution and use in source and binary forms, with or without
    12  * modification, are permitted provided that the following conditions
    13  * are met:
    14  * 1. Redistributions of source code must retain the above copyright
    15  *    notice, this list of conditions and the following disclaimer.
    16  * 2. Redistributions in binary form must reproduce the above copyright
    17  *    notice, this list of conditions and the following disclaimer in the
    18  *    documentation and/or other materials provided with the distribution.
    19  * 3. Neither the name of the University nor the names of its contributors
    20  *    may be used to endorse or promote products derived from this software
    21  *    without specific prior written permission.
    22  *
    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33  * SUCH DAMAGE.
    34  *
    35  *      @(#)scores.h    8.1 (Berkeley) 5/31/93
    3644 */
    3745
    … …  
    4149/** @file
    4250 */
    43 
    4451
    4552/*

  • uspace/app/tetris/screen.c

    r764d71e r79ae36dd  
    1 /*      $OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray Exp $ */
    2 /*      $NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft Exp $       */
    3 
    4 /*-
    5  * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * This code is derived from software contributed to Berkeley by
    9  * Chris Torek and Darren F. Provine.
     1/*
     2 * Copyright (c) 2011 Martin Decky
     3 * All rights reserved.
    104 *
    115 * Redistribution and use in source and binary forms, with or without
    126 * modification, are permitted provided that the following conditions
    137 * are met:
    14  * 1. Redistributions of source code must retain the above copyright
    15  *    notice, this list of conditions and the following disclaimer.
    16  * 2. Redistributions in binary form must reproduce the above copyright
    17  *    notice, this list of conditions and the following disclaimer in the
    18  *    documentation and/or other materials provided with the distribution.
    19  * 3. Neither the name of the University nor the names of its contributors
    20  *    may be used to endorse or promote products derived from this software
    21  *    without specific prior written permission.
    22  *
    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33  * SUCH DAMAGE.
    34  *
    35  *      @(#)screen.c    8.1 (Berkeley) 5/31/93
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
     28
     29/** Attributations
     30 *
     31 * screen.c 8.1 (Berkeley) 5/31/93
     32 * NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft
     33 * OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray
     34 *
     35 * Based upon BSD Tetris
     36 *
     37 * Copyright (c) 1992, 1993
     38 *      The Regents of the University of California.
     39 *      Distributed under BSD license.
     40 *
     41 * This code is derived from software contributed to Berkeley by
     42 * Chris Torek and Darren F. Provine.
     43 *
    3644 */
    3745
    … …  
    6977static const struct shape *lastshape;
    7078
     79static suseconds_t timeleft = 0;
     80
     81console_ctrl_t *console;
     82
    7183
    7284/*
    … …  
    8294static void start_standout(uint32_t color)
    8395{
    84         fflush(stdout);
    85         console_set_rgb_color(fphone(stdout), 0xffffff,
     96        console_flush(console);
     97        console_set_rgb_color(console, 0xffffff,
    8698            use_color ? color : 0x000000);
    8799}
    … …  
    89101static void resume_normal(void)
    90102{
    91         fflush(stdout);
    92         console_set_style(fphone(stdout), STYLE_NORMAL);
     103        console_flush(console);
     104        console_set_style(console, STYLE_NORMAL);
    93105}
    94106
    95107void clear_screen(void)
    96108{
    97         console_clear(fphone(stdout));
     109        console_clear(console);
    98110        moveto(0, 0);
    99111}
    … …  
    105117{
    106118        resume_normal();
    107         console_clear(fphone(stdout));
     119        console_clear(console);
    108120        curscore = -1;
    109121        memset(curscreen, 0, sizeof(curscreen));
    … …  
    115127void scr_init(void)
    116128{
    117         console_cursor_visibility(fphone(stdout), 0);
     129        console_cursor_visibility(console, 0);
    118130        resume_normal();
    119131        scr_clear();
    … …  
    122134void moveto(sysarg_t r, sysarg_t c)
    123135{
    124         fflush(stdout);
    125         console_set_pos(fphone(stdout), c, r);
     136        console_flush(console);
     137        console_set_pos(console, c, r);
    126138}
    127139
    … …  
    130142static int get_display_size(winsize_t *ws)
    131143{
    132         return console_get_size(fphone(stdout), &ws->ws_col, &ws->ws_row);
     144        return console_get_size(console, &ws->ws_col, &ws->ws_row);
    133145}
    134146
    … …  
    136148{
    137149        sysarg_t ccap;
    138         int rc = console_get_color_cap(fphone(stdout), &ccap);
     150        int rc = console_get_color_cap(console, &ccap);
    139151       
    140152        if (rc != 0)
    … …  
    179191void scr_end(void)
    180192{
    181         console_cursor_visibility(fphone(stdout), 1);
     193        console_cursor_visibility(console, 1);
    182194}
    183195
    … …  
    302314                resume_normal();
    303315       
    304         fflush(stdout);
     316        console_flush(console);
    305317}
    306318
    … …  
    322334}
    323335
     336/** Sleep for the current turn time
     337 *
     338 * Eat any input that might be available.
     339 *
     340 */
     341void tsleep(void)
     342{
     343        suseconds_t timeout = fallrate;
     344       
     345        while (timeout > 0) {
     346                kbd_event_t event;
     347               
     348                if (!console_get_kbd_event_timeout(console, &event, &timeout))
     349                        break;
     350        }
     351}
     352
     353/** Get char with timeout
     354 *
     355 */
     356int tgetchar(void)
     357{
     358        /*
     359         * Reset timeleft to fallrate whenever it is not positive
     360         * and increase speed.
     361         */
     362       
     363        if (timeleft <= 0) {
     364                faster();
     365                timeleft = fallrate;
     366        }
     367       
     368        /*
     369         * Wait to see if there is any input. If so, take it and
     370         * update timeleft so that the next call to tgetchar()
     371         * will not wait as long. If there is no input,
     372         * make timeleft zero and return -1.
     373         */
     374       
     375        wchar_t c = 0;
     376       
     377        while (c == 0) {
     378                kbd_event_t event;
     379               
     380                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
     381                        timeleft = 0;
     382                        return -1;
     383                }
     384               
     385                if (event.type == KEY_PRESS)
     386                        c = event.c;
     387        }
     388       
     389        return (int) c;
     390}
     391
     392/** Get char without timeout
     393 *
     394 */
     395int twait(void)
     396{
     397        wchar_t c = 0;
     398       
     399        while (c == 0) {
     400                kbd_event_t event;
     401               
     402                if (!console_get_kbd_event(console, &event))
     403                        return -1;
     404               
     405                if (event.type == KEY_PRESS)
     406                        c = event.c;
     407        }
     408       
     409        return (int) c;
     410}
     411
    324412/** @}
    325413 */

  • uspace/app/tetris/screen.h

    r764d71e r79ae36dd  
    1 /*      $OpenBSD: screen.h,v 1.5 2003/06/03 03:01:41 millert Exp $      */
    2 /*      $NetBSD: screen.h,v 1.2 1995/04/22 07:42:42 cgd Exp $   */
     1/*
     2 * Copyright (c) 2011 Martin Decky
     3 * All rights reserved.
     4 *
     5 * Redistribution and use in source and binary forms, with or without
     6 * modification, are permitted provided that the following conditions
     7 * are met:
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
    328
    4 /*-
     29/** Attributations
     30 *
     31 * screen.h 8.1 (Berkeley) 5/31/93
     32 * NetBSD: screen.h,v 1.2 1995/04/22 07:42:42 cgd
     33 * OpenBSD: screen.h,v 1.5 2003/06/03 03:01:41 millert
     34 *
     35 * Based upon BSD Tetris
     36 *
    537 * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
     38 *      The Regents of the University of California.
     39 *      Distributed under BSD license.
    740 *
    841 * This code is derived from software contributed to Berkeley by
    942 * Chris Torek and Darren F. Provine.
    1043 *
    11  * Redistribution and use in source and binary forms, with or without
    12  * modification, are permitted provided that the following conditions
    13  * are met:
    14  * 1. Redistributions of source code must retain the above copyright
    15  *    notice, this list of conditions and the following disclaimer.
    16  * 2. Redistributions in binary form must reproduce the above copyright
    17  *    notice, this list of conditions and the following disclaimer in the
    18  *    documentation and/or other materials provided with the distribution.
    19  * 3. Neither the name of the University nor the names of its contributors
    20  *    may be used to endorse or promote products derived from this software
    21  *    without specific prior written permission.
    22  *
    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33  * SUCH DAMAGE.
    34  *
    35  *      @(#)screen.h    8.1 (Berkeley) 5/31/93
    3644 */
    3745
    … …  
    4856
    4957#include <sys/types.h>
     58#include <io/console.h>
    5059#include <async.h>
    5160#include <bool.h>
    … …  
    5665} winsize_t;
    5766
     67extern console_ctrl_t *console;
    5868extern winsize_t winsize;
    5969
    … …  
    6171extern void clear_screen(void);
    6272
    63 /* just calls putchar; for tputs */
    6473extern int put(int);
    6574extern void scr_clear(void);
    … …  
    7079extern void scr_update(void);
    7180
     81extern void tsleep(void);
     82extern int tgetchar(void);
     83extern int twait(void);
     84
    7285/** @}
    7386 */

  • uspace/app/tetris/shapes.c

    r764d71e r79ae36dd  
    1 /*      $OpenBSD: shapes.c,v 1.8 2004/07/10 07:26:24 deraadt Exp $      */
    2 /*      $NetBSD: shapes.c,v 1.2 1995/04/22 07:42:44 cgd Exp $   */
     1/*
     2 * Copyright (c) 2011 Martin Decky
     3 * All rights reserved.
     4 *
     5 * Redistribution and use in source and binary forms, with or without
     6 * modification, are permitted provided that the following conditions
     7 * are met:
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
    328
    4 /*-
     29/** Attributations
     30 *
     31 * shapes.c 8.1 (Berkeley) 5/31/93
     32 * NetBSD: shapes.c,v 1.2 1995/04/22 07:42:44 cgd
     33 * OpenBSD: shapes.c,v 1.8 2004/07/10 07:26:24 deraadt
     34 *
     35 * Based upon BSD Tetris
     36 *
    537 * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
     38 *      The Regents of the University of California.
     39 *      Distributed under BSD license.
    740 *
    841 * This code is derived from software contributed to Berkeley by
    942 * Chris Torek and Darren F. Provine.
    1043 *
    11  * Redistribution and use in source and binary forms, with or without
    12  * modification, are permitted provided that the following conditions
    13  * are met:
    14  * 1. Redistributions of source code must retain the above copyright
    15  *    notice, this list of conditions and the following disclaimer.
    16  * 2. Redistributions in binary form must reproduce the above copyright
    17  *    notice, this list of conditions and the following disclaimer in the
    18  *    documentation and/or other materials provided with the distribution.
    19  * 3. Neither the name of the University nor the names of its contributors
    20  *    may be used to endorse or promote products derived from this software
    21  *    without specific prior written permission.
    22  *
    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33  * SUCH DAMAGE.
    34  *
    35  *      @(#)shapes.c    8.1 (Berkeley) 5/31/93
    3644 */
    3745

  • uspace/app/tetris/tetris.c

    r764d71e r79ae36dd  
    1 /*      $OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray Exp $ */
    2 /*      $NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd Exp $   */
    3 
    4 /*-
    5  * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * This code is derived from software contributed to Berkeley by
    9  * Chris Torek and Darren F. Provine.
     1/*
     2 * Copyright (c) 2011 Martin Decky
     3 * All rights reserved.
    104 *
    115 * Redistribution and use in source and binary forms, with or without
    126 * modification, are permitted provided that the following conditions
    137 * are met:
    14  * 1. Redistributions of source code must retain the above copyright
    15  *    notice, this list of conditions and the following disclaimer.
    16  * 2. Redistributions in binary form must reproduce the above copyright
    17  *    notice, this list of conditions and the following disclaimer in the
    18  *    documentation and/or other materials provided with the distribution.
    19  * 3. Neither the name of the University nor the names of its contributors
    20  *    may be used to endorse or promote products derived from this software
    21  *    without specific prior written permission.
    22  *
    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33  * SUCH DAMAGE.
    34  *
    35  *      @(#)tetris.c    8.1 (Berkeley) 5/31/93
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
     28
     29/** Attributations
     30 *
     31 * tetris.c 8.1 (Berkeley) 5/31/93
     32 * NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd
     33 * OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray
     34 *
     35 * Based upon BSD Tetris
     36 *
     37 * Copyright (c) 1992, 1993
     38 *      The Regents of the University of California.
     39 *      Distributed under BSD license.
     40 *
     41 * This code is derived from software contributed to Berkeley by
     42 * Chris Torek and Darren F. Provine.
     43 *
    3644 */
    3745
    … …  
    5664#include <unistd.h>
    5765#include <getopt.h>
    58 
    59 #include "input.h"
    6066#include "scores.h"
    6167#include "screen.h"
    … …  
    245251        int ch;
    246252       
     253        console = console_init(stdin, stdout);
     254       
    247255        keys = "jkl pq";
    248256       
    249257        classic = 0;
    250         showpreview = 1; 
     258        showpreview = 1;
    251259       
    252260        while ((ch = getopt(argc, argv, "ck:ps")) != -1)
    … …  
    371379                                        scr_msg(key_msg, 0);
    372380                                        scr_msg(msg, 1);
    373                                         (void) fflush(stdout);
    374                                 } while (rwait((struct timeval *) NULL) == -1);
     381                                        console_flush(console);
     382                                } while (!twait());
    375383                               
    376384                                scr_msg(msg, 0);

  • uspace/app/tetris/tetris.h

    r764d71e r79ae36dd  
    1 /*      $OpenBSD: tetris.h,v 1.9 2003/06/03 03:01:41 millert Exp $      */
    2 /*      $NetBSD: tetris.h,v 1.2 1995/04/22 07:42:48 cgd Exp $   */
     1/*
     2 * Copyright (c) 2011 Martin Decky
     3 * All rights reserved.
     4 *
     5 * Redistribution and use in source and binary forms, with or without
     6 * modification, are permitted provided that the following conditions
     7 * are met:
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
    328
    4 /*-
     29/** Attributations
     30 *
     31 * tetris.h 8.1 (Berkeley) 5/31/93
     32 * NetBSD: tetris.h,v 1.2 1995/04/22 07:42:48 cgd
     33 * OpenBSD: tetris.h,v 1.9 2003/06/03 03:01:41 millert
     34 *
     35 * Based upon BSD Tetris
     36 *
    537 * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
     38 *      The Regents of the University of California.
     39 *      Distributed under BSD license.
    740 *
    841 * This code is derived from software contributed to Berkeley by
    942 * Chris Torek and Darren F. Provine.
    1043 *
    11  * Redistribution and use in source and binary forms, with or without
    12  * modification, are permitted provided that the following conditions
    13  * are met:
    14  * 1. Redistributions of source code must retain the above copyright
    15  *    notice, this list of conditions and the following disclaimer.
    16  * 2. Redistributions in binary form must reproduce the above copyright
    17  *    notice, this list of conditions and the following disclaimer in the
    18  *    documentation and/or other materials provided with the distribution.
    19  * 3. Neither the name of the University nor the names of its contributors
    20  *    may be used to endorse or promote products derived from this software
    21  *    without specific prior written permission.
    22  *
    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    33  * SUCH DAMAGE.
    34  *
    35  *      @(#)tetris.h    8.1 (Berkeley) 5/31/93
    3644 */
    3745

  • uspace/app/top/Makefile

    r764d71e r79ae36dd  
    3333SOURCES = \
    3434        top.c \
    35         screen.c \
    36         input.c
     35        screen.c
    3736
    3837include $(USPACE_PREFIX)/Makefile.common

  • uspace/app/top/screen.c

    r764d71e r79ae36dd  
    4646#include "top.h"
    4747
     48#define USEC_COUNT  1000000
     49
    4850static sysarg_t warn_col = 0;
    4951static sysarg_t warn_row = 0;
     52static suseconds_t timeleft = 0;
     53
     54console_ctrl_t *console;
    5055
    5156static void screen_style_normal(void)
    5257{
    53         fflush(stdout);
    54         console_set_style(fphone(stdout), STYLE_NORMAL);
     58        console_flush(console);
     59        console_set_style(console, STYLE_NORMAL);
    5560}
    5661
    5762static void screen_style_inverted(void)
    5863{
    59         fflush(stdout);
    60         console_set_style(fphone(stdout), STYLE_INVERTED);
     64        console_flush(console);
     65        console_set_style(console, STYLE_INVERTED);
    6166}
    6267
    6368static void screen_moveto(sysarg_t col, sysarg_t row)
    6469{
    65         fflush(stdout);
    66         console_set_pos(fphone(stdout), col, row);
     70        console_flush(console);
     71        console_set_pos(console, col, row);
    6772}
    6873
    6974static void screen_get_pos(sysarg_t *col, sysarg_t *row)
    7075{
    71         fflush(stdout);
    72         console_get_pos(fphone(stdout), col, row);
     76        console_flush(console);
     77        console_get_pos(console, col, row);
    7378}
    7479
    7580static void screen_get_size(sysarg_t *col, sysarg_t *row)
    7681{
    77         fflush(stdout);
    78         console_get_size(fphone(stdout), col, row);
     82        console_flush(console);
     83        console_get_size(console, col, row);
    7984}
    8085
    … …  
    8489       
    8590        if (clear) {
    86                 fflush(stdout);
    87                 console_clear(fphone(stdout));
     91                console_flush(console);
     92                console_clear(console);
    8893        }
    8994       
    … …  
    111116void screen_init(void)
    112117{
    113         fflush(stdout);
    114         console_cursor_visibility(fphone(stdout), false);
     118        console = console_init(stdin, stdout);
     119       
     120        console_flush(console);
     121        console_cursor_visibility(console, false);
    115122       
    116123        screen_restart(true);
    … …  
    121128        screen_restart(true);
    122129       
    123         fflush(stdout);
    124         console_cursor_visibility(fphone(stdout), true);
     130        console_flush(console);
     131        console_cursor_visibility(console, true);
    125132}
    126133
    … …  
    508515        }
    509516       
    510         fflush(stdout);
     517        console_flush(console);
    511518}
    512519
    … …  
    521528       
    522529        screen_newline();
    523         fflush(stdout);
     530        console_flush(console);
     531}
     532
     533/** Get char with timeout
     534 *
     535 */
     536int tgetchar(unsigned int sec)
     537{
     538        /*
     539         * Reset timeleft whenever it is not positive.
     540         */
     541       
     542        if (timeleft <= 0)
     543                timeleft = sec * USEC_COUNT;
     544       
     545        /*
     546         * Wait to see if there is any input. If so, take it and
     547         * update timeleft so that the next call to tgetchar()
     548         * will not wait as long. If there is no input,
     549         * make timeleft zero and return -1.
     550         */
     551       
     552        wchar_t c = 0;
     553       
     554        while (c == 0) {
     555                kbd_event_t event;
     556               
     557                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
     558                        timeleft = 0;
     559                        return -1;
     560                }
     561               
     562                if (event.type == KEY_PRESS)
     563                        c = event.c;
     564        }
     565       
     566        return (int) c;
    524567}
    525568

  • uspace/app/top/screen.h

    r764d71e r79ae36dd  
    3535#define TOP_SCREEN_H_
    3636
     37#include <io/console.h>
    3738#include "top.h"
     39
     40extern console_ctrl_t *console;
    3841
    3942extern void screen_init(void);
    … …  
    4245extern void print_warning(const char *, ...);
    4346
     47extern int tgetchar(unsigned int);
     48
    4449#endif
    4550

  • uspace/app/top/top.c

    r764d71e r79ae36dd  
    4646#include <sort.h>
    4747#include "screen.h"
    48 #include "input.h"
    4948#include "top.h"
    5049

  • uspace/app/trace/ipc_desc.c

    r764d71e r79ae36dd  
    3333 */
    3434
    35 #include <ipc/common.h>
     35#include <kernel/ipc/ipc.h>
     36#include <kernel/ipc/ipc_methods.h>
    3637#include <stdlib.h>
    3738#include "ipc_desc.h"
    … …  
    3940ipc_m_desc_t ipc_methods[] = {
    4041        /* System methods */
    41         { IPC_M_CONNECT_TO_ME,  "CONNECT_TO_ME" },
    42         { IPC_M_CONNECT_ME_TO,  "CONNECT_ME_TO" },
    43         { IPC_M_PHONE_HUNGUP,   "PHONE_HUNGUP" },
    44         { IPC_M_SHARE_OUT,      "SHARE_OUT" },
    45         { IPC_M_SHARE_IN,       "SHARE_IN" },
    46         { IPC_M_DATA_WRITE,     "DATA_WRITE" },
    47         { IPC_M_DATA_READ,      "DATA_READ" },
    48         { IPC_M_DEBUG_ALL,      "DEBUG_ALL" },
    49 
    50         /* Well-known methods */
    51         { IPC_M_PING,           "PING" },
    52 
     42        { IPC_M_PHONE_HUNGUP,  "PHONE_HUNGUP" },
     43        { IPC_M_CONNECT_ME,    "CONNECT_ME" },
     44        { IPC_M_CONNECT_ME_TO, "CONNECT_ME_TO" },
     45        { IPC_M_CONNECT_TO_ME, "CONNECT_TO_ME" },
     46        { IPC_M_SHARE_OUT,     "SHARE_OUT" },
     47        { IPC_M_SHARE_IN,      "SHARE_IN" },
     48        { IPC_M_DATA_WRITE,    "DATA_WRITE" },
     49        { IPC_M_DATA_READ,     "DATA_READ" },
     50        { IPC_M_DEBUG,         "DEBUG" },
     51       
    5352        /* Terminating entry */
    5453        { 0, NULL }

  • uspace/app/trace/ipcp.c

    r764d71e r79ae36dd  
    3737#include <adt/hash_table.h>
    3838#include <sys/typefmt.h>
    39 
     39#include <kernel/ipc/ipc_methods.h>
    4040#include "ipc_desc.h"
    4141#include "proto.h"
    … …  
    268268        proto_t *proto;
    269269        int cphone;
    270 
     270       
    271271        sysarg_t *resp;
    272272        oper_t *oper;
    273273        int i;
    274 
    275 //      printf("parse_answer\n");
    276 
     274       
    277275        phone = pcall->phone_hash;
    278276        method = IPC_GET_IMETHOD(pcall->question);
    279277        retval = IPC_GET_RETVAL(*answer);
    280 
     278       
    281279        resp = answer->args;
    282 
     280       
    283281        if ((display_mask & DM_IPC) != 0) {
    284282                printf("Response to %p: retval=%" PRIdn ", args = (%" PRIun ", "
    … …  
    288286                    IPC_GET_ARG4(*answer), IPC_GET_ARG5(*answer));
    289287        }
    290 
     288       
    291289        if ((display_mask & DM_USER) != 0) {
    292290                oper = pcall->oper;
    293 
    294                 if (oper != NULL && (oper->rv_type != V_VOID || oper->respc > 0)) {
     291               
     292                if ((oper != NULL) &&
     293                    ((oper->rv_type != V_VOID) || (oper->respc > 0))) {
    295294                        printf("->");
    296 
     295                       
    297296                        if (oper->rv_type != V_VOID) {
    298297                                putchar(' ');
    … …  
    304303                                putchar('(');
    305304                                for (i = 1; i <= oper->respc; ++i) {
    306                                         if (i > 1) printf(", ");
     305                                        if (i > 1)
     306                                                printf(", ");
    307307                                        val_print(resp[i], oper->resp_type[i - 1]);
    308308                                }
    309309                                putchar(')');
    310310                        }
    311 
     311                       
    312312                        putchar('\n');
    313313                }
    314314        }
    315 
    316         if (phone == 0 && method == IPC_M_CONNECT_ME_TO && retval == 0) {
     315       
     316        if ((phone == PHONE_NS) && (method == IPC_M_CONNECT_ME_TO) &&
     317            (retval == 0)) {
    317318                /* Connected to a service (through NS) */
    318319                service = IPC_GET_ARG1(pcall->question);
    319320                proto = proto_get_by_srv(service);
    320                 if (proto == NULL) proto = proto_unknown;
    321 
     321                if (proto == NULL)
     322                        proto = proto_unknown;
     323               
    322324                cphone = IPC_GET_ARG5(*answer);
    323325                if ((display_mask & DM_SYSTEM) != 0) {
    324326                        printf("Registering connection (phone %d, protocol: %s)\n", cphone,
    325                                 proto->name);
    326                 }
     327                    proto->name);
     328                }
     329               
    327330                ipcp_connection_set(cphone, 0, proto);
    328331        }
    … …  
    334337        pending_call_t *pcall;
    335338        unsigned long key[1];
    336 
    337 //      printf("ipcp_call_in()\n");
    338 
     339       
    339340        if ((hash & IPC_CALLID_ANSWERED) == 0 && hash != IPCP_CALLID_SYNC) {
    340341                /* Not a response */
    … …  
    344345                return;
    345346        }
    346 
     347       
    347348        hash = hash & ~IPC_CALLID_ANSWERED;
    348349        key[0] = hash;
    349 
     350       
    350351        item = hash_table_find(&pending_calls, key);
    351         if (item == NULL) return; // No matching question found
    352 
     352        if (item == NULL)
     353                return; /* No matching question found */
     354       
    353355        /*
    354356         * Response matched to question.
    … …  
    357359        pcall = hash_table_get_instance(item, pending_call_t, link);
    358360        hash_table_remove(&pending_calls, key, 1);
    359 
     361       
    360362        parse_answer(hash, pcall, call);
    361363        free(pcall);

  • uspace/app/trace/syscalls.c

    r764d71e r79ae36dd  
    4040    [SYS_KLOG] ={ "klog",                               3,      V_INT_ERRNO },
    4141    [SYS_TLS_SET] = { "tls_set",                        1,      V_ERRNO },
     42
    4243    [SYS_THREAD_CREATE] = { "thread_create",            3,      V_ERRNO },
    4344    [SYS_THREAD_EXIT] = { "thread_exit",                1,      V_ERRNO },

  • uspace/app/trace/trace.c

    r764d71e r79ae36dd  
    7272ipc_call_t thread_ipc_req[THBUF_SIZE];
    7373
    74 int phoneid;
     74async_sess_t *sess;
    7575bool abort_trace;
    7676
    … …  
    8181
    8282static bool cev_valid;
    83 static console_event_t cev;
     83static kbd_event_t cev;
    8484
    8585void thread_trace_start(uintptr_t thread_hash);
    … …  
    146146static int connect_task(task_id_t task_id)
    147147{
    148         int rc;
    149 
    150         rc = async_connect_kbox(task_id);
    151 
    152         if (rc == ENOTSUP) {
    153                 printf("You do not have userspace debugging support "
    154                     "compiled in the kernel.\n");
    155                 printf("Compile kernel with 'Support for userspace debuggers' "
    156                     "(CONFIG_UDEBUG) enabled.\n");
    157                 return rc;
    158         }
    159 
    160         if (rc < 0) {
     148        async_sess_t *ksess = async_connect_kbox(task_id);
     149       
     150        if (!ksess) {
     151                if (errno == ENOTSUP) {
     152                        printf("You do not have userspace debugging support "
     153                            "compiled in the kernel.\n");
     154                        printf("Compile kernel with 'Support for userspace debuggers' "
     155                            "(CONFIG_UDEBUG) enabled.\n");
     156                        return errno;
     157                }
     158               
    161159                printf("Error connecting\n");
    162                 printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, rc);
    163                 return rc;
    164         }
    165 
    166         phoneid = rc;
    167 
    168         rc = udebug_begin(phoneid);
     160                printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, errno);
     161                return errno;
     162        }
     163       
     164        int rc = udebug_begin(ksess);
    169165        if (rc < 0) {
    170166                printf("udebug_begin() -> %d\n", rc);
    171167                return rc;
    172168        }
    173 
    174         rc = udebug_set_evmask(phoneid, UDEBUG_EM_ALL);
     169       
     170        rc = udebug_set_evmask(ksess, UDEBUG_EM_ALL);
    175171        if (rc < 0) {
    176172                printf("udebug_set_evmask(0x%x) -> %d\n ", UDEBUG_EM_ALL, rc);
    177173                return rc;
    178174        }
    179 
     175       
     176        sess = ksess;
    180177        return 0;
    181178}
    … …  
    188185        int i;
    189186
    190         rc = udebug_thread_read(phoneid, thread_hash_buf,
     187        rc = udebug_thread_read(sess, thread_hash_buf,
    191188                THBUF_SIZE*sizeof(unsigned), &tb_copied, &tb_needed);
    192189        if (rc < 0) {
    … …  
    314311
    315312        memset(&call, 0, sizeof(call));
    316         rc = udebug_mem_read(phoneid, &call.args, sc_args[1], sizeof(call.args));
     313        rc = udebug_mem_read(sess, &call.args, sc_args[1], sizeof(call.args));
    317314
    318315        if (rc >= 0) {
    … …  
    325322        ipc_call_t question, reply;
    326323        int rc;
    327         int phoneidx;
    328 
    329 //      printf("sc_ipc_call_sync_fast()\n");
    330         phoneidx = sc_args[0];
     324        int phoneid;
     325
     326        phoneid = sc_args[0];
    331327
    332328        IPC_SET_IMETHOD(question, sc_args[1]);
    … …  
    337333        IPC_SET_ARG5(question, 0);
    338334
    339 //      printf("memset\n");
    340335        memset(&reply, 0, sizeof(reply));
    341 //      printf("udebug_mem_read(phone=%d, buffer_ptr=%u, src_addr=%d, n=%d\n",
    342 //              phoneid, &reply.args, sc_args[5], sizeof(reply.args));
    343         rc = udebug_mem_read(phoneid, &reply.args, sc_args[5], sizeof(reply.args));
    344 //      printf("dmr->%d\n", rc);
    345         if (rc < 0) return;
    346 
    347 //      printf("call ipc_call_sync\n");
    348         ipcp_call_sync(phoneidx, &question, &reply);
     336        rc = udebug_mem_read(sess, &reply.args, sc_args[5], sizeof(reply.args));
     337        if (rc < 0)
     338                return;
     339       
     340        ipcp_call_sync(phoneid, &question, &reply);
    349341}
    350342
    … …  
    355347
    356348        memset(&question, 0, sizeof(question));
    357         rc = udebug_mem_read(phoneid, &question.args, sc_args[1],
     349        rc = udebug_mem_read(sess, &question.args, sc_args[1],
    358350            sizeof(question.args));
    359351
    … …  
    372364
    373365        memset(&reply, 0, sizeof(reply));
    374         rc = udebug_mem_read(phoneid, &reply.args, sc_args[2],
     366        rc = udebug_mem_read(sess, &reply.args, sc_args[2],
    375367            sizeof(reply.args));
    376368
    … …  
    391383
    392384        memset(&call, 0, sizeof(call));
    393         rc = udebug_mem_read(phoneid, &call, sc_args[0], sizeof(call));
    394 //      printf("udebug_mem_read(phone %d, dest %d, app-mem src %d, size %d -> %d\n",
    395 //              phoneid, (int)&call, sc_args[0], sizeof(call), rc);
    396 
    397         if (rc >= 0) {
     385        rc = udebug_mem_read(sess, &call, sc_args[0], sizeof(call));
     386       
     387        if (rc >= 0)
    398388                ipcp_call_in(&call, sc_rc);
    399         }
    400389}
    401390
    … …  
    407396
    408397        /* Read syscall arguments */
    409         rc = udebug_args_read(phoneid, thread_hash, sc_args);
    410 
    411         async_serialize_start();
    412 
    413 //      printf("[%d] ", thread_id);
     398        rc = udebug_args_read(sess, thread_hash, sc_args);
    414399
    415400        if (rc < 0) {
    416401                printf("error\n");
    417                 async_serialize_end();
    418402                return;
    419403        }
    … …  
    432416                break;
    433417        }
    434 
    435         async_serialize_end();
    436418}
    437419
    … …  
    444426
    445427        /* Read syscall arguments */
    446         rc = udebug_args_read(phoneid, thread_hash, sc_args);
    447 
    448         async_serialize_start();
     428        rc = udebug_args_read(sess, thread_hash, sc_args);
    449429
    450430//      printf("[%d] ", thread_id);
    … …  
    452432        if (rc < 0) {
    453433                printf("error\n");
    454                 async_serialize_end();
    455434                return;
    456435        }
    … …  
    481460                break;
    482461        }
    483 
    484         async_serialize_end();
    485462}
    486463
    487464static void event_thread_b(uintptr_t hash)
    488465{
    489         async_serialize_start();
    490466        printf("New thread, hash %p\n", (void *) hash);
    491         async_serialize_end();
    492 
    493467        thread_trace_start(hash);
    494468}
    … …  
    527501
    528502                /* Run thread until an event occurs */
    529                 rc = udebug_go(phoneid, thread_hash,
     503                rc = udebug_go(sess, thread_hash,
    530504                    &ev_type, &val0, &val1);
    531505
    … …  
    656630{
    657631        (void) arg;
    658 
     632       
     633        console_ctrl_t *console = console_init(stdin, stdout);
     634       
    659635        while (true) {
    660636                fibril_mutex_lock(&state_lock);
    … …  
    662638                        fibril_condvar_wait(&state_cv, &state_lock);
    663639                fibril_mutex_unlock(&state_lock);
    664 
    665                 if (!console_get_event(fphone(stdin), &cev))
     640               
     641                if (!console_get_kbd_event(console, &cev))
    666642                        return -1;
    667 
     643               
    668644                fibril_mutex_lock(&state_lock);
    669645                cev_valid = true;
    670646                fibril_condvar_broadcast(&state_cv);
    671                 fibril_mutex_unlock(&state_lock);               
     647                fibril_mutex_unlock(&state_lock);
    672648        }
    673649}
    … …  
    675651static void trace_task(task_id_t task_id)
    676652{
    677         console_event_t ev;
     653        kbd_event_t ev;
    678654        bool done;
    679655        int i;
    … …  
    727703                case KC_P:
    728704                        printf("Pause...\n");
    729                         rc = udebug_stop(phoneid, thash);
     705                        rc = udebug_stop(sess, thash);
    730706                        if (rc != EOK)
    731707                                printf("Error: stop -> %d\n", rc);
    … …  
    743719        printf("\nTerminate debugging session...\n");
    744720        abort_trace = true;
    745         udebug_end(phoneid);
    746         async_hangup(phoneid);
     721        udebug_end(sess);
     722        async_hangup(sess);
    747723
    748724        ipcp_cleanup();
Note: See TracChangeset for help on using the changeset viewer.