Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 004cd3c5 authored by Mark Salyzyn's avatar Mark Salyzyn
Browse files

liblog: logd: logcat: deprecate log/log_read.h 

Always used in combination with log/logger.h except in log_time.cpp,
and not used externally.  As a result liblog has to support stl, a
small price to pay since goal is to convert liblog to C++ internally.

Test: compile
Bug: 31456426
Bug: 26552300
Bug: 31289077
Change-Id: I72828ec807d0a2c8e40bbdebd7a69f147a7ca5a9
parent 8eaaac01

include/log/log_read.h

deleted100644 → 0
+0 −170
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2013-2014 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef _LIBS_LOG_LOG_READ_H

#define _LIBS_LOG_LOG_READ_H



#include <stdint.h>

#include <time.h>



/* struct log_time is a wire-format variant of struct timespec */

#define NS_PER_SEC 1000000000ULL



#ifdef __cplusplus



// NB: do NOT define a copy constructor. This will result in structure

// no longer being compatible with pass-by-value which is desired

// efficient behavior. Also, pass-by-reference breaks C/C++ ABI.

struct log_time {

public:

    uint32_t tv_sec; // good to Feb 5 2106

    uint32_t tv_nsec;



    static const uint32_t tv_sec_max = 0xFFFFFFFFUL;

    static const uint32_t tv_nsec_max = 999999999UL;



    log_time(const timespec &T)

    {

        tv_sec = T.tv_sec;

        tv_nsec = T.tv_nsec;

    }

    log_time(uint32_t sec, uint32_t nsec)

    {

        tv_sec = sec;

        tv_nsec = nsec;

    }

    static const timespec EPOCH;

    log_time()

    {

    }

    log_time(clockid_t id)

    {

        timespec T;

        clock_gettime(id, &T);

        tv_sec = T.tv_sec;

        tv_nsec = T.tv_nsec;

    }

    log_time(const char *T)

    {

        const uint8_t *c = (const uint8_t *) T;

        tv_sec = c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24);

        tv_nsec = c[4] | (c[5] << 8) | (c[6] << 16) | (c[7] << 24);

    }



    // timespec

    bool operator== (const timespec &T) const

    {

        return (tv_sec == static_cast<uint32_t>(T.tv_sec))

            && (tv_nsec == static_cast<uint32_t>(T.tv_nsec));

    }

    bool operator!= (const timespec &T) const

    {

        return !(*this == T);

    }

    bool operator< (const timespec &T) const

    {

        return (tv_sec < static_cast<uint32_t>(T.tv_sec))

            || ((tv_sec == static_cast<uint32_t>(T.tv_sec))

                && (tv_nsec < static_cast<uint32_t>(T.tv_nsec)));

    }

    bool operator>= (const timespec &T) const

    {

        return !(*this < T);

    }

    bool operator> (const timespec &T) const

    {

        return (tv_sec > static_cast<uint32_t>(T.tv_sec))

            || ((tv_sec == static_cast<uint32_t>(T.tv_sec))

                && (tv_nsec > static_cast<uint32_t>(T.tv_nsec)));

    }

    bool operator<= (const timespec &T) const

    {

        return !(*this > T);

    }

    log_time operator-= (const timespec &T);

    log_time operator- (const timespec &T) const

    {

        log_time local(*this);

        return local -= T;

    }

    log_time operator+= (const timespec &T);

    log_time operator+ (const timespec &T) const

    {

        log_time local(*this);

        return local += T;

    }



    // log_time

    bool operator== (const log_time &T) const

    {

        return (tv_sec == T.tv_sec) && (tv_nsec == T.tv_nsec);

    }

    bool operator!= (const log_time &T) const

    {

        return !(*this == T);

    }

    bool operator< (const log_time &T) const

    {

        return (tv_sec < T.tv_sec)

            || ((tv_sec == T.tv_sec) && (tv_nsec < T.tv_nsec));

    }

    bool operator>= (const log_time &T) const

    {

        return !(*this < T);

    }

    bool operator> (const log_time &T) const

    {

        return (tv_sec > T.tv_sec)

            || ((tv_sec == T.tv_sec) && (tv_nsec > T.tv_nsec));

    }

    bool operator<= (const log_time &T) const

    {

        return !(*this > T);

    }

    log_time operator-= (const log_time &T);

    log_time operator- (const log_time &T) const

    {

        log_time local(*this);

        return local -= T;

    }

    log_time operator+= (const log_time &T);

    log_time operator+ (const log_time &T) const

    {

        log_time local(*this);

        return local += T;

    }



    uint64_t nsec() const

    {

        return static_cast<uint64_t>(tv_sec) * NS_PER_SEC + tv_nsec;

    }



    static const char default_format[];



    // Add %#q for the fraction of a second to the standard library functions

    char *strptime(const char *s, const char *format = default_format);

} __attribute__((__packed__));



