1

当我尝试在线教程中的 Wayland 代码时，它运行良好，并且 *pixel++ = 0xffff;在下面的代码行中显示分段错误，

static void
paint_pixels_A(void *temp_data) {
    int n;
    uint32_t *pixel = temp_data;

    fprintf(stderr, "Painting pixels\n");
    for (n =0; n < WIDTH*HEIGHT; n++) {
        *pixel++ = 0xffff;
    }
}

我对此代码所做的更改，

static struct wl_buffer *
create_buffer() {
    struct wl_shm_pool *pool;
    int stride = WIDTH * 4; // 4 bytes per pixel
    int size = stride * HEIGHT;
    int fd;
    struct wl_buffer *buff;

    fd = os_create_anonymous_file(size);
    if (fd < 0) {
    fprintf(stderr, "creating a buffer file for %d B failed: %m\n",
        size);
    exit(1);
    }

    shm_data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shm_data == MAP_FAILED) {
    close(fd);
    exit(1);
    }

    pool = wl_shm_create_pool(shm, fd, size);
    buff = wl_shm_pool_create_buffer(pool, 0,
                      WIDTH, HEIGHT,
                      stride,   
                      WL_SHM_FORMAT_XRGB8888);

    wl_shm_pool_destroy(pool);
    return buff;
}

我将上面的代码行修改为

static struct wl_buffer *
create_buffer(void *temp_data) {  // modification 1
    struct wl_shm_pool *pool;
    int stride = WIDTH * 4; 
    int size = stride * HEIGHT;
    int fd;
    struct wl_buffer *buff;

    fd = os_create_anonymous_file(size);
    if (fd < 0) {
    fprintf(stderr, "creating a buffer file for %d B failed: %m\n",
        size);
    exit(1);
    }

    temp_data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); //modification 2
    if (temp_data == MAP_FAILED) {
    close(fd);
    exit(1);
    }

    pool = wl_shm_create_pool(shm, fd, size);
    buff = wl_shm_pool_create_buffer(pool, 0,
                      WIDTH, HEIGHT,
                      stride,   
                      WL_SHM_FORMAT_XRGB8888)
    wl_shm_pool_destroy(pool);
    return buff;
}

以及相应的函数调用，您可以在此链接中看到正确的代码 这是我的完整代码，请检查并提供反馈

struct wl_display *display = NULL;
struct wl_compositor *compositor = NULL;
struct wl_surface *surface;
struct wl_shell *shell;
struct wl_shell_surface *shell_surface;
struct wl_shm *shm;
struct wl_buffer *buffer;

void *shm_data;

int WIDTH = 480;
int HEIGHT = 360;

static void
handle_ping(void *data, struct wl_shell_surface *shell_surface,
                            uint32_t serial)
{
    wl_shell_surface_pong(shell_surface, serial);
}

static void
handle_configure(void *data, struct wl_shell_surface *shell_surface,
         uint32_t edges, int32_t width, int32_t height)
{
}

static void
handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
{
}

static const struct wl_shell_surface_listener shell_surface_listener = {
    handle_ping,
    handle_configure,
    handle_popup_done
};

static int
set_cloexec_or_close(int fd)
{
        long flags;

        if (fd == -1)
                return -1;

        flags = fcntl(fd, F_GETFD);

        if (flags == -1)
                goto err;

        if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1)
                goto err;

        return fd;

err:
        close(fd);
        return -1;
}

static int
create_tmpfile_cloexec(char *tmpname)
{
        int fd;

#ifdef HAVE_MKOSTEMP
        fd = mkostemp(tmpname, O_CLOEXEC);
        if (fd >= 0)
                unlink(tmpname);
#else
        fd = mkstemp(tmpname);
        if (fd >= 0) {
                fd = set_cloexec_or_close(fd);
                unlink(tmpname);
        }
#endif

        return fd;
}

int
os_create_anonymous_file(off_t size)
{
        static const char template[] = "/weston-shared-XXXXXX";
        const char *path;
        char *name;
        int fd;

        path = getenv("XDG_RUNTIME_DIR");
        if (!path) {
                errno = ENOENT;
                return -1;
        }

        name = malloc(strlen(path) + sizeof(template));
        if (!name)
                return -1;
        strcpy(name, path);
        strcat(name, template);

        fd = create_tmpfile_cloexec(name);

        free(name);

        if (fd < 0)
                return -1;

        if (ftruncate(fd, size) < 0) {
                close(fd);
                return -1;
        }

        return fd;
}

static void
paint_pixels_A(void *temp_data) {
    int n;
    uint32_t *pixel = temp_data;

    fprintf(stderr, "Painting pixels\n");
    for (n =0; n < WIDTH*HEIGHT; n++) {
        *pixel++ = 0xffff;
    }
}


static struct wl_buffer *
create_buffer(void *temp_data) {
    struct wl_shm_pool *pool;
    int stride = WIDTH * 4; // 4 bytes per pixel
    int size = stride * HEIGHT;
    int fd;
    struct wl_buffer *buff;

    fd = os_create_anonymous_file(size);
    if (fd < 0) {
    exit(1);
    }

    temp_data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (temp_data == MAP_FAILED) {
    fprintf(stderr, "mmap failed: %m\n");
    close(fd);
    exit(1);
    }

    pool = wl_shm_create_pool(shm, fd, size);
    buff = wl_shm_pool_create_buffer(pool, 0,
                      WIDTH, HEIGHT,
                      stride,   
                      WL_SHM_FORMAT_XRGB8888);
    wl_shm_pool_destroy(pool);
    return buff;
}

static void
create_window() {
    buffer = create_buffer((void *)shm_data);

    wl_surface_attach(surface, buffer, 0, 0);
    wl_surface_commit(surface);
}


static void
shm_format(void *data, struct wl_shm *wl_shm, uint32_t format)
{
    fprintf(stderr, "Format %d\n", format);
}

struct wl_shm_listener shm_listener = {
    shm_format
};

static void
global_registry_handler(void *data, struct wl_registry *registry, uint32_t id,
           const char *interface, uint32_t version)
{
    if (strcmp(interface, "wl_compositor") == 0) {
        compositor = wl_registry_bind(registry, 
                      id, 
                      &wl_compositor_interface, 
                      1);
    } else if (strcmp(interface, "wl_shell") == 0) {
        shell = wl_registry_bind(registry, id,
                                 &wl_shell_interface, 1);
    } else if (strcmp(interface, "wl_shm") == 0) {
        shm = wl_registry_bind(registry, id,
                                 &wl_shm_interface, 1);
    wl_shm_add_listener(shm, &shm_listener, NULL);

    }
}

static void
global_registry_remover(void *data, struct wl_registry *registry, uint32_t id)
{
    printf("Got a registry losing event for %d\n", id);
}

static const struct wl_registry_listener registry_listener = {
    global_registry_handler,
    global_registry_remover
};


int main(int argc, char **argv) {


    int checker; 

    display = wl_display_connect(NULL);
    if (display == NULL) {
    exit(1);
    }

    struct wl_registry *registry = wl_display_get_registry(display);
    wl_registry_add_listener(registry, &registry_listener, NULL);

    wl_display_dispatch(display);
    wl_display_roundtrip(display);

    if (compositor == NULL) {
    exit(1);
    }

    surface = wl_compositor_create_surface(compositor);
    if (surface == NULL) {
    exit(1);
    }

    shell_surface = wl_shell_get_shell_surface(shell, surface);
    if (shell_surface == NULL) {
    exit(1);
    } 
    wl_shell_surface_set_toplevel(shell_surface);

    wl_shell_surface_add_listener(shell_surface,
                  &shell_surface_listener, NULL);


    create_window();
    paint_pixels_A((void *)shm_data);

    while (wl_display_dispatch(display) != -1) {
    ;
    }

    wl_display_disconnect(display);

    exit(0);
}
4

1 回答 1

-1

你永远不会分配shm_data.

这个：

buffer = create_buffer((void *)shm_data);

不改变。_ shm_data此外，您几乎不需要void *在 C 中强制转换，所以不要这样做。

那条线应该是：

shm_data = create_buffer();

当然create_buffer()应该更改为不采用虚拟参数，只需返回指向mmap()ed 区域的指针。

于 2014-11-05T10:46:58.817 回答