commit 34c27852534bdef19bddb8792c3629d01d8b6e5c Author: itycodes Date: Tue May 27 07:12:23 2025 +0200 Initial commit diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..adebef2 --- /dev/null +++ b/Makefile @@ -0,0 +1,36 @@ +.PHONY: all clean + +CC = gcc +CLIBS = -lwayland-client +CFLAGS = $(CLIBS) -g -fsanitize=address +DESTDIR = /usr/local/bin/ + +SRC = main.c +OUT = printlease + + +PROTOCOL_NAMES = $(foreach proto, $(wildcard protocols/*), $(notdir $(basename $(proto)))) +PROTOCOL_IMPLS = $(foreach proto, $(PROTOCOL_NAMES), $(addsuffix .prot.c,$(proto))) +PROTOCOL_HEADERS = $(foreach proto, $(PROTOCOL_NAMES), $(addsuffix .prot.h,$(proto))) +PROTOCOLS = $(PROTOCOL_IMPLS) $(PROTOCOL_HEADERS) + +%.prot.c: protocols/%.xml + wayland-scanner private-code $< $@ + +%.prot.h: protocols/%.xml + wayland-scanner client-header $< $@ + +all: $(OUT) + +clean: + rm -f $(OUT) + rm -f $(PROTOCOLS) + +$(OUT): $(PROTOCOLS) $(SRC) + $(CC) $(PROTOCOL_IMPLS) $(SRC) $(CFLAGS) -o $(OUT) + +run: $(OUT) + ./$(OUT) + +install: $(OUT) + mv $(OUT) $(DESTDIR) diff --git a/README.md b/README.md new file mode 100644 index 0000000..c12d5e9 --- /dev/null +++ b/README.md @@ -0,0 +1,11 @@ +Testing utility for drm-lease -> https://wayland.app/protocols/drm-lease-v1 + +Runtime Dependencies: + +- `libwayland-client` + +Make Dependencies: + +- `wayland-scanner` +- `make` +- `gcc` diff --git a/main.c b/main.c new file mode 100644 index 0000000..c141adc --- /dev/null +++ b/main.c @@ -0,0 +1,91 @@ +#include +#include +#include +#include + +#include + +#include + +#include "drm-lease-v1.prot.h" + +#define ASSERT(cond, msg)\ + if(!(cond)) {\ + fprintf(stderr, "Runtime assertion %s at %s:%d failed: %s\n", #cond, __FILE__, __LINE__, msg);\ + exit(-1);\ + } + +struct wp_drm_lease_device_v1** devs; +size_t devs_size = 0; + +uint8_t done = 0; + +void device_drm_fd(void *data, + struct wp_drm_lease_device_v1 *wp_drm_lease_device_v1, + int32_t fd){} + +void device_connector(void *data, + struct wp_drm_lease_device_v1 *wp_drm_lease_device_v1, + struct wp_drm_lease_connector_v1 *id) { + printf("Connector Found\n"); +} + +void device_done(void *data, + struct wp_drm_lease_device_v1 *wp_drm_lease_device_v1){ + printf("All connectors sent.\n"); + done = 1; +} + +void device_released(void *data, + struct wp_drm_lease_device_v1 *wp_drm_lease_device_v1){} + +const struct wp_drm_lease_device_v1_listener device_callbacks = { + .drm_fd = device_drm_fd, + .connector = device_connector, + .done = device_done, + .released = device_released, +}; + +void handle_global( + void* data, + struct wl_registry* registry, + uint32_t name, + const char* interface, + uint32_t version) { + if(strcmp(interface, wp_drm_lease_device_v1_interface.name) == 0) { + struct wp_drm_lease_device_v1* dev = wl_registry_bind(registry, name, &wp_drm_lease_device_v1_interface, version); + devs_size += 1; + devs = realloc(devs, devs_size*sizeof(void*)); + devs[devs_size-1] = dev; + wp_drm_lease_device_v1_add_listener(dev, &device_callbacks, NULL); + printf("Bound %d\n", devs_size); + } +} + +void handle_global_remove( + void* data, + struct wl_registry* registry, + uint32_t name) { + // Who cares +} + +const struct wl_registry_listener reg_callbacks = { + .global = handle_global, + .global_remove = handle_global_remove, +}; + +int main(int argc, char* argv[]) { + devs = malloc(sizeof(void*)); + + struct wl_display* dpy = wl_display_connect(NULL); + ASSERT(dpy != NULL, "Unable to connect to Wayland"); + + struct wl_registry* registry = wl_display_get_registry(dpy); + wl_registry_add_listener(registry, ®_callbacks, NULL); + wl_display_roundtrip(dpy); + + printf("Waiting for connectors.\n"); + while(!done) {} + + return 0; +} diff --git a/protocols/drm-lease-v1.xml b/protocols/drm-lease-v1.xml new file mode 100644 index 0000000..1fca538 --- /dev/null +++ b/protocols/drm-lease-v1.xml @@ -0,0 +1,317 @@ + + + + Copyright © 2018 NXP + Copyright © 2019 Status Research & Development GmbH. + Copyright © 2021 Xaver Hugl + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + + + + + This protocol is used by Wayland compositors which act as Direct + Rendering Manager (DRM) masters to lease DRM resources to Wayland + clients. + + The compositor will advertise one wp_drm_lease_device_v1 global for each + DRM node. Some time after a client binds to the wp_drm_lease_device_v1 + global, the compositor will send a drm_fd event followed by zero, one or + more connector events. After all currently available connectors have been + sent, the compositor will send a wp_drm_lease_device_v1.done event. + + When the list of connectors available for lease changes the compositor + will send wp_drm_lease_device_v1.connector events for added connectors and + wp_drm_lease_connector_v1.withdrawn events for removed connectors, + followed by a wp_drm_lease_device_v1.done event. + + The compositor will indicate when a device is gone by removing the global + via a wl_registry.global_remove event. Upon receiving this event, the + client should destroy any matching wp_drm_lease_device_v1 object. + + To destroy a wp_drm_lease_device_v1 object, the client must first issue + a release request. Upon receiving this request, the compositor will + immediately send a released event and destroy the object. The client must + continue to process and discard drm_fd and connector events until it + receives the released event. Upon receiving the released event, the + client can safely cleanup any client-side resources. + + Warning! The protocol described in this file is currently in the testing + phase. Backward compatible changes may be added together with the + corresponding interface version bump. Backward incompatible changes can + only be done by creating a new major version of the extension. + + + + + Creates a lease request object. + + See the documentation for wp_drm_lease_request_v1 for details. + + + + + + + Indicates the client no longer wishes to use this object. In response + the compositor will immediately send the released event and destroy + this object. It can however not guarantee that the client won't receive + connector events before the released event. The client must not send any + requests after this one, doing so will raise a wl_display error. + Existing connectors, lease request and leases will not be affected. + + + + + + The compositor will send this event when the wp_drm_lease_device_v1 + global is bound, although there are no guarantees as to how long this + takes - the compositor might need to wait until regaining DRM master. + The included fd is a non-master DRM file descriptor opened for this + device and the compositor must not authenticate it. + The purpose of this event is to give the client the ability to + query DRM and discover information which may help them pick the + appropriate DRM device or select the appropriate connectors therein. + + + + + + + The compositor will use this event to advertise connectors available for + lease by clients. This object may be passed into a lease request to + indicate the client would like to lease that connector, see + wp_drm_lease_request_v1.request_connector for details. While the + compositor will make a best effort to not send disconnected connectors, + no guarantees can be made. + + The compositor must send the drm_fd event before sending connectors. + After the drm_fd event it will send all available connectors but may + send additional connectors at any time. + + + + + + + The compositor will send this event to indicate that it has sent all + currently available connectors after the client binds to the global or + when it updates the connector list, for example on hotplug, drm master + change or when a leased connector becomes available again. It will + similarly send this event to group wp_drm_lease_connector_v1.withdrawn + events of connectors of this device. + + + + + + This event is sent in response to the release request and indicates + that the compositor is done sending connector events. + The compositor will destroy this object immediately after sending the + event and it will become invalid. The client should release any + resources associated with this device after receiving this event. + + + + + + + Represents a DRM connector which is available for lease. These objects are + created via wp_drm_lease_device_v1.connector events, and should be passed + to lease requests via wp_drm_lease_request_v1.request_connector. + Immediately after the wp_drm_lease_connector_v1 object is created the + compositor will send a name, a description, a connector_id and a done + event. When the description is updated the compositor will send a + description event followed by a done event. + + + + + The compositor sends this event once the connector is created to + indicate the name of this connector. This will not change for the + duration of the Wayland session, but is not guaranteed to be consistent + between sessions. + + If the compositor supports wl_output version 4 and this connector + corresponds to a wl_output, the compositor should use the same name as + for the wl_output. + + + + + + + The compositor sends this event once the connector is created to provide + a human-readable description for this connector, which may be presented + to the user. The compositor may send this event multiple times over the + lifetime of this object to reflect changes in the description. + + + + + + + The compositor sends this event once the connector is created to + indicate the DRM object ID which represents the underlying connector + that is being offered. Note that the final lease may include additional + object IDs, such as CRTCs and planes. + + + + + + + This event is sent after all properties of a connector have been sent. + This allows changes to the properties to be seen as atomic even if they + happen via multiple events. + + + + + + Sent to indicate that the compositor will no longer honor requests for + DRM leases which include this connector. The client may still issue a + lease request including this connector, but the compositor will send + wp_drm_lease_v1.finished without issuing a lease fd. Compositors are + encouraged to send this event when they lose access to connector, for + example when the connector is hot-unplugged, when the connector gets + leased to a client or when the compositor loses DRM master. + + If a client holds a lease for the connector, the status of the lease + remains the same. The client should destroy the object after receiving + this event. + + + + + + The client may send this request to indicate that it will not use this + connector. Clients are encouraged to send this after receiving the + "withdrawn" event so that the server can release the resources + associated with this connector offer. Neither existing lease requests + nor leases will be affected. + + + + + + + A client that wishes to lease DRM resources will attach the list of + connectors advertised with wp_drm_lease_device_v1.connector that they + wish to lease, then use wp_drm_lease_request_v1.submit to submit the + request. + + + + + + + + + + + Indicates that the client would like to lease the given connector. + This is only used as a suggestion, the compositor may choose to + include any resources in the lease it issues, or change the set of + leased resources at any time. Compositors are however encouraged to + include the requested connector and other resources necessary + to drive the connected output in the lease. + + Requesting a connector that was created from a different lease device + than this lease request raises the wrong_device error. Requesting a + connector twice will raise the duplicate_connector error. + + + + + + + Submits the lease request and creates a new wp_drm_lease_v1 object. + After calling submit the compositor will immediately destroy this + object, issuing any more requests will cause a wl_display error. + The compositor doesn't make any guarantees about the events of the + lease object, clients cannot expect an immediate response. + Not requesting any connectors before submitting the lease request + will raise the empty_lease error. + + + + + + + + A DRM lease object is used to transfer the DRM file descriptor to the + client and manage the lifetime of the lease. + + Some time after the wp_drm_lease_v1 object is created, the compositor + will reply with the lease request's result. If the lease request is + granted, the compositor will send a lease_fd event. If the lease request + is denied, the compositor will send a finished event without a lease_fd + event. + + + + + This event returns a file descriptor suitable for use with DRM-related + ioctls. The client should use drmModeGetLease to enumerate the DRM + objects which have been leased to them. The compositor guarantees it + will not use the leased DRM objects itself until it sends the finished + event. If the compositor cannot or will not grant a lease for the + requested connectors, it will not send this event, instead sending the + finished event. + + The compositor will send this event at most once during this objects + lifetime. + + + + + + + The compositor uses this event to either reject a lease request, or if + it previously sent a lease_fd, to notify the client that the lease has + been revoked. If the client requires a new lease, they should destroy + this object and submit a new lease request. The compositor will send + no further events for this object after sending the finish event. + Compositors should revoke the lease when any of the leased resources + become unavailable, namely when a hot-unplug occurs or when the + compositor loses DRM master. Compositors may advertise the connector + for leasing again, if the resource is available, by sending the + connector event through the wp_drm_lease_device_v1 interface. + + + + + + The client should send this to indicate that it no longer wishes to use + this lease. The compositor should use drmModeRevokeLease on the + appropriate file descriptor, if necessary. + + Upon destruction, the compositor should advertise the connector for + leasing again by sending the connector event through the + wp_drm_lease_device_v1 interface. + + + +