-------- Original Message --------
Subject: Re: :: rt_printf with daemonized task (09-Okt-2009 15:49)
From:    Gilles Chanteperdrix <[email protected]>
To:      [email protected]

> [email protected] wrote:
> > +#define RT_PRINT_SYSLOG_STREAM     ((FILE *)-9999)
> 
> -9999 may be a valid pointer. Only values between -4096 and 4095 can not
> be valid pointers.
> 
> -- 
>                                           Gilles
> 

ok, did change it to -99.



Oliver



--- rt_print.c.original 2008-09-10 10:36:27.000000000 +0200
+++ rt_print.c  2009-10-09 15:52:07.404908000 +0200
                 
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <syslog.h>
 
 #include <rtdk.h>
 #include <asm/xenomai/system.h>
                  
 
 #define RT_PRINT_LINE_BREAK            256
 
+#define RT_PRINT_SYSLOG_STREAM ((FILE *)-99)
+
 struct entry_head {
        FILE *dest;
        uint32_t seq_no;
+       int priority;
        char text[1];
 } __attribute__((packed));
 
                   
 
 static void cleanup_buffer(struct print_buffer *buffer);
 static void print_buffers(void);
+static void rt_print_reinit_atfork_prepare(void);
+static void rt_print_reinit_atfork_child(void);
 
 /* *** rt_print API *** */
 
-int rt_vfprintf(FILE *stream, const char *format, va_list args)
+static int rt_print_to_buffer(FILE *stream, int priority, const char *format, 
va_list args)
 {
        struct print_buffer *buffer = pthread_getspecific(__buffer_key);
        off_t write_pos, read_pos;
                   
                        /* Write out empty entry */
                        head = buffer->ring + write_pos;
                        head->seq_no = __seq_no;
+                       head->priority = 0;
                        head->text[0] = 0;
 
                        /* Forward to the ring buffer start */
                   
        /* 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;
 
                /* Move forward by text and head length */
                   
                /* An empty entry marks the wrap-around */
                head = buffer->ring + write_pos;
                head->seq_no = __seq_no;
+               head->priority = priority;
                head->text[0] = 0;
 
                write_pos = 0;
                    
        return res;
 }
 
+int rt_vfprintf(FILE *stream, const char *format, va_list args)
+{
+       return rt_print_to_buffer( stream, 0, format, args);
+}
+
 int rt_vprintf(const char *format, va_list args)
 {
        return rt_vfprintf(stdout, format, args);
                    
        return n;
 }
 
+void rt_syslog(int priority, char *format, ...)
+{
+       va_list args;
+
+       va_start(args, format);
+       rt_print_to_buffer(RT_PRINT_SYSLOG_STREAM, priority, format, args);
+       va_end(args);
+
+       return;
+}
+
+void rt_vsyslog(int priority, char *format, va_list args )
+{
+
+       rt_print_to_buffer(RT_PRINT_SYSLOG_STREAM, priority, format, args);
+
+       return;
+}
+
 static void set_buffer_name(struct print_buffer *buffer, const char *name)
 {
        int n;
                    
 
                if (len) {
                        /* Print out non-empty entry and proceed */
-                       fprintf(head->dest, "%s", head->text);
+                       /* Check if output goes to syslog */
+                       if (head->dest == RT_PRINT_SYSLOG_STREAM) {
+                               syslog( head->priority, "%s", head->text );
+                       } else {
+                               /* Output goes to specified stream */
+                               fprintf(head->dest, "%s", head->text);
+                       }
+
                        read_pos += sizeof(*head) + len;
                } else {
                        /* Emptry entries mark the wrap-around */
                    
        }
 }
 
+static void rt_print_reinit_atfork_child(void)
+{
+       pthread_attr_t thattr;
+       struct print_buffer *buffer,*next_b;
+
+       /* Clean parent process buffer list -
+          Shouldn't be necessary because also done at atfork_parent
+       */
+       buffer = __first_buffer;
+       while (buffer) {
+               next_b = buffer->next;
+               cleanup_buffer(buffer);
+               buffer = next_b;
+       }
+
+       /* Throw new thread with printer loop in child process */
+       pthread_attr_init(&thattr);
+       pthread_attr_setstacksize(&thattr, PTHREAD_STACK_MIN);
+       pthread_create(&__printer_thread, &thattr, printer_loop, NULL);
+       
pthread_atfork(rt_print_reinit_atfork_prepare,NULL,rt_print_reinit_atfork_child);
+}
+
+static void rt_print_reinit_atfork_prepare(void)
+{
+       struct print_buffer *buffer,*next_b;
+
+       /* Clean parent process buffer list */
+       buffer = __first_buffer;
+       while (buffer) {
+               next_b = buffer->next;
+               cleanup_buffer(buffer);
+               buffer = next_b;
+       }
+}
+
 void __rt_print_init(void)
 {
        pthread_attr_t thattr;
                   
        pthread_attr_init(&thattr);
        pthread_attr_setstacksize(&thattr, PTHREAD_STACK_MIN);
        pthread_create(&__printer_thread, &thattr, printer_loop, NULL);
+       
pthread_atfork(rt_print_reinit_atfork_prepare,NULL,rt_print_reinit_atfork_child);
 } 

To: [email protected]
Cc: [email protected]
    [email protected]
_______________________________________________
Xenomai-help mailing list
[email protected]
https://mail.gna.org/listinfo/xenomai-help

Reply via email to