1 /* 2 * net/tipc/bcast.h: Include file for TIPC broadcast code 3 * 4 * Copyright (c) 2003-2006, Ericsson AB 5 * Copyright (c) 2005, 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_BCAST_H 38 #define _TIPC_BCAST_H 39 40 #define MAX_NODES 4096 41 #define WSIZE 32 42 43 /** 44 * struct node_map - set of node identifiers 45 * @count: # of nodes in set 46 * @map: bitmap of node identifiers that are in the set 47 */ 48 49 struct node_map { 50 u32 count; 51 u32 map[MAX_NODES / WSIZE]; 52 }; 53 54 55 #define PLSIZE 32 56 57 /** 58 * struct port_list - set of node local destination ports 59 * @count: # of ports in set (only valid for first entry in list) 60 * @next: pointer to next entry in list 61 * @ports: array of port references 62 */ 63 64 struct port_list { 65 int count; 66 struct port_list *next; 67 u32 ports[PLSIZE]; 68 }; 69 70 71 struct node; 72 73 extern char tipc_bclink_name[]; 74 75 76 /** 77 * nmap_get - determine if node exists in a node map 78 */ 79 80 static inline int tipc_nmap_get(struct node_map *nm_ptr, u32 node) 81 { 82 int n = tipc_node(node); 83 int w = n / WSIZE; 84 int b = n % WSIZE; 85 86 return nm_ptr->map[w] & (1 << b); 87 } 88 89 /** 90 * nmap_add - add a node to a node map 91 */ 92 93 static inline void tipc_nmap_add(struct node_map *nm_ptr, u32 node) 94 { 95 int n = tipc_node(node); 96 int w = n / WSIZE; 97 u32 mask = (1 << (n % WSIZE)); 98 99 if ((nm_ptr->map[w] & mask) == 0) { 100 nm_ptr->count++; 101 nm_ptr->map[w] |= mask; 102 } 103 } 104 105 /** 106 * nmap_remove - remove a node from a node map 107 */ 108 109 static inline void tipc_nmap_remove(struct node_map *nm_ptr, u32 node) 110 { 111 int n = tipc_node(node); 112 int w = n / WSIZE; 113 u32 mask = (1 << (n % WSIZE)); 114 115 if ((nm_ptr->map[w] & mask) != 0) { 116 nm_ptr->map[w] &= ~mask; 117 nm_ptr->count--; 118 } 119 } 120 121 /** 122 * nmap_equal - test for equality of node maps 123 */ 124 125 static inline int tipc_nmap_equal(struct node_map *nm_a, struct node_map *nm_b) 126 { 127 return !memcmp(nm_a, nm_b, sizeof(*nm_a)); 128 } 129 130 /** 131 * nmap_diff - find differences between node maps 132 * @nm_a: input node map A 133 * @nm_b: input node map B 134 * @nm_diff: output node map A-B (i.e. nodes of A that are not in B) 135 */ 136 137 static inline void tipc_nmap_diff(struct node_map *nm_a, struct node_map *nm_b, 138 struct node_map *nm_diff) 139 { 140 int stop = sizeof(nm_a->map) / sizeof(u32); 141 int w; 142 int b; 143 u32 map; 144 145 memset(nm_diff, 0, sizeof(*nm_diff)); 146 for (w = 0; w < stop; w++) { 147 map = nm_a->map[w] ^ (nm_a->map[w] & nm_b->map[w]); 148 nm_diff->map[w] = map; 149 if (map != 0) { 150 for (b = 0 ; b < WSIZE; b++) { 151 if (map & (1 << b)) 152 nm_diff->count++; 153 } 154 } 155 } 156 } 157 158 /** 159 * port_list_add - add a port to a port list, ensuring no duplicates 160 */ 161 162 static inline void tipc_port_list_add(struct port_list *pl_ptr, u32 port) 163 { 164 struct port_list *item = pl_ptr; 165 int i; 166 int item_sz = PLSIZE; 167 int cnt = pl_ptr->count; 168 169 for (; ; cnt -= item_sz, item = item->next) { 170 if (cnt < PLSIZE) 171 item_sz = cnt; 172 for (i = 0; i < item_sz; i++) 173 if (item->ports[i] == port) 174 return; 175 if (i < PLSIZE) { 176 item->ports[i] = port; 177 pl_ptr->count++; 178 return; 179 } 180 if (!item->next) { 181 item->next = kmalloc(sizeof(*item), GFP_ATOMIC); 182 if (!item->next) { 183 warn("Incomplete multicast delivery, no memory\n"); 184 return; 185 } 186 item->next->next = NULL; 187 } 188 } 189 } 190 191 /** 192 * port_list_free - free dynamically created entries in port_list chain 193 * 194 * Note: First item is on stack, so it doesn't need to be released 195 */ 196 197 static inline void tipc_port_list_free(struct port_list *pl_ptr) 198 { 199 struct port_list *item; 200 struct port_list *next; 201 202 for (item = pl_ptr->next; item; item = next) { 203 next = item->next; 204 kfree(item); 205 } 206 } 207 208 209 int tipc_bclink_init(void); 210 void tipc_bclink_stop(void); 211 void tipc_bclink_acknowledge(struct node *n_ptr, u32 acked); 212 int tipc_bclink_send_msg(struct sk_buff *buf); 213 void tipc_bclink_recv_pkt(struct sk_buff *buf); 214 u32 tipc_bclink_get_last_sent(void); 215 u32 tipc_bclink_acks_missing(struct node *n_ptr); 216 void tipc_bclink_check_gap(struct node *n_ptr, u32 seqno); 217 int tipc_bclink_stats(char *stats_buf, const u32 buf_size); 218 int tipc_bclink_reset_stats(void); 219 int tipc_bclink_set_queue_limits(u32 limit); 220 void tipc_bcbearer_sort(void); 221 void tipc_bcbearer_push(void); 222 223 #endif 224