core.h 9.96 KB
Newer Older
Per Liden's avatar
Per Liden committed
1
2
/*
 * net/tipc/core.h: Include file for TIPC global declarations
3
 *
4
 * Copyright (c) 2005-2006, Ericsson AB
5
 * Copyright (c) 2005-2007, Wind River Systems
Per Liden's avatar
Per Liden committed
6
7
 * All rights reserved.
 *
Per Liden's avatar
Per Liden committed
8
 * Redistribution and use in source and binary forms, with or without
Per Liden's avatar
Per Liden committed
9
10
 * modification, are permitted provided that the following conditions are met:
 *
Per Liden's avatar
Per Liden committed
11
12
13
14
15
16
17
18
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
Per Liden's avatar
Per Liden committed
19
 *
Per Liden's avatar
Per Liden committed
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Per Liden's avatar
Per Liden committed
34
35
36
37
38
39
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _TIPC_CORE_H
#define _TIPC_CORE_H

Jon Maloy's avatar
Jon Maloy committed
40
41
42
43
44
#include <linux/tipc.h>
#include <linux/tipc_config.h>
#include <net/tipc/tipc_msg.h>
#include <net/tipc/tipc_port.h>
#include <net/tipc/tipc_bearer.h>
Per Liden's avatar
Per Liden committed
45
46
47
48
49
50
51
52
53
54
55
56
#include <net/tipc/tipc.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#include <linux/interrupt.h>
#include <asm/atomic.h>
#include <asm/hardirq.h>
#include <linux/netdevice.h>
57
#include <linux/in.h>
Per Liden's avatar
Per Liden committed
58
#include <linux/list.h>
59
#include <linux/slab.h>
Per Liden's avatar
Per Liden committed
60
61
62
#include <linux/vmalloc.h>

/*
63
 * TIPC sanity test macros
Per Liden's avatar
Per Liden committed
64
65
66
67
68
 */

#define assert(i)  BUG_ON(!(i))

/*
69
 * TIPC system monitoring code
Per Liden's avatar
Per Liden committed
70
71
 */

72
/*
73
 * TIPC's print buffer subsystem supports the following print buffers:
Per Liden's avatar
Per Liden committed
74
 *
75
76
77
78
 * TIPC_NULL : null buffer (i.e. print nowhere)
 * TIPC_CONS : system console
 * TIPC_LOG  : TIPC log buffer
 * &buf	     : user-defined buffer (struct print_buf *)
79
80
81
 *
 * Note: TIPC_LOG is configured to echo its output to the system console;
 *       user-defined buffers can be configured to do the same thing.
Per Liden's avatar
Per Liden committed
82
83
 */

84
85
86
87
88
89
90
91
92
93
extern struct print_buf *const TIPC_NULL;
extern struct print_buf *const TIPC_CONS;
extern struct print_buf *const TIPC_LOG;

void tipc_printf(struct print_buf *, const char *fmt, ...);

/*
 * TIPC_OUTPUT is the destination print buffer for system messages.
 */

Per Liden's avatar
Per Liden committed
94
#ifndef TIPC_OUTPUT
95
#define TIPC_OUTPUT TIPC_LOG
Per Liden's avatar
Per Liden committed
96
97
98
#endif

/*
99
100
 * TIPC can be configured to send system messages to TIPC_OUTPUT
 * or to the system console only.
Per Liden's avatar
Per Liden committed
101
102
 */

103
104
105
106
107
108
109
110
111
112
113
#ifdef CONFIG_TIPC_DEBUG

#define err(fmt, arg...)  tipc_printf(TIPC_OUTPUT, \
					KERN_ERR "TIPC: " fmt, ## arg)
#define warn(fmt, arg...) tipc_printf(TIPC_OUTPUT, \
					KERN_WARNING "TIPC: " fmt, ## arg)
#define info(fmt, arg...) tipc_printf(TIPC_OUTPUT, \
					KERN_NOTICE "TIPC: " fmt, ## arg)

#else

114
115
116
#define err(fmt, arg...)  printk(KERN_ERR "TIPC: " fmt , ## arg)
#define info(fmt, arg...) printk(KERN_INFO "TIPC: " fmt , ## arg)
#define warn(fmt, arg...) printk(KERN_WARNING "TIPC: " fmt , ## arg)
Per Liden's avatar
Per Liden committed
117

118
#endif
Per Liden's avatar
Per Liden committed
119

