android/log.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2014  Intel Corporation. All rights reserved.
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <fcntl.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <stdint.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <stdbool.h>
  34 #include <time.h>
  35 #include <sys/uio.h>
  36 #include <sys/types.h>
  37 #include <sys/socket.h>
  38 #include <sys/un.h>
  39
  40 #include "src/log.h"
  41
  42 #define LOG_TAG "bluetoothd"
  43
  44 #define LOG_DEBUG 3
  45 #define LOG_INFO 4
  46 #define LOG_WARN 5
  47 #define LOG_ERR 6
  48
  49 #define LOG_ID_SYSTEM 3
  50
  51 struct logd_header {
  52         uint8_t id;
  53         uint16_t pid; /* Android logd expects only 2 bytes for PID */
  54         uint32_t sec;
  55         uint32_t nsec;
  56 } __attribute__ ((packed));
  57
  58 static int log_fd = -1;
  59 static bool legacy_log = false;
  60
  61 static void android_log(unsigned char level, const char *fmt, va_list ap)
  62 {
  63         struct logd_header header;
  64         struct iovec vec[4];
  65         int cnt = 0;
  66         char *msg;
  67         static pid_t pid = 0;
  68
  69         if (log_fd < 0)
  70                 return;
  71
  72         /* no need to call getpid all the time since we don't fork */
  73         if (!pid)
  74                 pid = getpid();
  75
  76         if (vasprintf(&msg, fmt, ap) < 0)
  77                 return;
  78
  79         if (!legacy_log) {
  80                 struct timespec ts;
  81
  82                 clock_gettime(CLOCK_REALTIME, &ts);
  83
  84                 header.id = LOG_ID_SYSTEM;
  85                 header.pid = pid;
  86                 header.sec = ts.tv_sec;
  87                 header.nsec = ts.tv_nsec;
  88
  89                 vec[0].iov_base = &header;
  90                 vec[0].iov_len = sizeof(header);
  91
  92                 cnt += 1;
  93         }
  94
  95         vec[cnt + 0].iov_base = &level;
  96         vec[cnt + 0].iov_len = sizeof(level);
  97         vec[cnt + 1].iov_base = LOG_TAG;
  98         vec[cnt + 1].iov_len = sizeof(LOG_TAG);
  99         vec[cnt + 2].iov_base  = msg;
 100         vec[cnt + 2].iov_len  = strlen(msg) + 1;
 101
 102         cnt += 3;
 103
 104         writev(log_fd, vec, cnt);
 105
 106         free(msg);
 107 }
 108
 109 void info(const char *format, ...)
 110 {
 111         va_list ap;
 112
 113         va_start(ap, format);
 114
 115         android_log(LOG_INFO, format, ap);
 116
 117         va_end(ap);
 118 }
 119
 120 void warn(const char *format, ...)
 121 {
 122         va_list ap;
 123
 124         va_start(ap, format);
 125
 126         android_log(LOG_WARN, format, ap);
 127
 128         va_end(ap);
 129 }
 130
 131 void error(const char *format, ...)
 132 {
 133         va_list ap;
 134
 135         va_start(ap, format);
 136
 137         android_log(LOG_ERR, format, ap);
 138
 139         va_end(ap);
 140 }
 141
 142 void btd_debug(uint16_t index, const char *format, ...)
 143 {
 144         va_list ap;
 145
 146         va_start(ap, format);
 147
 148         android_log(LOG_DEBUG, format, ap);
 149
 150         va_end(ap);
 151 }
 152
 153 static bool init_legacy_log(void)
 154 {
 155         log_fd = open("/dev/log/system", O_WRONLY);
 156         if (log_fd < 0)
 157                 return false;
 158
 159         legacy_log = true;
 160
 161         return true;
 162 }
 163
 164 static bool init_logd(void)
 165 {
 166         struct sockaddr_un addr;
 167
 168         log_fd = socket(PF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 169         if (log_fd < 0)
 170                 return false;
 171
 172         if (fcntl(log_fd, F_SETFL, O_NONBLOCK) < 0)
 173                 goto failed;
 174
 175         memset(&addr, 0, sizeof(addr));
 176         addr.sun_family = AF_UNIX;
 177         strcpy(addr.sun_path, "/dev/socket/logdw");
 178
 179         if (connect(log_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
 180                 goto failed;
 181
 182         return true;
 183
 184 failed:
 185         close(log_fd);
 186         log_fd = -1;
 187
 188         return false;
 189 }
 190
 191 extern struct btd_debug_desc __start___debug[];
 192 extern struct btd_debug_desc __stop___debug[];
 193
 194 void __btd_log_init(const char *debug, int detach)
 195 {
 196         if (!init_logd() && !init_legacy_log())
 197                 return;
 198
 199         if (debug) {
 200                 struct btd_debug_desc *desc;
 201
 202                 for (desc = __start___debug; desc < __stop___debug; desc++)
 203                         desc->flags |= BTD_DEBUG_FLAG_PRINT;
 204         }
 205
 206         info("Bluetooth daemon %s", VERSION);
 207 }
 208
 209 void __btd_log_cleanup(void)
 210 {
 211         if (log_fd < 0)
 212                 return;
 213
 214         close(log_fd);
 215         log_fd = -1;
 216 }