#else



typedef struct log_time {

    uint32_t tv_sec;

    uint32_t tv_nsec;

} __attribute__((__packed__)) log_time;



#endif



#endif /* define _LIBS_LOG_LOG_READ_H */

include/log/logger.h

+150 −6
Original line number Diff line number Diff line
@@ -11,16 +11,13 @@ 
#define _LIBS_LOG_LOGGER_H



#include <stdint.h>

#ifdef __linux__

#include <time.h> /* clockid_t definition */

#endif

#include <time.h>



#ifdef __cplusplus

#include <string>

#endif



#include <log/log.h>

#include <log/log_read.h>



#ifdef __cplusplus

extern "C" {
@@ -80,6 +77,155 @@ struct logger_entry_v4 { 
    char        msg[0];    /* the entry's payload */

} __attribute__((__packed__));



/* struct log_time is a wire-format variant of struct timespec */

#define NS_PER_SEC 1000000000ULL



#ifdef __cplusplus



// NB: do NOT define a copy constructor. This will result in structure

// no longer being compatible with pass-by-value which is desired

// efficient behavior. Also, pass-by-reference breaks C/C++ ABI.

struct log_time {

public:

    uint32_t tv_sec; // good to Feb 5 2106

    uint32_t tv_nsec;



    static const uint32_t tv_sec_max = 0xFFFFFFFFUL;

    static const uint32_t tv_nsec_max = 999999999UL;



    log_time(const timespec &T)

    {

        tv_sec = T.tv_sec;

        tv_nsec = T.tv_nsec;

    }

    log_time(uint32_t sec, uint32_t nsec)

    {

        tv_sec = sec;

        tv_nsec = nsec;

    }

    static const timespec EPOCH;

    log_time()

    {

    }

#ifdef __linux__

    log_time(clockid_t id)

    {

        timespec T;

        clock_gettime(id, &T);

        tv_sec = T.tv_sec;

        tv_nsec = T.tv_nsec;

    }

#endif

    log_time(const char *T)

    {

        const uint8_t *c = (const uint8_t *) T;

        tv_sec = c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24);

        tv_nsec = c[4] | (c[5] << 8) | (c[6] << 16) | (c[7] << 24);

    }



    // timespec

    bool operator== (const timespec &T) const

    {

        return (tv_sec == static_cast<uint32_t>(T.tv_sec))

            && (tv_nsec == static_cast<uint32_t>(T.tv_nsec));

    }

    bool operator!= (const timespec &T) const

    {

        return !(*this == T);

    }

    bool operator< (const timespec &T) const

    {

        return (tv_sec < static_cast<uint32_t>(T.tv_sec))

            || ((tv_sec == static_cast<uint32_t>(T.tv_sec))

                && (tv_nsec < static_cast<uint32_t>(T.tv_nsec)));

    }

    bool operator>= (const timespec &T) const

    {

        return !(*this < T);

    }

    bool operator> (const timespec &T) const

    {

        return (tv_sec > static_cast<uint32_t>(T.tv_sec))

            || ((tv_sec == static_cast<uint32_t>(T.tv_sec))

                && (tv_nsec > static_cast<uint32_t>(T.tv_nsec)));

    }

    bool operator<= (const timespec &T) const

    {

        return !(*this > T);

    }

    log_time operator-= (const timespec &T);

    log_time operator- (const timespec &T) const

    {

        log_time local(*this);

        return local -= T;

    }

    log_time operator+= (const timespec &T);

    log_time operator+ (const timespec &T) const

    {

        log_time local(*this);

        return local += T;

    }



    // log_time

    bool operator== (const log_time &T) const

    {

        return (tv_sec == T.tv_sec) && (tv_nsec == T.tv_nsec);

    }

    bool operator!= (const log_time &T) const

    {

        return !(*this == T);

    }

    bool operator< (const log_time &T) const

    {

        return (tv_sec < T.tv_sec)

            || ((tv_sec == T.tv_sec) && (tv_nsec < T.tv_nsec));

    }

    bool operator>= (const log_time &T) const

    {

        return !(*this < T);

    }

    bool operator> (const log_time &T) const

    {

        return (tv_sec > T.tv_sec)

            || ((tv_sec == T.tv_sec) && (tv_nsec > T.tv_nsec));

    }

    bool operator<= (const log_time &T) const

    {

        return !(*this > T);

    }

    log_time operator-= (const log_time &T);

    log_time operator- (const log_time &T) const

    {

        log_time local(*this);

        return local -= T;

    }

    log_time operator+= (const log_time &T);

    log_time operator+ (const log_time &T) const

    {

        log_time local(*this);

        return local += T;

    }



    uint64_t nsec() const

    {

        return static_cast<uint64_t>(tv_sec) * NS_PER_SEC + tv_nsec;

    }



    static const char default_format[];



    // Add %#q for the fraction of a second to the standard library functions

    char *strptime(const char *s, const char *format = default_format);

} __attribute__((__packed__));



