From 6bca92db4ddd2d3d25671aa83e74dd11aca652a8 Mon Sep 17 00:00:00 2001 From: Nicholas Marriott Date: Sat, 10 Oct 2009 15:03:01 +0000 Subject: Rather than running status-left, status-right and window title #() with popen immediately every redraw, queue them up and run them in the background, starting each once every status-interval. The actual status line uses the output from the last run. This brings several advantages: - tmux itself may be called from inside #() without causing the server to hang; - likewise, sleep or similar doesn't cause the server to block; - commands aren't run excessively often when redrawing; - commands shared by status-left and status-right, or used multiple times, will only be run once. run-shell and if-shell still use system()/popen() but will be changed over to use this too later. --- job.c | 187 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 187 insertions(+) create mode 100644 job.c (limited to 'job.c') diff --git a/job.c b/job.c new file mode 100644 index 00000000..91646eda --- /dev/null +++ b/job.c @@ -0,0 +1,187 @@ +/* $OpenBSD$ */ + +/* + * Copyright (c) 2009 Nicholas Marriott + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include +#include +#include +#include + +#include "tmux.h" + +/* + * Job scheduling. Run queued commands in the background and record their + * output. + */ + +RB_GENERATE(jobs, job, entry, job_cmp); + +int +job_cmp(struct job *job1, struct job *job2) +{ + return (strcmp(job1->cmd, job2->cmd)); +} + +/* Initialise job tree. */ +void +job_tree_init(struct jobs *jobs) +{ + RB_INIT(jobs); +} + +/* Count the number of jobs in a tree. */ +u_int +job_tree_size(struct jobs *jobs) +{ + struct job *job; + u_int n; + + n = 0; + RB_FOREACH(job, jobs, jobs) + n++; + return (n); +} + +/* Destroy a job tree. */ +void +job_tree_free(struct jobs *jobs) +{ + struct job *job; + + while (!RB_EMPTY(jobs)) { + job = RB_ROOT(jobs); + RB_REMOVE(jobs, jobs, job); + job_free(job); + } +} + +/* Find a job and return it. */ +struct job * +job_get(struct jobs *jobs, const char *cmd) +{ + struct job job; + + job.cmd = (char *) cmd; + return (RB_FIND(jobs, jobs, &job)); +} + +/* Add a job. */ +struct job * +job_add(struct jobs *jobs, struct client *c, const char *cmd, + void (*callbackfn)(struct job *), void (*freefn)(void *), void *data) +{ + struct job *job; + + job = xmalloc(sizeof *job); + job->cmd = xstrdup(cmd); + + job->client = c; + + job->fd = -1; + job->out = buffer_create(BUFSIZ); + + job->callbackfn = callbackfn; + job->freefn = freefn; + job->data = data; + + RB_INSERT(jobs, jobs, job); + + return (job); +} + +/* Kill and free an individual job. */ +void +job_free(struct job *job) +{ + job_kill(job); + + xfree(job->cmd); + + if (job->fd != -1) + close(job->fd); + if (job->out != NULL) + buffer_destroy(job->out); + + xfree(job); +} + +/* Start a job running, if it isn't already. */ +int +job_run(struct job *job) +{ + int nullfd, out[2], mode; + + if (job->fd != -1) + return (0); + + if (pipe(out) != 0) + return (-1); + + switch (job->pid = fork()) { + case -1: + return (-1); + case 0: /* child */ + sigreset(); + /* XXX environ? */ + + nullfd = open(_PATH_DEVNULL, O_RDONLY, 0); + if (nullfd < 0) + fatal("open failed"); + if (dup2(nullfd, STDIN_FILENO) == -1) + fatal("dup2 failed"); + if (dup2(nullfd, STDERR_FILENO) == -1) + fatal("dup2 failed"); + if (nullfd != STDIN_FILENO && nullfd != STDERR_FILENO) + close(nullfd); + + close(out[1]); + if (dup2(out[0], STDOUT_FILENO) == -1) + fatal("dup2 failed"); + if (out[0] != STDOUT_FILENO) + close(out[0]); + + execl(_PATH_BSHELL, "sh", "-c", job->cmd, (char *) NULL); + fatal("execl failed"); + default: /* parent */ + close(out[0]); + + job->fd = out[1]; + if ((mode = fcntl(job->fd, F_GETFL)) == -1) + fatal("fcntl failed"); + if (fcntl(job->fd, F_SETFL, mode|O_NONBLOCK) == -1) + fatal("fcntl failed"); + if (fcntl(job->fd, F_SETFD, FD_CLOEXEC) == -1) + fatal("fcntl failed"); + + if (BUFFER_USED(job->out) != 0) + buffer_remove(job->out, BUFFER_USED(job->out)); + + return (0); + } +} + +/* Kill a job. */ +void +job_kill(struct job *job) +{ + if (job->pid == -1) + return; + kill(job->pid, SIGTERM); + job->pid = -1; +} -- cgit v1.2.3