Android架构分析之LOG模块

作者：刘昊昱 

博客：http://blog.csdn.net/liuhaoyutz

Android版本：2.3.7_r1

Linux内核版本：android-goldfish-2.6.29

 

Android的LOG模块分为内核驱动部分和用户空间接口部分。

 

一、内核LOG模块分析

 

我们先来看内核驱动部分，其代码位于drivers/staging/android/logger.c文件中。按照分析Linux内核驱动程序的惯例，我们从模块初始化函数开始分析：

 

588static int __init logger_init(void)

589{                                                             

590    int ret;

591

592    ret =init_log(&log_main);

593    if (unlikely(ret))

594        goto out;

595

596    ret =init_log(&log_events);

597    if (unlikely(ret))

598        goto out;

599

600    ret =init_log(&log_radio);

601    if (unlikely(ret))

602        goto out;

603

604out:

605    return ret;

606}

607device_initcall(logger_init);

logger_init函数即是LOG模块初始化函数，其调用了3次init_log函数，注册了log_main，log_events，log_radio三个LOG设备，init_log函数定义如下：

 

 

571static int __init init_log(struct logger_log *log)

572{

573    int ret;

574

575    ret =misc_register(&log->misc);

576    if (unlikely(ret)) {

577        printk(KERN_ERR"logger: failed to register misc "

578               "device forlog '%s'!\n", log->misc.name);

579        return ret;

580    }

581

582    printk(KERN_INFO"logger: created %luK log '%s'\n",

583           (unsigned long)log->size >> 10, log->misc.name);

584

585    return 0;

586}

575行，调用misc_register函数，注册misc设备。

 

init_log函数的参数是logger_log结构体类型，该类型代表一个LOG设备，其定义如下：

 

 30/*

 31 * struct logger_log -represents a specific log, such as 'main' or 'radio'

 32 *

 33 * This structure lives frommodule insertion until module removal, so it does

 34 * not need additionalreference counting. The structure is protected by the

 35 * mutex 'mutex'.

 36 */

 37struct logger_log {

 38    unsigned char *     buffer; /* the ring buffer itself */

 39    struct miscdevice   misc;  /* misc device representing the log */

 40    wait_queue_head_t   wq; /* wait queue for readers */

 41    struct list_head    readers; /* this log's readers */

 42    struct mutex        mutex; /* mutex protecting buffer */

 43    size_t          w_off;  /* current write head offset */

 44    size_t          head;   /* new readers start here */

 45    size_t          size;   /* size of the log */

 46};

log_main，log_events，log_radio三个LOG设备都是logger_log结构体类型的变量，其定义如下：

 

 

533/*

534 * Defines a log structure with name 'NAME' and a size of 'SIZE'bytes, which

535 * must be a power of two, greater than LOGGER_ENTRY_MAX_LEN, andless than

536 * LONG_MAX minus LOGGER_ENTRY_MAX_LEN.

537 */

538#define DEFINE_LOGGER_DEVICE(VAR, NAME, SIZE) \

539static unsigned char _buf_ ## VAR[SIZE]; \

540static struct logger_log VAR = { \

541    .buffer = _buf_ ## VAR, \

542    .misc = { \

543        .minor =MISC_DYNAMIC_MINOR, \

544        .name = NAME, \

545        .fops =&logger_fops, \

546        .parent = NULL, \

547    }, \

548    .wq =__WAIT_QUEUE_HEAD_INITIALIZER(VAR .wq), \

549    .readers = LIST_HEAD_INIT(VAR.readers), \

550    .mutex =__MUTEX_INITIALIZER(VAR .mutex), \

551    .w_off = 0, \

552    .head = 0, \

553    .size = SIZE, \

554};

555

556DEFINE_LOGGER_DEVICE(log_main, LOGGER_LOG_MAIN, 64*1024)

557DEFINE_LOGGER_DEVICE(log_events, LOGGER_LOG_EVENTS, 256*1024)

558DEFINE_LOGGER_DEVICE(log_radio, LOGGER_LOG_RADIO, 64*1024)

在drivers/staging/android/logger.h文件中，有如下定义：

 

 

33#define LOGGER_LOG_RADIO   "log_radio" /* radio-related messages */

34#define LOGGER_LOG_EVENTS  "log_events"    /*system/hardware events */

35#define LOGGER_LOG_MAIN    "log_main"  /*everything else */

由上面代码的注释，可以理解log_main，log_events，log_radio三种LOG设备的作用。

 

综合以上分析，可知在LOG模块初始化函数logger_init中，以misc设备类型注册了3个LOG设备log_main，log_events和log_radio，分别对应/dev/log/main，/dev/log/events，/dev/log/radio，应用空间程序就可以通过对这三个设备进行读写操作与LOG内核驱动模块交互。

 

由DEFINE_LOGGER_DEVICE 宏定义可知，LOG设备的操作函数集被设置为logger_fops，其定义如下：

 