#else



typedef struct log_time {

    uint32_t tv_sec;

    uint32_t tv_nsec;

} __attribute__((__packed__)) log_time;



#endif



/*

 * The maximum size of the log entry payload that can be

 * written to the logger. An attempt to write more than
@@ -94,8 +240,6 @@ struct logger_entry_v4 { 
 */

#define LOGGER_ENTRY_MAX_LEN    (5*1024)



#define NS_PER_SEC 1000000000ULL



struct log_msg {

    union {

        unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];

include/private/android_logger.h

+6 −5
Original line number Diff line number Diff line
@@ -25,10 +25,14 @@ 
#include <sys/types.h>



#include <log/log.h>

#include <log/log_read.h>

#include <log/logger.h>



#define LOGGER_MAGIC 'l'



#if defined(__cplusplus)

extern "C" {

#endif



/* Header Structure to pstore */

typedef struct __attribute__((__packed__)) {

    uint8_t magic;
@@ -84,6 +88,7 @@ typedef struct __attribute__((__packed__)) { 
 * in C++.

 * http://stackoverflow.com/questions/4412749/are-flexible-array-members-valid-in-c

 */



typedef struct __attribute__((__packed__)) {

    int8_t type;    // EVENT_TYPE_STRING;

    int32_t length; // Little Endian Order
@@ -98,10 +103,6 @@ typedef struct __attribute__((__packed__)) { 
    char data[];

} android_log_event_string_t;



#if defined(__cplusplus)

extern "C" {

#endif



#define ANDROID_LOG_PMSG_FILE_MAX_SEQUENCE 256 /* 1MB file */

#define ANDROID_LOG_PMSG_FILE_SEQUENCE     1000

liblog/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -89,7 +89,6 @@ cc_library { 
    ],

    logtags: ["event.logtags"],

    compile_multilib: "both",

    stl: "none",

}



ndk_library {

liblog/log_time.cpp

+1 −1
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 
#include <stdio.h>

#include <string.h>



#include <log/log_read.h>

#include <log/logger.h>



#include "log_portability.h"