1 // Copyright 2014 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package runtime 6 7 import "unsafe" 8 9 var ( 10 writeHeader = []byte{6 /* ANDROID_LOG_ERROR */, 'G', 'o', 0} 11 writePath = []byte("/dev/log/main\x00") 12 writeLogd = []byte("/dev/socket/logdw\x00") 13 14 // guarded by printlock/printunlock. 15 writeFD uintptr 16 writeBuf [1024]byte 17 writePos int 18 ) 19 20 // Prior to Android-L, logging was done through writes to /dev/log files implemented 21 // in kernel ring buffers. In Android-L, those /dev/log files are no longer 22 // accessible and logging is done through a centralized user-mode logger, logd. 23 // 24 // https://android.googlesource.com/platform/system/core/+/master/liblog/logd_write.c 25 type loggerType int32 26 27 const ( 28 unknown loggerType = iota 29 legacy 30 logd 31 // TODO(hakim): logging for emulator? 32 ) 33 34 var logger loggerType 35 36 func writeErr(b []byte) { 37 if logger == unknown { 38 // Use logd if /dev/socket/logdw is available. 39 if v := uintptr(access(&writeLogd[0], 0x02 /* W_OK */)); v == 0 { 40 logger = logd 41 initLogd() 42 } else { 43 logger = legacy 44 initLegacy() 45 } 46 } 47 48 // Write to stderr for command-line programs. 49 write(2, unsafe.Pointer(&b[0]), int32(len(b))) 50 51 // Log format: "<header>\x00<message m bytes>\x00" 52 // 53 // <header> 54 // In legacy mode: "<priority 1 byte><tag n bytes>". 55 // In logd mode: "<android_log_header_t 11 bytes><priority 1 byte><tag n bytes>" 56 // 57 // The entire log needs to be delivered in a single syscall (the NDK 58 // does this with writev). Each log is its own line, so we need to 59 // buffer writes until we see a newline. 60 var hlen int 61 switch logger { 62 case logd: 63 hlen = writeLogdHeader() 64 case legacy: 65 hlen = len(writeHeader) 66 } 67 68 dst := writeBuf[hlen:] 69 for _, v := range b { 70 if v == 0 { // android logging won't print a zero byte 71 v = '0' 72 } 73 dst[writePos] = v 74 writePos++ 75 if v == '\n' || writePos == len(dst)-1 { 76 dst[writePos] = 0 77 write(writeFD, unsafe.Pointer(&writeBuf[0]), int32(hlen+writePos)) 78 for i := range dst { 79 dst[i] = 0 80 } 81 writePos = 0 82 } 83 } 84 } 85 86 func initLegacy() { 87 // In legacy mode, logs are written to /dev/log/main 88 writeFD = uintptr(open(&writePath[0], 0x1 /* O_WRONLY */, 0)) 89 if writeFD == 0 { 90 // It is hard to do anything here. Write to stderr just 91 // in case user has root on device and has run 92 // adb shell setprop log.redirect-stdio true 93 msg := []byte("runtime: cannot open /dev/log/main\x00") 94 write(2, unsafe.Pointer(&msg[0]), int32(len(msg))) 95 exit(2) 96 } 97 98 // Prepopulate the invariant header part. 99 copy(writeBuf[:len(writeHeader)], writeHeader) 100 } 101 102 // used in initLogdWrite but defined here to avoid heap allocation. 103 var logdAddr sockaddr_un 104 105 func initLogd() { 106 // In logd mode, logs are sent to the logd via a unix domain socket. 107 logdAddr.family = _AF_UNIX 108 copy(logdAddr.path[:], writeLogd) 109 110 // We are not using non-blocking I/O because writes taking this path 111 // are most likely triggered by panic, we cannot think of the advantage of 112 // non-blocking I/O for panic but see disadvantage (dropping panic message), 113 // and blocking I/O simplifies the code a lot. 114 fd := socket(_AF_UNIX, _SOCK_DGRAM|_O_CLOEXEC, 0) 115 if fd < 0 { 116 msg := []byte("runtime: cannot create a socket for logging\x00") 117 write(2, unsafe.Pointer(&msg[0]), int32(len(msg))) 118 exit(2) 119 } 120 121 errno := connect(fd, unsafe.Pointer(&logdAddr), int32(unsafe.Sizeof(logdAddr))) 122 if errno < 0 { 123 msg := []byte("runtime: cannot connect to /dev/socket/logdw\x00") 124 write(2, unsafe.Pointer(&msg[0]), int32(len(msg))) 125 // TODO(hakim): or should we just close fd and hope for better luck next time? 126 exit(2) 127 } 128 writeFD = uintptr(fd) 129 130 // Prepopulate invariant part of the header. 131 // The first 11 bytes will be populated later in writeLogdHeader. 132 copy(writeBuf[11:11+len(writeHeader)], writeHeader) 133 } 134 135 // writeLogdHeader populates the header and returns the length of the payload. 136 func writeLogdHeader() int { 137 hdr := writeBuf[:11] 138 139 // The first 11 bytes of the header corresponds to android_log_header_t 140 // as defined in system/core/include/private/android_logger.h 141 // hdr[0] log type id (unsigned char), defined in <log/log.h> 142 // hdr[1:2] tid (uint16_t) 143 // hdr[3:11] log_time defined in <log/log_read.h> 144 // hdr[3:7] sec unsigned uint32, little endian. 145 // hdr[7:11] nsec unsigned uint32, little endian. 146 hdr[0] = 0 // LOG_ID_MAIN 147 sec, nsec := walltime() 148 packUint32(hdr[3:7], uint32(sec)) 149 packUint32(hdr[7:11], uint32(nsec)) 150 151 // TODO(hakim): hdr[1:2] = gettid? 152 153 return 11 + len(writeHeader) 154 } 155 156 func packUint32(b []byte, v uint32) { 157 // little-endian. 158 b[0] = byte(v) 159 b[1] = byte(v >> 8) 160 b[2] = byte(v >> 16) 161 b[3] = byte(v >> 24) 162 } 163
