?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
xtensa: avoid duplicate of IO range definitions
[linux-2.6/btrfs-unstable.git] / net / tipc / port.c
blobc081a7632302ca0798c193b039214466c3180184
1 /*
2 * net/tipc/port.c: TIPC port code
3 *
4 * Copyright (c) 1992-2007, Ericsson AB
5 * Copyright (c) 2004-2008, 2010-2013, 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 #include "core.h"
38 #include "config.h"
39 #include "port.h"
40 #include "name_table.h"
41
42 /* Connection management: */
43 #define PROBING_INTERVAL 3600000 /* [ms] => 1 h */
44 #define CONFIRMED 0
45 #define PROBING 1
46
47 #define MAX_REJECT_SIZE 1024
48
49 DEFINE_SPINLOCK(tipc_port_list_lock);
50
51 static LIST_HEAD(ports);
52 static void port_handle_node_down(unsigned long ref);
53 static struct sk_buff *port_build_self_abort_msg(struct tipc_port *, u32 err);
54 static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *, u32 err);
55 static void port_timeout(unsigned long ref);
56
57
58 static u32 port_peernode(struct tipc_port *p_ptr)
59 {
60 return msg_destnode(&p_ptr->phdr);
61 }
62
63 static u32 port_peerport(struct tipc_port *p_ptr)
64 {
65 return msg_destport(&p_ptr->phdr);
66 }
67
68 /**
69 * tipc_port_peer_msg - verify message was sent by connected port's peer
70 *
71 * Handles cases where the node's network address has changed from
72 * the default of <0.0.0> to its configured setting.
73 */
74 int tipc_port_peer_msg(struct tipc_port *p_ptr, struct tipc_msg *msg)
75 {
76 u32 peernode;
77 u32 orignode;
78
79 if (msg_origport(msg) != port_peerport(p_ptr))
80 return 0;
81
82 orignode = msg_orignode(msg);
83 peernode = port_peernode(p_ptr);
84 return (orignode == peernode) ||
85 (!orignode && (peernode == tipc_own_addr)) ||
86 (!peernode && (orignode == tipc_own_addr));
87 }
88
89 /**
90 * tipc_multicast - send a multicast message to local and remote destinations
91 */
92 int tipc_multicast(u32 ref, struct tipc_name_seq const *seq,
93 struct iovec const *msg_sect, unsigned int len)
94 {
95 struct tipc_msg *hdr;
96 struct sk_buff *buf;
97 struct sk_buff *ibuf = NULL;
98 struct tipc_port_list dports = {0, NULL, };
99 struct tipc_port *oport = tipc_port_deref(ref);
100 int ext_targets;
101 int res;
102
103 if (unlikely(!oport))
104 return -EINVAL;
105
106 /* Create multicast message */
107 hdr = &oport->phdr;
108 msg_set_type(hdr, TIPC_MCAST_MSG);
109 msg_set_lookup_scope(hdr, TIPC_CLUSTER_SCOPE);
110 msg_set_destport(hdr, 0);
111 msg_set_destnode(hdr, 0);
112 msg_set_nametype(hdr, seq->type);
113 msg_set_namelower(hdr, seq->lower);
114 msg_set_nameupper(hdr, seq->upper);
115 msg_set_hdr_sz(hdr, MCAST_H_SIZE);
116 res = tipc_msg_build(hdr, msg_sect, len, MAX_MSG_SIZE, &buf);
117 if (unlikely(!buf))
118 return res;
119
120 /* Figure out where to send multicast message */
121 ext_targets = tipc_nametbl_mc_translate(seq->type, seq->lower, seq->upper,
122 TIPC_NODE_SCOPE, &dports);
123
124 /* Send message to destinations (duplicate it only if necessary) */
125 if (ext_targets) {
126 if (dports.count != 0) {
127 ibuf = skb_copy(buf, GFP_ATOMIC);
128 if (ibuf == NULL) {
129 tipc_port_list_free(&dports);
130 kfree_skb(buf);
131 return -ENOMEM;
132 }
133 }
134 res = tipc_bclink_send_msg(buf);
135 if ((res < 0) && (dports.count != 0))
136 kfree_skb(ibuf);
137 } else {
138 ibuf = buf;
139 }
140
141 if (res >= 0) {
142 if (ibuf)
143 tipc_port_recv_mcast(ibuf, &dports);
144 } else {
145 tipc_port_list_free(&dports);
146 }
147 return res;
148 }
149
150 /**
151 * tipc_port_recv_mcast - deliver multicast message to all destination ports
152 *
153 * If there is no port list, perform a lookup to create one
154 */
155 void tipc_port_recv_mcast(struct sk_buff *buf, struct tipc_port_list *dp)
156 {
157 struct tipc_msg *msg;
158 struct tipc_port_list dports = {0, NULL, };
159 struct tipc_port_list *item = dp;
160 int cnt = 0;
161
162 msg = buf_msg(buf);
163
164 /* Create destination port list, if one wasn't supplied */
165 if (dp == NULL) {
166 tipc_nametbl_mc_translate(msg_nametype(msg),
167 msg_namelower(msg),
168 msg_nameupper(msg),
169 TIPC_CLUSTER_SCOPE,
170 &dports);
171 item = dp = &dports;
172 }
173
174 /* Deliver a copy of message to each destination port */
175 if (dp->count != 0) {
176 msg_set_destnode(msg, tipc_own_addr);
177 if (dp->count == 1) {
178 msg_set_destport(msg, dp->ports[0]);
179 tipc_port_recv_msg(buf);
180 tipc_port_list_free(dp);
181 return;
182 }
183 for (; cnt < dp->count; cnt++) {
184 int index = cnt % PLSIZE;
185 struct sk_buff *b = skb_clone(buf, GFP_ATOMIC);
186
187 if (b == NULL) {
188 pr_warn("Unable to deliver multicast message(s)\n");
189 goto exit;
190 }
191 if ((index == 0) && (cnt != 0))
192 item = item->next;
193 msg_set_destport(buf_msg(b), item->ports[index]);
194 tipc_port_recv_msg(b);
195 }
196 }
197 exit:
198 kfree_skb(buf);
199 tipc_port_list_free(dp);
200 }
201
202 /**
203 * tipc_createport - create a generic TIPC port
204 *
205 * Returns pointer to (locked) TIPC port, or NULL if unable to create it
206 */
207 struct tipc_port *tipc_createport(struct sock *sk,
208 u32 (*dispatcher)(struct tipc_port *,
209 struct sk_buff *),
210 void (*wakeup)(struct tipc_port *),
211 const u32 importance)
212 {
213 struct tipc_port *p_ptr;
214 struct tipc_msg *msg;
215 u32 ref;
216
217 p_ptr = kzalloc(sizeof(*p_ptr), GFP_ATOMIC);
218 if (!p_ptr) {
219 pr_warn("Port creation failed, no memory\n");
220 return NULL;
221 }
222 ref = tipc_ref_acquire(p_ptr, &p_ptr->lock);
223 if (!ref) {
224 pr_warn("Port creation failed, ref. table exhausted\n");
225 kfree(p_ptr);
226 return NULL;
227 }
228
229 p_ptr->sk = sk;
230 p_ptr->max_pkt = MAX_PKT_DEFAULT;
231 p_ptr->ref = ref;
232 INIT_LIST_HEAD(&p_ptr->wait_list);
233 INIT_LIST_HEAD(&p_ptr->subscription.nodesub_list);
234 p_ptr->dispatcher = dispatcher;
235 p_ptr->wakeup = wakeup;
236 k_init_timer(&p_ptr->timer, (Handler)port_timeout, ref);
237 INIT_LIST_HEAD(&p_ptr->publications);
238 INIT_LIST_HEAD(&p_ptr->port_list);
239
240 /*
241 * Must hold port list lock while initializing message header template
242 * to ensure a change to node's own network address doesn't result
243 * in template containing out-dated network address information
244 */
245 spin_lock_bh(&tipc_port_list_lock);
246 msg = &p_ptr->phdr;
247 tipc_msg_init(msg, importance, TIPC_NAMED_MSG, NAMED_H_SIZE, 0);
248 msg_set_origport(msg, ref);
249 list_add_tail(&p_ptr->port_list, &ports);
250 spin_unlock_bh(&tipc_port_list_lock);
251 return p_ptr;
252 }
253
254 int tipc_deleteport(u32 ref)
255 {
256 struct tipc_port *p_ptr;
257 struct sk_buff *buf = NULL;
258
259 tipc_withdraw(ref, 0, NULL);
260 p_ptr = tipc_port_lock(ref);
261 if (!p_ptr)
262 return -EINVAL;
263
264 tipc_ref_discard(ref);
265 tipc_port_unlock(p_ptr);
266
267 k_cancel_timer(&p_ptr->timer);
268 if (p_ptr->connected) {
269 buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
270 tipc_nodesub_unsubscribe(&p_ptr->subscription);
271 }
272
273 spin_lock_bh(&tipc_port_list_lock);
274 list_del(&p_ptr->port_list);
275 list_del(&p_ptr->wait_list);
276 spin_unlock_bh(&tipc_port_list_lock);
277 k_term_timer(&p_ptr->timer);
278 kfree(p_ptr);
279 tipc_net_route_msg(buf);
280 return 0;
281 }
282
283 static int port_unreliable(struct tipc_port *p_ptr)
284 {
285 return msg_src_droppable(&p_ptr->phdr);
286 }
287
288 int tipc_portunreliable(u32 ref, unsigned int *isunreliable)
289 {
290 struct tipc_port *p_ptr;
291
292 p_ptr = tipc_port_lock(ref);
293 if (!p_ptr)
294 return -EINVAL;
295 *isunreliable = port_unreliable(p_ptr);
296 tipc_port_unlock(p_ptr);
297 return 0;
298 }
299
300 int tipc_set_portunreliable(u32 ref, unsigned int isunreliable)
301 {
302 struct tipc_port *p_ptr;
303
304 p_ptr = tipc_port_lock(ref);
305 if (!p_ptr)
306 return -EINVAL;
307 msg_set_src_droppable(&p_ptr->phdr, (isunreliable != 0));
308 tipc_port_unlock(p_ptr);
309 return 0;
310 }
311
312 static int port_unreturnable(struct tipc_port *p_ptr)
313 {
314 return msg_dest_droppable(&p_ptr->phdr);
315 }
316
317 int tipc_portunreturnable(u32 ref, unsigned int *isunrejectable)
318 {
319 struct tipc_port *p_ptr;
320
321 p_ptr = tipc_port_lock(ref);
322 if (!p_ptr)
323 return -EINVAL;
324 *isunrejectable = port_unreturnable(p_ptr);
325 tipc_port_unlock(p_ptr);
326 return 0;
327 }
328
329 int tipc_set_portunreturnable(u32 ref, unsigned int isunrejectable)
330 {
331 struct tipc_port *p_ptr;
332
333 p_ptr = tipc_port_lock(ref);
334 if (!p_ptr)
335 return -EINVAL;
336 msg_set_dest_droppable(&p_ptr->phdr, (isunrejectable != 0));
337 tipc_port_unlock(p_ptr);
338 return 0;
339 }
340
341 /*
342 * port_build_proto_msg(): create connection protocol message for port
343 *
344 * On entry the port must be locked and connected.
345 */
346 static struct sk_buff *port_build_proto_msg(struct tipc_port *p_ptr,
347 u32 type, u32 ack)
348 {
349 struct sk_buff *buf;
350 struct tipc_msg *msg;
351
352 buf = tipc_buf_acquire(INT_H_SIZE);
353 if (buf) {
354 msg = buf_msg(buf);
355 tipc_msg_init(msg, CONN_MANAGER, type, INT_H_SIZE,
356 port_peernode(p_ptr));
357 msg_set_destport(msg, port_peerport(p_ptr));
358 msg_set_origport(msg, p_ptr->ref);
359 msg_set_msgcnt(msg, ack);
360 }
361 return buf;
362 }
363
364 int tipc_reject_msg(struct sk_buff *buf, u32 err)
365 {
366 struct tipc_msg *msg = buf_msg(buf);
367 struct sk_buff *rbuf;
368 struct tipc_msg *rmsg;
369 int hdr_sz;
370 u32 imp;
371 u32 data_sz = msg_data_sz(msg);
372 u32 src_node;
373 u32 rmsg_sz;
374
375 /* discard rejected message if it shouldn't be returned to sender */
376 if (WARN(!msg_isdata(msg),
377 "attempt to reject message with user=%u", msg_user(msg))) {
378 dump_stack();
379 goto exit;
380 }
381 if (msg_errcode(msg) || msg_dest_droppable(msg))
382 goto exit;
383
384 /*
385 * construct returned message by copying rejected message header and
386 * data (or subset), then updating header fields that need adjusting
387 */
388 hdr_sz = msg_hdr_sz(msg);
389 rmsg_sz = hdr_sz + min_t(u32, data_sz, MAX_REJECT_SIZE);
390
391 rbuf = tipc_buf_acquire(rmsg_sz);
392 if (rbuf == NULL)
393 goto exit;
394
395 rmsg = buf_msg(rbuf);
396 skb_copy_to_linear_data(rbuf, msg, rmsg_sz);
397
398 if (msg_connected(rmsg)) {
399 imp = msg_importance(rmsg);
400 if (imp < TIPC_CRITICAL_IMPORTANCE)
401 msg_set_importance(rmsg, ++imp);
402 }
403 msg_set_non_seq(rmsg, 0);
404 msg_set_size(rmsg, rmsg_sz);
405 msg_set_errcode(rmsg, err);
406 msg_set_prevnode(rmsg, tipc_own_addr);
407 msg_swap_words(rmsg, 4, 5);
408 if (!msg_short(rmsg))
409 msg_swap_words(rmsg, 6, 7);
410
411 /* send self-abort message when rejecting on a connected port */
412 if (msg_connected(msg)) {
413 struct tipc_port *p_ptr = tipc_port_lock(msg_destport(msg));
414
415 if (p_ptr) {
416 struct sk_buff *abuf = NULL;
417
418 if (p_ptr->connected)
419 abuf = port_build_self_abort_msg(p_ptr, err);
420 tipc_port_unlock(p_ptr);
421 tipc_net_route_msg(abuf);
422 }
423 }
424
425 /* send returned message & dispose of rejected message */
426 src_node = msg_prevnode(msg);
427 if (in_own_node(src_node))
428 tipc_port_recv_msg(rbuf);
429 else
430 tipc_link_send(rbuf, src_node, msg_link_selector(rmsg));
431 exit:
432 kfree_skb(buf);
433 return data_sz;
434 }
435
436 int tipc_port_reject_sections(struct tipc_port *p_ptr, struct tipc_msg *hdr,
437 struct iovec const *msg_sect, unsigned int len,
438 int err)
439 {
440 struct sk_buff *buf;
441 int res;
442
443 res = tipc_msg_build(hdr, msg_sect, len, MAX_MSG_SIZE, &buf);
444 if (!buf)
445 return res;
446
447 return tipc_reject_msg(buf, err);
448 }
449
450 static void port_timeout(unsigned long ref)
451 {
452 struct tipc_port *p_ptr = tipc_port_lock(ref);
453 struct sk_buff *buf = NULL;
454
455 if (!p_ptr)
456 return;
457
458 if (!p_ptr->connected) {
459 tipc_port_unlock(p_ptr);
460 return;
461 }
462
463 /* Last probe answered ? */
464 if (p_ptr->probing_state == PROBING) {
465 buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
466 } else {
467 buf = port_build_proto_msg(p_ptr, CONN_PROBE, 0);
468 p_ptr->probing_state = PROBING;
469 k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
470 }
471 tipc_port_unlock(p_ptr);
472 tipc_net_route_msg(buf);
473 }
474
475
476 static void port_handle_node_down(unsigned long ref)
477 {
478 struct tipc_port *p_ptr = tipc_port_lock(ref);
479 struct sk_buff *buf = NULL;
480
481 if (!p_ptr)
482 return;
483 buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_NODE);
484 tipc_port_unlock(p_ptr);
485 tipc_net_route_msg(buf);
486 }
487
488
489 static struct sk_buff *port_build_self_abort_msg(struct tipc_port *p_ptr, u32 err)
490 {
491 struct sk_buff *buf = port_build_peer_abort_msg(p_ptr, err);
492
493 if (buf) {
494 struct tipc_msg *msg = buf_msg(buf);
495 msg_swap_words(msg, 4, 5);
496 msg_swap_words(msg, 6, 7);
497 }
498 return buf;
499 }
500
501
502 static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *p_ptr, u32 err)
503 {
504 struct sk_buff *buf;
505 struct tipc_msg *msg;
506 u32 imp;
507
508 if (!p_ptr->connected)
509 return NULL;
510
511 buf = tipc_buf_acquire(BASIC_H_SIZE);
512 if (buf) {
513 msg = buf_msg(buf);
514 memcpy(msg, &p_ptr->phdr, BASIC_H_SIZE);
515 msg_set_hdr_sz(msg, BASIC_H_SIZE);
516 msg_set_size(msg, BASIC_H_SIZE);
517 imp = msg_importance(msg);
518 if (imp < TIPC_CRITICAL_IMPORTANCE)
519 msg_set_importance(msg, ++imp);
520 msg_set_errcode(msg, err);
521 }
522 return buf;
523 }
524
525 void tipc_port_recv_proto_msg(struct sk_buff *buf)
526 {
527 struct tipc_msg *msg = buf_msg(buf);
528 struct tipc_port *p_ptr;
529 struct sk_buff *r_buf = NULL;
530 u32 destport = msg_destport(msg);
531 int wakeable;
532
533 /* Validate connection */
534 p_ptr = tipc_port_lock(destport);
535 if (!p_ptr || !p_ptr->connected || !tipc_port_peer_msg(p_ptr, msg)) {
536 r_buf = tipc_buf_acquire(BASIC_H_SIZE);
537 if (r_buf) {
538 msg = buf_msg(r_buf);
539 tipc_msg_init(msg, TIPC_HIGH_IMPORTANCE, TIPC_CONN_MSG,
540 BASIC_H_SIZE, msg_orignode(msg));
541 msg_set_errcode(msg, TIPC_ERR_NO_PORT);
542 msg_set_origport(msg, destport);
543 msg_set_destport(msg, msg_origport(msg));
544 }
545 if (p_ptr)
546 tipc_port_unlock(p_ptr);
547 goto exit;
548 }
549
550 /* Process protocol message sent by peer */
551 switch (msg_type(msg)) {
552 case CONN_ACK:
553 wakeable = tipc_port_congested(p_ptr) && p_ptr->congested &&
554 p_ptr->wakeup;
555 p_ptr->acked += msg_msgcnt(msg);
556 if (!tipc_port_congested(p_ptr)) {
557 p_ptr->congested = 0;
558 if (wakeable)
559 p_ptr->wakeup(p_ptr);
560 }
561 break;
562 case CONN_PROBE:
563 r_buf = port_build_proto_msg(p_ptr, CONN_PROBE_REPLY, 0);
564 break;
565 default:
566 /* CONN_PROBE_REPLY or unrecognized - no action required */
567 break;
568 }
569 p_ptr->probing_state = CONFIRMED;
570 tipc_port_unlock(p_ptr);
571 exit:
572 tipc_net_route_msg(r_buf);
573 kfree_skb(buf);
574 }
575
576 static int port_print(struct tipc_port *p_ptr, char *buf, int len, int full_id)
577 {
578 struct publication *publ;
579 int ret;
580
581 if (full_id)
582 ret = tipc_snprintf(buf, len, "<%u.%u.%u:%u>:",
583 tipc_zone(tipc_own_addr),
584 tipc_cluster(tipc_own_addr),
585 tipc_node(tipc_own_addr), p_ptr->ref);
586 else
587 ret = tipc_snprintf(buf, len, "%-10u:", p_ptr->ref);
588
589 if (p_ptr->connected) {
590 u32 dport = port_peerport(p_ptr);
591 u32 destnode = port_peernode(p_ptr);
592
593 ret += tipc_snprintf(buf + ret, len - ret,
594 " connected to <%u.%u.%u:%u>",
595 tipc_zone(destnode),
596 tipc_cluster(destnode),
597 tipc_node(destnode), dport);
598 if (p_ptr->conn_type != 0)
599 ret += tipc_snprintf(buf + ret, len - ret,
600 " via {%u,%u}", p_ptr->conn_type,
601 p_ptr->conn_instance);
602 } else if (p_ptr->published) {
603 ret += tipc_snprintf(buf + ret, len - ret, " bound to");
604 list_for_each_entry(publ, &p_ptr->publications, pport_list) {
605 if (publ->lower == publ->upper)
606 ret += tipc_snprintf(buf + ret, len - ret,
607 " {%u,%u}", publ->type,
608 publ->lower);
609 else
610 ret += tipc_snprintf(buf + ret, len - ret,
611 " {%u,%u,%u}", publ->type,
612 publ->lower, publ->upper);
613 }
614 }
615 ret += tipc_snprintf(buf + ret, len - ret, "\n");
616 return ret;
617 }
618
619 struct sk_buff *tipc_port_get_ports(void)
620 {
621 struct sk_buff *buf;
622 struct tlv_desc *rep_tlv;
623 char *pb;
624 int pb_len;
625 struct tipc_port *p_ptr;
626 int str_len = 0;
627
628 buf = tipc_cfg_reply_alloc(TLV_SPACE(ULTRA_STRING_MAX_LEN));
629 if (!buf)
630 return NULL;
631 rep_tlv = (struct tlv_desc *)buf->data;
632 pb = TLV_DATA(rep_tlv);
633 pb_len = ULTRA_STRING_MAX_LEN;
634
635 spin_lock_bh(&tipc_port_list_lock);
636 list_for_each_entry(p_ptr, &ports, port_list) {
637 spin_lock_bh(p_ptr->lock);
638 str_len += port_print(p_ptr, pb, pb_len, 0);
639 spin_unlock_bh(p_ptr->lock);
640 }
641 spin_unlock_bh(&tipc_port_list_lock);
642 str_len += 1; /* for "\0" */
643 skb_put(buf, TLV_SPACE(str_len));
644 TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
645
646 return buf;
647 }
648
649 void tipc_port_reinit(void)
650 {
651 struct tipc_port *p_ptr;
652 struct tipc_msg *msg;
653
654 spin_lock_bh(&tipc_port_list_lock);
655 list_for_each_entry(p_ptr, &ports, port_list) {
656 msg = &p_ptr->phdr;
657 msg_set_prevnode(msg, tipc_own_addr);
658 msg_set_orignode(msg, tipc_own_addr);
659 }
660 spin_unlock_bh(&tipc_port_list_lock);
661 }
662
663 void tipc_acknowledge(u32 ref, u32 ack)
664 {
665 struct tipc_port *p_ptr;
666 struct sk_buff *buf = NULL;
667
668 p_ptr = tipc_port_lock(ref);
669 if (!p_ptr)
670 return;
671 if (p_ptr->connected) {
672 p_ptr->conn_unacked -= ack;
673 buf = port_build_proto_msg(p_ptr, CONN_ACK, ack);
674 }
675 tipc_port_unlock(p_ptr);
676 tipc_net_route_msg(buf);
677 }
678
679 int tipc_portimportance(u32 ref, unsigned int *importance)
680 {
681 struct tipc_port *p_ptr;
682
683 p_ptr = tipc_port_lock(ref);
684 if (!p_ptr)
685 return -EINVAL;
686 *importance = (unsigned int)msg_importance(&p_ptr->phdr);
687 tipc_port_unlock(p_ptr);
688 return 0;
689 }
690
691 int tipc_set_portimportance(u32 ref, unsigned int imp)
692 {
693 struct tipc_port *p_ptr;
694
695 if (imp > TIPC_CRITICAL_IMPORTANCE)
696 return -EINVAL;
697
698 p_ptr = tipc_port_lock(ref);
699 if (!p_ptr)
700 return -EINVAL;
701 msg_set_importance(&p_ptr->phdr, (u32)imp);
702 tipc_port_unlock(p_ptr);
703 return 0;
704 }
705
706
707 int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
708 {
709 struct tipc_port *p_ptr;
710 struct publication *publ;
711 u32 key;
712 int res = -EINVAL;
713
714 p_ptr = tipc_port_lock(ref);
715 if (!p_ptr)
716 return -EINVAL;
717
718 if (p_ptr->connected)
719 goto exit;
720 key = ref + p_ptr->pub_count + 1;
721 if (key == ref) {
722 res = -EADDRINUSE;
723 goto exit;
724 }
725 publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper,
726 scope, p_ptr->ref, key);
727 if (publ) {
728 list_add(&publ->pport_list, &p_ptr->publications);
729 p_ptr->pub_count++;
730 p_ptr->published = 1;
731 res = 0;
732 }
733 exit:
734 tipc_port_unlock(p_ptr);
735 return res;
736 }
737
738 int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
739 {
740 struct tipc_port *p_ptr;
741 struct publication *publ;
742 struct publication *tpubl;
743 int res = -EINVAL;
744
745 p_ptr = tipc_port_lock(ref);
746 if (!p_ptr)
747 return -EINVAL;
748 if (!seq) {
749 list_for_each_entry_safe(publ, tpubl,
750 &p_ptr->publications, pport_list) {
751 tipc_nametbl_withdraw(publ->type, publ->lower,
752 publ->ref, publ->key);
753 }
754 res = 0;
755 } else {
756 list_for_each_entry_safe(publ, tpubl,
757 &p_ptr->publications, pport_list) {
758 if (publ->scope != scope)
759 continue;
760 if (publ->type != seq->type)
761 continue;
762 if (publ->lower != seq->lower)
763 continue;
764 if (publ->upper != seq->upper)
765 break;
766 tipc_nametbl_withdraw(publ->type, publ->lower,
767 publ->ref, publ->key);
768 res = 0;
769 break;
770 }
771 }
772 if (list_empty(&p_ptr->publications))
773 p_ptr->published = 0;
774 tipc_port_unlock(p_ptr);
775 return res;
776 }
777
778 int tipc_connect(u32 ref, struct tipc_portid const *peer)
779 {
780 struct tipc_port *p_ptr;
781 int res;
782
783 p_ptr = tipc_port_lock(ref);
784 if (!p_ptr)
785 return -EINVAL;
786 res = __tipc_connect(ref, p_ptr, peer);
787 tipc_port_unlock(p_ptr);
788 return res;
789 }
790
791 /*
792 * __tipc_connect - connect to a remote peer
793 *
794 * Port must be locked.
795 */
796 int __tipc_connect(u32 ref, struct tipc_port *p_ptr,
797 struct tipc_portid const *peer)
798 {
799 struct tipc_msg *msg;
800 int res = -EINVAL;
801
802 if (p_ptr->published || p_ptr->connected)
803 goto exit;
804 if (!peer->ref)
805 goto exit;
806
807 msg = &p_ptr->phdr;
808 msg_set_destnode(msg, peer->node);
809 msg_set_destport(msg, peer->ref);
810 msg_set_type(msg, TIPC_CONN_MSG);
811 msg_set_lookup_scope(msg, 0);
812 msg_set_hdr_sz(msg, SHORT_H_SIZE);
813
814 p_ptr->probing_interval = PROBING_INTERVAL;
815 p_ptr->probing_state = CONFIRMED;
816 p_ptr->connected = 1;
817 k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
818
819 tipc_nodesub_subscribe(&p_ptr->subscription, peer->node,
820 (void *)(unsigned long)ref,
821 (net_ev_handler)port_handle_node_down);
822 res = 0;
823 exit:
824 p_ptr->max_pkt = tipc_link_get_max_pkt(peer->node, ref);
825 return res;
826 }
827
828 /*
829 * __tipc_disconnect - disconnect port from peer
830 *
831 * Port must be locked.
832 */
833 int __tipc_disconnect(struct tipc_port *tp_ptr)
834 {
835 int res;
836
837 if (tp_ptr->connected) {
838 tp_ptr->connected = 0;
839 /* let timer expire on it's own to avoid deadlock! */
840 tipc_nodesub_unsubscribe(&tp_ptr->subscription);
841 res = 0;
842 } else {
843 res = -ENOTCONN;
844 }
845 return res;
846 }
847
848 /*
849 * tipc_disconnect(): Disconnect port form peer.
850 * This is a node local operation.
851 */
852 int tipc_disconnect(u32 ref)
853 {
854 struct tipc_port *p_ptr;
855 int res;
856
857 p_ptr = tipc_port_lock(ref);
858 if (!p_ptr)
859 return -EINVAL;
860 res = __tipc_disconnect(p_ptr);
861 tipc_port_unlock(p_ptr);
862 return res;
863 }
864
865 /*
866 * tipc_shutdown(): Send a SHUTDOWN msg to peer and disconnect
867 */
868 int tipc_shutdown(u32 ref)
869 {
870 struct tipc_port *p_ptr;
871 struct sk_buff *buf = NULL;
872
873 p_ptr = tipc_port_lock(ref);
874 if (!p_ptr)
875 return -EINVAL;
876
877 buf = port_build_peer_abort_msg(p_ptr, TIPC_CONN_SHUTDOWN);
878 tipc_port_unlock(p_ptr);
879 tipc_net_route_msg(buf);
880 return tipc_disconnect(ref);
881 }
882
883 /**
884 * tipc_port_recv_msg - receive message from lower layer and deliver to port user
885 */
886 int tipc_port_recv_msg(struct sk_buff *buf)
887 {
888 struct tipc_port *p_ptr;
889 struct tipc_msg *msg = buf_msg(buf);
890 u32 destport = msg_destport(msg);
891 u32 dsz = msg_data_sz(msg);
892 u32 err;
893
894 /* forward unresolved named message */
895 if (unlikely(!destport)) {
896 tipc_net_route_msg(buf);
897 return dsz;
898 }
899
900 /* validate destination & pass to port, otherwise reject message */
901 p_ptr = tipc_port_lock(destport);
902 if (likely(p_ptr)) {
903 err = p_ptr->dispatcher(p_ptr, buf);
904 tipc_port_unlock(p_ptr);
905 if (likely(!err))
906 return dsz;
907 } else {
908 err = TIPC_ERR_NO_PORT;
909 }
910
911 return tipc_reject_msg(buf, err);
912 }
913
914 /*
915 * tipc_port_recv_sections(): Concatenate and deliver sectioned
916 * message for this node.
917 */
918 static int tipc_port_recv_sections(struct tipc_port *sender,
919 struct iovec const *msg_sect,
920 unsigned int len)
921 {
922 struct sk_buff *buf;
923 int res;
924
925 res = tipc_msg_build(&sender->phdr, msg_sect, len, MAX_MSG_SIZE, &buf);
926 if (likely(buf))
927 tipc_port_recv_msg(buf);
928 return res;
929 }
930
931 /**
932 * tipc_send - send message sections on connection
933 */
934 int tipc_send(u32 ref, struct iovec const *msg_sect, unsigned int len)
935 {
936 struct tipc_port *p_ptr;
937 u32 destnode;
938 int res;
939
940 p_ptr = tipc_port_deref(ref);
941 if (!p_ptr || !p_ptr->connected)
942 return -EINVAL;
943
944 p_ptr->congested = 1;
945 if (!tipc_port_congested(p_ptr)) {
946 destnode = port_peernode(p_ptr);
947 if (likely(!in_own_node(destnode)))
948 res = tipc_link_send_sections_fast(p_ptr, msg_sect,
949 len, destnode);
950 else
951 res = tipc_port_recv_sections(p_ptr, msg_sect, len);
952
953 if (likely(res != -ELINKCONG)) {
954 p_ptr->congested = 0;
955 if (res > 0)
956 p_ptr->sent++;
957 return res;
958 }
959 }
960 if (port_unreliable(p_ptr)) {
961 p_ptr->congested = 0;
962 return len;
963 }
964 return -ELINKCONG;
965 }
966
967 /**
968 * tipc_send2name - send message sections to port name
969 */
970 int tipc_send2name(u32 ref, struct tipc_name const *name, unsigned int domain,
971 struct iovec const *msg_sect, unsigned int len)
972 {
973 struct tipc_port *p_ptr;
974 struct tipc_msg *msg;
975 u32 destnode = domain;
976 u32 destport;
977 int res;
978
979 p_ptr = tipc_port_deref(ref);
980 if (!p_ptr || p_ptr->connected)
981 return -EINVAL;
982
983 msg = &p_ptr->phdr;
984 msg_set_type(msg, TIPC_NAMED_MSG);
985 msg_set_hdr_sz(msg, NAMED_H_SIZE);
986 msg_set_nametype(msg, name->type);
987 msg_set_nameinst(msg, name->instance);
988 msg_set_lookup_scope(msg, tipc_addr_scope(domain));
989 destport = tipc_nametbl_translate(name->type, name->instance, &destnode);
990 msg_set_destnode(msg, destnode);
991 msg_set_destport(msg, destport);
992
993 if (likely(destport || destnode)) {
994 if (likely(in_own_node(destnode)))
995 res = tipc_port_recv_sections(p_ptr, msg_sect, len);
996 else if (tipc_own_addr)
997 res = tipc_link_send_sections_fast(p_ptr, msg_sect,
998 len, destnode);
999 else
1000 res = tipc_port_reject_sections(p_ptr, msg, msg_sect,
1001 len, TIPC_ERR_NO_NODE);
1002 if (likely(res != -ELINKCONG)) {
1003 if (res > 0)
1004 p_ptr->sent++;
1005 return res;
1006 }
1007 if (port_unreliable(p_ptr)) {
1008 return len;
1009 }
1010 return -ELINKCONG;
1011 }
1012 return tipc_port_reject_sections(p_ptr, msg, msg_sect, len,
1013 TIPC_ERR_NO_NAME);
1014 }
1015
1016 /**
1017 * tipc_send2port - send message sections to port identity
1018 */
1019 int tipc_send2port(u32 ref, struct tipc_portid const *dest,
1020 struct iovec const *msg_sect, unsigned int len)
1021 {
1022 struct tipc_port *p_ptr;
1023 struct tipc_msg *msg;
1024 int res;
1025
1026 p_ptr = tipc_port_deref(ref);
1027 if (!p_ptr || p_ptr->connected)
1028 return -EINVAL;
1029
1030 msg = &p_ptr->phdr;
1031 msg_set_type(msg, TIPC_DIRECT_MSG);
1032 msg_set_lookup_scope(msg, 0);
1033 msg_set_destnode(msg, dest->node);
1034 msg_set_destport(msg, dest->ref);
1035 msg_set_hdr_sz(msg, BASIC_H_SIZE);
1036
1037 if (in_own_node(dest->node))
1038 res = tipc_port_recv_sections(p_ptr, msg_sect, len);
1039 else if (tipc_own_addr)
1040 res = tipc_link_send_sections_fast(p_ptr, msg_sect, len,
1041 dest->node);
1042 else
1043 res = tipc_port_reject_sections(p_ptr, msg, msg_sect, len,
1044 TIPC_ERR_NO_NODE);
1045 if (likely(res != -ELINKCONG)) {
1046 if (res > 0)
1047 p_ptr->sent++;
1048 return res;
1049 }
1050 if (port_unreliable(p_ptr)) {
1051 return len;
1052 }
1053 return -ELINKCONG;
1054 }
(deprecated) Btrfs devel tree