thermal: fix Mediatek thermal controller build
[linux/fpc-iii.git] / net / tipc / name_distr.c
blobebe9d0ff6e9e9220621676e3384df3a28477d7a9
1 /*
2 * net/tipc/name_distr.c: TIPC name distribution code
4 * Copyright (c) 2000-2006, 2014, Ericsson AB
5 * Copyright (c) 2005, 2010-2011, Wind River Systems
6 * All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
37 #include "core.h"
38 #include "link.h"
39 #include "name_distr.h"
41 int sysctl_tipc_named_timeout __read_mostly = 2000;
43 /**
44 * struct tipc_dist_queue - queue holding deferred name table updates
46 static struct list_head tipc_dist_queue = LIST_HEAD_INIT(tipc_dist_queue);
48 struct distr_queue_item {
49 struct distr_item i;
50 u32 dtype;
51 u32 node;
52 unsigned long expires;
53 struct list_head next;
56 /**
57 * publ_to_item - add publication info to a publication message
59 static void publ_to_item(struct distr_item *i, struct publication *p)
61 i->type = htonl(p->type);
62 i->lower = htonl(p->lower);
63 i->upper = htonl(p->upper);
64 i->ref = htonl(p->ref);
65 i->key = htonl(p->key);
68 /**
69 * named_prepare_buf - allocate & initialize a publication message
71 static struct sk_buff *named_prepare_buf(struct net *net, u32 type, u32 size,
72 u32 dest)
74 struct tipc_net *tn = net_generic(net, tipc_net_id);
75 struct sk_buff *buf = tipc_buf_acquire(INT_H_SIZE + size);
76 struct tipc_msg *msg;
78 if (buf != NULL) {
79 msg = buf_msg(buf);
80 tipc_msg_init(tn->own_addr, msg, NAME_DISTRIBUTOR, type,
81 INT_H_SIZE, dest);
82 msg_set_size(msg, INT_H_SIZE + size);
84 return buf;
87 /**
88 * tipc_named_publish - tell other nodes about a new publication by this node
90 struct sk_buff *tipc_named_publish(struct net *net, struct publication *publ)
92 struct tipc_net *tn = net_generic(net, tipc_net_id);
93 struct sk_buff *buf;
94 struct distr_item *item;
96 list_add_tail_rcu(&publ->local_list,
97 &tn->nametbl->publ_list[publ->scope]);
99 if (publ->scope == TIPC_NODE_SCOPE)
100 return NULL;
102 buf = named_prepare_buf(net, PUBLICATION, ITEM_SIZE, 0);
103 if (!buf) {
104 pr_warn("Publication distribution failure\n");
105 return NULL;
108 item = (struct distr_item *)msg_data(buf_msg(buf));
109 publ_to_item(item, publ);
110 return buf;
114 * tipc_named_withdraw - tell other nodes about a withdrawn publication by this node
116 struct sk_buff *tipc_named_withdraw(struct net *net, struct publication *publ)
118 struct sk_buff *buf;
119 struct distr_item *item;
121 list_del(&publ->local_list);
123 if (publ->scope == TIPC_NODE_SCOPE)
124 return NULL;
126 buf = named_prepare_buf(net, WITHDRAWAL, ITEM_SIZE, 0);
127 if (!buf) {
128 pr_warn("Withdrawal distribution failure\n");
129 return NULL;
132 item = (struct distr_item *)msg_data(buf_msg(buf));
133 publ_to_item(item, publ);
134 return buf;
138 * named_distribute - prepare name info for bulk distribution to another node
139 * @list: list of messages (buffers) to be returned from this function
140 * @dnode: node to be updated
141 * @pls: linked list of publication items to be packed into buffer chain
143 static void named_distribute(struct net *net, struct sk_buff_head *list,
144 u32 dnode, struct list_head *pls)
146 struct publication *publ;
147 struct sk_buff *skb = NULL;
148 struct distr_item *item = NULL;
149 uint msg_dsz = (tipc_node_get_mtu(net, dnode, 0) / ITEM_SIZE) *
150 ITEM_SIZE;
151 uint msg_rem = msg_dsz;
153 list_for_each_entry(publ, pls, local_list) {
154 /* Prepare next buffer: */
155 if (!skb) {
156 skb = named_prepare_buf(net, PUBLICATION, msg_rem,
157 dnode);
158 if (!skb) {
159 pr_warn("Bulk publication failure\n");
160 return;
162 item = (struct distr_item *)msg_data(buf_msg(skb));
165 /* Pack publication into message: */
166 publ_to_item(item, publ);
167 item++;
168 msg_rem -= ITEM_SIZE;
170 /* Append full buffer to list: */
171 if (!msg_rem) {
172 __skb_queue_tail(list, skb);
173 skb = NULL;
174 msg_rem = msg_dsz;
177 if (skb) {
178 msg_set_size(buf_msg(skb), INT_H_SIZE + (msg_dsz - msg_rem));
179 skb_trim(skb, INT_H_SIZE + (msg_dsz - msg_rem));
180 __skb_queue_tail(list, skb);
185 * tipc_named_node_up - tell specified node about all publications by this node
187 void tipc_named_node_up(struct net *net, u32 dnode)
189 struct tipc_net *tn = net_generic(net, tipc_net_id);
190 struct sk_buff_head head;
192 __skb_queue_head_init(&head);
194 rcu_read_lock();
195 named_distribute(net, &head, dnode,
196 &tn->nametbl->publ_list[TIPC_CLUSTER_SCOPE]);
197 named_distribute(net, &head, dnode,
198 &tn->nametbl->publ_list[TIPC_ZONE_SCOPE]);
199 rcu_read_unlock();
201 tipc_node_xmit(net, &head, dnode, 0);
205 * tipc_publ_purge - remove publication associated with a failed node
207 * Invoked for each publication issued by a newly failed node.
208 * Removes publication structure from name table & deletes it.
210 static void tipc_publ_purge(struct net *net, struct publication *publ, u32 addr)
212 struct tipc_net *tn = net_generic(net, tipc_net_id);
213 struct publication *p;
215 spin_lock_bh(&tn->nametbl_lock);
216 p = tipc_nametbl_remove_publ(net, publ->type, publ->lower,
217 publ->node, publ->ref, publ->key);
218 if (p)
219 tipc_node_unsubscribe(net, &p->nodesub_list, addr);
220 spin_unlock_bh(&tn->nametbl_lock);
222 if (p != publ) {
223 pr_err("Unable to remove publication from failed node\n"
224 " (type=%u, lower=%u, node=0x%x, ref=%u, key=%u)\n",
225 publ->type, publ->lower, publ->node, publ->ref,
226 publ->key);
229 kfree_rcu(p, rcu);
232 void tipc_publ_notify(struct net *net, struct list_head *nsub_list, u32 addr)
234 struct publication *publ, *tmp;
236 list_for_each_entry_safe(publ, tmp, nsub_list, nodesub_list)
237 tipc_publ_purge(net, publ, addr);
241 * tipc_update_nametbl - try to process a nametable update and notify
242 * subscribers
244 * tipc_nametbl_lock must be held.
245 * Returns the publication item if successful, otherwise NULL.
247 static bool tipc_update_nametbl(struct net *net, struct distr_item *i,
248 u32 node, u32 dtype)
250 struct publication *publ = NULL;
252 if (dtype == PUBLICATION) {
253 publ = tipc_nametbl_insert_publ(net, ntohl(i->type),
254 ntohl(i->lower),
255 ntohl(i->upper),
256 TIPC_CLUSTER_SCOPE, node,
257 ntohl(i->ref), ntohl(i->key));
258 if (publ) {
259 tipc_node_subscribe(net, &publ->nodesub_list, node);
260 return true;
262 } else if (dtype == WITHDRAWAL) {
263 publ = tipc_nametbl_remove_publ(net, ntohl(i->type),
264 ntohl(i->lower),
265 node, ntohl(i->ref),
266 ntohl(i->key));
267 if (publ) {
268 tipc_node_unsubscribe(net, &publ->nodesub_list, node);
269 kfree_rcu(publ, rcu);
270 return true;
272 } else {
273 pr_warn("Unrecognized name table message received\n");
275 return false;
279 * tipc_named_add_backlog - add a failed name table update to the backlog
282 static void tipc_named_add_backlog(struct distr_item *i, u32 type, u32 node)
284 struct distr_queue_item *e;
285 unsigned long now = get_jiffies_64();
287 e = kzalloc(sizeof(*e), GFP_ATOMIC);
288 if (!e)
289 return;
290 e->dtype = type;
291 e->node = node;
292 e->expires = now + msecs_to_jiffies(sysctl_tipc_named_timeout);
293 memcpy(e, i, sizeof(*i));
294 list_add_tail(&e->next, &tipc_dist_queue);
298 * tipc_named_process_backlog - try to process any pending name table updates
299 * from the network.
301 void tipc_named_process_backlog(struct net *net)
303 struct distr_queue_item *e, *tmp;
304 char addr[16];
305 unsigned long now = get_jiffies_64();
307 list_for_each_entry_safe(e, tmp, &tipc_dist_queue, next) {
308 if (time_after(e->expires, now)) {
309 if (!tipc_update_nametbl(net, &e->i, e->node, e->dtype))
310 continue;
311 } else {
312 tipc_addr_string_fill(addr, e->node);
313 pr_warn_ratelimited("Dropping name table update (%d) of {%u, %u, %u} from %s key=%u\n",
314 e->dtype, ntohl(e->i.type),
315 ntohl(e->i.lower),
316 ntohl(e->i.upper),
317 addr, ntohl(e->i.key));
319 list_del(&e->next);
320 kfree(e);
325 * tipc_named_rcv - process name table update messages sent by another node
327 void tipc_named_rcv(struct net *net, struct sk_buff_head *inputq)
329 struct tipc_net *tn = net_generic(net, tipc_net_id);
330 struct tipc_msg *msg;
331 struct distr_item *item;
332 uint count;
333 u32 node;
334 struct sk_buff *skb;
335 int mtype;
337 spin_lock_bh(&tn->nametbl_lock);
338 for (skb = skb_dequeue(inputq); skb; skb = skb_dequeue(inputq)) {
339 skb_linearize(skb);
340 msg = buf_msg(skb);
341 mtype = msg_type(msg);
342 item = (struct distr_item *)msg_data(msg);
343 count = msg_data_sz(msg) / ITEM_SIZE;
344 node = msg_orignode(msg);
345 while (count--) {
346 if (!tipc_update_nametbl(net, item, node, mtype))
347 tipc_named_add_backlog(item, mtype, node);
348 item++;
350 kfree_skb(skb);
351 tipc_named_process_backlog(net);
353 spin_unlock_bh(&tn->nametbl_lock);
357 * tipc_named_reinit - re-initialize local publications
359 * This routine is called whenever TIPC networking is enabled.
360 * All name table entries published by this node are updated to reflect
361 * the node's new network address.
363 void tipc_named_reinit(struct net *net)
365 struct tipc_net *tn = net_generic(net, tipc_net_id);
366 struct publication *publ;
367 int scope;
369 spin_lock_bh(&tn->nametbl_lock);
371 for (scope = TIPC_ZONE_SCOPE; scope <= TIPC_NODE_SCOPE; scope++)
372 list_for_each_entry_rcu(publ, &tn->nametbl->publ_list[scope],
373 local_list)
374 publ->node = tn->own_addr;
376 spin_unlock_bh(&tn->nametbl_lock);