/*
|
* Copyright (C) 2007,2011 Jan Kiszka <jan.kiszka@web.de>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
|
#include <errno.h>
|
#include <inttypes.h>
|
#include <limits.h>
|
#include <pthread.h>
|
#include <signal.h>
|
#include <stdarg.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <unistd.h>
|
#include <syslog.h>
|
#include <boilerplate/atomic.h>
|
#include <boilerplate/compiler.h>
|
#include <cobalt/tunables.h>
|
#include <cobalt/sys/cobalt.h>
|
#include "internal.h"
|
|
#define RT_PRINT_DEFAULT_BUFFER 16*1024
|
#define RT_PRINT_DEFAULT_SYNCDELAY 100 /* ms */
|
#define RT_PRINT_DEFAULT_BUFFERS_COUNT 4
|
|
#define RT_PRINT_LINE_BREAK 256
|
|
#define RT_PRINT_SYSLOG_STREAM NULL
|
|
#define RT_PRINT_MODE_FORMAT 0
|
#define RT_PRINT_MODE_FWRITE 1
|
|
struct entry_head {
|
FILE *dest;
|
uint32_t seq_no;
|
int priority;
|
size_t len;
|
char data[0];
|
} __attribute__((packed));
|
|
struct print_buffer {
|
off_t write_pos;
|
|
struct print_buffer *next, *prev;
|
|
void *ring;
|
size_t size;
|
|
char name[32];
|
|
/*
|
* Keep read_pos separated from write_pos to optimise write
|
* caching on SMP.
|
*/
|
off_t read_pos;
|
};
|
|
__weak int __cobalt_print_bufsz = RT_PRINT_DEFAULT_BUFFER;
|
|
int __cobalt_print_bufcount = RT_PRINT_DEFAULT_BUFFERS_COUNT;
|
|
int __cobalt_print_syncdelay = RT_PRINT_DEFAULT_SYNCDELAY;
|
|
static struct print_buffer *first_buffer;
|
static int buffers;
|
static uint32_t seq_no;
|
static struct timespec syncdelay;
|
static pthread_mutex_t buffer_lock;
|
static pthread_cond_t printer_wakeup;
|
static pthread_key_t buffer_key;
|
static pthread_key_t cleanup_key;
|
static pthread_t printer_thread;
|
static atomic_long_t *pool_bitmap;
|
static unsigned pool_bitmap_len;
|
static unsigned pool_buf_size;
|
static unsigned long pool_start, pool_len;
|
|
static void release_buffer(struct print_buffer *buffer);
|
static void print_buffers(void);
|
|
/* *** rt_print API *** */
|
|
static int
|
vprint_to_buffer(FILE *stream, int fortify_level, int priority,
|
unsigned int mode, size_t sz, const char *format, va_list args)
|
{
|
struct print_buffer *buffer = pthread_getspecific(buffer_key);
|
off_t write_pos, read_pos;
|
struct entry_head *head;
|
int len, str_len;
|
int res = 0;
|
|
if (!buffer) {
|
res = rt_print_init(0, NULL);
|
if (res) {
|
errno = res;
|
return -1;
|
}
|
buffer = pthread_getspecific(buffer_key);
|
}
|
|
/* Take a snapshot of the ring buffer state */
|
write_pos = buffer->write_pos;
|
read_pos = buffer->read_pos;
|
smp_mb();
|
|
/* Is our write limit the end of the ring buffer? */
|
if (write_pos >= read_pos) {
|
/* Keep a safety margin to the end for at least an empty entry */
|
len = buffer->size - write_pos - sizeof(struct entry_head);
|
|
/* Special case: We were stuck at the end of the ring buffer
|
with space left there only for one empty entry. Now
|
read_pos was moved forward and we can wrap around. */
|
if (len == 0 && read_pos > sizeof(struct entry_head)) {
|
/* Write out empty entry */
|
head = buffer->ring + write_pos;
|
head->seq_no = seq_no;
|
head->priority = 0;
|
head->len = 0;
|
|
/* Forward to the ring buffer start */
|
write_pos = 0;
|
len = read_pos - 1;
|
}
|
} else {
|
/* Our limit is the read_pos ahead of our write_pos. One byte
|
margin is required to detect a full ring. */
|
len = read_pos - write_pos - 1;
|
}
|
|
/* Account for head length */
|
len -= sizeof(struct entry_head);
|
if (len < 0)
|
len = 0;
|
|
head = buffer->ring + write_pos;
|
|
if (mode == RT_PRINT_MODE_FORMAT) {
|
if (stream != RT_PRINT_SYSLOG_STREAM) {
|
/* We do not need the terminating \0 */
|
#ifdef CONFIG_XENO_FORTIFY
|
if (fortify_level > 0)
|
res = __vsnprintf_chk(head->data, len,
|
fortify_level - 1,
|
len > 0 ? len : 0,
|
format, args);
|
else
|
#else
|
(void)fortify_level;
|
#endif
|
res = vsnprintf(head->data, len, format, args);
|
|
if (res < len) {
|
/* Text was written completely, res contains its
|
length */
|
len = res;
|
} else {
|
/* Text was truncated */
|
res = len;
|
}
|
} else {
|
/* We DO need the terminating \0 */
|
#ifdef CONFIG_XENO_FORTIFY
|
if (fortify_level > 0)
|
res = __vsnprintf_chk(head->data, len,
|
fortify_level - 1,
|
len > 0 ? len : 0,
|
format, args);
|
else
|
#endif
|
res = vsnprintf(head->data, len, format, args);
|
|
if (res < len) {
|
/* Text was written completely, res contains its
|
length */
|
len = res + 1;
|
} else {
|
/* Text was truncated */
|
res = len;
|
}
|
}
|
} else if (len >= 1) {
|
str_len = sz;
|
len = (str_len < len) ? str_len : len;
|
memcpy(head->data, format, len);
|
} else
|
len = 0;
|
|
/* If we were able to write some text, finalise the entry */
|
if (len > 0) {
|
head->seq_no = ++seq_no;
|
head->priority = priority;
|
head->dest = stream;
|
head->len = len;
|
|
/* Move forward by text and head length */
|
write_pos += len + sizeof(struct entry_head);
|
}
|
|
/* Wrap around early if there is more space on the other side */
|
if (write_pos >= buffer->size - RT_PRINT_LINE_BREAK &&
|
read_pos <= write_pos && read_pos > buffer->size - write_pos) {
|
/* An empty entry marks the wrap-around */
|
head = buffer->ring + write_pos;
|
head->seq_no = seq_no;
|
head->priority = priority;
|
head->len = 0;
|
|
write_pos = 0;
|
}
|
|
/* All entry data must be written before we can update write_pos */
|
smp_wmb();
|
|
buffer->write_pos = write_pos;
|
|
return res;
|
}
|
|
static int print_to_buffer(FILE *stream, int priority, unsigned int mode,
|
size_t sz, const char *format, ...)
|
{
|
va_list args;
|
int ret;
|
|
va_start(args, format);
|
ret = vprint_to_buffer(stream, 0, priority, mode, sz, format, args);
|
va_end(args);
|
|
return ret;
|
}
|
|
int rt_vfprintf(FILE *stream, const char *format, va_list args)
|
{
|
return vprint_to_buffer(stream, 0, 0,
|
RT_PRINT_MODE_FORMAT, 0, format, args);
|
}
|
|
#ifdef CONFIG_XENO_FORTIFY
|
|
int __rt_vfprintf_chk(FILE *stream, int level, const char *fmt, va_list args)
|
{
|
return vprint_to_buffer(stream, level + 1, 0,
|
RT_PRINT_MODE_FORMAT, 0, fmt, args);
|
}
|
|
#endif
|
|
int rt_vprintf(const char *format, va_list args)
|
{
|
return rt_vfprintf(stdout, format, args);
|
}
|
|
int rt_fprintf(FILE *stream, const char *format, ...)
|
{
|
va_list args;
|
int n;
|
|
va_start(args, format);
|
n = rt_vfprintf(stream, format, args);
|
va_end(args);
|
|
return n;
|
}
|
|
int rt_printf(const char *format, ...)
|
{
|
va_list args;
|
int n;
|
|
va_start(args, format);
|
n = rt_vfprintf(stdout, format, args);
|
va_end(args);
|
|
return n;
|
}
|
|
int rt_fputs(const char *s, FILE *stream)
|
{
|
return print_to_buffer(stream, 0, RT_PRINT_MODE_FWRITE, strlen(s), s);
|
}
|
|
int rt_puts(const char *s)
|
{
|
int res;
|
|
res = rt_fputs(s, stdout);
|
if (res < 0)
|
return res;
|
|
return print_to_buffer(stdout, 0, RT_PRINT_MODE_FWRITE, 1, "\n");
|
}
|
|
int rt_fputc(int c, FILE *stream)
|
{
|
unsigned char uc = c;
|
int rc;
|
|
rc = print_to_buffer(stream, 0, RT_PRINT_MODE_FWRITE, 1, (char *)&uc);
|
if (rc < 0)
|
return EOF;
|
|
return (int)uc;
|
}
|
|
int rt_putchar(int c)
|
{
|
return rt_fputc(c, stdout);
|
}
|
|
size_t rt_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
|
{
|
print_to_buffer(stream, 0, RT_PRINT_MODE_FWRITE, size * nmemb, ptr);
|
return nmemb;
|
}
|
|
|
void rt_syslog(int priority, const char *format, ...)
|
{
|
va_list args;
|
|
va_start(args, format);
|
vprint_to_buffer(RT_PRINT_SYSLOG_STREAM, 0, priority,
|
RT_PRINT_MODE_FORMAT, 0, format, args);
|
va_end(args);
|
}
|
|
void rt_vsyslog(int priority, const char *format, va_list args)
|
{
|
vprint_to_buffer(RT_PRINT_SYSLOG_STREAM, 0, priority,
|
RT_PRINT_MODE_FORMAT, 0, format, args);
|
}
|
|
#ifdef CONFIG_XENO_FORTIFY
|
|
void __rt_vsyslog_chk(int priority, int level, const char *fmt, va_list args)
|
{
|
vprint_to_buffer(RT_PRINT_SYSLOG_STREAM, level + 1, priority,
|
RT_PRINT_MODE_FORMAT, 0, fmt, args);
|
}
|
|
#endif
|
|
static void set_buffer_name(struct print_buffer *buffer, const char *name)
|
{
|
int n;
|
|
n = sprintf(buffer->name, "%08lx", (unsigned long)pthread_self());
|
if (name) {
|
buffer->name[n++] = ' ';
|
strncpy(buffer->name+n, name, sizeof(buffer->name)-n-1);
|
buffer->name[sizeof(buffer->name)-1] = 0;
|
}
|
}
|
|
static void rt_print_init_inner(struct print_buffer *buffer, size_t size)
|
{
|
buffer->size = size;
|
|
memset(buffer->ring, 0, size);
|
|
buffer->read_pos = 0;
|
buffer->write_pos = 0;
|
|
buffer->prev = NULL;
|
|
pthread_mutex_lock(&buffer_lock);
|
|
buffer->next = first_buffer;
|
if (first_buffer)
|
first_buffer->prev = buffer;
|
first_buffer = buffer;
|
|
buffers++;
|
pthread_cond_signal(&printer_wakeup);
|
|
pthread_mutex_unlock(&buffer_lock);
|
}
|
|
int rt_print_init(size_t buffer_size, const char *buffer_name)
|
{
|
struct print_buffer *buffer = pthread_getspecific(buffer_key);
|
size_t size = buffer_size;
|
unsigned long old_bitmap;
|
unsigned j;
|
|
if (!size)
|
size = __cobalt_print_bufsz;
|
else if (size < RT_PRINT_LINE_BREAK)
|
return EINVAL;
|
|
if (buffer) {
|
/* Only set name if buffer size is unchanged or default */
|
if (size == buffer->size || !buffer_size) {
|
set_buffer_name(buffer, buffer_name);
|
return 0;
|
}
|
release_buffer(buffer);
|
buffer = NULL;
|
}
|
|
/* Find a free buffer in the pool */
|
do {
|
unsigned long bitmap;
|
unsigned i;
|
|
for (i = 0; i < pool_bitmap_len; i++) {
|
old_bitmap = atomic_long_read(&pool_bitmap[i]);
|
if (old_bitmap)
|
goto acquire;
|
}
|
|
goto not_found;
|
|
acquire:
|
do {
|
bitmap = old_bitmap;
|
j = __builtin_ffsl(bitmap) - 1;
|
old_bitmap = atomic_cmpxchg(&pool_bitmap[i],
|
bitmap,
|
bitmap & ~(1UL << j));
|
} while (old_bitmap != bitmap && old_bitmap);
|
j += i * LONG_BIT;
|
} while (!old_bitmap);
|
|
buffer = (struct print_buffer *)(pool_start + j * pool_buf_size);
|
|
not_found:
|
|
if (!buffer) {
|
cobalt_assert_nrt();
|
|
buffer = malloc(sizeof(*buffer));
|
if (!buffer)
|
return ENOMEM;
|
|
buffer->ring = malloc(size);
|
if (!buffer->ring)
|
return ENOMEM;
|
|
rt_print_init_inner(buffer, size);
|
}
|
|
set_buffer_name(buffer, buffer_name);
|
|
pthread_setspecific(buffer_key, buffer);
|
|
return 0;
|
}
|
|
const char *rt_print_buffer_name(void)
|
{
|
struct print_buffer *buffer = pthread_getspecific(buffer_key);
|
int res;
|
|
if (!buffer) {
|
res = rt_print_init(0, NULL);
|
if (res)
|
return NULL;
|
|
buffer = pthread_getspecific(buffer_key);
|
}
|
|
return buffer->name;
|
}
|
|
/* *** Deferred Output Management *** */
|
void rt_print_flush_buffers(void)
|
{
|
cobalt_thread_relax();
|
pthread_mutex_lock(&buffer_lock);
|
print_buffers();
|
pthread_mutex_unlock(&buffer_lock);
|
}
|
|
static void release_buffer(struct print_buffer *buffer)
|
{
|
struct print_buffer *prev, *next;
|
unsigned long old_bitmap, bitmap;
|
unsigned int i, j;
|
|
cobalt_assert_nrt();
|
|
pthread_setspecific(buffer_key, NULL);
|
|
pthread_mutex_lock(&buffer_lock);
|
|
print_buffers();
|
|
pthread_mutex_unlock(&buffer_lock);
|
|
/* Return the buffer to the pool */
|
if ((unsigned long)buffer - pool_start >= pool_len)
|
goto dofree;
|
|
j = ((unsigned long)buffer - pool_start) / pool_buf_size;
|
i = j / LONG_BIT;
|
j = j % LONG_BIT;
|
|
old_bitmap = atomic_long_read(&pool_bitmap[i]);
|
do {
|
bitmap = old_bitmap;
|
old_bitmap = atomic_cmpxchg(&pool_bitmap[i],
|
bitmap,
|
bitmap | (1UL << j));
|
} while (old_bitmap != bitmap);
|
|
return;
|
dofree:
|
pthread_mutex_lock(&buffer_lock);
|
|
prev = buffer->prev;
|
next = buffer->next;
|
|
if (prev)
|
prev->next = next;
|
else
|
first_buffer = next;
|
if (next)
|
next->prev = prev;
|
|
buffers--;
|
|
pthread_mutex_unlock(&buffer_lock);
|
|
free(buffer->ring);
|
free(buffer);
|
}
|
|
static void do_cleanup(void *arg)
|
{
|
struct print_buffer *buffer = pthread_getspecific(buffer_key);
|
|
if (buffer)
|
release_buffer(buffer);
|
|
pthread_cancel(printer_thread);
|
}
|
|
static inline uint32_t get_next_seq_no(struct print_buffer *buffer)
|
{
|
struct entry_head *head = buffer->ring + buffer->read_pos;
|
return head->seq_no;
|
}
|
|
static struct print_buffer *get_next_buffer(void)
|
{
|
struct print_buffer *pos = first_buffer;
|
struct print_buffer *buffer = NULL;
|
uint32_t next_seq_no = 0; /* silence gcc... */
|
|
while (pos) {
|
if (pos->read_pos != pos->write_pos &&
|
(!buffer || get_next_seq_no(pos) < next_seq_no)) {
|
buffer = pos;
|
next_seq_no = get_next_seq_no(pos);
|
}
|
pos = pos->next;
|
}
|
|
return buffer;
|
}
|
|
static void print_buffers(void)
|
{
|
struct print_buffer *buffer;
|
struct entry_head *head;
|
off_t read_pos;
|
int len, ret;
|
|
while (1) {
|
buffer = get_next_buffer();
|
if (!buffer)
|
break;
|
|
read_pos = buffer->read_pos;
|
head = buffer->ring + read_pos;
|
len = head->len;
|
|
if (len) {
|
/* Print out non-empty entry and proceed */
|
/* Check if output goes to syslog */
|
if (head->dest == RT_PRINT_SYSLOG_STREAM) {
|
syslog(head->priority,
|
"%s", head->data);
|
} else {
|
ret = fwrite(head->data,
|
head->len, 1, head->dest);
|
(void)ret;
|
}
|
|
read_pos += sizeof(*head) + len;
|
} else {
|
/* Emptry entries mark the wrap-around */
|
read_pos = 0;
|
}
|
|
/* Make sure we have read the entry competely before
|
forwarding read_pos */
|
smp_rmb();
|
buffer->read_pos = read_pos;
|
|
/* Enforce the read_pos update before proceeding */
|
smp_wmb();
|
}
|
}
|
|
static void *printer_loop(void *arg)
|
{
|
while (1) {
|
pthread_mutex_lock(&buffer_lock);
|
|
while (buffers == 0)
|
pthread_cond_wait(&printer_wakeup, &buffer_lock);
|
|
print_buffers();
|
|
pthread_mutex_unlock(&buffer_lock);
|
|
nanosleep(&syncdelay, NULL);
|
}
|
|
return NULL;
|
}
|
|
static void spawn_printer_thread(void)
|
{
|
pthread_attr_t thattr;
|
sigset_t sset, oset;
|
|
pthread_attr_init(&thattr);
|
sigfillset(&sset);
|
pthread_sigmask(SIG_BLOCK, &sset, &oset);
|
pthread_create(&printer_thread, &thattr, printer_loop, NULL);
|
pthread_sigmask(SIG_SETMASK, &oset, NULL);
|
pthread_setname_np(printer_thread, "cobalt_printf");
|
}
|
|
void cobalt_print_init_atfork(void)
|
{
|
struct print_buffer *my_buffer = pthread_getspecific(buffer_key);
|
struct print_buffer **pbuffer = &first_buffer;
|
|
if (my_buffer) {
|
/* Any content of my_buffer should be printed by our parent,
|
not us. */
|
memset(my_buffer->ring, 0, my_buffer->size);
|
|
my_buffer->read_pos = 0;
|
my_buffer->write_pos = 0;
|
}
|
|
/* re-init to avoid finding it locked by some parent thread */
|
pthread_mutex_init(&buffer_lock, NULL);
|
|
while (*pbuffer) {
|
if (*pbuffer == my_buffer)
|
pbuffer = &(*pbuffer)->next;
|
else if ((unsigned long)*pbuffer - pool_start < pool_len) {
|
release_buffer(*pbuffer);
|
pbuffer = &(*pbuffer)->next;
|
}
|
else
|
release_buffer(*pbuffer);
|
}
|
|
spawn_printer_thread();
|
}
|
|
void cobalt_print_init(void)
|
{
|
unsigned int i;
|
|
first_buffer = NULL;
|
seq_no = 0;
|
|
syncdelay.tv_sec = __cobalt_print_syncdelay / 1000;
|
syncdelay.tv_nsec = (__cobalt_print_syncdelay % 1000) * 1000000;
|
|
/* Fill the buffer pool */
|
pool_bitmap_len = (__cobalt_print_bufcount+LONG_BIT-1)/LONG_BIT;
|
if (!pool_bitmap_len)
|
goto done;
|
|
pool_bitmap = malloc(pool_bitmap_len * sizeof(*pool_bitmap));
|
if (!pool_bitmap)
|
early_panic("error allocating print relay buffers");
|
|
pool_buf_size = sizeof(struct print_buffer) + __cobalt_print_bufsz;
|
pool_len = __cobalt_print_bufcount * pool_buf_size;
|
pool_start = (unsigned long)malloc(pool_len);
|
if (!pool_start)
|
early_panic("error allocating print relay buffers");
|
|
for (i = 0; i < __cobalt_print_bufcount / LONG_BIT; i++)
|
atomic_long_set(&pool_bitmap[i], ~0UL);
|
if (__cobalt_print_bufcount % LONG_BIT)
|
atomic_long_set(&pool_bitmap[i],
|
(1UL << (__cobalt_print_bufcount % LONG_BIT)) - 1);
|
|
for (i = 0; i < __cobalt_print_bufcount; i++) {
|
struct print_buffer *buffer =
|
(struct print_buffer *)
|
(pool_start + i * pool_buf_size);
|
|
buffer->ring = (char *)(buffer + 1);
|
|
rt_print_init_inner(buffer, __cobalt_print_bufsz);
|
}
|
done:
|
pthread_mutex_init(&buffer_lock, NULL);
|
pthread_key_create(&buffer_key, (void (*)(void*))release_buffer);
|
pthread_key_create(&cleanup_key, do_cleanup);
|
pthread_cond_init(&printer_wakeup, NULL);
|
spawn_printer_thread();
|
/* We just need a non-zero TSD to trigger the dtor upon unwinding. */
|
pthread_setspecific(cleanup_key, &cleanup_key);
|
|
atexit(rt_print_flush_buffers);
|
}
|
|
COBALT_IMPL(int, vfprintf, (FILE *stream, const char *fmt, va_list args))
|
{
|
if (!cobalt_is_relaxed())
|
return rt_vfprintf(stream, fmt, args);
|
else {
|
rt_print_flush_buffers();
|
return __STD(vfprintf(stream, fmt, args));
|
}
|
}
|
|
COBALT_IMPL(int, vprintf, (const char *fmt, va_list args))
|
{
|
return __COBALT(vfprintf(stdout, fmt, args));
|
}
|
|
COBALT_IMPL(int, fprintf, (FILE *stream, const char *fmt, ...))
|
{
|
va_list args;
|
int rc;
|
|
va_start(args, fmt);
|
rc = __COBALT(vfprintf(stream, fmt, args));
|
va_end(args);
|
|
return rc;
|
}
|
|
COBALT_IMPL(int, printf, (const char *fmt, ...))
|
{
|
va_list args;
|
int rc;
|
|
va_start(args, fmt);
|
rc = __COBALT(vfprintf(stdout, fmt, args));
|
va_end(args);
|
|
return rc;
|
}
|
|
COBALT_IMPL(int, fputs, (const char *s, FILE *stream))
|
{
|
if (!cobalt_is_relaxed())
|
return rt_fputs(s, stream);
|
else {
|
rt_print_flush_buffers();
|
return __STD(fputs(s, stream));
|
}
|
}
|
|
COBALT_IMPL(int, puts, (const char *s))
|
{
|
if (!cobalt_is_relaxed())
|
return rt_puts(s);
|
else {
|
rt_print_flush_buffers();
|
return __STD(puts(s));
|
}
|
}
|
|
COBALT_IMPL(int, fputc, (int c, FILE *stream))
|
{
|
if (!cobalt_is_relaxed())
|
return rt_fputc(c, stream);
|
else {
|
rt_print_flush_buffers();
|
return __STD(fputc(c, stream));
|
}
|
}
|
|
COBALT_IMPL(int, putchar, (int c))
|
{
|
if (!cobalt_is_relaxed())
|
return rt_putchar(c);
|
else {
|
rt_print_flush_buffers();
|
return __STD(putchar(c));
|
}
|
}
|
|
COBALT_IMPL(size_t, fwrite, (const void *ptr, size_t size, size_t nmemb, FILE *stream))
|
{
|
if (!cobalt_is_relaxed())
|
return rt_fwrite(ptr, size, nmemb, stream);
|
else {
|
rt_print_flush_buffers();
|
return __STD(fwrite(ptr, size, nmemb, stream));
|
}
|
|
}
|
|
COBALT_IMPL(int, fclose, (FILE *stream))
|
{
|
rt_print_flush_buffers();
|
return __STD(fclose(stream));
|
}
|
|
COBALT_IMPL(void, vsyslog, (int priority, const char *fmt, va_list ap))
|
{
|
if (!cobalt_is_relaxed())
|
return rt_vsyslog(priority, fmt, ap);
|
else {
|
rt_print_flush_buffers();
|
__STD(vsyslog(priority, fmt, ap));
|
}
|
}
|
|
COBALT_IMPL(void, syslog, (int priority, const char *fmt, ...))
|
{
|
va_list args;
|
|
va_start(args, fmt);
|
__COBALT(vsyslog(priority, fmt, args));
|
va_end(args);
|
}
|
|
/*
|
* Checked versions for -D_FORTIFY_SOURCE
|
*/
|
COBALT_IMPL(int, __vfprintf_chk, (FILE *f, int flag, const char *fmt, va_list ap))
|
{
|
#ifdef CONFIG_XENO_FORTIFY
|
if (!cobalt_is_relaxed())
|
return __rt_vfprintf_chk(f, flag, fmt, ap);
|
else {
|
rt_print_flush_buffers();
|
return __STD(__vfprintf_chk(f, flag, fmt, ap));
|
}
|
#else
|
panic("--enable-fortify is required with applications enabling _FORTIFY_SOURCE");
|
#endif
|
}
|
|
COBALT_IMPL(int, __vprintf_chk, (int flag, const char *fmt, va_list ap))
|
{
|
return __COBALT(__vfprintf_chk(stdout, flag, fmt, ap));
|
}
|
|
COBALT_IMPL(int, __fprintf_chk, (FILE *f, int flag, const char *fmt, ...))
|
{
|
va_list args;
|
int ret;
|
|
va_start(args, fmt);
|
ret = __COBALT(__vfprintf_chk(f, flag, fmt, args));
|
va_end(args);
|
|
return ret;
|
}
|
|
COBALT_IMPL(int, __printf_chk, (int flag, const char *fmt, ...))
|
{
|
va_list args;
|
int ret;
|
|
va_start(args, fmt);
|
ret = __COBALT(__vprintf_chk(flag, fmt, args));
|
va_end(args);
|
|
return ret;
|
}
|
|
COBALT_IMPL(void, __vsyslog_chk, (int pri, int flag, const char *fmt, va_list ap))
|
{
|
#ifdef CONFIG_XENO_FORTIFY
|
if (!cobalt_is_relaxed())
|
return __rt_vsyslog_chk(pri, flag, fmt, ap);
|
else {
|
rt_print_flush_buffers();
|
__STD(__vsyslog_chk(pri, flag, fmt, ap));
|
}
|
#else
|
panic("--enable-fortify is required with applications enabling _FORTIFY_SOURCE");
|
#endif
|
}
|
|
COBALT_IMPL(void, __syslog_chk, (int pri, int flag, const char *fmt, ...))
|
{
|
va_list args;
|
|
va_start(args, fmt);
|
__COBALT(__vsyslog_chk(pri, flag, fmt, args));
|
va_end(args);
|
}
|
