Changeset 2595dab in mainline
- Timestamp:
- 2009-06-03T19:26:28Z (16 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- d00ae4c
- Parents:
- ca3ba3a
- Location:
- uspace/lib/libc
- Files:
-
- 7 deleted
- 16 edited
- 7 moved
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/libc/Makefile
rca3ba3a r2595dab 47 47 generic/as.c \ 48 48 generic/cap.c \ 49 generic/console.c \50 49 generic/devmap.c \ 51 50 generic/event.c \ … … 62 61 generic/io/io.c \ 63 62 generic/io/printf.c \ 64 generic/io/fprintf.c \ 65 generic/io/stdio.c \ 66 generic/io/stream.c \ 67 generic/io/sprintf.c \ 63 generic/io/klog.c \ 68 64 generic/io/snprintf.c \ 69 65 generic/io/vprintf.c \ 70 generic/io/vsprintf.c \71 66 generic/io/vsnprintf.c \ 72 67 generic/io/printf_core.c \ 68 generic/io/console.c \ 73 69 malloc/malloc.c \ 74 70 generic/sysinfo.c \ … … 82 78 generic/err.c \ 83 79 generic/stdlib.c \ 84 generic/kbd.c \85 80 generic/mman.c \ 86 81 generic/udebug.c \ -
uspace/lib/libc/generic/io/asprintf.c
rca3ba3a r2595dab 37 37 #include <stdio.h> 38 38 #include <stdlib.h> 39 #include <string.h> 39 40 #include <io/printf_core.h> 40 41 41 static int asprintf_ prewrite(const char *str, size_t count, void *unused)42 static int asprintf_str_write(const char *str, size_t count, void *unused) 42 43 { 43 return count; 44 return str_nlength(str, count); 45 } 46 47 static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused) 48 { 49 return wstr_nlength(str, count); 44 50 } 45 51 46 52 /** Allocate and print to string. 47 53 * 48 * @param strp 49 * 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. 51 57 * 52 * @return Number of characters printed or a negative error code. 58 * @return Number of characters printed or a negative error code. 59 * 53 60 */ 54 61 int asprintf(char **strp, const char *fmt, ...) 55 62 { 56 63 struct printf_spec ps = { 57 asprintf_prewrite, 58 NULL 64 asprintf_str_write, 65 asprintf_wstr_write, 66 NULL 59 67 }; 60 int ret;68 61 69 va_list args; 62 63 70 va_start(args, fmt); 64 ret = printf_core(fmt, &ps, args); 71 72 int ret = printf_core(fmt, &ps, args); 65 73 va_end(args); 74 66 75 if (ret > 0) { 67 *strp = malloc( ret + 20);68 if ( !*strp)76 *strp = malloc(STR_BOUNDS(ret) + 1); 77 if (*strp == NULL) 69 78 return -1; 79 70 80 va_start(args, fmt); 71 vs printf(*strp, fmt, args);72 va_end(args); 81 vsnprintf(*strp, STR_BOUNDS(ret) + 1, fmt, args); 82 va_end(args); 73 83 } 74 84 75 85 return ret; 76 86 } -
uspace/lib/libc/generic/io/console.c
rca3ba3a r2595dab 2 2 * Copyright (c) 2006 Josef Cejka 3 3 * Copyright (c) 2006 Jakub Vana 4 * Copyright (c) 2008 Jiri Svoboda 4 5 * All rights reserved. 5 6 * … … 34 35 */ 35 36 36 #include <io/io.h>37 #include <io/stream.h>38 #include <string.h>39 #include <malloc.h>40 37 #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> 45 40 #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>51 41 52 ssize_t read_stdin(void *buf, size_t count)42 void console_clear(int phone) 53 43 { 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); 72 45 } 73 46 74 /** Write a string to klog. */ 75 int klog_puts(const char *str) 47 int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols) 76 48 { 77 return __SYSCALL3(SYS_KLOG, 1, (sysarg_t) str, str_size(str));49 return async_req_0_2(phone, CONSOLE_GET_SIZE, rows, cols); 78 50 } 79 51 80 void klog_update(void)52 void console_set_style(int phone, int style) 81 53 { 82 (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0); 54 async_msg_1(phone, CONSOLE_SET_STYLE, style); 55 } 56 57 void 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 62 void 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 67 void console_cursor_visibility(int phone, bool show) 68 { 69 async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, show != false); 70 } 71 72 void console_kcon_enable(int phone) 73 { 74 async_msg_0(phone, CONSOLE_KCON_ENABLE); 75 } 76 77 void console_goto(int phone, ipcarg_t row, ipcarg_t col) 78 { 79 async_msg_2(phone, CONSOLE_GOTO, row, col); 80 } 81 82 bool 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; 83 99 } 84 100 -
uspace/lib/libc/generic/io/io.c
rca3ba3a r2595dab 31 31 */ 32 32 /** @file 33 */ 34 35 #include < libc.h>33 */ 34 35 #include <stdio.h> 36 36 #include <unistd.h> 37 #include <stdio.h> 38 #include <io/io.h> 37 #include <fcntl.h> 39 38 #include <string.h> 40 39 #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 46 FILE stdin_null = { 47 .fd = -1, 48 .error = true, 49 .eof = true, 50 .klog = false, 51 .phone = -1 52 }; 53 54 FILE stdout_klog = { 55 .fd = -1, 56 .error = false, 57 .eof = false, 58 .klog = true, 59 .phone = -1 60 }; 61 62 FILE *stdin = &stdin_null; 63 FILE *stdout = &stdout_klog; 64 FILE *stderr = &stdout_klog; 65 66 static 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 */ 119 FILE *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 147 FILE *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 175 int 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 */ 208 size_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 */ 237 size_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 261 int 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 278 int putchar(wchar_t c) 279 { 280 return fputc(c, stdout); 281 } 282 283 int fputs(const char *str, FILE *stream) 284 { 285 return fwrite(str, str_size(str), 1, stream); 286 } 44 287 45 288 int puts(const char *str) 46 289 { 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 293 int fgetc(FILE *stream) 294 { 295 char c; 296 297 if (fread(&c, sizeof(char), 1, stream) < sizeof(char)) 99 298 return EOF; 100 101 if (console_write((void *) buf, offs) == offs) 102 return c; 103 104 return EOF; 299 300 return (int) c; 105 301 } 106 302 107 303 int getchar(void) 108 304 { 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 308 int 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 123 318 return 0; 124 319 } 125 320 321 int 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 334 int feof(FILE *stream) 335 { 336 return stream->eof; 337 } 338 339 int ferror(FILE *stream) 340 { 341 return stream->error; 342 } 343 344 int 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 356 void 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 126 367 /** @} 127 368 */ -
uspace/lib/libc/generic/io/klog.c
rca3ba3a r2595dab 1 1 /* 2 2 * Copyright (c) 2006 Josef Cejka 3 * Copyright (c) 2006 Jakub Vana 3 4 * All rights reserved. 4 5 * … … 33 34 */ 34 35 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> 37 41 38 #include <sys/types.h> 42 size_t klog_write(const void *buf, size_t size) 43 { 44 return (size_t) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, size); 45 } 39 46 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 47 void klog_update(void) 48 { 49 (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0); 50 } 46 51 47 52 /** @} 48 53 */ 49 50 -
uspace/lib/libc/generic/io/printf.c
rca3ba3a r2595dab 35 35 #include <io/printf_core.h> 36 36 #include <stdio.h> 37 #include <stdio.h>38 37 39 38 /** Print formatted text. 40 * @param fmt format string 39 * 40 * @param stream Output stream 41 * @param fmt Format string 42 * 41 43 * \see For more details about format string see printf_core. 44 * 45 */ 46 int 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 * 42 64 */ 43 65 int printf(const char *fmt, ...) 44 66 { 45 int ret;46 67 va_list args; 47 48 68 va_start(args, fmt); 49 50 ret = vprintf(fmt, args);69 70 int ret = vprintf(fmt, args); 51 71 52 72 va_end(args); 53 73 54 74 return ret; 55 75 } -
uspace/lib/libc/generic/io/printf_core.c
rca3ba3a r2595dab 174 174 static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps) 175 175 { 176 count_t counter = 0;176 size_t counter = 0; 177 177 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { 178 178 while (--width > 0) { … … 212 212 static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps) 213 213 { 214 count_t counter = 0;214 size_t counter = 0; 215 215 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { 216 216 while (--width > 0) { … … 255 255 256 256 /* Print leading spaces. */ 257 count_t strw = str_length(str);257 size_t strw = str_length(str); 258 258 if (precision == 0) 259 259 precision = strw; 260 260 261 261 /* Left padding */ 262 count_t counter = 0;262 size_t counter = 0; 263 263 width -= precision; 264 264 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { … … 311 311 312 312 /* Left padding */ 313 count_t counter = 0;313 size_t counter = 0; 314 314 width -= precision; 315 315 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { … … 433 433 434 434 width -= precision + size - number_size; 435 count_t counter = 0;435 size_t counter = 0; 436 436 437 437 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { … … 596 596 size_t j = 0; /* Index to the first not printed nonformating character */ 597 597 598 count_t counter = 0;/* Number of characters printed */598 size_t counter = 0; /* Number of characters printed */ 599 599 int retval; /* Return values from nested functions */ 600 600 -
uspace/lib/libc/generic/io/snprintf.c
rca3ba3a r2595dab 38 38 39 39 /** 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 * 43 45 * \see For more details about format string see printf_core. 46 * 44 47 */ 45 48 int snprintf(char *str, size_t size, const char *fmt, ...) 46 49 { 47 int ret;48 50 va_list args; 51 va_start(args, fmt); 49 52 50 va_start(args, fmt); 51 ret = vsnprintf(str, size, fmt, args); 52 53 int ret = vsnprintf(str, size, fmt, args); 54 53 55 va_end(args); 54 56 55 57 return ret; 56 58 } -
uspace/lib/libc/generic/io/vprintf.c
rca3ba3a r2595dab 39 39 #include <futex.h> 40 40 #include <async.h> 41 #include < console.h>41 #include <string.h> 42 42 43 43 static atomic_t printf_futex = FUTEX_INITIALIZER; 44 44 45 static int vprintf_str_write(const char *str, size_t size, void *data) 45 static 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 51 static int vprintf_wstr_write(const wchar_t *str, size_t size, void *stream) 46 52 { 47 53 size_t offset = 0; 48 size_t prev; 49 count_t chars = 0; 54 size_t chars = 0; 50 55 51 56 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 72 60 chars++; 73 61 offset += sizeof(wchar_t); … … 77 65 } 78 66 79 80 67 /** 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 * 83 73 * \see For more details about format string see printf_core. 74 * 84 75 */ 85 int v printf(const char *fmt, va_list ap)76 int vfprintf(FILE *stream, const char *fmt, va_list ap) 86 77 { 87 78 struct printf_spec ps = { 88 79 vprintf_str_write, 89 80 vprintf_wstr_write, 90 NULL81 stream 91 82 }; 83 92 84 /* 93 85 * Prevent other threads to execute printf_core() 94 86 */ 95 87 futex_down(&printf_futex); 88 96 89 /* 97 90 * Prevent other pseudo threads of the same thread … … 99 92 */ 100 93 async_serialize_start(); 94 101 95 int ret = printf_core(fmt, &ps, ap); 96 102 97 async_serialize_end(); 103 98 futex_up(&printf_futex); 99 104 100 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 */ 112 int vprintf(const char *fmt, va_list ap) 113 { 114 return vfprintf(stdout, fmt, ap); 105 115 } 106 116 -
uspace/lib/libc/generic/io/vsnprintf.c
rca3ba3a r2595dab 83 83 * of string 84 84 */ 85 index_t index = 0;85 size_t index = 0; 86 86 87 87 while (index < size) { … … 131 131 static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data) 132 132 { 133 index_t index = 0;133 size_t index = 0; 134 134 135 135 while (index < (size / sizeof(wchar_t))) { -
uspace/lib/libc/generic/vfs/vfs.c
rca3ba3a r2595dab 50 50 #include <string.h> 51 51 #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 55 static int vfs_phone = -1; 56 static futex_t vfs_phone_futex = FUTEX_INITIALIZER; 57 static futex_t cwd_futex = FUTEX_INITIALIZER; 58 58 59 DIR *cwd_dir = NULL; 59 60 char *cwd_path = NULL; … … 211 212 futex_up(&vfs_phone_futex); 212 213 free(pa); 213 214 214 215 if (rc != EOK) 215 216 return (int) rc; 217 216 218 return (int) IPC_GET_ARG1(answer); 217 219 } … … 220 222 { 221 223 return _open(path, L_FILE, oflag); 224 } 225 226 int 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); 222 245 } 223 246 … … 290 313 else 291 314 return -1; 315 } 316 317 int 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 335 void 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 361 int 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; 292 373 } 293 374 … … 387 468 futex_up(&vfs_phone_futex); 388 469 free(pa); 389 return rc; 470 return rc; 390 471 } 391 472 … … 417 498 futex_up(&vfs_phone_futex); 418 499 free(pa); 419 return rc; 500 return rc; 420 501 } 421 502 -
uspace/lib/libc/include/dirent.h
rca3ba3a r2595dab 36 36 #define LIBC_DIRENT_H_ 37 37 38 #define NAME_MAX 25638 #define NAME_MAX 256 39 39 40 40 struct dirent { … … 47 47 } DIR; 48 48 49 50 49 extern DIR *opendir(const char *); 51 50 extern struct dirent *readdir(DIR *); -
uspace/lib/libc/include/fcntl.h
rca3ba3a r2595dab 36 36 #define LIBC_FCNTL_H_ 37 37 38 #define O_CREAT 39 #define O_EXCL 40 #define O_TRUNC 41 #define O_APPEND 42 #define O_RDONLY 43 #define O_RDWR 44 #define O_WRONLY 38 #define O_CREAT 1 39 #define O_EXCL 2 40 #define O_TRUNC 4 41 #define O_APPEND 8 42 #define O_RDONLY 16 43 #define O_RDWR 32 44 #define O_WRONLY 64 45 45 46 46 extern int open(const char *, int, ...); -
uspace/lib/libc/include/fibril.h
rca3ba3a r2595dab 41 41 42 42 #ifndef context_set 43 #define context_set(c, _pc, stack, size, ptls) 44 (c)->pc = (sysarg_t) (_pc); 45 (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; 46 43 #define context_set(c, _pc, stack, size, ptls) \ 44 (c)->pc = (sysarg_t) (_pc); \ 45 (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \ 46 (c)->tls = (sysarg_t) (ptls); 47 47 #endif /* context_set */ 48 48 49 #define FIBRIL_SERIALIZED 49 #define FIBRIL_SERIALIZED 1 50 50 51 51 typedef enum { -
uspace/lib/libc/include/io/color.h
rca3ba3a r2595dab 28 28 29 29 /** @addtogroup libc 30 * @{ 30 * @{ 31 31 */ 32 32 /** @file 33 33 */ 34 34 35 #ifndef LIBC_ CONSOLE_COLOR_H_36 #define LIBC_ CONSOLE_COLOR_H_35 #ifndef LIBC_IO_COLOR_H_ 36 #define LIBC_IO_COLOR_H_ 37 37 38 38 enum console_color { 39 COLOR_BLACK 40 COLOR_BLUE 41 COLOR_GREEN 42 COLOR_CYAN 43 COLOR_RED 44 COLOR_MAGENTA 45 COLOR_YELLOW 46 COLOR_WHITE 47 48 CATTR_BRIGHT 49 CATTR_BLINK 39 COLOR_BLACK = 0, 40 COLOR_BLUE = 1, 41 COLOR_GREEN = 2, 42 COLOR_CYAN = 3, 43 COLOR_RED = 4, 44 COLOR_MAGENTA = 5, 45 COLOR_YELLOW = 6, 46 COLOR_WHITE = 7, 47 48 CATTR_BRIGHT = 8, 49 CATTR_BLINK = 8 50 50 }; 51 51 52 52 #endif 53 53 54 54 /** @} 55 55 */ -
uspace/lib/libc/include/io/console.h
rca3ba3a r2595dab 1 1 /* 2 * Copyright (c) 200 9Jiri Svoboda2 * Copyright (c) 2008 Jiri Svoboda 3 3 * All rights reserved. 4 4 * … … 28 28 29 29 /** @addtogroup libc 30 * @{ 30 * @{ 31 31 */ 32 32 /** @file 33 33 */ 34 34 35 #ifndef LIBC_ KBD_H_36 #define LIBC_ KBD_H_35 #ifndef LIBC_IO_CONSOLE_H_ 36 #define LIBC_IO_CONSOLE_H_ 37 37 38 #include <sys/types.h> 38 #include <ipc/ipc.h> 39 #include <bool.h> 39 40 40 typedef enum kbd_ev_type{41 KE _PRESS,42 KE _RELEASE43 } kbd_ev_type_t;41 typedef enum { 42 KEY_PRESS, 43 KEY_RELEASE 44 } console_ev_type_t; 44 45 45 /** Keyboardevent structure. */46 /** Console event structure. */ 46 47 typedef struct { 47 48 /** Press or release event. */ 48 kbd_ev_type_t type;49 49 console_ev_type_t type; 50 50 51 /** Keycode of the key that was pressed or released. */ 51 52 unsigned int key; 52 53 53 54 /** Bitmask of modifiers held. */ 54 55 unsigned int mods; 55 56 56 57 /** The character that was generated or '\0' for none. */ 57 58 wchar_t c; 58 } kbd_event_t;59 } console_event_t; 59 60 60 extern int kbd_get_event(kbd_event_t *); 61 extern void console_clear(int phone); 62 63 extern int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols); 64 extern void console_goto(int phone, ipcarg_t row, ipcarg_t col); 65 66 extern void console_set_style(int phone, int style); 67 extern void console_set_color(int phone, int fg_color, int bg_color, int flags); 68 extern void console_set_rgb_color(int phone, int fg_color, int bg_color); 69 70 extern void console_cursor_visibility(int phone, bool show); 71 extern void console_kcon_enable(int phone); 72 73 extern bool console_get_event(int phone, console_event_t *event); 61 74 62 75 #endif 63 76 64 77 /** @} 65 78 */ -
uspace/lib/libc/include/io/keycode.h
rca3ba3a r2595dab 28 28 29 29 /** @addtogroup libc 30 * @{ 30 * @{ 31 31 */ 32 32 /** @file 33 33 */ 34 34 35 #ifndef LIBC_ KBD_KEYCODE_H_36 #define LIBC_ KBD_KEYCODE_H_35 #ifndef LIBC_IO_KEYCODE_H_ 36 #define LIBC_IO_KEYCODE_H_ 37 37 38 38 /** Keycode definitions. … … 200 200 201 201 enum keymod { 202 KM_LSHIFT 203 KM_RSHIFT 204 KM_LCTRL 205 KM_RCTRL 206 KM_LALT 207 KM_RALT 208 KM_CAPS_LOCK 209 KM_NUM_LOCK 210 KM_SCROLL_LOCK 211 212 KM_SHIFT 213 KM_CTRL 214 KM_ALT 202 KM_LSHIFT = 0x001, 203 KM_RSHIFT = 0x002, 204 KM_LCTRL = 0x004, 205 KM_RCTRL = 0x008, 206 KM_LALT = 0x010, 207 KM_RALT = 0x020, 208 KM_CAPS_LOCK = 0x040, 209 KM_NUM_LOCK = 0x080, 210 KM_SCROLL_LOCK = 0x100, 211 212 KM_SHIFT = KM_LSHIFT | KM_RSHIFT, 213 KM_CTRL = KM_LCTRL | KM_RCTRL, 214 KM_ALT = KM_LALT | KM_RALT 215 215 } keymod_t; 216 216 217 217 #endif 218 218 219 219 /** @} 220 220 */ -
uspace/lib/libc/include/io/klog.h
rca3ba3a r2595dab 36 36 #define LIBC_STREAM_H_ 37 37 38 #include < libarch/types.h>38 #include <sys/types.h> 39 39 40 #define EMFILE -17 41 42 extern ssize_t read_stdin(void *, size_t); 43 extern int klog_puts(const char *); 40 extern size_t klog_write(const void *buf, size_t size); 44 41 extern void klog_update(void); 45 42 -
uspace/lib/libc/include/io/printf_core.h
rca3ba3a r2595dab 57 57 /** @} 58 58 */ 59 60 -
uspace/lib/libc/include/io/style.h
rca3ba3a r2595dab 28 28 29 29 /** @addtogroup libc 30 * @{ 30 * @{ 31 31 */ 32 32 /** @file 33 33 */ 34 34 35 #ifndef LIBC_ CONSOLE_STYLE_H_36 #define LIBC_ CONSOLE_STYLE_H_35 #ifndef LIBC_IO_STYLE_H_ 36 #define LIBC_IO_STYLE_H_ 37 37 38 38 enum console_style { 39 STYLE_NORMAL 40 STYLE_EMPHASIS 39 STYLE_NORMAL = 0, 40 STYLE_EMPHASIS = 1 41 41 }; 42 42 43 43 #endif 44 44 45 45 /** @} 46 46 */ -
uspace/lib/libc/include/stdio.h
rca3ba3a r2595dab 39 39 #include <stdarg.h> 40 40 41 #define EOF (-1) 42 43 #include <string.h> 44 #include <io/stream.h> 41 #define EOF (-1) 45 42 46 43 #define DEBUG(fmt, ...) \ 47 44 { \ 48 45 char buf[256]; \ 49 int n; \ 50 n = snprintf(buf, sizeof(buf), fmt, ##__VA_ARGS__); \ 46 int n = snprintf(buf, sizeof(buf), fmt, ##__VA_ARGS__); \ 51 47 if (n > 0) \ 52 48 (void) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, str_size(buf)); \ 53 49 } 54 50 51 #ifndef SEEK_SET 52 #define SEEK_SET 0 53 #define SEEK_CUR 1 54 #define SEEK_END 2 55 #endif 56 55 57 typedef struct { 56 58 /** Underlying file descriptor. */ 57 59 int fd; 58 60 59 61 /** Error indicator. */ 60 62 int error; 61 63 62 64 /** End-of-file indicator. */ 63 65 int eof; 66 67 /** Klog indicator */ 68 int klog; 69 70 /** Phone to the file provider */ 71 int phone; 64 72 } FILE; 65 73 66 extern FILE *stdin, *stdout, *stderr; 74 extern FILE stdin_null; 75 extern FILE stdout_klog; 76 77 extern FILE *stdin; 78 extern FILE *stdout; 79 extern FILE *stderr; 80 81 /* Character and string input functions */ 82 extern int fgetc(FILE *); 83 extern char *fgets(char *, size_t, FILE *); 67 84 68 85 extern int getchar(void); 86 extern char *gets(char *, size_t); 69 87 88 /* Character and string output functions */ 89 extern int fputc(wchar_t, FILE *); 90 extern int fputs(const char *, FILE *); 91 92 extern int putchar(wchar_t); 70 93 extern int puts(const char *); 71 extern int putchar(int); 72 extern int fflush(FILE *); 94 95 /* Formatted string output functions */ 96 extern int fprintf(FILE *, const char*, ...); 97 extern int vfprintf(FILE *, const char *, va_list); 73 98 74 99 extern int printf(const char *, ...); 100 extern int vprintf(const char *, va_list); 101 102 extern int snprintf(char *, size_t , const char *, ...); 75 103 extern int asprintf(char **, const char *, ...); 76 extern int sprintf(char *, const char *, ...);77 extern int snprintf(char *, size_t , const char *, ...);78 79 extern int vprintf(const char *, va_list);80 extern int vsprintf(char *, const char *, va_list);81 104 extern int vsnprintf(char *, size_t, const char *, va_list); 82 105 83 extern int rename(const char *, const char *); 84 106 /* File stream functions */ 85 107 extern FILE *fopen(const char *, const char *); 86 108 extern int fclose(FILE *); 109 87 110 extern size_t fread(void *, size_t, size_t, FILE *); 88 111 extern size_t fwrite(const void *, size_t, size_t, FILE *); 112 113 extern int fseek(FILE *, long, int); 114 extern int ftell(FILE *); 89 115 extern int feof(FILE *); 116 117 extern int fflush(FILE *); 90 118 extern int ferror(FILE *); 91 119 extern void clearerr(FILE *); 92 120 93 extern int fgetc(FILE *); 94 extern int fputc(int, FILE *); 95 extern int fputs(const char *, FILE *); 96 97 extern int fprintf(FILE *, const char *, ...); 98 extern int vfprintf(FILE *, const char *, va_list); 99 100 #define getc fgetc 101 #define putc fputc 102 103 extern int fseek(FILE *, long, int); 104 105 #ifndef SEEK_SET 106 #define SEEK_SET 0 107 #define SEEK_CUR 1 108 #define SEEK_END 2 109 #endif 121 /* Misc file functions */ 122 extern int rename(const char *, const char *); 110 123 111 124 #endif -
uspace/lib/libc/include/unistd.h
rca3ba3a r2595dab 40 40 41 41 #ifndef NULL 42 #define NULL042 #define NULL 0 43 43 #endif 44 44 45 #define getpagesize() 45 #define getpagesize() (PAGE_SIZE) 46 46 47 47 #ifndef SEEK_SET 48 #define SEEK_SET 49 #define SEEK_CUR 50 #define SEEK_END 48 #define SEEK_SET 0 49 #define SEEK_CUR 1 50 #define SEEK_END 2 51 51 #endif 52 52 53 53 extern ssize_t write(int, const void *, size_t); 54 54 extern ssize_t read(int, void *, size_t); 55 55 56 extern off_t lseek(int, off_t, int); 56 57 extern int ftruncate(int, off_t); 58 57 59 extern int close(int); 60 extern int fsync(int); 58 61 extern int unlink(const char *); 62 63 extern char *getcwd(char *buf, size_t); 59 64 extern int rmdir(const char *); 60 65 extern int chdir(const char *); 61 extern char *getcwd(char *buf, size_t);62 66 63 67 extern void _exit(int status) __attribute__ ((noreturn)); -
uspace/lib/libc/include/vfs/vfs.h
rca3ba3a r2595dab 37 37 38 38 #include <sys/types.h> 39 #include <ipc/vfs.h> 40 #include <ipc/devmap.h> 41 #include <stdio.h> 42 43 typedef struct { 44 fs_handle_t fs_handle; 45 dev_handle_t dev_handle; 46 fs_index_t index; 47 } fs_node_t; 39 48 40 49 extern char *absolutize(const char *, size_t *); … … 43 52 unsigned int flags); 44 53 54 extern int open_node(fs_node_t *node, int oflag); 55 extern int fd_phone(int); 56 extern void fd_node(int, fs_node_t *); 57 58 extern FILE *fopen_node(fs_node_t *node, const char *); 59 extern int fphone(FILE *); 60 extern void fnode(FILE *stream, fs_node_t *node); 61 45 62 #endif 46 63
Note:
See TracChangeset
for help on using the changeset viewer.