ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge changes from topic "remove-legacy-logger_entry-structs"

Browse source 
* changes:
  liblog: document the liblog<->logd protocol format
  liblog: remove unused parts of android_log_transport_context
  Remove old logger_entry_v* formats
  liblog: disable header_abi_checker
This commit is contained in:
Tom Cherry 2019-10-25 16:53:20 +00:00 • committed by Gerrit Code Review
commit c8ef01344d
14 changed files with 134 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
debuggerd/libdebuggerd/tombstone.cpp
View file

@ -595,7 +595,7 @@ static void dump_log_file(log_t* log, pid_t pid, const char* filename, unsigned
}
AndroidLogEntry e;
char buf[512];
if (android_log_processBinaryLogBuffer(&log_entry.entry_v1, &e, g_eventTagMap, buf,
if (android_log_processBinaryLogBuffer(&log_entry.entry, &e, g_eventTagMap, buf,
sizeof(buf)) == 0) {
_LOG(log, logtype::LOGS, "%s.%03d %5d %5d %c %-8.*s: %s\n", timeBuf,
log_entry.entry.nsec / 1000000, log_entry.entry.pid, log_entry.entry.tid, 'I',

5
liblog/Android.bp
View file

@ -105,6 +105,11 @@ cc_library {
versions: ["10000"],
},
// TODO(tomcherry): Renable this before release branch is cut
header_abi_checker: {
enabled: false,
},
cflags: [
"-Wall",
"-Werror",

49
liblog/README.protocol.md Normal file
View file

@ -0,0 +1,49 @@
# liblog -> logd
The data that liblog sends to logd is represented below.
struct {
android_log_header_t header;
union {
struct {
char prio;
char tag[...];
char message[...];
} string;
struct {
android_event_header_t event_header;
android_event_*_t payload[...];
} binary;
};
};
The payload, excluding the header, has a max size of LOGGER_ENTRY_MAX_PAYLOAD.
## header
The header is added immediately before sending the log message to logd.
## `string` payload
The `string` part of the union is for normal buffers (main, system, radio, etc) and consists of a
single character priority, followed by a variable length null terminated string for the tag, and
finally a variable length null terminated string for the message.
This payload is used for the `__android_log_buf_write()` family of functions.
## `binary` payload
The `binary` part of the union is for binary buffers (events, security, etc) and consists of an
android_event_header_t struct followed by a variable number of android_event_*_t
(android_event_list_t, android_event_int_t, etc) structs.
If multiple android_event_*_t elements are present, then they must be in a list and the first
element in payload must be an android_event_list_t.
This payload is used for the `__android_log_bwrite()` family of functions. It is additionally used
for `android_log_write_list()` and the related functions that manipulate event lists.
# logd -> liblog
logd sends a `logger_entry` struct to liblog followed by the payload. The payload is identical to
the payloads defined above. The max size of the entire message from logd is LOGGER_ENTRY_MAX_LEN.

63
liblog/include/log/log_read.h
View file

@ -50,53 +50,9 @@ extern "C" {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wzero-length-array"
/*
* The userspace structure for version 1 of the logger_entry ABI.
*/
struct logger_entry {
uint16_t len; /* length of the payload */
uint16_t __pad; /* no matter what, we get 2 bytes of padding */
int32_t pid; /* generating process's pid */
int32_t tid; /* generating process's tid */
int32_t sec; /* seconds since Epoch */
int32_t nsec; /* nanoseconds */
char msg[0]; /* the entry's payload */
};
/*
* The userspace structure for version 2 of the logger_entry ABI.
*/
struct logger_entry_v2 {
uint16_t len; /* length of the payload */
uint16_t hdr_size; /* sizeof(struct logger_entry_v2) */
int32_t pid; /* generating process's pid */
int32_t tid; /* generating process's tid */
int32_t sec; /* seconds since Epoch */
int32_t nsec; /* nanoseconds */
uint32_t euid; /* effective UID of logger */
char msg[0]; /* the entry's payload */
} __attribute__((__packed__));
/*
* The userspace structure for version 3 of the logger_entry ABI.
*/
struct logger_entry_v3 {
uint16_t len; /* length of the payload */
uint16_t hdr_size; /* sizeof(struct logger_entry_v3) */
int32_t pid; /* generating process's pid */
int32_t tid; /* generating process's tid */
int32_t sec; /* seconds since Epoch */
int32_t nsec; /* nanoseconds */
uint32_t lid; /* log id of the payload */
char msg[0]; /* the entry's payload */
} __attribute__((__packed__));
/*
* The userspace structure for version 4 of the logger_entry ABI.
*/
struct logger_entry_v4 {
uint16_t len; /* length of the payload */
uint16_t hdr_size; /* sizeof(struct logger_entry_v4) */
uint16_t hdr_size; /* sizeof(struct logger_entry) */
int32_t pid; /* generating process's pid */
uint32_t tid; /* generating process's tid */
uint32_t sec; /* seconds since Epoch */
@ -124,11 +80,7 @@ struct logger_entry_v4 {
struct log_msg {
union {
unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];
struct logger_entry_v4 entry;
struct logger_entry_v4 entry_v4;
struct logger_entry_v3 entry_v3;
struct logger_entry_v2 entry_v2;
struct logger_entry entry_v1;
struct logger_entry entry;
} __attribute__((aligned(4)));
#ifdef __cplusplus
/* Matching log_time operators */
@ -162,19 +114,12 @@ struct log_msg {
}
char* msg() {
unsigned short hdr_size = entry.hdr_size;
if (!hdr_size) {
hdr_size = sizeof(entry_v1);
}
if ((hdr_size < sizeof(entry_v1)) || (hdr_size > sizeof(entry))) {
if (hdr_size != sizeof(entry)) {
return nullptr;
}
return reinterpret_cast<char*>(buf) + hdr_size;
}
unsigned int len() {
return (entry.hdr_size ? entry.hdr_size
: static_cast<uint16_t>(sizeof(entry_v1))) +
entry.len;
}
unsigned int len() { return entry.hdr_size + entry.len; }
#endif
};

18
liblog/logd_writer.cpp
View file

@ -148,24 +148,6 @@ static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, siz
return 0;
}
/*
* struct {
* // what we provide to socket
* android_log_header_t header;
* // caller provides
* union {
* struct {
* char prio;
* char payload[];
* } string;
* struct {
* uint32_t tag
* char payload[];
* } binary;
* };
* };
*/
header.tid = gettid();
header.realtime.tv_sec = ts->tv_sec;
header.realtime.tv_nsec = ts->tv_nsec;

2
liblog/logger.h
View file

@ -96,8 +96,6 @@ struct android_log_transport_context {
struct android_log_transport_read* transport;
unsigned logMask; /* mask of requested log buffers */
int ret; /* return value associated with following data */
struct log_msg logMsg; /* peek at upcoming data, valid if logMsg.len != 0 */
};
struct android_log_logger_list {

33
liblog/logger_read.cpp
View file

@ -92,7 +92,6 @@ static int init_transport_context(struct android_log_logger_list* logger_list) {
logger_list->transport_context.transport = transport;
logger_list->transport_context.logMask = logMask;
logger_list->transport_context.ret = 1;
#endif
return 0;
}
@ -273,34 +272,24 @@ static int android_transport_read(struct android_log_logger_list* logger_list,
struct log_msg* log_msg) {
int ret = (*transp->transport->read)(logger_list, transp, log_msg);
if (ret < 0) {
return ret;
}
if (ret > (int)sizeof(*log_msg)) {
ret = sizeof(*log_msg);
}
transp->ret = ret;
/* propagate errors, or make sure len & hdr_size members visible */
if (ret < (int)(sizeof(log_msg->entry.len) + sizeof(log_msg->entry.hdr_size))) {
if (ret >= (int)sizeof(log_msg->entry.len)) {
log_msg->entry.len = 0;
}
return ret;
}
/* hdr_size correction (logger_entry -> logger_entry_v2+ conversion) */
if (log_msg->entry_v2.hdr_size == 0) {
log_msg->entry_v2.hdr_size = sizeof(struct logger_entry);
}
if ((log_msg->entry_v2.hdr_size < sizeof(log_msg->entry_v1)) ||
(log_msg->entry_v2.hdr_size > sizeof(log_msg->entry))) {
if (ret < static_cast<int>(sizeof(log_msg->entry))) {
return -EINVAL;
}
/* len validation */
if (ret <= log_msg->entry_v2.hdr_size) {
log_msg->entry.len = 0;
} else {
log_msg->entry.len = ret - log_msg->entry_v2.hdr_size;
if (log_msg->entry.hdr_size != sizeof(log_msg->entry)) {
return -EINVAL;
}
if (log_msg->entry.len > ret - log_msg->entry.hdr_size) {
return -EINVAL;
}
return ret;

45
liblog/logprint.cpp
View file

@ -532,18 +532,12 @@ int android_log_processLogBuffer(struct logger_entry* buf, AndroidLogEntry* entr
int i;
char* msg = buf->msg;
struct logger_entry_v2* buf2 = (struct logger_entry_v2*)buf;
if (buf2->hdr_size) {
if ((buf2->hdr_size < sizeof(((struct log_msg*)NULL)->entry_v1)) ||
(buf2->hdr_size > sizeof(((struct log_msg*)NULL)->entry))) {
fprintf(stderr, "+++ LOG: entry illegal hdr_size\n");
return -1;
}
msg = ((char*)buf2) + buf2->hdr_size;
if (buf2->hdr_size >= sizeof(struct logger_entry_v4)) {
entry->uid = ((struct logger_entry_v4*)buf)->uid;
}
if (buf->hdr_size != sizeof(struct logger_entry)) {
fprintf(stderr, "+++ LOG: entry illegal hdr_size\n");
return -1;
}
entry->uid = buf->uid;
for (i = 1; i < buf->len; i++) {
if (msg[i] == '\0') {
if (msgStart == -1) {
@ -993,27 +987,15 @@ int android_log_processBinaryLogBuffer(
entry->pid = buf->pid;
entry->tid = buf->tid;
/*
* Pull the tag out, fill in some additional details based on incoming
* buffer version (v3 adds lid, v4 adds uid).
*/
eventData = (const unsigned char*)buf->msg;
struct logger_entry_v2* buf2 = (struct logger_entry_v2*)buf;
if (buf2->hdr_size) {
if ((buf2->hdr_size < sizeof(((struct log_msg*)NULL)->entry_v1)) ||
(buf2->hdr_size > sizeof(((struct log_msg*)NULL)->entry))) {
fprintf(stderr, "+++ LOG: entry illegal hdr_size\n");
return -1;
}
eventData = ((unsigned char*)buf2) + buf2->hdr_size;
if ((buf2->hdr_size >= sizeof(struct logger_entry_v3)) &&
(((struct logger_entry_v3*)buf)->lid == LOG_ID_SECURITY)) {
entry->priority = ANDROID_LOG_WARN;
}
if (buf2->hdr_size >= sizeof(struct logger_entry_v4)) {
entry->uid = ((struct logger_entry_v4*)buf)->uid;
}
if (buf->hdr_size != sizeof(struct logger_entry)) {
fprintf(stderr, "+++ LOG: entry illegal hdr_size\n");
return -1;
}
if (buf->lid == LOG_ID_SECURITY) {
entry->priority = ANDROID_LOG_WARN;
}
entry->uid = buf->uid;
inCount = buf->len;
if (inCount < sizeof(android_event_header_t)) return -1;
auto* event_header = reinterpret_cast<const android_event_header_t*>(eventData);
@ -1069,9 +1051,6 @@ int android_log_processBinaryLogBuffer(
if ((result == 1) && fmtStr) {
/* We overflowed :-(, let's repaint the line w/o format dressings */
eventData = (const unsigned char*)buf->msg;
if (buf2->hdr_size) {
eventData = ((unsigned char*)buf2) + buf2->hdr_size;
}
eventData += 4;
outBuf = messageBuf;
outRemaining = messageBufLen - 1;

55
liblog/pmsg_reader.cpp
View file

@ -144,7 +144,7 @@ static int pmsgRead(struct android_log_logger_list* logger_list,
((logger_list->start.tv_sec != buf.l.realtime.tv_sec) ||
(logger_list->start.tv_nsec <= buf.l.realtime.tv_nsec)))) &&
(!logger_list->pid || (logger_list->pid == buf.p.pid))) {
char* msg = log_msg->entry_v4.msg;
char* msg = log_msg->entry.msg;
*msg = buf.prio;
fd = atomic_load(&transp->context.fd);
if (fd <= 0) {
@ -158,16 +158,16 @@ static int pmsgRead(struct android_log_logger_list* logger_list,
return -EIO;
}
log_msg->entry_v4.len = buf.p.len - sizeof(buf) + sizeof(buf.prio);
log_msg->entry_v4.hdr_size = sizeof(log_msg->entry_v4);
log_msg->entry_v4.pid = buf.p.pid;
log_msg->entry_v4.tid = buf.l.tid;
log_msg->entry_v4.sec = buf.l.realtime.tv_sec;
log_msg->entry_v4.nsec = buf.l.realtime.tv_nsec;
log_msg->entry_v4.lid = buf.l.id;
log_msg->entry_v4.uid = buf.p.uid;
log_msg->entry.len = buf.p.len - sizeof(buf) + sizeof(buf.prio);
log_msg->entry.hdr_size = sizeof(log_msg->entry);
log_msg->entry.pid = buf.p.pid;
log_msg->entry.tid = buf.l.tid;
log_msg->entry.sec = buf.l.realtime.tv_sec;
log_msg->entry.nsec = buf.l.realtime.tv_nsec;
log_msg->entry.lid = buf.l.id;
log_msg->entry.uid = buf.p.uid;
return ret + sizeof(buf.prio) + log_msg->entry_v4.hdr_size;
return ret + sizeof(buf.prio) + log_msg->entry.hdr_size;
}
fd = atomic_load(&transp->context.fd);
@ -215,7 +215,7 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref
struct android_log_transport_context transp;
struct content {
struct listnode node;
struct logger_entry_v4 entry;
struct logger_entry entry;
} * content;
struct names {
struct listnode node;
@ -267,25 +267,26 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref
}
/* Read the file content */
while (pmsgRead(&logger_list, &transp, &transp.logMsg) > 0) {
log_msg log_msg;
while (pmsgRead(&logger_list, &transp, &log_msg) > 0) {
const char* cp;
size_t hdr_size = transp.logMsg.entry.hdr_size ? transp.logMsg.entry.hdr_size
: sizeof(transp.logMsg.entry_v1);
char* msg = (char*)&transp.logMsg + hdr_size;
size_t hdr_size = log_msg.entry.hdr_size;
char* msg = (char*)&log_msg + hdr_size;
const char* split = NULL;
if ((hdr_size < sizeof(transp.logMsg.entry_v1)) || (hdr_size > sizeof(transp.logMsg.entry))) {
if (hdr_size != sizeof(log_msg.entry)) {
continue;
}
/* Check for invalid sequence number */
if ((transp.logMsg.entry.nsec % ANDROID_LOG_PMSG_FILE_SEQUENCE) ||
((transp.logMsg.entry.nsec / ANDROID_LOG_PMSG_FILE_SEQUENCE) >=
ANDROID_LOG_PMSG_FILE_MAX_SEQUENCE)) {
if (log_msg.entry.nsec % ANDROID_LOG_PMSG_FILE_SEQUENCE ||
(log_msg.entry.nsec / ANDROID_LOG_PMSG_FILE_SEQUENCE) >=
ANDROID_LOG_PMSG_FILE_MAX_SEQUENCE) {
continue;
}
/* Determine if it has <dirbase>:<filebase> format for tag */
len = transp.logMsg.entry.len - sizeof(prio);
len = log_msg.entry.len - sizeof(prio);
for (cp = msg + sizeof(prio); *cp && isprint(*cp) && !isspace(*cp) && --len; ++cp) {
if (*cp == ':') {
if (split) {
@ -331,8 +332,8 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref
/* check if there is an existing entry */
list_for_each(node, &name_list) {
names = node_to_item(node, struct names, node);
if (!strcmp(names->name, msg + sizeof(prio)) && (names->id == transp.logMsg.entry.lid) &&
(names->prio == *msg)) {
if (!strcmp(names->name, msg + sizeof(prio)) && names->id == log_msg.entry.lid &&
names->prio == *msg) {
break;
}
}
@ -349,7 +350,7 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref
break;
}
strcpy(names->name, msg + sizeof(prio));
names->id = static_cast<log_id_t>(transp.logMsg.entry.lid);
names->id = static_cast<log_id_t>(log_msg.entry.lid);
names->prio = *msg;
list_init(&names->content);
/*
@ -402,7 +403,7 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref
/* Remove any file fragments that match our sequence number */
list_for_each_safe(node, n, &names->content) {
content = node_to_item(node, struct content, node);
if (transp.logMsg.entry.nsec == content->entry.nsec) {
if (log_msg.entry.nsec == content->entry.nsec) {
list_remove(&content->node);
free(content);
}
@ -410,16 +411,16 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref
/* Add content */
content = static_cast<struct content*>(
calloc(1, sizeof(content->node) + hdr_size + transp.logMsg.entry.len));
calloc(1, sizeof(content->node) + hdr_size + log_msg.entry.len));
if (!content) {
ret = -ENOMEM;
break;
}
memcpy(&content->entry, &transp.logMsg.entry, hdr_size + transp.logMsg.entry.len);
memcpy(&content->entry, &log_msg.entry, hdr_size + log_msg.entry.len);
/* Insert in sequence number sorted order, to ease reconstruction */
list_for_each_reverse(node, &names->content) {
if ((node_to_item(node, struct content, node))->entry.nsec < transp.logMsg.entry.nsec) {
if ((node_to_item(node, struct content, node))->entry.nsec < log_msg.entry.nsec) {
break;
}
}

12
liblog/tests/liblog_test.cpp
View file

@ -385,7 +385,7 @@ static void bswrite_test(const char* message) {
fprintf(stderr, "Expect \"Binary log entry conversion failed\"\n");
}
int processBinaryLogBuffer = android_log_processBinaryLogBuffer(
&log_msg.entry_v1, &entry, NULL, msgBuf, sizeof(msgBuf));
&log_msg.entry, &entry, nullptr, msgBuf, sizeof(msgBuf));
EXPECT_EQ((length == total) ? 0 : -1, processBinaryLogBuffer);
if ((processBinaryLogBuffer == 0) || entry.message) {
size_t line_overhead = 20;
@ -469,8 +469,7 @@ static void buf_write_test(const char* message) {
AndroidLogFormat* logformat = android_log_format_new();
EXPECT_TRUE(NULL != logformat);
AndroidLogEntry entry;
int processLogBuffer =
android_log_processLogBuffer(&log_msg.entry_v1, &entry);
int processLogBuffer = android_log_processLogBuffer(&log_msg.entry, &entry);
EXPECT_EQ(0, processLogBuffer);
if (processLogBuffer == 0) {
size_t line_overhead = 11;
@ -1013,8 +1012,7 @@ TEST(liblog, __android_log_buf_print__maxtag) {
AndroidLogFormat* logformat = android_log_format_new();
EXPECT_TRUE(NULL != logformat);
AndroidLogEntry entry;
int processLogBuffer =
android_log_processLogBuffer(&log_msg.entry_v1, &entry);
int processLogBuffer = android_log_processLogBuffer(&log_msg.entry, &entry);
EXPECT_EQ(0, processLogBuffer);
if (processLogBuffer == 0) {
fflush(stderr);
@ -2507,8 +2505,8 @@ static void create_android_logger(const char* (*fn)(uint32_t tag,
EXPECT_TRUE(NULL != logformat);
AndroidLogEntry entry;
char msgBuf[1024];
int processBinaryLogBuffer = android_log_processBinaryLogBuffer(
&log_msg.entry_v1, &entry, NULL, msgBuf, sizeof(msgBuf));
int processBinaryLogBuffer =
android_log_processBinaryLogBuffer(&log_msg.entry, &entry, nullptr, msgBuf, sizeof(msgBuf));
EXPECT_EQ(0, processBinaryLogBuffer);
if (processBinaryLogBuffer == 0) {
int line_overhead = 20;

7
logcat/logcat.cpp
View file

@ -337,13 +337,12 @@ static void processBuffer(android_logcat_context_internal* context,
context->eventTagMap = android_openEventTagMap(nullptr);
context->hasOpenedEventTagMap = true;
}
err = android_log_processBinaryLogBuffer(
&buf->entry_v1, &entry, context->eventTagMap, binaryMsgBuf,
sizeof(binaryMsgBuf));
err = android_log_processBinaryLogBuffer(&buf->entry, &entry, context->eventTagMap,
binaryMsgBuf, sizeof(binaryMsgBuf));
// printf(">>> pri=%d len=%d msg='%s'\n",
// entry.priority, entry.messageLen, entry.message);
} else {
err = android_log_processLogBuffer(&buf->entry_v1, &entry);
err = android_log_processLogBuffer(&buf->entry, &entry);
}
if ((err < 0) && !context->debug) return;

4
logd/LogBufferElement.cpp
View file

@ -245,9 +245,9 @@ size_t LogBufferElement::populateDroppedMessage(char*& buffer, LogBuffer* parent
}
log_time LogBufferElement::flushTo(SocketClient* reader, LogBuffer* parent, bool lastSame) {
struct logger_entry_v4 entry = {};
struct logger_entry entry = {};
entry.hdr_size = sizeof(struct logger_entry_v4);
entry.hdr_size = sizeof(struct logger_entry);
entry.lid = mLogId;
entry.pid = mPid;
entry.tid = mTid;

4
logd/LogTags.cpp
View file

@ -311,9 +311,7 @@ void LogTags::ReadPersistEventLogTags() {
if (log_msg.entry.len <= sizeof(uint32_t)) continue;
uint32_t Tag = get4LE(msg);
if (Tag != TAG_DEF_LOG_TAG) continue;
uid_t uid = (log_msg.entry.hdr_size >= sizeof(logger_entry_v4))
? log_msg.entry.uid
: AID_ROOT;
uid_t uid = log_msg.entry.uid;
std::string Name;
std::string Format;

55
logd/tests/logd_test.cpp
View file

@ -241,47 +241,18 @@ TEST(logd, statistics) {
static void caught_signal(int /* signum */) {
}
static void dump_log_msg(const char* prefix, log_msg* msg, unsigned int version,
int lid) {
static void dump_log_msg(const char* prefix, log_msg* msg, int lid) {
std::cout << std::flush;
std::cerr << std::flush;
fflush(stdout);
fflush(stderr);
switch (msg->entry.hdr_size) {
case 0:
version = 1;
break;
EXPECT_EQ(sizeof(logger_entry), msg->entry.hdr_size);
case sizeof(msg->entry_v2): /* PLUS case sizeof(msg->entry_v3): */
if (version == 0) {
version = (msg->entry_v3.lid < LOG_ID_MAX) ? 3 : 2;
}
break;
case sizeof(msg->entry_v4):
if (version == 0) {
version = 4;
}
break;
}
fprintf(stderr, "%s: v%u[%u] ", prefix, version, msg->len());
if (version != 1) {
fprintf(stderr, "hdr_size=%u ", msg->entry.hdr_size);
}
fprintf(stderr, "pid=%u tid=%u %u.%09u ", msg->entry.pid, msg->entry.tid,
msg->entry.sec, msg->entry.nsec);
switch (version) {
case 1:
break;
case 2:
fprintf(stderr, "euid=%u ", msg->entry_v2.euid);
break;
case 3:
default:
lid = msg->entry.lid;
break;
}
fprintf(stderr, "%s: [%u] ", prefix, msg->len());
fprintf(stderr, "hdr_size=%u ", msg->entry.hdr_size);
fprintf(stderr, "pid=%u tid=%u %u.%09u ", msg->entry.pid, msg->entry.tid, msg->entry.sec,
msg->entry.nsec);
lid = msg->entry.lid;
switch (lid) {
case 0:
@ -584,11 +555,11 @@ void timeout_negative(const char* command) {
}
if (content_wrap) {
dump_log_msg("wrap", &msg_wrap, 3, -1);
dump_log_msg("wrap", &msg_wrap, -1);
}
if (content_timeout) {
dump_log_msg("timeout", &msg_timeout, 3, -1);
dump_log_msg("timeout", &msg_timeout, -1);
}
EXPECT_TRUE(written);
@ -721,11 +692,11 @@ TEST(logd, timeout) {
}
if (content_wrap) {
dump_log_msg("wrap", &msg_wrap, 3, -1);
dump_log_msg("wrap", &msg_wrap, -1);
}
if (content_timeout) {
dump_log_msg("timeout", &msg_timeout, 3, -1);
dump_log_msg("timeout", &msg_timeout, -1);
}
if (content_wrap || !content_timeout) {
@ -776,7 +747,7 @@ TEST(logd, SNDTIMEO) {
EXPECT_TRUE(read_one);
if (read_one) {
dump_log_msg("user", &msg, 3, -1);
dump_log_msg("user", &msg, -1);
}
fprintf(stderr, "Sleep for >%d seconds logd SO_SNDTIMEO ...\n", sndtimeo);
@ -794,7 +765,7 @@ TEST(logd, SNDTIMEO) {
EXPECT_EQ(0, recv_ret);
if (recv_ret > 0) {
dump_log_msg("user", &msg, 3, -1);
dump_log_msg("user", &msg, -1);
}
EXPECT_EQ(0, save_errno);