]>
Commit | Line | Data |
---|---|---|
b97bf3fd PL |
1 | /* |
2 | * net/tipc/core.h: Include file for TIPC global declarations | |
3 | * | |
4 | * Copyright (c) 2003-2005, Ericsson Research Canada | |
5 | * Copyright (c) 2005, Wind River Systems | |
6 | * Copyright (c) 2005-2006, Ericsson AB | |
7 | * All rights reserved. | |
8 | * | |
9 | * Redistribution and use in source and binary forms, with or without | |
10 | * modification, are permitted provided that the following conditions are met: | |
11 | * | |
12 | * Redistributions of source code must retain the above copyright notice, this | |
13 | * list of conditions and the following disclaimer. | |
14 | * Redistributions in binary form must reproduce the above copyright notice, | |
15 | * this list of conditions and the following disclaimer in the documentation | |
16 | * and/or other materials provided with the distribution. | |
17 | * Neither the names of the copyright holders nor the names of its | |
18 | * contributors may be used to endorse or promote products derived from this | |
19 | * software without specific prior written permission. | |
20 | * | |
21 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
22 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | |
25 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
26 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
27 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
28 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
29 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
30 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
31 | * POSSIBILITY OF SUCH DAMAGE. | |
32 | */ | |
33 | ||
34 | #ifndef _TIPC_CORE_H | |
35 | #define _TIPC_CORE_H | |
36 | ||
37 | #include <net/tipc/tipc.h> | |
38 | #include <linux/types.h> | |
39 | #include <linux/kernel.h> | |
40 | #include <linux/errno.h> | |
41 | #include <linux/mm.h> | |
42 | #include <linux/timer.h> | |
43 | #include <linux/string.h> | |
44 | #include <asm/uaccess.h> | |
45 | #include <linux/interrupt.h> | |
46 | #include <asm/atomic.h> | |
47 | #include <asm/hardirq.h> | |
48 | #include <linux/netdevice.h> | |
49 | #include <linux/in.h> | |
50 | #include <linux/list.h> | |
51 | #include <linux/vmalloc.h> | |
52 | ||
53 | /* | |
54 | * TIPC debugging code | |
55 | */ | |
56 | ||
57 | #define assert(i) BUG_ON(!(i)) | |
58 | ||
59 | struct tipc_msg; | |
60 | extern struct print_buf *CONS, *LOG; | |
61 | extern struct print_buf *TEE(struct print_buf *, struct print_buf *); | |
62 | void msg_print(struct print_buf*,struct tipc_msg *,const char*); | |
63 | void tipc_printf(struct print_buf *, const char *fmt, ...); | |
64 | void tipc_dump(struct print_buf*,const char *fmt, ...); | |
65 | ||
66 | #ifdef CONFIG_TIPC_DEBUG | |
67 | ||
68 | /* | |
69 | * TIPC debug support included: | |
70 | * - system messages are printed to TIPC_OUTPUT print buffer | |
71 | * - debug messages are printed to DBG_OUTPUT print buffer | |
72 | */ | |
73 | ||
74 | #define err(fmt, arg...) tipc_printf(TIPC_OUTPUT, KERN_ERR "TIPC: " fmt, ## arg) | |
75 | #define warn(fmt, arg...) tipc_printf(TIPC_OUTPUT, KERN_WARNING "TIPC: " fmt, ## arg) | |
76 | #define info(fmt, arg...) tipc_printf(TIPC_OUTPUT, KERN_NOTICE "TIPC: " fmt, ## arg) | |
77 | ||
78 | #define dbg(fmt, arg...) do {if (DBG_OUTPUT) tipc_printf(DBG_OUTPUT, fmt, ## arg);} while(0) | |
79 | #define msg_dbg(msg, txt) do {if (DBG_OUTPUT) msg_print(DBG_OUTPUT, msg, txt);} while(0) | |
80 | #define dump(fmt, arg...) do {if (DBG_OUTPUT) tipc_dump(DBG_OUTPUT, fmt, ##arg);} while(0) | |
81 | ||
82 | ||
83 | /* | |
84 | * By default, TIPC_OUTPUT is defined to be system console and TIPC log buffer, | |
85 | * while DBG_OUTPUT is the null print buffer. These defaults can be changed | |
86 | * here, or on a per .c file basis, by redefining these symbols. The following | |
87 | * print buffer options are available: | |
88 | * | |
89 | * NULL : Output to null print buffer (i.e. print nowhere) | |
90 | * CONS : Output to system console | |
91 | * LOG : Output to TIPC log buffer | |
92 | * &buf : Output to user-defined buffer (struct print_buf *) | |
93 | * TEE(&buf_a,&buf_b) : Output to two print buffers (eg. TEE(CONS,LOG) ) | |
94 | */ | |
95 | ||
96 | #ifndef TIPC_OUTPUT | |
97 | #define TIPC_OUTPUT TEE(CONS,LOG) | |
98 | #endif | |
99 | ||
100 | #ifndef DBG_OUTPUT | |
101 | #define DBG_OUTPUT NULL | |
102 | #endif | |
103 | ||
104 | #else | |
105 | ||
106 | #ifndef DBG_OUTPUT | |
107 | #define DBG_OUTPUT NULL | |
108 | #endif | |
109 | ||
110 | /* | |
111 | * TIPC debug support not included: | |
112 | * - system messages are printed to system console | |
113 | * - debug messages are not printed | |
114 | */ | |
115 | ||
116 | #define err(fmt, arg...) printk(KERN_ERR "%s: " fmt "\n" , __FILE__ , ## arg) | |
117 | #define info(fmt, arg...) printk(KERN_INFO "%s: " fmt "\n" , __FILE__ , ## arg) | |
118 | #define warn(fmt, arg...) printk(KERN_WARNING "%s: " fmt "\n" , __FILE__ , ## arg) | |
119 | ||
120 | #define dbg(fmt, arg...) do {} while (0) | |
121 | #define msg_dbg(msg,txt) do {} while (0) | |
122 | #define dump(fmt,arg...) do {} while (0) | |
123 | ||
124 | #endif | |
125 | ||
126 | ||
127 | /* | |
128 | * TIPC-specific error codes | |
129 | */ | |
130 | ||
131 | #define ELINKCONG EAGAIN /* link congestion <=> resource unavailable */ | |
132 | ||
133 | /* | |
134 | * Global configuration variables | |
135 | */ | |
136 | ||
137 | extern u32 tipc_own_addr; | |
138 | extern int tipc_max_zones; | |
139 | extern int tipc_max_clusters; | |
140 | extern int tipc_max_nodes; | |
141 | extern int tipc_max_slaves; | |
142 | extern int tipc_max_ports; | |
143 | extern int tipc_max_subscriptions; | |
144 | extern int tipc_max_publications; | |
145 | extern int tipc_net_id; | |
146 | extern int tipc_remote_management; | |
147 | ||
148 | /* | |
149 | * Other global variables | |
150 | */ | |
151 | ||
152 | extern int tipc_mode; | |
153 | extern int tipc_random; | |
154 | extern const char tipc_alphabet[]; | |
155 | extern atomic_t tipc_user_count; | |
156 | ||
157 | ||
158 | /* | |
159 | * Routines available to privileged subsystems | |
160 | */ | |
161 | ||
162 | extern int start_core(void); | |
163 | extern void stop_core(void); | |
164 | extern int start_net(void); | |
165 | extern void stop_net(void); | |
166 | ||
167 | static inline int delimit(int val, int min, int max) | |
168 | { | |
169 | if (val > max) | |
170 | return max; | |
171 | if (val < min) | |
172 | return min; | |
173 | return val; | |
174 | } | |
175 | ||
176 | ||
177 | /* | |
178 | * TIPC timer and signal code | |
179 | */ | |
180 | ||
181 | typedef void (*Handler) (unsigned long); | |
182 | ||
183 | u32 k_signal(Handler routine, unsigned long argument); | |
184 | ||
185 | /** | |
186 | * k_init_timer - initialize a timer | |
187 | * @timer: pointer to timer structure | |
188 | * @routine: pointer to routine to invoke when timer expires | |
189 | * @argument: value to pass to routine when timer expires | |
190 | * | |
191 | * Timer must be initialized before use (and terminated when no longer needed). | |
192 | */ | |
193 | ||
194 | static inline void k_init_timer(struct timer_list *timer, Handler routine, | |
195 | unsigned long argument) | |
196 | { | |
197 | dbg("initializing timer %p\n", timer); | |
198 | init_timer(timer); | |
199 | timer->function = routine; | |
200 | timer->data = argument; | |
201 | } | |
202 | ||
203 | /** | |
204 | * k_start_timer - start a timer | |
205 | * @timer: pointer to timer structure | |
206 | * @msec: time to delay (in ms) | |
207 | * | |
208 | * Schedules a previously initialized timer for later execution. | |
209 | * If timer is already running, the new timeout overrides the previous request. | |
210 | * | |
211 | * To ensure the timer doesn't expire before the specified delay elapses, | |
212 | * the amount of delay is rounded up when converting to the jiffies | |
213 | * then an additional jiffy is added to account for the fact that | |
214 | * the starting time may be in the middle of the current jiffy. | |
215 | */ | |
216 | ||
217 | static inline void k_start_timer(struct timer_list *timer, unsigned long msec) | |
218 | { | |
219 | dbg("starting timer %p for %u\n", timer, msec); | |
220 | mod_timer(timer, jiffies + msecs_to_jiffies(msec) + 1); | |
221 | } | |
222 | ||
223 | /** | |
224 | * k_cancel_timer - cancel a timer | |
225 | * @timer: pointer to timer structure | |
226 | * | |
227 | * Cancels a previously initialized timer. | |
228 | * Can be called safely even if the timer is already inactive. | |
229 | * | |
230 | * WARNING: Must not be called when holding locks required by the timer's | |
231 | * timeout routine, otherwise deadlock can occur on SMP systems! | |
232 | */ | |
233 | ||
234 | static inline void k_cancel_timer(struct timer_list *timer) | |
235 | { | |
236 | dbg("cancelling timer %p\n", timer); | |
237 | del_timer_sync(timer); | |
238 | } | |
239 | ||
240 | /** | |
241 | * k_term_timer - terminate a timer | |
242 | * @timer: pointer to timer structure | |
243 | * | |
244 | * Prevents further use of a previously initialized timer. | |
245 | * | |
246 | * WARNING: Caller must ensure timer isn't currently running. | |
247 | * | |
248 | * (Do not "enhance" this routine to automatically cancel an active timer, | |
249 | * otherwise deadlock can arise when a timeout routine calls k_term_timer.) | |
250 | */ | |
251 | ||
252 | static inline void k_term_timer(struct timer_list *timer) | |
253 | { | |
254 | dbg("terminating timer %p\n", timer); | |
255 | } | |
256 | ||
257 | ||
258 | /* | |
259 | * TIPC message buffer code | |
260 | * | |
261 | * TIPC message buffer headroom leaves room for 14 byte Ethernet header, | |
262 | * while ensuring TIPC header is word aligned for quicker access | |
263 | */ | |
264 | ||
265 | #define BUF_HEADROOM 16u | |
266 | ||
267 | struct tipc_skb_cb { | |
268 | void *handle; | |
269 | }; | |
270 | ||
271 | #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0])) | |
272 | ||
273 | ||
274 | static inline struct tipc_msg *buf_msg(struct sk_buff *skb) | |
275 | { | |
276 | return (struct tipc_msg *)skb->data; | |
277 | } | |
278 | ||
279 | /** | |
280 | * buf_acquire - creates a TIPC message buffer | |
281 | * @size: message size (including TIPC header) | |
282 | * | |
283 | * Returns a new buffer. Space is reserved for a data link header. | |
284 | */ | |
285 | ||
286 | static inline struct sk_buff *buf_acquire(u32 size) | |
287 | { | |
288 | struct sk_buff *skb; | |
289 | unsigned int buf_size = (BUF_HEADROOM + size + 3) & ~3u; | |
290 | ||
291 | skb = alloc_skb(buf_size, GFP_ATOMIC); | |
292 | if (skb) { | |
293 | skb_reserve(skb, BUF_HEADROOM); | |
294 | skb_put(skb, size); | |
295 | skb->next = NULL; | |
296 | } | |
297 | return skb; | |
298 | } | |
299 | ||
300 | /** | |
301 | * buf_discard - frees a TIPC message buffer | |
302 | * @skb: message buffer | |
303 | * | |
304 | * Frees a new buffer. If passed NULL, just returns. | |
305 | */ | |
306 | ||
307 | static inline void buf_discard(struct sk_buff *skb) | |
308 | { | |
309 | if (likely(skb != NULL)) | |
310 | kfree_skb(skb); | |
311 | } | |
312 | ||
313 | #endif |