522static struct file_operations logger_fops = {

523    .owner = THIS_MODULE,

524    .read = logger_read,

525    .aio_write =logger_aio_write,

526    .poll = logger_poll,

527    .unlocked_ioctl =logger_ioctl,

528    .compat_ioctl =logger_ioctl,

529    .open = logger_open,

530    .release = logger_release,

531};

我们先来看open函数：

 

 

384/*

385 * logger_open - the log's open() file operation

386 *

387 * Note how near a no-op this is in the write-only case. Keep it thatway!

388 */

389static int logger_open(struct inode *inode, struct file *file)

390{

391    struct logger_log *log;

392    int ret;

393

394    ret =nonseekable_open(inode, file);

395    if (ret)

396        return ret;

397

398    log =get_log_from_minor(MINOR(inode->i_rdev));

399    if (!log)

400        return -ENODEV;

401

402    if (file->f_mode &FMODE_READ) {

403        struct logger_reader*reader;

404

405        reader =kmalloc(sizeof(struct logger_reader), GFP_KERNEL);

406        if (!reader)

407            return -ENOMEM;

408

409        reader->log = log;

410       INIT_LIST_HEAD(&reader->list);

411

412       mutex_lock(&log->mutex);

413        reader->r_off =log->head;

414       list_add_tail(&reader->list, &log->readers);

415       mutex_unlock(&log->mutex);

416

417        file->private_data =reader;

418    } else

419        file->private_data =log;

420

421    return 0;

422}

423

398行，调用get_log_from_minor函数，通过次设备号来取得对应的logger_log结构体变量。该函数定义如下：

 

 

560static struct logger_log * get_log_from_minor(int minor)

561{

562    if (log_main.misc.minor ==minor)

563        return &log_main;

564    if (log_events.misc.minor== minor)

565        return &log_events;

566    if (log_radio.misc.minor ==minor)

567        return &log_radio;

568    return NULL;

569}

回到logger_open函数，402-418行，如果打开的LOG设备是可读的，创建一个logger_reader结构体变量，并初始化。logger_reader结构体代表被打开进行读操作的LOG设备，其定义如下：

 

 

 48/*

 49 * struct logger_reader - alogging device open for reading

 50 *

 51 * This object lives from opento release, so we don't need additional

 52 * reference counting. Thestructure is protected by log->mutex.

 53 */

 54struct logger_reader {

 55    struct logger_log * log;    /* associated log */

 56    struct list_head    list;  /* entry in logger_log's list */

 57    size_t          r_off;  /* current read head offset */

 58};

下面我们来看read函数：

 

 

143/*

144 * logger_read - our log's read() method

145 *

146 * Behavior:

147 *

148 *  - O_NONBLOCK works

149 *  - If there are no logentries to read, blocks until log is written to

150 *  - Atomically reads exactlyone log entry

151 *

152 * Optimal read size is LOGGER_ENTRY_MAX_LEN. Will set errno toEINVAL if read

153 * buffer is insufficient to hold next entry.

154 */

155static ssize_t logger_read(struct file *file, char __user *buf,

156               size_t count,loff_t *pos)

157{

158    struct logger_reader*reader = file->private_data;

159    struct logger_log *log =reader->log;

160    ssize_t ret;

161    DEFINE_WAIT(wait);

162

163start:

164    while (1) {

165       prepare_to_wait(&log->wq, &wait, TASK_INTERRUPTIBLE);

166

167        mutex_lock(&log->mutex);

168        ret = (log->w_off ==reader->r_off);

169       mutex_unlock(&log->mutex);

170        if (!ret)

171            break;

172

173        if (file->f_flags& O_NONBLOCK) {

174            ret = -EAGAIN;

175            break;

176        }

177

178        if(signal_pending(current)) {

179            ret = -EINTR;

180            break;

181        }

182

183        schedule();

184    }

185

186   finish_wait(&log->wq, &wait);

187    if (ret)

188        return ret;

189

190   mutex_lock(&log->mutex);

191

192    /* is there still somethingto read or did we race? */

193    if (unlikely(log->w_off== reader->r_off)) {

194       mutex_unlock(&log->mutex);

195        goto start;

196    }

197

198    /* get the size of the nextentry */

199    ret = get_entry_len(log,reader->r_off);

200    if (count < ret) {

201        ret = -EINVAL;

202        goto out;

203    }

204

205    /* get exactly one entryfrom the log */

206    ret =do_read_log_to_user(log, reader, buf, ret);

207

208out:

209   mutex_unlock(&log->mutex);

210

211    return ret;

212}

164-184行，这个while循环是用来处理如果没有LOG可读，则进入休眠等待。但是如果文件打开时被设置为非阻塞模式O_NONBLOCK或者有信号需要处理signal_pending(current)，则不休眠等待，直接返回。

 

LOG内容保存在一个循环缓冲区中，代码中通过log->w_off == reader->r_off判断是否有LOG可读。

198-203行，如果有LOG可读，则调用get_entry_len函数取得下一条LOG的长度(LOG的长度包括loger_entry结构体的大小和有效负载payload的长度)，该函数定义如下：

 

