Merge "libcutils: clean up the ashmem code a bit." into main (88cb60c8) · Commits · e / os / android_system_core

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;
		}