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

Commit 86e65989 authored by Elliott Hughes's avatar Elliott Hughes Committed by Automerger Merge Worker
Browse files

Merge "libcutils: clean up the ashmem code a bit." into main am: 88cb60c8 

Original change: https://android-review.googlesource.com/c/platform/system/core/+/3506451



Change-Id: I5b032486c5a55b3374cdfedf568b0d4666d0b863
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents d17dd1f3 88cb60c8

libcutils/ashmem-dev.cpp

+61 −113
Original line number Diff line number Diff line
@@ -76,8 +76,8 @@ static pthread_mutex_t __ashmem_lock = PTHREAD_MUTEX_INITIALIZER; 
 * debugging.

 */



static bool debug_log = false;            /* set to true for verbose logging and other debug  */

static bool pin_deprecation_warn = true; /* Log the pin deprecation warning only once */

/* set to true for verbose logging and other debug  */

static bool debug_log = false;



/* Determine if vendor processes would be ok with memfd in the system:

 *
@@ -120,11 +120,9 @@ static bool __has_memfd_support() { 
    // permissions of the buffer (i.e. they cannot be changed by fchmod()).

    //

    // MFD_NOEXEC_SEAL implies MFD_ALLOW_SEALING.

    const char *test_buf_name = "test_android_memfd";

    size_t buf_size = getpagesize();



    android::base::unique_fd fd(

            syscall(__NR_memfd_create, test_buf_name, MFD_CLOEXEC | MFD_NOEXEC_SEAL));

            syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_NOEXEC_SEAL));

    if (fd == -1) {

        ALOGE("memfd_create failed: %m, no memfd support");

        return false;
@@ -135,9 +133,9 @@ static bool __has_memfd_support() { 
        return false;

    }



    size_t buf_size = getpagesize();

    if (ftruncate(fd, buf_size) == -1) {

        ALOGE("ftruncate(%s, %zd) failed to set memfd buffer size: %m, no memfd support",

              test_buf_name, buf_size);

        ALOGE("ftruncate(%zd) failed to set memfd buffer size: %m, no memfd support", buf_size);

        return false;

    }
@@ -159,11 +157,7 @@ static bool __has_memfd_support() { 
}



static bool has_memfd_support() {

    /* memfd_supported is the initial global per-process state of what is known

     * about memfd.

     */

    static bool memfd_supported = __has_memfd_support();



    return memfd_supported;

}
@@ -173,75 +167,64 @@ static std::string get_ashmem_device_path() { 
    if (!android::base::ReadFileToString(boot_id_path, &boot_id)) {

        ALOGE("Failed to read %s: %m", boot_id_path.c_str());

        return "";

    };

    }

    boot_id = android::base::Trim(boot_id);



    return "/dev/ashmem" + boot_id;

}



/* logistics of getting file descriptor for ashmem */

static int __ashmem_open_locked()

{

static int __ashmem_open_locked() {

    static const std::string ashmem_device_path = get_ashmem_device_path();



    if (ashmem_device_path.empty()) {

        return -1;

    }



    int fd = TEMP_FAILURE_RETRY(open(ashmem_device_path.c_str(), O_RDWR | O_CLOEXEC));



    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(ashmem_device_path.c_str(), O_RDWR | O_CLOEXEC)));

    int errno1 = errno;

    // fallback for APEX w/ use_vendor on Q, which would have still used /dev/ashmem

    if (fd < 0) {

        int saved_errno = errno;

        fd = TEMP_FAILURE_RETRY(open("/dev/ashmem", O_RDWR | O_CLOEXEC));

        if (fd < 0) {

    // TODO: remove this?

    if (!fd.ok()) {

        fd.reset(TEMP_FAILURE_RETRY(open("/dev/ashmem", O_RDWR | O_CLOEXEC)));

        int errno2 = errno;

        if (!fd.ok()) {

            /* Q launching devices and newer must not reach here since they should have been

             * able to open ashmem_device_path */

            ALOGE("Unable to open ashmem device %s (error = %s) and /dev/ashmem(error = %s)",

                  ashmem_device_path.c_str(), strerror(saved_errno), strerror(errno));

            return fd;

            ALOGE("Unable to open ashmem device %s (%s) and /dev/ashmem (%s)",

                  ashmem_device_path.c_str(), strerror(errno1), strerror(errno2));

            return -1;

        }

    }



    struct stat st;

    int ret = TEMP_FAILURE_RETRY(fstat(fd, &st));

    if (ret < 0) {

        int save_errno = errno;

        close(fd);

        errno = save_errno;

        return ret;

    if (TEMP_FAILURE_RETRY(fstat(fd, &st)) == -1) {

        return -1;

    }

    if (!S_ISCHR(st.st_mode) || !st.st_rdev) {

        close(fd);

        errno = ENOTTY;

        return -1;

    }



    __ashmem_rdev = st.st_rdev;

    return fd;

    return fd.release();

}



static int __ashmem_open()

{

    int fd;



static int __ashmem_open() {

    pthread_mutex_lock(&__ashmem_lock);

    fd = __ashmem_open_locked();

    int fd = __ashmem_open_locked();

    pthread_mutex_unlock(&__ashmem_lock);



    return fd;

}



/* Make sure file descriptor references ashmem, negative number means false */

static int __ashmem_is_ashmem(int fd, int fatal)

{

    dev_t rdev;

static int __ashmem_is_ashmem(int fd, bool fatal) {

    struct stat st;



    if (fstat(fd, &st) < 0) {

        return -1;

    }



    rdev = 0; /* Too much complexity to sniff __ashmem_rdev */

    dev_t rdev = 0; /* Too much complexity to sniff __ashmem_rdev */

    if (S_ISCHR(st.st_mode) && st.st_rdev) {

        pthread_mutex_lock(&__ashmem_lock);

        rdev = __ashmem_rdev;
@@ -282,16 +265,15 @@ static int __ashmem_is_ashmem(int fd, int fatal) 
    return -1;

}



static int __ashmem_check_failure(int fd, int result)

{

    if (result == -1 && errno == ENOTTY) __ashmem_is_ashmem(fd, 1);

static int __ashmem_check_failure(int fd, int result) {

    if (result == -1 && errno == ENOTTY) __ashmem_is_ashmem(fd, true);

    return result;

}



static bool memfd_is_ashmem(int fd) {

static bool is_ashmem_fd(int fd) {

    static bool fd_check_error_once = false;



    if (__ashmem_is_ashmem(fd, 0) == 0) {

    if (__ashmem_is_ashmem(fd, false) == 0) {

        if (!fd_check_error_once) {

            ALOGE("memfd: memfd expected but ashmem fd used - please use libcutils");

            fd_check_error_once = true;
@@ -303,13 +285,16 @@ static bool memfd_is_ashmem(int fd) { 
    return false;

}



int ashmem_valid(int fd)

{

    if (has_memfd_support() && !memfd_is_ashmem(fd)) {

static bool is_memfd_fd(int fd) {

    return has_memfd_support() && !is_ashmem_fd(fd);

}



int ashmem_valid(int fd) {

    if (is_memfd_fd(fd)) {

        return 1;

    }



    return __ashmem_is_ashmem(fd, 0) >= 0;

    return __ashmem_is_ashmem(fd, false) >= 0;

}



static int memfd_create_region(const char* name, size_t size) {
@@ -352,41 +337,20 @@ static int memfd_create_region(const char* name, size_t size) { 
 * `name' is an optional label to give the region (visible in /proc/pid/maps)

 * `size' is the size of the region, in page-aligned bytes

 */

int ashmem_create_region(const char *name, size_t size)

{

    int ret, save_errno;

int ashmem_create_region(const char* name, size_t size) {

    if (name == NULL) name = "none";



    if (has_memfd_support()) {

        return memfd_create_region(name ? name : "none", size);

    }



    int fd = __ashmem_open();

    if (fd < 0) {

        return fd;

    }



    if (name) {

        char buf[ASHMEM_NAME_LEN] = {0};



        strlcpy(buf, name, sizeof(buf));

        ret = TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_NAME, buf));

        if (ret < 0) {

            goto error;

        }

        return memfd_create_region(name, size);

    }



    ret = TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_SIZE, size));

    if (ret < 0) {

        goto error;

    android::base::unique_fd fd(__ashmem_open());

    if (!fd.ok() ||

        TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_NAME, name) < 0) ||

        TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_SIZE, size) < 0)) {

        return -1;

    }



    return fd;



error:

    save_errno = errno;

    close(fd);

    errno = save_errno;

    return ret;

    return fd.release();

}



static int memfd_set_prot_region(int fd, int prot) {
@@ -418,61 +382,45 @@ static int memfd_set_prot_region(int fd, int prot) { 
    return 0;

}



int ashmem_set_prot_region(int fd, int prot)

{

    if (has_memfd_support() && !memfd_is_ashmem(fd)) {

int ashmem_set_prot_region(int fd, int prot) {

    if (is_memfd_fd(fd)) {

        return memfd_set_prot_region(fd, prot);

    }



    return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_PROT_MASK, prot)));

}



int ashmem_pin_region(int fd, size_t offset, size_t len)

{

    if (!pin_deprecation_warn || debug_log) {

static int do_pin(int op, int fd, size_t offset, size_t length) {

    static bool already_warned_about_pin_deprecation = false;

    if (!already_warned_about_pin_deprecation || debug_log) {

        ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.");

        pin_deprecation_warn = true;

        already_warned_about_pin_deprecation = true;

    }



    if (has_memfd_support() && !memfd_is_ashmem(fd)) {

    if (is_memfd_fd(fd)) {

        return 0;

    }



    // TODO: should LP64 reject too-large offset/len?

    ashmem_pin pin = { static_cast<uint32_t>(offset), static_cast<uint32_t>(len) };

    return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_PIN, &pin)));

}



int ashmem_unpin_region(int fd, size_t offset, size_t len)

{

    if (!pin_deprecation_warn || debug_log) {

        ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.");

        pin_deprecation_warn = true;

    ashmem_pin pin = { static_cast<uint32_t>(offset), static_cast<uint32_t>(length) };

    return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, op, &pin)));

}



    if (has_memfd_support() && !memfd_is_ashmem(fd)) {

        return 0;

int ashmem_pin_region(int fd, size_t offset, size_t length) {

    return do_pin(ASHMEM_PIN, fd, offset, length);

}



    // TODO: should LP64 reject too-large offset/len?

    ashmem_pin pin = { static_cast<uint32_t>(offset), static_cast<uint32_t>(len) };

    return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_UNPIN, &pin)));

int ashmem_unpin_region(int fd, size_t offset, size_t length) {

    return do_pin(ASHMEM_UNPIN, fd, offset, length);

}



int ashmem_get_size_region(int fd)

{

    if (has_memfd_support() && !memfd_is_ashmem(fd)) {

int ashmem_get_size_region(int fd) {

    if (is_memfd_fd(fd)) {

        struct stat sb;



        if (fstat(fd, &sb) == -1) {

            ALOGE("ashmem_get_size_region(%d): fstat failed: %m", fd);

            return -1;

        }



        if (debug_log) {

            ALOGD("ashmem_get_size_region(%d): %d", fd, static_cast<int>(sb.st_size));

        }



        return sb.st_size;

    }