86/*

 87 * get_entry_len - Grabs thelength of the payload of the next entry starting

 88 * from 'off'.

 89 *

 90 * Caller needs to holdlog->mutex.

 91 */

 92static __u32get_entry_len(struct logger_log *log, size_t off)

 93{

 94    __u16 val;

 95

 96    switch (log->size - off) {

 97    case 1:

 98        memcpy(&val, log->buffer + off,1);

 99        memcpy(((char *) &val) + 1,log->buffer, 1);

100        break;

101    default:

102        memcpy(&val,log->buffer + off, 2);

103    }

104

105    return sizeof(structlogger_entry) + val;

106}

LOG缓冲区中的每一条LOG由两部分组成，一是用于描述LOG信息的logger_entry结构体，二是LOG本身，又称为payload。在drivers/staging/android/logger.h文件中，logger_entry结构体定义如下：

 

 

23struct logger_entry {

24    __u16       len;   /* length of the payload */

25    __u16       __pad; /* no matter what, we get 2 bytes of padding */

26    __s32       pid;   /* generating process's pid */

27    __s32       tid;   /* generating process's tid */

28    __s32       sec;   /* seconds since Epoch */

29    __s32       nsec;  /* nanoseconds */

30    char        msg[0]; /* the entry's payload */

31};

get_entry_len函数用于取得整个LOG的长度，包括logger_entry结构体大小和payload的长度，logger_entry的大小是固定的，关键是怎样取得payload的长度。

 

payload的长度记录在logger_entry第一个成员len中，16位，占2个字节。因为LOG缓冲区是一个循环缓冲区，所以这2个字节存放的位置有一种特殊情况是，第一个字节在最后一个位置，第二个字节在第一个位置。所以在get_entry_len函数的实现中，分两种情况处理，case 1就是分别拷贝第一个字节和第二个字节到val变量中，其它的情况都是直接将2个节的内容拷贝到val变量中。

最后，注意get_entry_len函数的105行，返回值是sizeof(struct logger_entry) + val，即我们前面所说的，返回logger_entry结构体的大小加上payload的长度。

 

回到logger_read函数，206行，调用do_read_log_to_user函数，该函数真正将LOG信息读到用户空间，定义如下：

 

108/*

109 * do_read_log_to_user - reads exactly 'count' bytes from 'log' intothe

110 * user-space buffer 'buf'. Returns 'count' on success.

111 *

112 * Caller must hold log->mutex.

113 */

114static ssize_t do_read_log_to_user(struct logger_log *log,

115                   structlogger_reader *reader,

116                   char __user*buf,

117                   size_tcount)

118{

119    size_t len;

120

121    /*

122     * We read from the log intwo disjoint operations. First, we read from

123     * the current read headoffset up to 'count' bytes or to the end of

124     * the log, whichever comesfirst.

125     */

126    len = min(count, log->size- reader->r_off);

127    if (copy_to_user(buf,log->buffer + reader->r_off, len))

128        return -EFAULT;

129

130    /*

131     * Second, we read anyremaining bytes, starting back at the head of

132     * the log.

133     */

134    if (count != len)

135        if (copy_to_user(buf +len, log->buffer, count - len))

136            return -EFAULT;

137

138    reader->r_off =logger_offset(reader->r_off + count);

139

140    return count;

141}

因为LOG保存在循环缓冲区中，所以do_read_log_to_user函数考虑到这种情况，分两步通过copy_to_user函数拷贝LOG到用户空间。

 

最后注意138行，通过logger_offset宏设置下一次的读取位置。该宏定义如下：

 

 60/* logger_offset- returns index 'n' into the log via (optimized) modulus */

 61#define logger_offset(n)    ((n) & (log->size - 1))

下面我们来看LOG模块的write函数:

 

 

317/*

318 * logger_aio_write - our write method, implementing support forwrite(),

319 * writev(), and aio_write(). Writes are our fast path, and we try tooptimize

320 * them above all else.

321 */

322ssize_t logger_aio_write(struct kiocb *iocb, const struct iovec *iov,

323             unsigned longnr_segs, loff_t ppos)

324{

325    struct logger_log *log =file_get_log(iocb->ki_filp);

326    size_t orig =log->w_off;

327    struct logger_entry header;

328    struct timespec now;

329    ssize_t ret = 0;

330

331    now =current_kernel_time();

332

333    header.pid =current->tgid;

334    header.tid =current->pid;

335    header.sec = now.tv_sec;

336    header.nsec = now.tv_nsec;

337    header.len = min_t(size_t,iocb->ki_left, LOGGER_ENTRY_MAX_PAYLOAD);

338

339    /* null writes succeed,return zero */

340    if (unlikely(!header.len))

341        return 0;

342

343   mutex_lock(&log->mutex);

344

345    /*

346     * Fix up any readers,pulling them forward to the first readable

347     * entry after (what willbe) the new write offset. We do this now

348     * because if we partiallyfail, we can end up with clobbered log

349     * entries that encroach onreadable buffer.

350     */

351    fix_up_readers(log,sizeof(struct logger_entry) + header.len);

352

353    do_write_log(log,&header, sizeof(struct logger_entry));

354

355    while (nr_segs-- > 0) {

356        size_t len;

357        ssize_t nr;

358

359        /* figure out how muchof this vector we can keep */

360        len = min_t(size_t,iov->iov_len, header.len - ret);

361

362        /* write out thissegment's payload */

363        nr =do_write_log_from_user(log, iov->iov_base, len);

364        if (unlikely(nr <0)) {

365            log->w_off = orig;

366           mutex_unlock(&log->mutex);

367            return nr;

368        }

369

370        iov++;

371        ret += nr;

372    }

373

374   mutex_unlock(&log->mutex);

375

376    /* wake up any blockedreaders */

377   wake_up_interruptible(&log->wq);

378

379    return ret;

380}

