Initial commit.

This has the basic event loop, and a first cut of the libffi dispatcher.
Kristian Høgsberg 16 years ago
commit 97f1ebe8d5
  1. 17
      Makefile
  2. 53
      NOTES
  3. 109
      client.c
  4. 107
      event-loop.c
  5. 45
      hash.c
  6. 0
      socket.c
  7. 423
      wayland.c
  8. 67
      wayland.h

@ -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

53
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.

@ -0,0 +1,109 @@
#include <stdlib.h>
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <ctype.h>
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 <id>/<interface>:<method>\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;
}

@ -0,0 +1,107 @@
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/epoll.h>
#include <unistd.h>
#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;
}

@ -0,0 +1,45 @@
#include <stdlib.h>
#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 */
}

@ -0,0 +1,423 @@
#include <stdlib.h>
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <ffi.h>
#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;
}

@ -0,0 +1,67 @@
#ifndef WAYLAND_H
#define WAYLAND_H
#include <stdint.h>
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
Loading…
Cancel
Save