cb5b9822f51a5d01e6adf22b2d2d3ef6e360318b
[sip-router] / src / modules / pipelimit / pl_ht.h
1 /*
2  * pipelimit module
3  *
4  * Copyright (C) 2006 Hendrik Scholz <hscholz@raisdorf.net>
5  * Copyright (C) 2008 Ovidiu Sas <osas@voipembedded.com>
6  * Copyright (C) 2010 Daniel-Constantin Mierla (asipto.com)
7  *
8  * This file is part of Kamailio, a free SIP server.
9  *
10  * Kamailio is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version
14  *
15  * Kamailio is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
23  */
24
25 /*! \file
26  * \ingroup pipelimit
27  * \brief pipelimit :: pl_ht
28  */
29
30 #ifndef _RL_HT_H_
31 #define _RL_HT_H_
32
33 #include "../../core/str.h"
34
35 typedef struct _pl_pipe
36 {
37     unsigned int cellid;
38         str name;
39
40         /* stuff that gets read as a modparam or set via fifo */
41         int algo;
42         int limit;
43
44         /* updated values */
45         int counter;
46         int last_counter;
47         int load;
48
49     struct _pl_pipe *prev;
50     struct _pl_pipe *next;
51 } pl_pipe_t;
52
53 typedef struct _rlp_slot
54 {
55         unsigned int ssize;
56         pl_pipe_t *first;
57         gen_lock_t lock;
58 } rlp_slot_t;
59
60 typedef struct _rlp_htable
61 {
62         unsigned int htsize;
63         rlp_slot_t *slots;
64 } rlp_htable_t;
65
66 int pl_init_htable(unsigned int hsize);
67 int pl_destroy_htable(void);
68 void pl_pipe_release(str *pipeid);
69 pl_pipe_t* pl_pipe_get(str *pipeid, int mode);
70 int pl_pipe_add(str *pipeid, str *algorithm, int limit);
71 int pl_print_pipes(void);
72 int pl_pipe_check_feedback_setpoints(int *cfgsp);
73 void pl_pipe_timer_update(int interval, int netload);
74
75 void rpl_pipe_lock(int slot);
76 void rpl_pipe_release(int slot);
77
78 /* PIPE_ALGO_FEEDBACK holds cpu usage to a fixed value using
79  * negative feedback according to the PID controller model
80  *
81  * <http://en.wikipedia.org/wiki/PID_controller>
82  */
83 enum {
84         PIPE_ALGO_NOP = 0,
85         PIPE_ALGO_RED,
86         PIPE_ALGO_TAILDROP,
87         PIPE_ALGO_FEEDBACK,
88         PIPE_ALGO_NETWORK
89 };
90
91 typedef struct str_map {
92         str     str;
93         int     id;
94 } str_map_t;
95
96 extern str_map_t algo_names[];
97
98 static inline int str_cmp(const str * a , const str * b)
99 {
100         return ! (a->len == b->len && ! strncmp(a->s, b->s, a->len));
101 }
102
103 static inline int str_i_cmp(const str * a, const str * b)
104 {
105         return ! (a->len == b->len && ! strncasecmp(a->s, b->s, a->len));
106 }
107
108 /**
109  * converts a mapped str to an int
110  * \return      0 if found, -1 otherwise
111  */
112 static inline int str_map_str(const str_map_t * map, const str * key, int * ret)
113 {
114         for (; map->str.s; map++)
115                 if (! str_cmp(&map->str, key)) {
116                         *ret = map->id;
117                         return 0;
118                 }
119         LM_DBG("str_map_str() failed map=%p key=%.*s\n", map, key->len, key->s);
120         return -1;
121 }
122
123 /**
124  * converts a mapped int to a str
125  * \return      0 if found, -1 otherwise
126  */
127 static inline int str_map_int(const str_map_t * map, int key, str * ret)
128 {
129         for (; map->str.s; map++)
130                 if (map->id == key) {
131                         *ret = map->str;
132                         return 0;
133                 }
134         LM_DBG("str_map_str() failed map=%p key=%d\n", map, key);
135         return -1;
136 }
137
138 /**
139  * strcpy for str's (does not allocate the str structure but only the .s member)
140  * \return      0 if succeeded, -1 otherwise
141  */
142 static inline int str_cpy(str * dest, str * src)
143 {
144         dest->len = src->len;
145         dest->s = shm_malloc(src->len);
146         if (! dest->s) {
147                 LM_ERR("oom: '%.*s'\n", src->len, src->s);
148                 return -1;
149         }
150         memcpy(dest->s, src->s, src->len);
151         return 0;
152 }
153
154 #endif