325行,调用file_get_log函数取得要读取的LOG设备:

 

 

 77static inlinestruct logger_log * file_get_log(struct file *file)

 78{

 79    if (file->f_mode & FMODE_READ) {

 80        struct logger_reader *reader =file->private_data;

 81        return reader->log;

 82    } else

 83        return file->private_data;

 84}

327行，定义了一个logger_entry结构体变量header，logger_entry结构体用于描述一个LOG的信息，定义在drivers/staging/android/logger.h文件中：

 

 

23struct logger_entry {

24    __u16       len;   /* length of the payload */

25    __u16       __pad; /* no matter what, we get 2 bytes of padding */

26    __s32       pid;   /* generating process's pid */

27    __s32       tid;   /* generating process's tid */

28    __s32       sec;   /* seconds since Epoch */

29    __s32       nsec;  /* nanoseconds */

30    char        msg[0]; /* the entry's payload */

31};

333-337行，对logger_entry结构体变量header进行初始化。

 

351行，调用fix_up_readers函数，修正某些logger_read的读取位置指针。因为LOG缓冲区是循环使用的，当进行写操作后，可能会覆盖一些末读取的内容，因此，需要修正某些logger_read的读取位置指针。

 

250/*

251 * fix_up_readers - walk the list of all readers and "fixup" any who were

252 * lapped by the writer; also do the same for the default "starthead".

253 * We do this by "pulling forward" the readers and starthead to the first

254 * entry after the new write head.

255 *

256 * The caller needs to hold log->mutex.

257 */

258static void fix_up_readers(struct logger_log *log, size_t len)

259{

260    size_t old = log->w_off;

261    size_t new =logger_offset(old + len);

262    struct logger_reader*reader;

263

264    if (clock_interval(old,new, log->head))

265        log->head =get_next_entry(log, log->head, len);

266

267    list_for_each_entry(reader,&log->readers, list)

268        if (clock_interval(old,new, reader->r_off))

269            reader->r_off =get_next_entry(log, reader->r_off, len);

270}

264行，调用clock_interval(old, new, log->head)函数，判断第三个参数log->head是否在第一个和第二个参数范围之内，即判断第三个参数log->head指定的位置是否会被本次write操作覆盖。clock_interval函数定义如下：

 

 

233/*

234 * clock_interval - is a < c < b in mod-space? Put another way,does the line

235 * from a to b cross c?

236 */

237static inline int clock_interval(size_t a, size_t b, size_t c)

238{

239    if (b < a) {      // 转到循环缓冲区前面

240        if (a < c || b >=c)

241            return 1;

242    } else {

243        if (a < c &&b >= c)

244            return 1;

245    }

246

247    return 0;

248}

回到fix_up_readers 函数，265行，如果log->head指定的位置会被本次write操作覆盖，则调用get_next_entry获得下一条LOG记录的起始位置，并赋值给log->head。get_next_entry函数定义如下：

 

 

214/*

215 * get_next_entry - return the offset of the first valid entry atleast 'len'

216 * bytes after 'off'.

217 *

218 * Caller must hold log->mutex.

219 */

220static size_t get_next_entry(struct logger_log *log, size_t off,size_t len)

221{

222    size_t count = 0;

223

224    do {

225        size_t nr =get_entry_len(log, off);  // 取得一下条记录的长度

226        off = logger_offset(off+ nr);     // off指向一条记录

227        count += nr;

228    } while (count < len);

229

230    return off;

231}

回到fix_up_readers 函数，267-269行，遍历log->readers列表。对于每个logger_reader，如果logger_reader.r_off被覆盖，则向后做偏移。

 

回到logger_aio_write函数，353行，调用do_write_log函数，将logger_entry写入LOG缓冲区。do_write_log函数定义如下：

 

272/*

273 * do_write_log - writes 'len' bytes from 'buf' to 'log'

274 *

275 * The caller needs to hold log->mutex.

276 */

277static void do_write_log(struct logger_log *log, const void *buf,size_t count)

278{

279    size_t len;

280

281    len = min(count,log->size - log->w_off); // 处理后半部分

282    memcpy(log->buffer +log->w_off, buf, len);

283

284    if (count != len) // 如果有需要，处理前半部分

285        memcpy(log->buffer,buf + len, count - len);

286

287    log->w_off =logger_offset(log->w_off + count);

288

289}

