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

Commit d755f5df authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Don't depend on libbase result.h" into main am: 6c746778 

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/2814533



Change-Id: Ie6d707252c4b2364ece39b583246069a011ff961
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 4f556cbc 6c746778

libs/binder/FdTrigger.h

+0 −1
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 


#include <memory>



#include <android-base/result.h>

#include <android-base/unique_fd.h>

#include <utils/Errors.h>

libs/binder/OS.h

+1 −2
Original line number Diff line number Diff line
@@ -18,14 +18,13 @@ 
#include <stddef.h>

#include <cstdint>



#include <android-base/result.h>

#include <android-base/unique_fd.h>

#include <binder/RpcTransport.h>

#include <utils/Errors.h>



namespace android::binder::os {



android::base::Result<void> setNonBlocking(android::base::borrowed_fd fd);

status_t setNonBlocking(android::base::borrowed_fd fd);



status_t getRandomBytes(uint8_t* data, size_t size);

libs/binder/OS_unix_base.cpp

+7 −7
Original line number Diff line number Diff line
@@ -15,29 +15,29 @@ 
 */



#include "OS.h"

#include "Utils.h"



#include <android-base/file.h>

#include <binder/RpcTransportRaw.h>

#include <log/log.h>

#include <string.h>



using android::base::ErrnoError;

using android::base::Result;



namespace android::binder::os {



// Linux kernel supports up to 253 (from SCM_MAX_FD) for unix sockets.

constexpr size_t kMaxFdsPerMsg = 253;



Result<void> setNonBlocking(android::base::borrowed_fd fd) {

status_t setNonBlocking(android::base::borrowed_fd fd) {

    int flags = TEMP_FAILURE_RETRY(fcntl(fd.get(), F_GETFL));

    if (flags == -1) {

        return ErrnoError() << "Could not get flags for fd";

        PLOGE("Failed setNonBlocking: Could not get flags for fd");

        return -errno;

    }

    if (int ret = TEMP_FAILURE_RETRY(fcntl(fd.get(), F_SETFL, flags | O_NONBLOCK)); ret == -1) {

        return ErrnoError() << "Could not set non-blocking flag for fd";

        PLOGE("Failed setNonBlocking: Could not set non-blocking flag for fd");

        return -errno;

    }

    return {};

    return OK;

}



status_t getRandomBytes(uint8_t* data, size_t size) {

libs/binder/ProcessState.cpp

+22 −23
Original line number Diff line number Diff line
@@ -18,7 +18,6 @@ 


#include <binder/ProcessState.h>



#include <android-base/result.h>

#include <android-base/scopeguard.h>

#include <android-base/strings.h>

#include <binder/BpBinder.h>
@@ -32,6 +31,7 @@ 
#include <utils/Thread.h>



#include "Static.h"

#include "Utils.h"

#include "binder_module.h"



#include <errno.h>
@@ -512,31 +512,31 @@ String8 ProcessState::getDriverName() { 
    return mDriverName;

}



static base::Result<int> open_driver(const char* driver) {

    int fd = open(driver, O_RDWR | O_CLOEXEC);

    if (fd < 0) {

        return base::ErrnoError() << "Opening '" << driver << "' failed";

static base::unique_fd open_driver(const char* driver) {

    auto fd = base::unique_fd(open(driver, O_RDWR | O_CLOEXEC));

    if (!fd.ok()) {

        PLOGE("Opening '%s' failed", driver);

        return {};

    }

    int vers = 0;

    status_t result = ioctl(fd, BINDER_VERSION, &vers);

    int result = ioctl(fd.get(), BINDER_VERSION, &vers);

    if (result == -1) {

        close(fd);

        return base::ErrnoError() << "Binder ioctl to obtain version failed";

        PLOGE("Binder ioctl to obtain version failed");

        return {};

    }

    if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) {

        close(fd);

        return base::Error() << "Binder driver protocol(" << vers

                             << ") does not match user space protocol("

                             << BINDER_CURRENT_PROTOCOL_VERSION

                             << ")! ioctl() return value: " << result;

        ALOGE("Binder driver protocol(%d) does not match user space protocol(%d)! "

              "ioctl() return value: %d",

              vers, BINDER_CURRENT_PROTOCOL_VERSION, result);

        return {};

    }

    size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;

    result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);

    result = ioctl(fd.get(), BINDER_SET_MAX_THREADS, &maxThreads);

    if (result == -1) {

        ALOGE("Binder ioctl to set max threads failed: %s", strerror(errno));

    }

    uint32_t enable = DEFAULT_ENABLE_ONEWAY_SPAM_DETECTION;

    result = ioctl(fd, BINDER_ENABLE_ONEWAY_SPAM_DETECTION, &enable);

    result = ioctl(fd.get(), BINDER_ENABLE_ONEWAY_SPAM_DETECTION, &enable);

    if (result == -1) {

        ALOGE_IF(ProcessState::isDriverFeatureEnabled(

                     ProcessState::DriverFeature::ONEWAY_SPAM_DETECTION),
@@ -561,28 +561,27 @@ ProcessState::ProcessState(const char* driver) 
        mThreadPoolStarted(false),

        mThreadPoolSeq(1),

        mCallRestriction(CallRestriction::NONE) {

    base::Result<int> opened = open_driver(driver);

    base::unique_fd opened = open_driver(driver);



    if (opened.ok()) {

        // mmap the binder, providing a chunk of virtual address space to receive transactions.

        mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE,

                        opened.value(), 0);

                        opened.get(), 0);

        if (mVMStart == MAP_FAILED) {

            close(opened.value());

            // *sigh*

            opened = base::Error()

                    << "Using " << driver << " failed: unable to mmap transaction memory.";

            ALOGE("Using %s failed: unable to mmap transaction memory.", driver);

            opened.reset();

            mDriverName.clear();

        }

    }



#ifdef __ANDROID__

    LOG_ALWAYS_FATAL_IF(!opened.ok(), "Binder driver '%s' could not be opened. Terminating: %s",

                        driver, opened.error().message().c_str());

    LOG_ALWAYS_FATAL_IF(!opened.ok(), "Binder driver '%s' could not be opened. Terminating.",

                        driver);

#endif



    if (opened.ok()) {

        mDriverFD = opened.value();

        mDriverFD = opened.release();

    }

}

libs/binder/RpcServer.cpp

+1 −4
Original line number Diff line number Diff line
@@ -230,10 +230,7 @@ status_t RpcServer::recvmsgSocketConnection(const RpcServer& server, RpcTranspor 
    }



    unique_fd fd(std::move(std::get<unique_fd>(fds.back())));

    if (auto res = binder::os::setNonBlocking(fd); !res.ok()) {

        ALOGE("Failed setNonBlocking: %s", res.error().message().c_str());

        return res.error().code() == 0 ? UNKNOWN_ERROR : -res.error().code();

    }

    if (status_t res = binder::os::setNonBlocking(fd); res != OK) return res;



    *out = RpcTransportFd(std::move(fd));

    return OK;