blob: 3017bf4e168180d8f805632ba56fa95f5b3c379e [file] [log] [blame]
Willy Tarreau81f38d62015-04-13 17:11:11 +02001/*
2 * Functions managing applets
3 *
4 * Copyright 2000-2015 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <stdio.h>
14#include <stdlib.h>
15
16#include <common/config.h>
17#include <common/mini-clist.h>
18#include <proto/applet.h>
Christopher Fauleta73e59b2016-12-09 17:30:18 +010019#include <proto/channel.h>
Willy Tarreau3c595ac2015-04-19 09:59:31 +020020#include <proto/stream.h>
21#include <proto/stream_interface.h>
Olivier Houchard673867c2018-05-25 16:58:52 +020022#include <proto/task.h>
Willy Tarreau81f38d62015-04-13 17:11:11 +020023
Christopher Faulet1cbe74c2016-12-06 09:13:22 +010024unsigned int nb_applets = 0;
Emeric Brun1138fd02017-06-19 12:38:55 +020025
Willy Tarreau21028b52018-11-06 17:32:37 +010026/* Callback used to wake up an applet when a buffer is available. The applet
27 * <appctx> is woken up if an input buffer was requested for the associated
28 * stream interface. In this case the buffer is immediately allocated and the
29 * function returns 1. Otherwise it returns 0. Note that this automatically
30 * covers multiple wake-up attempts by ensuring that the same buffer will not
31 * be accounted for multiple times.
32 */
33int appctx_buf_available(void *arg)
34{
35 struct appctx *appctx = arg;
36 struct stream_interface *si = appctx->owner;
37
38 /* allocation requested ? */
39 if (!(si->flags & SI_FL_WAIT_ROOM) || c_size(si_ic(si)) || si_ic(si)->pipe)
40 return 0;
41
42 /* allocation possible now ? */
43 if (!b_alloc_margin(&si_ic(si)->buf, global.tune.reserved_bufs))
44 return 0;
45
46 si->flags &= ~SI_FL_WAIT_ROOM;
47 task_wakeup(appctx->t, TASK_WOKEN_RES);
48 return 1;
49}
50
51/* Default applet handler */
Olivier Houchard673867c2018-05-25 16:58:52 +020052struct task *task_run_applet(struct task *t, void *context, unsigned short state)
Willy Tarreau3c595ac2015-04-19 09:59:31 +020053{
Olivier Houchard673867c2018-05-25 16:58:52 +020054 struct appctx *app = context;
55 struct stream_interface *si = app->owner;
Christopher Fauletb4a4d9a2017-11-15 22:14:49 +010056
Olivier Houchard673867c2018-05-25 16:58:52 +020057 if (app->state & APPLET_WANT_DIE) {
58 __appctx_free(app);
59 return NULL;
Christopher Faulet71630562017-11-14 11:30:47 +010060 }
Olivier Houchard673867c2018-05-25 16:58:52 +020061 /* Now we'll try to allocate the input buffer. We wake up the
62 * applet in all cases. So this is the applet responsibility to
63 * check if this buffer was allocated or not. This let a chance
64 * for applets to do some other processing if needed. */
Willy Tarreau581abd32018-10-25 10:21:41 +020065 if (!si_alloc_ibuf(si, &app->buffer_wait))
Willy Tarreau0cd3bd62018-11-06 18:46:37 +010066 si_cant_put(si);
Emeric Brun1138fd02017-06-19 12:38:55 +020067
Olivier Houchard673867c2018-05-25 16:58:52 +020068 /* We always pretend the applet can't get and doesn't want to
69 * put, it's up to it to change this if needed. This ensures
70 * that one applet which ignores any event will not spin.
Willy Tarreau99942382015-09-25 17:56:16 +020071 */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +010072 si_cant_get(si);
73 si_stop_put(si);
Willy Tarreau3c595ac2015-04-19 09:59:31 +020074
Olivier Houchard673867c2018-05-25 16:58:52 +020075 app->applet->fct(app);
76 si_applet_wake_cb(si);
77 channel_release_buffer(si_ic(si), &app->buffer_wait);
78 return t;
Willy Tarreau3c595ac2015-04-19 09:59:31 +020079}
Emeric Brun1138fd02017-06-19 12:38:55 +020080