回到logger_aio_write函数，355-372行，通过这个while循环将用户空间提供的LOG内容写入LOG设备中。真正的写操作是通过do_write_log_from_user函数完成的，该函数定义如下：

 

 

291/*

292 * do_write_log_user - writes 'len' bytes from the user-space buffer'buf' to

293 * the log 'log'

294 *

295 * The caller needs to hold log->mutex.

296 *

297 * Returns 'count' on success, negative error code on failure.

298 */

299static ssize_t do_write_log_from_user(struct logger_log *log,

300                      constvoid __user *buf, size_t count)

301{

302    size_t len;

303

304    len = min(count,log->size - log->w_off);

305    if (len &©_from_user(log->buffer + log->w_off, buf, len))

306        return -EFAULT;

307

308    if (count != len)

309        if(copy_from_user(log->buffer, buf + len, count - len))

310            return -EFAULT;

311

312    log->w_off =logger_offset(log->w_off + count);

313

314    return count;

315}

回到logger_aio_write函数，377行，调用wake_up_interruptible函数唤醒在log->wq上等待的logger_reader。

 

至此，内核空间的LOG模块我们就分析完了。

 

二、用户空间LOG模块分析

Android应用程序是通过应用程序框架层的JAVA接口android.util.Log来使用LOG系统的，该接口定义在frameworks/base/core/java/android/util/Log.java文件中：

 

