Changeset 2595dab in mainline for uspace/lib/libc/generic


Ignore:
Timestamp:
2009-06-03T19:26:28Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d00ae4c
Parents:
ca3ba3a
Message:

I/O subsystem overhaul:

  • add more POSIX-like file and stream functions (with real functionality of stdin, stdout, stderr)
  • cleanup console access methods (now generic to any console-like device)
  • remove unsafe stream functions
  • add special open_node(), fd_node(), fd_phone() (file) and fopen_node(), fnode(), fphone() (stream) functions for HelenOS-specific I/O operations
Location:
uspace/lib/libc/generic
Files:
6 deleted
8 edited
2 moved

Legend:

Unmodified
Added
Removed
  • uspace/lib/libc/generic/io/asprintf.c

    rca3ba3a r2595dab  
    3737#include <stdio.h>
    3838#include <stdlib.h>
     39#include <string.h>
    3940#include <io/printf_core.h>
    4041
    41 static int asprintf_prewrite(const char *str, size_t count, void *unused)
     42static int asprintf_str_write(const char *str, size_t count, void *unused)
    4243{
    43         return count;
     44        return str_nlength(str, count);
     45}
     46
     47static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused)
     48{
     49        return wstr_nlength(str, count);
    4450}
    4551
    4652/** Allocate and print to string.
    4753 *
    48  * @param strp          Address of the pointer where to store the address of
    49  *                      the newly allocated string.
    50  * @fmt                 Format strin.
     54 * @param strp Address of the pointer where to store the address of
     55 *             the newly allocated string.
     56 * @fmt        Format string.
    5157 *
    52  * @return              Number of characters printed or a negative error code.
     58 * @return Number of characters printed or a negative error code.
     59 *
    5360 */
    5461int asprintf(char **strp, const char *fmt, ...)
    5562{
    5663        struct printf_spec ps = {
    57                  asprintf_prewrite,
    58                  NULL
     64                asprintf_str_write,
     65                asprintf_wstr_write,
     66                NULL
    5967        };
    60         int ret;
     68       
    6169        va_list args;
    62 
    6370        va_start(args, fmt);
    64         ret = printf_core(fmt, &ps, args);
     71       
     72        int ret = printf_core(fmt, &ps, args);
    6573        va_end(args);
     74       
    6675        if (ret > 0) {
    67                 *strp = malloc(ret + 20);
    68                 if (!*strp)
     76                *strp = malloc(STR_BOUNDS(ret) + 1);
     77                if (*strp == NULL)
    6978                        return -1;
     79               
    7080                va_start(args, fmt);
    71                 vsprintf(*strp, fmt, args);
    72                 va_end(args);           
     81                vsnprintf(*strp, STR_BOUNDS(ret) + 1, fmt, args);
     82                va_end(args);
    7383        }
    74 
     84       
    7585        return ret;
    7686}
  • uspace/lib/libc/generic/io/console.c

    rca3ba3a r2595dab  
    22 * Copyright (c) 2006 Josef Cejka
    33 * Copyright (c) 2006 Jakub Vana
     4 * Copyright (c) 2008 Jiri Svoboda
    45 * All rights reserved.
    56 *
     
    3435 */
    3536
    36 #include <io/io.h>
    37 #include <io/stream.h>
    38 #include <string.h>
    39 #include <malloc.h>
    4037#include <libc.h>
    41 #include <ipc/ipc.h>
    42 #include <ipc/ns.h>
    43 #include <ipc/fb.h>
    44 #include <ipc/services.h>
     38#include <async.h>
     39#include <io/console.h>
    4540#include <ipc/console.h>
    46 #include <console.h>
    47 #include <kbd/kbd.h>
    48 #include <unistd.h>
    49 #include <async.h>
    50 #include <sys/types.h>
    5141
    52 ssize_t read_stdin(void *buf, size_t count)
     42void console_clear(int phone)
    5343{
    54         int cons_phone = console_open(false);
    55        
    56         if (cons_phone >= 0) {
    57                 kbd_event_t ev;
    58                 int rc;
    59                 size_t i = 0;
    60                
    61                 while (i < count) {
    62                         do {
    63                                 rc = kbd_get_event(&ev);
    64                                 if (rc < 0) return -1;
    65                         } while (ev.c == 0 || ev.type == KE_RELEASE);
    66                        
    67                         ((char *) buf)[i++] = ev.c;
    68                 }
    69                 return i;
    70         } else
    71                 return -1;
     44        async_msg_0(phone, CONSOLE_CLEAR);
    7245}
    7346
    74 /** Write a string to klog. */
    75 int klog_puts(const char *str)
     47int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols)
    7648{
    77         return __SYSCALL3(SYS_KLOG, 1, (sysarg_t) str, str_size(str));
     49        return async_req_0_2(phone, CONSOLE_GET_SIZE, rows, cols);
    7850}
    7951
    80 void klog_update(void)
     52void console_set_style(int phone, int style)
    8153{
    82         (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
     54        async_msg_1(phone, CONSOLE_SET_STYLE, style);
     55}
     56
     57void console_set_color(int phone, int fg_color, int bg_color, int flags)
     58{
     59        async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
     60}
     61
     62void console_set_rgb_color(int phone, int fg_color, int bg_color)
     63{
     64        async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
     65}
     66
     67void console_cursor_visibility(int phone, bool show)
     68{
     69        async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, show != false);
     70}
     71
     72void console_kcon_enable(int phone)
     73{
     74        async_msg_0(phone, CONSOLE_KCON_ENABLE);
     75}
     76
     77void console_goto(int phone, ipcarg_t row, ipcarg_t col)
     78{
     79        async_msg_2(phone, CONSOLE_GOTO, row, col);
     80}
     81
     82bool console_get_event(int phone, console_event_t *event)
     83{
     84        ipcarg_t type;
     85        ipcarg_t key;
     86        ipcarg_t mods;
     87        ipcarg_t c;
     88       
     89        int rc = async_req_0_4(phone, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
     90        if (rc < 0)
     91                return false;
     92       
     93        event->type = type;
     94        event->key = key;
     95        event->mods = mods;
     96        event->c = c;
     97       
     98        return true;
    8399}
    84100
  • uspace/lib/libc/generic/io/io.c

    rca3ba3a r2595dab  
    3131 */
    3232/** @file
    33  */ 
    34 
    35 #include <libc.h>
     33 */
     34
     35#include <stdio.h>
    3636#include <unistd.h>
    37 #include <stdio.h>
    38 #include <io/io.h>
     37#include <fcntl.h>
    3938#include <string.h>
    4039#include <errno.h>
    41 #include <console.h>
    42 
    43 const static char nl = '\n';
     40#include <bool.h>
     41#include <malloc.h>
     42#include <io/klog.h>
     43#include <vfs/vfs.h>
     44#include <ipc/devmap.h>
     45
     46FILE stdin_null = {
     47        .fd = -1,
     48        .error = true,
     49        .eof = true,
     50        .klog = false,
     51        .phone = -1
     52};
     53
     54FILE stdout_klog = {
     55        .fd = -1,
     56        .error = false,
     57        .eof = false,
     58        .klog = true,
     59        .phone = -1
     60};
     61
     62FILE *stdin = &stdin_null;
     63FILE *stdout = &stdout_klog;
     64FILE *stderr = &stdout_klog;
     65
     66static bool parse_mode(const char *mode, int *flags)
     67{
     68        /* Parse mode except first character. */
     69        const char *mp = mode;
     70        if (*mp++ == 0) {
     71                errno = EINVAL;
     72                return false;
     73        }
     74       
     75        if ((*mp == 'b') || (*mp == 't'))
     76                mp++;
     77       
     78        bool plus;
     79        if (*mp == '+') {
     80                mp++;
     81                plus = true;
     82        } else
     83                plus = false;
     84       
     85        if (*mp != 0) {
     86                errno = EINVAL;
     87                return false;
     88        }
     89       
     90        /* Parse first character of mode and determine flags for open(). */
     91        switch (mode[0]) {
     92        case 'r':
     93                *flags = plus ? O_RDWR : O_RDONLY;
     94                break;
     95        case 'w':
     96                *flags = (O_TRUNC | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
     97                break;
     98        case 'a':
     99                /* TODO: a+ must read from beginning, append to the end. */
     100                if (plus) {
     101                        errno = ENOTSUP;
     102                        return false;
     103                }
     104                *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
     105        default:
     106                errno = EINVAL;
     107                return false;
     108        }
     109       
     110        return true;
     111}
     112
     113/** Open a stream.
     114 *
     115 * @param path Path of the file to open.
     116 * @param mode Mode string, (r|w|a)[b|t][+].
     117 *
     118 */
     119FILE *fopen(const char *path, const char *mode)
     120{
     121        int flags;
     122        if (!parse_mode(mode, &flags))
     123                return NULL;
     124       
     125        /* Open file. */
     126        FILE *stream = malloc(sizeof(FILE));
     127        if (stream == NULL) {
     128                errno = ENOMEM;
     129                return NULL;
     130        }
     131       
     132        stream->fd = open(path, flags, 0666);
     133        if (stream->fd < 0) {
     134                /* errno was set by open() */
     135                free(stream);
     136                return NULL;
     137        }
     138       
     139        stream->error = false;
     140        stream->eof = false;
     141        stream->klog = false;
     142        stream->phone = -1;
     143       
     144        return stream;
     145}
     146
     147FILE *fopen_node(fs_node_t *node, const char *mode)
     148{
     149        int flags;
     150        if (!parse_mode(mode, &flags))
     151                return NULL;
     152       
     153        /* Open file. */
     154        FILE *stream = malloc(sizeof(FILE));
     155        if (stream == NULL) {
     156                errno = ENOMEM;
     157                return NULL;
     158        }
     159       
     160        stream->fd = open_node(node, flags);
     161        if (stream->fd < 0) {
     162                /* errno was set by open_node() */
     163                free(stream);
     164                return NULL;
     165        }
     166       
     167        stream->error = false;
     168        stream->eof = false;
     169        stream->klog = false;
     170        stream->phone = -1;
     171       
     172        return stream;
     173}
     174
     175int fclose(FILE *stream)
     176{
     177        int rc = 0;
     178       
     179        fflush(stream);
     180       
     181        if (stream->phone >= 0)
     182                ipc_hangup(stream->phone);
     183       
     184        if (stream->fd >= 0)
     185                rc = close(stream->fd);
     186       
     187        if ((stream != &stdin_null) && (stream != &stdout_klog))
     188                free(stream);
     189       
     190        stream = NULL;
     191       
     192        if (rc != 0) {
     193                /* errno was set by close() */
     194                return EOF;
     195        }
     196       
     197        return 0;
     198}
     199
     200/** Read from a stream.
     201 *
     202 * @param buf    Destination buffer.
     203 * @param size   Size of each record.
     204 * @param nmemb  Number of records to read.
     205 * @param stream Pointer to the stream.
     206 *
     207 */
     208size_t fread(void *buf, size_t size, size_t nmemb, FILE *stream)
     209{
     210        size_t left = size * nmemb;
     211        size_t done = 0;
     212       
     213        while ((left > 0) && (!stream->error) && (!stream->eof)) {
     214                ssize_t rd = read(stream->fd, buf + done, left);
     215               
     216                if (rd < 0)
     217                        stream->error = true;
     218                else if (rd == 0)
     219                        stream->eof = true;
     220                else {
     221                        left -= rd;
     222                        done += rd;
     223                }
     224        }
     225       
     226        return (done / size);
     227}
     228
     229/** Write to a stream.
     230 *
     231 * @param buf    Source buffer.
     232 * @param size   Size of each record.
     233 * @param nmemb  Number of records to write.
     234 * @param stream Pointer to the stream.
     235 *
     236 */
     237size_t fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
     238{
     239        size_t left = size * nmemb;
     240        size_t done = 0;
     241       
     242        while ((left > 0) && (!stream->error)) {
     243                ssize_t wr;
     244               
     245                if (stream->klog)
     246                        wr = klog_write(buf + done, left);
     247                else
     248                        wr = write(stream->fd, buf + done, left);
     249               
     250                if (wr <= 0)
     251                        stream->error = true;
     252                else {
     253                        left -= wr;
     254                        done += wr;
     255                }
     256        }
     257       
     258        return (done / size);
     259}
     260
     261int fputc(wchar_t c, FILE *stream)
     262{
     263        char buf[STR_BOUNDS(1)];
     264        size_t sz = 0;
     265       
     266        if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) {
     267                size_t wr = fwrite(buf, sz, 1, stream);
     268               
     269                if (wr < sz)
     270                        return EOF;
     271               
     272                return (int) c;
     273        }
     274       
     275        return EOF;
     276}
     277
     278int putchar(wchar_t c)
     279{
     280        return fputc(c, stdout);
     281}
     282
     283int fputs(const char *str, FILE *stream)
     284{
     285        return fwrite(str, str_size(str), 1, stream);
     286}
    44287
    45288int puts(const char *str)
    46289{
    47         size_t count;
    48        
    49         if (str == NULL)
    50                 return putnchars("(NULL)", 6);
    51        
    52         for (count = 0; str[count] != 0; count++);
    53        
    54         if (console_write((void *) str, count) == count) {
    55                 if (console_write(&nl, 1) == 1)
    56                         return 0;
    57         }
    58        
    59         return EOF;
    60 }
    61 
    62 /** Put count chars from buffer to stdout without adding newline
    63  * @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
    64  * @param count
    65  * @return 0 on succes, EOF on fail
    66  */
    67 int putnchars(const char *buf, size_t count)
    68 {
    69         if (console_write((void *) buf, count) == count)
    70                 return 0;
    71        
    72         return EOF;
    73 }
    74 
    75 /** Same as puts, but does not print newline at end
    76  *
    77  */
    78 int putstr(const char *str)
    79 {
    80         size_t count;
    81        
    82         if (str == NULL)
    83                 return putnchars("(NULL)", 6);
    84 
    85         for (count = 0; str[count] != 0; count++);
    86         if (console_write((void *) str, count) == count)
    87                 return 0;
    88        
    89         return EOF;
    90 }
    91 
    92 int putchar(int c)
    93 {
    94         char buf[STR_BOUNDS(1)];
    95         size_t offs;
    96 
    97         offs = 0;
    98         if (chr_encode(c, buf, &offs, STR_BOUNDS(1)) != EOK)
     290        return fputs(str, stdout);
     291}
     292
     293int fgetc(FILE *stream)
     294{
     295        char c;
     296       
     297        if (fread(&c, sizeof(char), 1, stream) < sizeof(char))
    99298                return EOF;
    100 
    101         if (console_write((void *) buf, offs) == offs)
    102                 return c;
    103 
    104         return EOF;
     299       
     300        return (int) c;
    105301}
    106302
    107303int getchar(void)
    108304{
    109         unsigned char c;
    110        
    111         console_flush();
    112         if (read_stdin((void *) &c, 1) == 1)
    113                 return c;
    114        
    115         return EOF;
    116 }
    117 
    118 int fflush(FILE *f)
    119 {
    120         /* Dummy implementation */
    121         (void) f;
    122         console_flush();
     305        return fgetc(stdin);
     306}
     307
     308int fseek(FILE *stream, long offset, int origin)
     309{
     310        off_t rc = lseek(stream->fd, offset, origin);
     311        if (rc == (off_t) (-1)) {
     312                /* errno has been set by lseek. */
     313                return -1;
     314        }
     315       
     316        stream->eof = false;
     317       
    123318        return 0;
    124319}
    125320
     321int fflush(FILE *stream)
     322{
     323        if (stream->klog) {
     324                klog_update();
     325                return EOK;
     326        }
     327       
     328        if (stream->fd >= 0)
     329                return fsync(stream->fd);
     330       
     331        return ENOENT;
     332}
     333
     334int feof(FILE *stream)
     335{
     336        return stream->eof;
     337}
     338
     339int ferror(FILE *stream)
     340{
     341        return stream->error;
     342}
     343
     344int fphone(FILE *stream)
     345{
     346        if (stream->fd >= 0) {
     347                if (stream->phone < 0)
     348                        stream->phone = fd_phone(stream->fd);
     349               
     350                return stream->phone;
     351        }
     352       
     353        return -1;
     354}
     355
     356void fnode(FILE *stream, fs_node_t *node)
     357{
     358        if (stream->fd >= 0) {
     359                fd_node(stream->fd, node);
     360        } else {
     361                node->fs_handle = 0;
     362                node->dev_handle = 0;
     363                node->index = 0;
     364        }
     365}
     366
    126367/** @}
    127368 */
  • uspace/lib/libc/generic/io/klog.c

    rca3ba3a r2595dab  
    11/*
    22 * Copyright (c) 2006 Josef Cejka
     3 * Copyright (c) 2006 Jakub Vana
    34 * All rights reserved.
    45 *
     
    3334 */
    3435
    35 #ifndef LIBC_IO_H_
    36 #define LIBC_IO_H_
     36#include <libc.h>
     37#include <string.h>
     38#include <sys/types.h>
     39#include <unistd.h>
     40#include <io/klog.h>
    3741
    38 #include <sys/types.h>
     42size_t klog_write(const void *buf, size_t size)
     43{
     44        return (size_t) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, size);
     45}
    3946
    40 int putnchars(const char * buf, size_t count);
    41 int putstr(const char * str);
    42 int putchar(int c);
    43 int getchar(void);
    44 
    45 #endif
     47void klog_update(void)
     48{
     49        (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
     50}
    4651
    4752/** @}
    4853 */
    49  
    50  
  • uspace/lib/libc/generic/io/printf.c

    rca3ba3a r2595dab  
    3535#include <io/printf_core.h>
    3636#include <stdio.h>
    37 #include <stdio.h>
    3837
    3938/** Print formatted text.
    40  * @param fmt   format string
     39 *
     40 * @param stream Output stream
     41 * @param fmt    Format string
     42 *
    4143 * \see For more details about format string see printf_core.
     44 *
     45 */
     46int fprintf(FILE *stream, const char *fmt, ...)
     47{
     48        va_list args;
     49        va_start(args, fmt);
     50       
     51        int ret = vfprintf(stream, fmt, args);
     52       
     53        va_end(args);
     54       
     55        return ret;
     56}
     57
     58/** Print formatted text to stdout.
     59 *
     60 * @param fmt Format string
     61 *
     62 * \see For more details about format string see printf_core.
     63 *
    4264 */
    4365int printf(const char *fmt, ...)
    4466{
    45         int ret;
    4667        va_list args;
    47 
    4868        va_start(args, fmt);
    49 
    50         ret = vprintf(fmt, args);
     69       
     70        int ret = vprintf(fmt, args);
    5171       
    5272        va_end(args);
    53 
     73       
    5474        return ret;
    5575}
  • uspace/lib/libc/generic/io/printf_core.c

    rca3ba3a r2595dab  
    174174static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
    175175{
    176         count_t counter = 0;
     176        size_t counter = 0;
    177177        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
    178178                while (--width > 0) {
     
    212212static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
    213213{
    214         count_t counter = 0;
     214        size_t counter = 0;
    215215        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
    216216                while (--width > 0) {
     
    255255
    256256        /* Print leading spaces. */
    257         count_t strw = str_length(str);
     257        size_t strw = str_length(str);
    258258        if (precision == 0)
    259259                precision = strw;
    260260
    261261        /* Left padding */
    262         count_t counter = 0;
     262        size_t counter = 0;
    263263        width -= precision;
    264264        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
     
    311311       
    312312        /* Left padding */
    313         count_t counter = 0;
     313        size_t counter = 0;
    314314        width -= precision;
    315315        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
     
    433433       
    434434        width -= precision + size - number_size;
    435         count_t counter = 0;
     435        size_t counter = 0;
    436436       
    437437        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
     
    596596        size_t j = 0;    /* Index to the first not printed nonformating character */
    597597       
    598         count_t counter = 0;  /* Number of characters printed */
     598        size_t counter = 0;   /* Number of characters printed */
    599599        int retval;           /* Return values from nested functions */
    600600       
  • uspace/lib/libc/generic/io/snprintf.c

    rca3ba3a r2595dab  
    3838
    3939/** Print formatted to the given buffer with limited size.
    40  * @param str   buffer
    41  * @param size  buffer size
    42  * @param fmt   format string
     40 *
     41 * @param str  Buffer
     42 * @param size Buffer size
     43 * @param fmt  Format string
     44 *
    4345 * \see For more details about format string see printf_core.
     46 *
    4447 */
    4548int snprintf(char *str, size_t size, const char *fmt, ...)
    4649{
    47         int ret;
    4850        va_list args;
     51        va_start(args, fmt);
    4952       
    50         va_start(args, fmt);
    51         ret = vsnprintf(str, size, fmt, args);
    52 
     53        int ret = vsnprintf(str, size, fmt, args);
     54       
    5355        va_end(args);
    54 
     56       
    5557        return ret;
    5658}
  • uspace/lib/libc/generic/io/vprintf.c

    rca3ba3a r2595dab  
    3939#include <futex.h>
    4040#include <async.h>
    41 #include <console.h>
     41#include <string.h>
    4242
    4343static atomic_t printf_futex = FUTEX_INITIALIZER;
    4444
    45 static int vprintf_str_write(const char *str, size_t size, void *data)
     45static int vprintf_str_write(const char *str, size_t size, void *stream)
     46{
     47        size_t wr = fwrite(str, 1, size, (FILE *) stream);
     48        return str_nlength(str, wr);
     49}
     50
     51static int vprintf_wstr_write(const wchar_t *str, size_t size, void *stream)
    4652{
    4753        size_t offset = 0;
    48         size_t prev;
    49         count_t chars = 0;
     54        size_t chars = 0;
    5055       
    5156        while (offset < size) {
    52                 prev = offset;
    53                 str_decode(str, &offset, size);
    54                 console_write(str + prev, offset - prev);
    55                 chars++;
    56         }
    57        
    58         return chars;
    59 }
    60 
    61 static int vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
    62 {
    63         size_t offset = 0;
    64         size_t boff;
    65         count_t chars = 0;
    66         char buf[4];
    67        
    68         while (offset < size) {
    69                 boff = 0;
    70                 chr_encode(str[chars], buf, &boff, 4);
    71                 console_write(buf, boff);
     57                if (fputc(str[chars], (FILE *) stream) <= 0)
     58                        break;
     59               
    7260                chars++;
    7361                offset += sizeof(wchar_t);
     
    7765}
    7866
    79 
    8067/** Print formatted text.
    81  * @param fmt   format string
    82  * @param ap    format parameters
     68 *
     69 * @param stream Output stream
     70 * @param fmt    Format string
     71 * @param ap     Format parameters
     72 *
    8373 * \see For more details about format string see printf_core.
     74 *
    8475 */
    85 int vprintf(const char *fmt, va_list ap)
     76int vfprintf(FILE *stream, const char *fmt, va_list ap)
    8677{
    8778        struct printf_spec ps = {
    8879                vprintf_str_write,
    8980                vprintf_wstr_write,
    90                  NULL
     81                stream
    9182        };
     83       
    9284        /*
    9385         * Prevent other threads to execute printf_core()
    9486         */
    9587        futex_down(&printf_futex);
     88       
    9689        /*
    9790         * Prevent other pseudo threads of the same thread
     
    9992         */
    10093        async_serialize_start();
     94       
    10195        int ret = printf_core(fmt, &ps, ap);
     96       
    10297        async_serialize_end();
    10398        futex_up(&printf_futex);
     99       
    104100        return ret;
     101}
     102
     103/** Print formatted text to stdout.
     104 *
     105 * @param file Output stream
     106 * @param fmt  Format string
     107 * @param ap   Format parameters
     108 *
     109 * \see For more details about format string see printf_core.
     110 *
     111 */
     112int vprintf(const char *fmt, va_list ap)
     113{
     114        return vfprintf(stdout, fmt, ap);
    105115}
    106116
  • uspace/lib/libc/generic/io/vsnprintf.c

    rca3ba3a r2595dab  
    8383                 * of string
    8484                 */
    85                 index_t index = 0;
     85                size_t index = 0;
    8686               
    8787                while (index < size) {
     
    131131static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
    132132{
    133         index_t index = 0;
     133        size_t index = 0;
    134134       
    135135        while (index < (size / sizeof(wchar_t))) {
  • uspace/lib/libc/generic/vfs/vfs.c

    rca3ba3a r2595dab  
    5050#include <string.h>
    5151#include <devmap.h>
    52 #include "../../../srv/vfs/vfs.h"
    53 
    54 int vfs_phone = -1;
    55 futex_t vfs_phone_futex = FUTEX_INITIALIZER;
    56 
    57 futex_t cwd_futex = FUTEX_INITIALIZER;
     52#include <ipc/vfs.h>
     53#include <ipc/devmap.h>
     54
     55static int vfs_phone = -1;
     56static futex_t vfs_phone_futex = FUTEX_INITIALIZER;
     57static futex_t cwd_futex = FUTEX_INITIALIZER;
     58
    5859DIR *cwd_dir = NULL;
    5960char *cwd_path = NULL;
     
    211212        futex_up(&vfs_phone_futex);
    212213        free(pa);
    213 
     214       
    214215        if (rc != EOK)
    215216            return (int) rc;
     217       
    216218        return (int) IPC_GET_ARG1(answer);
    217219}
     
    220222{
    221223        return _open(path, L_FILE, oflag);
     224}
     225
     226int open_node(fs_node_t *node, int oflag)
     227{
     228        futex_down(&vfs_phone_futex);
     229        async_serialize_start();
     230        vfs_connect();
     231       
     232        ipc_call_t answer;
     233        aid_t req = async_send_4(vfs_phone, VFS_OPEN_NODE, node->fs_handle,
     234            node->dev_handle, node->index, oflag, &answer);
     235       
     236        ipcarg_t rc;
     237        async_wait_for(req, &rc);
     238        async_serialize_end();
     239        futex_up(&vfs_phone_futex);
     240       
     241        if (rc != EOK)
     242            return (int) rc;
     243       
     244        return (int) IPC_GET_ARG1(answer);
    222245}
    223246
     
    290313        else
    291314                return -1;
     315}
     316
     317int fd_phone(int fildes)
     318{
     319        futex_down(&vfs_phone_futex);
     320        async_serialize_start();
     321        vfs_connect();
     322       
     323        ipcarg_t device;
     324        ipcarg_t rc = async_req_1_1(vfs_phone, VFS_DEVICE, fildes, &device);
     325       
     326        async_serialize_end();
     327        futex_up(&vfs_phone_futex);
     328       
     329        if (rc != EOK)
     330                return -1;
     331       
     332        return devmap_device_connect((dev_handle_t) device, 0);
     333}
     334
     335void fd_node(int fildes, fs_node_t *node)
     336{
     337        futex_down(&vfs_phone_futex);
     338        async_serialize_start();
     339        vfs_connect();
     340       
     341        ipcarg_t fs_handle;
     342        ipcarg_t dev_handle;
     343        ipcarg_t index;
     344        ipcarg_t rc = async_req_1_3(vfs_phone, VFS_NODE, fildes, &fs_handle,
     345            &dev_handle, &index);
     346       
     347        async_serialize_end();
     348        futex_up(&vfs_phone_futex);
     349       
     350        if (rc == EOK) {
     351                node->fs_handle = (fs_handle_t) fs_handle;
     352                node->dev_handle = (dev_handle_t) dev_handle;
     353                node->index = (fs_index_t) index;
     354        } else {
     355                node->fs_handle = 0;
     356                node->dev_handle = 0;
     357                node->index = 0;
     358        }
     359}
     360
     361int fsync(int fildes)
     362{
     363        futex_down(&vfs_phone_futex);
     364        async_serialize_start();
     365        vfs_connect();
     366       
     367        ipcarg_t rc = async_req_1_0(vfs_phone, VFS_SYNC, fildes);
     368       
     369        async_serialize_end();
     370        futex_up(&vfs_phone_futex);
     371       
     372        return (int) rc;
    292373}
    293374
     
    387468        futex_up(&vfs_phone_futex);
    388469        free(pa);
    389         return rc; 
     470        return rc;
    390471}
    391472
     
    417498        futex_up(&vfs_phone_futex);
    418499        free(pa);
    419         return rc; 
     500        return rc;
    420501}
    421502
Note: See TracChangeset for help on using the changeset viewer.