core.h 9.93 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
59
60
61
#include <linux/list.h>
#include <linux/vmalloc.h>

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

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

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

71
/*
72
 * TIPC's print buffer subsystem supports the following print buffers:
Per Liden's avatar
Per Liden committed
73
 *
74
75
76
77
 * TIPC_NULL : null buffer (i.e. print nowhere)
 * TIPC_CONS : system console
 * TIPC_LOG  : TIPC log buffer
 * &buf	     : user-defined buffer (struct print_buf *)
78
79
80
 *
 * 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
81
82
 */

83
84
85
86
87
88
89
90
91
92
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
93
#ifndef TIPC_OUTPUT
94
#define TIPC_OUTPUT TIPC_LOG
Per Liden's avatar
Per Liden committed
95
96
97
#endif

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

102
103
104
105
106
107
108
109
110
111
112
#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

113
114
115
#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
116

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

119
120
121
122
123
124
125
126
127
128
/*
 * 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
129

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

135
#ifdef CONFIG_TIPC_DEBUG
136

137
138
139
140
141
142
143
144
#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) \
145
			tipc_msg_dbg(DBG_OUTPUT, msg, txt); \
146
147
148
149
	} while (0)
#define dump(fmt, arg...) \
	do { \
		if (DBG_OUTPUT != TIPC_NULL) \
150
			tipc_dump_dbg(DBG_OUTPUT, fmt, ##arg); \
151
152
	} while (0)

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

156
157
158
159
160
#else

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

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

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


168
/*
Per Liden's avatar
Per Liden committed
169
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
 * 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
 */

203
204
extern int  tipc_core_start(void);
extern void tipc_core_stop(void);
205
extern int  tipc_core_start_net(unsigned long addr);
206
extern void tipc_core_stop_net(void);
207
208
209
210
211
212
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
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229

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);

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

/**
 * 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
237
 *
Per Liden's avatar
Per Liden committed
238
239
240
 * Timer must be initialized before use (and terminated when no longer needed).
 */

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

/**
 * k_start_timer - start a timer
 * @timer: pointer to timer structure
 * @msec: time to delay (in ms)
252
 *
Per Liden's avatar
Per Liden committed
253
254
 * Schedules a previously initialized timer for later execution.
 * If timer is already running, the new timeout overrides the previous request.
255
 *
Per Liden's avatar
Per Liden committed
256
257
 * To ensure the timer doesn't expire before the specified delay elapses,
 * the amount of delay is rounded up when converting to the jiffies
258
 * then an additional jiffy is added to account for the fact that
Per Liden's avatar
Per Liden committed
259
260
261
262
263
264
265
266
267
268
269
270
 * 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
271
272
 *
 * Cancels a previously initialized timer.
Per Liden's avatar
Per Liden committed
273
 * Can be called safely even if the timer is already inactive.
274
 *
Per Liden's avatar
Per Liden committed
275
276
277
278
279
280
281
282
283
284
285
286
287
 * 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
288
 *
Per Liden's avatar
Per Liden committed
289
 * Prevents further use of a previously initialized timer.
290
 *
Per Liden's avatar
Per Liden committed
291
 * WARNING: Caller must ensure timer isn't currently running.
292
 *
Per Liden's avatar
Per Liden committed
293
294
295
296
297
298
299
300
301
302
303
304
305
 * (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
 *
306
307
 * TIPC message buffer headroom reserves space for the worst-case
 * link-level device header (in case the message is sent off-node).
308
 *
309
310
 * 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
311
312
 */

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

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)
 *
331
 * Returns a new buffer with data pointers set to the specified size.
332
 *
333
334
 * 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
335
336
337
338
339
340
341
 */

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

342
	skb = alloc_skb_fclone(buf_size, GFP_ATOMIC);
Per Liden's avatar
Per Liden committed
343
344
345
346
347
348
349
350
351
352
353
354
	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
 *
355
 * Frees a message buffer.  If passed NULL, just returns.
Per Liden's avatar
Per Liden committed
356
357
358
359
 */

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

363
364
365
366
367
368
369
370
371
372
373
374
/**
 * 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);
}

375
#endif