52public finalclass Log {

 53

 54    /**

 55     * Priority constant for the printlnmethod; use Log.v.

 56     */

 57    public static final int VERBOSE = 2;

 58

 59    /**

 60     * Priority constant for the printlnmethod; use Log.d.

 61     */

 62    public static final int DEBUG = 3;

 63

 64    /**

 65     * Priority constant for the printlnmethod; use Log.i.

 66     */

 67    public static final int INFO = 4;

 68

 69    /**

 70     * Priority constant for the printlnmethod; use Log.w.

 71     */

 72    public static final int WARN = 5;

 73

 74    /**

 75     * Priority constant for the printlnmethod; use Log.e.

 76     */

 77    public static final int ERROR = 6;

 78

 79    /**

 80     * Priority constant for the printlnmethod.

 81     */

 82    public static final int ASSERT = 7;

 83

 84    /**

 85     * Exception class used to capture a stacktrace in {@link #wtf()}.

 86     */

 87    private static class TerribleFailureextends Exception {

 88        TerribleFailure(String msg, Throwablecause) { super(msg, cause); }

 89    }

 90

 91    /**

 92     * Interface to handle terrible failuresfrom {@link #wtf()}.

 93     *

 94     * @hide

 95     */

 96    public interface TerribleFailureHandler {

97        void onTerribleFailure(String tag, TerribleFailurewhat);

 98    }

 99

100    private staticTerribleFailureHandler sWtfHandler = new TerribleFailureHandler() {

101            public voidonTerribleFailure(String tag, TerribleFailure what) {

102               RuntimeInit.wtf(tag, what);

103            }

104        };

105

106    private Log() {

107    }

108

109    /**

110     * Send a {@link #VERBOSE}log message.

111     * @param tag Used toidentify the source of a log message.  Itusually identifies

112     *        the class or activity where the logcall occurs.

113     * @param msg The messageyou would like logged.

114     */

115    public static int v(Stringtag, String msg) {

116        returnprintln_native(LOG_ID_MAIN, VERBOSE, tag, msg);

117    }

118

119    /**

120     * Send a {@link #VERBOSE}log message and log the exception.

121     * @param tag Used toidentify the source of a log message.  Itusually identifies

122     *        the class or activity where the logcall occurs.

123     * @param msg The messageyou would like logged.

124     * @param tr An exceptionto log

125     */

126    public static int v(Stringtag, String msg, Throwable tr) {

127        returnprintln_native(LOG_ID_MAIN, VERBOSE, tag, msg + '\n' + getStackTraceString(tr));

128    }

129

130    /**

131     * Send a {@link #DEBUG}log message.

132     * @param tag Used toidentify the source of a log message.  Itusually identifies

133     *        the class or activity where the logcall occurs.

134     * @param msg The messageyou would like logged.

135     */

136    public static int d(Stringtag, String msg) {

137        returnprintln_native(LOG_ID_MAIN, DEBUG, tag, msg);

138    }

139

140    /**

141     * Send a {@link #DEBUG}log message and log the exception.

142     * @param tag Used toidentify the source of a log message.  Itusually identifies

143     *        the class or activity where the logcall occurs.

144     * @param msg The messageyou would like logged.

145     * @param tr An exceptionto log

146     */

147    public static int d(Stringtag, String msg, Throwable tr) {

148        returnprintln_native(LOG_ID_MAIN, DEBUG, tag, msg + '\n' + getStackTraceString(tr));

149    }

150

151    /**

152     * Send an {@link #INFO}log message.

153     * @param tag Used toidentify the source of a log message.  Itusually identifies

154     *        the class or activity where the logcall occurs.

155     * @param msg The messageyou would like logged.

156     */

157    public static int i(Stringtag, String msg) {

158        returnprintln_native(LOG_ID_MAIN, INFO, tag, msg);

159    }

160

161    /**

162     * Send a {@link #INFO} logmessage and log the exception.

163     * @param tag Used toidentify the source of a log message.  Itusually identifies

164     *        the class or activity where the logcall occurs.

165     * @param msg The messageyou would like logged.

166     * @param tr An exceptionto log

167     */

168    public static int i(Stringtag, String msg, Throwable tr) {

169        returnprintln_native(LOG_ID_MAIN, INFO, tag, msg + '\n' + getStackTraceString(tr));

170    }

171

172    /**

173     * Send a {@link #WARN} logmessage.

174     * @param tag Used toidentify the source of a log message.  Itusually identifies

175     *        the class or activity where the logcall occurs.

176     * @param msg The messageyou would like logged.

177     */

178    public static int w(Stringtag, String msg) {

179        returnprintln_native(LOG_ID_MAIN, WARN, tag, msg);

180    }

181

182    /**

183     * Send a {@link #WARN} logmessage and log the exception.

184     * @param tag Used toidentify the source of a log message.  Itusually identifies

185     *        the class or activity where the log calloccurs.

186     * @param msg The messageyou would like logged.

187     * @param tr An exceptionto log

188     */

189    public static int w(Stringtag, String msg, Throwable tr) {

190        return println_native(LOG_ID_MAIN,WARN, tag, msg + '\n' + getStackTraceString(tr));

191    }

192

193    /**

194     * Checks to see whether ornot a log for the specified tag is loggable at the specified level.

195     *

196     *  The default level of any tag is set to INFO.This means that any level above and including

197     *  INFO will be logged. Before you make anycalls to a logging method you should check to see

198     *  if your tag should be logged. You can changethe default level by setting a system property:

199     *      'setprop log.tag.<YOUR_LOG_TAG><LEVEL>'

200     *  Where level is either VERBOSE, DEBUG, INFO,WARN, ERROR, ASSERT, or SUPPRESS. SUPPRESS will

201     *  turn off all logging for your tag. You canalso create a local.prop file that with the

202     *  following in it:

203     *     'log.tag.<YOUR_LOG_TAG>=<LEVEL>'

204     *  and place that in /data/local.prop.

205     *

206     * @param tag The tag tocheck.

207     * @param level The levelto check.

208     * @return Whether or notthat this is allowed to be logged.

209     * @throwsIllegalArgumentException is thrown if the tag.length() > 23.

210     */

211    public static nativeboolean isLoggable(String tag, int level);

212

213    /*

214     * Send a {@link #WARN} logmessage and log the exception.

215     * @param tag Used toidentify the source of a log message.  Itusually identifies

216     *        the class or activity where the logcall occurs.

217     * @param tr An exceptionto log

218     */

219    public static int w(Stringtag, Throwable tr) {

220        returnprintln_native(LOG_ID_MAIN, WARN, tag, getStackTraceString(tr));

221    }

222

223    /**

224     * Send an {@link #ERROR}log message.

225     * @param tag Used toidentify the source of a log message.  Itusually identifies

226     *        the class or activity where the logcall occurs.

227     * @param msg The messageyou would like logged.

228     */

229    public static int e(Stringtag, String msg) {

230        returnprintln_native(LOG_ID_MAIN, ERROR, tag, msg);

231    }

232

233    /**

234     * Send a {@link #ERROR}log message and log the exception.

235     * @param tag Used toidentify the source of a log message.  Itusually identifies

236     *        the class or activity where the logcall occurs.

237     * @param msg The messageyou would like logged.

238     * @param tr An exceptionto log

239     */

240    public static int e(Stringtag, String msg, Throwable tr) {

241        return println_native(LOG_ID_MAIN, ERROR,tag, msg + '\n' + getStackTraceString(tr));

242    }

243

244    /**

245     * What a Terrible Failure:Report a condition that should never happen.

246     * The error will always belogged at level ASSERT with the call stack.

247     * Depending on systemconfiguration, a report may be added to the

248     * {@linkandroid.os.DropBoxManager} and/or the process may be terminated

249     * immediately with anerror dialog.

250     * @param tag Used toidentify the source of a log message.

251     * @param msg The messageyou would like logged.

252     */

253    public static intwtf(String tag, String msg) {

254        return wtf(tag, msg,null);

255    }

256

257    /**

258     * What a Terrible Failure:Report an exception that should never happen.

259     * Similar to {@link#wtf(String, String)}, with an exception to log.

260     * @param tag Used toidentify the source of a log message.

261     * @param tr An exceptionto log.

262     */

263    public static intwtf(String tag, Throwable tr) {

264        return wtf(tag,tr.getMessage(), tr);

265    }

266

267    /**

268     * What a Terrible Failure:Report an exception that should never happen.

269     * Similar to {@link #wtf(String,Throwable)}, with a message as well.

270     * @param tag Used toidentify the source of a log message.

271     * @param msg The messageyou would like logged.

272     * @param tr An exceptionto log.  May be null.

273     */

274    public static intwtf(String tag, String msg, Throwable tr) {

275        TerribleFailure what =new TerribleFailure(msg, tr);

276        int bytes =println_native(LOG_ID_MAIN, ASSERT, tag, getStackTraceString(tr));

277       sWtfHandler.onTerribleFailure(tag, what);

278        return bytes;

279    }

280

281    /**

282     * Sets the terriblefailure handler, for testing.

283     *

284     * @return the old handler

285     *

286     * @hide

287     */

288    public staticTerribleFailureHandler setWtfHandler(TerribleFailureHandler handler) {

289        if (handler == null) {

290            throw newNullPointerException("handler == null");

291        }

292        TerribleFailureHandleroldHandler = sWtfHandler;

293        sWtfHandler = handler;

294        return oldHandler;

295    }

296

297    /**

298     * Handy function to get aloggable stack trace from a Throwable

299     * @param tr An exceptionto log

300     */

301    public static StringgetStackTraceString(Throwable tr) {

302        if (tr == null) {

303            return"";

304        }

305        StringWriter sw = newStringWriter();

306        PrintWriter pw = newPrintWriter(sw);

307        tr.printStackTrace(pw);

308        return sw.toString();

309    }

310

311    /**

312     * Low-level logging call.

313     * @param priority Thepriority/type of this log message

314     * @param tag Used toidentify the source of a log message.  Itusually identifies

315     *        the class or activity where the log calloccurs.

316     * @param msg The messageyou would like logged.

317     * @return The number ofbytes written.

318     */

319    public static intprintln(int priority, String tag, String msg) {

320        returnprintln_native(LOG_ID_MAIN, priority, tag, msg);

321    }

322

323    /** @hide */ public staticfinal int LOG_ID_MAIN = 0;

324    /** @hide */ public staticfinal int LOG_ID_RADIO = 1;

325    /** @hide */ public staticfinal int LOG_ID_EVENTS = 2;

326    /** @hide */ public staticfinal int LOG_ID_SYSTEM = 3;

327

328    /** @hide */ public staticnative int println_native(int bufID,

329            int priority,String tag, String msg);

330}

