Re: [PATCH] ring-buffer: Fix polling on trace_pipe

[Martin Lau]

Hi Steve,

I retried the test program (with the kernel patch).  It does block from
time to time.  I spotted the ee.events is not set to EPOLLIN before
calling epll_ctl(eft, EPOLL_CTL_ADD,...).  I fixed it and ran
the test in a bash-loop.

I have the kafai-2 version attached (with some more logging in case
if it still blocks).

Can you retry?

Thanks,
Martin

On Thu, Jun 26, 2014 at 08:53:27PM -0400, Steven Rostedt wrote:
> On Thu, 26 Jun 2014 11:34:46 -0700
> Martin Lau <ka...@fb.com> wrote:
> 
> > Hi Steve,
> > 
> > Can the modified test program reproduce the problem in your test setup?
> 
> Ah sorry, got distracted by other work.
> 
> OK, I just tried it out, and here's my results:
> 
> I ran you code with my current kernel and this is what I got:
> 
> # ./ftrace-test-epoll-kafai 
>            <...>-3183  [002] ...1    81.777891: tracing_mark_write:
> some data 3183: waitting for more data......
> 3184: written more data
> 
> And it just hung there.
> 
> 
> Then I applied your patch, compiled and booted it, and ran the test
> again, and I got this:
> 
> # ./ftrace-test-epoll-kafai
> 
> It just hung there. No forward progress.
> 
> I don't think that was the result you intended.
> 
> -- Steve
> 
> 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>

static const char * debugfs_list[] = {
        "/debug/tracing",
        "/sys/kernel/debug/tracing",
        "/d/tracing",
        NULL,
};

static const char *debugfs;
static int markfd;
static int trace_pipe_fd;

static void alog(const char *name, int ret)
{
        printf("%d: %s: %d\n", getpid(), name, ret);
}

static const char *find_debugfs(void)
{
        struct stat st;
        int i;
        int r;

        for (i = 0; debugfs_list[i]; i++) {
                r = stat(debugfs_list[i], &st);
                if (r < 0)
                        continue;
                if (S_ISDIR(st.st_mode))
                        return debugfs_list[i];
        }
        return NULL;
}

static char * make_path(const char *file)
{
        char *path;
        int size;

        size = strlen(debugfs) + strlen(file) + 2;
        path = malloc(size);
        if (!path) {
                perror("malloc");
                exit(-1);
        }
        sprintf(path, "%s/%s", debugfs, file);
        return path;
}

static void mark_write(const char *str)
{
        int ret;
        ret = write(markfd, str, strlen(str));
        alog("write(markfd)", ret);
}

static void read_trace_pipe(void)
{
        char buf[1024];
        int r;

        while ((r = read(trace_pipe_fd, buf, 1024)) > 0)
                printf("%.*s", r, buf);
}

int main (int argc, char **argv)
{
        struct epoll_event ee;
        char *marker;
        char *pipe;
        int efd;
        int ret;
        pid_t dwrt_pid;

        debugfs = find_debugfs();
        if (!debugfs) {
                fprintf(stderr, "Could not find debugfs\n");
                exit(-1);
        }

        marker = make_path("trace_marker");
        pipe = make_path("trace_pipe");

        markfd = open(marker, O_WRONLY);
        if (markfd < 0) {
                perror("marker");
                exit(-1);
        }
        trace_pipe_fd = open(pipe, O_RDONLY|O_NONBLOCK);
        if (trace_pipe_fd < 0) {
                perror("trace_pipe");
                exit(-1);
        }

        efd = epoll_create(1);
        if (efd < 0) {
                perror("epoll_create");
                exit(-1);
        }

        mark_write("some data");
        memset(&ee, 0, sizeof(ee));
        ee.events = EPOLLIN;
        ret = epoll_ctl(efd, EPOLL_CTL_ADD, trace_pipe_fd, &ee);
        if (ret < 0) {
                perror("epoll_ctl");
                exit(-1);
        }
        alog("waiting data......", 0);
        ret = epoll_wait(efd, &ee, 1, -1);
        alog("epoll_wait()", ret);
        read_trace_pipe();
        dwrt_pid = fork();
        assert(dwrt_pid != -1);
        if (dwrt_pid == 0) {
                sleep(10);
                mark_write("more data");
        } else {
                alog("waiting form more data......", 0);
                ret = epoll_wait(efd, &ee, 1, -1);
                alog("epoll_wait()", ret);
                read_trace_pipe();
                wait(NULL);
        }
        return 0;
}