src/logutil/logutil.c

   1 /*
   2  * Copyright (c) 2005-2008, The Android Open Source Project
   3  * Copyright (c) 2009-2013, Samsung Electronics Co., Ltd. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #define _GNU_SOURCE
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <stdbool.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <time.h>
  27 #include <sys/time.h>
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <assert.h>
  31 #include <sys/stat.h>
  32 #include <arpa/inet.h>
  33
  34
  35 #include <logger.h>
  36 #include <logprint.h>
  37
  38 #define DEFAULT_LOG_ROTATE_SIZE_KBYTES 16
  39 #define DEFAULT_MAX_ROTATED_LOGS 4
  40
  41 #define LOG_FILE_DIR    "/dev/log_"
  42
  43 static log_format* g_logformat;
  44 static bool g_nonblock = false;
  45 static int g_tail_lines = 0;
  46
  47 static const char * g_output_filename = NULL;
  48 static int g_log_rotate_size_kbytes = 0;                   // 0 means "no log rotation"
  49 static int g_max_rotated_logs = DEFAULT_MAX_ROTATED_LOGS; // 0 means "unbounded"
  50 static int g_outfd = -1;
  51 static off_t g_out_byte_count = 0;
  52 static int g_dev_count = 0;
  53
  54 struct queued_entry_t {
  55         union {
  56                 unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1] __attribute__((aligned(4)));
  57                 struct logger_entry entry __attribute__((aligned(4)));
  58         };
  59         struct queued_entry_t* next;
  60 };
  61
  62 static int cmp(struct queued_entry_t* a, struct queued_entry_t* b)
  63 {
  64         int n = a->entry.sec - b->entry.sec;
  65         if (n != 0)
  66         {
  67                 return n;
  68         }
  69         return a->entry.nsec - b->entry.nsec;
  70 }
  71
  72
  73 struct log_device_t {
  74         char* device;
  75         int fd;
  76         bool printed;
  77         struct queued_entry_t* queue;
  78         struct log_device_t* next;
  79 };
  80
  81 static void enqueue(struct log_device_t* device, struct queued_entry_t* entry)
  82 {
  83         if( device->queue == NULL)
  84         {
  85                 device->queue = entry;
  86         }
  87         else
  88         {
  89                 struct queued_entry_t** e = &device->queue;
  90                 while(*e && cmp(entry, *e) >= 0 )
  91                 {
  92                         e = &((*e)->next);
  93                 }
  94                 entry->next = *e;
  95                 *e = entry;
  96     }
  97 }
  98
  99 static int open_logfile (const char *pathname)
 100 {
 101     return open(pathname, O_WRONLY | O_APPEND | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
 102 }
 103
 104 static void rotate_logs()
 105 {
 106     int err;
 107         int i;
 108         char file0[256]={0};
 109         char file1[256]={0};
 110
 111     // Can't rotate logs if we're not outputting to a file
 112     if (g_output_filename == NULL) {
 113         return;
 114     }
 115
 116     close(g_outfd);
 117
 118     for (i = g_max_rotated_logs ; i > 0 ; i--)
 119         {
 120                 snprintf(file1, 255, "%s.%d", g_output_filename, i);
 121
 122                 if (i - 1 == 0) {
 123                         snprintf(file0, 255, "%s", g_output_filename);
 124                 } else {
 125                         snprintf(file0, 255, "%s.%d", g_output_filename, i - 1);
 126                 }
 127
 128                 err = rename (file0, file1);
 129
 130                 if (err < 0 && errno != ENOENT) {
 131                         perror("while rotating log files");
 132                 }
 133     }
 134
 135     g_outfd = open_logfile (g_output_filename);
 136
 137     if (g_outfd < 0) {
 138         perror ("couldn't open output file");
 139         exit(-1);
 140     }
 141
 142     g_out_byte_count = 0;
 143
 144 }
 145
 146
 147 static void processBuffer(struct log_device_t* dev, struct logger_entry *buf)
 148 {
 149         int bytes_written = 0;
 150         int err;
 151         log_entry entry;
 152         char mgs_buf[1024];
 153
 154         err = log_process_log_buffer(buf, &entry);
 155
 156         if (err < 0) {
 157                 goto error;
 158         }
 159
 160         if (log_should_print_line(g_logformat, entry.tag, entry.priority)) {
 161                 if (false && g_dev_count > 1) {
 162                         // FIXME
 163                         mgs_buf[0] = dev->device[0];
 164                         mgs_buf[1] = ' ';
 165                         bytes_written = write(g_outfd, mgs_buf, 2);
 166                         if (bytes_written < 0)
 167                         {
 168                                 perror("output error");
 169                                 exit(-1);
 170                         }
 171                 }
 172
 173                 bytes_written = log_print_log_line(g_logformat, g_outfd, &entry);
 174
 175                 if (bytes_written < 0)
 176                 {
 177                         perror("output error");
 178                         exit(-1);
 179                 }
 180         }
 181
 182         g_out_byte_count += bytes_written;
 183
 184         if (g_log_rotate_size_kbytes > 0 && (g_out_byte_count / 1024) >= g_log_rotate_size_kbytes) {
 185                 if (g_nonblock) {
 186                         exit(0);
 187                 } else {
 188                         rotate_logs();
 189                 }
 190         }
 191
 192 error:
 193         //fprintf (stderr, "Error processing record\n");
 194         return;
 195 }
 196
 197 static void chooseFirst(struct log_device_t* dev, struct log_device_t** firstdev)
 198 {
 199         for (*firstdev = NULL; dev != NULL; dev = dev->next) {
 200                 if (dev->queue != NULL && (*firstdev == NULL || cmp(dev->queue, (*firstdev)->queue) < 0))
 201                 {
 202                         *firstdev = dev;
 203                 }
 204         }
 205 }
 206
 207 static void maybePrintStart(struct log_device_t* dev) {
 208         if (!dev->printed) {
 209                 dev->printed = true;
 210                 if (g_dev_count > 1 ) {
 211                         char buf[1024];
 212                         snprintf(buf, sizeof(buf), "--------- beginning of %s\n", dev->device);
 213                         if (write(g_outfd, buf, strlen(buf)) < 0) {
 214                                 perror("output error");
 215                                 exit(-1);
 216                         }
 217                 }
 218         }
 219 }
 220
 221 static void skipNextEntry(struct log_device_t* dev) {
 222         maybePrintStart(dev);
 223         struct queued_entry_t* entry = dev->queue;
 224         dev->queue = entry->next;
 225         free(entry);
 226 }
 227
 228 static void printNextEntry(struct log_device_t* dev)
 229 {
 230         maybePrintStart(dev);
 231         processBuffer(dev, &dev->queue->entry);
 232         skipNextEntry(dev);
 233 }
 234
 235
 236 static void read_log_lines(struct log_device_t* devices)
 237 {
 238         struct log_device_t* dev;
 239         int max = 0;
 240         int ret;
 241         int queued_lines = 0;
 242         bool sleep = false; // for exit immediately when log buffer is empty and g_nonblock value is true.
 243
 244         int result;
 245         fd_set readset;
 246
 247         for (dev=devices; dev; dev = dev->next) {
 248                 if (dev->fd > max) {
 249                         max = dev->fd;
 250                 }
 251         }
 252
 253         while (1) {
 254                 do {
 255                         struct timeval timeout = { 0, 5000 /* 5ms */ }; // If we oversleep it's ok, i.e. ignore EINTR.
 256                         FD_ZERO(&readset);
 257                         for (dev=devices; dev; dev = dev->next) {
 258                                 FD_SET(dev->fd, &readset);
 259                         }
 260                         result = select(max + 1, &readset, NULL, NULL, sleep ? NULL : &timeout);
 261                 } while (result == -1 && errno == EINTR);
 262
 263         if (result >= 0) {
 264             for (dev=devices; dev; dev = dev->next) {
 265                 if (FD_ISSET(dev->fd, &readset)) {
 266                     struct queued_entry_t* entry = (struct queued_entry_t *)malloc(sizeof( struct queued_entry_t));
 267                                         if (entry == NULL) {
 268                                                 fprintf(stderr,"Can't malloc queued_entry\n");
 269                                                 exit(-1);
 270                                         }
 271                                         entry->next = NULL;
 272
 273                     /* NOTE: driver guarantees we read exactly one full entry */
 274                     ret = read(dev->fd, entry->buf, LOGGER_ENTRY_MAX_LEN);
 275                     if (ret < 0) {
 276                         if (errno == EINTR) {
 277                             free(entry);
 278                             goto next;
 279                         }
 280                         if (errno == EAGAIN) {
 281                             free(entry);
 282                             break;
 283                         }
 284                         perror("dlogutil read");
 285                         exit(EXIT_FAILURE);
 286                     }
 287                     else if (!ret) {
 288                         free(entry);
 289                         fprintf(stderr, "read: Unexpected EOF!\n");
 290                         exit(EXIT_FAILURE);
 291                                         }
 292                                         else if (entry->entry.len != ret - sizeof(struct logger_entry)) {
 293                         free(entry);
 294                                                 fprintf(stderr, "read: unexpected length. Expected %d, got %d\n",
 295                                                                 entry->entry.len, ret - sizeof(struct logger_entry));
 296                                                 exit(EXIT_FAILURE);
 297                                         }
 298
 299
 300                     entry->entry.msg[entry->entry.len] = '\0';
 301
 302                     enqueue(dev, entry);
 303                     ++queued_lines;
 304                 }
 305             }
 306
 307             if (result == 0) {
 308                 // we did our short timeout trick and there's nothing new
 309                 // print everything we have and wait for more data
 310                 sleep = true;
 311                 while (true) {
 312                     chooseFirst(devices, &dev);
 313                     if (dev == NULL) {
 314                         break;
 315                     }
 316                     if (g_tail_lines == 0 || queued_lines <= g_tail_lines) {
 317                         printNextEntry(dev);
 318                     } else {
 319                         skipNextEntry(dev);
 320                     }
 321                     --queued_lines;
 322                 }
 323
 324                 // the caller requested to just dump the log and exit
 325                 if (g_nonblock) {
 326                     exit(0);
 327                 }
 328             } else {
 329                 // print all that aren't the last in their list
 330                 sleep = false;
 331                 while (g_tail_lines == 0 || queued_lines > g_tail_lines) {
 332                     chooseFirst(devices, &dev);
 333                     if (dev == NULL || dev->queue->next == NULL) {
 334                         break;
 335                     }
 336                     if (g_tail_lines == 0) {
 337                         printNextEntry(dev);
 338                     } else {
 339                         skipNextEntry(dev);
 340                     }
 341                     --queued_lines;
 342                 }
 343             }
 344         }
 345 next:
 346         ;
 347     }
 348 }
 349
 350
 351 static int clear_log(int logfd)
 352 {
 353     return ioctl(logfd, LOGGER_FLUSH_LOG);
 354 }
 355
 356 /* returns the total size of the log's ring buffer */
 357 static int get_log_size(int logfd)
 358 {
 359     return ioctl(logfd, LOGGER_GET_LOG_BUF_SIZE);
 360 }
 361
 362 /* returns the readable size of the log's ring buffer (that is, amount of the log consumed) */
 363 static int get_log_readable_size(int logfd)
 364 {
 365     return ioctl(logfd, LOGGER_GET_LOG_LEN);
 366 }
 367
 368 static void setup_output()
 369 {
 370
 371         if (g_output_filename == NULL) {
 372                 g_outfd = STDOUT_FILENO;
 373
 374         } else {
 375                 struct stat statbuf;
 376
 377                 g_outfd = open_logfile (g_output_filename);
 378
 379                 if (g_outfd < 0) {
 380                         perror ("couldn't open output file");
 381                         exit(-1);
 382                 }
 383                 if (fstat(g_outfd, &statbuf) == -1)
 384                         g_out_byte_count = 0;
 385                 else
 386                         g_out_byte_count = statbuf.st_size;
 387         }
 388 }
 389
 390 static int set_log_format(const char * formatString)
 391 {
 392         static log_print_format format;
 393
 394         format = log_format_from_string(formatString);
 395
 396         if (format == FORMAT_OFF) {
 397                 // FORMAT_OFF means invalid string
 398                 return -1;
 399         }
 400
 401         log_set_print_format(g_logformat, format);
 402
 403         return 0;
 404 }
 405
 406 static void show_help(const char *cmd)
 407 {
 408     fprintf(stderr,"Usage: %s [options] [filterspecs]\n", cmd);
 409
 410     fprintf(stderr, "options include:\n"
 411                     "  -s              Set default filter to silent.\n"
 412                     "                  Like specifying filterspec '*:s'\n"
 413                     "  -f <filename>   Log to file. Default to stdout\n"
 414                     "  -r [<kbytes>]   Rotate log every kbytes. (16 if unspecified). Requires -f\n"
 415                     "  -n <count>      Sets max number of rotated logs to <count>, default 4\n"
 416                     "  -v <format>     Sets the log print format, where <format> is one of:\n\n"
 417                     "                  brief(by default) process tag thread raw time threadtime long\n\n"
 418                     "  -c              clear (flush) the entire log and exit, conflicts with '-g'\n"
 419                     "  -d              dump the log and then exit (don't block)\n"
 420                     "  -t <count>      print only the most recent <count> lines (implies -d)\n"
 421                     "  -g              get the size of the log's ring buffer and exit, conflicts with '-c'\n"
 422                     "  -b <buffer>     request alternate ring buffer\n"
 423                     "                  ('main' (default), 'radio', 'system')");
 424
 425
 426     fprintf(stderr,"\nfilterspecs are a series of \n"
 427                    "  <tag>[:priority]\n\n"
 428                    "where <tag> is a log component tag (or * for all) and priority is:\n"
 429                    "  V    Verbose\n"
 430                    "  D    Debug\n"
 431                    "  I    Info\n"
 432                    "  W    Warn\n"
 433                    "  E    Error\n"
 434                    "  F    Fatal\n"
 435                    "  S    Silent (supress all output)\n"
 436                    "\n'*' means '*:D' and <tag> by itself means <tag>:V\n"
 437                    "If no filterspec is found, filter defaults to '*:I'\n\n");
 438 }
 439
 440
 441 /*
 442  * free one log_device_t and it doesn't take care of chain so it
 443  * may break the chain list
 444  */
 445 static void log_devices_free(struct log_device_t *dev)
 446 {
 447         if (!dev)
 448                 return;
 449
 450         if (dev->device)
 451                 free(dev->device);
 452
 453         if (dev->queue) {
 454                 while (dev->queue->next) {
 455                         struct queued_entry_t *tmp = dev->queue->next;
 456                         dev->queue->next = tmp->next;
 457                         free(tmp);
 458                 }
 459                 free(dev->queue);
 460         }
 461
 462         free(dev);
 463         dev = NULL;
 464 }
 465
 466
 467 /*
 468  * free all the nodes after the "dev" and includes itself
 469  */
 470 static void log_devices_chain_free(struct log_device_t *dev)
 471 {
 472         if (!dev)
 473                 return;
 474
 475         while (dev->next) {
 476                 struct log_device_t *tmp = dev->next;
 477                 dev->next = tmp->next;
 478                 log_devices_free(tmp);
 479         }
 480
 481         log_devices_free(dev);
 482         dev = NULL;
 483 }
 484
 485
 486 /*
 487  * create a new log_device_t instance but don't care about
 488  * the device node accessable or not
 489  */
 490 static struct log_device_t *log_devices_new(const char *path)
 491 {
 492         struct log_device_t *new;
 493
 494         if (!path || strlen(path) <= 0)
 495                 return NULL;
 496
 497         new = malloc(sizeof(*new));
 498         if (!new) {
 499                 fprintf(stderr, "out of memory\n");
 500                 return NULL;
 501         }
 502
 503         new->device = strdup(path);
 504         new->fd = -1;
 505         new->printed = false;
 506         new->queue = NULL;
 507         new->next = NULL;
 508
 509         return new;
 510 }
 511
 512
 513 /*
 514  * add a new device to the tail of chain
 515  */
 516 static int log_devices_add_to_tail(struct log_device_t *devices, struct log_device_t *new)
 517 {
 518         struct log_device_t *tail = devices;
 519
 520         if (!devices || !new)
 521                 return -1;
 522
 523         while (tail->next)
 524                 tail = tail->next;
 525
 526         tail->next = new;
 527         g_dev_count++;
 528
 529         return 0;
 530 }
 531
 532 int main(int argc, char **argv)
 533 {
 534     int err;
 535     int has_set_log_format = 0;
 536     int is_clear_log = 0;
 537     int getLogSize = 0;
 538     int mode = O_RDONLY;
 539         int i;
 540 //    const char *forceFilters = NULL;
 541         struct log_device_t* devices = NULL;
 542         struct log_device_t* dev;
 543
 544     g_logformat = (log_format *)log_format_new();
 545
 546     if (argc == 2 && 0 == strcmp(argv[1], "--test")) {
 547         logprint_run_tests();
 548         exit(0);
 549     }
 550
 551     if (argc == 2 && 0 == strcmp(argv[1], "--help")) {
 552         show_help(argv[0]);
 553         exit(0);
 554     }
 555
 556     for (;;) {
 557         int ret;
 558
 559         ret = getopt(argc, argv, "cdt:gsf:r:n:v:b:D");
 560
 561         if (ret < 0) {
 562             break;
 563         }
 564
 565         switch(ret) {
 566             case 's':
 567                 // default to all silent
 568                 log_add_filter_rule(g_logformat, "*:s");
 569             break;
 570
 571             case 'c':
 572                 is_clear_log = 1;
 573                 mode = O_WRONLY;
 574             break;
 575
 576             case 'd':
 577                 g_nonblock = true;
 578             break;
 579
 580             case 't':
 581                 g_nonblock = true;
 582                 g_tail_lines = atoi(optarg);
 583             break;
 584
 585
 586             case 'g':
 587                 getLogSize = 1;
 588             break;
 589
 590                         case 'b': {
 591                                                   char *buf;
 592                                                   if (asprintf(&buf, LOG_FILE_DIR "%s", optarg) == -1) {
 593                                                           fprintf(stderr,"Can't malloc LOG_FILE_DIR\n");
 594                                                           exit(-1);
 595                                                   }
 596
 597                                                   dev = log_devices_new(buf);
 598                                                   if (dev == NULL) {
 599                                                           fprintf(stderr,"Can't add log device: %s\n", buf);
 600                                                           exit(-1);
 601                                                   }
 602                                                   if (devices) {
 603                                                           if (log_devices_add_to_tail(devices, dev)) {
 604                                                                   fprintf(stderr, "Open log device %s failed\n", buf);
 605                                                                   exit(-1);
 606                                                           }
 607                                                   } else {
 608                                                           devices = dev;
 609                                                           g_dev_count = 1;
 610                                                   }
 611                                           }
 612             break;
 613
 614             case 'f':
 615                 // redirect output to a file
 616
 617                 g_output_filename = optarg;
 618
 619             break;
 620
 621             case 'r':
 622 //                if (optarg == NULL) {
 623 //                                      fprintf(stderr,"optarg == null\n");
 624  //                  g_log_rotate_size_kbytes = DEFAULT_LOG_ROTATE_SIZE_KBYTES;
 625  //              } else {
 626                     //long logRotateSize;
 627                     //char *lastDigit;
 628
 629                     if (!isdigit(optarg[0])) {
 630                         fprintf(stderr,"Invalid parameter to -r\n");
 631                         show_help(argv[0]);
 632                         exit(-1);
 633                     }
 634                     g_log_rotate_size_kbytes = atoi(optarg);
 635    //             }
 636             break;
 637
 638             case 'n':
 639                 if (!isdigit(optarg[0])) {
 640                     fprintf(stderr,"Invalid parameter to -r\n");
 641                     show_help(argv[0]);
 642                     exit(-1);
 643                 }
 644
 645                 g_max_rotated_logs = atoi(optarg);
 646             break;
 647
 648             case 'v':
 649                 err = set_log_format (optarg);
 650                 if (err < 0) {
 651                     fprintf(stderr,"Invalid parameter to -v\n");
 652                     show_help(argv[0]);
 653                     exit(-1);
 654                 }
 655
 656                 has_set_log_format = 1;
 657             break;
 658
 659                         default:
 660                                 fprintf(stderr,"Unrecognized Option\n");
 661                                 show_help(argv[0]);
 662                                 exit(-1);
 663                         break;
 664                 }
 665         }
 666
 667         /* get log size conflicts with write mode */
 668         if (getLogSize && mode != O_RDONLY) {
 669                 show_help(argv[0]);
 670                 exit(-1);
 671         }
 672
 673         if (!devices) {
 674                 devices = log_devices_new("/dev/"LOGGER_LOG_MAIN);
 675                 if (devices == NULL) {
 676                         fprintf(stderr,"Can't add log device: %s\n", LOGGER_LOG_MAIN);
 677                         exit(-1);
 678                 }
 679         g_dev_count = 1;
 680
 681         int accessmode =
 682                   (mode == O_RDONLY) ? R_OK : (mode == O_WRONLY) ? W_OK : 0;
 683
 684         // only add this if it's available
 685         if (0 == access("/dev/"LOGGER_LOG_SYSTEM, accessmode)) {
 686                 if (log_devices_add_to_tail(devices, log_devices_new("/dev/"LOGGER_LOG_SYSTEM))) {
 687                         fprintf(stderr,"Can't add log device: %s\n", LOGGER_LOG_SYSTEM);
 688                         exit(-1);
 689                 }
 690         }
 691         if (0 == access("/dev/"LOGGER_LOG_APPS, accessmode)) {
 692                 if (log_devices_add_to_tail(devices, log_devices_new("/dev/"LOGGER_LOG_APPS))) {
 693                         fprintf(stderr,"Can't add log device: %s\n", LOGGER_LOG_APPS);
 694                         exit(-1);
 695                 }
 696         }
 697
 698 /*
 699         // only add this if it's available
 700         int fd;
 701         if ((fd = open("/dev/"LOGGER_LOG_SYSTEM, mode)) != -1) {
 702                 devices->next = (struct log_device_t *)malloc( sizeof(struct log_device_t));
 703                 devices->next->device = strdup("/dev/"LOGGER_LOG_SYSTEM);
 704                 devices->next->fd = -1;
 705                 devices->next->printed = false;
 706                 devices->next->queue = NULL;
 707                 devices->next->next = NULL;
 708                 g_dev_count ++;
 709
 710                 close(fd);
 711         }
 712 */
 713     }
 714
 715     if (g_log_rotate_size_kbytes != 0 && g_output_filename == NULL)
 716         {
 717                 fprintf(stderr,"-r requires -f as well\n");
 718                 show_help(argv[0]);
 719                 exit(-1);
 720         }
 721
 722     setup_output();
 723
 724
 725         if (has_set_log_format == 0) {
 726                 err = set_log_format("brief");
 727         }
 728 /*
 729                 const char* logFormat = getenv("DLOG_PRINTF_LOG");
 730
 731                 if (logFormat != NULL) {
 732                         err = set_log_format("brief");
 733
 734                         if (err < 0) {
 735                                 fprintf(stderr, "invalid format in DLOG_PRINTF_LOG '%s'\n", logFormat);
 736                         }
 737                 }
 738         }
 739         if (forceFilters) {
 740                 err = log_add_filter_string(g_logformat, forceFilters);
 741                 if (err < 0) {
 742                         fprintf (stderr, "Invalid filter expression in -logcat option\n");
 743                         exit(0);
 744                 }
 745         } else if (argc == optind) {
 746         // Add from environment variable
 747                 char *env_tags_orig = getenv("DLOG_LOG_TAGS");
 748
 749                 if (env_tags_orig != NULL) {
 750                         err = log_add_filter_string(g_logformat, env_tags_orig);
 751
 752                         if (err < 0) {
 753                                 fprintf(stderr, "Invalid filter expression in DLOG_LOG_TAGS\n");
 754                                 show_help(argv[0]);
 755                                 exit(-1);
 756                         }
 757                 }
 758         } else {
 759         // Add from commandline
 760 */
 761         fprintf(stderr,"arc = %d, optind = %d ,Kb %d, rotate %d\n", argc, optind,g_log_rotate_size_kbytes,g_max_rotated_logs);
 762
 763         if(argc == optind )
 764         {
 765                 // Add from environment variable
 766         //char *env_tags_orig = getenv("DLOG_TAGS");
 767                 log_add_filter_string(g_logformat, "*:d");
 768         }
 769         else
 770         {
 771
 772                 for (i = optind ; i < argc ; i++) {
 773                         err = log_add_filter_string(g_logformat, argv[i]);
 774
 775                         if (err < 0) {
 776                                 fprintf (stderr, "Invalid filter expression '%s'\n", argv[i]);
 777                                 show_help(argv[0]);
 778                                 exit(-1);
 779                         }
 780                 }
 781         }
 782 /*
 783     }
 784 */
 785     dev = devices;
 786     while (dev) {
 787         dev->fd = open(dev->device, mode);
 788         if (dev->fd < 0) {
 789             fprintf(stderr, "Unable to open log device '%s': %s\n",
 790                 dev->device, strerror(errno));
 791             exit(EXIT_FAILURE);
 792         }
 793
 794         if (is_clear_log) {
 795             int ret;
 796             ret = clear_log(dev->fd);
 797             if (ret) {
 798                 perror("ioctl");
 799                 exit(EXIT_FAILURE);
 800             }
 801         }
 802
 803         if (getLogSize) {
 804             int size, readable;
 805
 806             size = get_log_size(dev->fd);
 807             if (size < 0) {
 808                 perror("ioctl");
 809                 exit(EXIT_FAILURE);
 810             }
 811
 812             readable = get_log_readable_size(dev->fd);
 813             if (readable < 0) {
 814                 perror("ioctl");
 815                 exit(EXIT_FAILURE);
 816             }
 817
 818             printf("%s: ring buffer is %dKb (%dKb consumed), "
 819                    "max entry is %db, max payload is %db\n", dev->device,
 820                    size / 1024, readable / 1024,
 821                    (int) LOGGER_ENTRY_MAX_LEN, (int) LOGGER_ENTRY_MAX_PAYLOAD);
 822         }
 823
 824         dev = dev->next;
 825     }
 826
 827     if (getLogSize) {
 828         return 0;
 829     }
 830
 831     if (is_clear_log) {
 832         return 0;
 833     }
 834
 835     read_log_lines(devices);
 836
 837         log_devices_chain_free(devices);
 838
 839     return 0;
 840 }