void _IO_un_link(struct _IO_FILE_plus *fp) { if (fp->file._flags & _IO_LINKED) { struct _IO_FILE_plus **f; #ifdef _IO_MTSAFE_IO _IO_cleanup_region_start_noarg (flush_cleanup); _IO_lock_lock (list_all_lock); run_fp = (_IO_FILE *) fp; _IO_flockfile ((_IO_FILE *) fp); #endif for (f = &INTUSE(_IO_list_all); *f; f = (struct _IO_FILE_plus **) &(*f)->file._chain) { if (*f == fp) { *f = (struct _IO_FILE_plus *) fp->file._chain; ++_IO_list_all_stamp; break; } } fp->file._flags &= ~_IO_LINKED; #ifdef _IO_MTSAFE_IO _IO_funlockfile ((_IO_FILE *) fp); run_fp = NULL; _IO_lock_unlock (list_all_lock); _IO_cleanup_region_end (0); #endif } }
int __vfxprintf (FILE *fp, const char *fmt, va_list ap, unsigned int mode_flags) { if (fp == NULL) fp = stderr; _IO_flockfile (fp); int res = locked_vfxprintf (fp, fmt, ap, mode_flags); _IO_funlockfile (fp); return res; }
int _IO_flush_all_lockp (int do_lock) { int result = 0; struct _IO_FILE *fp; int last_stamp; #ifdef _IO_MTSAFE_IO __libc_cleanup_region_start (do_lock, flush_cleanup, NULL); if (do_lock) _IO_lock_lock (list_all_lock); #endif last_stamp = _IO_list_all_stamp; fp = (_IO_FILE *) _IO_list_all; while (fp != NULL) { run_fp = fp; if (do_lock) _IO_flockfile (fp); if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base) #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T || (_IO_vtable_offset (fp) == 0 && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)) #endif ) && _IO_OVERFLOW (fp, EOF) == EOF) result = EOF; if (do_lock) _IO_funlockfile (fp); run_fp = NULL; if (last_stamp != _IO_list_all_stamp) { /* Something was added to the list. Start all over again. */ fp = (_IO_FILE *) _IO_list_all; last_stamp = _IO_list_all_stamp; } else fp = fp->_chain; } #ifdef _IO_MTSAFE_IO if (do_lock) _IO_lock_unlock (list_all_lock); __libc_cleanup_region_end (0); #endif return result; }
/* Write an entry to the given stream. This must know the format of the group file. */ int putsgent (const struct sgrp *g, FILE *stream) { int errors = 0; if (g->sg_namp == NULL || !__nss_valid_field (g->sg_namp) || !__nss_valid_field (g->sg_passwd) || !__nss_valid_list_field (g->sg_adm) || !__nss_valid_list_field (g->sg_mem)) { __set_errno (EINVAL); return -1; } _IO_flockfile (stream); if (fprintf (stream, "%s:%s:", g->sg_namp, _S (g->sg_passwd)) < 0) ++errors; bool first = true; char **sp = g->sg_adm; if (sp != NULL) while (*sp != NULL) { if (fprintf (stream, "%s%s", first ? "" : ",", *sp++) < 0) { ++errors; break; } first = false; } if (putc_unlocked (':', stream) == EOF) ++errors; first = true; sp = g->sg_mem; if (sp != NULL) while (*sp != NULL) { if (fprintf (stream, "%s%s", first ? "" : ",", *sp++) < 0) { ++errors; break; } first = false; } if (putc_unlocked ('\n', stream) == EOF) ++errors; _IO_funlockfile (stream); return errors ? -1 : 0; }
/* Write an entry to the given stream. This must know the format of the group file. */ int putsgent (const struct sgrp *g, FILE *stream) { int errors = 0; _IO_flockfile (stream); if (fprintf (stream, "%s:%s:", g->sg_namp, _S (g->sg_passwd)) < 0) ++errors; bool first = true; char **sp = g->sg_adm; if (sp != NULL) while (*sp != NULL) { if (fprintf (stream, "%s%s", first ? "" : ",", *sp++) < 0) { ++errors; break; } first = false; } if (putc_unlocked (':', stream) == EOF) ++errors; first = true; sp = g->sg_mem; if (sp != NULL) while (*sp != NULL) { if (fprintf (stream, "%s%s", first ? "" : ",", *sp++) < 0) { ++errors; break; } first = false; } if (putc_unlocked ('\n', stream) == EOF) ++errors; _IO_funlockfile (stream); return errors ? -1 : 0; }
int __fxprintf_nocancel (FILE *fp, const char *fmt, ...) { if (fp == NULL) fp = stderr; va_list ap; va_start (ap, fmt); _IO_flockfile (fp); int save_flags2 = fp->_flags2; fp->_flags2 |= _IO_FLAGS2_NOTCANCEL; int res = locked_vfxprintf (fp, fmt, ap, 0); fp->_flags2 = save_flags2; _IO_funlockfile (fp); va_end (ap); return res; }
/* Read one shadow entry from the given stream. */ int __fgetsgent_r (FILE *stream, struct sgrp *resbuf, char *buffer, size_t buflen, struct sgrp **result) { char *p; _IO_flockfile (stream); do { buffer[buflen - 1] = '\xff'; p = fgets_unlocked (buffer, buflen, stream); if (p == NULL && feof_unlocked (stream)) { _IO_funlockfile (stream); *result = NULL; __set_errno (ENOENT); return errno; } if (p == NULL || buffer[buflen - 1] != '\xff') { _IO_funlockfile (stream); *result = NULL; __set_errno (ERANGE); return errno; } /* Skip leading blanks. */ while (isspace (*p)) ++p; } while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */ /* Parse the line. If it is invalid, loop to get the next line of the file to parse. */ ! parse_line (buffer, (void *) resbuf, (void *) buffer, buflen, &errno)); _IO_funlockfile (stream); *result = resbuf; return 0; }
void _IO_flush_all_linebuffered (void) { struct _IO_FILE *fp; int last_stamp; #ifdef _IO_MTSAFE_IO _IO_cleanup_region_start_noarg (flush_cleanup); _IO_lock_lock (list_all_lock); #endif last_stamp = _IO_list_all_stamp; fp = (_IO_FILE *) _IO_list_all; while (fp != NULL) { run_fp = fp; _IO_flockfile (fp); if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF) _IO_OVERFLOW (fp, EOF); _IO_funlockfile (fp); run_fp = NULL; if (last_stamp != _IO_list_all_stamp) { /* Something was added to the list. Start all over again. */ fp = (_IO_FILE *) _IO_list_all; last_stamp = _IO_list_all_stamp; } else fp = fp->_chain; } #ifdef _IO_MTSAFE_IO _IO_lock_unlock (list_all_lock); _IO_cleanup_region_end (0); #endif }
void _IO_link_in (struct _IO_FILE_plus *fp) { if ((fp->file._flags & _IO_LINKED) == 0) { fp->file._flags |= _IO_LINKED; #ifdef _IO_MTSAFE_IO _IO_cleanup_region_start_noarg (flush_cleanup); _IO_lock_lock (list_all_lock); run_fp = (_IO_FILE *) fp; _IO_flockfile ((_IO_FILE *) fp); #endif fp->file._chain = (_IO_FILE *) _IO_list_all; _IO_list_all = fp; ++_IO_list_all_stamp; #ifdef _IO_MTSAFE_IO _IO_funlockfile ((_IO_FILE *) fp); run_fp = NULL; _IO_lock_unlock (list_all_lock); _IO_cleanup_region_end (0); #endif } }
void _IO_un_link (struct _IO_FILE_plus *fp) { if (fp->file._flags & _IO_LINKED) { struct _IO_FILE **f; #ifdef _IO_MTSAFE_IO _IO_cleanup_region_start_noarg (flush_cleanup); _IO_lock_lock (list_all_lock); run_fp = (_IO_FILE *) fp; _IO_flockfile ((_IO_FILE *) fp); #endif if (_IO_list_all == NULL) ; else if (fp == _IO_list_all) { _IO_list_all = (struct _IO_FILE_plus *) _IO_list_all->file._chain; ++_IO_list_all_stamp; } else for (f = &_IO_list_all->file._chain; *f; f = &(*f)->_chain) if (*f == (_IO_FILE *) fp) { *f = fp->file._chain; ++_IO_list_all_stamp; break; } fp->file._flags &= ~_IO_LINKED; #ifdef _IO_MTSAFE_IO _IO_funlockfile ((_IO_FILE *) fp); run_fp = NULL; _IO_lock_unlock (list_all_lock); _IO_cleanup_region_end (0); #endif } }
void public_mSTATs() { int i; mstate ar_ptr; struct malloc_global_info mgi; struct malloc_arena_info mai; unsigned long in_use_b, system_b, avail_b; #if defined(THREAD_STATS) && THREAD_STATS long stat_lock_direct = 0, stat_lock_loop = 0, stat_lock_wait = 0; #endif #if 0 if(__malloc_initialized < 0) ptmalloc_init (); #endif _int_get_global_info(&mgi); system_b = in_use_b = mgi.mmapped_mem; #ifdef _LIBC _IO_flockfile (stderr); int old_flags2 = ((_IO_FILE *) stderr)->_flags2; ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; #endif for (i=0; (ar_ptr = _int_get_arena(i)); i++) { _int_get_arena_info(ar_ptr, &mai); avail_b = mai.fastavail + mai.binavail + mai.top_size; fprintf(stderr, "Arena %d:\n", i); fprintf(stderr, "system bytes = %10lu\n", (unsigned long)mai.system_mem); fprintf(stderr, "in use bytes = %10lu\n", (unsigned long)(mai.system_mem - avail_b)); #if MALLOC_DEBUG > 1 if (i > 0) dump_heap(heap_for_ptr(top(ar_ptr))); #endif system_b += mai.system_mem; in_use_b += mai.system_mem - avail_b; #if defined(THREAD_STATS) && THREAD_STATS stat_lock_direct += mai.stat_lock_direct; stat_lock_loop += mai.stat_lock_loop; stat_lock_wait += mai.stat_lock_wait; #endif } #if HAVE_MMAP fprintf(stderr, "Total (incl. mmap):\n"); #else fprintf(stderr, "Total:\n"); #endif fprintf(stderr, "system bytes = %10lu\n", system_b); fprintf(stderr, "in use bytes = %10lu\n", in_use_b); #ifdef NO_THREADS fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)mgi.max_total_mem); #endif #if HAVE_MMAP fprintf(stderr, "max mmap regions = %10u\n", (unsigned int)mgi.max_n_mmaps); fprintf(stderr, "max mmap bytes = %10lu\n", (unsigned long)mgi.max_mmapped_mem); #endif #if defined(THREAD_STATS) && THREAD_STATS fprintf(stderr, "heaps created = %10d\n", mgi.stat_n_heaps); fprintf(stderr, "locked directly = %10ld\n", stat_lock_direct); fprintf(stderr, "locked in loop = %10ld\n", stat_lock_loop); fprintf(stderr, "locked waiting = %10ld\n", stat_lock_wait); fprintf(stderr, "locked total = %10ld\n", stat_lock_direct + stat_lock_loop + stat_lock_wait); #endif #ifdef _LIBC ((_IO_FILE *) stderr)->_flags2 |= old_flags2; _IO_funlockfile (stderr); #endif }