tipc: Eliminate unused routing message definitions
[linux-2.6.git] / net / tipc / bearer.h
1 /*
2  * net/tipc/bearer.h: Include file for TIPC bearer code
3  *
4  * Copyright (c) 1996-2006, Ericsson AB
5  * Copyright (c) 2005, 2010-2011, Wind River Systems
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the names of the copyright holders nor the names of its
17  *    contributors may be used to endorse or promote products derived from
18  *    this software without specific prior written permission.
19  *
20  * Alternatively, this software may be distributed under the terms of the
21  * GNU General Public License ("GPL") version 2 as published by the Free
22  * Software Foundation.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  * POSSIBILITY OF SUCH DAMAGE.
35  */
36
37 #ifndef _TIPC_BEARER_H
38 #define _TIPC_BEARER_H
39
40 #include "bcast.h"
41
42 #define MAX_BEARERS 8
43 #define MAX_MEDIA 4
44
45 /*
46  * Identifiers of supported TIPC media types
47  */
48 #define TIPC_MEDIA_TYPE_ETH     1
49
50 /*
51  * Destination address structure used by TIPC bearers when sending messages
52  *
53  * IMPORTANT: The fields of this structure MUST be stored using the specified
54  * byte order indicated below, as the structure is exchanged between nodes
55  * as part of a link setup process.
56  */
57 struct tipc_media_addr {
58         __be32  type;                   /* bearer type (network byte order) */
59         union {
60                 __u8   eth_addr[6];     /* 48 bit Ethernet addr (byte array) */
61         } dev_addr;
62 };
63
64 struct tipc_bearer;
65
66 /**
67  * struct media - TIPC media information available to internal users
68  * @send_msg: routine which handles buffer transmission
69  * @enable_bearer: routine which enables a bearer
70  * @disable_bearer: routine which disables a bearer
71  * @addr2str: routine which converts bearer's address to string form
72  * @bcast_addr: media address used in broadcasting
73  * @priority: default link (and bearer) priority
74  * @tolerance: default time (in ms) before declaring link failure
75  * @window: default window (in packets) before declaring link congestion
76  * @type_id: TIPC media identifier
77  * @name: media name
78  */
79
80 struct media {
81         int (*send_msg)(struct sk_buff *buf,
82                         struct tipc_bearer *b_ptr,
83                         struct tipc_media_addr *dest);
84         int (*enable_bearer)(struct tipc_bearer *b_ptr);
85         void (*disable_bearer)(struct tipc_bearer *b_ptr);
86         char *(*addr2str)(struct tipc_media_addr *a,
87                           char *str_buf, int str_size);
88         struct tipc_media_addr bcast_addr;
89         u32 priority;
90         u32 tolerance;
91         u32 window;
92         u32 type_id;
93         char name[TIPC_MAX_MEDIA_NAME];
94 };
95
96 /**
97  * struct tipc_bearer - TIPC bearer structure
98  * @usr_handle: pointer to additional media-specific information about bearer
99  * @mtu: max packet size bearer can support
100  * @blocked: non-zero if bearer is blocked
101  * @lock: spinlock for controlling access to bearer
102  * @addr: media-specific address associated with bearer
103  * @name: bearer name (format = media:interface)
104  * @media: ptr to media structure associated with bearer
105  * @priority: default link priority for bearer
106  * @identity: array index of this bearer within TIPC bearer array
107  * @link_req: ptr to (optional) structure making periodic link setup requests
108  * @links: list of non-congested links associated with bearer
109  * @cong_links: list of congested links associated with bearer
110  * @continue_count: # of times bearer has resumed after congestion or blocking
111  * @active: non-zero if bearer structure is represents a bearer
112  * @net_plane: network plane ('A' through 'H') currently associated with bearer
113  * @nodes: indicates which nodes in cluster can be reached through bearer
114  *
115  * Note: media-specific code is responsible for initialization of the fields
116  * indicated below when a bearer is enabled; TIPC's generic bearer code takes
117  * care of initializing all other fields.
118  */
119 struct tipc_bearer {
120         void *usr_handle;                       /* initalized by media */
121         u32 mtu;                                /* initalized by media */
122         int blocked;                            /* initalized by media */
123         struct tipc_media_addr addr;            /* initalized by media */
124         char name[TIPC_MAX_BEARER_NAME];
125         spinlock_t lock;
126         struct media *media;
127         u32 priority;
128         u32 identity;
129         struct link_req *link_req;
130         struct list_head links;
131         struct list_head cong_links;
132         u32 continue_count;
133         int active;
134         char net_plane;
135         struct tipc_node_map nodes;
136 };
137
138 struct bearer_name {
139         char media_name[TIPC_MAX_MEDIA_NAME];
140         char if_name[TIPC_MAX_IF_NAME];
141 };
142
143 struct link;
144
145 extern struct tipc_bearer tipc_bearers[];
146
147 /*
148  * TIPC routines available to supported media types
149  */
150 int tipc_register_media(u32 media_type,
151                  char *media_name, int (*enable)(struct tipc_bearer *),
152                  void (*disable)(struct tipc_bearer *),
153                  int (*send_msg)(struct sk_buff *,
154                         struct tipc_bearer *, struct tipc_media_addr *),
155                  char *(*addr2str)(struct tipc_media_addr *a,
156                         char *str_buf, int str_size),
157                  struct tipc_media_addr *bcast_addr, const u32 bearer_priority,
158                  const u32 link_tolerance,  /* [ms] */
159                  const u32 send_window_limit);
160
161 void tipc_recv_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr);
162
163 int  tipc_block_bearer(const char *name);
164 void tipc_continue(struct tipc_bearer *tb_ptr);
165
166 int tipc_enable_bearer(const char *bearer_name, u32 disc_domain, u32 priority);
167 int tipc_disable_bearer(const char *name);
168
169 /*
170  * Routines made available to TIPC by supported media types
171  */
172 int  tipc_eth_media_start(void);
173 void tipc_eth_media_stop(void);
174
175 void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a);
176 struct sk_buff *tipc_media_get_names(void);
177
178 struct sk_buff *tipc_bearer_get_names(void);
179 void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest);
180 void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest);
181 void tipc_bearer_schedule(struct tipc_bearer *b_ptr, struct link *l_ptr);
182 struct tipc_bearer *tipc_bearer_find_interface(const char *if_name);
183 int tipc_bearer_resolve_congestion(struct tipc_bearer *b_ptr, struct link *l_ptr);
184 int tipc_bearer_congested(struct tipc_bearer *b_ptr, struct link *l_ptr);
185 void tipc_bearer_stop(void);
186 void tipc_bearer_lock_push(struct tipc_bearer *b_ptr);
187
188
189 /**
190  * tipc_bearer_send- sends buffer to destination over bearer
191  *
192  * Returns true (1) if successful, or false (0) if unable to send
193  *
194  * IMPORTANT:
195  * The media send routine must not alter the buffer being passed in
196  * as it may be needed for later retransmission!
197  *
198  * If the media send routine returns a non-zero value (indicating that
199  * it was unable to send the buffer), it must:
200  *   1) mark the bearer as blocked,
201  *   2) call tipc_continue() once the bearer is able to send again.
202  * Media types that are unable to meet these two critera must ensure their
203  * send routine always returns success -- even if the buffer was not sent --
204  * and let TIPC's link code deal with the undelivered message.
205  */
206
207 static inline int tipc_bearer_send(struct tipc_bearer *b_ptr,
208                                    struct sk_buff *buf,
209                                    struct tipc_media_addr *dest)
210 {
211         return !b_ptr->media->send_msg(buf, b_ptr, dest);
212 }
213
214 #endif  /* _TIPC_BEARER_H */