From 97f1ebe8d5c2e166fabf757182c289fed266a45a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristian=20H=C3=B8gsberg?= Date: Tue, 30 Sep 2008 09:46:10 -0400 Subject: [PATCH] Initial commit. This has the basic event loop, and a first cut of the libffi dispatcher. --- Makefile | 17 +++ NOTES | 53 +++++++ client.c | 109 +++++++++++++ event-loop.c | 107 +++++++++++++ hash.c | 45 ++++++ socket.c | 0 wayland.c | 423 +++++++++++++++++++++++++++++++++++++++++++++++++++ wayland.h | 67 ++++++++ 8 files changed, 821 insertions(+) create mode 100644 Makefile create mode 100644 NOTES create mode 100644 client.c create mode 100644 event-loop.c create mode 100644 hash.c create mode 100644 socket.c create mode 100644 wayland.c create mode 100644 wayland.h diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..661cd6f0 --- /dev/null +++ b/Makefile @@ -0,0 +1,17 @@ +CFLAGS = -Wall -g $(shell pkg-config --cflags libffi) +LDLIBS = $(shell pkg-config --libs libffi) + +all : wayland client + +wayland_objs = wayland.o event-loop.o hash.o + +wayland : $(wayland_objs) + gcc -o $@ $(wayland_objs) $(LDLIBS) + +client_objs = client.o + +client : $(client_objs) + gcc -o $@ $(client_objs) + +clean : + rm client wayland *.o \ No newline at end of file diff --git a/NOTES b/NOTES new file mode 100644 index 00000000..f4534c24 --- /dev/null +++ b/NOTES @@ -0,0 +1,53 @@ + +KEYWORDS: + +Wayland is a nano display server, relying on drm modesetting, gem +batchbuffer submission and hw initialization generally in the +kernel. Wayland is compositing manager and display server in one +process. window management is largely pushed to the clients, they +draw their own decorations and move and resize themselves, +typically implemented in a library. more of the core desktop could +be pushed into wayland, for example, stock desktop components such +as the panel or the desktop background. + +It is still designed with a windowed type of desktop in mind, as +opposed to fullscreen-all-the-time type of interface. + +Current trends goes towards less and less rendering in X server, +more hardware setup and management in kernel and shared libraries +allow code sharing without putting it all in a server. + +Client allocates DRM buffers, draws decorations, and full window +contents and posts entire thing to server along with dimensions. + +Everything is direct rendered and composited. No cliprects, no +drawing api/protocl between server and client. No +pixmaps/windows/drawables, only surfaces (essentially pixmaps). No +gcs/fonts, no nested windows. OpenGL is already direct rendered, +pixman may be direct rendered which adds the cairo API, or cairo +may gain a GL backend. + +ISSUES: + +Include panel and desktop background in wayland? + +How does clients move their surfaces? set a full tri-mesh every time? + +How does the server apply transformations to a surface behind the +clients back? (wobbly, minimize, zoom) Maybe wobble is client side? + +How do apps share the glyph cache? + +Input handling - keyboard focus, multiple input devices, multiple +pointers, multi touch. + +Drawing cursors, moving them, cursor themes, attaching surfaces to +cursors. How do you change cursors when you mouse over a text +field if you don't have subwindows? + +synaptics, 3-button emulation, xkb, scim + +RMI + +the get_interface method is called on an object to get an object +handle that implements the specified interface. \ No newline at end of file diff --git a/client.c b/client.c new file mode 100644 index 00000000..8312be87 --- /dev/null +++ b/client.c @@ -0,0 +1,109 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static const char socket_name[] = "\0wayland"; + +struct method { + const char *name; + uint32_t opcode; +}; + +static const struct method display_methods[] = { + { "get_interface", 0 }, + { "create_surface", 1 }, + { NULL } +}; + +static const struct method surface_methods[] = { + { "get_interface", 0 }, + { "post", 1 }, + { NULL } +}; + +struct interface { + const char *name; + const struct method *methods; +}; + +static const struct interface interfaces[] = { + { "display", display_methods }, + { "surface", surface_methods }, + { NULL }, +}; + +int send_request(int sock, const char *buffer, int buffer_len) +{ + const struct method *methods; + char interface[32], method[32]; + uint32_t request[3], id, new_id; + int i; + + if (sscanf(buffer, "%d/%32[^:]:%32s %d\n", + &id, interface, method, &new_id) != 4) { + printf("invalid input, expected /:\n"); + return -1; + } + + printf("got object id %d, interface \"%s\", name \"%s\"\n", + id, interface, method); + + for (i = 0; interfaces[i].name != NULL; i++) { + if (strcmp(interfaces[i].name, interface) == 0) + break; + } + if (interfaces[i].name == NULL) { + printf("unknown interface \"%s\"\n", interface); + return -1; + } + + methods = interfaces[i].methods; + for (i = 0; methods[i].name != NULL; i++) { + if (strcmp(methods[i].name, method) == 0) + break; + } + + if (methods[i].name == NULL) { + printf("unknown request \"%s\"\n", method); + return -1; + } + + request[0] = id; + request[1] = methods[i].opcode; + request[2] = new_id; + + return write(sock, request, sizeof request); +} + +int main(int argc, char *argv[]) +{ + struct sockaddr_un name; + socklen_t size; + int sock, len; + char buffer[256]; + + sock = socket(PF_LOCAL, SOCK_STREAM, 0); + if (sock < 0) + return -1; + + name.sun_family = AF_LOCAL; + memcpy(name.sun_path, socket_name, sizeof socket_name); + + size = offsetof (struct sockaddr_un, sun_path) + sizeof socket_name; + + if (connect (sock, (struct sockaddr *) &name, size) < 0) + return -1; + + while (len = read(STDIN_FILENO, buffer, sizeof buffer), len > 0) + if (send_request(sock, buffer, len) < 0) + break; + + return 0; +} diff --git a/event-loop.c b/event-loop.c new file mode 100644 index 00000000..2946a648 --- /dev/null +++ b/event-loop.c @@ -0,0 +1,107 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "wayland.h" + +struct wl_event_loop { + int epoll_fd; +}; + +struct wl_event_source { + int fd; + wl_event_loop_func_t func; + void *data; +}; + +struct wl_event_source * +wl_event_loop_add_fd(struct wl_event_loop *loop, + int fd, uint32_t mask, + wl_event_loop_func_t func, + void *data) +{ + struct wl_event_source *source; + struct epoll_event ep; + + source = malloc(sizeof *source); + source->fd = fd; + source->func = func; + source->data = data; + + ep.events = 0; + if (mask & WL_EVENT_READABLE) + ep.events |= EPOLLIN; + if (mask & WL_EVENT_WRITEABLE) + ep.events |= EPOLLOUT; + ep.data.ptr = source; + + if (epoll_ctl(loop->epoll_fd, EPOLL_CTL_ADD, fd, &ep) < 0) { + free(source); + return NULL; + } + + return source; +} + +int +wl_event_loop_remove_source(struct wl_event_loop *loop, + struct wl_event_source *source) +{ + int fd; + + fd = source->fd; + free(source); + + return epoll_ctl(loop->epoll_fd, EPOLL_CTL_DEL, fd, NULL); +} + +struct wl_event_loop * +wl_event_loop_create(void) +{ + struct wl_event_loop *loop; + + loop = malloc(sizeof *loop); + if (loop == NULL) + return NULL; + + loop->epoll_fd = epoll_create(16); + if (loop->epoll_fd < 0) { + free(loop); + return NULL; + } + + return loop; +} + +void +wl_event_loop_destroy(struct wl_event_loop *loop) +{ + close(loop->epoll_fd); + free(loop); +} + +#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0]) + +int +wl_event_loop_wait(struct wl_event_loop *loop) +{ + struct epoll_event ep[32]; + struct wl_event_source *source; + int i, count; + + count = epoll_wait(loop->epoll_fd, ep, ARRAY_LENGTH(ep), -1); + if (count < 0) + return -1; + + for (i = 0; i < count; i++) { + source = ep[i].data.ptr; + source->func(source->fd, ep[i].events, source->data); + } + + return 0; +} diff --git a/hash.c b/hash.c new file mode 100644 index 00000000..80a14572 --- /dev/null +++ b/hash.c @@ -0,0 +1,45 @@ +#include +#include "wayland.h" + +int wl_hash_insert(struct wl_hash *hash, struct wl_object *object) +{ + struct wl_object **objects; + uint32_t alloc; + + if (hash->count == hash->alloc) { + if (hash->alloc == 0) + alloc = 16; + else + alloc = hash->alloc * 2; + objects = realloc(hash->objects, alloc * sizeof *objects); + if (objects == NULL) + return -1; + + hash->objects = objects; + hash->alloc = alloc; + } + + hash->objects[hash->count] = object; + hash->count++; + + return 0; +} + +struct wl_object * +wl_hash_lookup(struct wl_hash *hash, uint32_t id) +{ + int i; + + for (i = 0; i < hash->count; i++) { + if (hash->objects[i]->id == id) + return hash->objects[i]; + } + + return NULL; +} + +void +wl_hash_delete(struct wl_hash *hash, struct wl_object *object) +{ + /* writeme */ +} diff --git a/socket.c b/socket.c new file mode 100644 index 00000000..e69de29b diff --git a/wayland.c b/wayland.c new file mode 100644 index 00000000..496f866b --- /dev/null +++ b/wayland.c @@ -0,0 +1,423 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "wayland.h" + +#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0]) + +struct wl_region { +}; + +struct wl_client { + char protocol_buffer[4096]; + struct wl_event_source *source; + struct wl_display *display; +}; + +struct wl_display { + struct wl_object base; + struct wl_event_loop *loop; + struct wl_hash objects; +}; + +struct wl_surface { + struct wl_object base; + + /* provided by client */ + int width, height; + int buffer; + int stride; + + /* these are used by the wayland server, not set from client */ + void (*screen_to_surface)(int sx, int sy, int *wx, int *wy); + void (*surface_to_screen)(int sx, int sy, int *wx, int *wy); + + /* how to convert buffer contents to pixels in screen format; + * yuv->rgb, indexed->rgb, svg->rgb, but mostly just rgb->rgb. */ + + /* how to transform/render rectangular contents to polygons. */ +}; + +static void +wl_surface_get_interface(struct wl_client *client, + struct wl_surface *surface, + const char *interface, uint32_t id) +{ + /* client sends a new object id, and an interface identifier + * to name the object that implements the interface */ + printf("surface::get_interface\n"); +} + +static const struct wl_argument get_interface_arguments[] = { + { WL_ARGUMENT_STRING }, + { WL_ARGUMENT_NEW_ID } +}; + +static void +wl_surface_post(struct wl_client *client, + struct wl_surface *surface, uint32_t name, + uint32_t width, uint32_t height, uint32_t stride) +{ + printf("surface::post\n"); +} + +static const struct wl_argument post_arguments[] = { + { WL_ARGUMENT_UINT32 }, + { WL_ARGUMENT_UINT32 }, + { WL_ARGUMENT_UINT32 }, + { WL_ARGUMENT_UINT32 }, +}; + +void +wl_surface_update(struct wl_surface *surface, + uint32_t source_name, struct wl_region *region) +{ + /* FIXME: how to demarshal region? */ + /* copy region from buffer into current window contents. */ +} + +static const struct wl_argument update_arguments[] = { + { WL_ARGUMENT_UINT32 }, + { WL_ARGUMENT_UINT32 }, +}; + +static const struct wl_method surface_methods[] = { + { "get_interface", wl_surface_get_interface, + ARRAY_LENGTH(get_interface_arguments), get_interface_arguments }, + { "post", wl_surface_post, + ARRAY_LENGTH(post_arguments), post_arguments } +}; + +static const struct wl_interface surface_interface = { + "surface", 1, + ARRAY_LENGTH(surface_methods), + surface_methods, +}; + +struct wl_surface * +wl_surface_create(struct wl_display *display, uint32_t id) +{ + struct wl_surface *surface; + + surface = malloc(sizeof *surface); + if (surface == NULL) + return NULL; + + surface->base.id = id; + surface->base.interface = &surface_interface; + /* doesn't create any pixel buffers, just the wl_surface + * object. the client allocates and attaches pixel buffers + * itself and renders to them, then posts them using + * wl_window_post. */ + + /* add to display list */ + + return surface; +} + +static void +wl_client_data(int fd, uint32_t mask, void *data); + +struct wl_client * +wl_client_create(struct wl_display *display, int fd) +{ + struct wl_client *client; + + client = malloc(sizeof *client); + if (client == NULL) + return NULL; + + client->display = display; + + client->source = wl_event_loop_add_fd(display->loop, fd, + WL_EVENT_READABLE | + WL_EVENT_READABLE, + wl_client_data, client); + + printf("new client: %p\n", client); + + /* Send global objects to client in hand shake response, eg: + * + * display: 0, + * glyph_cache: 1 + * some other extension global object: 2 + * + * etc */ + + return client; +} + +void +wl_client_destroy(struct wl_client *client) +{ + printf("disconnect from client %p\n", client); + wl_event_loop_remove_source(client->display->loop, client->source); + free(client); +} + +static void +demarshal(struct wl_client *client, struct wl_object *target, + const struct wl_method *method, uint32_t *data, int len) +{ + ffi_type *types[10]; + ffi_cif cif; + uint32_t *p, result; + int i; + union { + uint32_t uint32; + const char *string; + void *object; + uint32_t new_id; + } values[10]; + void *args[10]; + struct wl_object *object; + + if (method->argument_count > ARRAY_LENGTH(types)) { + printf("too many args (%d)\n", method->argument_count); + return; + } + + types[0] = &ffi_type_pointer; + values[0].object = client; + args[0] = &values[0]; + + types[1] = &ffi_type_pointer; + values[1].object = target; + args[1] = &values[1]; + + p = data; + for (i = 0; i < method->argument_count; i++) { + switch (method->arguments[i].type) { + case WL_ARGUMENT_UINT32: + types[i + 2] = &ffi_type_uint32; + values[i + 2].uint32 = *p; + printf("got uint32 (%d)\n", *p); + p++; + break; + case WL_ARGUMENT_STRING: + printf("got string\n"); + types[i + 2] = &ffi_type_pointer; + /* FIXME */ + values[i + 2].uint32 = *p++; + break; + case WL_ARGUMENT_OBJECT: + types[i + 2] = &ffi_type_pointer; + object = wl_hash_lookup(&client->display->objects, *p); + if (object == NULL) + printf("unknown object (%d)\n", *p); + if (object->interface != method->arguments[i].data) + printf("wrong object type\n"); + values[i + 2].object = object; + printf("got object (%d)\n", *p); + p++; + break; + case WL_ARGUMENT_NEW_ID: + types[i + 2] = &ffi_type_uint32; + values[i + 2].new_id = *p; + object = wl_hash_lookup(&client->display->objects, *p); + if (object != NULL) + printf("object already exists (%d)\n", *p); + printf("got new_id (%d)\n", *p); + p++; + break; + default: + printf("unknown type\n"); + break; + } + args[i + 2] = &values[i + 2]; + } + + ffi_prep_cif(&cif, FFI_DEFAULT_ABI, method->argument_count + 2, + &ffi_type_uint32, types); + ffi_call(&cif, FFI_FN(method->func), &result, args); +} + +static void +wl_client_data(int fd, uint32_t mask, void *data) +{ + struct wl_client *client = data; + struct wl_object *object; + const struct wl_method *method; + char buffer[256]; + uint32_t *p; + int len; + + if (mask & WL_EVENT_READABLE) { + len = read(fd, buffer, sizeof buffer); + if (len == 0) { + wl_client_destroy(client); + } else { + printf("got %d bytes from client %p\n", + len, client); + if (len < 2 * sizeof *p) + /* read more... */ + return; + + p = (uint32_t *) buffer; + object = wl_hash_lookup(&client->display->objects, + p[0]); + if (object == NULL) { + /* send error */ + printf("invalid object\n"); + return; + } + + if (p[1] >= object->interface->method_count) { + /* send error */ + printf("invalid method\n"); + return; + } + + method = &object->interface->methods[p[1]]; + printf("calling method %s on interface %s\n", + method->name, object->interface->name); + demarshal(client, object, method, p + 2, len - 8); + } + } + + if (mask & WL_EVENT_WRITEABLE) { + } +} + +static void +wl_display_get_interface(struct wl_client *client, + struct wl_display *display, + const char *interface, uint32_t id) +{ + /* client sends a new object id, and an interface identifier + * to name the object that implements the interface */ + printf("display::get_interface\n"); +} + +static int +wl_display_create_surface(struct wl_client *client, + struct wl_display *display, uint32_t id) +{ + struct wl_surface *surface; + + printf("display::create_surface, client %p, display %p, new_id=%d\n", + client, display, id); + + surface = wl_surface_create(display, id); + wl_hash_insert(&display->objects, &surface->base); + + return 0; +} + +static const struct wl_argument create_surface_arguments[] = { + { WL_ARGUMENT_NEW_ID } +}; + +static const struct wl_method display_methods[] = { + { "get_interface", wl_display_get_interface, + ARRAY_LENGTH(get_interface_arguments), get_interface_arguments }, + { "create_surface", wl_display_create_surface, + ARRAY_LENGTH(create_surface_arguments), create_surface_arguments }, +}; + +static const struct wl_interface display_interface = { + "display", 1, ARRAY_LENGTH(display_methods), display_methods, +}; + +struct wl_display * +wl_display_create(void) +{ + struct wl_display *display; + + display = malloc(sizeof *display); + if (display == NULL) + return NULL; + + display->loop = wl_event_loop_create(); + if (display->loop == NULL) { + free(display); + return NULL; + } + + display->base.id = 0; + display->base.interface = &display_interface; + wl_hash_insert(&display->objects, &display->base); + + return display; +} + +void +wl_display_run(struct wl_display *display) +{ + while (1) + wl_event_loop_wait(display->loop); +} + +/* The plan here is to generate a random anonymous socket name and + * advertise that through a service on the session dbus. + */ +static const char socket_name[] = "\0wayland"; + +static void +socket_data(int fd, uint32_t mask, void *data) +{ + struct wl_display *display = data; + struct sockaddr_un name; + socklen_t length; + int client_fd; + + length = sizeof name; + client_fd = accept (fd, (struct sockaddr *) &name, &length); + if (client_fd < 0) + fprintf(stderr, "failed to accept\n"); + + wl_client_create(display, client_fd); +} + +int +wl_display_add_socket(struct wl_display *display) +{ + struct sockaddr_un name; + int sock; + socklen_t size; + + sock = socket(PF_LOCAL, SOCK_STREAM, 0); + if (sock < 0) + return -1; + + name.sun_family = AF_LOCAL; + memcpy(name.sun_path, socket_name, sizeof socket_name); + + size = offsetof (struct sockaddr_un, sun_path) + sizeof socket_name; + if (bind(sock, (struct sockaddr *) &name, size) < 0) + return -1; + + if (listen(sock, 1) < 0) + return -1; + + wl_event_loop_add_fd(display->loop, sock, WL_EVENT_READABLE, + socket_data, display); + + return 0; +} + + +int main(int argc, char *argv[]) +{ + struct wl_display *display; + + display = wl_display_create(); + + if (wl_display_add_socket(display)) { + fprintf(stderr, "failed to add socket: %m\n"); + exit(EXIT_FAILURE); + } + + printf("wayland online, display is %p\n", display); + + wl_display_run(display); + + return 0; +} diff --git a/wayland.h b/wayland.h new file mode 100644 index 00000000..409e3a3e --- /dev/null +++ b/wayland.h @@ -0,0 +1,67 @@ +#ifndef WAYLAND_H +#define WAYLAND_H + +#include + +enum { + WL_EVENT_READABLE = 0x01, + WL_EVENT_WRITEABLE = 0x02 +}; + +struct wl_event_loop; +struct wl_event_source; +typedef void (*wl_event_loop_func_t)(int fd, uint32_t mask, void *data); + +struct wl_event_loop *wl_event_loop_create(void); +void wl_event_loop_destroy(struct wl_event_loop *loop); +struct wl_event_source *wl_event_loop_add_fd(struct wl_event_loop *loop, + int fd, uint32_t mask, + wl_event_loop_func_t func, + void *data); +int wl_event_loop_remove_source(struct wl_event_loop *loop, + struct wl_event_source *source); +int wl_event_loop_wait(struct wl_event_loop *loop); + +struct wl_hash { + struct wl_object **objects; + uint32_t count, alloc, id; +}; + +int wl_hash_insert(struct wl_hash *hash, struct wl_object *object); +struct wl_object *wl_hash_lookup(struct wl_hash *hash, uint32_t id); +void wl_hash_delete(struct wl_hash *hash, struct wl_object *object); + +struct wl_client; + +enum { + WL_ARGUMENT_UINT32, + WL_ARGUMENT_STRING, + WL_ARGUMENT_OBJECT, + WL_ARGUMENT_NEW_ID +}; + +struct wl_argument { + uint32_t type; + void *data; +}; + +struct wl_method { + const char *name; + void *func; + int argument_count; + const struct wl_argument *arguments; +}; + +struct wl_interface { + const char *name; + int version; + int method_count; + const struct wl_method *methods; +}; + +struct wl_object { + const struct wl_interface *interface; + uint32_t id; +}; + +#endif