ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge changes Ie9dd5d5d,Ifc6038c1

Browse source 
am: 0cde0eae09

Change-Id: Ie402e720388b35daed0f704992686f4b84bc5736
This commit is contained in:
Greg Hackmann 2017-02-28 00:10:47 +00:00 • committed by android-build-merger
commit 5fb6ef6b7a
3 changed files with 107 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
adf/libadf/Android.bp
View file

@ -14,7 +14,7 @@
cc_library_static { cc_library_static {
name: "libadf", name: "libadf",
srcs: ["adf.c"], srcs: ["adf.cpp"],
cflags: ["-Werror"], cflags: ["-Werror"],
local_include_dirs: ["include"], local_include_dirs: ["include"],
export_include_dirs: ["include"], export_include_dirs: ["include"],

348
adf/libadf/adf.c → adf/libadf/adf.cpp
View file

@ -23,6 +23,10 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <algorithm>
#include <memory>
#include <vector>
#include <linux/limits.h> #include <linux/limits.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
@ -31,52 +35,44 @@
#define ADF_BASE_PATH "/dev/" #define ADF_BASE_PATH "/dev/"
static ssize_t adf_find_nodes(const char *pattern, adf_id_t **ids) static ssize_t adf_id_vector_to_array(const std::vector<adf_id_t> &in,
adf_id_t **out)
{ {
DIR *dir; auto size = sizeof(in[0]) * in.size();
struct dirent *dirent; // We can't use new[] since the existing API says the caller should free()
size_t n = 0; // the returned array
ssize_t ret; auto ret = static_cast<adf_id_t *>(malloc(size));
adf_id_t *ids_ret = NULL; if (!ret)
return -ENOMEM;
dir = opendir(ADF_BASE_PATH); std::copy(in.begin(), in.end(), ret);
*out = ret;
return in.size();
}
static ssize_t adf_find_nodes(const char *pattern, adf_id_t **ids_out)
{
struct dirent *dirent;
std::unique_ptr<DIR, decltype(&closedir)>
dir{opendir(ADF_BASE_PATH), closedir};
if (!dir) if (!dir)
return -errno; return -errno;
std::vector<adf_id_t> ids;
errno = 0; errno = 0;
while ((dirent = readdir(dir))) { while ((dirent = readdir(dir.get()))) {
adf_id_t id; adf_id_t id;
int matched = sscanf(dirent->d_name, pattern, &id); int matched = sscanf(dirent->d_name, pattern, &id);
if (matched < 0) { if (matched < 0)
ret = -errno; return -errno;
goto done; else if (matched == 1)
} else if (matched != 1) { ids.push_back(id);
continue;
}
adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
if (!new_ids) {
ret = -ENOMEM;
goto done;
}
ids_ret = new_ids;
ids_ret[n] = id;
n++;
} }
if (errno) if (errno)
ret = -errno; return -errno;
else
ret = n;
done: return adf_id_vector_to_array(ids, ids_out);
closedir(dir);
if (ret < 0)
free(ids_ret);
else
*ids = ids_ret;
return ret;
} }
ssize_t adf_devices(adf_id_t **ids) ssize_t adf_devices(adf_id_t **ids)
@ -115,46 +111,29 @@ int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data)
if (err < 0) if (err < 0)
return -ENOMEM; return -ENOMEM;
if (data->n_attachments) { if (data->n_attachments)
data->attachments = malloc(sizeof(data->attachments[0]) * data->attachments = new adf_attachment_config[data->n_attachments];
data->n_attachments);
if (!data->attachments)
return -ENOMEM;
}
if (data->n_allowed_attachments) { if (data->n_allowed_attachments)
data->allowed_attachments = data->allowed_attachments =
malloc(sizeof(data->allowed_attachments[0]) * new adf_attachment_config[data->n_allowed_attachments];
data->n_allowed_attachments);
if (!data->allowed_attachments) {
ret = -ENOMEM;
goto done;
}
}
if (data->custom_data_size) { if (data->custom_data_size)
data->custom_data = malloc(data->custom_data_size); data->custom_data = new char[data->custom_data_size];
if (!data->custom_data) {
ret = -ENOMEM;
goto done;
}
}
err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data); err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
if (err < 0) if (err < 0) {
ret = -errno; ret = -errno;
done:
if (ret < 0)
adf_free_device_data(data); adf_free_device_data(data);
}
return ret; return ret;
} }
void adf_free_device_data(struct adf_device_data *data) void adf_free_device_data(struct adf_device_data *data)
{ {
free(data->attachments); delete [] data->attachments;
free(data->allowed_attachments); delete [] data->allowed_attachments;
free(data->custom_data); delete [] static_cast<char *>(data->custom_data);
} }
int adf_device_post(struct adf_device *dev, int adf_device_post(struct adf_device *dev,
@ -252,39 +231,17 @@ ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev,
adf_id_t overlay_engine, adf_id_t **interfaces) adf_id_t overlay_engine, adf_id_t **interfaces)
{ {
struct adf_device_data data; struct adf_device_data data;
ssize_t n = 0; auto err = adf_get_device_data(dev, &data);
ssize_t ret; if (err < 0)
adf_id_t *ids_ret = NULL; return err;
ret = adf_get_device_data(dev, &data); std::vector<adf_id_t> ids;
if (ret < 0) for (size_t i = 0; i < data.n_allowed_attachments; i++)
return ret; if (data.allowed_attachments[i].overlay_engine == overlay_engine)
ids.push_back(data.allowed_attachments[i].interface);
size_t i;
for (i = 0; i < data.n_allowed_attachments; i++) {
if (data.allowed_attachments[i].overlay_engine != overlay_engine)
continue;
adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
if (!new_ids) {
ret = -ENOMEM;
goto done;
}
ids_ret = new_ids;
ids_ret[n] = data.allowed_attachments[i].interface;
n++;
}
ret = n;
done:
adf_free_device_data(&data); adf_free_device_data(&data);
if (ret < 0) return adf_id_vector_to_array(ids, interfaces);
free(ids_ret);
else
*interfaces = ids_ret;
return ret;
} }
static ssize_t adf_interfaces_filter(struct adf_device *dev, static ssize_t adf_interfaces_filter(struct adf_device *dev,
@ -292,46 +249,23 @@ static ssize_t adf_interfaces_filter(struct adf_device *dev,
bool (*filter)(struct adf_interface_data *data, __u32 match), bool (*filter)(struct adf_interface_data *data, __u32 match),
__u32 match) __u32 match)
{ {
size_t n = 0; std::vector<adf_id_t> ids;
ssize_t ret; for (size_t i = 0; i < n_in; i++) {
adf_id_t *ids_ret = NULL;
size_t i;
for (i = 0; i < n_in; i++) {
int fd = adf_interface_open(dev, in[i], O_RDONLY); int fd = adf_interface_open(dev, in[i], O_RDONLY);
if (fd < 0) { if (fd < 0)
ret = fd; return fd;
goto done;
}
struct adf_interface_data data; struct adf_interface_data data;
ret = adf_get_interface_data(fd, &data); auto ret = adf_get_interface_data(fd, &data);
close(fd); close(fd);
if (ret < 0) if (ret < 0)
goto done; return ret;
if (!filter(&data, match)) if (filter(&data, match))
continue; ids.push_back(in[i]);
adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
if (!new_ids) {
ret = -ENOMEM;
goto done;
}
ids_ret = new_ids;
ids_ret[n] = in[i];
n++;
} }
ret = n; return adf_id_vector_to_array(ids, out);
done:
if (ret < 0)
free(ids_ret);
else
*out = ids_ret;
return ret;
} }
static bool adf_interface_type_filter(struct adf_interface_data *data, static bool adf_interface_type_filter(struct adf_interface_data *data,
@ -385,35 +319,24 @@ int adf_get_interface_data(int fd, struct adf_interface_data *data)
if (err < 0) if (err < 0)
return -errno; return -errno;
if (data->n_available_modes) { if (data->n_available_modes)
data->available_modes = malloc(sizeof(data->available_modes[0]) * data->available_modes = new drm_mode_modeinfo[data->n_available_modes];
data->n_available_modes);
if (!data->available_modes)
return -ENOMEM;
}
if (data->custom_data_size) { if (data->custom_data_size)
data->custom_data = malloc(data->custom_data_size); data->custom_data = new char[data->custom_data_size];
if (!data->custom_data) {
ret = -ENOMEM;
goto done;
}
}
err = ioctl(fd, ADF_GET_INTERFACE_DATA, data); err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
if (err < 0) if (err < 0) {
ret = -errno; ret = -errno;
done:
if (ret < 0)
adf_free_interface_data(data); adf_free_interface_data(data);
}
return ret; return ret;
} }
void adf_free_interface_data(struct adf_interface_data *data) void adf_free_interface_data(struct adf_interface_data *data)
{ {
free(data->available_modes); delete [] data->available_modes;
free(data->custom_data); delete [] static_cast<char *>(data->custom_data);
} }
int adf_interface_blank(int fd, __u8 mode) int adf_interface_blank(int fd, __u8 mode)
@ -522,39 +445,16 @@ ssize_t adf_overlay_engines_for_interface(struct adf_device *dev,
adf_id_t interface, adf_id_t **overlay_engines) adf_id_t interface, adf_id_t **overlay_engines)
{ {
struct adf_device_data data; struct adf_device_data data;
ssize_t n = 0; auto err = adf_get_device_data(dev, &data);
ssize_t ret; if (err < 0)
adf_id_t *ids_ret = NULL; return err;
ret = adf_get_device_data(dev, &data); std::vector<adf_id_t> ids;
if (ret < 0) for (size_t i = 0; i < data.n_allowed_attachments; i++)
return ret; if (data.allowed_attachments[i].interface == interface)
ids.push_back(data.allowed_attachments[i].overlay_engine);
size_t i; return adf_id_vector_to_array(ids, overlay_engines);
for (i = 0; i < data.n_allowed_attachments; i++) {
if (data.allowed_attachments[i].interface != interface)
continue;
adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
if (!new_ids) {
ret = -ENOMEM;
goto done;
}
ids_ret = new_ids;
ids_ret[n] = data.allowed_attachments[i].overlay_engine;
n++;
}
ret = n;
done:
adf_free_device_data(&data);
if (ret < 0)
free(ids_ret);
else
*overlay_engines = ids_ret;
return ret;
} }
static ssize_t adf_overlay_engines_filter(struct adf_device *dev, static ssize_t adf_overlay_engines_filter(struct adf_device *dev,
@ -562,46 +462,24 @@ static ssize_t adf_overlay_engines_filter(struct adf_device *dev,
bool (*filter)(struct adf_overlay_engine_data *data, void *cookie), bool (*filter)(struct adf_overlay_engine_data *data, void *cookie),
void *cookie) void *cookie)
{ {
size_t n = 0; std::vector<adf_id_t> ids;
ssize_t ret;
adf_id_t *ids_ret = NULL;
size_t i; size_t i;
for (i = 0; i < n_in; i++) { for (i = 0; i < n_in; i++) {
int fd = adf_overlay_engine_open(dev, in[i], O_RDONLY); int fd = adf_overlay_engine_open(dev, in[i], O_RDONLY);
if (fd < 0) { if (fd < 0)
ret = fd; return fd;
goto done;
}
struct adf_overlay_engine_data data; struct adf_overlay_engine_data data;
ret = adf_get_overlay_engine_data(fd, &data); auto ret = adf_get_overlay_engine_data(fd, &data);
close(fd); close(fd);
if (ret < 0) if (ret < 0)
goto done; return ret;
if (!filter(&data, cookie)) if (filter(&data, cookie))
continue; ids.push_back(in[i]);
adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
if (!new_ids) {
ret = -ENOMEM;
goto done;
}
ids_ret = new_ids;
ids_ret[n] = in[i];
n++;
} }
ret = n; return adf_id_vector_to_array(ids, out);
done:
if (ret < 0)
free(ids_ret);
else
*out = ids_ret;
return ret;
} }
struct format_filter_cookie { struct format_filter_cookie {
@ -612,7 +490,7 @@ struct format_filter_cookie {
static bool adf_overlay_engine_format_filter( static bool adf_overlay_engine_format_filter(
struct adf_overlay_engine_data *data, void *cookie) struct adf_overlay_engine_data *data, void *cookie)
{ {
struct format_filter_cookie *c = cookie; auto c = static_cast<format_filter_cookie *>(cookie);
size_t i; size_t i;
for (i = 0; i < data->n_supported_formats; i++) { for (i = 0; i < data->n_supported_formats; i++) {
size_t j; size_t j;
@ -656,35 +534,24 @@ int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data)
if (err < 0) if (err < 0)
return -errno; return -errno;
if (data->n_supported_formats) { if (data->n_supported_formats)
data->supported_formats = malloc(sizeof(data->supported_formats[0]) * data->supported_formats = new __u32[data->n_supported_formats];
data->n_supported_formats);
if (!data->supported_formats)
return -ENOMEM;
}
if (data->custom_data_size) { if (data->custom_data_size)
data->custom_data = malloc(data->custom_data_size); data->custom_data = new char[data->custom_data_size];
if (!data->custom_data) {
ret = -ENOMEM;
goto done;
}
}
err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data); err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
if (err < 0) if (err < 0) {
ret = -errno; ret = -errno;
done:
if (ret < 0)
adf_free_overlay_engine_data(data); adf_free_overlay_engine_data(data);
}
return ret; return ret;
} }
void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data) void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data)
{ {
free(data->supported_formats); delete [] data->supported_formats;
free(data->custom_data); delete [] static_cast<char *>(data->custom_data);
} }
bool adf_overlay_engine_supports_format(int fd, __u32 format) bool adf_overlay_engine_supports_format(int fd, __u32 format)
@ -724,12 +591,12 @@ int adf_set_event(int fd, enum adf_event_type type, bool enabled)
int adf_read_event(int fd, struct adf_event **event) int adf_read_event(int fd, struct adf_event **event)
{ {
struct adf_event header; struct adf_event header;
struct { struct event_with_data {
struct adf_event base; struct adf_event base;
uint8_t data[0]; uint8_t data[0];
} *event_ret; };
using unique_event = std::unique_ptr<event_with_data, decltype(&free)>;
size_t data_size; size_t data_size;
int ret = 0;
int err = read(fd, &header, sizeof(header)); int err = read(fd, &header, sizeof(header));
if (err < 0) if (err < 0)
@ -739,28 +606,23 @@ int adf_read_event(int fd, struct adf_event **event)
if (header.length < sizeof(header)) if (header.length < sizeof(header))
return -EIO; return -EIO;
event_ret = malloc(header.length); // Again, we can't use new[] since the existing API says the caller should
// free() the returned event
auto event_ptr = static_cast<event_with_data *>(malloc(header.length));
unique_event event_ret{event_ptr, free};
if (!event_ret) if (!event_ret)
return -ENOMEM; return -ENOMEM;
data_size = header.length - sizeof(header); data_size = header.length - sizeof(header);
memcpy(event_ret, &header, sizeof(header)); memcpy(event_ret.get(), &header, sizeof(header));
ssize_t read_size = read(fd, &event_ret->data, data_size); ssize_t read_size = read(fd, &event_ret->data, data_size);
if (read_size < 0) { if (read_size < 0)
ret = -errno; return -errno;
goto done; if ((size_t)read_size < data_size)
} return -EIO;
if ((size_t)read_size < data_size) {
ret = -EIO;
goto done;
}
*event = &event_ret->base; *event = &event_ret.release()->base;
return 0;
done:
if (ret < 0)
free(event_ret);
return ret;
} }
void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE]) void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE])

2
adf/libadf/tests/adf_test.cpp
View file

@ -188,7 +188,7 @@ const __u32 AdfTest::fmt8888[] = {
const size_t AdfTest::n_fmt8888 = sizeof(fmt8888) / sizeof(fmt8888[0]); const size_t AdfTest::n_fmt8888 = sizeof(fmt8888) / sizeof(fmt8888[0]);
TEST(adf, devices) { TEST(adf, devices) {
adf_id_t *devs; adf_id_t *devs = nullptr;
ssize_t n_devs = adf_devices(&devs); ssize_t n_devs = adf_devices(&devs);
free(devs); free(devs);