l4/pkg/l4re-core/uclibc/lib/contrib/uclibc/libc/stdio/_stdio.c

   1 /* Copyright (C) 2004       Manuel Novoa III    <mjn3@codepoet.org>
   2  *
   3  * GNU Library General Public License (LGPL) version 2 or later.
   4  *
   5  * Dedicated to Toni.  See uClibc/DEDICATION.mjn3 for details.
   6  */
   7
   8 #include "_stdio.h"
   9
  10 /* This is pretty much straight from uClibc, but with one important
  11  * difference.
  12  *
  13  * We now initialize the locking flag to user locking instead of
  14  * auto locking (i.e. FSETLOCKING_BYCALLER vs FSETLOCKING_INTERNAL).
  15  * This greatly benefits non-threading applications linked to a
  16  * shared thread-enabled library.  In threading applications, we
  17  * walk the stdio open file list and reset the locking mode
  18  * appropriately when the thread subsystem is initialized.
  19  */
  20
  21 /**********************************************************************/
  22
  23 #ifdef __UCLIBC_HAS_WCHAR__
  24 #define __STDIO_FILE_INIT_WUNGOT                { 0, 0 },
  25 #else
  26 #define __STDIO_FILE_INIT_WUNGOT
  27 #endif
  28
  29 #ifdef __STDIO_GETC_MACRO
  30 # define __STDIO_FILE_INIT_BUFGETC(x) x,
  31 #else
  32 # define __STDIO_FILE_INIT_BUFGETC(x)
  33 #endif
  34
  35 #ifdef __STDIO_PUTC_MACRO
  36 # define __STDIO_FILE_INIT_BUFPUTC(x) x,
  37 #else
  38 # define __STDIO_FILE_INIT_BUFPUTC(x)
  39 #endif
  40
  41 #ifdef __STDIO_HAS_OPENLIST
  42 #define __STDIO_FILE_INIT_NEXT(next)    (next),
  43 #else
  44 #define __STDIO_FILE_INIT_NEXT(next)
  45 #endif
  46
  47 #ifdef __STDIO_BUFFERS
  48 #define __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
  49         (buf), (buf)+(bufsize), (buf), (buf),
  50 #else
  51 #define __STDIO_FILE_INIT_BUFFERS(buf,bufsize)
  52 #endif
  53
  54 #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
  55 #define __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
  56         &((stream).__filedes), { _cs_read, _cs_write, _cs_seek, _cs_close },
  57 #else
  58 #define __STDIO_FILE_INIT_CUSTOM_STREAM(stream)
  59 #endif
  60
  61 #ifdef __STDIO_MBSTATE
  62 #define __STDIO_FILE_INIT_MBSTATE \
  63         { 0, 0 },
  64 #else
  65 #define __STDIO_FILE_INIT_MBSTATE
  66 #endif
  67
  68 #ifdef __UCLIBC_HAS_XLOCALE__
  69 #define __STDIO_FILE_INIT_UNUSED \
  70         NULL,
  71 #else
  72 #define __STDIO_FILE_INIT_UNUSED
  73 #endif
  74
  75 #ifdef __UCLIBC_HAS_THREADS__
  76 #ifdef __USE_STDIO_FUTEXES__
  77 #define __STDIO_FILE_INIT_THREADSAFE \
  78         2, _LIBC_LOCK_RECURSIVE_INITIALIZER,
  79 #else
  80 #define __STDIO_FILE_INIT_THREADSAFE \
  81         2, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
  82 #endif
  83 #else
  84 #define __STDIO_FILE_INIT_THREADSAFE
  85 #endif
  86
  87 #define __STDIO_INIT_FILE_STRUCT(stream, flags, filedes, next, buf, bufsize) \
  88         { (flags), \
  89         { 0, 0 }, /* ungot[2] (no wchar) or ungot_width[2] (wchar)*/ \
  90         (filedes), \
  91         __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
  92         __STDIO_FILE_INIT_BUFGETC((buf)) \
  93         __STDIO_FILE_INIT_BUFPUTC((buf)) \
  94         __STDIO_FILE_INIT_NEXT(next) \
  95         __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
  96         __STDIO_FILE_INIT_WUNGOT \
  97         __STDIO_FILE_INIT_MBSTATE \
  98         __STDIO_FILE_INIT_UNUSED \
  99         __STDIO_FILE_INIT_THREADSAFE \
 100 } /* TODO: builtin buf */
 101
 102 /**********************************************************************/
 103 /* First we need the standard files. */
 104
 105 #ifdef __STDIO_BUFFERS
 106 static unsigned char _fixed_buffers[2 * BUFSIZ];
 107 #endif
 108
 109 static FILE _stdio_streams[] = {
 110         __STDIO_INIT_FILE_STRUCT(_stdio_streams[0], \
 111                                                          __FLAG_LBF|__FLAG_READONLY, \
 112                                                          0, \
 113                                                          _stdio_streams + 1, \
 114                                                          _fixed_buffers, \
 115                                                          BUFSIZ ),
 116         __STDIO_INIT_FILE_STRUCT(_stdio_streams[1], \
 117                                                          __FLAG_LBF|__FLAG_WRITEONLY, \
 118                                                          1, \
 119                                                          _stdio_streams + 2, \
 120                                                          _fixed_buffers + BUFSIZ, \
 121                                                          BUFSIZ ),
 122         __STDIO_INIT_FILE_STRUCT(_stdio_streams[2], \
 123                                                          __FLAG_NBF|__FLAG_WRITEONLY, \
 124                                                          2, \
 125                                                          NULL, \
 126                                                          NULL, \
 127                                                          0 )
 128 };
 129
 130 FILE *stdin  = _stdio_streams;
 131 FILE *stdout = _stdio_streams + 1;
 132 FILE *stderr = _stdio_streams + 2;
 133
 134 #ifdef __STDIO_GETC_MACRO
 135 FILE *__stdin = _stdio_streams;          /* For getchar() macro. */
 136 #endif
 137 #ifdef __STDIO_PUTC_MACRO
 138 FILE *__stdout = _stdio_streams + 1; /* For putchar() macro. */
 139 /* FILE *__stderr = _stdio_streams + 2; */
 140 #endif
 141
 142 /**********************************************************************/
 143 #ifdef __STDIO_HAS_OPENLIST
 144
 145 /* In certain configurations, we need to keep a list of open files.
 146  * 1) buffering enabled - We need to initialize the buffering mode
 147  *       (full or line buffering) of stdin and stdout.  We also
 148  *       need to flush all write buffers prior to normal termination.
 149  * 2) custom streams - Even if we aren't buffering in the library
 150  *       itself, we need to fclose() all custom streams when terminating
 151  *       so that any special cleanup is done.
 152  * 3) threads enabled - We need to be able to reset the locking mode
 153  *       of all open streams when the threading system is initialized.
 154  */
 155
 156 FILE *_stdio_openlist = _stdio_streams;
 157
 158 # ifdef __UCLIBC_HAS_THREADS__
 159 __UCLIBC_IO_MUTEX_INIT(_stdio_openlist_add_lock);
 160 #  ifdef __STDIO_BUFFERS
 161 __UCLIBC_IO_MUTEX_INIT(_stdio_openlist_del_lock);
 162 volatile int _stdio_openlist_use_count = 0;
 163 int _stdio_openlist_del_count = 0;
 164 #  endif
 165 # endif
 166 #endif
 167 /**********************************************************************/
 168 #ifdef __UCLIBC_HAS_THREADS__
 169
 170 /* 2 if threading not initialized and 0 otherwise; */
 171 int _stdio_user_locking = 2;
 172
 173 #ifndef __USE_STDIO_FUTEXES__
 174 void attribute_hidden __stdio_init_mutex(__UCLIBC_MUTEX_TYPE *m)
 175 {
 176         const __UCLIBC_MUTEX_STATIC(__stdio_mutex_initializer,
 177                 PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
 178
 179         memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer));
 180 }
 181 #endif
 182
 183 #endif
 184 /**********************************************************************/
 185
 186 /* We assume here that we are the only remaining thread. */
 187 void _stdio_term(void)
 188 {
 189 #if defined(__STDIO_BUFFERS) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__)
 190         register FILE *ptr;
 191
 192 #ifdef __UCLIBC_HAS_THREADS__
 193         /* First, make sure the open file list is unlocked.  If it was
 194          * locked, then I suppose there is a chance that a pointer in the
 195          * chain might be corrupt due to a partial store.
 196          */
 197         STDIO_INIT_MUTEX(_stdio_openlist_add_lock);
 198 #warning check
 199 #ifdef __STDIO_BUFFERS
 200         STDIO_INIT_MUTEX(_stdio_openlist_del_lock);
 201 #endif
 202
 203         /* Next we need to worry about the streams themselves.  If a stream
 204          * is currently locked, then it may be in an invalid state.  So we
 205          * 'disable' it in case a custom stream is stacked on top of it.
 206          * Then we reinitialize the locks.
 207          */
 208         for (ptr = _stdio_openlist ; ptr ; ptr = ptr->__nextopen ) {
 209                 if (__STDIO_ALWAYS_THREADTRYLOCK_CANCEL_UNSAFE(ptr)) {
 210                         /* The stream is already locked, so we don't want to touch it.
 211                          * However, if we have custom streams, we can't just close it
 212                          * or leave it locked since a custom stream may be stacked
 213                          * on top of it.  So we do unlock it, while also disabling it.
 214                          */
 215                         ptr->__modeflags = (__FLAG_READONLY|__FLAG_WRITEONLY);
 216                         __STDIO_STREAM_DISABLE_GETC(ptr);
 217                         __STDIO_STREAM_DISABLE_PUTC(ptr);
 218                         __STDIO_STREAM_INIT_BUFREAD_BUFPOS(ptr);
 219                 }
 220
 221                 ptr->__user_locking = 1; /* Set locking mode to "by caller". */
 222                 STDIO_INIT_MUTEX(ptr->__lock); /* Shouldn't be necessary, but... */
 223         }
 224 #endif
 225
 226         /* Finally, flush all writing streams and shut down all custom streams.
 227          * NOTE: We assume that any stacking by custom streams is done on top
 228          *       of streams previously allocated, and hence further down the
 229          *       list.  Otherwise we have no way of knowing the order in which
 230          *       to shut them down.
 231          *       Remember that freopen() counts as a new allocation here, even
 232          *       though the stream is reused.  That's because it moves the
 233          *       stream to the head of the list.
 234          */
 235         for (ptr = _stdio_openlist ; ptr ; ptr = ptr->__nextopen ) {
 236 #ifdef __STDIO_BUFFERS
 237                 /* Write any pending buffered chars. */
 238                 if (__STDIO_STREAM_IS_WRITING(ptr)) {
 239                         __STDIO_COMMIT_WRITE_BUFFER(ptr);
 240                 }
 241 #endif
 242 #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
 243                 /* Actually close all custom streams to perform any special cleanup. */
 244                 if (ptr->__cookie != &ptr->__filedes) {
 245                         __CLOSE(ptr);
 246                 }
 247 #endif
 248         }
 249
 250 #endif
 251 }
 252
 253 #if defined __STDIO_BUFFERS || !defined __UCLIBC__
 254 void _stdio_init(void)
 255 {
 256 #ifdef __NOT_FOR_L4__
 257 #ifdef __STDIO_BUFFERS
 258         int old_errno = errno;
 259         /* stdin and stdout uses line buffering when connected to a tty. */
 260         if (!isatty(0))
 261                 _stdio_streams[0].__modeflags ^= __FLAG_LBF;
 262         if (!isatty(1))
 263                 _stdio_streams[1].__modeflags ^= __FLAG_LBF;
 264         __set_errno(old_errno);
 265 #endif
 266 #else
 267 # if defined(__STDIO_BUFFERS) && defined(__UCLIBC_HAS_THREADS__)
 268         register FILE *ptr;
 269         _stdio_user_locking = 0;
 270         for (ptr = _stdio_openlist ; ptr ; ptr = ptr->__nextopen ) {
 271                 if (ptr->__user_locking != 1) {
 272                                 ptr->__user_locking = 0;
 273                 }
 274         }
 275 # endif
 276
 277 #endif
 278
 279 #ifndef __UCLIBC__
 280         /* _stdio_term is done automatically when exiting if stdio is used.
 281          * See misc/internals/__uClibc_main.c and and stdlib/atexit.c. */
 282         atexit(_stdio_term);
 283 #endif
 284 }
 285 #endif
 286
 287 /**********************************************************************/
 288
 289 #if !(__MASK_READING & __FLAG_UNGOT)
 290 #error Assumption violated about __MASK_READING and __FLAG_UNGOT
 291 #endif
 292
 293 #ifndef NDEBUG
 294
 295 void attribute_hidden _stdio_validate_FILE(const FILE *stream)
 296 {
 297 #ifdef __UCLIBC_HAS_THREADS__
 298         assert(((unsigned int)(stream->__user_locking)) <= 2);
 299 #endif
 300
 301 #warning Define a constant for minimum possible valid __filedes?
 302         assert(stream->__filedes >= -3);
 303
 304         if (stream->__filedes < 0) {
 305 /*              assert((stream->__filedes != -1) */
 306 /* #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ */
 307 /*                         || (stream->__cookie == &stream->__filedes) /\* custom *\/ */
 308 /* #endif */
 309 /*                         ); */
 310 /*              assert((stream->__filedes == -1) || __STDIO_STREAM_IS_FBF(stream)); */
 311
 312                 assert(!__STDIO_STREAM_IS_FAKE_VSNPRINTF(stream)
 313                            || __STDIO_STREAM_IS_NARROW(stream));
 314                 assert(!__STDIO_STREAM_IS_FAKE_VSSCANF(stream)
 315                            || __STDIO_STREAM_IS_NARROW(stream));
 316 #ifdef __STDIO_STREAM_IS_FAKE_VSWPRINTF
 317                 assert(!__STDIO_STREAM_IS_FAKE_VSWPRINTF(stream)
 318                            || __STDIO_STREAM_IS_WIDE(stream));
 319 #endif
 320 #ifdef __STDIO_STREAM_IS_FAKE_VSWSCANF
 321                 assert(!__STDIO_STREAM_IS_FAKE_VSWSCANF(stream)
 322                            || __STDIO_STREAM_IS_WIDE(stream));
 323 #endif
 324         }
 325
 326 #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
 327         if (stream->__cookie != &stream->__filedes) { /* custom */
 328                 assert(stream->__filedes == -1);
 329         }
 330 #endif
 331
 332         /* Can not be both narrow and wide oriented at the same time. */
 333         assert(!(__STDIO_STREAM_IS_NARROW(stream)
 334                          && __STDIO_STREAM_IS_WIDE(stream)));
 335
 336
 337         /* The following impossible case is used to disable a stream. */
 338         if ((stream->__modeflags & (__FLAG_READONLY|__FLAG_WRITEONLY))
 339                 == (__FLAG_READONLY|__FLAG_WRITEONLY)
 340                 ) {
 341                 assert(stream->__modeflags == (__FLAG_READONLY|__FLAG_WRITEONLY));
 342                 assert(stream->__filedes == -1);
 343 #ifdef __STDIO_BUFFERS
 344                 assert(stream->__bufpos == stream->__bufstart);
 345                 assert(stream->__bufread == stream->__bufstart);
 346 # ifdef __UCLIBC_HAS_STDIO_PUTC_MACRO__
 347                 assert(stream->__bufputc_u == stream->__bufstart);
 348 # endif
 349 # ifdef __UCLIBC_HAS_STDIO_GETC_MACRO__
 350                 assert(stream->__bufgetc_u == stream->__bufstart);
 351 # endif
 352 #endif
 353         }
 354
 355         if (__STDIO_STREAM_IS_READONLY(stream)) {
 356 /*              assert(!__STDIO_STREAM_IS_WRITEONLY(stream)); */
 357                 assert(!__STDIO_STREAM_IS_WRITING(stream));
 358                 if (stream->__modeflags & __FLAG_UNGOT) {
 359                         assert(((unsigned)(stream->__ungot[1])) <= 1);
 360                         assert(!__FEOF_UNLOCKED(stream));
 361                 }
 362         }
 363
 364         if (__STDIO_STREAM_IS_WRITEONLY(stream)) {
 365 /*              assert(!__STDIO_STREAM_IS_READONLY(stream)); */
 366                 assert(!__STDIO_STREAM_IS_READING(stream));
 367                 assert(!(stream->__modeflags & __FLAG_UNGOT));
 368         }
 369
 370         if (__STDIO_STREAM_IS_NBF(stream)) {
 371                 /* We require that all non buffered streams have no buffer. */
 372                 assert(!__STDIO_STREAM_BUFFER_SIZE(stream));
 373         }
 374
 375         assert((stream->__modeflags & __MASK_BUFMODE) <= __FLAG_NBF);
 376
 377 #ifdef __STDIO_BUFFERS
 378         /* Ensure __bufstart <= __bufpos <= __bufend. */
 379         assert(stream->__bufpos >= stream->__bufstart);
 380         assert(stream->__bufpos <= stream->__bufend);
 381         /* Ensure __bufstart <= __bufread <= __bufend. */
 382         assert(stream->__bufread >= stream->__bufstart);
 383         assert(stream->__bufread <= stream->__bufend);
 384 #endif
 385
 386         /* If EOF, then we must have no buffered readable or ungots. */
 387         if (__FEOF_UNLOCKED(stream)) {
 388 #ifdef __STDIO_BUFFERS
 389                 assert(stream->__bufpos == stream->__bufread);
 390 #endif
 391                 assert(!(stream->__modeflags & __FLAG_UNGOT));
 392         }
 393
 394
 395         if (!__STDIO_STREAM_IS_WRITING(stream)) {
 396 #ifdef __STDIO_BUFFERS
 397                 /* If not writing, then putc macro must be disabled. */
 398 # ifdef __UCLIBC_HAS_STDIO_PUTC_MACRO__
 399                 assert(stream->__bufputc_u == stream->__bufstart);
 400 # endif
 401 #endif
 402         }
 403
 404         if (!__STDIO_STREAM_IS_READING(stream)) {
 405                 /* If not reading, then can not have ungots. */
 406                 assert(!(stream->__modeflags & __FLAG_UNGOT));
 407 #ifdef __STDIO_BUFFERS
 408                 /* Ensure __bufread == __bufstart. */
 409                 assert(stream->__bufread == stream->__bufstart);
 410                 /* If not reading, then getc macro must be disabled. */
 411 # ifdef __UCLIBC_HAS_STDIO_GETC_MACRO__
 412                 assert(stream->__bufgetc_u == stream->__bufstart);
 413 # endif
 414 #endif
 415         }
 416
 417         if (__STDIO_STREAM_IS_READING(stream)) {
 418                 assert(!__STDIO_STREAM_IS_WRITING(stream));
 419 #ifdef __STDIO_BUFFERS
 420                 /* Ensure __bufpos <= __bufread. */
 421                 assert(stream->__bufpos <= stream->__bufread);
 422
 423                 /* Ensure __bufgetc_u is valid. */
 424 # ifdef __UCLIBC_HAS_STDIO_GETC_MACRO__
 425                 assert(stream->__bufgetc_u >= stream->__bufstart);
 426                 assert(stream->__bufgetc_u <= stream->__bufread);
 427 # endif
 428
 429 #endif
 430         }
 431
 432         if (__STDIO_STREAM_IS_WRITING(stream)) {
 433                 assert(!__STDIO_STREAM_IS_READING(stream));
 434 #ifdef __STDIO_BUFFERS
 435 # ifdef __UCLIBC_HAS_STDIO_PUTC_MACRO__
 436                 assert(stream->__bufputc_u >= stream->__bufstart);
 437                 assert(stream->__bufputc_u <= stream->__bufend);
 438 # endif
 439 #endif
 440         }
 441
 442         /* If have an ungotten char, then getc (and putc) must be disabled. */
 443         /* Also, wide streams must have the getc/putc macros disabled. */
 444         if ((stream->__modeflags & __FLAG_UNGOT)
 445                 || __STDIO_STREAM_IS_WIDE(stream)
 446                 ) {
 447 #ifdef __STDIO_BUFFERS
 448 # ifdef __UCLIBC_HAS_STDIO_PUTC_MACRO__
 449                 assert(stream->__bufputc_u == stream->__bufstart);
 450 # endif
 451 # ifdef __UCLIBC_HAS_STDIO_GETC_MACRO__
 452                 assert(stream->__bufgetc_u == stream->__bufstart);
 453 # endif
 454 #endif
 455         }
 456
 457         /* TODO -- filepos?  ungot_width?  filedes?  nextopen? */
 458 }
 459
 460 #endif