diff --git a/automotive/vehicle/2.0/default/Android.bp b/automotive/vehicle/2.0/default/Android.bp index f24b1f5474..c13efde4e4 100644 --- a/automotive/vehicle/2.0/default/Android.bp +++ b/automotive/vehicle/2.0/default/Android.bp @@ -91,13 +91,13 @@ cc_library_static { "impl/vhal_v2_0/LinearFakeValueGenerator.cpp", "impl/vhal_v2_0/JsonFakeValueGenerator.cpp", "impl/vhal_v2_0/GeneratorHub.cpp", + "impl/vhal_v2_0/qemu_pipe.cpp", ], local_include_dirs: ["common/include/vhal_v2_0"], export_include_dirs: ["impl"], whole_static_libs: [ "android.hardware.automotive.vehicle@2.0-emulated-user-hal-lib", "android.hardware.automotive.vehicle@2.0-manager-lib", - "libqemu_pipe", ], shared_libs: [ "libbase", diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp b/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp index f0242879bc..81e7c781c2 100644 --- a/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp +++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/PipeComm.cpp @@ -18,9 +18,9 @@ #include #include -#include #include "PipeComm.h" +#include "qemu_pipe.h" #define CAR_SERVICE_NAME "pipe:qemud:car" diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/qemu_pipe.cpp b/automotive/vehicle/2.0/default/impl/vhal_v2_0/qemu_pipe.cpp new file mode 100644 index 0000000000..cf1a002479 --- /dev/null +++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/qemu_pipe.cpp @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2011 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. + */ + +#include "qemu_pipe.h" + +#include +#include +#include +#include +#include + +#include + +using android::base::ReadFully; +using android::base::WriteFully; + +// Define QEMU_PIPE_DEBUG if you want to print error messages when an error +// occurs during pipe operations. The macro should simply take a printf-style +// formatting string followed by optional arguments. +#ifndef QEMU_PIPE_DEBUG +#define QEMU_PIPE_DEBUG(...) (void)0 +#endif + +int qemu_pipe_open(const char* pipeName) { + if (!pipeName) { + errno = EINVAL; + return -1; + } + + int fd = TEMP_FAILURE_RETRY(open("/dev/qemu_pipe", O_RDWR)); + if (fd < 0) { + QEMU_PIPE_DEBUG("%s: Could not open /dev/qemu_pipe: %s", __FUNCTION__, strerror(errno)); + return -1; + } + + // Write the pipe name, *including* the trailing zero which is necessary. + size_t pipeNameLen = strlen(pipeName); + if (WriteFully(fd, pipeName, pipeNameLen + 1U)) { + return fd; + } + + // now, add 'pipe:' prefix and try again + // Note: host side will wait for the trailing '\0' to start + // service lookup. + const char pipe_prefix[] = "pipe:"; + if (WriteFully(fd, pipe_prefix, strlen(pipe_prefix)) && + WriteFully(fd, pipeName, pipeNameLen + 1U)) { + return fd; + } + QEMU_PIPE_DEBUG("%s: Could not write to %s pipe service: %s", __FUNCTION__, pipeName, + strerror(errno)); + close(fd); + return -1; +} + +int qemu_pipe_frame_send(int fd, const void* buff, size_t len) { + char header[5]; + snprintf(header, sizeof(header), "%04zx", len); + if (!WriteFully(fd, header, 4)) { + QEMU_PIPE_DEBUG("Can't write qemud frame header: %s", strerror(errno)); + return -1; + } + if (!WriteFully(fd, buff, len)) { + QEMU_PIPE_DEBUG("Can't write qemud frame payload: %s", strerror(errno)); + return -1; + } + return 0; +} + +int qemu_pipe_frame_recv(int fd, void* buff, size_t len) { + char header[5]; + if (!ReadFully(fd, header, 4)) { + QEMU_PIPE_DEBUG("Can't read qemud frame header: %s", strerror(errno)); + return -1; + } + header[4] = '\0'; + size_t size; + if (sscanf(header, "%04zx", &size) != 1) { + QEMU_PIPE_DEBUG("Malformed qemud frame header: [%.*s]", 4, header); + return -1; + } + if (size > len) { + QEMU_PIPE_DEBUG("Oversized qemud frame (% bytes, expected <= %)", size, len); + return -1; + } + if (!ReadFully(fd, buff, size)) { + QEMU_PIPE_DEBUG("Could not read qemud frame payload: %s", strerror(errno)); + return -1; + } + return size; +} diff --git a/automotive/vehicle/2.0/default/impl/vhal_v2_0/qemu_pipe.h b/automotive/vehicle/2.0/default/impl/vhal_v2_0/qemu_pipe.h new file mode 100644 index 0000000000..0987498990 --- /dev/null +++ b/automotive/vehicle/2.0/default/impl/vhal_v2_0/qemu_pipe.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2011 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 ANDROID_CORE_INCLUDE_QEMU_PIPE_H +#define ANDROID_CORE_INCLUDE_QEMU_PIPE_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif +// Try to open a new Qemu fast-pipe. This function returns a file descriptor +// that can be used to communicate with a named service managed by the +// emulator. +// +// This file descriptor can be used as a standard pipe/socket descriptor. +// +// 'pipeName' is the name of the emulator service you want to connect to, +// and should begin with 'pipe:' (e.g. 'pipe:camera' or 'pipe:opengles'). +// For backward compatibility, the 'pipe:' prefix can be omitted, and in +// that case, qemu_pipe_open will add it for you. + +// On success, return a valid file descriptor, or -1/errno on failure. E.g.: +// +// EINVAL -> unknown/unsupported pipeName +// ENOSYS -> fast pipes not available in this system. +// +// ENOSYS should never happen, except if you're trying to run within a +// misconfigured emulator. +// +// You should be able to open several pipes to the same pipe service, +// except for a few special cases (e.g. GSM modem), where EBUSY will be +// returned if more than one client tries to connect to it. +int qemu_pipe_open(const char* pipeName); + +// Send a framed message |buff| of |len| bytes through the |fd| descriptor. +// This really adds a 4-hexchar prefix describing the payload size. +// Returns 0 on success, and -1 on error. +int qemu_pipe_frame_send(int fd, const void* buff, size_t len); + +// Read a frame message from |fd|, and store it into |buff| of |len| bytes. +// If the framed message is larger than |len|, then this returns -1 and the +// content is lost. Otherwise, this returns the size of the message. NOTE: +// empty messages are possible in a framed wire protocol and do not mean +// end-of-stream. +int qemu_pipe_frame_recv(int fd, void* buff, size_t len); + +#ifdef __cplusplus +} +#endif + +#endif /* ANDROID_CORE_INCLUDE_QEMU_PIPE_H */