57-82行，定义了2-7共6个LOG优先级。

 

115-117行，定义了Log.v函数，可以看到，该函数是通过调用本地函数println_native来实现的。

LOG类的其它函数很多都是类似的实现，我们不再详细分析，下面我们来看println_native函数是怎么实现的。该函数定义在frameworks/base/core/jni/android_util_Log.cpp文件中。

 

142/*

143 * JNI registration.

144 */

145static JNINativeMethod gMethods[] = {

146    /* name, signature, funcPtr*/

147    {"isLoggable",     "(Ljava/lang/String;I)Z", (void*) android_util_Log_isLoggable},

148    {"println_native", "(IILjava/lang/String;Ljava/lang/String;)I", (void*)android_util_Log_println_native },

149};

由这段代码可以看出，JAVA层调用的本地函数println_native，在这里是指向android_util_Log_println_native函数，该函数定义如下：

 

 

99/*

100 * In class android.util.Log:

101 *  public static native intprintln_native(int buffer, int priority, String tag, String msg)

102 */

103static jint android_util_Log_println_native(JNIEnv* env, jobjectclazz,

104        jint bufID, jintpriority, jstring tagObj, jstring msgObj)

105{

106    const char* tag = NULL;

107    const char* msg = NULL;

108

109    if (msgObj == NULL) {

110        jclass npeClazz;

111

112        npeClazz =env->FindClass("java/lang/NullPointerException");

113        assert(npeClazz !=NULL);

114

115       env->ThrowNew(npeClazz, "println needs a message");

116        return -1;

117    }

118

119    if (bufID < 0 || bufID>= LOG_ID_MAX) {

120        jclass npeClazz;

121

122        npeClazz =env->FindClass("java/lang/NullPointerException");

123        assert(npeClazz !=NULL);

124

125       env->ThrowNew(npeClazz, "bad bufID");

126        return -1;

127    }

128

129    if (tagObj != NULL)

130        tag =env->GetStringUTFChars(tagObj, NULL);

131    msg =env->GetStringUTFChars(msgObj, NULL);

132

133    int res =__android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);

134

135    if (tag != NULL)

136       env->ReleaseStringUTFChars(tagObj, tag);

137   env->ReleaseStringUTFChars(msgObj, msg);

138

139    return res;

140}

开始是进行一些参数的检查，133行，调用运行时库函数__android_log_buf_write执行写操作，该函数定义在system/core/liblog/logd_write.c文件中：

 

 

162int __android_log_buf_write(int bufID, int prio, const char *tag,const char *msg)

