_stdio.c 13 KB

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