120
121
122
123
124
125
126
127
128
129
/*
 * DBG_OUTPUT is the destination print buffer for debug messages.
 * It defaults to the the null print buffer, but can be redefined
 * (typically in the individual .c files being debugged) to allow
 * selected debug messages to be generated where needed.
 */

#ifndef DBG_OUTPUT
#define DBG_OUTPUT TIPC_NULL
#endif
130

131
/*
132
133
 * TIPC can be configured to send debug messages to the specified print buffer
 * (typically DBG_OUTPUT) or to suppress them entirely.
134
135
 */

136
#ifdef CONFIG_TIPC_DEBUG
137

138
139
140
141
142
143
144
145
#define dbg(fmt, arg...)  \
	do { \
		if (DBG_OUTPUT != TIPC_NULL) \
			tipc_printf(DBG_OUTPUT, fmt, ## arg); \
	} while (0)
#define msg_dbg(msg, txt) \
	do { \
		if (DBG_OUTPUT != TIPC_NULL) \
146
			tipc_msg_dbg(DBG_OUTPUT, msg, txt); \
147
148
149
150
	} while (0)
#define dump(fmt, arg...) \
	do { \
		if (DBG_OUTPUT != TIPC_NULL) \
151
			tipc_dump_dbg(DBG_OUTPUT, fmt, ##arg); \
152
153
	} while (0)

154
155
156
void tipc_msg_dbg(struct print_buf *, struct tipc_msg *, const char *);
void tipc_dump_dbg(struct print_buf *, const char *fmt, ...);

157
158
159
160
161
#else

#define dbg(fmt, arg...)	do {} while (0)
#define msg_dbg(msg, txt)	do {} while (0)
#define dump(fmt, arg...)	do {} while (0)
162
163
164

#define tipc_msg_dbg(...)	do {} while (0)
#define tipc_dump_dbg(...)	do {} while (0)
165

166
#endif
Per Liden's avatar
Per Liden committed
167
168


169
/*
Per Liden's avatar
Per Liden committed
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 * TIPC-specific error codes
 */

#define ELINKCONG EAGAIN	/* link congestion <=> resource unavailable */

/*
 * Global configuration variables
 */

extern u32 tipc_own_addr;
extern int tipc_max_zones;
extern int tipc_max_clusters;
extern int tipc_max_nodes;
extern int tipc_max_slaves;
extern int tipc_max_ports;
extern int tipc_max_subscriptions;
extern int tipc_max_publications;
extern int tipc_net_id;
extern int tipc_remote_management;

/*
 * Other global variables
 */

extern int tipc_mode;
extern int tipc_random;
extern const char tipc_alphabet[];
extern atomic_t tipc_user_count;


/*
 * Routines available to privileged subsystems
 */

204
205
extern int  tipc_core_start(void);
extern void tipc_core_stop(void);
206
extern int  tipc_core_start_net(unsigned long addr);
207
extern void tipc_core_stop_net(void);
208
209
210
211
212
213
extern int  tipc_handler_start(void);
extern void tipc_handler_stop(void);
extern int  tipc_netlink_start(void);
extern void tipc_netlink_stop(void);
extern int  tipc_socket_init(void);
extern void tipc_socket_stop(void);
Per Liden's avatar
Per Liden committed
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230

static inline int delimit(int val, int min, int max)
{
	if (val > max)
		return max;
	if (val < min)
		return min;
	return val;
}


/*
 * TIPC timer and signal code
 */

typedef void (*Handler) (unsigned long);

231
u32 tipc_k_signal(Handler routine, unsigned long argument);
Per Liden's avatar
Per Liden committed
232
233
234
235
236
237

/**
 * k_init_timer - initialize a timer
 * @timer: pointer to timer structure
 * @routine: pointer to routine to invoke when timer expires
 * @argument: value to pass to routine when timer expires
238
 *
Per Liden's avatar
Per Liden committed
239
240
241
 * Timer must be initialized before use (and terminated when no longer needed).
 */

242
static inline void k_init_timer(struct timer_list *timer, Handler routine,
Per Liden's avatar
Per Liden committed
243
244
245
				unsigned long argument)
{
	dbg("initializing timer %p\n", timer);
246
	setup_timer(timer, routine, argument);
Per Liden's avatar
Per Liden committed
247
248
249
250
251
252
}

/**
 * k_start_timer - start a timer
 * @timer: pointer to timer structure
 * @msec: time to delay (in ms)
253
 *
Per Liden's avatar
Per Liden committed
254
255
 * Schedules a previously initialized timer for later execution.
 * If timer is already running, the new timeout overrides the previous request.
256
 *
Per Liden's avatar
Per Liden committed
257
258
 * To ensure the timer doesn't expire before the specified delay elapses,
 * the amount of delay is rounded up when converting to the jiffies
259
 * then an additional jiffy is added to account for the fact that
Per Liden's avatar
Per Liden committed
260
261
262
263
264
265
266
267
268
269
270
271
 * the starting time may be in the middle of the current jiffy.
 */

static inline void k_start_timer(struct timer_list *timer, unsigned long msec)
{
	dbg("starting timer %p for %u\n", timer, msec);
	mod_timer(timer, jiffies + msecs_to_jiffies(msec) + 1);
}

/**
 * k_cancel_timer - cancel a timer
 * @timer: pointer to timer structure
272
273
 *
 * Cancels a previously initialized timer.
Per Liden's avatar
Per Liden committed
274
 * Can be called safely even if the timer is already inactive.
275
 *
Per Liden's avatar
Per Liden committed
276
277
278
279
280
281
282
283
284
285
286
287
288
 * WARNING: Must not be called when holding locks required by the timer's
 *          timeout routine, otherwise deadlock can occur on SMP systems!
 */

static inline void k_cancel_timer(struct timer_list *timer)
{
	dbg("cancelling timer %p\n", timer);
	del_timer_sync(timer);
}

/**
 * k_term_timer - terminate a timer
 * @timer: pointer to timer structure
289
 *
Per Liden's avatar
Per Liden committed
290
 * Prevents further use of a previously initialized timer.
291
 *
Per Liden's avatar
Per Liden committed
292
 * WARNING: Caller must ensure timer isn't currently running.
293
 *
Per Liden's avatar
Per Liden committed
294
295
296
297
298
299
300
301
302
303
304
305
306
 * (Do not "enhance" this routine to automatically cancel an active timer,
 * otherwise deadlock can arise when a timeout routine calls k_term_timer.)
 */

static inline void k_term_timer(struct timer_list *timer)
{
	dbg("terminating timer %p\n", timer);
}


/*
 * TIPC message buffer code
 *
307
308
 * TIPC message buffer headroom reserves space for the worst-case
 * link-level device header (in case the message is sent off-node).
309
 *
310
311
 * Note: Headroom should be a multiple of 4 to ensure the TIPC header fields
 *       are word aligned for quicker access
Per Liden's avatar
Per Liden committed
312
313
 */

314
#define BUF_HEADROOM LL_MAX_HEADER
Per Liden's avatar
Per Liden committed
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331

struct tipc_skb_cb {
	void *handle;
};

#define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0]))


static inline struct tipc_msg *buf_msg(struct sk_buff *skb)
{
	return (struct tipc_msg *)skb->data;
}

/**
 * buf_acquire - creates a TIPC message buffer
 * @size: message size (including TIPC header)
 *
332
 * Returns a new buffer with data pointers set to the specified size.
333
 *
334
335
 * NOTE: Headroom is reserved to allow prepending of a data link header.
 *       There may also be unrequested tailroom present at the buffer's end.
Per Liden's avatar
Per Liden committed
336
337
338
339
340
341
342
 */

static inline struct sk_buff *buf_acquire(u32 size)
{
	struct sk_buff *skb;
	unsigned int buf_size = (BUF_HEADROOM + size + 3) & ~3u;

343
	skb = alloc_skb_fclone(buf_size, GFP_ATOMIC);
Per Liden's avatar
Per Liden committed
344
345
346
347
348
349
350
351
352
353
354
355
	if (skb) {
		skb_reserve(skb, BUF_HEADROOM);
		skb_put(skb, size);
		skb->next = NULL;
	}
	return skb;
}

/**
 * buf_discard - frees a TIPC message buffer
 * @skb: message buffer
 *
356
 * Frees a message buffer.  If passed NULL, just returns.
Per Liden's avatar
Per Liden committed
357
358
359
360
 */

static inline void buf_discard(struct sk_buff *skb)
{
361
	kfree_skb(skb);
Per Liden's avatar
Per Liden committed
362
363
}

364
365
366
367
368
369
370
371
372
373
374
375
/**
 * buf_linearize - convert a TIPC message buffer into a single contiguous piece
 * @skb: message buffer
 *
 * Returns 0 on success.
 */

static inline int buf_linearize(struct sk_buff *skb)
{
	return skb_linearize(skb);
}

376
#endif