From f991de200799118355fd75237a740321bda7aaa7 Mon Sep 17 00:00:00 2001 From: Damian Hobson-Garcia Date: Tue, 24 Nov 2020 17:16:39 +0900 Subject: [PATCH] Add initial version The initial version implements the basic functionality of the client/server communication and lease management. For now, one lease is created per valid connector (dependent on CRTC availablity). Bug-AGL: SPEC-3729 Signed-off-by: Damian Hobson-Garcia Change-Id: I2b37a892742cc22bdc53a5172c8ad3d8a7bb5e66 --- .clang-format | 9 + LICENSE | 202 ++++++++++++ README.md | 85 +++++ common/log.c | 38 +++ common/log.h | 33 ++ common/meson.build | 22 ++ common/socket-path.c | 48 +++ common/socket-path.h | 26 ++ common/test/test-helpers.c | 56 ++++ common/test/test-helpers.h | 34 ++ drm-lease-manager/drm-lease.h | 22 ++ drm-lease-manager/lease-manager.c | 386 +++++++++++++++++++++++ drm-lease-manager/lease-manager.h | 29 ++ drm-lease-manager/lease-server.c | 335 ++++++++++++++++++++ drm-lease-manager/lease-server.h | 42 +++ drm-lease-manager/main.c | 120 +++++++ drm-lease-manager/meson.build | 12 + drm-lease-manager/test/lease-manager-test.c | 448 +++++++++++++++++++++++++++ drm-lease-manager/test/lease-server-test.c | 380 +++++++++++++++++++++++ drm-lease-manager/test/meson.build | 30 ++ drm-lease-manager/test/test-drm-device.c | 122 ++++++++ drm-lease-manager/test/test-drm-device.h | 81 +++++ drm-lease-manager/test/test-socket-client.c | 162 ++++++++++ drm-lease-manager/test/test-socket-client.h | 37 +++ examples/dlm-client-test/dlm-client-test.c | 94 ++++++ examples/dlm-client-test/meson.build | 4 + examples/meson.build | 1 + libdlmclient/dlmclient.c | 170 ++++++++++ libdlmclient/dlmclient.h | 86 +++++ libdlmclient/docs/Doxyfile.in | 9 + libdlmclient/docs/meson.build | 21 ++ libdlmclient/meson.build | 38 +++ libdlmclient/test/libdlmclient-test.c | 291 +++++++++++++++++ libdlmclient/test/meson.build | 6 + libdlmclient/test/test-socket-server.c | 169 ++++++++++ libdlmclient/test/test-socket-server.h | 33 ++ meson.build | 61 ++++ meson_options.txt | 17 + subprojects/fff.wrap | 8 + subprojects/packagefiles/fff-1.0/meson.build | 8 + 40 files changed, 3775 insertions(+) create mode 100644 .clang-format create mode 100644 LICENSE create mode 100644 README.md create mode 100644 common/log.c create mode 100644 common/log.h create mode 100644 common/meson.build create mode 100644 common/socket-path.c create mode 100644 common/socket-path.h create mode 100644 common/test/test-helpers.c create mode 100644 common/test/test-helpers.h create mode 100644 drm-lease-manager/drm-lease.h create mode 100644 drm-lease-manager/lease-manager.c create mode 100644 drm-lease-manager/lease-manager.h create mode 100644 drm-lease-manager/lease-server.c create mode 100644 drm-lease-manager/lease-server.h create mode 100644 drm-lease-manager/main.c create mode 100644 drm-lease-manager/meson.build create mode 100644 drm-lease-manager/test/lease-manager-test.c create mode 100644 drm-lease-manager/test/lease-server-test.c create mode 100644 drm-lease-manager/test/meson.build create mode 100644 drm-lease-manager/test/test-drm-device.c create mode 100644 drm-lease-manager/test/test-drm-device.h create mode 100644 drm-lease-manager/test/test-socket-client.c create mode 100644 drm-lease-manager/test/test-socket-client.h create mode 100644 examples/dlm-client-test/dlm-client-test.c create mode 100644 examples/dlm-client-test/meson.build create mode 100644 examples/meson.build create mode 100644 libdlmclient/dlmclient.c create mode 100644 libdlmclient/dlmclient.h create mode 100644 libdlmclient/docs/Doxyfile.in create mode 100644 libdlmclient/docs/meson.build create mode 100644 libdlmclient/meson.build create mode 100644 libdlmclient/test/libdlmclient-test.c create mode 100644 libdlmclient/test/meson.build create mode 100644 libdlmclient/test/test-socket-server.c create mode 100644 libdlmclient/test/test-socket-server.h create mode 100644 meson.build create mode 100644 meson_options.txt create mode 100644 subprojects/fff.wrap create mode 100644 subprojects/packagefiles/fff-1.0/meson.build diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..97c7b2c --- /dev/null +++ b/.clang-format @@ -0,0 +1,9 @@ +BasedOnStyle: LLVM +IndentWidth: 8 +ColumnLimit: 80 +UseTab: Always +BreakBeforeBraces: Linux +AllowShortIfStatementsOnASingleLine: false +AllowShortFunctionsOnASingleLine: None +IndentCaseLabels: false +AlignEscapedNewlines: Left diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..5368f6b --- /dev/null +++ b/README.md @@ -0,0 +1,85 @@ +# DRM Lease Manager + +The DRM Lease Manager uses the DRM Lease feature, introduced in the Linux kernel version 4.15, +to partition display controller output resources between multiple processes. + +For more information on the DRM lease functionality, please see the blog posts published by Keith +Packard, who developed the feature, at https://keithp.com/blogs/DRM-lease/ + +This repository contains a user space daemon to create and manage DRM leases, and distribute them +to client applications. This implementation is independent of any window system / compositor, +such as X11 or wayland, so can be used with clients that directly access a DRM device. + +This repository also provides a library that clients can use to communicate with the DRM Lease Manager. + +## Building + +Build this repository requires a recent version of the [meson](https://mesonbuild.com/Getting-meson.html) build system. + +The basic build procedure is as follows: + + meson + ninja -C + sudo ninja -C install + +`` can be any directory name, but `build` is commonly used. + +## Running + +Once installed, running the following command will start the DRM Lease Manager daemon + + drm-lease-manager [] + +If no DRM device is specified, `/dev/dri/card0` will be used. +More detailed options can be displayed by specifying the `-h` flag. + +### Lease naming + +One DRM lease will be created for each connector on the DRM device (up to the number of available CRTCs). + +The names of the DRM leases will have the following pattern: + + - + +So, for example, a DRM lease for the first LVDS device on the device `/dev/dri/card0` would be named +`card0-LVDS-1`. + +## Client API usage + +The libdmclient handles all communication with the DRM Lease Manager and provides file descriptors that +can be used as if the DRM device was opened directly. Clients only need to replace their calls to +`drmOpen()` and `drmClose()` with the appropriate libdlmclient API calls. + +The client library API is described in `dlmclient.h` in the `libdlmclient` directory. + +If doxygen is available, building the repository will generate doxygen documentation in the +`/libdlmclient/docs/html` directory. + +### Examples + +_Error handling has been omitted for brevity and clarity of examples._ + +#### Requesting a lease from the DRM Lease Manager + +```c + struct dlm_lease *lease = dlm_get_lease("card0-HDMI-A-1"); + int drm_device_fd = dlm_lease_fd(lease); +``` + +`drm_device_fd` can now be used to access the DRM device + +#### Releasing a lease + +```c + dlm_release_lease(lease); +``` + +**Note: `drm_device_fd` is not usable after calling `dlm_release_lease()`** + +## Runtime directory +A runtime directory under the `/var` system directory is used by the drm-lease-manager and clients to +communicate with each other. +The default path is `/var/run/drm-lease-manager`, but can be changed by setting the `-Druntime_subdir` +option during configuration with `meson`. + +The runtime directory can also be specified at runtime by setting the `DLM_RUNTIME_PATH` environment variable. diff --git a/common/log.c b/common/log.c new file mode 100644 index 0000000..f3f8899 --- /dev/null +++ b/common/log.c @@ -0,0 +1,38 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "log.h" + +#include +#include +#include + +static bool debug_log = false; + +void dlm_log_enable_debug(bool enable) +{ + debug_log = enable; +} + +void dlm_log_print(bool debug, FILE *stream, char *fmt, ...) +{ + if (debug && !debug_log) + return; + + va_list argl; + va_start(argl, fmt); + vfprintf(stream, fmt, argl); + va_end(argl); +} diff --git a/common/log.h b/common/log.h new file mode 100644 index 0000000..cd0c0e3 --- /dev/null +++ b/common/log.h @@ -0,0 +1,33 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 LOG_H +#define LOG_H + +#include +#include + +#define DEBUG_LOG(FMT, ...) \ + dlm_log_print(true, stdout, "DEBUG: %s: " FMT, __func__, ##__VA_ARGS__) +#define INFO_LOG(FMT, ...) \ + dlm_log_print(false, stdout, "INFO: " FMT, ##__VA_ARGS__) +#define WARN_LOG(FMT, ...) \ + dlm_log_print(false, stderr, "WARNING: " FMT, ##__VA_ARGS__) +#define ERROR_LOG(FMT, ...) \ + dlm_log_print(false, stderr, "ERROR: " FMT, ##__VA_ARGS__) + +void dlm_log_enable_debug(bool enable); +void dlm_log_print(bool debug, FILE *stream, char *fmt, ...); +#endif diff --git a/common/meson.build b/common/meson.build new file mode 100644 index 0000000..e465fa5 --- /dev/null +++ b/common/meson.build @@ -0,0 +1,22 @@ +libdlmcommon_sources = [ + 'socket-path.c', + 'log.c' +] + +libdlmcommon_inc = [include_directories('.')] + +if enable_tests + libdlmcommon_inc += include_directories('test') + libdlmcommon_sources += ['test/test-helpers.c'] +endif + +libdlmcommon = static_library( + 'common', + sources: libdlmcommon_sources, + include_directories : configuration_inc, +) + +dlmcommon_dep = declare_dependency( + link_with : libdlmcommon, + include_directories : libdlmcommon_inc +) diff --git a/common/socket-path.c b/common/socket-path.c new file mode 100644 index 0000000..7a412da --- /dev/null +++ b/common/socket-path.c @@ -0,0 +1,48 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "socket-path.h" +#include "config.h" +#include "log.h" + +#include +#include +#include +#include + +#define RUNTIME_PATH DLM_DEFAULT_RUNTIME_PATH + +bool sockaddr_set_lease_server_path(struct sockaddr_un *sa, + const char *lease_name) +{ + int maxlen = sizeof(sa->sun_path); + char *socket_dir = getenv("DLM_RUNTIME_PATH") ?: RUNTIME_PATH; + + int len = + snprintf(sa->sun_path, maxlen, "%s/%s", socket_dir, lease_name); + + if (len < 0) { + DEBUG_LOG("Socket path creation failed: %s\n", strerror(errno)); + return false; + } + if (len >= maxlen) { + errno = ENAMETOOLONG; + DEBUG_LOG("Socket directoy path too long. " + "Full path to socket must be less than %d bytes\n", + maxlen); + return false; + } + return true; +} diff --git a/common/socket-path.h b/common/socket-path.h new file mode 100644 index 0000000..b05c60f --- /dev/null +++ b/common/socket-path.h @@ -0,0 +1,26 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 SOCKET_PATH_H +#define SOCKET_PATH_H + +#include +#include +#include + +bool sockaddr_set_lease_server_path(struct sockaddr_un *dest, + const char *lease_name); + +#endif diff --git a/common/test/test-helpers.c b/common/test/test-helpers.c new file mode 100644 index 0000000..ea37a89 --- /dev/null +++ b/common/test/test-helpers.c @@ -0,0 +1,56 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "test-helpers.h" +#include + +#include +#include +#include + +int get_dummy_fd(void) +{ + return dup(STDIN_FILENO); +} + +void check_fd_equality(int fd1, int fd2) +{ + struct stat s1, s2; + ck_assert_int_eq(fstat(fd1, &s1), 0); + ck_assert_int_eq(fstat(fd2, &s2), 0); + ck_assert_int_eq(s1.st_dev, s2.st_dev); + ck_assert_int_eq(s1.st_ino, s2.st_ino); +} + +void check_fd_is_open(int fd) +{ + struct stat st; + ck_assert_int_eq(fstat(fd, &st), 0); +} + +void check_fd_is_closed(int fd) +{ + struct stat st; + ck_assert_int_ne(fstat(fd, &st), 0); + ck_assert_int_eq(errno, EBADF); +} + +void check_uint_array_eq(const uint32_t *a, const uint32_t *b, int cnt) +{ + for (int i = 0; i < cnt; i++) { + ck_assert_msg(a[i] == b[i], "Array diff at index %d (%u != %u)", + i, a[i], b[i]); + } +} diff --git a/common/test/test-helpers.h b/common/test/test-helpers.h new file mode 100644 index 0000000..8886acd --- /dev/null +++ b/common/test/test-helpers.h @@ -0,0 +1,34 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 TEST_HELPERS_H +#define TEST_HELPERS_H + +#include + +#define UNUSED(x) (void)(x) +#define ARRAY_LEN(x) ((int)(sizeof(x) / sizeof(x[0]))) + +/* Get a vaild fd to use a a placeholder. + * The dummy fd should never be used for anything other + * than comparing the fd value or the referenced file description. */ +int get_dummy_fd(void); + +void check_fd_equality(int fd1, int fd2); +void check_fd_is_open(int fd); +void check_fd_is_closed(int fd); + +void check_uint_array_eq(const uint32_t *a, const uint32_t *b, int cnt); +#endif diff --git a/drm-lease-manager/drm-lease.h b/drm-lease-manager/drm-lease.h new file mode 100644 index 0000000..6c618a0 --- /dev/null +++ b/drm-lease-manager/drm-lease.h @@ -0,0 +1,22 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 DRM_LEASE_H +#define DRM_LEASE_H + +struct lease_handle { + char *name; +}; +#endif diff --git a/drm-lease-manager/lease-manager.c b/drm-lease-manager/lease-manager.c new file mode 100644 index 0000000..5cfc5de --- /dev/null +++ b/drm-lease-manager/lease-manager.c @@ -0,0 +1,386 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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. + */ + +#define _GNU_SOURCE +#include "lease-manager.h" + +#include "drm-lease.h" +#include "log.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Number of resources, excluding planes, to be included in each DRM lease. + * Each lease needs at least a CRTC and conector. */ +#define DRM_LEASE_MIN_RES (2) + +#define ARRAY_LENGTH(x) (sizeof(x) / sizeof(x[0])) + +struct lease { + struct lease_handle base; + + bool is_granted; + uint32_t lessee_id; + int lease_fd; + + uint32_t *object_ids; + int nobject_ids; +}; + +struct lm { + int drm_fd; + dev_t dev_id; + + drmModeResPtr drm_resource; + drmModePlaneResPtr drm_plane_resource; + uint32_t available_crtcs; + + struct lease **leases; + int nleases; +}; + +static const char *const connector_type_names[] = { + [DRM_MODE_CONNECTOR_Unknown] = "Unknown", + [DRM_MODE_CONNECTOR_VGA] = "VGA", + [DRM_MODE_CONNECTOR_DVII] = "DVI-I", + [DRM_MODE_CONNECTOR_DVID] = "DVI-D", + [DRM_MODE_CONNECTOR_DVIA] = "DVI-A", + [DRM_MODE_CONNECTOR_Composite] = "Composite", + [DRM_MODE_CONNECTOR_SVIDEO] = "SVIDEO", + [DRM_MODE_CONNECTOR_LVDS] = "LVDS", + [DRM_MODE_CONNECTOR_Component] = "Component", + [DRM_MODE_CONNECTOR_9PinDIN] = "DIN", + [DRM_MODE_CONNECTOR_DisplayPort] = "DP", + [DRM_MODE_CONNECTOR_HDMIA] = "HDMI-A", + [DRM_MODE_CONNECTOR_HDMIB] = "HDMI-B", + [DRM_MODE_CONNECTOR_TV] = "TV", + [DRM_MODE_CONNECTOR_eDP] = "eDP", + [DRM_MODE_CONNECTOR_VIRTUAL] = "Virtual", + [DRM_MODE_CONNECTOR_DSI] = "DSI", + [DRM_MODE_CONNECTOR_DPI] = "DPI", + [DRM_MODE_CONNECTOR_WRITEBACK] = "Writeback", +}; + +static char *drm_create_lease_name(struct lm *lm, drmModeConnectorPtr connector) +{ + uint32_t type = connector->connector_type; + uint32_t id = connector->connector_type_id; + + if (type >= ARRAY_LENGTH(connector_type_names)) + type = DRM_MODE_CONNECTOR_Unknown; + + /* If the type is "Unknown", use the connector_id as the identify to + * guarantee that the name will be unique. */ + if (type == DRM_MODE_CONNECTOR_Unknown) + id = connector->connector_id; + + char *name; + if (asprintf(&name, "card%d-%s-%d", minor(lm->dev_id), + connector_type_names[type], id) < 0) + return NULL; + + return name; +} + +static int drm_get_encoder_crtc_index(struct lm *lm, drmModeEncoderPtr encoder) +{ + uint32_t crtc_id = encoder->crtc_id; + if (!crtc_id) + return -1; + + // The CRTC index only makes sense if it is less than the number of + // bits in the encoder possible_crtcs bitmap, which is 32. + assert(lm->drm_resource->count_crtcs < 32); + + for (int i = 0; i < lm->drm_resource->count_crtcs; i++) { + if (lm->drm_resource->crtcs[i] == crtc_id) + return i; + } + return -1; +} + +static int drm_get_active_crtc_index(struct lm *lm, + drmModeConnectorPtr connector) +{ + drmModeEncoder *encoder = + drmModeGetEncoder(lm->drm_fd, connector->encoder_id); + if (!encoder) + return -1; + + int crtc_idx = drm_get_encoder_crtc_index(lm, encoder); + drmModeFreeEncoder(encoder); + return crtc_idx; +} + +static int drm_get_crtc_index(struct lm *lm, drmModeConnectorPtr connector) +{ + + // try the active CRTC first + int crtc_index = drm_get_active_crtc_index(lm, connector); + if (crtc_index != -1) + return crtc_index; + + // If not try the first available CRTC on the connector/encoder + for (int i = 0; i < connector->count_encoders; i++) { + drmModeEncoder *encoder = + drmModeGetEncoder(lm->drm_fd, connector->encoders[i]); + + assert(encoder); + + uint32_t usable_crtcs = + lm->available_crtcs & encoder->possible_crtcs; + int crtc = ffs(usable_crtcs); + drmModeFreeEncoder(encoder); + if (crtc == 0) + continue; + crtc_index = crtc - 1; + lm->available_crtcs &= ~(1 << crtc_index); + break; + } + return crtc_index; +} + +static void drm_find_available_crtcs(struct lm *lm) +{ + // Assume all CRTCS are available by default, + lm->available_crtcs = ~0; + + // then remove any that are in use. */ + for (int i = 0; i < lm->drm_resource->count_encoders; i++) { + int enc_id = lm->drm_resource->encoders[i]; + drmModeEncoderPtr enc = drmModeGetEncoder(lm->drm_fd, enc_id); + if (!enc) + continue; + + int crtc_idx = drm_get_encoder_crtc_index(lm, enc); + if (crtc_idx >= 0) + lm->available_crtcs &= ~(1 << crtc_idx); + + drmModeFreeEncoder(enc); + } +} + +static bool lease_add_planes(struct lm *lm, struct lease *lease, int crtc_index) +{ + for (uint32_t i = 0; i < lm->drm_plane_resource->count_planes; i++) { + uint32_t plane_id = lm->drm_plane_resource->planes[i]; + drmModePlanePtr plane = drmModeGetPlane(lm->drm_fd, plane_id); + + assert(plane); + + // Exclude planes that can be used with multiple CRTCs for now + if (plane->possible_crtcs == (1u << crtc_index)) { + lease->object_ids[lease->nobject_ids++] = plane_id; + } + drmModeFreePlane(plane); + } + return true; +} + +static void lease_free(struct lease *lease) +{ + free(lease->base.name); + free(lease->object_ids); + free(lease); +} + +static struct lease *lease_create(struct lm *lm, drmModeConnectorPtr connector) +{ + struct lease *lease = calloc(1, sizeof(struct lease)); + if (!lease) { + DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno)); + return NULL; + } + + lease->base.name = drm_create_lease_name(lm, connector); + if (!lease->base.name) { + DEBUG_LOG("Can't create lease name: %s\n", strerror(errno)); + goto err; + } + + int nobjects = lm->drm_plane_resource->count_planes + DRM_LEASE_MIN_RES; + lease->object_ids = calloc(nobjects, sizeof(uint32_t)); + if (!lease->object_ids) { + DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno)); + goto err; + } + + int crtc_index = drm_get_crtc_index(lm, connector); + if (crtc_index < 0) { + DEBUG_LOG("No crtc found for connector: %s\n", + lease->base.name); + goto err; + } + + if (!lease_add_planes(lm, lease, crtc_index)) + goto err; + + uint32_t crtc_id = lm->drm_resource->crtcs[crtc_index]; + lease->object_ids[lease->nobject_ids++] = crtc_id; + lease->object_ids[lease->nobject_ids++] = connector->connector_id; + + lease->is_granted = false; + + return lease; + +err: + lease_free(lease); + return NULL; +} + +struct lm *lm_create(const char *device) +{ + struct lm *lm = calloc(1, sizeof(struct lm)); + if (!lm) { + DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno)); + return NULL; + } + lm->drm_fd = open(device, O_RDWR); + if (lm->drm_fd < 0) { + ERROR_LOG("Cannot open DRM device (%s): %s\n", device, + strerror(errno)); + goto err; + } + + lm->drm_resource = drmModeGetResources(lm->drm_fd); + if (!lm->drm_resource) { + ERROR_LOG("Invalid DRM device(%s)\n", device); + DEBUG_LOG("drmModeGetResources failed: %s\n", strerror(errno)); + goto err; + } + + lm->drm_plane_resource = drmModeGetPlaneResources(lm->drm_fd); + if (!lm->drm_plane_resource) { + DEBUG_LOG("drmModeGetPlaneResources failed: %s\n", + strerror(errno)); + goto err; + } + + struct stat st; + if (fstat(lm->drm_fd, &st) < 0 || !S_ISCHR(st.st_mode)) { + DEBUG_LOG("%s is not a valid device file\n", device); + goto err; + } + + lm->dev_id = st.st_rdev; + + int num_leases = lm->drm_resource->count_connectors; + + lm->leases = calloc(num_leases, sizeof(struct lease *)); + if (!lm->leases) { + DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno)); + goto err; + } + + drm_find_available_crtcs(lm); + + for (int i = 0; i < num_leases; i++) { + uint32_t connector_id = lm->drm_resource->connectors[i]; + drmModeConnectorPtr connector = + drmModeGetConnector(lm->drm_fd, connector_id); + + if (!connector) + continue; + + struct lease *lease = lease_create(lm, connector); + drmModeFreeConnector(connector); + + if (!lease) + continue; + + lm->leases[lm->nleases] = lease; + lm->nleases++; + } + if (lm->nleases == 0) + goto err; + + return lm; + +err: + lm_destroy(lm); + return NULL; +} + +void lm_destroy(struct lm *lm) +{ + assert(lm); + + for (int i = 0; i < lm->nleases; i++) { + lm_lease_revoke(lm, (struct lease_handle *)lm->leases[i]); + lease_free(lm->leases[i]); + } + + free(lm->leases); + drmModeFreeResources(lm->drm_resource); + drmModeFreePlaneResources(lm->drm_plane_resource); + close(lm->drm_fd); + free(lm); +} + +int lm_get_lease_handles(struct lm *lm, struct lease_handle ***handles) +{ + assert(lm); + assert(handles); + + *handles = (struct lease_handle **)lm->leases; + return lm->nleases; +} + +int lm_lease_grant(struct lm *lm, struct lease_handle *handle) +{ + assert(lm); + assert(handle); + + struct lease *lease = (struct lease *)handle; + if (lease->is_granted) + return lease->lease_fd; + + lease->lease_fd = + drmModeCreateLease(lm->drm_fd, lease->object_ids, + lease->nobject_ids, 0, &lease->lessee_id); + if (lease->lease_fd < 0) { + ERROR_LOG("drmModeCreateLease failed on lease %s: %s\n", + lease->base.name, strerror(errno)); + return -1; + } + + lease->is_granted = true; + return lease->lease_fd; +} + +void lm_lease_revoke(struct lm *lm, struct lease_handle *handle) +{ + assert(lm); + assert(handle); + + struct lease *lease = (struct lease *)handle; + + if (!lease->is_granted) + return; + + drmModeRevokeLease(lm->drm_fd, lease->lessee_id); + close(lease->lease_fd); + lease->is_granted = false; +} diff --git a/drm-lease-manager/lease-manager.h b/drm-lease-manager/lease-manager.h new file mode 100644 index 0000000..ed5bcdc --- /dev/null +++ b/drm-lease-manager/lease-manager.h @@ -0,0 +1,29 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 LEASE_MANAGER_H +#define LEASE_MANAGER_H +#include "drm-lease.h" + +struct lm; + +struct lm *lm_create(const char *path); +void lm_destroy(struct lm *lm); + +int lm_get_lease_handles(struct lm *lm, struct lease_handle ***lease_handles); + +int lm_lease_grant(struct lm *lm, struct lease_handle *lease_handle); +void lm_lease_revoke(struct lm *lm, struct lease_handle *lease_handle); +#endif diff --git a/drm-lease-manager/lease-server.c b/drm-lease-manager/lease-server.c new file mode 100644 index 0000000..e05e8e4 --- /dev/null +++ b/drm-lease-manager/lease-server.c @@ -0,0 +1,335 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "lease-server.h" +#include "log.h" +#include "socket-path.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define SOCK_LOCK_SUFFIX ".lock" + +struct ls_socket { + int fd; + struct ls_server *serv; +}; + +struct ls_server { + struct lease_handle *lease_handle; + struct sockaddr_un address; + int server_socket_lock; + + struct ls_socket listen; + struct ls_socket client; + + bool is_client_connected; +}; + +struct ls { + int epoll_fd; + + struct ls_server *servers; + int nservers; +}; + +static bool client_connect(struct ls *ls, struct ls_server *serv) +{ + int cfd = accept(serv->listen.fd, NULL, NULL); + if (cfd < 0) { + DEBUG_LOG("accept failed on %s: %s\n", serv->address.sun_path, + strerror(errno)); + return false; + } + + if (serv->is_client_connected) { + WARN_LOG("Client already connected on %s\n", + serv->address.sun_path); + close(cfd); + return false; + } + + serv->client.fd = cfd; + serv->client.serv = serv; + + struct epoll_event ev = { + .events = POLLHUP, + .data.ptr = &serv->client, + }; + if (epoll_ctl(ls->epoll_fd, EPOLL_CTL_ADD, cfd, &ev)) { + DEBUG_LOG("epoll_ctl add failed: %s\n", strerror(errno)); + close(cfd); + return false; + } + + serv->is_client_connected = true; + return true; +} + +static int create_socket_lock(struct sockaddr_un *addr) +{ + int lock_fd; + + int lockfile_len = sizeof(addr->sun_path) + sizeof(SOCK_LOCK_SUFFIX); + char lockfile[lockfile_len]; + int len = snprintf(lockfile, lockfile_len, "%s%s", addr->sun_path, + SOCK_LOCK_SUFFIX); + + if (len < 0 || len >= lockfile_len) { + DEBUG_LOG("Can't create socket lock filename\n"); + return -1; + } + + lock_fd = open(lockfile, O_CREAT | O_RDWR, + S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); + + if (lock_fd < 0) { + ERROR_LOG("Cannot access runtime directory\n"); + return -1; + } + + if (flock(lock_fd, LOCK_EX | LOCK_NB)) { + ERROR_LOG( + "socket %s: in use. Possible duplicate lease name or " + "mutiple drm-lease-manager instances running\n", + addr->sun_path); + close(lock_fd); + return -1; + } + + return lock_fd; +} + +static bool server_setup(struct ls *ls, struct ls_server *serv, + struct lease_handle *lease_handle) +{ + struct sockaddr_un *address = &serv->address; + + if (!sockaddr_set_lease_server_path(address, lease_handle->name)) + return false; + + int socket_lock = create_socket_lock(address); + if (socket_lock < 0) + return false; + + /* The socket address is now owned by this instance, so any existing + * sockets can safely be removed */ + unlink(address->sun_path); + + address->sun_family = AF_UNIX; + + int server_socket = socket(PF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0); + if (server_socket < 0) { + DEBUG_LOG("Socket creation failed: %s\n", strerror(errno)); + return false; + } + + if (bind(server_socket, (struct sockaddr *)address, sizeof(*address))) { + ERROR_LOG("Failed to create named socket at %s: %s\n", + address->sun_path, strerror(errno)); + close(server_socket); + return false; + } + + if (listen(server_socket, 0)) { + DEBUG_LOG("listen failed on %s: %s\n", address->sun_path, + strerror(errno)); + close(server_socket); + unlink(address->sun_path); + return false; + } + + serv->is_client_connected = false; + serv->lease_handle = lease_handle; + serv->server_socket_lock = socket_lock; + serv->listen.fd = server_socket; + serv->listen.serv = serv; + + struct epoll_event ev = { + .events = POLLIN, + .data.ptr = &serv->listen, + }; + + if (epoll_ctl(ls->epoll_fd, EPOLL_CTL_ADD, server_socket, &ev)) { + DEBUG_LOG("epoll_ctl add failed: %s\n", strerror(errno)); + close(server_socket); + unlink(address->sun_path); + return false; + } + + INFO_LOG("Lease server (%s) initialized at %s\n", lease_handle->name, + address->sun_path); + return true; +} + +static void server_shutdown(struct ls *ls, struct ls_server *serv) +{ + if (unlink(serv->address.sun_path)) { + WARN_LOG("Server socket %s delete failed: %s\n", + serv->address.sun_path, strerror(errno)); + } + + epoll_ctl(ls->epoll_fd, EPOLL_CTL_DEL, serv->listen.fd, NULL); + close(serv->listen.fd); + ls_disconnect_client(ls, serv); + close(serv->server_socket_lock); +} + +struct ls *ls_create(struct lease_handle **lease_handles, int count) +{ + assert(lease_handles); + assert(count > 0); + + struct ls *ls = calloc(1, sizeof(struct ls)); + if (!ls) { + DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno)); + return NULL; + } + + ls->servers = calloc(count, sizeof(struct ls_server)); + if (!ls->servers) { + DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno)); + goto err; + } + + ls->epoll_fd = epoll_create1(0); + if (ls->epoll_fd < 0) { + DEBUG_LOG("epoll_create failed: %s\n", strerror(errno)); + goto err; + } + + for (int i = 0; i < count; i++) { + if (!server_setup(ls, &ls->servers[i], lease_handles[i])) + goto err; + ls->nservers++; + } + return ls; +err: + ls_destroy(ls); + return NULL; +} + +void ls_destroy(struct ls *ls) +{ + assert(ls); + + for (int i = 0; i < ls->nservers; i++) + server_shutdown(ls, &ls->servers[i]); + + close(ls->epoll_fd); + free(ls->servers); + free(ls); +} + +bool ls_get_request(struct ls *ls, struct ls_req *req) +{ + assert(ls); + assert(req); + + int request = -1; + while (request < 0) { + struct epoll_event ev; + if (epoll_wait(ls->epoll_fd, &ev, 1, -1) < 0) { + if (errno == EINTR) + continue; + DEBUG_LOG("epoll_wait failed: %s\n", strerror(errno)); + return false; + } + + struct ls_socket *sock = ev.data.ptr; + assert(sock); + + struct ls_server *server = sock->serv; + req->lease_handle = server->lease_handle; + req->server = server; + + if (sock == &server->listen) { + if (!(ev.events & POLLIN)) + continue; + if (client_connect(ls, server)) + request = LS_REQ_GET_LEASE; + } else if (sock == &server->client) { + if (!(ev.events & POLLHUP)) + continue; + request = LS_REQ_RELEASE_LEASE; + } else { + ERROR_LOG("Internal error: Invalid socket context\n"); + return false; + } + } + req->type = request; + return true; +} + +bool ls_send_fd(struct ls *ls, struct ls_server *serv, int fd) +{ + assert(ls); + assert(serv); + + if (fd < 0) + return false; + + char data[1]; + struct iovec iov = { + .iov_base = data, + .iov_len = sizeof(data), + }; + + char ctrl_buf[CMSG_SPACE(sizeof(int))] = {0}; + + struct msghdr msg = { + .msg_iov = &iov, + .msg_iovlen = 1, + .msg_controllen = sizeof(ctrl_buf), + .msg_control = ctrl_buf, + }; + + struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(sizeof(int)); + *((int *)CMSG_DATA(cmsg)) = fd; + + if (sendmsg(serv->client.fd, &msg, 0) < 0) { + DEBUG_LOG("sendmsg failed on %s: %s\n", serv->address.sun_path, + strerror(errno)); + return false; + } + + INFO_LOG("Lease request granted on %s\n", serv->address.sun_path); + return true; +} + +void ls_disconnect_client(struct ls *ls, struct ls_server *serv) +{ + assert(ls); + assert(serv); + if (!serv->is_client_connected) + return; + + epoll_ctl(ls->epoll_fd, EPOLL_CTL_DEL, serv->client.fd, NULL); + close(serv->client.fd); + serv->is_client_connected = false; +} diff --git a/drm-lease-manager/lease-server.h b/drm-lease-manager/lease-server.h new file mode 100644 index 0000000..c87b834 --- /dev/null +++ b/drm-lease-manager/lease-server.h @@ -0,0 +1,42 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 LEASE_SERVER_H +#define LEASE_SERVER_H +#include + +#include "drm-lease.h" + +struct ls; +struct ls_server; +enum ls_req_type { + LS_REQ_GET_LEASE, + LS_REQ_RELEASE_LEASE, +}; + +struct ls_req { + struct lease_handle *lease_handle; + struct ls_server *server; + enum ls_req_type type; +}; + +struct ls *ls_create(struct lease_handle **lease_handles, int count); +void ls_destroy(struct ls *ls); + +bool ls_get_request(struct ls *ls, struct ls_req *req); +bool ls_send_fd(struct ls *ls, struct ls_server *server, int fd); + +void ls_disconnect_client(struct ls *ls, struct ls_server *server); +#endif diff --git a/drm-lease-manager/main.c b/drm-lease-manager/main.c new file mode 100644 index 0000000..c3a933f --- /dev/null +++ b/drm-lease-manager/main.c @@ -0,0 +1,120 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "lease-manager.h" +#include "lease-server.h" +#include "log.h" + +#include +#include +#include +#include + +static void usage(const char *progname) +{ + printf("Usage: %s [OPTIONS] []\n\n" + "Options:\n" + "-h, --help \tPrint this help\n" + "-v, --verbose \tEnable verbose debug messages\n", + progname); +} + +const char *opts = "vh"; +const struct option options[] = { + {"help", no_argument, NULL, 'h'}, + {"verbose", no_argument, NULL, 'v'}, + {NULL, 0, NULL, 0}, +}; + +int main(int argc, char **argv) +{ + char *device = "/dev/dri/card0"; + + bool debug_log = false; + + int c; + while ((c = getopt_long(argc, argv, opts, options, NULL)) != -1) { + int ret = EXIT_FAILURE; + switch (c) { + case 'v': + debug_log = true; + break; + case 'h': + ret = EXIT_SUCCESS; + /* fall through */ + default: + usage(argv[0]); + return ret; + } + } + + if (optind < argc) + device = argv[optind]; + + dlm_log_enable_debug(debug_log); + + struct lm *lm = lm_create(device); + if (!lm) { + ERROR_LOG("DRM Lease initialization failed\n"); + return EXIT_FAILURE; + } + + struct lease_handle **lease_handles = NULL; + int count_ids = lm_get_lease_handles(lm, &lease_handles); + assert(count_ids > 0); + + struct ls *ls = ls_create(lease_handles, count_ids); + if (!ls) { + lm_destroy(lm); + ERROR_LOG("Client socket initialization failed\n"); + return EXIT_FAILURE; + } + + struct ls_req req; + while (ls_get_request(ls, &req)) { + switch (req.type) { + case LS_REQ_GET_LEASE: { + int fd = lm_lease_grant(lm, req.lease_handle); + if (fd < 0) { + ERROR_LOG( + "Can't fulfill lease request: lease=%s\n", + req.lease_handle->name); + ls_disconnect_client(ls, req.server); + break; + } + + if (!ls_send_fd(ls, req.server, fd)) { + ERROR_LOG( + "Client communication error: lease=%s\n", + req.lease_handle->name); + ls_disconnect_client(ls, req.server); + lm_lease_revoke(lm, req.lease_handle); + } + break; + } + case LS_REQ_RELEASE_LEASE: + ls_disconnect_client(ls, req.server); + lm_lease_revoke(lm, req.lease_handle); + break; + default: + ERROR_LOG("Internal error: Invalid lease request\n"); + goto done; + } + } +done: + ls_destroy(ls); + lm_destroy(lm); + return EXIT_FAILURE; +} diff --git a/drm-lease-manager/meson.build b/drm-lease-manager/meson.build new file mode 100644 index 0000000..1171b02 --- /dev/null +++ b/drm-lease-manager/meson.build @@ -0,0 +1,12 @@ + +lease_manager_files = files('lease-manager.c') +lease_server_files = files('lease-server.c') +main = executable('drm-lease-manager', + [ 'main.c', lease_manager_files, lease_server_files ], + dependencies: [ drm_dep, dlmcommon_dep ], + install: true, +) + +if enable_tests + subdir('test') +endif diff --git a/drm-lease-manager/test/lease-manager-test.c b/drm-lease-manager/test/lease-manager-test.c new file mode 100644 index 0000000..c741cb3 --- /dev/null +++ b/drm-lease-manager/test/lease-manager-test.c @@ -0,0 +1,448 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 +#include + +#include +#include +#include + +#include "lease-manager.h" +#include "log.h" +#include "test-drm-device.h" +#include "test-helpers.h" + +/* CHECK_LEASE_OBJECTS + * + * Checks the list of objects associated with a given lease_index. + * Asks the lease manager to create the lease, and checks that + * the requested objects are the ones given in the supplied list. */ + +#define CHECK_LEASE_OBJECTS(lease, ...) \ + do { \ + lm_lease_grant(lm, lease); \ + uint32_t objs[] = {__VA_ARGS__}; \ + int nobjs = ARRAY_LEN(objs); \ + ck_assert_int_eq(drmModeCreateLease_fake.arg2_val, nobjs); \ + check_uint_array_eq(drmModeCreateLease_fake.arg1_val, objs, \ + nobjs); \ + } while (0) + +/************** Mock functions *************/ +DEFINE_FFF_GLOBALS; + +FAKE_VALUE_FUNC(drmModeResPtr, drmModeGetResources, int); +FAKE_VOID_FUNC(drmModeFreeResources, drmModeResPtr); +FAKE_VALUE_FUNC(drmModePlaneResPtr, drmModeGetPlaneResources, int); +FAKE_VOID_FUNC(drmModeFreePlaneResources, drmModePlaneResPtr); + +FAKE_VALUE_FUNC(drmModePlanePtr, drmModeGetPlane, int, uint32_t); +FAKE_VOID_FUNC(drmModeFreePlane, drmModePlanePtr); +FAKE_VALUE_FUNC(drmModeConnectorPtr, drmModeGetConnector, int, uint32_t); +FAKE_VOID_FUNC(drmModeFreeConnector, drmModeConnectorPtr); +FAKE_VALUE_FUNC(drmModeEncoderPtr, drmModeGetEncoder, int, uint32_t); +FAKE_VOID_FUNC(drmModeFreeEncoder, drmModeEncoderPtr); + +FAKE_VALUE_FUNC(int, drmModeCreateLease, int, const uint32_t *, int, int, + uint32_t *); +FAKE_VALUE_FUNC(int, drmModeRevokeLease, int, uint32_t); + +/************** Test fixutre functions *************************/ + +static void test_setup(void) +{ + RESET_FAKE(drmModeGetResources); + RESET_FAKE(drmModeFreeResources); + RESET_FAKE(drmModeGetPlaneResources); + RESET_FAKE(drmModeFreePlaneResources); + + RESET_FAKE(drmModeGetPlane); + RESET_FAKE(drmModeFreePlane); + RESET_FAKE(drmModeGetConnector); + RESET_FAKE(drmModeFreeConnector); + RESET_FAKE(drmModeGetEncoder); + RESET_FAKE(drmModeFreeEncoder); + + RESET_FAKE(drmModeCreateLease); + RESET_FAKE(drmModeRevokeLease); + + drmModeGetResources_fake.return_val = TEST_DEVICE_RESOURCES; + drmModeGetPlaneResources_fake.return_val = TEST_DEVICE_PLANE_RESOURCES; + + drmModeGetPlane_fake.custom_fake = get_plane; + drmModeGetConnector_fake.custom_fake = get_connector; + drmModeGetEncoder_fake.custom_fake = get_encoder; + drmModeCreateLease_fake.custom_fake = create_lease; +} + +static void test_shutdown(void) +{ + reset_drm_test_device(); +} + +/************** Resource enumeration tests *************/ + +/* These tests verify that the lease manager correctly assigns + * DRM resources to thier respective leases. In some cases + * the lease manager must choose which resources to include in + * each lease, so these tests verify that a valid (but not + * necessarily optimal) choice is made. + */ + +/* all_outputs_connected + * + * Test details: Create leases when all crtc/encoder/connector paths are + * connected. + * + * Expected results: Leases are created for the currently connected sets of + * resources. + */ +START_TEST(all_outputs_connected) +{ + int out_cnt = 2, plane_cnt = 0; + + ck_assert_int_eq( + setup_drm_test_device(out_cnt, out_cnt, out_cnt, plane_cnt), true); + + drmModeConnector connectors[] = { + CONNECTOR(CONNECTOR_ID(0), ENCODER_ID(0), &ENCODER_ID(0), 1), + CONNECTOR(CONNECTOR_ID(1), ENCODER_ID(1), &ENCODER_ID(1), 1), + }; + + drmModeEncoder encoders[] = { + ENCODER(ENCODER_ID(0), CRTC_ID(0), 0x3), + ENCODER(ENCODER_ID(1), CRTC_ID(1), 0x2), + }; + + setup_test_device_layout(connectors, encoders, NULL); + + struct lm *lm = lm_create(TEST_DRM_DEVICE); + ck_assert_ptr_ne(lm, NULL); + + struct lease_handle **handles; + ck_assert_int_eq(out_cnt, lm_get_lease_handles(lm, &handles)); + ck_assert_ptr_ne(handles, NULL); + + CHECK_LEASE_OBJECTS(handles[0], CRTC_ID(0), CONNECTOR_ID(0)); + CHECK_LEASE_OBJECTS(handles[1], CRTC_ID(1), CONNECTOR_ID(1)); + + lm_destroy(lm); +} +END_TEST + +/* no_outputs_connected + * + * Test details: Create leases when no crtc/encoder/connector paths are + * connected. + * + * Expected results: Available resources are divided between the leases. + * The same resource should not appear in multiple leases. + */ +START_TEST(no_outputs_connected) +{ + int out_cnt = 2, plane_cnt = 0; + + ck_assert_int_eq( + setup_drm_test_device(out_cnt, out_cnt, out_cnt, plane_cnt), true); + + drmModeConnector connectors[] = { + CONNECTOR(CONNECTOR_ID(0), 0, &ENCODER_ID(0), 1), + CONNECTOR(CONNECTOR_ID(1), 0, &ENCODER_ID(1), 1), + }; + + drmModeEncoder encoders[] = { + ENCODER(ENCODER_ID(0), 0, 0x2), + ENCODER(ENCODER_ID(1), 0, 0x3), + }; + + setup_test_device_layout(connectors, encoders, NULL); + + struct lm *lm = lm_create(TEST_DRM_DEVICE); + ck_assert_ptr_ne(lm, NULL); + + struct lease_handle **handles; + ck_assert_int_eq(out_cnt, lm_get_lease_handles(lm, &handles)); + ck_assert_ptr_ne(handles, NULL); + + CHECK_LEASE_OBJECTS(handles[0], CRTC_ID(1), CONNECTOR_ID(0)); + CHECK_LEASE_OBJECTS(handles[1], CRTC_ID(0), CONNECTOR_ID(1)); + + lm_destroy(lm); +} +END_TEST + +/* some_outputs_connected */ +/* Test details: Create leases when one output is connected and one is not. + * Expected results: Currently connected resources should be added to + * the same lease. + * The non-connected resources should be added to a second + * lease. + */ +START_TEST(some_outputs_connected) +{ + int out_cnt = 2, plane_cnt = 0; + + ck_assert_int_eq( + setup_drm_test_device(out_cnt, out_cnt, out_cnt, plane_cnt), true); + + drmModeConnector connectors[] = { + CONNECTOR(CONNECTOR_ID(0), ENCODER_ID(0), &ENCODER_ID(0), 1), + CONNECTOR(CONNECTOR_ID(1), 0, &ENCODER_ID(1), 1), + }; + + drmModeEncoder encoders[] = { + ENCODER(ENCODER_ID(0), CRTC_ID(0), 0x3), + ENCODER(ENCODER_ID(1), 0, 0x3), + }; + + setup_test_device_layout(connectors, encoders, NULL); + + struct lm *lm = lm_create(TEST_DRM_DEVICE); + ck_assert_ptr_ne(lm, NULL); + + struct lease_handle **handles; + ck_assert_int_eq(out_cnt, lm_get_lease_handles(lm, &handles)); + ck_assert_ptr_ne(handles, NULL); + + CHECK_LEASE_OBJECTS(handles[0], CRTC_ID(0), CONNECTOR_ID(0)); + CHECK_LEASE_OBJECTS(handles[1], CRTC_ID(1), CONNECTOR_ID(1)); + + lm_destroy(lm); +} +END_TEST + +/* fewer_crtcs_than_connectors */ +/* Test details: Create leases on a system with more connectors than CRTCs + * Expected results: Number of leases generated should correspond to number of + * CRTCs. + * Leases contain one valid connector for each CRTC. + */ +START_TEST(fewer_crtcs_than_connectors) +{ + int out_cnt = 3, plane_cnt = 0, crtc_cnt = 2; + + ck_assert_int_eq( + setup_drm_test_device(crtc_cnt, out_cnt, out_cnt, plane_cnt), true); + + drmModeConnector connectors[] = { + CONNECTOR(CONNECTOR_ID(0), 0, &ENCODER_ID(0), 1), + CONNECTOR(CONNECTOR_ID(1), 0, &ENCODER_ID(1), 1), + CONNECTOR(CONNECTOR_ID(2), 0, &ENCODER_ID(2), 1), + }; + + drmModeEncoder encoders[] = { + ENCODER(ENCODER_ID(0), 0, 0x3), + ENCODER(ENCODER_ID(1), 0, 0x1), + ENCODER(ENCODER_ID(2), 0, 0x3), + }; + + setup_test_device_layout(connectors, encoders, NULL); + + struct lm *lm = lm_create(TEST_DRM_DEVICE); + ck_assert_ptr_ne(lm, NULL); + + struct lease_handle **handles; + ck_assert_int_eq(lm_get_lease_handles(lm, &handles), crtc_cnt); + ck_assert_ptr_ne(handles, NULL); + + CHECK_LEASE_OBJECTS(handles[0], CRTC_ID(0), CONNECTOR_ID(0)); + CHECK_LEASE_OBJECTS(handles[1], CRTC_ID(1), CONNECTOR_ID(2)); + lm_destroy(lm); +} +END_TEST + +/* separate_overlay_planes_by_crtc */ +/* Test details: Add overlay planes to leases. Each plane is tied to a + * specific CRTC. + * Expected results: The leases contain all of the planes for connected to + * each CRTC and no others. + */ +START_TEST(separate_overlay_planes_by_crtc) +{ + + int out_cnt = 2, plane_cnt = 3; + + ck_assert_int_eq( + setup_drm_test_device(out_cnt, out_cnt, out_cnt, plane_cnt), true); + + drmModeConnector connectors[] = { + CONNECTOR(CONNECTOR_ID(0), ENCODER_ID(0), &ENCODER_ID(0), 1), + CONNECTOR(CONNECTOR_ID(1), ENCODER_ID(1), &ENCODER_ID(1), 1), + }; + + drmModeEncoder encoders[] = { + ENCODER(ENCODER_ID(0), CRTC_ID(0), 0x1), + ENCODER(ENCODER_ID(1), CRTC_ID(1), 0x2), + }; + + drmModePlane planes[] = { + PLANE(PLANE_ID(0), 0x2), + PLANE(PLANE_ID(1), 0x1), + PLANE(PLANE_ID(2), 0x2), + }; + + setup_test_device_layout(connectors, encoders, planes); + + struct lm *lm = lm_create(TEST_DRM_DEVICE); + ck_assert_ptr_ne(lm, NULL); + + struct lease_handle **handles; + ck_assert_int_eq(out_cnt, lm_get_lease_handles(lm, &handles)); + ck_assert_ptr_ne(handles, NULL); + + CHECK_LEASE_OBJECTS(handles[0], PLANE_ID(1), CRTC_ID(0), + CONNECTOR_ID(0)); + CHECK_LEASE_OBJECTS(handles[1], PLANE_ID(0), PLANE_ID(2), CRTC_ID(1), + CONNECTOR_ID(1)); + lm_destroy(lm); +} +END_TEST + +/* reject_planes_shared_between_multiple_crtcs */ +/* Test details: Add overlay planes to leases. Some planes are shared between + * multiple CRTCs. + * Expected results: The leases contain all of the unique planes for each CRTC. + * Planes that can be used on multiple CRTCs are not included + * in any lease. + */ +START_TEST(reject_planes_shared_between_multiple_crtcs) +{ + + int out_cnt = 2, plane_cnt = 3; + + ck_assert_int_eq( + setup_drm_test_device(out_cnt, out_cnt, out_cnt, plane_cnt), true); + + drmModeConnector connectors[] = { + CONNECTOR(CONNECTOR_ID(0), ENCODER_ID(0), &ENCODER_ID(0), 1), + CONNECTOR(CONNECTOR_ID(1), ENCODER_ID(1), &ENCODER_ID(1), 1), + }; + + drmModeEncoder encoders[] = { + ENCODER(ENCODER_ID(0), CRTC_ID(0), 0x1), + ENCODER(ENCODER_ID(1), CRTC_ID(1), 0x2), + }; + + drmModePlane planes[] = { + PLANE(PLANE_ID(0), 0x2), + PLANE(PLANE_ID(1), 0x1), + PLANE(PLANE_ID(2), 0x3), + }; + + setup_test_device_layout(connectors, encoders, planes); + + struct lm *lm = lm_create(TEST_DRM_DEVICE); + ck_assert_ptr_ne(lm, NULL); + + struct lease_handle **handles; + ck_assert_int_eq(out_cnt, lm_get_lease_handles(lm, &handles)); + ck_assert_ptr_ne(handles, NULL); + + CHECK_LEASE_OBJECTS(handles[0], PLANE_ID(1), CRTC_ID(0), + CONNECTOR_ID(0)); + CHECK_LEASE_OBJECTS(handles[1], PLANE_ID(0), CRTC_ID(1), + CONNECTOR_ID(1)); + lm_destroy(lm); +} +END_TEST + +static void add_connector_enum_tests(Suite *s) +{ + TCase *tc = tcase_create("Resource enumeration"); + + tcase_add_checked_fixture(tc, test_setup, test_shutdown); + + tcase_add_test(tc, all_outputs_connected); + tcase_add_test(tc, no_outputs_connected); + tcase_add_test(tc, fewer_crtcs_than_connectors); + tcase_add_test(tc, some_outputs_connected); + tcase_add_test(tc, separate_overlay_planes_by_crtc); + tcase_add_test(tc, reject_planes_shared_between_multiple_crtcs); + suite_add_tcase(s, tc); +} + +/************** Lease management tests *************/ + +/* create_and_revoke_lease */ +/* Test details: Create leases and revoke them. + * Expected results: drmModeRevokeLease() is called with the correct leasee_id. + */ +START_TEST(create_and_revoke_lease) +{ + int lease_cnt = 2; + bool res = setup_drm_test_device(lease_cnt, lease_cnt, lease_cnt, 0); + ck_assert_int_eq(res, true); + + drmModeConnector connectors[] = { + CONNECTOR(CONNECTOR_ID(0), ENCODER_ID(0), &ENCODER_ID(0), 1), + CONNECTOR(CONNECTOR_ID(1), ENCODER_ID(1), &ENCODER_ID(1), 1), + }; + + drmModeEncoder encoders[] = { + ENCODER(ENCODER_ID(0), CRTC_ID(0), 0x1), + ENCODER(ENCODER_ID(1), CRTC_ID(1), 0x2), + }; + + setup_test_device_layout(connectors, encoders, NULL); + + struct lm *lm = lm_create(TEST_DRM_DEVICE); + ck_assert_ptr_ne(lm, NULL); + + struct lease_handle **handles; + ck_assert_int_eq(lease_cnt, lm_get_lease_handles(lm, &handles)); + ck_assert_ptr_ne(handles, NULL); + + for (int i = 0; i < lease_cnt; i++) { + ck_assert_int_ge(lm_lease_grant(lm, handles[i]), 0); + lm_lease_revoke(lm, handles[i]); + } + + ck_assert_int_eq(drmModeRevokeLease_fake.call_count, lease_cnt); + + for (int i = 0; i < lease_cnt; i++) { + ck_assert_int_eq(drmModeRevokeLease_fake.arg1_history[i], + LESSEE_ID(i)); + } +} +END_TEST + +static void add_lease_management_tests(Suite *s) +{ + TCase *tc = tcase_create("Lease management"); + + tcase_add_checked_fixture(tc, test_setup, test_shutdown); + + tcase_add_test(tc, create_and_revoke_lease); + suite_add_tcase(s, tc); +} + +int main(void) +{ + int number_failed; + Suite *s; + SRunner *sr; + + s = suite_create("DLM lease manager tests"); + + add_connector_enum_tests(s); + add_lease_management_tests(s); + + sr = srunner_create(s); + srunner_run_all(sr, CK_NORMAL); + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/drm-lease-manager/test/lease-server-test.c b/drm-lease-manager/test/lease-server-test.c new file mode 100644 index 0000000..f8e000e --- /dev/null +++ b/drm-lease-manager/test/lease-server-test.c @@ -0,0 +1,380 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 + +#include +#include +#include + +#include + +#include "lease-server.h" +#include "log.h" +#include "test-helpers.h" +#include "test-socket-client.h" + +#define SOCKETDIR "/tmp" + +/************** Test fixutre functions *************************/ +struct test_config default_test_config; + +#define TEST_LEASE_NAME "test-lease" + +static struct lease_handle test_lease = { + .name = TEST_LEASE_NAME, +}; + +static void test_setup(void) +{ + dlm_log_enable_debug(true); + setenv("DLM_RUNTIME_PATH", SOCKETDIR, 1); + + default_test_config = (struct test_config){ + .lease = &test_lease, + }; +} + +static void test_shutdown(void) +{ + test_config_cleanup(&default_test_config); +} + +static struct ls *create_default_server(void) +{ + struct lease_handle *leases[] = { + &test_lease, + }; + struct ls *ls = ls_create(leases, 1); + ck_assert_ptr_ne(ls, NULL); + return ls; +} + +/************** Lease server error handling tests *************/ + +/* duplicate_server_failure + * + * Test details: Try to intialize the same server twice + * Expected results: ls_create() fails. + */ +START_TEST(duplicate_server_failure) +{ + struct lease_handle *leases[] = {&test_lease, &test_lease}; + struct ls *ls = ls_create(leases, 2); + ck_assert_ptr_eq(ls, NULL); +} +END_TEST + +START_TEST(long_lease_name_failure) +{ + char long_lease_name[200]; + + size_t len = sizeof(long_lease_name) - 1; + memset(long_lease_name, 'a', len); + long_lease_name[len] = '\0'; + + struct lease_handle long_name_lease = {.name = long_lease_name}; + + struct lease_handle *leases[] = {&long_name_lease}; + struct ls *ls = ls_create(leases, 1); + ck_assert_ptr_eq(ls, NULL); +} +END_TEST + +static void add_error_tests(Suite *s) +{ + TCase *tc = tcase_create("Lease server errors"); + + tcase_add_checked_fixture(tc, test_setup, test_shutdown); + + tcase_add_test(tc, duplicate_server_failure); + tcase_add_test(tc, long_lease_name_failure); + suite_add_tcase(s, tc); +} + +/************** Client request handling tests ************/ + +/* Test the handling of client requests. Make sure that the + * proper struct ls_req are generated for each client request. + */ + +static void check_request(struct ls_req *req, + struct lease_handle *expected_lease, + enum ls_req_type expected_type) +{ + ck_assert_ptr_eq(req->lease_handle, expected_lease); + ck_assert_int_eq(req->type, expected_type); +} + +static void get_and_check_request(struct ls *ls, + struct lease_handle *expected_lease, + enum ls_req_type expected_type) +{ + struct ls_req req; + bool req_valid = ls_get_request(ls, &req); + ck_assert_int_eq(req_valid, true); + check_request(&req, expected_lease, expected_type); +} + +/* Asynchronous version of the above. Has the extra overhead of + * spawning a new thread, so should be used sparingly. */ +struct async_req { + pthread_t tid; + struct ls *ls; + + bool req_valid; + struct ls_req expected; + struct ls_req actual; +}; + +static void *get_request_thread(void *arg) +{ + struct async_req *async_req = arg; + async_req->req_valid = + ls_get_request(async_req->ls, &async_req->actual); + + return NULL; +} + +static struct async_req * +get_and_check_request_async(struct ls *ls, struct lease_handle *expected_lease, + enum ls_req_type expected_type) + +{ + struct async_req *req = malloc(sizeof(struct async_req)); + ck_assert_ptr_ne(req, NULL); + + *req = (struct async_req){ + .ls = ls, + .expected = + { + .lease_handle = expected_lease, + .type = expected_type, + }, + }; + + int ret = pthread_create(&req->tid, NULL, get_request_thread, req); + ck_assert_int_eq(ret, 0); + + return req; +} + +static void check_async_req_result(struct async_req *req) +{ + + pthread_join(req->tid, NULL); + ck_assert_int_eq(req->req_valid, true); + check_request(&req->actual, req->expected.lease_handle, + req->expected.type); + free(req); +} + +/* issue_lease_request_and_release + * + * Test details: Generate a lease request and lease release command from + * a client. + * Expected results: One get lease and one release lease request are returned + * from ls_get_request(). + */ +START_TEST(issue_lease_request_and_release) +{ + struct ls *ls = create_default_server(); + + struct client_state *cstate = test_client_start(&default_test_config); + + get_and_check_request(ls, &test_lease, LS_REQ_GET_LEASE); + test_client_stop(cstate); + get_and_check_request(ls, &test_lease, LS_REQ_RELEASE_LEASE); +} +END_TEST + +/* issue_lease_request_and_early_release + * + * Test details: Close client connection immediately after connecting (before + * lease request is processed) + * Expected results: Should be the same result as + * issue_lease_request_and_release. + */ +START_TEST(issue_lease_request_and_early_release) +{ + struct ls *ls = create_default_server(); + + struct client_state *cstate = test_client_start(&default_test_config); + + test_client_stop(cstate); + get_and_check_request(ls, &test_lease, LS_REQ_GET_LEASE); + get_and_check_request(ls, &test_lease, LS_REQ_RELEASE_LEASE); +} +END_TEST + +/* issue_multiple_lease_requests + * + * Test details: Generate multiple lease requests to the same lease server from + * multiple clients at the same time + * Expected results: One get lease and one release lease request are returned + * from ls_get_request(). + * Requests from all but the first client are rejected + * (sockets are closed). + */ +START_TEST(issue_multiple_lease_requests) +{ + struct lease_handle *leases[] = { + &test_lease, + }; + struct ls *ls = ls_create(leases, 1); + + struct test_config accepted_config; + struct client_state *accepted_cstate; + + accepted_config = default_test_config; + accepted_cstate = test_client_start(&accepted_config); + get_and_check_request(ls, &test_lease, LS_REQ_GET_LEASE); + + /*Try to make additional connections while the first is still + *connected. */ + const int nextra_clients = 2; + struct test_config extra_configs[nextra_clients]; + struct client_state *extra_cstates[nextra_clients]; + + for (int i = 0; i < nextra_clients; i++) { + extra_configs[i] = default_test_config; + extra_cstates[i] = test_client_start(&extra_configs[i]); + } + + // Start asyncronously checking for the accepted client to release. + struct async_req *async_release_req = + get_and_check_request_async(ls, &test_lease, LS_REQ_RELEASE_LEASE); + + for (int i = 0; i < nextra_clients; i++) { + test_client_stop(extra_cstates[i]); + } + + /* Release the first connection and check results */ + test_client_stop(accepted_cstate); + check_async_req_result(async_release_req); + + /* Only one connection should be granted access by the lease manager */ + ck_assert_int_eq(accepted_config.connection_completed, true); + for (int i = 0; i < nextra_clients; i++) + ck_assert_int_eq(extra_configs[i].connection_completed, false); +} +END_TEST + +static void add_client_request_tests(Suite *s) +{ + TCase *tc = tcase_create("Client request testing"); + + tcase_add_checked_fixture(tc, test_setup, test_shutdown); + + tcase_add_test(tc, issue_lease_request_and_release); + tcase_add_test(tc, issue_lease_request_and_early_release); + tcase_add_test(tc, issue_multiple_lease_requests); + suite_add_tcase(s, tc); +} + +/************** File descriptor sending tests ************/ + +/* Test the sending (and failure to send) of file descriptors + * to the client. + */ + +/* send_fd_to_client + * + * Test details: Send a valid fd to a given client. + * Expected results: The correct fd is successfully sent. + */ +START_TEST(send_fd_to_client) +{ + struct ls *ls = create_default_server(); + + struct client_state *cstate = test_client_start(&default_test_config); + + struct ls_req req; + bool req_valid = ls_get_request(ls, &req); + ck_assert_int_eq(req_valid, true); + check_request(&req, &test_lease, LS_REQ_GET_LEASE); + + /* send an fd to the client*/ + int test_fd = get_dummy_fd(); + ck_assert_int_eq(ls_send_fd(ls, req.server, test_fd), true); + + test_client_stop(cstate); + get_and_check_request(ls, &test_lease, LS_REQ_RELEASE_LEASE); + + ck_assert_int_eq(default_test_config.connection_completed, true); + ck_assert_int_eq(default_test_config.has_data, true); + check_fd_equality(test_fd, default_test_config.received_fd); +} +END_TEST + +/* ls_send_fd_is_noop_when_fd_is_invalid + * + * Test details: Call ls_send_fd() with an invalid fd. + * Expected results: No fd is sent to client. The connection to the + * client is closed. + */ +START_TEST(ls_send_fd_is_noop_when_fd_is_invalid) +{ + struct ls *ls = create_default_server(); + + struct client_state *cstate = test_client_start(&default_test_config); + + struct ls_req req; + bool req_valid = ls_get_request(ls, &req); + ck_assert_int_eq(req_valid, true); + check_request(&req, &test_lease, LS_REQ_GET_LEASE); + + int invalid_fd = get_dummy_fd(); + close(invalid_fd); + + ck_assert_int_eq(ls_send_fd(ls, req.server, invalid_fd), false); + + test_client_stop(cstate); + get_and_check_request(ls, &test_lease, LS_REQ_RELEASE_LEASE); + ck_assert_int_eq(default_test_config.connection_completed, true); + ck_assert_int_eq(default_test_config.has_data, false); +} +END_TEST + +static void add_fd_send_tests(Suite *s) +{ + TCase *tc = tcase_create("File descriptor sending tests"); + + tcase_add_checked_fixture(tc, test_setup, test_shutdown); + + tcase_add_test(tc, send_fd_to_client); + tcase_add_test(tc, ls_send_fd_is_noop_when_fd_is_invalid); + suite_add_tcase(s, tc); +} + +int main(void) +{ + int number_failed; + Suite *s; + SRunner *sr; + + s = suite_create("DLM lease server tests"); + + add_error_tests(s); + add_client_request_tests(s); + add_fd_send_tests(s); + + sr = srunner_create(s); + + srunner_run_all(sr, CK_NORMAL); + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/drm-lease-manager/test/meson.build b/drm-lease-manager/test/meson.build new file mode 100644 index 0000000..7d42bec --- /dev/null +++ b/drm-lease-manager/test/meson.build @@ -0,0 +1,30 @@ +check_dep = dependency('check') + +ls_inc = include_directories('..') + +ls_objects = main.extract_objects(lease_server_files) +ls_test_sources = [ + 'lease-server-test.c', + 'test-socket-client.c', +] + +ls_test = executable('lease-server-test', + sources: ls_test_sources, + objects: ls_objects, + dependencies: [check_dep, fff_dep, dlmcommon_dep, thread_dep], + include_directories: ls_inc) + +lm_objects = main.extract_objects(lease_manager_files) +lm_test_sources = [ + 'lease-manager-test.c', + 'test-drm-device.c', +] + +lm_test = executable('lease-manager-test', + sources: lm_test_sources, + objects: lm_objects, + dependencies: [check_dep, fff_dep, dlmcommon_dep, drm_dep], + include_directories: ls_inc) + +test('DRM Lease manager - socket server test', ls_test, is_parallel: false) +test('DRM Lease manager - DRM interface test', lm_test) diff --git a/drm-lease-manager/test/test-drm-device.c b/drm-lease-manager/test/test-drm-device.c new file mode 100644 index 0000000..844599a --- /dev/null +++ b/drm-lease-manager/test/test-drm-device.c @@ -0,0 +1,122 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 +#include +#include +#include +#include + +#include "test-drm-device.h" +#define UNUSED(x) (void)(x) + +/* Set the base value for IDs of each resource type. + * These can be adjusted if test cases need more IDs. */ +#define IDS_PER_RES_TYPE 32 + +#define CRTC_BASE (IDS_PER_RES_TYPE) +#define CONNECTOR_BASE (CRTC_BASE + IDS_PER_RES_TYPE) +#define ENCODER_BASE (CONNECTOR_BASE + IDS_PER_RES_TYPE) +#define PLANE_BASE (ENCODER_BASE + IDS_PER_RES_TYPE) +#define LESSEE_ID_BASE (PLANE_BASE + IDS_PER_RES_TYPE) + +struct drm_device test_device; + +#define ALLOC_RESOURCE(res, container) \ + do { \ + if (res != 0) { \ + test_device.container.res = \ + malloc(sizeof(uint32_t) * res); \ + if (!test_device.container.res) \ + return false; \ + test_device.container.count_##res = res; \ + } \ + } while (0) + +#define FILL_RESOURCE(res, RES, container) \ + for (int i = 0; i < res; i++) { \ + test_device.container.res[i] = RES##_BASE + i; \ + } + +bool setup_drm_test_device(int crtcs, int connectors, int encoders, int planes) +{ + int lessee_ids = crtcs; + ALLOC_RESOURCE(crtcs, resources); + ALLOC_RESOURCE(connectors, resources); + ALLOC_RESOURCE(encoders, resources); + ALLOC_RESOURCE(planes, plane_resources); + ALLOC_RESOURCE(lessee_ids, leases); + + FILL_RESOURCE(crtcs, CRTC, resources); + FILL_RESOURCE(connectors, CONNECTOR, resources); + FILL_RESOURCE(encoders, ENCODER, resources); + FILL_RESOURCE(planes, PLANE, plane_resources); + FILL_RESOURCE(lessee_ids, LESSEE_ID, leases); + + return true; +} + +void reset_drm_test_device(void) +{ + free(test_device.resources.crtcs); + free(test_device.resources.connectors); + free(test_device.resources.encoders); + free(test_device.plane_resources.planes); + free(test_device.leases.lessee_ids); + memset(&test_device, 0, sizeof(test_device)); +} + +void setup_test_device_layout(drmModeConnector *connectors, + drmModeEncoder *encoders, drmModePlane *planes) +{ + test_device.layout.connectors = connectors; + test_device.layout.encoders = encoders; + test_device.layout.planes = planes; +} + +#define GET_DRM_RESOURCE_FN(Res, res, RES, container) \ + drmMode##Res##Ptr get_##res(int fd, uint32_t id) \ + { \ + UNUSED(fd); \ + if (id == 0) \ + return NULL; \ + ck_assert_int_ge(id, RES##_BASE); \ + ck_assert_int_lt( \ + id, RES##_BASE + test_device.container.count_##res##s); \ + return &test_device.layout.res##s[id - RES##_BASE]; \ + } + +GET_DRM_RESOURCE_FN(Connector, connector, CONNECTOR, resources) +GET_DRM_RESOURCE_FN(Encoder, encoder, ENCODER, resources) +GET_DRM_RESOURCE_FN(Plane, plane, PLANE, plane_resources) + +int create_lease(int fd, const uint32_t *objects, int num_objects, int flags, + uint32_t *lessee_id) +{ + UNUSED(fd); + UNUSED(objects); + UNUSED(num_objects); + UNUSED(flags); + + int lease_count = test_device.leases.count; + if (lease_count < test_device.leases.count_lessee_ids) + *lessee_id = test_device.leases.lessee_ids[lease_count]; + else + *lessee_id = 0; + + test_device.leases.count++; + + return 0; +} diff --git a/drm-lease-manager/test/test-drm-device.h b/drm-lease-manager/test/test-drm-device.h new file mode 100644 index 0000000..1d5b683 --- /dev/null +++ b/drm-lease-manager/test/test-drm-device.h @@ -0,0 +1,81 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 TEST_DRM_DEVICE_H +#define TEST_DRM_DEVICE_H + +#include + +/* TEST_DRM_DEVICE can be the path to any + * file that can be opened. + */ +#define TEST_DRM_DEVICE "/dev/null" + +struct drm_device { + drmModeRes resources; + drmModePlaneRes plane_resources; + struct { + drmModeConnector *connectors; + drmModeEncoder *encoders; + drmModePlane *planes; + } layout; + + struct { + int count; + uint32_t *lessee_ids; + int count_lessee_ids; + } leases; +}; + +extern struct drm_device test_device; + +bool setup_drm_test_device(int crtcs, int connectors, int encoders, int planes); +void setup_test_device_layout(drmModeConnector *connectors, + drmModeEncoder *encoders, drmModePlane *planes); +void reset_drm_test_device(void); + +drmModeConnectorPtr get_connector(int fd, uint32_t id); +drmModeEncoderPtr get_encoder(int fd, uint32_t id); +drmModePlanePtr get_plane(int fd, uint32_t id); +int create_lease(int fd, const uint32_t *objects, int num_objects, int flags, + uint32_t *lessee_id); + +#define TEST_DEVICE_RESOURCES (&test_device.resources) +#define TEST_DEVICE_PLANE_RESOURCES (&test_device.plane_resources) + +#define CRTC_ID(x) (test_device.resources.crtcs[x]) +#define CONNECTOR_ID(x) (test_device.resources.connectors[x]) +#define ENCODER_ID(x) (test_device.resources.encoders[x]) +#define PLANE_ID(x) (test_device.plane_resources.planes[x]) +#define LESSEE_ID(x) (test_device.leases.lessee_ids[x]) + +#define CONNECTOR(cid, eid, encs, enc_cnt) \ + { \ + .connector_id = cid, .encoder_id = eid, \ + .count_encoders = enc_cnt, .encoders = encs, \ + } + +#define ENCODER(eid, crtc, crtc_mask) \ + { \ + .encoder_id = eid, .crtc_id = crtc, \ + .possible_crtcs = crtc_mask, \ + } + +#define PLANE(pid, crtc_mask) \ + { \ + .plane_id = pid, .possible_crtcs = crtc_mask, \ + } + +#endif diff --git a/drm-lease-manager/test/test-socket-client.c b/drm-lease-manager/test/test-socket-client.c new file mode 100644 index 0000000..260437a --- /dev/null +++ b/drm-lease-manager/test/test-socket-client.c @@ -0,0 +1,162 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "test-socket-client.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "socket-path.h" + +#define DEFAULT_RECV_TIMEOUT (100) // timeout in ms to receive data from server + +struct client_state { + pthread_t tid; + + int socket_fd; + struct test_config *config; +}; + +static void client_gst_socket_status(int socket_fd, struct test_config *config) +{ + + config->connection_completed = true; + + struct pollfd pfd = {.fd = socket_fd, .events = POLLIN}; + if (poll(&pfd, 1, config->recv_timeout) <= 0) + return; + + if (pfd.revents & POLLHUP) + config->connection_completed = false; + + if (pfd.revents & POLLIN) + config->has_data = true; + + return; +} + +static int receive_fd_from_socket(int sockfd) +{ + union { + struct cmsghdr align; + char buf[CMSG_SPACE(sizeof(int))]; + } u; + + char data; + struct iovec iov = {.iov_base = &data, .iov_len = sizeof(data)}; + struct msghdr msg = { + .msg_iov = &iov, + .msg_iovlen = 1, + .msg_control = u.buf, + .msg_controllen = sizeof(u.buf), + }; + + if (recvmsg(sockfd, &msg, 0) < 0) + return -1; + + int recv_fd = -1; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; + cmsg = CMSG_NXTHDR(&msg, cmsg)) { + ck_assert_int_eq(cmsg->cmsg_level, SOL_SOCKET); + + if (cmsg->cmsg_type != SCM_RIGHTS) + continue; + + int nfds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int); + ck_assert_int_eq(nfds, 1); + recv_fd = *(int *)CMSG_DATA(cmsg); + } + return recv_fd; +} + +static void *test_client_thread(void *arg) +{ + struct client_state *cstate = arg; + struct test_config *config = cstate->config; + + struct sockaddr_un address = { + .sun_family = AF_UNIX, + }; + + ck_assert_int_eq( + sockaddr_set_lease_server_path(&address, config->lease->name), + true); + + int client = socket(PF_UNIX, SOCK_STREAM, 0); + ck_assert_int_ge(client, 0); + + int ret; + ret = connect(client, (struct sockaddr *)&address, sizeof(address)); + if (ret != 0) { + printf("Connect failed;: %s\n", strerror(errno)); + close(client); + return NULL; + } + + if (!config->recv_timeout) + config->recv_timeout = DEFAULT_RECV_TIMEOUT; + + client_gst_socket_status(client, config); + + if (config->has_data) { + config->received_fd = receive_fd_from_socket(client); + } + + cstate->socket_fd = client; + + return NULL; +} + +struct client_state *test_client_start(struct test_config *test_config) +{ + struct client_state *cstate = malloc(sizeof(*cstate)); + + *cstate = (struct client_state){ + .config = test_config, + }; + + pthread_create(&cstate->tid, NULL, test_client_thread, cstate); + + return cstate; +} + +void test_client_stop(struct client_state *cstate) +{ + + ck_assert_ptr_ne(cstate, NULL); + + pthread_join(cstate->tid, NULL); + + if (cstate->socket_fd >= 0) + close(cstate->socket_fd); + + free(cstate); +} + +void test_config_cleanup(struct test_config *config) +{ + if (config->has_data && config->received_fd >= 0) + close(config->received_fd); +} diff --git a/drm-lease-manager/test/test-socket-client.h b/drm-lease-manager/test/test-socket-client.h new file mode 100644 index 0000000..b5bdf6d --- /dev/null +++ b/drm-lease-manager/test/test-socket-client.h @@ -0,0 +1,37 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 TEST_SOCKET_CLIENT_H +#define TEST_SOCKET_CLIENT_H +#include + +#include "drm-lease.h" +struct test_config { + // settings + struct lease_handle *lease; + int recv_timeout; + + // outputs + int received_fd; + bool has_data; + bool connection_completed; +}; + +void test_config_cleanup(struct test_config *config); + +struct client_state; +struct client_state *test_client_start(struct test_config *test_config); +void test_client_stop(struct client_state *cstate); +#endif diff --git a/examples/dlm-client-test/dlm-client-test.c b/examples/dlm-client-test/dlm-client-test.c new file mode 100644 index 0000000..411fce7 --- /dev/null +++ b/examples/dlm-client-test/dlm-client-test.c @@ -0,0 +1,94 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "dlmclient.h" + +#include +#include +#include +#include +#include + +#include + +static void usage(const char *name) +{ + fprintf(stderr, + "%s \n" + "\tlease name: Name of lease to check\n", + name); +} + +static void dump_lease_resources(int lease_fd) +{ + drmModeObjectListPtr ol = drmModeGetLease(lease_fd); + if (!ol) { + fprintf( + stderr, + "drmModeGetLease failed. Received fd is not a DRM lease\n"); + return; + } + free(ol); + + drmModeRes *res = drmModeGetResources(lease_fd); + if (!res) { + fprintf(stderr, "drmModeGetResources failed\n"); + return; + } + + for (int i = 0; i < res->count_crtcs; i++) + printf("crtc-id: %u\n", res->crtcs[i]); + + for (int i = 0; i < res->count_connectors; i++) + printf("connector-id: %u\n", res->connectors[i]); + + drmModeFreeResources(res); + + drmModePlaneRes *plane_res = drmModeGetPlaneResources(lease_fd); + if (!plane_res) { + fprintf(stderr, "drmModeGetPlaneResources failed\n"); + return; + } + + for (uint32_t i = 0; i < plane_res->count_planes; i++) + printf("plane-id: %u\n", plane_res->planes[i]); + + drmModeFreePlaneResources(plane_res); +} + +int main(int argc, char **argv) +{ + if (argc < 2) { + usage(argv[0]); + return EXIT_FAILURE; + } + + struct dlm_lease *lease = dlm_get_lease(argv[1]); + if (!lease) { + fprintf(stderr, "dlm_get_lease: %s\n", strerror(errno)); + return EXIT_FAILURE; + } + + int lease_fd = dlm_lease_fd(lease); + if (lease_fd < 0) { + fprintf(stderr, "dlm_lease_fd: %s\n", strerror(errno)); + dlm_release_lease(lease); + return EXIT_FAILURE; + } + + dump_lease_resources(lease_fd); + dlm_release_lease(lease); + return EXIT_SUCCESS; +} diff --git a/examples/dlm-client-test/meson.build b/examples/dlm-client-test/meson.build new file mode 100644 index 0000000..aa51c78 --- /dev/null +++ b/examples/dlm-client-test/meson.build @@ -0,0 +1,4 @@ +executable('dlm-client-test', + ['dlm-client-test.c'], + dependencies : [dlmclient_dep, drm_dep], +) diff --git a/examples/meson.build b/examples/meson.build new file mode 100644 index 0000000..706c2b8 --- /dev/null +++ b/examples/meson.build @@ -0,0 +1 @@ +subdir('dlm-client-test') diff --git a/libdlmclient/dlmclient.c b/libdlmclient/dlmclient.c new file mode 100644 index 0000000..32493d3 --- /dev/null +++ b/libdlmclient/dlmclient.c @@ -0,0 +1,170 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "dlmclient.h" +#include "log.h" +#include "socket-path.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void dlm_enable_debug_log(bool enable) +{ + dlm_log_enable_debug(enable); +} + +struct dlm_lease { + int dlm_server_sock; + int lease_fd; +}; + +static bool lease_connect(struct dlm_lease *lease, const char *name) +{ + struct sockaddr_un sa = { + .sun_family = AF_UNIX, + }; + + if (!sockaddr_set_lease_server_path(&sa, name)) + return false; + + int dlm_server_sock = socket(AF_UNIX, SOCK_STREAM, 0); + if (dlm_server_sock < 0) { + DEBUG_LOG("Socket creation failed: %s\n", strerror(errno)); + return false; + } + + while (connect(dlm_server_sock, (struct sockaddr *)&sa, + sizeof(struct sockaddr_un)) == -1) { + if (errno == EINTR) + continue; + DEBUG_LOG("Cannot connect to %s: %s\n", sa.sun_path, + strerror(errno)); + close(dlm_server_sock); + return false; + } + lease->dlm_server_sock = dlm_server_sock; + return true; +} + +static bool lease_recv_fd(struct dlm_lease *lease) +{ + char ctrl_buf[CMSG_SPACE(sizeof(int))] = {0}; + char data[1] = {0}; + + struct iovec iov[1]; + iov[0].iov_base = data; + iov[0].iov_len = sizeof(data); + + struct msghdr msg = { + .msg_control = ctrl_buf, + .msg_controllen = CMSG_SPACE(sizeof(int)), + .msg_iov = iov, + .msg_iovlen = 1, + }; + + int ret; + while ((ret = recvmsg(lease->dlm_server_sock, &msg, 0)) <= 0) { + if (ret == 0) { + errno = EACCES; + DEBUG_LOG("Request rejected by DRM lease manager\n"); + // TODO: Report why the request was rejected. + return false; + } + if (errno != EINTR) { + DEBUG_LOG("Socket data receive error: %s\n", + strerror(errno)); + return false; + } + } + + lease->lease_fd = -1; + struct cmsghdr *cmsg; + for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; + cmsg = CMSG_NXTHDR(&msg, cmsg)) { + if (cmsg->cmsg_level == SOL_SOCKET && + cmsg->cmsg_type == SCM_RIGHTS) { + int nfds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int); + int *fds = (int *)CMSG_DATA(cmsg); + + if (nfds == 1) { + lease->lease_fd = fds[0]; + break; + } + + DEBUG_LOG( + "Expected 1 fd from lease manager. Received %d\n", + nfds); + /* Close any unexpected fds so we don't leak them. */ + for (int i = 0; i < nfds; i++) + close(fds[i]); + break; + } + } + + if (lease->lease_fd < 0) { + DEBUG_LOG("Expected data not received from lease manager\n"); + errno = EPROTO; + return false; + } + + return true; +} + +struct dlm_lease *dlm_get_lease(const char *name) +{ + struct dlm_lease *lease = calloc(1, sizeof(struct dlm_lease)); + if (!lease) { + DEBUG_LOG("can't allocate memory : %s\n", strerror(errno)); + return NULL; + } + + if (!lease_connect(lease, name)) { + free(lease); + return NULL; + } + + if (!lease_recv_fd(lease)) { + close(lease->dlm_server_sock); + free(lease); + return NULL; + } + + return lease; +} + +void dlm_release_lease(struct dlm_lease *lease) +{ + if (!lease) + return; + + close(lease->lease_fd); + close(lease->dlm_server_sock); + free(lease); +} + +int dlm_lease_fd(struct dlm_lease *lease) +{ + if (!lease) + return -1; + + return lease->lease_fd; +} diff --git a/libdlmclient/dlmclient.h b/libdlmclient/dlmclient.h new file mode 100644 index 0000000..908cd6b --- /dev/null +++ b/libdlmclient/dlmclient.h @@ -0,0 +1,86 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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. + */ + +/** + * @file dlmclient.h + */ +#ifndef DLM_CLIENT_H +#define DLM_CLIENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/** + * @brief Enable debug logging + * + * @param[in] enable enable/disable debug logging + */ +void dlm_enable_debug_log(bool enable); + +/** + * @brief lease handle + */ +struct dlm_lease; + +/** + * @brief Get a DRM lease from the lease manager + * + * @param[in] name requested lease + * @return A pointer to a lease handle on success. + * On error this function returns NULL and errno is set accordingly. + * + * Possible errors: + * + * errno | Meaning + * -------------|------------------------------------------------------------- + * EACCESS | Cannot access lease manager socket directory + * EACCESS | Lease request denied by lease manager + * ENAMETOOLONG | The path to the lease manager socket directory is too long + * ENOENT | Lease manager or requested lease not available + * ENOMEM | Out of memory during operation + * EPROTO | Protocol error in communication with lease manager + * + * This list is not exhaustive, and errno may be set to other error codes, + * especially those related to socket communication. + */ +struct dlm_lease *dlm_get_lease(const char *name); + +/** + * @brief Release a lease handle + * + * @details Release a lease handle. The lease handle will be invalidated and + * the associated DRM lease wil be revoked. Any fd's retrieved from + * dlm_lease_fd() will be closed. + * @param[in] lease pointer to lease handle + */ +void dlm_release_lease(struct dlm_lease *lease); + +/** + * @brief Get a DRM Master fd from a valid lease handle + * + * @param[in] lease pointer to a lease handle + * @return A DRM Master file descriptor for the lease on success. + * -1 is returned when called with a NULL lease handle. + */ +int dlm_lease_fd(struct dlm_lease *lease); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libdlmclient/docs/Doxyfile.in b/libdlmclient/docs/Doxyfile.in new file mode 100644 index 0000000..dce4244 --- /dev/null +++ b/libdlmclient/docs/Doxyfile.in @@ -0,0 +1,9 @@ +# General information +PROJECT_NAME = "DRM Lease Manager Client Library" +OUTPUT_DIRECTORY = @DOXYGEN_OUTPUT@ +INPUT = @README@ @CLIENT_HEADER_DIR@ +USE_MDFILE_AS_MAINPAGE = @README@ +FILE_PATTERNS = *.h +GENERATE_LATEX = NO +OPTIMIZE_OUTPUT_FOR_C = YES +STRIP_FROM_PATH = @CLIENT_HEADER_DIR@ diff --git a/libdlmclient/docs/meson.build b/libdlmclient/docs/meson.build new file mode 100644 index 0000000..563e5fb --- /dev/null +++ b/libdlmclient/docs/meson.build @@ -0,0 +1,21 @@ +doxygen = find_program('doxygen', required : false) + +readme = join_paths(meson.source_root(), 'README.md') + +if get_option('enable-docs') and doxygen.found() + conf_data = configuration_data() + conf_data.set('README', readme) + conf_data.set('CLIENT_HEADER_DIR', dlmclient_header_dir) + conf_data.set('DOXYGEN_OUTPUT', meson.current_build_dir()) + doxyfile = configure_file( + input: 'Doxyfile.in', + output: 'Doxyfile', + configuration: conf_data + ) + custom_target('docs', + input: [doxyfile, readme, dlmclient_headers], + build_by_default: true, + command: [doxygen, '@INPUT0@'], + output: ['html'] + ) +endif diff --git a/libdlmclient/meson.build b/libdlmclient/meson.build new file mode 100644 index 0000000..d63a842 --- /dev/null +++ b/libdlmclient/meson.build @@ -0,0 +1,38 @@ +dlmclient_sources = files( + 'dlmclient.c' +) + +dlmclient_headers = files( + 'dlmclient.h' +) + +libdlmclient = library( + 'dlmclient', + sources: dlmclient_sources, + version: meson.project_version(), + dependencies: [dlmcommon_dep], + install: true, +) + +dlmclient_dep = declare_dependency( + link_with: libdlmclient, + include_directories: include_directories('.') +) + + +install_headers(dlmclient_headers, subdir: 'libdlmclient') + +pkg.generate( + name: 'libdlmclient', + libraries: libdlmclient, + subdirs: [ 'libdlmclient' ], + version: meson.project_version(), + description: 'DRM lease manager client library', +) + +dlmclient_header_dir = meson.current_source_dir() +subdir('docs') + +if enable_tests + subdir('test') +endif diff --git a/libdlmclient/test/libdlmclient-test.c b/libdlmclient/test/libdlmclient-test.c new file mode 100644 index 0000000..5b04c09 --- /dev/null +++ b/libdlmclient/test/libdlmclient-test.c @@ -0,0 +1,291 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 + +#include +#include +#include +#include +#include + +#include "config.h" +#include "dlmclient.h" +#include "test-helpers.h" +#include "test-socket-server.h" + +#define SOCKETDIR "/tmp" + +#define TEST_LEASE_NAME "test-lease" + +/************** Test fixutre functions *************/ +struct test_config default_test_config; + +static void test_setup(void) +{ + dlm_enable_debug_log(true); + setenv("DLM_RUNTIME_PATH", SOCKETDIR, 1); + + default_test_config = (struct test_config){ + .lease_name = TEST_LEASE_NAME, + .nfds = 1, + }; +} + +static void test_shutdown(void) +{ + test_config_cleanup(&default_test_config); +} + +/************** Lease manager error tests *************/ + +/* These tests verify that the client library gracefully handles + * failures when trying to receive data from the lease manager. + * Failures or errors in the lease manager should cause meaningful + * errors to be reported by the client. Lease manager errors should + * not cause crashes or invalid state in the client */ + +/* manager_connection_err + * + * Test details: Simulate socket connection failure. + * Expected results: dlm_get_lease() fails. + */ +START_TEST(manager_connection_err) +{ + struct server_state *sstate = test_server_start(&default_test_config); + + struct dlm_lease *lease = dlm_get_lease(TEST_LEASE_NAME "-bad"); + + ck_assert_ptr_eq(lease, NULL); + + test_server_stop(sstate); +} +END_TEST + +/* no_data_from_manager + * + * Test details: Close the remote (lease manager) without sending any data. + * Currently this means that the lease request has been rejected + * for some reason. + * + * TODO: Update this when the client-server protocol is updated to + * include the reason for the lease rejection. + * + * Expected results: dlm_get_lease() fails, errno set to EACCESS. + */ +START_TEST(no_data_from_manager) +{ + + struct test_config config = { + .lease_name = TEST_LEASE_NAME, + .send_no_data = true, + }; + + struct server_state *sstate = test_server_start(&config); + + struct dlm_lease *lease = dlm_get_lease(TEST_LEASE_NAME); + + ck_assert_ptr_eq(lease, NULL); + ck_assert_int_eq(errno, EACCES); + + test_server_stop(sstate); +} +END_TEST + +/* no_lease_fd_from_manager + * + * Test details: Simulate receiving response from lease manager with + * no fd attached. (i.e. a protocol error) + * + * Expected results: dlm_get_lease() fails, errno set to EPROTO. + */ +START_TEST(no_lease_fd_from_manager) +{ + /* Receive message from the lease manager with missing lease fd */ + struct test_config config = { + .lease_name = TEST_LEASE_NAME, + .send_data_without_fd = true, + }; + + struct server_state *sstate = test_server_start(&config); + + struct dlm_lease *lease = dlm_get_lease(TEST_LEASE_NAME); + + ck_assert_ptr_eq(lease, NULL); + ck_assert_int_eq(errno, EPROTO); + + test_server_stop(sstate); +} +END_TEST + +static void add_lease_manager_error_tests(Suite *s) +{ + TCase *tc = tcase_create("Lease manager error handling"); + + tcase_add_checked_fixture(tc, test_setup, test_shutdown); + + tcase_add_test(tc, manager_connection_err); + tcase_add_test(tc, no_data_from_manager); + tcase_add_test(tc, no_lease_fd_from_manager); + + suite_add_tcase(s, tc); +} + +/************** Lease handling tests *****************/ + +/* These tests verify that the client library handles the received + * lease data properly. Receiving the lease fds without leaks, + * properly passing the fds to the client application and cleaning + * them up on release. + */ + +static int count_open_fds(void) +{ + int fds = 0; + DIR *dirp = opendir("/proc/self/fd"); + while ((readdir(dirp) != NULL)) + fds++; + closedir(dirp); + return fds; +} + +/* receive_fd_from_manager + * + * Test details: Successfully receive a file descriptor. + * Expected results: dlm_get_lease() succeeds. + * dlm_lease_fd() returns the correct fd value. + */ +START_TEST(receive_fd_from_manager) +{ + struct server_state *sstate = test_server_start(&default_test_config); + + struct dlm_lease *lease = dlm_get_lease(TEST_LEASE_NAME); + ck_assert_ptr_ne(lease, NULL); + + int received_fd = dlm_lease_fd(lease); + + int sent_fd = default_test_config.fds[0]; + + check_fd_equality(received_fd, sent_fd); + + dlm_release_lease(lease); + + test_server_stop(sstate); + close(sent_fd); +} +END_TEST + +/* lease_fd_is_closed_on_release + * + * Test details: Verify that dlm_release_lease() closes the lease fd. + * Expected results: lease fd is closed. + */ +START_TEST(lease_fd_is_closed_on_release) +{ + struct server_state *sstate = test_server_start(&default_test_config); + + struct dlm_lease *lease = dlm_get_lease(TEST_LEASE_NAME); + ck_assert_ptr_ne(lease, NULL); + + int received_fd = dlm_lease_fd(lease); + + check_fd_is_open(received_fd); + dlm_release_lease(lease); + check_fd_is_closed(received_fd); + + test_server_stop(sstate); +} +END_TEST + +/* dlm_lease_fd_always_returns_same_lease + * + * Test details: Verify that dlm_lease_fd() always returns the same value + * for a given lease. + * Expected results: same value is returned when called multiple times. + */ +START_TEST(dlm_lease_fd_always_returns_same_lease) +{ + struct server_state *sstate = test_server_start(&default_test_config); + + struct dlm_lease *lease = dlm_get_lease(TEST_LEASE_NAME); + ck_assert_ptr_ne(lease, NULL); + + int received_fd = dlm_lease_fd(lease); + + ck_assert_int_eq(received_fd, dlm_lease_fd(lease)); + ck_assert_int_eq(received_fd, dlm_lease_fd(lease)); + + dlm_release_lease(lease); + + test_server_stop(sstate); +} +END_TEST + +START_TEST(verify_that_unused_fds_are_not_leaked) +{ + int nopen_fds = count_open_fds(); + + struct test_config config = { + .lease_name = TEST_LEASE_NAME, + .nfds = 2, + }; + + struct server_state *sstate = test_server_start(&config); + + struct dlm_lease *lease = dlm_get_lease(TEST_LEASE_NAME); + + ck_assert_ptr_eq(lease, NULL); + ck_assert_int_eq(errno, EPROTO); + + dlm_release_lease(lease); + + test_server_stop(sstate); + + test_config_cleanup(&config); + ck_assert_int_eq(nopen_fds, count_open_fds()); +} +END_TEST + +static void add_lease_handling_tests(Suite *s) +{ + TCase *tc = tcase_create("Lease processing tests"); + + tcase_add_checked_fixture(tc, test_setup, test_shutdown); + + tcase_add_test(tc, receive_fd_from_manager); + tcase_add_test(tc, lease_fd_is_closed_on_release); + tcase_add_test(tc, dlm_lease_fd_always_returns_same_lease); + tcase_add_test(tc, verify_that_unused_fds_are_not_leaked); + suite_add_tcase(s, tc); +} + +int main(void) +{ + int number_failed; + Suite *s; + SRunner *sr; + + s = suite_create("DLM client library tests"); + + add_lease_manager_error_tests(s); + add_lease_handling_tests(s); + + sr = srunner_create(s); + + srunner_run_all(sr, CK_NORMAL); + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/libdlmclient/test/meson.build b/libdlmclient/test/meson.build new file mode 100644 index 0000000..35e8575 --- /dev/null +++ b/libdlmclient/test/meson.build @@ -0,0 +1,6 @@ +cl_test = executable('libdlmclient-test', + sources: [ 'libdlmclient-test.c', 'test-socket-server.c'], + dependencies: [check_dep, fff_dep, dlmcommon_dep, dlmclient_dep, thread_dep], + include_directories: configuration_inc) + +test('Client library test', cl_test, is_parallel: false) diff --git a/libdlmclient/test/test-socket-server.c b/libdlmclient/test/test-socket-server.c new file mode 100644 index 0000000..281aaf7 --- /dev/null +++ b/libdlmclient/test/test-socket-server.c @@ -0,0 +1,169 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 "test-socket-server.h" +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "socket-path.h" +#include "test-helpers.h" + +static void send_fd_list_over_socket(int socket, int nfds, int *fds) +{ + char data; + struct iovec iov = { + .iov_base = &data, + .iov_len = 1, + }; + + int bufsize = CMSG_SPACE(nfds * sizeof(int)); + char *buf = malloc(bufsize); + + struct msghdr msg = { + .msg_iov = &iov, + .msg_iovlen = 1, + .msg_controllen = bufsize, + .msg_control = buf, + }; + + struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(nfds * sizeof(int)); + memcpy(CMSG_DATA(cmsg), fds, sizeof(int) * nfds); + + ck_assert_int_gt(sendmsg(socket, &msg, 0), 0); + free(buf); +} + +struct server_state { + pthread_t tid; + pthread_mutex_t lock; + pthread_cond_t cond; + bool is_server_started; + + struct test_config *config; +}; + +static void *test_server_thread(void *arg) +{ + struct server_state *sstate = arg; + struct test_config *config = sstate->config; + + struct sockaddr_un address = { + .sun_family = AF_UNIX, + }; + + ck_assert_int_eq( + sockaddr_set_lease_server_path(&address, config->lease_name), true); + + int server = socket(PF_UNIX, SOCK_STREAM, 0); + ck_assert_int_ge(server, 0); + + unlink(address.sun_path); + + int ret; + ret = bind(server, (struct sockaddr *)&address, sizeof(address)); + ck_assert_int_eq(ret, 0); + + ret = listen(server, 1); + ck_assert_int_eq(ret, 0); + + sstate->is_server_started = true; + pthread_cond_signal(&sstate->cond); + + int client = accept(server, NULL, NULL); + /* accept is the cancellation point for this thread. If + * pthread_cancel() is called on this thread, accept() may return + * -1, so don't assert on it. */ + + if (client < 0) { + close(server); + return NULL; + } + + if (config->send_no_data) + goto done; + + if (config->send_data_without_fd) { + char data; + write(client, &data, 1); + goto done; + } + + if (config->nfds == 0) + config->nfds = 1; + + config->fds = calloc(config->nfds, sizeof(int)); + + for (int i = 0; i < config->nfds; i++) + config->fds[i] = get_dummy_fd(); + + send_fd_list_over_socket(client, config->nfds, config->fds); +done: + close(client); + close(server); + return NULL; +} + +struct server_state *test_server_start(struct test_config *test_config) +{ + struct server_state *sstate = malloc(sizeof(*sstate)); + + *sstate = (struct server_state){ + .lock = PTHREAD_MUTEX_INITIALIZER, + .cond = PTHREAD_COND_INITIALIZER, + .is_server_started = false, + .config = test_config, + }; + + pthread_create(&sstate->tid, NULL, test_server_thread, sstate); + + pthread_mutex_lock(&sstate->lock); + while (!sstate->is_server_started) + pthread_cond_wait(&sstate->cond, &sstate->lock); + pthread_mutex_unlock(&sstate->lock); + return sstate; +} + +void test_server_stop(struct server_state *sstate) +{ + + ck_assert_ptr_ne(sstate, NULL); + + pthread_cancel(sstate->tid); + pthread_join(sstate->tid, NULL); + + free(sstate); +} + +void test_config_cleanup(struct test_config *config) +{ + if (!config->fds) + return; + + for (int i = 0; i < config->nfds; i++) + close(config->fds[i]); + + free(config->fds); +} diff --git a/libdlmclient/test/test-socket-server.h b/libdlmclient/test/test-socket-server.h new file mode 100644 index 0000000..ebdbd2d --- /dev/null +++ b/libdlmclient/test/test-socket-server.h @@ -0,0 +1,33 @@ +/* Copyright 2020-2021 IGEL Co., Ltd. + * + * 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 TEST_SOCKET_SERVER_H +#define TEST_SOCKET_SERVER_H +#include + +struct test_config { + char *lease_name; + int nfds; + int *fds; + + bool send_data_without_fd; + bool send_no_data; +}; + +void test_config_cleanup(struct test_config *config); + +struct server_state *test_server_start(struct test_config *test_config); +void test_server_stop(struct server_state *sstate); +#endif diff --git a/meson.build b/meson.build new file mode 100644 index 0000000..2f6cd15 --- /dev/null +++ b/meson.build @@ -0,0 +1,61 @@ +project( + 'lease_manager', 'c', + # Version based on Semantic Versioning 2.0.0 (https://semver.org/) + version: '0.1.0', + default_options: [ + 'warning_level=2', + ] +) + +config = configuration_data() + +pkg = import('pkgconfig') + +compiler_flags = [ + '-Wstrict-prototypes', + '-Wmissing-prototypes', +] + +#Setup and create runtime path +runtime_path = join_paths(get_option('localstatedir'), get_option('runtime_subdir')) +config.set_quoted('DLM_DEFAULT_RUNTIME_PATH', runtime_path) + +meson.add_install_script('sh', '-c', 'install -d $DESTDIR/$1', '_', runtime_path) + +cc = meson.get_compiler('c') +add_project_arguments( + cc.get_supported_arguments(compiler_flags), + language: 'c' +) + +configure_file(output: 'config.h', + configuration: config) + +configuration_inc = include_directories('.') + +drm_dep = dependency('libdrm', version: '>= 2.4.89') + +enable_tests = get_option('enable-tests') + +if enable_tests + check_dep = dependency('check') + thread_dep = dependency('threads') + +# Default to the system provided version of fff.h. +# otherwise fetch it ourselves. + if cc.check_header('fff.h') + fff_dep = declare_dependency() + else + if meson.version().version_compare('>=0.55') + fff_proj = subproject('fff') + fff_dep = fff_proj.get_variable('fff_dep') + else + error('Update meson version to >=0.55 to enable unit testing') + endif + endif +endif + +subdir('common') +subdir('libdlmclient') +subdir('drm-lease-manager') +subdir('examples') diff --git a/meson_options.txt b/meson_options.txt new file mode 100644 index 0000000..ee1f8dc --- /dev/null +++ b/meson_options.txt @@ -0,0 +1,17 @@ +option('enable-docs', + type: 'boolean', + value: true, + description: 'Build Doxygen document if available.' +) + +option('enable-tests', + type: 'boolean', + value: false, + description: 'Build unit tests' +) + +option('runtime_subdir', + type: 'string', + value: 'run/drm-lease-manager', + description: 'subdirectory to use for runtime data' +) diff --git a/subprojects/fff.wrap b/subprojects/fff.wrap new file mode 100644 index 0000000..047a44f --- /dev/null +++ b/subprojects/fff.wrap @@ -0,0 +1,8 @@ +[wrap-file] +directory = fff-1.0 + +source_url = https://github.com/meekrosoft/fff/archive/v1.0.tar.gz +source_filename = v1.0.tar.gz +source_hash = 3fbe25ac451d3f56b5b0f82b9a4dbf68e4412b3cee278f7b2feda47fc4d692c6 + +patch_directory = fff-1.0 diff --git a/subprojects/packagefiles/fff-1.0/meson.build b/subprojects/packagefiles/fff-1.0/meson.build new file mode 100644 index 0000000..c7ce1f2 --- /dev/null +++ b/subprojects/packagefiles/fff-1.0/meson.build @@ -0,0 +1,8 @@ +project('fff', 'c', + version: '1.0', + license: 'MIT' +) + +fff_dep = declare_dependency( + include_directories: include_directories('.') +) -- 2.16.6