163{

164    struct iovec vec[3];

165

166    if (!tag)

167        tag = "";

168

169    /* XXX: This needs to go!*/

170    if (!strcmp(tag,"HTC_RIL") ||

171        !strncmp(tag,"RIL", 3) || /* Any log tag with "RIL" as the prefix */

172        !strcmp(tag,"AT") ||

173        !strcmp(tag,"GSM") ||

174        !strcmp(tag,"STK") ||

175        !strcmp(tag,"CDMA") ||

176        !strcmp(tag,"PHONE") ||

177        !strcmp(tag,"SMS"))

178            bufID =LOG_ID_RADIO;

179

180    vec[0].iov_base   = (unsigned char *) &prio;

181    vec[0].iov_len    = 1;

182    vec[1].iov_base   = (void *) tag;

183    vec[1].iov_len    = strlen(tag) + 1;

184    vec[2].iov_base   = (void *) msg;

185    vec[2].iov_len    = strlen(msg) + 1;

186

187    return write_to_log(bufID,vec, 3);

188}

170-178行，如果出现“HTC_RIL”等字符，将bufID设置为LOG_ID_RADIO。

 

180-185行，将prio,tag,msg保存在数组vec中。

187行，调用write_to_log函数，该函数定义如下：

 

45static int __write_to_log_init(log_id_t, struct iovec *vec, size_tnr);

46static int (*write_to_log)(log_id_t, struct iovec *vec, size_t nr) =__write_to_log_init;

__write_to_log_init函数定义如下：

 

 

 96static int__write_to_log_init(log_id_t log_id, struct iovec *vec, size_t nr)

 97{

 98#ifdef HAVE_PTHREADS

 99    pthread_mutex_lock(&log_init_lock);

100#endif

101

102    if (write_to_log ==__write_to_log_init) {

103        log_fds[LOG_ID_MAIN] =log_open("/dev/"LOGGER_LOG_MAIN, O_WRONLY);

104        log_fds[LOG_ID_RADIO] =log_open("/dev/"LOGGER_LOG_RADIO, O_WRONLY);

105        log_fds[LOG_ID_EVENTS]= log_open("/dev/"LOGGER_LOG_EVENTS, O_WRONLY);

106        log_fds[LOG_ID_SYSTEM]= log_open("/dev/"LOGGER_LOG_SYSTEM, O_WRONLY);

107

108        write_to_log =__write_to_log_kernel;

109

110        if(log_fds[LOG_ID_MAIN] < 0 || log_fds[LOG_ID_RADIO] < 0 ||

111               log_fds[LOG_ID_EVENTS] < 0) {

112           log_close(log_fds[LOG_ID_MAIN]);

113           log_close(log_fds[LOG_ID_RADIO]);

114           log_close(log_fds[LOG_ID_EVENTS]);

115           log_fds[LOG_ID_MAIN] = -1;

116           log_fds[LOG_ID_RADIO] = -1;

117           log_fds[LOG_ID_EVENTS] = -1;

118            write_to_log =__write_to_log_null;

119        }

120

121        if(log_fds[LOG_ID_SYSTEM] < 0) {

122           log_fds[LOG_ID_SYSTEM] = log_fds[LOG_ID_MAIN];

123        }

124    }

125

126#ifdef HAVE_PTHREADS

127   pthread_mutex_unlock(&log_init_lock);

128#endif

129

130    return write_to_log(log_id,vec, nr);

131}

如果write_to_log等于__write_to_log_init，即第一次调用write_to_log，则调用log_open打开4个LOG设备，并将write_to_log设置为__write_to_log_kernel，所以130行再调用write_to_log，即是调用__write_to_log_kernel函数。

 

 

 78static int__write_to_log_kernel(log_id_t log_id, struct iovec *vec, size_t nr)

 79{

 80    ssize_t ret;

 81    int log_fd;

 82

 83    if (/*(int)log_id >= 0 &&*/(int)log_id < (int)LOG_ID_MAX) {

 84        log_fd = log_fds[(int)log_id];

 85    } else {

 86        return EBADF;

 87    }

 88

 89    do {

 90        ret = log_writev(log_fd, vec, nr);

 91    } while (ret < 0 && errno ==EINTR);

 92

 93    return ret;

 94}

核心函数是第90行调用的log_writev，该函数实现了写入操作。

 

 

 40#definelog_open(pathname, flags) open(pathname, flags)

 41#define log_writev(filedes,vector, count) writev(filedes, vector, count)

 42#define log_close(filedes)close(filedes)

 

 

log_writev是一个宏，对应writev函数，定义在system/core/libcutils/uio.c文件中：

 

49int  writev( int  fd, const struct iovec*  vecs, int count )

50{

51    int   total = 0;

52

53    for ( ; count > 0;count--, vecs++ ) {

54        const char*  buf = (const char*)vecs->iov_base;

55        int          len = (int)vecs->iov_len;

56

57        while (len > 0) {

58            int  ret = write( fd, buf, len );

59            if (ret < 0) {

60                if (total == 0)

61                    total = -1;

62                goto Exit;

63            }

64            if (ret == 0)

65                goto Exit;

66

67            total += ret;

68            buf   += ret;

69            len   -= ret;

70        }

71    }

72Exit:

73    return total;

74}

该函数完成将字符串数组成员依次写到指定的设备中。

 

分析到这里，我们就清楚了应用程序怎样把LOG信息写到LOG设备中了。