Annotation of embedaddon/tmux/cmd-wait-for.c, revision 1.1.1.1
1.1 misho 1: /* $OpenBSD$ */
2:
3: /*
4: * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
5: * Copyright (c) 2013 Thiago de Arruda <tpadilha84@gmail.com>
6: *
7: * Permission to use, copy, modify, and distribute this software for any
8: * purpose with or without fee is hereby granted, provided that the above
9: * copyright notice and this permission notice appear in all copies.
10: *
11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
16: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
17: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18: */
19:
20: #include <sys/types.h>
21:
22: #include <stdlib.h>
23: #include <string.h>
24:
25: #include "tmux.h"
26:
27: /*
28: * Block or wake a client on a named wait channel.
29: */
30:
31: static enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmdq_item *);
32:
33: const struct cmd_entry cmd_wait_for_entry = {
34: .name = "wait-for",
35: .alias = "wait",
36:
37: .args = { "LSU", 1, 1 },
38: .usage = "[-L|-S|-U] channel",
39:
40: .flags = 0,
41: .exec = cmd_wait_for_exec
42: };
43:
44: struct wait_item {
45: struct cmdq_item *item;
46: TAILQ_ENTRY(wait_item) entry;
47: };
48:
49: struct wait_channel {
50: const char *name;
51: int locked;
52: int woken;
53:
54: TAILQ_HEAD(, wait_item) waiters;
55: TAILQ_HEAD(, wait_item) lockers;
56:
57: RB_ENTRY(wait_channel) entry;
58: };
59: RB_HEAD(wait_channels, wait_channel);
60: static struct wait_channels wait_channels = RB_INITIALIZER(wait_channels);
61:
62: static int wait_channel_cmp(struct wait_channel *, struct wait_channel *);
63: RB_GENERATE_STATIC(wait_channels, wait_channel, entry, wait_channel_cmp);
64:
65: static int
66: wait_channel_cmp(struct wait_channel *wc1, struct wait_channel *wc2)
67: {
68: return (strcmp(wc1->name, wc2->name));
69: }
70:
71: static enum cmd_retval cmd_wait_for_signal(struct cmdq_item *, const char *,
72: struct wait_channel *);
73: static enum cmd_retval cmd_wait_for_wait(struct cmdq_item *, const char *,
74: struct wait_channel *);
75: static enum cmd_retval cmd_wait_for_lock(struct cmdq_item *, const char *,
76: struct wait_channel *);
77: static enum cmd_retval cmd_wait_for_unlock(struct cmdq_item *, const char *,
78: struct wait_channel *);
79:
80: static struct wait_channel *cmd_wait_for_add(const char *);
81: static void cmd_wait_for_remove(struct wait_channel *);
82:
83: static struct wait_channel *
84: cmd_wait_for_add(const char *name)
85: {
86: struct wait_channel *wc;
87:
88: wc = xmalloc(sizeof *wc);
89: wc->name = xstrdup(name);
90:
91: wc->locked = 0;
92: wc->woken = 0;
93:
94: TAILQ_INIT(&wc->waiters);
95: TAILQ_INIT(&wc->lockers);
96:
97: RB_INSERT(wait_channels, &wait_channels, wc);
98:
99: log_debug("add wait channel %s", wc->name);
100:
101: return (wc);
102: }
103:
104: static void
105: cmd_wait_for_remove(struct wait_channel *wc)
106: {
107: if (wc->locked)
108: return;
109: if (!TAILQ_EMPTY(&wc->waiters) || !wc->woken)
110: return;
111:
112: log_debug("remove wait channel %s", wc->name);
113:
114: RB_REMOVE(wait_channels, &wait_channels, wc);
115:
116: free((void *)wc->name);
117: free(wc);
118: }
119:
120: static enum cmd_retval
121: cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
122: {
123: struct args *args = self->args;
124: const char *name = args->argv[0];
125: struct wait_channel *wc, wc0;
126:
127: wc0.name = name;
128: wc = RB_FIND(wait_channels, &wait_channels, &wc0);
129:
130: if (args_has(args, 'S'))
131: return (cmd_wait_for_signal(item, name, wc));
132: if (args_has(args, 'L'))
133: return (cmd_wait_for_lock(item, name, wc));
134: if (args_has(args, 'U'))
135: return (cmd_wait_for_unlock(item, name, wc));
136: return (cmd_wait_for_wait(item, name, wc));
137: }
138:
139: static enum cmd_retval
140: cmd_wait_for_signal(__unused struct cmdq_item *item, const char *name,
141: struct wait_channel *wc)
142: {
143: struct wait_item *wi, *wi1;
144:
145: if (wc == NULL)
146: wc = cmd_wait_for_add(name);
147:
148: if (TAILQ_EMPTY(&wc->waiters) && !wc->woken) {
149: log_debug("signal wait channel %s, no waiters", wc->name);
150: wc->woken = 1;
151: return (CMD_RETURN_NORMAL);
152: }
153: log_debug("signal wait channel %s, with waiters", wc->name);
154:
155: TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
156: wi->item->flags &= ~CMDQ_WAITING;
157:
158: TAILQ_REMOVE(&wc->waiters, wi, entry);
159: free(wi);
160: }
161:
162: cmd_wait_for_remove(wc);
163: return (CMD_RETURN_NORMAL);
164: }
165:
166: static enum cmd_retval
167: cmd_wait_for_wait(struct cmdq_item *item, const char *name,
168: struct wait_channel *wc)
169: {
170: struct client *c = item->client;
171: struct wait_item *wi;
172:
173: if (c == NULL || c->session != NULL) {
174: cmdq_error(item, "not able to wait");
175: return (CMD_RETURN_ERROR);
176: }
177:
178: if (wc == NULL)
179: wc = cmd_wait_for_add(name);
180:
181: if (wc->woken) {
182: log_debug("wait channel %s already woken (%p)", wc->name, c);
183: cmd_wait_for_remove(wc);
184: return (CMD_RETURN_NORMAL);
185: }
186: log_debug("wait channel %s not woken (%p)", wc->name, c);
187:
188: wi = xcalloc(1, sizeof *wi);
189: wi->item = item;
190: TAILQ_INSERT_TAIL(&wc->waiters, wi, entry);
191:
192: return (CMD_RETURN_WAIT);
193: }
194:
195: static enum cmd_retval
196: cmd_wait_for_lock(struct cmdq_item *item, const char *name,
197: struct wait_channel *wc)
198: {
199: struct wait_item *wi;
200:
201: if (item->client == NULL || item->client->session != NULL) {
202: cmdq_error(item, "not able to lock");
203: return (CMD_RETURN_ERROR);
204: }
205:
206: if (wc == NULL)
207: wc = cmd_wait_for_add(name);
208:
209: if (wc->locked) {
210: wi = xcalloc(1, sizeof *wi);
211: wi->item = item;
212: TAILQ_INSERT_TAIL(&wc->lockers, wi, entry);
213: return (CMD_RETURN_WAIT);
214: }
215: wc->locked = 1;
216:
217: return (CMD_RETURN_NORMAL);
218: }
219:
220: static enum cmd_retval
221: cmd_wait_for_unlock(struct cmdq_item *item, const char *name,
222: struct wait_channel *wc)
223: {
224: struct wait_item *wi;
225:
226: if (wc == NULL || !wc->locked) {
227: cmdq_error(item, "channel %s not locked", name);
228: return (CMD_RETURN_ERROR);
229: }
230:
231: if ((wi = TAILQ_FIRST(&wc->lockers)) != NULL) {
232: wi->item->flags &= ~CMDQ_WAITING;
233: TAILQ_REMOVE(&wc->lockers, wi, entry);
234: free(wi);
235: } else {
236: wc->locked = 0;
237: cmd_wait_for_remove(wc);
238: }
239:
240: return (CMD_RETURN_NORMAL);
241: }
242:
243: void
244: cmd_wait_for_flush(void)
245: {
246: struct wait_channel *wc, *wc1;
247: struct wait_item *wi, *wi1;
248:
249: RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
250: TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
251: wi->item->flags &= ~CMDQ_WAITING;
252: TAILQ_REMOVE(&wc->waiters, wi, entry);
253: free(wi);
254: }
255: wc->woken = 1;
256: TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
257: wi->item->flags &= ~CMDQ_WAITING;
258: TAILQ_REMOVE(&wc->lockers, wi, entry);
259: free(wi);
260: }
261: wc->locked = 0;
262: cmd_wait_for_remove(wc);
263: }
264: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cmd-wait-for.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux