Changeset 79ae36dd in mainline for uspace/lib/c/generic/io


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/lib/c/generic/io
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/io/console.c

    r764d71e r79ae36dd  
    3737#include <libc.h>
    3838#include <async.h>
     39#include <errno.h>
     40#include <stdio.h>
     41#include <malloc.h>
     42#include <vfs/vfs_sess.h>
    3943#include <io/console.h>
    4044#include <ipc/console.h>
    4145
    42 void console_clear(int phone)
    43 {
    44         async_msg_0(phone, CONSOLE_CLEAR);
    45 }
    46 
    47 int console_get_size(int phone, sysarg_t *cols, sysarg_t *rows)
    48 {
    49         return async_req_0_2(phone, CONSOLE_GET_SIZE, cols, rows);
    50 }
    51 
    52 void console_set_style(int phone, uint8_t style)
    53 {
    54         async_msg_1(phone, CONSOLE_SET_STYLE, style);
    55 }
    56 
    57 void console_set_color(int phone, uint8_t fg_color, uint8_t bg_color,
     46console_ctrl_t *console_init(FILE *ifile, FILE *ofile)
     47{
     48        console_ctrl_t *ctrl = malloc(sizeof(console_ctrl_t));
     49        if (!ctrl)
     50                return NULL;
     51       
     52        ctrl->input_sess = fsession(EXCHANGE_SERIALIZE, ifile);
     53        if (!ctrl->input_sess) {
     54                free(ctrl);
     55                return NULL;
     56        }
     57       
     58        ctrl->output_sess = fsession(EXCHANGE_SERIALIZE, ofile);
     59        if (!ctrl->output_sess) {
     60                free(ctrl);
     61                return NULL;
     62        }
     63       
     64        ctrl->input = ifile;
     65        ctrl->output = ofile;
     66        ctrl->input_aid = 0;
     67       
     68        return ctrl;
     69}
     70
     71void console_done(console_ctrl_t *ctrl)
     72{
     73        free(ctrl);
     74}
     75
     76bool console_kcon(void)
     77{
     78#if 0
     79        return __SYSCALL0(SYS_DEBUG_ACTIVATE_CONSOLE);
     80#endif
     81       
     82        return false;
     83}
     84
     85void console_flush(console_ctrl_t *ctrl)
     86{
     87        fflush(ctrl->output);
     88}
     89
     90void console_clear(console_ctrl_t *ctrl)
     91{
     92        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     93        async_msg_0(exch, CONSOLE_CLEAR);
     94        async_exchange_end(exch);
     95}
     96
     97int console_get_size(console_ctrl_t *ctrl, sysarg_t *cols, sysarg_t *rows)
     98{
     99        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     100        int rc = async_req_0_2(exch, CONSOLE_GET_SIZE, cols, rows);
     101        async_exchange_end(exch);
     102       
     103        return rc;
     104}
     105
     106void console_set_style(console_ctrl_t *ctrl, uint8_t style)
     107{
     108        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     109        async_msg_1(exch, CONSOLE_SET_STYLE, style);
     110        async_exchange_end(exch);
     111}
     112
     113void console_set_color(console_ctrl_t *ctrl, uint8_t fg_color, uint8_t bg_color,
    58114    uint8_t flags)
    59115{
    60         async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
    61 }
    62 
    63 void console_set_rgb_color(int phone, uint32_t fg_color, uint32_t bg_color)
    64 {
    65         async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
    66 }
    67 
    68 void console_cursor_visibility(int phone, bool show)
    69 {
    70         async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, (show != false));
    71 }
    72 
    73 int console_get_color_cap(int phone, sysarg_t *ccap)
    74 {
    75         return async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, ccap);
    76 }
    77 
    78 void console_kcon_enable(int phone)
    79 {
    80         async_msg_0(phone, CONSOLE_KCON_ENABLE);
    81 }
    82 
    83 int console_get_pos(int phone, sysarg_t *col, sysarg_t *row)
    84 {
    85         return async_req_0_2(phone, CONSOLE_GET_POS, col, row);
    86 }
    87 
    88 void console_set_pos(int phone, sysarg_t col, sysarg_t row)
    89 {
    90         async_msg_2(phone, CONSOLE_GOTO, col, row);
    91 }
    92 
    93 bool console_get_event(int phone, console_event_t *event)
    94 {
    95         sysarg_t type;
    96         sysarg_t key;
    97         sysarg_t mods;
    98         sysarg_t c;
    99        
    100         int rc = async_req_0_4(phone, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
    101         if (rc < 0)
     116        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     117        async_msg_3(exch, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
     118        async_exchange_end(exch);
     119}
     120
     121void console_set_rgb_color(console_ctrl_t *ctrl, uint32_t fg_color,
     122    uint32_t bg_color)
     123{
     124        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     125        async_msg_2(exch, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
     126        async_exchange_end(exch);
     127}
     128
     129void console_cursor_visibility(console_ctrl_t *ctrl, bool show)
     130{
     131        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     132        async_msg_1(exch, CONSOLE_CURSOR_VISIBILITY, (show != false));
     133        async_exchange_end(exch);
     134}
     135
     136int console_get_color_cap(console_ctrl_t *ctrl, sysarg_t *ccap)
     137{
     138        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     139        int rc = async_req_0_1(exch, CONSOLE_GET_COLOR_CAP, ccap);
     140        async_exchange_end(exch);
     141       
     142        return rc;
     143}
     144
     145int console_get_pos(console_ctrl_t *ctrl, sysarg_t *col, sysarg_t *row)
     146{
     147        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     148        int rc = async_req_0_2(exch, CONSOLE_GET_POS, col, row);
     149        async_exchange_end(exch);
     150       
     151        return rc;
     152}
     153
     154void console_set_pos(console_ctrl_t *ctrl, sysarg_t col, sysarg_t row)
     155{
     156        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
     157        async_msg_2(exch, CONSOLE_GOTO, col, row);
     158        async_exchange_end(exch);
     159}
     160
     161bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event)
     162{
     163        if (ctrl->input_aid == 0) {
     164                sysarg_t type;
     165                sysarg_t key;
     166                sysarg_t mods;
     167                sysarg_t c;
     168               
     169                async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
     170                int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
     171                async_exchange_end(exch);
     172               
     173                if (rc != EOK) {
     174                        errno = rc;
     175                        return false;
     176                }
     177               
     178                event->type = type;
     179                event->key = key;
     180                event->mods = mods;
     181                event->c = c;
     182        } else {
     183                sysarg_t retval;
     184                async_wait_for(ctrl->input_aid, &retval);
     185               
     186                ctrl->input_aid = 0;
     187               
     188                if (retval != EOK) {
     189                        errno = (int) retval;
     190                        return false;
     191                }
     192               
     193                event->type = IPC_GET_ARG1(ctrl->input_call);
     194                event->key = IPC_GET_ARG2(ctrl->input_call);
     195                event->mods = IPC_GET_ARG3(ctrl->input_call);
     196                event->c = IPC_GET_ARG4(ctrl->input_call);
     197        }
     198       
     199        return true;
     200}
     201
     202bool console_get_kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event,
     203    suseconds_t *timeout)
     204{
     205        struct timeval t0;
     206        gettimeofday(&t0, NULL);
     207       
     208        if (ctrl->input_aid == 0) {
     209                async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
     210                ctrl->input_aid = async_send_0(exch, CONSOLE_GET_EVENT,
     211                    &ctrl->input_call);
     212                async_exchange_end(exch);
     213        }
     214       
     215        sysarg_t retval;
     216        int rc = async_wait_timeout(ctrl->input_aid, &retval, *timeout);
     217        if (rc != EOK) {
     218                *timeout = 0;
     219                errno = rc;
    102220                return false;
    103        
    104         event->type = type;
    105         event->key = key;
    106         event->mods = mods;
    107         event->c = c;
     221        }
     222       
     223        ctrl->input_aid = 0;
     224       
     225        if (retval != EOK) {
     226                errno = (int) retval;
     227                return false;
     228        }
     229       
     230        event->type = IPC_GET_ARG1(ctrl->input_call);
     231        event->key = IPC_GET_ARG2(ctrl->input_call);
     232        event->mods = IPC_GET_ARG3(ctrl->input_call);
     233        event->c = IPC_GET_ARG4(ctrl->input_call);
     234       
     235        /* Update timeout */
     236        struct timeval t1;
     237        gettimeofday(&t1, NULL);
     238        *timeout -= tv_sub(&t1, &t0);
    108239       
    109240        return true;

  • uspace/lib/c/generic/io/io.c

    r764d71e r79ae36dd  
    4444#include <io/klog.h>
    4545#include <vfs/vfs.h>
     46#include <vfs/vfs_sess.h>
    4647#include <ipc/devmap.h>
    4748#include <adt/list.h>
    4849#include "../private/io.h"
     50#include "../private/stdio.h"
    4951
    5052static void _ffillbuf(FILE *stream);
    … …  
    5658        .eof = true,
    5759        .klog = false,
    58         .phone = -1,
     60        .sess = NULL,
    5961        .btype = _IONBF,
    6062        .buf = NULL,
    … …  
    7072        .eof = false,
    7173        .klog = true,
    72         .phone = -1,
     74        .sess = NULL,
    7375        .btype = _IOLBF,
    7476        .buf = NULL,
    … …  
    8486        .eof = false,
    8587        .klog = true,
    86         .phone = -1,
     88        .sess = NULL,
    8789        .btype = _IONBF,
    8890        .buf = NULL,
    … …  
    255257        stream->eof = false;
    256258        stream->klog = false;
    257         stream->phone = -1;
     259        stream->sess = NULL;
    258260        stream->need_sync = false;
    259261        _setvbuf(stream);
    … …  
    277279        stream->eof = false;
    278280        stream->klog = false;
    279         stream->phone = -1;
     281        stream->sess = NULL;
    280282        stream->need_sync = false;
    281283        _setvbuf(stream);
    … …  
    309311        stream->eof = false;
    310312        stream->klog = false;
    311         stream->phone = -1;
     313        stream->sess = NULL;
    312314        stream->need_sync = false;
    313315        _setvbuf(stream);
    … …  
    324326        fflush(stream);
    325327       
    326         if (stream->phone >= 0)
    327                 async_hangup(stream->phone);
     328        if (stream->sess != NULL)
     329                async_hangup(stream->sess);
    328330       
    329331        if (stream->fd >= 0)
    … …  
    732734        }
    733735       
    734         if (stream->fd >= 0 && stream->need_sync) {
     736        if ((stream->fd >= 0) && (stream->need_sync)) {
    735737                /**
    736738                 * Better than syncing always, but probably still not the
    … …  
    770772}
    771773
    772 int fphone(FILE *stream)
     774async_sess_t *fsession(exch_mgmt_t mgmt, FILE *stream)
    773775{
    774776        if (stream->fd >= 0) {
    775                 if (stream->phone < 0)
    776                         stream->phone = fd_phone(stream->fd);
    777                
    778                 return stream->phone;
    779         }
    780        
    781         return -1;
     777                if (stream->sess == NULL)
     778                        stream->sess = fd_session(mgmt, stream->fd);
     779               
     780                return stream->sess;
     781        }
     782       
     783        return NULL;
    782784}
    783785
Note: See TracChangeset for help on using the changeset viewer.