release/src/router/busybox/sysklogd/logread.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * circular buffer syslog implementation for busybox
   4  *
   5  * Copyright (C) 2000 by Gennady Feldman <gfeldman@gena01.com>
   6  *
   7  * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001
   8  *
   9  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  10  */
  11
  12 //usage:#define logread_trivial_usage
  13 //usage:       "[-f]"
  14 //usage:#define logread_full_usage "\n\n"
  15 //usage:       "Show messages in syslogd's circular buffer\n"
  16 //usage:     "\n        -f      Output data as log grows"
  17
  18 #include "libbb.h"
  19 #include <sys/ipc.h>
  20 #include <sys/sem.h>
  21 #include <sys/shm.h>
  22
  23 #define DEBUG 0
  24
  25 /* our shared key (syslogd.c and logread.c must be in sync) */
  26 enum { KEY_ID = 0x414e4547 }; /* "GENA" */
  27
  28 struct shbuf_ds {
  29         int32_t size;           // size of data - 1
  30         int32_t tail;           // end of message list
  31         char data[1];           // messages
  32 };
  33
  34 static const struct sembuf init_sem[3] = {
  35         {0, -1, IPC_NOWAIT | SEM_UNDO},
  36         {1, 0}, {0, +1, SEM_UNDO}
  37 };
  38
  39 struct globals {
  40         struct sembuf SMrup[1]; // {0, -1, IPC_NOWAIT | SEM_UNDO},
  41         struct sembuf SMrdn[2]; // {1, 0}, {0, +1, SEM_UNDO}
  42         struct shbuf_ds *shbuf;
  43 } FIX_ALIASING;
  44 #define G (*(struct globals*)&bb_common_bufsiz1)
  45 #define SMrup (G.SMrup)
  46 #define SMrdn (G.SMrdn)
  47 #define shbuf (G.shbuf)
  48 #define INIT_G() do { \
  49         memcpy(SMrup, init_sem, sizeof(init_sem)); \
  50 } while (0)
  51
  52 #if 0
  53 static void error_exit(const char *str) NORETURN;
  54 static void error_exit(const char *str)
  55 {
  56         /* Release all acquired resources */
  57         shmdt(shbuf);
  58         bb_perror_msg_and_die(str);
  59 }
  60 #else
  61 /* On Linux, shmdt is not mandatory on exit */
  62 # define error_exit(str) bb_perror_msg_and_die(str)
  63 #endif
  64
  65 /*
  66  * sem_up - up()'s a semaphore.
  67  */
  68 static void sem_up(int semid)
  69 {
  70         if (semop(semid, SMrup, 1) == -1)
  71                 error_exit("semop[SMrup]");
  72 }
  73
  74 static void interrupted(int sig)
  75 {
  76         /* shmdt(shbuf); - on Linux, shmdt is not mandatory on exit */
  77         kill_myself_with_sig(sig);
  78 }
  79
  80 int logread_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  81 int logread_main(int argc UNUSED_PARAM, char **argv)
  82 {
  83         unsigned cur;
  84         int log_semid; /* ipc semaphore id */
  85         int log_shmid; /* ipc shared memory id */
  86         smallint follow = getopt32(argv, "f");
  87
  88         INIT_G();
  89
  90         log_shmid = shmget(KEY_ID, 0, 0);
  91         if (log_shmid == -1)
  92                 bb_perror_msg_and_die("can't %s syslogd buffer", "find");
  93
  94         /* Attach shared memory to our char* */
  95         shbuf = shmat(log_shmid, NULL, SHM_RDONLY);
  96         if (shbuf == NULL)
  97                 bb_perror_msg_and_die("can't %s syslogd buffer", "access");
  98
  99         log_semid = semget(KEY_ID, 0, 0);
 100         if (log_semid == -1)
 101                 error_exit("can't get access to semaphores for syslogd buffer");
 102
 103         bb_signals(BB_FATAL_SIGS, interrupted);
 104
 105         /* Suppose atomic memory read */
 106         /* Max possible value for tail is shbuf->size - 1 */
 107         cur = shbuf->tail;
 108
 109         /* Loop for logread -f, one pass if there was no -f */
 110         do {
 111                 unsigned shbuf_size;
 112                 unsigned shbuf_tail;
 113                 const char *shbuf_data;
 114 #if ENABLE_FEATURE_LOGREAD_REDUCED_LOCKING
 115                 int i;
 116                 int len_first_part;
 117                 int len_total = len_total; /* for gcc */
 118                 char *copy = copy; /* for gcc */
 119 #endif
 120                 if (semop(log_semid, SMrdn, 2) == -1)
 121                         error_exit("semop[SMrdn]");
 122
 123                 /* Copy the info, helps gcc to realize that it doesn't change */
 124                 shbuf_size = shbuf->size;
 125                 shbuf_tail = shbuf->tail;
 126                 shbuf_data = shbuf->data; /* pointer! */
 127
 128                 if (DEBUG)
 129                         printf("cur:%u tail:%u size:%u\n",
 130                                         cur, shbuf_tail, shbuf_size);
 131
 132                 if (!follow) {
 133                         /* advance to oldest complete message */
 134                         /* find NUL */
 135                         cur += strlen(shbuf_data + cur);
 136                         if (cur >= shbuf_size) { /* last byte in buffer? */
 137                                 cur = strnlen(shbuf_data, shbuf_tail);
 138                                 if (cur == shbuf_tail)
 139                                         goto unlock; /* no complete messages */
 140                         }
 141                         /* advance to first byte of the message */
 142                         cur++;
 143                         if (cur >= shbuf_size) /* last byte in buffer? */
 144                                 cur = 0;
 145                 } else { /* logread -f */
 146                         if (cur == shbuf_tail) {
 147                                 sem_up(log_semid);
 148                                 fflush_all();
 149                                 sleep(1); /* TODO: replace me with a sleep_on */
 150                                 continue;
 151                         }
 152                 }
 153
 154                 /* Read from cur to tail */
 155 #if ENABLE_FEATURE_LOGREAD_REDUCED_LOCKING
 156                 len_first_part = len_total = shbuf_tail - cur;
 157                 if (len_total < 0) {
 158                         /* message wraps: */
 159                         /* [SECOND PART.........FIRST PART] */
 160                         /*  ^data      ^tail    ^cur      ^size */
 161                         len_total += shbuf_size;
 162                 }
 163                 copy = xmalloc(len_total + 1);
 164                 if (len_first_part < 0) {
 165                         /* message wraps (see above) */
 166                         len_first_part = shbuf_size - cur;
 167                         memcpy(copy + len_first_part, shbuf_data, shbuf_tail);
 168                 }
 169                 memcpy(copy, shbuf_data + cur, len_first_part);
 170                 copy[len_total] = '\0';
 171                 cur = shbuf_tail;
 172 #else
 173                 while (cur != shbuf_tail) {
 174                         fputs(shbuf_data + cur, stdout);
 175                         cur += strlen(shbuf_data + cur) + 1;
 176                         if (cur >= shbuf_size)
 177                                 cur = 0;
 178                 }
 179 #endif
 180  unlock:
 181                 /* release the lock on the log chain */
 182                 sem_up(log_semid);
 183
 184 #if ENABLE_FEATURE_LOGREAD_REDUCED_LOCKING
 185                 for (i = 0; i < len_total; i += strlen(copy + i) + 1) {
 186                         fputs(copy + i, stdout);
 187                 }
 188                 free(copy);
 189 #endif
 190                 fflush_all();
 191         } while (follow);
 192
 193         /* shmdt(shbuf); - on Linux, shmdt is not mandatory on exit */
 194
 195         fflush_stdout_and_exit(EXIT_SUCCESS);
 196 }