aboutsummaryrefslogtreecommitdiffstats
path: root/net
diff options
context:
space:
mode:
Diffstat (limited to 'net')
-rw-r--r--net/tipc/bcast.c47
-rw-r--r--net/tipc/bcast.h3
-rw-r--r--net/tipc/bearer.c100
-rw-r--r--net/tipc/bearer.h67
-rw-r--r--net/tipc/core.c3
-rw-r--r--net/tipc/core.h3
-rw-r--r--net/tipc/discover.c37
-rw-r--r--net/tipc/discover.h9
-rw-r--r--net/tipc/link.c82
-rw-r--r--net/tipc/link.h28
-rw-r--r--net/tipc/msg.c7
-rw-r--r--net/tipc/msg.h22
-rw-r--r--net/tipc/node.c4
-rw-r--r--net/tipc/port.c306
-rw-r--r--net/tipc/port.h73
-rw-r--r--net/tipc/socket.c6
-rw-r--r--net/tipc/subscr.c13
17 files changed, 375 insertions, 435 deletions
diff --git a/net/tipc/bcast.c b/net/tipc/bcast.c
index 70ab5ef48766..7dc1dc7151ea 100644
--- a/net/tipc/bcast.c
+++ b/net/tipc/bcast.c
@@ -3,7 +3,7 @@
3 * 3 *
4 * Copyright (c) 2004-2006, Ericsson AB 4 * Copyright (c) 2004-2006, Ericsson AB
5 * Copyright (c) 2004, Intel Corporation. 5 * Copyright (c) 2004, Intel Corporation.
6 * Copyright (c) 2005, Wind River Systems 6 * Copyright (c) 2005, 2010-2011, Wind River Systems
7 * All rights reserved. 7 * All rights reserved.
8 * 8 *
9 * Redistribution and use in source and binary forms, with or without 9 * Redistribution and use in source and binary forms, with or without
@@ -61,8 +61,8 @@
61 */ 61 */
62 62
63struct bcbearer_pair { 63struct bcbearer_pair {
64 struct bearer *primary; 64 struct tipc_bearer *primary;
65 struct bearer *secondary; 65 struct tipc_bearer *secondary;
66}; 66};
67 67
68/** 68/**
@@ -81,7 +81,7 @@ struct bcbearer_pair {
81 */ 81 */
82 82
83struct bcbearer { 83struct bcbearer {
84 struct bearer bearer; 84 struct tipc_bearer bearer;
85 struct media media; 85 struct media media;
86 struct bcbearer_pair bpairs[MAX_BEARERS]; 86 struct bcbearer_pair bpairs[MAX_BEARERS];
87 struct bcbearer_pair bpairs_temp[TIPC_MAX_LINK_PRI + 1]; 87 struct bcbearer_pair bpairs_temp[TIPC_MAX_LINK_PRI + 1];
@@ -93,6 +93,7 @@ struct bcbearer {
93 * struct bclink - link used for broadcast messages 93 * struct bclink - link used for broadcast messages
94 * @link: (non-standard) broadcast link structure 94 * @link: (non-standard) broadcast link structure
95 * @node: (non-standard) node structure representing b'cast link's peer node 95 * @node: (non-standard) node structure representing b'cast link's peer node
96 * @retransmit_to: node that most recently requested a retransmit
96 * 97 *
97 * Handles sequence numbering, fragmentation, bundling, etc. 98 * Handles sequence numbering, fragmentation, bundling, etc.
98 */ 99 */
@@ -100,6 +101,7 @@ struct bcbearer {
100struct bclink { 101struct bclink {
101 struct link link; 102 struct link link;
102 struct tipc_node node; 103 struct tipc_node node;
104 struct tipc_node *retransmit_to;
103}; 105};
104 106
105 107
@@ -184,6 +186,17 @@ static int bclink_ack_allowed(u32 n)
184 186
185 187
186/** 188/**
189 * tipc_bclink_retransmit_to - get most recent node to request retransmission
190 *
191 * Called with bc_lock locked
192 */
193
194struct tipc_node *tipc_bclink_retransmit_to(void)
195{
196 return bclink->retransmit_to;
197}
198
199/**
187 * bclink_retransmit_pkt - retransmit broadcast packets 200 * bclink_retransmit_pkt - retransmit broadcast packets
188 * @after: sequence number of last packet to *not* retransmit 201 * @after: sequence number of last packet to *not* retransmit
189 * @to: sequence number of last packet to retransmit 202 * @to: sequence number of last packet to retransmit
@@ -285,6 +298,7 @@ static void bclink_send_nack(struct tipc_node *n_ptr)
285 msg = buf_msg(buf); 298 msg = buf_msg(buf);
286 tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG, 299 tipc_msg_init(msg, BCAST_PROTOCOL, STATE_MSG,
287 INT_H_SIZE, n_ptr->addr); 300 INT_H_SIZE, n_ptr->addr);
301 msg_set_non_seq(msg, 1);
288 msg_set_mc_netid(msg, tipc_net_id); 302 msg_set_mc_netid(msg, tipc_net_id);
289 msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in)); 303 msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in));
290 msg_set_bcgap_after(msg, n_ptr->bclink.gap_after); 304 msg_set_bcgap_after(msg, n_ptr->bclink.gap_after);
@@ -405,8 +419,6 @@ int tipc_bclink_send_msg(struct sk_buff *buf)
405 else 419 else
406 bclink_set_last_sent(); 420 bclink_set_last_sent();
407 421
408 if (bcl->out_queue_size > bcl->stats.max_queue_sz)
409 bcl->stats.max_queue_sz = bcl->out_queue_size;
410 bcl->stats.queue_sz_counts++; 422 bcl->stats.queue_sz_counts++;
411 bcl->stats.accu_queue_sz += bcl->out_queue_size; 423 bcl->stats.accu_queue_sz += bcl->out_queue_size;
412 424
@@ -444,10 +456,9 @@ void tipc_bclink_recv_pkt(struct sk_buff *buf)
444 tipc_node_unlock(node); 456 tipc_node_unlock(node);
445 spin_lock_bh(&bc_lock); 457 spin_lock_bh(&bc_lock);
446 bcl->stats.recv_nacks++; 458 bcl->stats.recv_nacks++;
447 bcl->owner->next = node; /* remember requestor */ 459 bclink->retransmit_to = node;
448 bclink_retransmit_pkt(msg_bcgap_after(msg), 460 bclink_retransmit_pkt(msg_bcgap_after(msg),
449 msg_bcgap_to(msg)); 461 msg_bcgap_to(msg));
450 bcl->owner->next = NULL;
451 spin_unlock_bh(&bc_lock); 462 spin_unlock_bh(&bc_lock);
452 } else { 463 } else {
453 tipc_bclink_peek_nack(msg_destnode(msg), 464 tipc_bclink_peek_nack(msg_destnode(msg),
@@ -574,8 +585,8 @@ static int tipc_bcbearer_send(struct sk_buff *buf,
574 bcbearer->remains = tipc_bcast_nmap; 585 bcbearer->remains = tipc_bcast_nmap;
575 586
576 for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) { 587 for (bp_index = 0; bp_index < MAX_BEARERS; bp_index++) {
577 struct bearer *p = bcbearer->bpairs[bp_index].primary; 588 struct tipc_bearer *p = bcbearer->bpairs[bp_index].primary;
578 struct bearer *s = bcbearer->bpairs[bp_index].secondary; 589 struct tipc_bearer *s = bcbearer->bpairs[bp_index].secondary;
579 590
580 if (!p) 591 if (!p)
581 break; /* no more bearers to try */ 592 break; /* no more bearers to try */
@@ -584,11 +595,11 @@ static int tipc_bcbearer_send(struct sk_buff *buf,
584 if (bcbearer->remains_new.count == bcbearer->remains.count) 595 if (bcbearer->remains_new.count == bcbearer->remains.count)
585 continue; /* bearer pair doesn't add anything */ 596 continue; /* bearer pair doesn't add anything */
586 597
587 if (p->publ.blocked || 598 if (p->blocked ||
588 p->media->send_msg(buf, &p->publ, &p->media->bcast_addr)) { 599 p->media->send_msg(buf, p, &p->media->bcast_addr)) {
589 /* unable to send on primary bearer */ 600 /* unable to send on primary bearer */
590 if (!s || s->publ.blocked || 601 if (!s || s->blocked ||
591 s->media->send_msg(buf, &s->publ, 602 s->media->send_msg(buf, s,
592 &s->media->bcast_addr)) { 603 &s->media->bcast_addr)) {
593 /* unable to send on either bearer */ 604 /* unable to send on either bearer */
594 continue; 605 continue;
@@ -633,7 +644,7 @@ void tipc_bcbearer_sort(void)
633 memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp)); 644 memset(bp_temp, 0, sizeof(bcbearer->bpairs_temp));
634 645
635 for (b_index = 0; b_index < MAX_BEARERS; b_index++) { 646 for (b_index = 0; b_index < MAX_BEARERS; b_index++) {
636 struct bearer *b = &tipc_bearers[b_index]; 647 struct tipc_bearer *b = &tipc_bearers[b_index];
637 648
638 if (!b->active || !b->nodes.count) 649 if (!b->active || !b->nodes.count)
639 continue; 650 continue;
@@ -682,12 +693,12 @@ void tipc_bcbearer_sort(void)
682 693
683void tipc_bcbearer_push(void) 694void tipc_bcbearer_push(void)
684{ 695{
685 struct bearer *b_ptr; 696 struct tipc_bearer *b_ptr;
686 697
687 spin_lock_bh(&bc_lock); 698 spin_lock_bh(&bc_lock);
688 b_ptr = &bcbearer->bearer; 699 b_ptr = &bcbearer->bearer;
689 if (b_ptr->publ.blocked) { 700 if (b_ptr->blocked) {
690 b_ptr->publ.blocked = 0; 701 b_ptr->blocked = 0;
691 tipc_bearer_lock_push(b_ptr); 702 tipc_bearer_lock_push(b_ptr);
692 } 703 }
693 spin_unlock_bh(&bc_lock); 704 spin_unlock_bh(&bc_lock);
diff --git a/net/tipc/bcast.h b/net/tipc/bcast.h
index 51f8c5326ce6..500c97f1c859 100644
--- a/net/tipc/bcast.h
+++ b/net/tipc/bcast.h
@@ -2,7 +2,7 @@
2 * net/tipc/bcast.h: Include file for TIPC broadcast code 2 * net/tipc/bcast.h: Include file for TIPC broadcast code
3 * 3 *
4 * Copyright (c) 2003-2006, Ericsson AB 4 * Copyright (c) 2003-2006, Ericsson AB
5 * Copyright (c) 2005, Wind River Systems 5 * Copyright (c) 2005, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -90,6 +90,7 @@ void tipc_port_list_free(struct port_list *pl_ptr);
90 90
91int tipc_bclink_init(void); 91int tipc_bclink_init(void);
92void tipc_bclink_stop(void); 92void tipc_bclink_stop(void);
93struct tipc_node *tipc_bclink_retransmit_to(void);
93void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked); 94void tipc_bclink_acknowledge(struct tipc_node *n_ptr, u32 acked);
94int tipc_bclink_send_msg(struct sk_buff *buf); 95int tipc_bclink_send_msg(struct sk_buff *buf);
95void tipc_bclink_recv_pkt(struct sk_buff *buf); 96void tipc_bclink_recv_pkt(struct sk_buff *buf);
diff --git a/net/tipc/bearer.c b/net/tipc/bearer.c
index 837b7a467885..f2839b0f6b65 100644
--- a/net/tipc/bearer.c
+++ b/net/tipc/bearer.c
@@ -2,7 +2,7 @@
2 * net/tipc/bearer.c: TIPC bearer code 2 * net/tipc/bearer.c: TIPC bearer code
3 * 3 *
4 * Copyright (c) 1996-2006, Ericsson AB 4 * Copyright (c) 1996-2006, Ericsson AB
5 * Copyright (c) 2004-2006, Wind River Systems 5 * Copyright (c) 2004-2006, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -44,7 +44,7 @@
44static struct media media_list[MAX_MEDIA]; 44static struct media media_list[MAX_MEDIA];
45static u32 media_count; 45static u32 media_count;
46 46
47struct bearer tipc_bearers[MAX_BEARERS]; 47struct tipc_bearer tipc_bearers[MAX_BEARERS];
48 48
49/** 49/**
50 * media_name_valid - validate media name 50 * media_name_valid - validate media name
@@ -278,13 +278,13 @@ static int bearer_name_validate(const char *name,
278 * bearer_find - locates bearer object with matching bearer name 278 * bearer_find - locates bearer object with matching bearer name
279 */ 279 */
280 280
281static struct bearer *bearer_find(const char *name) 281static struct tipc_bearer *bearer_find(const char *name)
282{ 282{
283 struct bearer *b_ptr; 283 struct tipc_bearer *b_ptr;
284 u32 i; 284 u32 i;
285 285
286 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) { 286 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
287 if (b_ptr->active && (!strcmp(b_ptr->publ.name, name))) 287 if (b_ptr->active && (!strcmp(b_ptr->name, name)))
288 return b_ptr; 288 return b_ptr;
289 } 289 }
290 return NULL; 290 return NULL;
@@ -294,16 +294,16 @@ static struct bearer *bearer_find(const char *name)
294 * tipc_bearer_find_interface - locates bearer object with matching interface name 294 * tipc_bearer_find_interface - locates bearer object with matching interface name
295 */ 295 */
296 296
297struct bearer *tipc_bearer_find_interface(const char *if_name) 297struct tipc_bearer *tipc_bearer_find_interface(const char *if_name)
298{ 298{
299 struct bearer *b_ptr; 299 struct tipc_bearer *b_ptr;
300 char *b_if_name; 300 char *b_if_name;
301 u32 i; 301 u32 i;
302 302
303 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) { 303 for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
304 if (!b_ptr->active) 304 if (!b_ptr->active)
305 continue; 305 continue;
306 b_if_name = strchr(b_ptr->publ.name, ':') + 1; 306 b_if_name = strchr(b_ptr->name, ':') + 1;
307 if (!strcmp(b_if_name, if_name)) 307 if (!strcmp(b_if_name, if_name))
308 return b_ptr; 308 return b_ptr;
309 } 309 }
@@ -318,7 +318,7 @@ struct sk_buff *tipc_bearer_get_names(void)
318{ 318{
319 struct sk_buff *buf; 319 struct sk_buff *buf;
320 struct media *m_ptr; 320 struct media *m_ptr;
321 struct bearer *b_ptr; 321 struct tipc_bearer *b_ptr;
322 int i, j; 322 int i, j;
323 323
324 buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME)); 324 buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
@@ -331,8 +331,8 @@ struct sk_buff *tipc_bearer_get_names(void)
331 b_ptr = &tipc_bearers[j]; 331 b_ptr = &tipc_bearers[j];
332 if (b_ptr->active && (b_ptr->media == m_ptr)) { 332 if (b_ptr->active && (b_ptr->media == m_ptr)) {
333 tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME, 333 tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
334 b_ptr->publ.name, 334 b_ptr->name,
335 strlen(b_ptr->publ.name) + 1); 335 strlen(b_ptr->name) + 1);
336 } 336 }
337 } 337 }
338 } 338 }
@@ -340,14 +340,14 @@ struct sk_buff *tipc_bearer_get_names(void)
340 return buf; 340 return buf;
341} 341}
342 342
343void tipc_bearer_add_dest(struct bearer *b_ptr, u32 dest) 343void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest)
344{ 344{
345 tipc_nmap_add(&b_ptr->nodes, dest); 345 tipc_nmap_add(&b_ptr->nodes, dest);
346 tipc_disc_update_link_req(b_ptr->link_req); 346 tipc_disc_update_link_req(b_ptr->link_req);
347 tipc_bcbearer_sort(); 347 tipc_bcbearer_sort();
348} 348}
349 349
350void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest) 350void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest)
351{ 351{
352 tipc_nmap_remove(&b_ptr->nodes, dest); 352 tipc_nmap_remove(&b_ptr->nodes, dest);
353 tipc_disc_update_link_req(b_ptr->link_req); 353 tipc_disc_update_link_req(b_ptr->link_req);
@@ -362,12 +362,12 @@ void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest)
362 * bearer.lock must be taken before calling 362 * bearer.lock must be taken before calling
363 * Returns binary true(1) ore false(0) 363 * Returns binary true(1) ore false(0)
364 */ 364 */
365static int bearer_push(struct bearer *b_ptr) 365static int bearer_push(struct tipc_bearer *b_ptr)
366{ 366{
367 u32 res = 0; 367 u32 res = 0;
368 struct link *ln, *tln; 368 struct link *ln, *tln;
369 369
370 if (b_ptr->publ.blocked) 370 if (b_ptr->blocked)
371 return 0; 371 return 0;
372 372
373 while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) { 373 while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) {
@@ -382,13 +382,13 @@ static int bearer_push(struct bearer *b_ptr)
382 return list_empty(&b_ptr->cong_links); 382 return list_empty(&b_ptr->cong_links);
383} 383}
384 384
385void tipc_bearer_lock_push(struct bearer *b_ptr) 385void tipc_bearer_lock_push(struct tipc_bearer *b_ptr)
386{ 386{
387 int res; 387 int res;
388 388
389 spin_lock_bh(&b_ptr->publ.lock); 389 spin_lock_bh(&b_ptr->lock);
390 res = bearer_push(b_ptr); 390 res = bearer_push(b_ptr);
391 spin_unlock_bh(&b_ptr->publ.lock); 391 spin_unlock_bh(&b_ptr->lock);
392 if (res) 392 if (res)
393 tipc_bcbearer_push(); 393 tipc_bcbearer_push();
394} 394}
@@ -398,16 +398,14 @@ void tipc_bearer_lock_push(struct bearer *b_ptr)
398 * Interrupt enabling new requests after bearer congestion or blocking: 398 * Interrupt enabling new requests after bearer congestion or blocking:
399 * See bearer_send(). 399 * See bearer_send().
400 */ 400 */
401void tipc_continue(struct tipc_bearer *tb_ptr) 401void tipc_continue(struct tipc_bearer *b_ptr)
402{ 402{
403 struct bearer *b_ptr = (struct bearer *)tb_ptr; 403 spin_lock_bh(&b_ptr->lock);
404
405 spin_lock_bh(&b_ptr->publ.lock);
406 b_ptr->continue_count++; 404 b_ptr->continue_count++;
407 if (!list_empty(&b_ptr->cong_links)) 405 if (!list_empty(&b_ptr->cong_links))
408 tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr); 406 tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr);
409 b_ptr->publ.blocked = 0; 407 b_ptr->blocked = 0;
410 spin_unlock_bh(&b_ptr->publ.lock); 408 spin_unlock_bh(&b_ptr->lock);
411} 409}
412 410
413/* 411/*
@@ -418,7 +416,7 @@ void tipc_continue(struct tipc_bearer *tb_ptr)
418 * bearer.lock is busy 416 * bearer.lock is busy
419 */ 417 */
420 418
421static void tipc_bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr) 419static void tipc_bearer_schedule_unlocked(struct tipc_bearer *b_ptr, struct link *l_ptr)
422{ 420{
423 list_move_tail(&l_ptr->link_list, &b_ptr->cong_links); 421 list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
424} 422}
@@ -431,11 +429,11 @@ static void tipc_bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_p
431 * bearer.lock is free 429 * bearer.lock is free
432 */ 430 */
433 431
434void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr) 432void tipc_bearer_schedule(struct tipc_bearer *b_ptr, struct link *l_ptr)
435{ 433{
436 spin_lock_bh(&b_ptr->publ.lock); 434 spin_lock_bh(&b_ptr->lock);
437 tipc_bearer_schedule_unlocked(b_ptr, l_ptr); 435 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
438 spin_unlock_bh(&b_ptr->publ.lock); 436 spin_unlock_bh(&b_ptr->lock);
439} 437}
440 438
441 439
@@ -444,18 +442,18 @@ void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr)
444 * and if there is, try to resolve it before returning. 442 * and if there is, try to resolve it before returning.
445 * 'tipc_net_lock' is read_locked when this function is called 443 * 'tipc_net_lock' is read_locked when this function is called
446 */ 444 */
447int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr) 445int tipc_bearer_resolve_congestion(struct tipc_bearer *b_ptr, struct link *l_ptr)
448{ 446{
449 int res = 1; 447 int res = 1;
450 448
451 if (list_empty(&b_ptr->cong_links)) 449 if (list_empty(&b_ptr->cong_links))
452 return 1; 450 return 1;
453 spin_lock_bh(&b_ptr->publ.lock); 451 spin_lock_bh(&b_ptr->lock);
454 if (!bearer_push(b_ptr)) { 452 if (!bearer_push(b_ptr)) {
455 tipc_bearer_schedule_unlocked(b_ptr, l_ptr); 453 tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
456 res = 0; 454 res = 0;
457 } 455 }
458 spin_unlock_bh(&b_ptr->publ.lock); 456 spin_unlock_bh(&b_ptr->lock);
459 return res; 457 return res;
460} 458}
461 459
@@ -463,9 +461,9 @@ int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
463 * tipc_bearer_congested - determines if bearer is currently congested 461 * tipc_bearer_congested - determines if bearer is currently congested
464 */ 462 */
465 463
466int tipc_bearer_congested(struct bearer *b_ptr, struct link *l_ptr) 464int tipc_bearer_congested(struct tipc_bearer *b_ptr, struct link *l_ptr)
467{ 465{
468 if (unlikely(b_ptr->publ.blocked)) 466 if (unlikely(b_ptr->blocked))
469 return 1; 467 return 1;
470 if (likely(list_empty(&b_ptr->cong_links))) 468 if (likely(list_empty(&b_ptr->cong_links)))
471 return 0; 469 return 0;
@@ -478,7 +476,7 @@ int tipc_bearer_congested(struct bearer *b_ptr, struct link *l_ptr)
478 476
479int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority) 477int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority)
480{ 478{
481 struct bearer *b_ptr; 479 struct tipc_bearer *b_ptr;
482 struct media *m_ptr; 480 struct media *m_ptr;
483 struct bearer_name b_name; 481 struct bearer_name b_name;
484 char addr_string[16]; 482 char addr_string[16];
@@ -528,7 +526,7 @@ restart:
528 bearer_id = i; 526 bearer_id = i;
529 continue; 527 continue;
530 } 528 }
531 if (!strcmp(name, tipc_bearers[i].publ.name)) { 529 if (!strcmp(name, tipc_bearers[i].name)) {
532 warn("Bearer <%s> rejected, already enabled\n", name); 530 warn("Bearer <%s> rejected, already enabled\n", name);
533 goto failed; 531 goto failed;
534 } 532 }
@@ -551,8 +549,8 @@ restart:
551 } 549 }
552 550
553 b_ptr = &tipc_bearers[bearer_id]; 551 b_ptr = &tipc_bearers[bearer_id];
554 strcpy(b_ptr->publ.name, name); 552 strcpy(b_ptr->name, name);
555 res = m_ptr->enable_bearer(&b_ptr->publ); 553 res = m_ptr->enable_bearer(b_ptr);
556 if (res) { 554 if (res) {
557 warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res); 555 warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res);
558 goto failed; 556 goto failed;
@@ -568,9 +566,9 @@ restart:
568 INIT_LIST_HEAD(&b_ptr->links); 566 INIT_LIST_HEAD(&b_ptr->links);
569 if (m_ptr->bcast) { 567 if (m_ptr->bcast) {
570 b_ptr->link_req = tipc_disc_init_link_req(b_ptr, &m_ptr->bcast_addr, 568 b_ptr->link_req = tipc_disc_init_link_req(b_ptr, &m_ptr->bcast_addr,
571 bcast_scope, 2); 569 bcast_scope);
572 } 570 }
573 spin_lock_init(&b_ptr->publ.lock); 571 spin_lock_init(&b_ptr->lock);
574 write_unlock_bh(&tipc_net_lock); 572 write_unlock_bh(&tipc_net_lock);
575 info("Enabled bearer <%s>, discovery domain %s, priority %u\n", 573 info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
576 name, tipc_addr_string_fill(addr_string, bcast_scope), priority); 574 name, tipc_addr_string_fill(addr_string, bcast_scope), priority);
@@ -587,7 +585,7 @@ failed:
587 585
588int tipc_block_bearer(const char *name) 586int tipc_block_bearer(const char *name)
589{ 587{
590 struct bearer *b_ptr = NULL; 588 struct tipc_bearer *b_ptr = NULL;
591 struct link *l_ptr; 589 struct link *l_ptr;
592 struct link *temp_l_ptr; 590 struct link *temp_l_ptr;
593 591
@@ -600,8 +598,8 @@ int tipc_block_bearer(const char *name)
600 } 598 }
601 599
602 info("Blocking bearer <%s>\n", name); 600 info("Blocking bearer <%s>\n", name);
603 spin_lock_bh(&b_ptr->publ.lock); 601 spin_lock_bh(&b_ptr->lock);
604 b_ptr->publ.blocked = 1; 602 b_ptr->blocked = 1;
605 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) { 603 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
606 struct tipc_node *n_ptr = l_ptr->owner; 604 struct tipc_node *n_ptr = l_ptr->owner;
607 605
@@ -609,7 +607,7 @@ int tipc_block_bearer(const char *name)
609 tipc_link_reset(l_ptr); 607 tipc_link_reset(l_ptr);
610 spin_unlock_bh(&n_ptr->lock); 608 spin_unlock_bh(&n_ptr->lock);
611 } 609 }
612 spin_unlock_bh(&b_ptr->publ.lock); 610 spin_unlock_bh(&b_ptr->lock);
613 read_unlock_bh(&tipc_net_lock); 611 read_unlock_bh(&tipc_net_lock);
614 return 0; 612 return 0;
615} 613}
@@ -620,27 +618,27 @@ int tipc_block_bearer(const char *name)
620 * Note: This routine assumes caller holds tipc_net_lock. 618 * Note: This routine assumes caller holds tipc_net_lock.
621 */ 619 */
622 620
623static void bearer_disable(struct bearer *b_ptr) 621static void bearer_disable(struct tipc_bearer *b_ptr)
624{ 622{
625 struct link *l_ptr; 623 struct link *l_ptr;
626 struct link *temp_l_ptr; 624 struct link *temp_l_ptr;
627 625
628 info("Disabling bearer <%s>\n", b_ptr->publ.name); 626 info("Disabling bearer <%s>\n", b_ptr->name);
629 tipc_disc_stop_link_req(b_ptr->link_req); 627 tipc_disc_stop_link_req(b_ptr->link_req);
630 spin_lock_bh(&b_ptr->publ.lock); 628 spin_lock_bh(&b_ptr->lock);
631 b_ptr->link_req = NULL; 629 b_ptr->link_req = NULL;
632 b_ptr->publ.blocked = 1; 630 b_ptr->blocked = 1;
633 b_ptr->media->disable_bearer(&b_ptr->publ); 631 b_ptr->media->disable_bearer(b_ptr);
634 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) { 632 list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
635 tipc_link_delete(l_ptr); 633 tipc_link_delete(l_ptr);
636 } 634 }
637 spin_unlock_bh(&b_ptr->publ.lock); 635 spin_unlock_bh(&b_ptr->lock);
638 memset(b_ptr, 0, sizeof(struct bearer)); 636 memset(b_ptr, 0, sizeof(struct tipc_bearer));
639} 637}
640 638
641int tipc_disable_bearer(const char *name) 639int tipc_disable_bearer(const char *name)
642{ 640{
643 struct bearer *b_ptr; 641 struct tipc_bearer *b_ptr;
644 int res; 642 int res;
645 643
646 write_lock_bh(&tipc_net_lock); 644 write_lock_bh(&tipc_net_lock);
diff --git a/net/tipc/bearer.h b/net/tipc/bearer.h
index 85f451d5aacf..255dea64f7bd 100644
--- a/net/tipc/bearer.h
+++ b/net/tipc/bearer.h
@@ -2,7 +2,7 @@
2 * net/tipc/bearer.h: Include file for TIPC bearer code 2 * net/tipc/bearer.h: Include file for TIPC bearer code
3 * 3 *
4 * Copyright (c) 1996-2006, Ericsson AB 4 * Copyright (c) 1996-2006, Ericsson AB
5 * Copyright (c) 2005, Wind River Systems 5 * Copyright (c) 2005, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -61,26 +61,7 @@ struct tipc_media_addr {
61 } dev_addr; 61 } dev_addr;
62}; 62};
63 63
64/** 64struct tipc_bearer;
65 * struct tipc_bearer - TIPC bearer info available to media code
66 * @usr_handle: pointer to additional media-specific information about bearer
67 * @mtu: max packet size bearer can support
68 * @blocked: non-zero if bearer is blocked
69 * @lock: spinlock for controlling access to bearer
70 * @addr: media-specific address associated with bearer
71 * @name: bearer name (format = media:interface)
72 *
73 * Note: TIPC initializes "name" and "lock" fields; media code is responsible
74 * for initialization all other fields when a bearer is enabled.
75 */
76struct tipc_bearer {
77 void *usr_handle;
78 u32 mtu;
79 int blocked;
80 spinlock_t lock;
81 struct tipc_media_addr addr;
82 char name[TIPC_MAX_BEARER_NAME];
83};
84 65
85/** 66/**
86 * struct media - TIPC media information available to internal users 67 * struct media - TIPC media information available to internal users
@@ -115,8 +96,13 @@ struct media {
115}; 96};
116 97
117/** 98/**
118 * struct bearer - TIPC bearer information available to internal users 99 * struct tipc_bearer - TIPC bearer structure
119 * @publ: bearer information available to privileged users 100 * @usr_handle: pointer to additional media-specific information about bearer
101 * @mtu: max packet size bearer can support
102 * @blocked: non-zero if bearer is blocked
103 * @lock: spinlock for controlling access to bearer
104 * @addr: media-specific address associated with bearer
105 * @name: bearer name (format = media:interface)
120 * @media: ptr to media structure associated with bearer 106 * @media: ptr to media structure associated with bearer
121 * @priority: default link priority for bearer 107 * @priority: default link priority for bearer
122 * @detect_scope: network address mask used during automatic link creation 108 * @detect_scope: network address mask used during automatic link creation
@@ -128,10 +114,18 @@ struct media {
128 * @active: non-zero if bearer structure is represents a bearer 114 * @active: non-zero if bearer structure is represents a bearer
129 * @net_plane: network plane ('A' through 'H') currently associated with bearer 115 * @net_plane: network plane ('A' through 'H') currently associated with bearer
130 * @nodes: indicates which nodes in cluster can be reached through bearer 116 * @nodes: indicates which nodes in cluster can be reached through bearer
117 *
118 * Note: media-specific code is responsible for initialization of the fields
119 * indicated below when a bearer is enabled; TIPC's generic bearer code takes
120 * care of initializing all other fields.
131 */ 121 */
132 122struct tipc_bearer {
133struct bearer { 123 void *usr_handle; /* initalized by media */
134 struct tipc_bearer publ; 124 u32 mtu; /* initalized by media */
125 int blocked; /* initalized by media */
126 struct tipc_media_addr addr; /* initalized by media */
127 char name[TIPC_MAX_BEARER_NAME];
128 spinlock_t lock;
135 struct media *media; 129 struct media *media;
136 u32 priority; 130 u32 priority;
137 u32 detect_scope; 131 u32 detect_scope;
@@ -152,7 +146,7 @@ struct bearer_name {
152 146
153struct link; 147struct link;
154 148
155extern struct bearer tipc_bearers[]; 149extern struct tipc_bearer tipc_bearers[];
156 150
157/* 151/*
158 * TIPC routines available to supported media types 152 * TIPC routines available to supported media types
@@ -186,14 +180,14 @@ void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a);
186struct sk_buff *tipc_media_get_names(void); 180struct sk_buff *tipc_media_get_names(void);
187 181
188struct sk_buff *tipc_bearer_get_names(void); 182struct sk_buff *tipc_bearer_get_names(void);
189void tipc_bearer_add_dest(struct bearer *b_ptr, u32 dest); 183void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest);
190void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest); 184void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest);
191void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr); 185void tipc_bearer_schedule(struct tipc_bearer *b_ptr, struct link *l_ptr);
192struct bearer *tipc_bearer_find_interface(const char *if_name); 186struct tipc_bearer *tipc_bearer_find_interface(const char *if_name);
193int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr); 187int tipc_bearer_resolve_congestion(struct tipc_bearer *b_ptr, struct link *l_ptr);
194int tipc_bearer_congested(struct bearer *b_ptr, struct link *l_ptr); 188int tipc_bearer_congested(struct tipc_bearer *b_ptr, struct link *l_ptr);
195void tipc_bearer_stop(void); 189void tipc_bearer_stop(void);
196void tipc_bearer_lock_push(struct bearer *b_ptr); 190void tipc_bearer_lock_push(struct tipc_bearer *b_ptr);
197 191
198 192
199/** 193/**
@@ -214,10 +208,11 @@ void tipc_bearer_lock_push(struct bearer *b_ptr);
214 * and let TIPC's link code deal with the undelivered message. 208 * and let TIPC's link code deal with the undelivered message.
215 */ 209 */
216 210
217static inline int tipc_bearer_send(struct bearer *b_ptr, struct sk_buff *buf, 211static inline int tipc_bearer_send(struct tipc_bearer *b_ptr,
212 struct sk_buff *buf,
218 struct tipc_media_addr *dest) 213 struct tipc_media_addr *dest)
219{ 214{
220 return !b_ptr->media->send_msg(buf, &b_ptr->publ, dest); 215 return !b_ptr->media->send_msg(buf, b_ptr, dest);
221} 216}
222 217
223#endif /* _TIPC_BEARER_H */ 218#endif /* _TIPC_BEARER_H */
diff --git a/net/tipc/core.c b/net/tipc/core.c
index e071579e0850..2da1fc75ad65 100644
--- a/net/tipc/core.c
+++ b/net/tipc/core.c
@@ -2,7 +2,7 @@
2 * net/tipc/core.c: TIPC module code 2 * net/tipc/core.c: TIPC module code
3 * 3 *
4 * Copyright (c) 2003-2006, Ericsson AB 4 * Copyright (c) 2003-2006, Ericsson AB
5 * Copyright (c) 2005-2006, Wind River Systems 5 * Copyright (c) 2005-2006, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -57,7 +57,6 @@
57 57
58int tipc_mode = TIPC_NOT_RUNNING; 58int tipc_mode = TIPC_NOT_RUNNING;
59int tipc_random; 59int tipc_random;
60atomic_t tipc_user_count = ATOMIC_INIT(0);
61 60
62const char tipc_alphabet[] = 61const char tipc_alphabet[] =
63 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_."; 62 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.";
diff --git a/net/tipc/core.h b/net/tipc/core.h
index 997158546e25..37544d9f73e1 100644
--- a/net/tipc/core.h
+++ b/net/tipc/core.h
@@ -2,7 +2,7 @@
2 * net/tipc/core.h: Include file for TIPC global declarations 2 * net/tipc/core.h: Include file for TIPC global declarations
3 * 3 *
4 * Copyright (c) 2005-2006, Ericsson AB 4 * Copyright (c) 2005-2006, Ericsson AB
5 * Copyright (c) 2005-2007, Wind River Systems 5 * Copyright (c) 2005-2007, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -161,7 +161,6 @@ extern int tipc_remote_management;
161extern int tipc_mode; 161extern int tipc_mode;
162extern int tipc_random; 162extern int tipc_random;
163extern const char tipc_alphabet[]; 163extern const char tipc_alphabet[];
164extern atomic_t tipc_user_count;
165 164
166 165
167/* 166/*
diff --git a/net/tipc/discover.c b/net/tipc/discover.c
index fa026bd91a68..09ce2318b89e 100644
--- a/net/tipc/discover.c
+++ b/net/tipc/discover.c
@@ -2,7 +2,7 @@
2 * net/tipc/discover.c 2 * net/tipc/discover.c
3 * 3 *
4 * Copyright (c) 2003-2006, Ericsson AB 4 * Copyright (c) 2003-2006, Ericsson AB
5 * Copyright (c) 2005-2006, Wind River Systems 5 * Copyright (c) 2005-2006, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -57,7 +57,7 @@
57 * @timer_intv: current interval between requests (in ms) 57 * @timer_intv: current interval between requests (in ms)
58 */ 58 */
59struct link_req { 59struct link_req {
60 struct bearer *bearer; 60 struct tipc_bearer *bearer;
61 struct tipc_media_addr dest; 61 struct tipc_media_addr dest;
62 struct sk_buff *buf; 62 struct sk_buff *buf;
63 struct timer_list timer; 63 struct timer_list timer;
@@ -67,15 +67,13 @@ struct link_req {
67/** 67/**
68 * tipc_disc_init_msg - initialize a link setup message 68 * tipc_disc_init_msg - initialize a link setup message
69 * @type: message type (request or response) 69 * @type: message type (request or response)
70 * @req_links: number of links associated with message
71 * @dest_domain: network domain of node(s) which should respond to message 70 * @dest_domain: network domain of node(s) which should respond to message
72 * @b_ptr: ptr to bearer issuing message 71 * @b_ptr: ptr to bearer issuing message
73 */ 72 */
74 73
75static struct sk_buff *tipc_disc_init_msg(u32 type, 74static struct sk_buff *tipc_disc_init_msg(u32 type,
76 u32 req_links,
77 u32 dest_domain, 75 u32 dest_domain,
78 struct bearer *b_ptr) 76 struct tipc_bearer *b_ptr)
79{ 77{
80 struct sk_buff *buf = tipc_buf_acquire(DSC_H_SIZE); 78 struct sk_buff *buf = tipc_buf_acquire(DSC_H_SIZE);
81 struct tipc_msg *msg; 79 struct tipc_msg *msg;
@@ -84,10 +82,9 @@ static struct sk_buff *tipc_disc_init_msg(u32 type,
84 msg = buf_msg(buf); 82 msg = buf_msg(buf);
85 tipc_msg_init(msg, LINK_CONFIG, type, DSC_H_SIZE, dest_domain); 83 tipc_msg_init(msg, LINK_CONFIG, type, DSC_H_SIZE, dest_domain);
86 msg_set_non_seq(msg, 1); 84 msg_set_non_seq(msg, 1);
87 msg_set_req_links(msg, req_links);
88 msg_set_dest_domain(msg, dest_domain); 85 msg_set_dest_domain(msg, dest_domain);
89 msg_set_bc_netid(msg, tipc_net_id); 86 msg_set_bc_netid(msg, tipc_net_id);
90 msg_set_media_addr(msg, &b_ptr->publ.addr); 87 msg_set_media_addr(msg, &b_ptr->addr);
91 } 88 }
92 return buf; 89 return buf;
93} 90}
@@ -99,7 +96,7 @@ static struct sk_buff *tipc_disc_init_msg(u32 type,
99 * @media_addr: media address advertised by duplicated node 96 * @media_addr: media address advertised by duplicated node
100 */ 97 */
101 98
102static void disc_dupl_alert(struct bearer *b_ptr, u32 node_addr, 99static void disc_dupl_alert(struct tipc_bearer *b_ptr, u32 node_addr,
103 struct tipc_media_addr *media_addr) 100 struct tipc_media_addr *media_addr)
104{ 101{
105 char node_addr_str[16]; 102 char node_addr_str[16];
@@ -111,7 +108,7 @@ static void disc_dupl_alert(struct bearer *b_ptr, u32 node_addr,
111 tipc_media_addr_printf(&pb, media_addr); 108 tipc_media_addr_printf(&pb, media_addr);
112 tipc_printbuf_validate(&pb); 109 tipc_printbuf_validate(&pb);
113 warn("Duplicate %s using %s seen on <%s>\n", 110 warn("Duplicate %s using %s seen on <%s>\n",
114 node_addr_str, media_addr_str, b_ptr->publ.name); 111 node_addr_str, media_addr_str, b_ptr->name);
115} 112}
116 113
117/** 114/**
@@ -120,7 +117,7 @@ static void disc_dupl_alert(struct bearer *b_ptr, u32 node_addr,
120 * @b_ptr: bearer that message arrived on 117 * @b_ptr: bearer that message arrived on
121 */ 118 */
122 119
123void tipc_disc_recv_msg(struct sk_buff *buf, struct bearer *b_ptr) 120void tipc_disc_recv_msg(struct sk_buff *buf, struct tipc_bearer *b_ptr)
124{ 121{
125 struct link *link; 122 struct link *link;
126 struct tipc_media_addr media_addr; 123 struct tipc_media_addr media_addr;
@@ -140,7 +137,7 @@ void tipc_disc_recv_msg(struct sk_buff *buf, struct bearer *b_ptr)
140 if (!tipc_addr_node_valid(orig)) 137 if (!tipc_addr_node_valid(orig))
141 return; 138 return;
142 if (orig == tipc_own_addr) { 139 if (orig == tipc_own_addr) {
143 if (memcmp(&media_addr, &b_ptr->publ.addr, sizeof(media_addr))) 140 if (memcmp(&media_addr, &b_ptr->addr, sizeof(media_addr)))
144 disc_dupl_alert(b_ptr, tipc_own_addr, &media_addr); 141 disc_dupl_alert(b_ptr, tipc_own_addr, &media_addr);
145 return; 142 return;
146 } 143 }
@@ -191,9 +188,9 @@ void tipc_disc_recv_msg(struct sk_buff *buf, struct bearer *b_ptr)
191 spin_unlock_bh(&n_ptr->lock); 188 spin_unlock_bh(&n_ptr->lock);
192 if ((type == DSC_RESP_MSG) || link_fully_up) 189 if ((type == DSC_RESP_MSG) || link_fully_up)
193 return; 190 return;
194 rbuf = tipc_disc_init_msg(DSC_RESP_MSG, 1, orig, b_ptr); 191 rbuf = tipc_disc_init_msg(DSC_RESP_MSG, orig, b_ptr);
195 if (rbuf != NULL) { 192 if (rbuf != NULL) {
196 b_ptr->media->send_msg(rbuf, &b_ptr->publ, &media_addr); 193 b_ptr->media->send_msg(rbuf, b_ptr, &media_addr);
197 buf_discard(rbuf); 194 buf_discard(rbuf);
198 } 195 }
199 } 196 }
@@ -249,9 +246,9 @@ void tipc_disc_update_link_req(struct link_req *req)
249 246
250static void disc_timeout(struct link_req *req) 247static void disc_timeout(struct link_req *req)
251{ 248{
252 spin_lock_bh(&req->bearer->publ.lock); 249 spin_lock_bh(&req->bearer->lock);
253 250
254 req->bearer->media->send_msg(req->buf, &req->bearer->publ, &req->dest); 251 req->bearer->media->send_msg(req->buf, req->bearer, &req->dest);
255 252
256 if ((req->timer_intv == TIPC_LINK_REQ_SLOW) || 253 if ((req->timer_intv == TIPC_LINK_REQ_SLOW) ||
257 (req->timer_intv == TIPC_LINK_REQ_FAST)) { 254 (req->timer_intv == TIPC_LINK_REQ_FAST)) {
@@ -266,7 +263,7 @@ static void disc_timeout(struct link_req *req)
266 } 263 }
267 k_start_timer(&req->timer, req->timer_intv); 264 k_start_timer(&req->timer, req->timer_intv);
268 265
269 spin_unlock_bh(&req->bearer->publ.lock); 266 spin_unlock_bh(&req->bearer->lock);
270} 267}
271 268
272/** 269/**
@@ -274,15 +271,13 @@ static void disc_timeout(struct link_req *req)
274 * @b_ptr: ptr to bearer issuing requests 271 * @b_ptr: ptr to bearer issuing requests
275 * @dest: destination address for request messages 272 * @dest: destination address for request messages
276 * @dest_domain: network domain of node(s) which should respond to message 273 * @dest_domain: network domain of node(s) which should respond to message
277 * @req_links: max number of desired links
278 * 274 *
279 * Returns pointer to link request structure, or NULL if unable to create. 275 * Returns pointer to link request structure, or NULL if unable to create.
280 */ 276 */
281 277
282struct link_req *tipc_disc_init_link_req(struct bearer *b_ptr, 278struct link_req *tipc_disc_init_link_req(struct tipc_bearer *b_ptr,
283 const struct tipc_media_addr *dest, 279 const struct tipc_media_addr *dest,
284 u32 dest_domain, 280 u32 dest_domain)
285 u32 req_links)
286{ 281{
287 struct link_req *req; 282 struct link_req *req;
288 283
@@ -290,7 +285,7 @@ struct link_req *tipc_disc_init_link_req(struct bearer *b_ptr,
290 if (!req) 285 if (!req)
291 return NULL; 286 return NULL;
292 287
293 req->buf = tipc_disc_init_msg(DSC_REQ_MSG, req_links, dest_domain, b_ptr); 288 req->buf = tipc_disc_init_msg(DSC_REQ_MSG, dest_domain, b_ptr);
294 if (!req->buf) { 289 if (!req->buf) {
295 kfree(req); 290 kfree(req);
296 return NULL; 291 return NULL;
diff --git a/net/tipc/discover.h b/net/tipc/discover.h
index d2c3cffb79fc..e48a167e47b2 100644
--- a/net/tipc/discover.h
+++ b/net/tipc/discover.h
@@ -2,7 +2,7 @@
2 * net/tipc/discover.h 2 * net/tipc/discover.h
3 * 3 *
4 * Copyright (c) 2003-2006, Ericsson AB 4 * Copyright (c) 2003-2006, Ericsson AB
5 * Copyright (c) 2005, Wind River Systems 5 * Copyright (c) 2005, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -39,13 +39,12 @@
39 39
40struct link_req; 40struct link_req;
41 41
42struct link_req *tipc_disc_init_link_req(struct bearer *b_ptr, 42struct link_req *tipc_disc_init_link_req(struct tipc_bearer *b_ptr,
43 const struct tipc_media_addr *dest, 43 const struct tipc_media_addr *dest,
44 u32 dest_domain, 44 u32 dest_domain);
45 u32 req_links);
46void tipc_disc_update_link_req(struct link_req *req); 45void tipc_disc_update_link_req(struct link_req *req);
47void tipc_disc_stop_link_req(struct link_req *req); 46void tipc_disc_stop_link_req(struct link_req *req);
48 47
49void tipc_disc_recv_msg(struct sk_buff *buf, struct bearer *b_ptr); 48void tipc_disc_recv_msg(struct sk_buff *buf, struct tipc_bearer *b_ptr);
50 49
51#endif 50#endif
diff --git a/net/tipc/link.c b/net/tipc/link.c
index 18702f58d111..89fbb6d6e956 100644
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -2,7 +2,7 @@
2 * net/tipc/link.c: TIPC link code 2 * net/tipc/link.c: TIPC link code
3 * 3 *
4 * Copyright (c) 1996-2007, Ericsson AB 4 * Copyright (c) 1996-2007, Ericsson AB
5 * Copyright (c) 2004-2007, Wind River Systems 5 * Copyright (c) 2004-2007, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -90,7 +90,7 @@ static void link_handle_out_of_seq_msg(struct link *l_ptr,
90static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf); 90static void link_recv_proto_msg(struct link *l_ptr, struct sk_buff *buf);
91static int link_recv_changeover_msg(struct link **l_ptr, struct sk_buff **buf); 91static int link_recv_changeover_msg(struct link **l_ptr, struct sk_buff **buf);
92static void link_set_supervision_props(struct link *l_ptr, u32 tolerance); 92static void link_set_supervision_props(struct link *l_ptr, u32 tolerance);
93static int link_send_sections_long(struct port *sender, 93static int link_send_sections_long(struct tipc_port *sender,
94 struct iovec const *msg_sect, 94 struct iovec const *msg_sect,
95 u32 num_sect, u32 destnode); 95 u32 num_sect, u32 destnode);
96static void link_check_defragm_bufs(struct link *l_ptr); 96static void link_check_defragm_bufs(struct link *l_ptr);
@@ -113,7 +113,7 @@ static void link_init_max_pkt(struct link *l_ptr)
113{ 113{
114 u32 max_pkt; 114 u32 max_pkt;
115 115
116 max_pkt = (l_ptr->b_ptr->publ.mtu & ~3); 116 max_pkt = (l_ptr->b_ptr->mtu & ~3);
117 if (max_pkt > MAX_MSG_SIZE) 117 if (max_pkt > MAX_MSG_SIZE)
118 max_pkt = MAX_MSG_SIZE; 118 max_pkt = MAX_MSG_SIZE;
119 119
@@ -246,9 +246,6 @@ static void link_timeout(struct link *l_ptr)
246 l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size; 246 l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size;
247 l_ptr->stats.queue_sz_counts++; 247 l_ptr->stats.queue_sz_counts++;
248 248
249 if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz)
250 l_ptr->stats.max_queue_sz = l_ptr->out_queue_size;
251
252 if (l_ptr->first_out) { 249 if (l_ptr->first_out) {
253 struct tipc_msg *msg = buf_msg(l_ptr->first_out); 250 struct tipc_msg *msg = buf_msg(l_ptr->first_out);
254 u32 length = msg_size(msg); 251 u32 length = msg_size(msg);
@@ -303,7 +300,7 @@ static void link_set_timer(struct link *l_ptr, u32 time)
303 * Returns pointer to link. 300 * Returns pointer to link.
304 */ 301 */
305 302
306struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer, 303struct link *tipc_link_create(struct tipc_bearer *b_ptr, const u32 peer,
307 const struct tipc_media_addr *media_addr) 304 const struct tipc_media_addr *media_addr)
308{ 305{
309 struct link *l_ptr; 306 struct link *l_ptr;
@@ -317,7 +314,7 @@ struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer,
317 } 314 }
318 315
319 l_ptr->addr = peer; 316 l_ptr->addr = peer;
320 if_name = strchr(b_ptr->publ.name, ':') + 1; 317 if_name = strchr(b_ptr->name, ':') + 1;
321 sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:", 318 sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:",
322 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr), 319 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
323 tipc_node(tipc_own_addr), 320 tipc_node(tipc_own_addr),
@@ -391,7 +388,9 @@ void tipc_link_delete(struct link *l_ptr)
391 388
392static void link_start(struct link *l_ptr) 389static void link_start(struct link *l_ptr)
393{ 390{
391 tipc_node_lock(l_ptr->owner);
394 link_state_event(l_ptr, STARTING_EVT); 392 link_state_event(l_ptr, STARTING_EVT);
393 tipc_node_unlock(l_ptr->owner);
395} 394}
396 395
397/** 396/**
@@ -406,7 +405,7 @@ static void link_start(struct link *l_ptr)
406 405
407static int link_schedule_port(struct link *l_ptr, u32 origport, u32 sz) 406static int link_schedule_port(struct link *l_ptr, u32 origport, u32 sz)
408{ 407{
409 struct port *p_ptr; 408 struct tipc_port *p_ptr;
410 409
411 spin_lock_bh(&tipc_port_list_lock); 410 spin_lock_bh(&tipc_port_list_lock);
412 p_ptr = tipc_port_lock(origport); 411 p_ptr = tipc_port_lock(origport);
@@ -415,7 +414,7 @@ static int link_schedule_port(struct link *l_ptr, u32 origport, u32 sz)
415 goto exit; 414 goto exit;
416 if (!list_empty(&p_ptr->wait_list)) 415 if (!list_empty(&p_ptr->wait_list))
417 goto exit; 416 goto exit;
418 p_ptr->publ.congested = 1; 417 p_ptr->congested = 1;
419 p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt); 418 p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt);
420 list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports); 419 list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);
421 l_ptr->stats.link_congs++; 420 l_ptr->stats.link_congs++;
@@ -428,8 +427,8 @@ exit:
428 427
429void tipc_link_wakeup_ports(struct link *l_ptr, int all) 428void tipc_link_wakeup_ports(struct link *l_ptr, int all)
430{ 429{
431 struct port *p_ptr; 430 struct tipc_port *p_ptr;
432 struct port *temp_p_ptr; 431 struct tipc_port *temp_p_ptr;
433 int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size; 432 int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size;
434 433
435 if (all) 434 if (all)
@@ -445,11 +444,11 @@ void tipc_link_wakeup_ports(struct link *l_ptr, int all)
445 if (win <= 0) 444 if (win <= 0)
446 break; 445 break;
447 list_del_init(&p_ptr->wait_list); 446 list_del_init(&p_ptr->wait_list);
448 spin_lock_bh(p_ptr->publ.lock); 447 spin_lock_bh(p_ptr->lock);
449 p_ptr->publ.congested = 0; 448 p_ptr->congested = 0;
450 p_ptr->wakeup(&p_ptr->publ); 449 p_ptr->wakeup(p_ptr);
451 win -= p_ptr->waiting_pkts; 450 win -= p_ptr->waiting_pkts;
452 spin_unlock_bh(p_ptr->publ.lock); 451 spin_unlock_bh(p_ptr->lock);
453 } 452 }
454 453
455exit: 454exit:
@@ -824,7 +823,10 @@ static void link_add_to_outqueue(struct link *l_ptr,
824 l_ptr->last_out = buf; 823 l_ptr->last_out = buf;
825 } else 824 } else
826 l_ptr->first_out = l_ptr->last_out = buf; 825 l_ptr->first_out = l_ptr->last_out = buf;
826
827 l_ptr->out_queue_size++; 827 l_ptr->out_queue_size++;
828 if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz)
829 l_ptr->stats.max_queue_sz = l_ptr->out_queue_size;
828} 830}
829 831
830/* 832/*
@@ -867,9 +869,6 @@ int tipc_link_send_buf(struct link *l_ptr, struct sk_buff *buf)
867 869
868 /* Packet can be queued or sent: */ 870 /* Packet can be queued or sent: */
869 871
870 if (queue_size > l_ptr->stats.max_queue_sz)
871 l_ptr->stats.max_queue_sz = queue_size;
872
873 if (likely(!tipc_bearer_congested(l_ptr->b_ptr, l_ptr) && 872 if (likely(!tipc_bearer_congested(l_ptr->b_ptr, l_ptr) &&
874 !link_congested(l_ptr))) { 873 !link_congested(l_ptr))) {
875 link_add_to_outqueue(l_ptr, buf, msg); 874 link_add_to_outqueue(l_ptr, buf, msg);
@@ -1027,12 +1026,12 @@ int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
1027 * except for total message length. 1026 * except for total message length.
1028 * Returns user data length or errno. 1027 * Returns user data length or errno.
1029 */ 1028 */
1030int tipc_link_send_sections_fast(struct port *sender, 1029int tipc_link_send_sections_fast(struct tipc_port *sender,
1031 struct iovec const *msg_sect, 1030 struct iovec const *msg_sect,
1032 const u32 num_sect, 1031 const u32 num_sect,
1033 u32 destaddr) 1032 u32 destaddr)
1034{ 1033{
1035 struct tipc_msg *hdr = &sender->publ.phdr; 1034 struct tipc_msg *hdr = &sender->phdr;
1036 struct link *l_ptr; 1035 struct link *l_ptr;
1037 struct sk_buff *buf; 1036 struct sk_buff *buf;
1038 struct tipc_node *node; 1037 struct tipc_node *node;
@@ -1045,7 +1044,7 @@ again:
1045 * (Must not hold any locks while building message.) 1044 * (Must not hold any locks while building message.)
1046 */ 1045 */
1047 1046
1048 res = tipc_msg_build(hdr, msg_sect, num_sect, sender->publ.max_pkt, 1047 res = tipc_msg_build(hdr, msg_sect, num_sect, sender->max_pkt,
1049 !sender->user_port, &buf); 1048 !sender->user_port, &buf);
1050 1049
1051 read_lock_bh(&tipc_net_lock); 1050 read_lock_bh(&tipc_net_lock);
@@ -1056,7 +1055,7 @@ again:
1056 if (likely(l_ptr)) { 1055 if (likely(l_ptr)) {
1057 if (likely(buf)) { 1056 if (likely(buf)) {
1058 res = link_send_buf_fast(l_ptr, buf, 1057 res = link_send_buf_fast(l_ptr, buf,
1059 &sender->publ.max_pkt); 1058 &sender->max_pkt);
1060 if (unlikely(res < 0)) 1059 if (unlikely(res < 0))
1061 buf_discard(buf); 1060 buf_discard(buf);
1062exit: 1061exit:
@@ -1075,7 +1074,7 @@ exit:
1075 if (link_congested(l_ptr) || 1074 if (link_congested(l_ptr) ||
1076 !list_empty(&l_ptr->b_ptr->cong_links)) { 1075 !list_empty(&l_ptr->b_ptr->cong_links)) {
1077 res = link_schedule_port(l_ptr, 1076 res = link_schedule_port(l_ptr,
1078 sender->publ.ref, res); 1077 sender->ref, res);
1079 goto exit; 1078 goto exit;
1080 } 1079 }
1081 1080
@@ -1084,12 +1083,12 @@ exit:
1084 * then re-try fast path or fragment the message 1083 * then re-try fast path or fragment the message
1085 */ 1084 */
1086 1085
1087 sender->publ.max_pkt = l_ptr->max_pkt; 1086 sender->max_pkt = l_ptr->max_pkt;
1088 tipc_node_unlock(node); 1087 tipc_node_unlock(node);
1089 read_unlock_bh(&tipc_net_lock); 1088 read_unlock_bh(&tipc_net_lock);
1090 1089
1091 1090
1092 if ((msg_hdr_sz(hdr) + res) <= sender->publ.max_pkt) 1091 if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
1093 goto again; 1092 goto again;
1094 1093
1095 return link_send_sections_long(sender, msg_sect, 1094 return link_send_sections_long(sender, msg_sect,
@@ -1123,14 +1122,14 @@ exit:
1123 * 1122 *
1124 * Returns user data length or errno. 1123 * Returns user data length or errno.
1125 */ 1124 */
1126static int link_send_sections_long(struct port *sender, 1125static int link_send_sections_long(struct tipc_port *sender,
1127 struct iovec const *msg_sect, 1126 struct iovec const *msg_sect,
1128 u32 num_sect, 1127 u32 num_sect,
1129 u32 destaddr) 1128 u32 destaddr)
1130{ 1129{
1131 struct link *l_ptr; 1130 struct link *l_ptr;
1132 struct tipc_node *node; 1131 struct tipc_node *node;
1133 struct tipc_msg *hdr = &sender->publ.phdr; 1132 struct tipc_msg *hdr = &sender->phdr;
1134 u32 dsz = msg_data_sz(hdr); 1133 u32 dsz = msg_data_sz(hdr);
1135 u32 max_pkt, fragm_sz, rest; 1134 u32 max_pkt, fragm_sz, rest;
1136 struct tipc_msg fragm_hdr; 1135 struct tipc_msg fragm_hdr;
@@ -1142,7 +1141,7 @@ static int link_send_sections_long(struct port *sender,
1142 1141
1143again: 1142again:
1144 fragm_no = 1; 1143 fragm_no = 1;
1145 max_pkt = sender->publ.max_pkt - INT_H_SIZE; 1144 max_pkt = sender->max_pkt - INT_H_SIZE;
1146 /* leave room for tunnel header in case of link changeover */ 1145 /* leave room for tunnel header in case of link changeover */
1147 fragm_sz = max_pkt - INT_H_SIZE; 1146 fragm_sz = max_pkt - INT_H_SIZE;
1148 /* leave room for fragmentation header in each fragment */ 1147 /* leave room for fragmentation header in each fragment */
@@ -1157,7 +1156,7 @@ again:
1157 1156
1158 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT, 1157 tipc_msg_init(&fragm_hdr, MSG_FRAGMENTER, FIRST_FRAGMENT,
1159 INT_H_SIZE, msg_destnode(hdr)); 1158 INT_H_SIZE, msg_destnode(hdr));
1160 msg_set_link_selector(&fragm_hdr, sender->publ.ref); 1159 msg_set_link_selector(&fragm_hdr, sender->ref);
1161 msg_set_size(&fragm_hdr, max_pkt); 1160 msg_set_size(&fragm_hdr, max_pkt);
1162 msg_set_fragm_no(&fragm_hdr, 1); 1161 msg_set_fragm_no(&fragm_hdr, 1);
1163 1162
@@ -1238,13 +1237,13 @@ error:
1238 node = tipc_node_find(destaddr); 1237 node = tipc_node_find(destaddr);
1239 if (likely(node)) { 1238 if (likely(node)) {
1240 tipc_node_lock(node); 1239 tipc_node_lock(node);
1241 l_ptr = node->active_links[sender->publ.ref & 1]; 1240 l_ptr = node->active_links[sender->ref & 1];
1242 if (!l_ptr) { 1241 if (!l_ptr) {
1243 tipc_node_unlock(node); 1242 tipc_node_unlock(node);
1244 goto reject; 1243 goto reject;
1245 } 1244 }
1246 if (l_ptr->max_pkt < max_pkt) { 1245 if (l_ptr->max_pkt < max_pkt) {
1247 sender->publ.max_pkt = l_ptr->max_pkt; 1246 sender->max_pkt = l_ptr->max_pkt;
1248 tipc_node_unlock(node); 1247 tipc_node_unlock(node);
1249 for (; buf_chain; buf_chain = buf) { 1248 for (; buf_chain; buf_chain = buf) {
1250 buf = buf_chain->next; 1249 buf = buf_chain->next;
@@ -1441,7 +1440,7 @@ static void link_retransmit_failure(struct link *l_ptr, struct sk_buff *buf)
1441 info("Outstanding acks: %lu\n", 1440 info("Outstanding acks: %lu\n",
1442 (unsigned long) TIPC_SKB_CB(buf)->handle); 1441 (unsigned long) TIPC_SKB_CB(buf)->handle);
1443 1442
1444 n_ptr = l_ptr->owner->next; 1443 n_ptr = tipc_bclink_retransmit_to();
1445 tipc_node_lock(n_ptr); 1444 tipc_node_lock(n_ptr);
1446 1445
1447 tipc_addr_string_fill(addr_string, n_ptr->addr); 1446 tipc_addr_string_fill(addr_string, n_ptr->addr);
@@ -1595,11 +1594,10 @@ static int link_recv_buf_validate(struct sk_buff *buf)
1595 * structure (i.e. cannot be NULL), but bearer can be inactive. 1594 * structure (i.e. cannot be NULL), but bearer can be inactive.
1596 */ 1595 */
1597 1596
1598void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *tb_ptr) 1597void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *b_ptr)
1599{ 1598{
1600 read_lock_bh(&tipc_net_lock); 1599 read_lock_bh(&tipc_net_lock);
1601 while (head) { 1600 while (head) {
1602 struct bearer *b_ptr = (struct bearer *)tb_ptr;
1603 struct tipc_node *n_ptr; 1601 struct tipc_node *n_ptr;
1604 struct link *l_ptr; 1602 struct link *l_ptr;
1605 struct sk_buff *crs; 1603 struct sk_buff *crs;
@@ -1950,6 +1948,7 @@ void tipc_link_send_proto_msg(struct link *l_ptr, u32 msg_typ, int probe_msg,
1950 msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1)); 1948 msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
1951 msg_set_seq_gap(msg, 0); 1949 msg_set_seq_gap(msg, 0);
1952 msg_set_next_sent(msg, 1); 1950 msg_set_next_sent(msg, 1);
1951 msg_set_probe(msg, 0);
1953 msg_set_link_tolerance(msg, l_ptr->tolerance); 1952 msg_set_link_tolerance(msg, l_ptr->tolerance);
1954 msg_set_linkprio(msg, l_ptr->priority); 1953 msg_set_linkprio(msg, l_ptr->priority);
1955 msg_set_max_pkt(msg, l_ptr->max_pkt_target); 1954 msg_set_max_pkt(msg, l_ptr->max_pkt_target);
@@ -2618,6 +2617,9 @@ static void link_check_defragm_bufs(struct link *l_ptr)
2618 2617
2619static void link_set_supervision_props(struct link *l_ptr, u32 tolerance) 2618static void link_set_supervision_props(struct link *l_ptr, u32 tolerance)
2620{ 2619{
2620 if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
2621 return;
2622
2621 l_ptr->tolerance = tolerance; 2623 l_ptr->tolerance = tolerance;
2622 l_ptr->continuity_interval = 2624 l_ptr->continuity_interval =
2623 ((tolerance / 4) > 500) ? 500 : tolerance / 4; 2625 ((tolerance / 4) > 500) ? 500 : tolerance / 4;
@@ -2658,7 +2660,7 @@ void tipc_link_set_queue_limits(struct link *l_ptr, u32 window)
2658static struct link *link_find_link(const char *name, struct tipc_node **node) 2660static struct link *link_find_link(const char *name, struct tipc_node **node)
2659{ 2661{
2660 struct link_name link_name_parts; 2662 struct link_name link_name_parts;
2661 struct bearer *b_ptr; 2663 struct tipc_bearer *b_ptr;
2662 struct link *l_ptr; 2664 struct link *l_ptr;
2663 2665
2664 if (!link_name_validate(name, &link_name_parts)) 2666 if (!link_name_validate(name, &link_name_parts))
@@ -2961,7 +2963,7 @@ static void link_print(struct link *l_ptr, const char *str)
2961 2963
2962 tipc_printf(buf, str); 2964 tipc_printf(buf, str);
2963 tipc_printf(buf, "Link %x<%s>:", 2965 tipc_printf(buf, "Link %x<%s>:",
2964 l_ptr->addr, l_ptr->b_ptr->publ.name); 2966 l_ptr->addr, l_ptr->b_ptr->name);
2965 2967
2966#ifdef CONFIG_TIPC_DEBUG 2968#ifdef CONFIG_TIPC_DEBUG
2967 if (link_reset_reset(l_ptr) || link_reset_unknown(l_ptr)) 2969 if (link_reset_reset(l_ptr) || link_reset_unknown(l_ptr))
@@ -2981,9 +2983,9 @@ static void link_print(struct link *l_ptr, const char *str)
2981 != (l_ptr->out_queue_size - 1)) || 2983 != (l_ptr->out_queue_size - 1)) ||
2982 (l_ptr->last_out->next != NULL)) { 2984 (l_ptr->last_out->next != NULL)) {
2983 tipc_printf(buf, "\nSend queue inconsistency\n"); 2985 tipc_printf(buf, "\nSend queue inconsistency\n");
2984 tipc_printf(buf, "first_out= %x ", l_ptr->first_out); 2986 tipc_printf(buf, "first_out= %p ", l_ptr->first_out);
2985 tipc_printf(buf, "next_out= %x ", l_ptr->next_out); 2987 tipc_printf(buf, "next_out= %p ", l_ptr->next_out);
2986 tipc_printf(buf, "last_out= %x ", l_ptr->last_out); 2988 tipc_printf(buf, "last_out= %p ", l_ptr->last_out);
2987 } 2989 }
2988 } else 2990 } else
2989 tipc_printf(buf, "[]"); 2991 tipc_printf(buf, "[]");
diff --git a/net/tipc/link.h b/net/tipc/link.h
index 70967e637027..a7794e7ede29 100644
--- a/net/tipc/link.h
+++ b/net/tipc/link.h
@@ -2,7 +2,7 @@
2 * net/tipc/link.h: Include file for TIPC link code 2 * net/tipc/link.h: Include file for TIPC link code
3 * 3 *
4 * Copyright (c) 1995-2006, Ericsson AB 4 * Copyright (c) 1995-2006, Ericsson AB
5 * Copyright (c) 2004-2005, Wind River Systems 5 * Copyright (c) 2004-2005, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -122,7 +122,7 @@ struct link {
122 u32 checkpoint; 122 u32 checkpoint;
123 u32 peer_session; 123 u32 peer_session;
124 u32 peer_bearer_id; 124 u32 peer_bearer_id;
125 struct bearer *b_ptr; 125 struct tipc_bearer *b_ptr;
126 u32 tolerance; 126 u32 tolerance;
127 u32 continuity_interval; 127 u32 continuity_interval;
128 u32 abort_limit; 128 u32 abort_limit;
@@ -196,24 +196,18 @@ struct link {
196 u32 bearer_congs; 196 u32 bearer_congs;
197 u32 deferred_recv; 197 u32 deferred_recv;
198 u32 duplicates; 198 u32 duplicates;
199 199 u32 max_queue_sz; /* send queue size high water mark */
200 /* for statistical profiling of send queue size */ 200 u32 accu_queue_sz; /* used for send queue size profiling */
201 201 u32 queue_sz_counts; /* used for send queue size profiling */
202 u32 max_queue_sz; 202 u32 msg_length_counts; /* used for message length profiling */
203 u32 accu_queue_sz; 203 u32 msg_lengths_total; /* used for message length profiling */
204 u32 queue_sz_counts; 204 u32 msg_length_profile[7]; /* used for msg. length profiling */
205
206 /* for statistical profiling of message lengths */
207
208 u32 msg_length_counts;
209 u32 msg_lengths_total;
210 u32 msg_length_profile[7];
211 } stats; 205 } stats;
212}; 206};
213 207
214struct port; 208struct tipc_port;
215 209
216struct link *tipc_link_create(struct bearer *b_ptr, const u32 peer, 210struct link *tipc_link_create(struct tipc_bearer *b_ptr, const u32 peer,
217 const struct tipc_media_addr *media_addr); 211 const struct tipc_media_addr *media_addr);
218void tipc_link_delete(struct link *l_ptr); 212void tipc_link_delete(struct link *l_ptr);
219void tipc_link_changeover(struct link *l_ptr); 213void tipc_link_changeover(struct link *l_ptr);
@@ -230,7 +224,7 @@ void tipc_link_reset(struct link *l_ptr);
230int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector); 224int tipc_link_send(struct sk_buff *buf, u32 dest, u32 selector);
231int tipc_link_send_buf(struct link *l_ptr, struct sk_buff *buf); 225int tipc_link_send_buf(struct link *l_ptr, struct sk_buff *buf);
232u32 tipc_link_get_max_pkt(u32 dest, u32 selector); 226u32 tipc_link_get_max_pkt(u32 dest, u32 selector);
233int tipc_link_send_sections_fast(struct port *sender, 227int tipc_link_send_sections_fast(struct tipc_port *sender,
234 struct iovec const *msg_sect, 228 struct iovec const *msg_sect,
235 const u32 num_sect, 229 const u32 num_sect,
236 u32 destnode); 230 u32 destnode);
diff --git a/net/tipc/msg.c b/net/tipc/msg.c
index bb6180c4fcbb..0787e12423b8 100644
--- a/net/tipc/msg.c
+++ b/net/tipc/msg.c
@@ -2,7 +2,7 @@
2 * net/tipc/msg.c: TIPC message header routines 2 * net/tipc/msg.c: TIPC message header routines
3 * 3 *
4 * Copyright (c) 2000-2006, Ericsson AB 4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2005, Wind River Systems 5 * Copyright (c) 2005, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -381,20 +381,15 @@ void tipc_msg_dbg(struct print_buf *buf, struct tipc_msg *msg, const char *str)
381 tipc_printf(buf, ":OPRT(%u):", msg_origport(msg)); 381 tipc_printf(buf, ":OPRT(%u):", msg_origport(msg));
382 tipc_printf(buf, ":DPRT(%u):", msg_destport(msg)); 382 tipc_printf(buf, ":DPRT(%u):", msg_destport(msg));
383 } 383 }
384 if (msg_routed(msg) && !msg_non_seq(msg))
385 tipc_printf(buf, ":TSEQN(%u)", msg_transp_seqno(msg));
386 } 384 }
387 if (msg_user(msg) == NAME_DISTRIBUTOR) { 385 if (msg_user(msg) == NAME_DISTRIBUTOR) {
388 tipc_printf(buf, ":ONOD(%x):", msg_orignode(msg)); 386 tipc_printf(buf, ":ONOD(%x):", msg_orignode(msg));
389 tipc_printf(buf, ":DNOD(%x):", msg_destnode(msg)); 387 tipc_printf(buf, ":DNOD(%x):", msg_destnode(msg));
390 if (msg_routed(msg))
391 tipc_printf(buf, ":CSEQN(%u)", msg_transp_seqno(msg));
392 } 388 }
393 389
394 if (msg_user(msg) == LINK_CONFIG) { 390 if (msg_user(msg) == LINK_CONFIG) {
395 u32 *raw = (u32 *)msg; 391 u32 *raw = (u32 *)msg;
396 struct tipc_media_addr *orig = (struct tipc_media_addr *)&raw[5]; 392 struct tipc_media_addr *orig = (struct tipc_media_addr *)&raw[5];
397 tipc_printf(buf, ":REQL(%u):", msg_req_links(msg));
398 tipc_printf(buf, ":DDOM(%x):", msg_dest_domain(msg)); 393 tipc_printf(buf, ":DDOM(%x):", msg_dest_domain(msg));
399 tipc_printf(buf, ":NETID(%u):", msg_bc_netid(msg)); 394 tipc_printf(buf, ":NETID(%u):", msg_bc_netid(msg));
400 tipc_media_addr_printf(buf, orig); 395 tipc_media_addr_printf(buf, orig);
diff --git a/net/tipc/msg.h b/net/tipc/msg.h
index 92c4c4fd7b3f..9d643a1b7d22 100644
--- a/net/tipc/msg.h
+++ b/net/tipc/msg.h
@@ -2,7 +2,7 @@
2 * net/tipc/msg.h: Include file for TIPC message header routines 2 * net/tipc/msg.h: Include file for TIPC message header routines
3 * 3 *
4 * Copyright (c) 2000-2007, Ericsson AB 4 * Copyright (c) 2000-2007, Ericsson AB
5 * Copyright (c) 2005-2008, Wind River Systems 5 * Copyright (c) 2005-2008, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -438,11 +438,6 @@ static inline void msg_set_nametype(struct tipc_msg *m, u32 n)
438 msg_set_word(m, 8, n); 438 msg_set_word(m, 8, n);
439} 439}
440 440
441static inline u32 msg_transp_seqno(struct tipc_msg *m)
442{
443 return msg_word(m, 8);
444}
445
446static inline void msg_set_timestamp(struct tipc_msg *m, u32 n) 441static inline void msg_set_timestamp(struct tipc_msg *m, u32 n)
447{ 442{
448 msg_set_word(m, 8, n); 443 msg_set_word(m, 8, n);
@@ -453,11 +448,6 @@ static inline u32 msg_timestamp(struct tipc_msg *m)
453 return msg_word(m, 8); 448 return msg_word(m, 8);
454} 449}
455 450
456static inline void msg_set_transp_seqno(struct tipc_msg *m, u32 n)
457{
458 msg_set_word(m, 8, n);
459}
460
461static inline u32 msg_nameinst(struct tipc_msg *m) 451static inline u32 msg_nameinst(struct tipc_msg *m)
462{ 452{
463 return msg_word(m, 9); 453 return msg_word(m, 9);
@@ -577,16 +567,6 @@ static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
577 msg_set_bits(m, 1, 16, 0x1fff, n); 567 msg_set_bits(m, 1, 16, 0x1fff, n);
578} 568}
579 569
580static inline u32 msg_req_links(struct tipc_msg *m)
581{
582 return msg_bits(m, 1, 16, 0xfff);
583}
584
585static inline void msg_set_req_links(struct tipc_msg *m, u32 n)
586{
587 msg_set_bits(m, 1, 16, 0xfff, n);
588}
589
590 570
591/* 571/*
592 * Word 2 572 * Word 2
diff --git a/net/tipc/node.c b/net/tipc/node.c
index 3af53e327f49..e4dba1dfb6ea 100644
--- a/net/tipc/node.c
+++ b/net/tipc/node.c
@@ -2,7 +2,7 @@
2 * net/tipc/node.c: TIPC node management routines 2 * net/tipc/node.c: TIPC node management routines
3 * 3 *
4 * Copyright (c) 2000-2006, Ericsson AB 4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2005-2006, Wind River Systems 5 * Copyright (c) 2005-2006, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -238,7 +238,7 @@ struct tipc_node *tipc_node_attach_link(struct link *l_ptr)
238 return n_ptr; 238 return n_ptr;
239 } 239 }
240 err("Attempt to establish second link on <%s> to %s\n", 240 err("Attempt to establish second link on <%s> to %s\n",
241 l_ptr->b_ptr->publ.name, 241 l_ptr->b_ptr->name,
242 tipc_addr_string_fill(addr_string, l_ptr->addr)); 242 tipc_addr_string_fill(addr_string, l_ptr->addr));
243 } 243 }
244 return NULL; 244 return NULL;
diff --git a/net/tipc/port.c b/net/tipc/port.c
index 067bab2a0b98..6ff78f9c7d65 100644
--- a/net/tipc/port.c
+++ b/net/tipc/port.c
@@ -2,7 +2,7 @@
2 * net/tipc/port.c: TIPC port code 2 * net/tipc/port.c: TIPC port code
3 * 3 *
4 * Copyright (c) 1992-2007, Ericsson AB 4 * Copyright (c) 1992-2007, Ericsson AB
5 * Copyright (c) 2004-2008, Wind River Systems 5 * Copyright (c) 2004-2008, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -54,33 +54,19 @@ static DEFINE_SPINLOCK(queue_lock);
54 54
55static LIST_HEAD(ports); 55static LIST_HEAD(ports);
56static void port_handle_node_down(unsigned long ref); 56static void port_handle_node_down(unsigned long ref);
57static struct sk_buff *port_build_self_abort_msg(struct port *, u32 err); 57static struct sk_buff *port_build_self_abort_msg(struct tipc_port *, u32 err);
58static struct sk_buff *port_build_peer_abort_msg(struct port *, u32 err); 58static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *, u32 err);
59static void port_timeout(unsigned long ref); 59static void port_timeout(unsigned long ref);
60 60
61 61
62static u32 port_peernode(struct port *p_ptr) 62static u32 port_peernode(struct tipc_port *p_ptr)
63{ 63{
64 return msg_destnode(&p_ptr->publ.phdr); 64 return msg_destnode(&p_ptr->phdr);
65} 65}
66 66
67static u32 port_peerport(struct port *p_ptr) 67static u32 port_peerport(struct tipc_port *p_ptr)
68{ 68{
69 return msg_destport(&p_ptr->publ.phdr); 69 return msg_destport(&p_ptr->phdr);
70}
71
72static u32 port_out_seqno(struct port *p_ptr)
73{
74 return msg_transp_seqno(&p_ptr->publ.phdr);
75}
76
77static void port_incr_out_seqno(struct port *p_ptr)
78{
79 struct tipc_msg *m = &p_ptr->publ.phdr;
80
81 if (likely(!msg_routed(m)))
82 return;
83 msg_set_transp_seqno(m, (msg_transp_seqno(m) + 1));
84} 70}
85 71
86/** 72/**
@@ -94,7 +80,7 @@ int tipc_multicast(u32 ref, struct tipc_name_seq const *seq,
94 struct sk_buff *buf; 80 struct sk_buff *buf;
95 struct sk_buff *ibuf = NULL; 81 struct sk_buff *ibuf = NULL;
96 struct port_list dports = {0, NULL, }; 82 struct port_list dports = {0, NULL, };
97 struct port *oport = tipc_port_deref(ref); 83 struct tipc_port *oport = tipc_port_deref(ref);
98 int ext_targets; 84 int ext_targets;
99 int res; 85 int res;
100 86
@@ -103,7 +89,7 @@ int tipc_multicast(u32 ref, struct tipc_name_seq const *seq,
103 89
104 /* Create multicast message */ 90 /* Create multicast message */
105 91
106 hdr = &oport->publ.phdr; 92 hdr = &oport->phdr;
107 msg_set_type(hdr, TIPC_MCAST_MSG); 93 msg_set_type(hdr, TIPC_MCAST_MSG);
108 msg_set_nametype(hdr, seq->type); 94 msg_set_nametype(hdr, seq->type);
109 msg_set_namelower(hdr, seq->lower); 95 msg_set_namelower(hdr, seq->lower);
@@ -211,7 +197,7 @@ struct tipc_port *tipc_createport_raw(void *usr_handle,
211 void (*wakeup)(struct tipc_port *), 197 void (*wakeup)(struct tipc_port *),
212 const u32 importance) 198 const u32 importance)
213{ 199{
214 struct port *p_ptr; 200 struct tipc_port *p_ptr;
215 struct tipc_msg *msg; 201 struct tipc_msg *msg;
216 u32 ref; 202 u32 ref;
217 203
@@ -220,21 +206,19 @@ struct tipc_port *tipc_createport_raw(void *usr_handle,
220 warn("Port creation failed, no memory\n"); 206 warn("Port creation failed, no memory\n");
221 return NULL; 207 return NULL;
222 } 208 }
223 ref = tipc_ref_acquire(p_ptr, &p_ptr->publ.lock); 209 ref = tipc_ref_acquire(p_ptr, &p_ptr->lock);
224 if (!ref) { 210 if (!ref) {
225 warn("Port creation failed, reference table exhausted\n"); 211 warn("Port creation failed, reference table exhausted\n");
226 kfree(p_ptr); 212 kfree(p_ptr);
227 return NULL; 213 return NULL;
228 } 214 }
229 215
230 p_ptr->publ.usr_handle = usr_handle; 216 p_ptr->usr_handle = usr_handle;
231 p_ptr->publ.max_pkt = MAX_PKT_DEFAULT; 217 p_ptr->max_pkt = MAX_PKT_DEFAULT;
232 p_ptr->publ.ref = ref; 218 p_ptr->ref = ref;
233 msg = &p_ptr->publ.phdr; 219 msg = &p_ptr->phdr;
234 tipc_msg_init(msg, importance, TIPC_NAMED_MSG, LONG_H_SIZE, 0); 220 tipc_msg_init(msg, importance, TIPC_NAMED_MSG, LONG_H_SIZE, 0);
235 msg_set_origport(msg, ref); 221 msg_set_origport(msg, ref);
236 p_ptr->last_in_seqno = 41;
237 p_ptr->sent = 1;
238 INIT_LIST_HEAD(&p_ptr->wait_list); 222 INIT_LIST_HEAD(&p_ptr->wait_list);
239 INIT_LIST_HEAD(&p_ptr->subscription.nodesub_list); 223 INIT_LIST_HEAD(&p_ptr->subscription.nodesub_list);
240 p_ptr->dispatcher = dispatcher; 224 p_ptr->dispatcher = dispatcher;
@@ -246,12 +230,12 @@ struct tipc_port *tipc_createport_raw(void *usr_handle,
246 INIT_LIST_HEAD(&p_ptr->port_list); 230 INIT_LIST_HEAD(&p_ptr->port_list);
247 list_add_tail(&p_ptr->port_list, &ports); 231 list_add_tail(&p_ptr->port_list, &ports);
248 spin_unlock_bh(&tipc_port_list_lock); 232 spin_unlock_bh(&tipc_port_list_lock);
249 return &(p_ptr->publ); 233 return p_ptr;
250} 234}
251 235
252int tipc_deleteport(u32 ref) 236int tipc_deleteport(u32 ref)
253{ 237{
254 struct port *p_ptr; 238 struct tipc_port *p_ptr;
255 struct sk_buff *buf = NULL; 239 struct sk_buff *buf = NULL;
256 240
257 tipc_withdraw(ref, 0, NULL); 241 tipc_withdraw(ref, 0, NULL);
@@ -263,7 +247,7 @@ int tipc_deleteport(u32 ref)
263 tipc_port_unlock(p_ptr); 247 tipc_port_unlock(p_ptr);
264 248
265 k_cancel_timer(&p_ptr->timer); 249 k_cancel_timer(&p_ptr->timer);
266 if (p_ptr->publ.connected) { 250 if (p_ptr->connected) {
267 buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT); 251 buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
268 tipc_nodesub_unsubscribe(&p_ptr->subscription); 252 tipc_nodesub_unsubscribe(&p_ptr->subscription);
269 } 253 }
@@ -279,14 +263,14 @@ int tipc_deleteport(u32 ref)
279 return 0; 263 return 0;
280} 264}
281 265
282static int port_unreliable(struct port *p_ptr) 266static int port_unreliable(struct tipc_port *p_ptr)
283{ 267{
284 return msg_src_droppable(&p_ptr->publ.phdr); 268 return msg_src_droppable(&p_ptr->phdr);
285} 269}
286 270
287int tipc_portunreliable(u32 ref, unsigned int *isunreliable) 271int tipc_portunreliable(u32 ref, unsigned int *isunreliable)
288{ 272{
289 struct port *p_ptr; 273 struct tipc_port *p_ptr;
290 274
291 p_ptr = tipc_port_lock(ref); 275 p_ptr = tipc_port_lock(ref);
292 if (!p_ptr) 276 if (!p_ptr)
@@ -298,24 +282,24 @@ int tipc_portunreliable(u32 ref, unsigned int *isunreliable)
298 282
299int tipc_set_portunreliable(u32 ref, unsigned int isunreliable) 283int tipc_set_portunreliable(u32 ref, unsigned int isunreliable)
300{ 284{
301 struct port *p_ptr; 285 struct tipc_port *p_ptr;
302 286
303 p_ptr = tipc_port_lock(ref); 287 p_ptr = tipc_port_lock(ref);
304 if (!p_ptr) 288 if (!p_ptr)
305 return -EINVAL; 289 return -EINVAL;
306 msg_set_src_droppable(&p_ptr->publ.phdr, (isunreliable != 0)); 290 msg_set_src_droppable(&p_ptr->phdr, (isunreliable != 0));
307 tipc_port_unlock(p_ptr); 291 tipc_port_unlock(p_ptr);
308 return 0; 292 return 0;
309} 293}
310 294
311static int port_unreturnable(struct port *p_ptr) 295static int port_unreturnable(struct tipc_port *p_ptr)
312{ 296{
313 return msg_dest_droppable(&p_ptr->publ.phdr); 297 return msg_dest_droppable(&p_ptr->phdr);
314} 298}
315 299
316int tipc_portunreturnable(u32 ref, unsigned int *isunrejectable) 300int tipc_portunreturnable(u32 ref, unsigned int *isunrejectable)
317{ 301{
318 struct port *p_ptr; 302 struct tipc_port *p_ptr;
319 303
320 p_ptr = tipc_port_lock(ref); 304 p_ptr = tipc_port_lock(ref);
321 if (!p_ptr) 305 if (!p_ptr)
@@ -327,12 +311,12 @@ int tipc_portunreturnable(u32 ref, unsigned int *isunrejectable)
327 311
328int tipc_set_portunreturnable(u32 ref, unsigned int isunrejectable) 312int tipc_set_portunreturnable(u32 ref, unsigned int isunrejectable)
329{ 313{
330 struct port *p_ptr; 314 struct tipc_port *p_ptr;
331 315
332 p_ptr = tipc_port_lock(ref); 316 p_ptr = tipc_port_lock(ref);
333 if (!p_ptr) 317 if (!p_ptr)
334 return -EINVAL; 318 return -EINVAL;
335 msg_set_dest_droppable(&p_ptr->publ.phdr, (isunrejectable != 0)); 319 msg_set_dest_droppable(&p_ptr->phdr, (isunrejectable != 0));
336 tipc_port_unlock(p_ptr); 320 tipc_port_unlock(p_ptr);
337 return 0; 321 return 0;
338} 322}
@@ -345,7 +329,7 @@ int tipc_set_portunreturnable(u32 ref, unsigned int isunrejectable)
345static struct sk_buff *port_build_proto_msg(u32 destport, u32 destnode, 329static struct sk_buff *port_build_proto_msg(u32 destport, u32 destnode,
346 u32 origport, u32 orignode, 330 u32 origport, u32 orignode,
347 u32 usr, u32 type, u32 err, 331 u32 usr, u32 type, u32 err,
348 u32 seqno, u32 ack) 332 u32 ack)
349{ 333{
350 struct sk_buff *buf; 334 struct sk_buff *buf;
351 struct tipc_msg *msg; 335 struct tipc_msg *msg;
@@ -358,7 +342,6 @@ static struct sk_buff *port_build_proto_msg(u32 destport, u32 destnode,
358 msg_set_destport(msg, destport); 342 msg_set_destport(msg, destport);
359 msg_set_origport(msg, origport); 343 msg_set_origport(msg, origport);
360 msg_set_orignode(msg, orignode); 344 msg_set_orignode(msg, orignode);
361 msg_set_transp_seqno(msg, seqno);
362 msg_set_msgcnt(msg, ack); 345 msg_set_msgcnt(msg, ack);
363 } 346 }
364 return buf; 347 return buf;
@@ -413,10 +396,10 @@ int tipc_reject_msg(struct sk_buff *buf, u32 err)
413 /* send self-abort message when rejecting on a connected port */ 396 /* send self-abort message when rejecting on a connected port */
414 if (msg_connected(msg)) { 397 if (msg_connected(msg)) {
415 struct sk_buff *abuf = NULL; 398 struct sk_buff *abuf = NULL;
416 struct port *p_ptr = tipc_port_lock(msg_destport(msg)); 399 struct tipc_port *p_ptr = tipc_port_lock(msg_destport(msg));
417 400
418 if (p_ptr) { 401 if (p_ptr) {
419 if (p_ptr->publ.connected) 402 if (p_ptr->connected)
420 abuf = port_build_self_abort_msg(p_ptr, err); 403 abuf = port_build_self_abort_msg(p_ptr, err);
421 tipc_port_unlock(p_ptr); 404 tipc_port_unlock(p_ptr);
422 } 405 }
@@ -429,7 +412,7 @@ int tipc_reject_msg(struct sk_buff *buf, u32 err)
429 return data_sz; 412 return data_sz;
430} 413}
431 414
432int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr, 415int tipc_port_reject_sections(struct tipc_port *p_ptr, struct tipc_msg *hdr,
433 struct iovec const *msg_sect, u32 num_sect, 416 struct iovec const *msg_sect, u32 num_sect,
434 int err) 417 int err)
435{ 418{
@@ -446,13 +429,13 @@ int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
446 429
447static void port_timeout(unsigned long ref) 430static void port_timeout(unsigned long ref)
448{ 431{
449 struct port *p_ptr = tipc_port_lock(ref); 432 struct tipc_port *p_ptr = tipc_port_lock(ref);
450 struct sk_buff *buf = NULL; 433 struct sk_buff *buf = NULL;
451 434
452 if (!p_ptr) 435 if (!p_ptr)
453 return; 436 return;
454 437
455 if (!p_ptr->publ.connected) { 438 if (!p_ptr->connected) {
456 tipc_port_unlock(p_ptr); 439 tipc_port_unlock(p_ptr);
457 return; 440 return;
458 } 441 }
@@ -463,14 +446,12 @@ static void port_timeout(unsigned long ref)
463 } else { 446 } else {
464 buf = port_build_proto_msg(port_peerport(p_ptr), 447 buf = port_build_proto_msg(port_peerport(p_ptr),
465 port_peernode(p_ptr), 448 port_peernode(p_ptr),
466 p_ptr->publ.ref, 449 p_ptr->ref,
467 tipc_own_addr, 450 tipc_own_addr,
468 CONN_MANAGER, 451 CONN_MANAGER,
469 CONN_PROBE, 452 CONN_PROBE,
470 TIPC_OK, 453 TIPC_OK,
471 port_out_seqno(p_ptr),
472 0); 454 0);
473 port_incr_out_seqno(p_ptr);
474 p_ptr->probing_state = PROBING; 455 p_ptr->probing_state = PROBING;
475 k_start_timer(&p_ptr->timer, p_ptr->probing_interval); 456 k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
476 } 457 }
@@ -481,7 +462,7 @@ static void port_timeout(unsigned long ref)
481 462
482static void port_handle_node_down(unsigned long ref) 463static void port_handle_node_down(unsigned long ref)
483{ 464{
484 struct port *p_ptr = tipc_port_lock(ref); 465 struct tipc_port *p_ptr = tipc_port_lock(ref);
485 struct sk_buff *buf = NULL; 466 struct sk_buff *buf = NULL;
486 467
487 if (!p_ptr) 468 if (!p_ptr)
@@ -492,73 +473,71 @@ static void port_handle_node_down(unsigned long ref)
492} 473}
493 474
494 475
495static struct sk_buff *port_build_self_abort_msg(struct port *p_ptr, u32 err) 476static struct sk_buff *port_build_self_abort_msg(struct tipc_port *p_ptr, u32 err)
496{ 477{
497 u32 imp = msg_importance(&p_ptr->publ.phdr); 478 u32 imp = msg_importance(&p_ptr->phdr);
498 479
499 if (!p_ptr->publ.connected) 480 if (!p_ptr->connected)
500 return NULL; 481 return NULL;
501 if (imp < TIPC_CRITICAL_IMPORTANCE) 482 if (imp < TIPC_CRITICAL_IMPORTANCE)
502 imp++; 483 imp++;
503 return port_build_proto_msg(p_ptr->publ.ref, 484 return port_build_proto_msg(p_ptr->ref,
504 tipc_own_addr, 485 tipc_own_addr,
505 port_peerport(p_ptr), 486 port_peerport(p_ptr),
506 port_peernode(p_ptr), 487 port_peernode(p_ptr),
507 imp, 488 imp,
508 TIPC_CONN_MSG, 489 TIPC_CONN_MSG,
509 err, 490 err,
510 p_ptr->last_in_seqno + 1,
511 0); 491 0);
512} 492}
513 493
514 494
515static struct sk_buff *port_build_peer_abort_msg(struct port *p_ptr, u32 err) 495static struct sk_buff *port_build_peer_abort_msg(struct tipc_port *p_ptr, u32 err)
516{ 496{
517 u32 imp = msg_importance(&p_ptr->publ.phdr); 497 u32 imp = msg_importance(&p_ptr->phdr);
518 498
519 if (!p_ptr->publ.connected) 499 if (!p_ptr->connected)
520 return NULL; 500 return NULL;
521 if (imp < TIPC_CRITICAL_IMPORTANCE) 501 if (imp < TIPC_CRITICAL_IMPORTANCE)
522 imp++; 502 imp++;
523 return port_build_proto_msg(port_peerport(p_ptr), 503 return port_build_proto_msg(port_peerport(p_ptr),
524 port_peernode(p_ptr), 504 port_peernode(p_ptr),
525 p_ptr->publ.ref, 505 p_ptr->ref,
526 tipc_own_addr, 506 tipc_own_addr,
527 imp, 507 imp,
528 TIPC_CONN_MSG, 508 TIPC_CONN_MSG,
529 err, 509 err,
530 port_out_seqno(p_ptr),
531 0); 510 0);
532} 511}
533 512
534void tipc_port_recv_proto_msg(struct sk_buff *buf) 513void tipc_port_recv_proto_msg(struct sk_buff *buf)
535{ 514{
536 struct tipc_msg *msg = buf_msg(buf); 515 struct tipc_msg *msg = buf_msg(buf);
537 struct port *p_ptr = tipc_port_lock(msg_destport(msg)); 516 struct tipc_port *p_ptr = tipc_port_lock(msg_destport(msg));
538 u32 err = TIPC_OK; 517 u32 err = TIPC_OK;
539 struct sk_buff *r_buf = NULL; 518 struct sk_buff *r_buf = NULL;
540 struct sk_buff *abort_buf = NULL; 519 struct sk_buff *abort_buf = NULL;
541 520
542 if (!p_ptr) { 521 if (!p_ptr) {
543 err = TIPC_ERR_NO_PORT; 522 err = TIPC_ERR_NO_PORT;
544 } else if (p_ptr->publ.connected) { 523 } else if (p_ptr->connected) {
545 if ((port_peernode(p_ptr) != msg_orignode(msg)) || 524 if ((port_peernode(p_ptr) != msg_orignode(msg)) ||
546 (port_peerport(p_ptr) != msg_origport(msg))) { 525 (port_peerport(p_ptr) != msg_origport(msg))) {
547 err = TIPC_ERR_NO_PORT; 526 err = TIPC_ERR_NO_PORT;
548 } else if (msg_type(msg) == CONN_ACK) { 527 } else if (msg_type(msg) == CONN_ACK) {
549 int wakeup = tipc_port_congested(p_ptr) && 528 int wakeup = tipc_port_congested(p_ptr) &&
550 p_ptr->publ.congested && 529 p_ptr->congested &&
551 p_ptr->wakeup; 530 p_ptr->wakeup;
552 p_ptr->acked += msg_msgcnt(msg); 531 p_ptr->acked += msg_msgcnt(msg);
553 if (tipc_port_congested(p_ptr)) 532 if (tipc_port_congested(p_ptr))
554 goto exit; 533 goto exit;
555 p_ptr->publ.congested = 0; 534 p_ptr->congested = 0;
556 if (!wakeup) 535 if (!wakeup)
557 goto exit; 536 goto exit;
558 p_ptr->wakeup(&p_ptr->publ); 537 p_ptr->wakeup(p_ptr);
559 goto exit; 538 goto exit;
560 } 539 }
561 } else if (p_ptr->publ.published) { 540 } else if (p_ptr->published) {
562 err = TIPC_ERR_NO_PORT; 541 err = TIPC_ERR_NO_PORT;
563 } 542 }
564 if (err) { 543 if (err) {
@@ -569,7 +548,6 @@ void tipc_port_recv_proto_msg(struct sk_buff *buf)
569 TIPC_HIGH_IMPORTANCE, 548 TIPC_HIGH_IMPORTANCE,
570 TIPC_CONN_MSG, 549 TIPC_CONN_MSG,
571 err, 550 err,
572 0,
573 0); 551 0);
574 goto exit; 552 goto exit;
575 } 553 }
@@ -583,11 +561,9 @@ void tipc_port_recv_proto_msg(struct sk_buff *buf)
583 CONN_MANAGER, 561 CONN_MANAGER,
584 CONN_PROBE_REPLY, 562 CONN_PROBE_REPLY,
585 TIPC_OK, 563 TIPC_OK,
586 port_out_seqno(p_ptr),
587 0); 564 0);
588 } 565 }
589 p_ptr->probing_state = CONFIRMED; 566 p_ptr->probing_state = CONFIRMED;
590 port_incr_out_seqno(p_ptr);
591exit: 567exit:
592 if (p_ptr) 568 if (p_ptr)
593 tipc_port_unlock(p_ptr); 569 tipc_port_unlock(p_ptr);
@@ -596,29 +572,29 @@ exit:
596 buf_discard(buf); 572 buf_discard(buf);
597} 573}
598 574
599static void port_print(struct port *p_ptr, struct print_buf *buf, int full_id) 575static void port_print(struct tipc_port *p_ptr, struct print_buf *buf, int full_id)
600{ 576{
601 struct publication *publ; 577 struct publication *publ;
602 578
603 if (full_id) 579 if (full_id)
604 tipc_printf(buf, "<%u.%u.%u:%u>:", 580 tipc_printf(buf, "<%u.%u.%u:%u>:",
605 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr), 581 tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
606 tipc_node(tipc_own_addr), p_ptr->publ.ref); 582 tipc_node(tipc_own_addr), p_ptr->ref);
607 else 583 else
608 tipc_printf(buf, "%-10u:", p_ptr->publ.ref); 584 tipc_printf(buf, "%-10u:", p_ptr->ref);
609 585
610 if (p_ptr->publ.connected) { 586 if (p_ptr->connected) {
611 u32 dport = port_peerport(p_ptr); 587 u32 dport = port_peerport(p_ptr);
612 u32 destnode = port_peernode(p_ptr); 588 u32 destnode = port_peernode(p_ptr);
613 589
614 tipc_printf(buf, " connected to <%u.%u.%u:%u>", 590 tipc_printf(buf, " connected to <%u.%u.%u:%u>",
615 tipc_zone(destnode), tipc_cluster(destnode), 591 tipc_zone(destnode), tipc_cluster(destnode),
616 tipc_node(destnode), dport); 592 tipc_node(destnode), dport);
617 if (p_ptr->publ.conn_type != 0) 593 if (p_ptr->conn_type != 0)
618 tipc_printf(buf, " via {%u,%u}", 594 tipc_printf(buf, " via {%u,%u}",
619 p_ptr->publ.conn_type, 595 p_ptr->conn_type,
620 p_ptr->publ.conn_instance); 596 p_ptr->conn_instance);
621 } else if (p_ptr->publ.published) { 597 } else if (p_ptr->published) {
622 tipc_printf(buf, " bound to"); 598 tipc_printf(buf, " bound to");
623 list_for_each_entry(publ, &p_ptr->publications, pport_list) { 599 list_for_each_entry(publ, &p_ptr->publications, pport_list) {
624 if (publ->lower == publ->upper) 600 if (publ->lower == publ->upper)
@@ -639,7 +615,7 @@ struct sk_buff *tipc_port_get_ports(void)
639 struct sk_buff *buf; 615 struct sk_buff *buf;
640 struct tlv_desc *rep_tlv; 616 struct tlv_desc *rep_tlv;
641 struct print_buf pb; 617 struct print_buf pb;
642 struct port *p_ptr; 618 struct tipc_port *p_ptr;
643 int str_len; 619 int str_len;
644 620
645 buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_QUERY)); 621 buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_QUERY));
@@ -650,9 +626,9 @@ struct sk_buff *tipc_port_get_ports(void)
650 tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_QUERY); 626 tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_QUERY);
651 spin_lock_bh(&tipc_port_list_lock); 627 spin_lock_bh(&tipc_port_list_lock);
652 list_for_each_entry(p_ptr, &ports, port_list) { 628 list_for_each_entry(p_ptr, &ports, port_list) {
653 spin_lock_bh(p_ptr->publ.lock); 629 spin_lock_bh(p_ptr->lock);
654 port_print(p_ptr, &pb, 0); 630 port_print(p_ptr, &pb, 0);
655 spin_unlock_bh(p_ptr->publ.lock); 631 spin_unlock_bh(p_ptr->lock);
656 } 632 }
657 spin_unlock_bh(&tipc_port_list_lock); 633 spin_unlock_bh(&tipc_port_list_lock);
658 str_len = tipc_printbuf_validate(&pb); 634 str_len = tipc_printbuf_validate(&pb);
@@ -665,12 +641,12 @@ struct sk_buff *tipc_port_get_ports(void)
665 641
666void tipc_port_reinit(void) 642void tipc_port_reinit(void)
667{ 643{
668 struct port *p_ptr; 644 struct tipc_port *p_ptr;
669 struct tipc_msg *msg; 645 struct tipc_msg *msg;
670 646
671 spin_lock_bh(&tipc_port_list_lock); 647 spin_lock_bh(&tipc_port_list_lock);
672 list_for_each_entry(p_ptr, &ports, port_list) { 648 list_for_each_entry(p_ptr, &ports, port_list) {
673 msg = &p_ptr->publ.phdr; 649 msg = &p_ptr->phdr;
674 if (msg_orignode(msg) == tipc_own_addr) 650 if (msg_orignode(msg) == tipc_own_addr)
675 break; 651 break;
676 msg_set_prevnode(msg, tipc_own_addr); 652 msg_set_prevnode(msg, tipc_own_addr);
@@ -695,7 +671,7 @@ static void port_dispatcher_sigh(void *dummy)
695 spin_unlock_bh(&queue_lock); 671 spin_unlock_bh(&queue_lock);
696 672
697 while (buf) { 673 while (buf) {
698 struct port *p_ptr; 674 struct tipc_port *p_ptr;
699 struct user_port *up_ptr; 675 struct user_port *up_ptr;
700 struct tipc_portid orig; 676 struct tipc_portid orig;
701 struct tipc_name_seq dseq; 677 struct tipc_name_seq dseq;
@@ -720,8 +696,8 @@ static void port_dispatcher_sigh(void *dummy)
720 orig.node = msg_orignode(msg); 696 orig.node = msg_orignode(msg);
721 up_ptr = p_ptr->user_port; 697 up_ptr = p_ptr->user_port;
722 usr_handle = up_ptr->usr_handle; 698 usr_handle = up_ptr->usr_handle;
723 connected = p_ptr->publ.connected; 699 connected = p_ptr->connected;
724 published = p_ptr->publ.published; 700 published = p_ptr->published;
725 701
726 if (unlikely(msg_errcode(msg))) 702 if (unlikely(msg_errcode(msg)))
727 goto err; 703 goto err;
@@ -732,6 +708,7 @@ static void port_dispatcher_sigh(void *dummy)
732 tipc_conn_msg_event cb = up_ptr->conn_msg_cb; 708 tipc_conn_msg_event cb = up_ptr->conn_msg_cb;
733 u32 peer_port = port_peerport(p_ptr); 709 u32 peer_port = port_peerport(p_ptr);
734 u32 peer_node = port_peernode(p_ptr); 710 u32 peer_node = port_peernode(p_ptr);
711 u32 dsz;
735 712
736 tipc_port_unlock(p_ptr); 713 tipc_port_unlock(p_ptr);
737 if (unlikely(!cb)) 714 if (unlikely(!cb))
@@ -742,13 +719,14 @@ static void port_dispatcher_sigh(void *dummy)
742 } else if ((msg_origport(msg) != peer_port) || 719 } else if ((msg_origport(msg) != peer_port) ||
743 (msg_orignode(msg) != peer_node)) 720 (msg_orignode(msg) != peer_node))
744 goto reject; 721 goto reject;
745 if (unlikely(++p_ptr->publ.conn_unacked >= 722 dsz = msg_data_sz(msg);
746 TIPC_FLOW_CONTROL_WIN)) 723 if (unlikely(dsz &&
724 (++p_ptr->conn_unacked >=
725 TIPC_FLOW_CONTROL_WIN)))
747 tipc_acknowledge(dref, 726 tipc_acknowledge(dref,
748 p_ptr->publ.conn_unacked); 727 p_ptr->conn_unacked);
749 skb_pull(buf, msg_hdr_sz(msg)); 728 skb_pull(buf, msg_hdr_sz(msg));
750 cb(usr_handle, dref, &buf, msg_data(msg), 729 cb(usr_handle, dref, &buf, msg_data(msg), dsz);
751 msg_data_sz(msg));
752 break; 730 break;
753 } 731 }
754 case TIPC_DIRECT_MSG:{ 732 case TIPC_DIRECT_MSG:{
@@ -872,7 +850,7 @@ static u32 port_dispatcher(struct tipc_port *dummy, struct sk_buff *buf)
872 850
873static void port_wakeup_sh(unsigned long ref) 851static void port_wakeup_sh(unsigned long ref)
874{ 852{
875 struct port *p_ptr; 853 struct tipc_port *p_ptr;
876 struct user_port *up_ptr; 854 struct user_port *up_ptr;
877 tipc_continue_event cb = NULL; 855 tipc_continue_event cb = NULL;
878 void *uh = NULL; 856 void *uh = NULL;
@@ -898,14 +876,14 @@ static void port_wakeup(struct tipc_port *p_ptr)
898 876
899void tipc_acknowledge(u32 ref, u32 ack) 877void tipc_acknowledge(u32 ref, u32 ack)
900{ 878{
901 struct port *p_ptr; 879 struct tipc_port *p_ptr;
902 struct sk_buff *buf = NULL; 880 struct sk_buff *buf = NULL;
903 881
904 p_ptr = tipc_port_lock(ref); 882 p_ptr = tipc_port_lock(ref);
905 if (!p_ptr) 883 if (!p_ptr)
906 return; 884 return;
907 if (p_ptr->publ.connected) { 885 if (p_ptr->connected) {
908 p_ptr->publ.conn_unacked -= ack; 886 p_ptr->conn_unacked -= ack;
909 buf = port_build_proto_msg(port_peerport(p_ptr), 887 buf = port_build_proto_msg(port_peerport(p_ptr),
910 port_peernode(p_ptr), 888 port_peernode(p_ptr),
911 ref, 889 ref,
@@ -913,7 +891,6 @@ void tipc_acknowledge(u32 ref, u32 ack)
913 CONN_MANAGER, 891 CONN_MANAGER,
914 CONN_ACK, 892 CONN_ACK,
915 TIPC_OK, 893 TIPC_OK,
916 port_out_seqno(p_ptr),
917 ack); 894 ack);
918 } 895 }
919 tipc_port_unlock(p_ptr); 896 tipc_port_unlock(p_ptr);
@@ -936,14 +913,14 @@ int tipc_createport(void *usr_handle,
936 u32 *portref) 913 u32 *portref)
937{ 914{
938 struct user_port *up_ptr; 915 struct user_port *up_ptr;
939 struct port *p_ptr; 916 struct tipc_port *p_ptr;
940 917
941 up_ptr = kmalloc(sizeof(*up_ptr), GFP_ATOMIC); 918 up_ptr = kmalloc(sizeof(*up_ptr), GFP_ATOMIC);
942 if (!up_ptr) { 919 if (!up_ptr) {
943 warn("Port creation failed, no memory\n"); 920 warn("Port creation failed, no memory\n");
944 return -ENOMEM; 921 return -ENOMEM;
945 } 922 }
946 p_ptr = (struct port *)tipc_createport_raw(NULL, port_dispatcher, 923 p_ptr = (struct tipc_port *)tipc_createport_raw(NULL, port_dispatcher,
947 port_wakeup, importance); 924 port_wakeup, importance);
948 if (!p_ptr) { 925 if (!p_ptr) {
949 kfree(up_ptr); 926 kfree(up_ptr);
@@ -952,7 +929,7 @@ int tipc_createport(void *usr_handle,
952 929
953 p_ptr->user_port = up_ptr; 930 p_ptr->user_port = up_ptr;
954 up_ptr->usr_handle = usr_handle; 931 up_ptr->usr_handle = usr_handle;
955 up_ptr->ref = p_ptr->publ.ref; 932 up_ptr->ref = p_ptr->ref;
956 up_ptr->err_cb = error_cb; 933 up_ptr->err_cb = error_cb;
957 up_ptr->named_err_cb = named_error_cb; 934 up_ptr->named_err_cb = named_error_cb;
958 up_ptr->conn_err_cb = conn_error_cb; 935 up_ptr->conn_err_cb = conn_error_cb;
@@ -960,26 +937,26 @@ int tipc_createport(void *usr_handle,
960 up_ptr->named_msg_cb = named_msg_cb; 937 up_ptr->named_msg_cb = named_msg_cb;
961 up_ptr->conn_msg_cb = conn_msg_cb; 938 up_ptr->conn_msg_cb = conn_msg_cb;
962 up_ptr->continue_event_cb = continue_event_cb; 939 up_ptr->continue_event_cb = continue_event_cb;
963 *portref = p_ptr->publ.ref; 940 *portref = p_ptr->ref;
964 tipc_port_unlock(p_ptr); 941 tipc_port_unlock(p_ptr);
965 return 0; 942 return 0;
966} 943}
967 944
968int tipc_portimportance(u32 ref, unsigned int *importance) 945int tipc_portimportance(u32 ref, unsigned int *importance)
969{ 946{
970 struct port *p_ptr; 947 struct tipc_port *p_ptr;
971 948
972 p_ptr = tipc_port_lock(ref); 949 p_ptr = tipc_port_lock(ref);
973 if (!p_ptr) 950 if (!p_ptr)
974 return -EINVAL; 951 return -EINVAL;
975 *importance = (unsigned int)msg_importance(&p_ptr->publ.phdr); 952 *importance = (unsigned int)msg_importance(&p_ptr->phdr);
976 tipc_port_unlock(p_ptr); 953 tipc_port_unlock(p_ptr);
977 return 0; 954 return 0;
978} 955}
979 956
980int tipc_set_portimportance(u32 ref, unsigned int imp) 957int tipc_set_portimportance(u32 ref, unsigned int imp)
981{ 958{
982 struct port *p_ptr; 959 struct tipc_port *p_ptr;
983 960
984 if (imp > TIPC_CRITICAL_IMPORTANCE) 961 if (imp > TIPC_CRITICAL_IMPORTANCE)
985 return -EINVAL; 962 return -EINVAL;
@@ -987,7 +964,7 @@ int tipc_set_portimportance(u32 ref, unsigned int imp)
987 p_ptr = tipc_port_lock(ref); 964 p_ptr = tipc_port_lock(ref);
988 if (!p_ptr) 965 if (!p_ptr)
989 return -EINVAL; 966 return -EINVAL;
990 msg_set_importance(&p_ptr->publ.phdr, (u32)imp); 967 msg_set_importance(&p_ptr->phdr, (u32)imp);
991 tipc_port_unlock(p_ptr); 968 tipc_port_unlock(p_ptr);
992 return 0; 969 return 0;
993} 970}
@@ -995,7 +972,7 @@ int tipc_set_portimportance(u32 ref, unsigned int imp)
995 972
996int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq) 973int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
997{ 974{
998 struct port *p_ptr; 975 struct tipc_port *p_ptr;
999 struct publication *publ; 976 struct publication *publ;
1000 u32 key; 977 u32 key;
1001 int res = -EINVAL; 978 int res = -EINVAL;
@@ -1004,7 +981,7 @@ int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
1004 if (!p_ptr) 981 if (!p_ptr)
1005 return -EINVAL; 982 return -EINVAL;
1006 983
1007 if (p_ptr->publ.connected) 984 if (p_ptr->connected)
1008 goto exit; 985 goto exit;
1009 if (seq->lower > seq->upper) 986 if (seq->lower > seq->upper)
1010 goto exit; 987 goto exit;
@@ -1016,11 +993,11 @@ int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
1016 goto exit; 993 goto exit;
1017 } 994 }
1018 publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper, 995 publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper,
1019 scope, p_ptr->publ.ref, key); 996 scope, p_ptr->ref, key);
1020 if (publ) { 997 if (publ) {
1021 list_add(&publ->pport_list, &p_ptr->publications); 998 list_add(&publ->pport_list, &p_ptr->publications);
1022 p_ptr->pub_count++; 999 p_ptr->pub_count++;
1023 p_ptr->publ.published = 1; 1000 p_ptr->published = 1;
1024 res = 0; 1001 res = 0;
1025 } 1002 }
1026exit: 1003exit:
@@ -1030,7 +1007,7 @@ exit:
1030 1007
1031int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq) 1008int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
1032{ 1009{
1033 struct port *p_ptr; 1010 struct tipc_port *p_ptr;
1034 struct publication *publ; 1011 struct publication *publ;
1035 struct publication *tpubl; 1012 struct publication *tpubl;
1036 int res = -EINVAL; 1013 int res = -EINVAL;
@@ -1063,37 +1040,36 @@ int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
1063 } 1040 }
1064 } 1041 }
1065 if (list_empty(&p_ptr->publications)) 1042 if (list_empty(&p_ptr->publications))
1066 p_ptr->publ.published = 0; 1043 p_ptr->published = 0;
1067 tipc_port_unlock(p_ptr); 1044 tipc_port_unlock(p_ptr);
1068 return res; 1045 return res;
1069} 1046}
1070 1047
1071int tipc_connect2port(u32 ref, struct tipc_portid const *peer) 1048int tipc_connect2port(u32 ref, struct tipc_portid const *peer)
1072{ 1049{
1073 struct port *p_ptr; 1050 struct tipc_port *p_ptr;
1074 struct tipc_msg *msg; 1051 struct tipc_msg *msg;
1075 int res = -EINVAL; 1052 int res = -EINVAL;
1076 1053
1077 p_ptr = tipc_port_lock(ref); 1054 p_ptr = tipc_port_lock(ref);
1078 if (!p_ptr) 1055 if (!p_ptr)
1079 return -EINVAL; 1056 return -EINVAL;
1080 if (p_ptr->publ.published || p_ptr->publ.connected) 1057 if (p_ptr->published || p_ptr->connected)
1081 goto exit; 1058 goto exit;
1082 if (!peer->ref) 1059 if (!peer->ref)
1083 goto exit; 1060 goto exit;
1084 1061
1085 msg = &p_ptr->publ.phdr; 1062 msg = &p_ptr->phdr;
1086 msg_set_destnode(msg, peer->node); 1063 msg_set_destnode(msg, peer->node);
1087 msg_set_destport(msg, peer->ref); 1064 msg_set_destport(msg, peer->ref);
1088 msg_set_orignode(msg, tipc_own_addr); 1065 msg_set_orignode(msg, tipc_own_addr);
1089 msg_set_origport(msg, p_ptr->publ.ref); 1066 msg_set_origport(msg, p_ptr->ref);
1090 msg_set_transp_seqno(msg, 42);
1091 msg_set_type(msg, TIPC_CONN_MSG); 1067 msg_set_type(msg, TIPC_CONN_MSG);
1092 msg_set_hdr_sz(msg, SHORT_H_SIZE); 1068 msg_set_hdr_sz(msg, SHORT_H_SIZE);
1093 1069
1094 p_ptr->probing_interval = PROBING_INTERVAL; 1070 p_ptr->probing_interval = PROBING_INTERVAL;
1095 p_ptr->probing_state = CONFIRMED; 1071 p_ptr->probing_state = CONFIRMED;
1096 p_ptr->publ.connected = 1; 1072 p_ptr->connected = 1;
1097 k_start_timer(&p_ptr->timer, p_ptr->probing_interval); 1073 k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
1098 1074
1099 tipc_nodesub_subscribe(&p_ptr->subscription, peer->node, 1075 tipc_nodesub_subscribe(&p_ptr->subscription, peer->node,
@@ -1102,7 +1078,7 @@ int tipc_connect2port(u32 ref, struct tipc_portid const *peer)
1102 res = 0; 1078 res = 0;
1103exit: 1079exit:
1104 tipc_port_unlock(p_ptr); 1080 tipc_port_unlock(p_ptr);
1105 p_ptr->publ.max_pkt = tipc_link_get_max_pkt(peer->node, ref); 1081 p_ptr->max_pkt = tipc_link_get_max_pkt(peer->node, ref);
1106 return res; 1082 return res;
1107} 1083}
1108 1084
@@ -1120,7 +1096,7 @@ int tipc_disconnect_port(struct tipc_port *tp_ptr)
1120 tp_ptr->connected = 0; 1096 tp_ptr->connected = 0;
1121 /* let timer expire on it's own to avoid deadlock! */ 1097 /* let timer expire on it's own to avoid deadlock! */
1122 tipc_nodesub_unsubscribe( 1098 tipc_nodesub_unsubscribe(
1123 &((struct port *)tp_ptr)->subscription); 1099 &((struct tipc_port *)tp_ptr)->subscription);
1124 res = 0; 1100 res = 0;
1125 } else { 1101 } else {
1126 res = -ENOTCONN; 1102 res = -ENOTCONN;
@@ -1135,7 +1111,7 @@ int tipc_disconnect_port(struct tipc_port *tp_ptr)
1135 1111
1136int tipc_disconnect(u32 ref) 1112int tipc_disconnect(u32 ref)
1137{ 1113{
1138 struct port *p_ptr; 1114 struct tipc_port *p_ptr;
1139 int res; 1115 int res;
1140 1116
1141 p_ptr = tipc_port_lock(ref); 1117 p_ptr = tipc_port_lock(ref);
@@ -1151,15 +1127,15 @@ int tipc_disconnect(u32 ref)
1151 */ 1127 */
1152int tipc_shutdown(u32 ref) 1128int tipc_shutdown(u32 ref)
1153{ 1129{
1154 struct port *p_ptr; 1130 struct tipc_port *p_ptr;
1155 struct sk_buff *buf = NULL; 1131 struct sk_buff *buf = NULL;
1156 1132
1157 p_ptr = tipc_port_lock(ref); 1133 p_ptr = tipc_port_lock(ref);
1158 if (!p_ptr) 1134 if (!p_ptr)
1159 return -EINVAL; 1135 return -EINVAL;
1160 1136
1161 if (p_ptr->publ.connected) { 1137 if (p_ptr->connected) {
1162 u32 imp = msg_importance(&p_ptr->publ.phdr); 1138 u32 imp = msg_importance(&p_ptr->phdr);
1163 if (imp < TIPC_CRITICAL_IMPORTANCE) 1139 if (imp < TIPC_CRITICAL_IMPORTANCE)
1164 imp++; 1140 imp++;
1165 buf = port_build_proto_msg(port_peerport(p_ptr), 1141 buf = port_build_proto_msg(port_peerport(p_ptr),
@@ -1169,7 +1145,6 @@ int tipc_shutdown(u32 ref)
1169 imp, 1145 imp,
1170 TIPC_CONN_MSG, 1146 TIPC_CONN_MSG,
1171 TIPC_CONN_SHUTDOWN, 1147 TIPC_CONN_SHUTDOWN,
1172 port_out_seqno(p_ptr),
1173 0); 1148 0);
1174 } 1149 }
1175 tipc_port_unlock(p_ptr); 1150 tipc_port_unlock(p_ptr);
@@ -1182,13 +1157,13 @@ int tipc_shutdown(u32 ref)
1182 * message for this node. 1157 * message for this node.
1183 */ 1158 */
1184 1159
1185static int tipc_port_recv_sections(struct port *sender, unsigned int num_sect, 1160static int tipc_port_recv_sections(struct tipc_port *sender, unsigned int num_sect,
1186 struct iovec const *msg_sect) 1161 struct iovec const *msg_sect)
1187{ 1162{
1188 struct sk_buff *buf; 1163 struct sk_buff *buf;
1189 int res; 1164 int res;
1190 1165
1191 res = tipc_msg_build(&sender->publ.phdr, msg_sect, num_sect, 1166 res = tipc_msg_build(&sender->phdr, msg_sect, num_sect,
1192 MAX_MSG_SIZE, !sender->user_port, &buf); 1167 MAX_MSG_SIZE, !sender->user_port, &buf);
1193 if (likely(buf)) 1168 if (likely(buf))
1194 tipc_port_recv_msg(buf); 1169 tipc_port_recv_msg(buf);
@@ -1201,15 +1176,15 @@ static int tipc_port_recv_sections(struct port *sender, unsigned int num_sect,
1201 1176
1202int tipc_send(u32 ref, unsigned int num_sect, struct iovec const *msg_sect) 1177int tipc_send(u32 ref, unsigned int num_sect, struct iovec const *msg_sect)
1203{ 1178{
1204 struct port *p_ptr; 1179 struct tipc_port *p_ptr;
1205 u32 destnode; 1180 u32 destnode;
1206 int res; 1181 int res;
1207 1182
1208 p_ptr = tipc_port_deref(ref); 1183 p_ptr = tipc_port_deref(ref);
1209 if (!p_ptr || !p_ptr->publ.connected) 1184 if (!p_ptr || !p_ptr->connected)
1210 return -EINVAL; 1185 return -EINVAL;
1211 1186
1212 p_ptr->publ.congested = 1; 1187 p_ptr->congested = 1;
1213 if (!tipc_port_congested(p_ptr)) { 1188 if (!tipc_port_congested(p_ptr)) {
1214 destnode = port_peernode(p_ptr); 1189 destnode = port_peernode(p_ptr);
1215 if (likely(destnode != tipc_own_addr)) 1190 if (likely(destnode != tipc_own_addr))
@@ -1219,14 +1194,14 @@ int tipc_send(u32 ref, unsigned int num_sect, struct iovec const *msg_sect)
1219 res = tipc_port_recv_sections(p_ptr, num_sect, msg_sect); 1194 res = tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
1220 1195
1221 if (likely(res != -ELINKCONG)) { 1196 if (likely(res != -ELINKCONG)) {
1222 port_incr_out_seqno(p_ptr); 1197 p_ptr->congested = 0;
1223 p_ptr->publ.congested = 0; 1198 if (res > 0)
1224 p_ptr->sent++; 1199 p_ptr->sent++;
1225 return res; 1200 return res;
1226 } 1201 }
1227 } 1202 }
1228 if (port_unreliable(p_ptr)) { 1203 if (port_unreliable(p_ptr)) {
1229 p_ptr->publ.congested = 0; 1204 p_ptr->congested = 0;
1230 /* Just calculate msg length and return */ 1205 /* Just calculate msg length and return */
1231 return tipc_msg_calc_data_size(msg_sect, num_sect); 1206 return tipc_msg_calc_data_size(msg_sect, num_sect);
1232 } 1207 }
@@ -1240,17 +1215,17 @@ int tipc_send(u32 ref, unsigned int num_sect, struct iovec const *msg_sect)
1240int tipc_send2name(u32 ref, struct tipc_name const *name, unsigned int domain, 1215int tipc_send2name(u32 ref, struct tipc_name const *name, unsigned int domain,
1241 unsigned int num_sect, struct iovec const *msg_sect) 1216 unsigned int num_sect, struct iovec const *msg_sect)
1242{ 1217{
1243 struct port *p_ptr; 1218 struct tipc_port *p_ptr;
1244 struct tipc_msg *msg; 1219 struct tipc_msg *msg;
1245 u32 destnode = domain; 1220 u32 destnode = domain;
1246 u32 destport; 1221 u32 destport;
1247 int res; 1222 int res;
1248 1223
1249 p_ptr = tipc_port_deref(ref); 1224 p_ptr = tipc_port_deref(ref);
1250 if (!p_ptr || p_ptr->publ.connected) 1225 if (!p_ptr || p_ptr->connected)
1251 return -EINVAL; 1226 return -EINVAL;
1252 1227
1253 msg = &p_ptr->publ.phdr; 1228 msg = &p_ptr->phdr;
1254 msg_set_type(msg, TIPC_NAMED_MSG); 1229 msg_set_type(msg, TIPC_NAMED_MSG);
1255 msg_set_orignode(msg, tipc_own_addr); 1230 msg_set_orignode(msg, tipc_own_addr);
1256 msg_set_origport(msg, ref); 1231 msg_set_origport(msg, ref);
@@ -1263,13 +1238,17 @@ int tipc_send2name(u32 ref, struct tipc_name const *name, unsigned int domain,
1263 msg_set_destport(msg, destport); 1238 msg_set_destport(msg, destport);
1264 1239
1265 if (likely(destport)) { 1240 if (likely(destport)) {
1266 p_ptr->sent++;
1267 if (likely(destnode == tipc_own_addr)) 1241 if (likely(destnode == tipc_own_addr))
1268 return tipc_port_recv_sections(p_ptr, num_sect, msg_sect); 1242 res = tipc_port_recv_sections(p_ptr, num_sect,
1269 res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect, 1243 msg_sect);
1270 destnode); 1244 else
1271 if (likely(res != -ELINKCONG)) 1245 res = tipc_link_send_sections_fast(p_ptr, msg_sect,
1246 num_sect, destnode);
1247 if (likely(res != -ELINKCONG)) {
1248 if (res > 0)
1249 p_ptr->sent++;
1272 return res; 1250 return res;
1251 }
1273 if (port_unreliable(p_ptr)) { 1252 if (port_unreliable(p_ptr)) {
1274 /* Just calculate msg length and return */ 1253 /* Just calculate msg length and return */
1275 return tipc_msg_calc_data_size(msg_sect, num_sect); 1254 return tipc_msg_calc_data_size(msg_sect, num_sect);
@@ -1287,27 +1266,32 @@ int tipc_send2name(u32 ref, struct tipc_name const *name, unsigned int domain,
1287int tipc_send2port(u32 ref, struct tipc_portid const *dest, 1266int tipc_send2port(u32 ref, struct tipc_portid const *dest,
1288 unsigned int num_sect, struct iovec const *msg_sect) 1267 unsigned int num_sect, struct iovec const *msg_sect)
1289{ 1268{
1290 struct port *p_ptr; 1269 struct tipc_port *p_ptr;
1291 struct tipc_msg *msg; 1270 struct tipc_msg *msg;
1292 int res; 1271 int res;
1293 1272
1294 p_ptr = tipc_port_deref(ref); 1273 p_ptr = tipc_port_deref(ref);
1295 if (!p_ptr || p_ptr->publ.connected) 1274 if (!p_ptr || p_ptr->connected)
1296 return -EINVAL; 1275 return -EINVAL;
1297 1276
1298 msg = &p_ptr->publ.phdr; 1277 msg = &p_ptr->phdr;
1299 msg_set_type(msg, TIPC_DIRECT_MSG); 1278 msg_set_type(msg, TIPC_DIRECT_MSG);
1300 msg_set_orignode(msg, tipc_own_addr); 1279 msg_set_orignode(msg, tipc_own_addr);
1301 msg_set_origport(msg, ref); 1280 msg_set_origport(msg, ref);
1302 msg_set_destnode(msg, dest->node); 1281 msg_set_destnode(msg, dest->node);
1303 msg_set_destport(msg, dest->ref); 1282 msg_set_destport(msg, dest->ref);
1304 msg_set_hdr_sz(msg, DIR_MSG_H_SIZE); 1283 msg_set_hdr_sz(msg, DIR_MSG_H_SIZE);
1305 p_ptr->sent++; 1284
1306 if (dest->node == tipc_own_addr) 1285 if (dest->node == tipc_own_addr)
1307 return tipc_port_recv_sections(p_ptr, num_sect, msg_sect); 1286 res = tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
1308 res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect, dest->node); 1287 else
1309 if (likely(res != -ELINKCONG)) 1288 res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect,
1289 dest->node);
1290 if (likely(res != -ELINKCONG)) {
1291 if (res > 0)
1292 p_ptr->sent++;
1310 return res; 1293 return res;
1294 }
1311 if (port_unreliable(p_ptr)) { 1295 if (port_unreliable(p_ptr)) {
1312 /* Just calculate msg length and return */ 1296 /* Just calculate msg length and return */
1313 return tipc_msg_calc_data_size(msg_sect, num_sect); 1297 return tipc_msg_calc_data_size(msg_sect, num_sect);
@@ -1322,15 +1306,15 @@ int tipc_send2port(u32 ref, struct tipc_portid const *dest,
1322int tipc_send_buf2port(u32 ref, struct tipc_portid const *dest, 1306int tipc_send_buf2port(u32 ref, struct tipc_portid const *dest,
1323 struct sk_buff *buf, unsigned int dsz) 1307 struct sk_buff *buf, unsigned int dsz)
1324{ 1308{
1325 struct port *p_ptr; 1309 struct tipc_port *p_ptr;
1326 struct tipc_msg *msg; 1310 struct tipc_msg *msg;
1327 int res; 1311 int res;
1328 1312
1329 p_ptr = (struct port *)tipc_ref_deref(ref); 1313 p_ptr = (struct tipc_port *)tipc_ref_deref(ref);
1330 if (!p_ptr || p_ptr->publ.connected) 1314 if (!p_ptr || p_ptr->connected)
1331 return -EINVAL; 1315 return -EINVAL;
1332 1316
1333 msg = &p_ptr->publ.phdr; 1317 msg = &p_ptr->phdr;
1334 msg_set_type(msg, TIPC_DIRECT_MSG); 1318 msg_set_type(msg, TIPC_DIRECT_MSG);
1335 msg_set_orignode(msg, tipc_own_addr); 1319 msg_set_orignode(msg, tipc_own_addr);
1336 msg_set_origport(msg, ref); 1320 msg_set_origport(msg, ref);
@@ -1343,12 +1327,16 @@ int tipc_send_buf2port(u32 ref, struct tipc_portid const *dest,
1343 1327
1344 skb_push(buf, DIR_MSG_H_SIZE); 1328 skb_push(buf, DIR_MSG_H_SIZE);
1345 skb_copy_to_linear_data(buf, msg, DIR_MSG_H_SIZE); 1329 skb_copy_to_linear_data(buf, msg, DIR_MSG_H_SIZE);
1346 p_ptr->sent++; 1330
1347 if (dest->node == tipc_own_addr) 1331 if (dest->node == tipc_own_addr)
1348 return tipc_port_recv_msg(buf); 1332 res = tipc_port_recv_msg(buf);
1349 res = tipc_send_buf_fast(buf, dest->node); 1333 else
1350 if (likely(res != -ELINKCONG)) 1334 res = tipc_send_buf_fast(buf, dest->node);
1335 if (likely(res != -ELINKCONG)) {
1336 if (res > 0)
1337 p_ptr->sent++;
1351 return res; 1338 return res;
1339 }
1352 if (port_unreliable(p_ptr)) 1340 if (port_unreliable(p_ptr))
1353 return dsz; 1341 return dsz;
1354 return -ELINKCONG; 1342 return -ELINKCONG;
diff --git a/net/tipc/port.h b/net/tipc/port.h
index 8e84b989949c..87b9424ae0ec 100644
--- a/net/tipc/port.h
+++ b/net/tipc/port.h
@@ -2,7 +2,7 @@
2 * net/tipc/port.h: Include file for TIPC port code 2 * net/tipc/port.h: Include file for TIPC port code
3 * 3 *
4 * Copyright (c) 1994-2007, Ericsson AB 4 * Copyright (c) 1994-2007, Ericsson AB
5 * Copyright (c) 2004-2007, Wind River Systems 5 * Copyright (c) 2004-2007, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -95,7 +95,7 @@ struct user_port {
95}; 95};
96 96
97/** 97/**
98 * struct tipc_port - TIPC port info available to socket API 98 * struct tipc_port - TIPC port structure
99 * @usr_handle: pointer to additional user-defined information about port 99 * @usr_handle: pointer to additional user-defined information about port
100 * @lock: pointer to spinlock for controlling access to port 100 * @lock: pointer to spinlock for controlling access to port
101 * @connected: non-zero if port is currently connected to a peer port 101 * @connected: non-zero if port is currently connected to a peer port
@@ -107,43 +107,33 @@ struct user_port {
107 * @max_pkt: maximum packet size "hint" used when building messages sent by port 107 * @max_pkt: maximum packet size "hint" used when building messages sent by port
108 * @ref: unique reference to port in TIPC object registry 108 * @ref: unique reference to port in TIPC object registry
109 * @phdr: preformatted message header used when sending messages 109 * @phdr: preformatted message header used when sending messages
110 */
111struct tipc_port {
112 void *usr_handle;
113 spinlock_t *lock;
114 int connected;
115 u32 conn_type;
116 u32 conn_instance;
117 u32 conn_unacked;
118 int published;
119 u32 congested;
120 u32 max_pkt;
121 u32 ref;
122 struct tipc_msg phdr;
123};
124
125/**
126 * struct port - TIPC port structure
127 * @publ: TIPC port info available to privileged users
128 * @port_list: adjacent ports in TIPC's global list of ports 110 * @port_list: adjacent ports in TIPC's global list of ports
129 * @dispatcher: ptr to routine which handles received messages 111 * @dispatcher: ptr to routine which handles received messages
130 * @wakeup: ptr to routine to call when port is no longer congested 112 * @wakeup: ptr to routine to call when port is no longer congested
131 * @user_port: ptr to user port associated with port (if any) 113 * @user_port: ptr to user port associated with port (if any)
132 * @wait_list: adjacent ports in list of ports waiting on link congestion 114 * @wait_list: adjacent ports in list of ports waiting on link congestion
133 * @waiting_pkts: 115 * @waiting_pkts:
134 * @sent: 116 * @sent: # of non-empty messages sent by port
135 * @acked: 117 * @acked: # of non-empty message acknowledgements from connected port's peer
136 * @publications: list of publications for port 118 * @publications: list of publications for port
137 * @pub_count: total # of publications port has made during its lifetime 119 * @pub_count: total # of publications port has made during its lifetime
138 * @probing_state: 120 * @probing_state:
139 * @probing_interval: 121 * @probing_interval:
140 * @last_in_seqno:
141 * @timer_ref: 122 * @timer_ref:
142 * @subscription: "node down" subscription used to terminate failed connections 123 * @subscription: "node down" subscription used to terminate failed connections
143 */ 124 */
144 125struct tipc_port {
145struct port { 126 void *usr_handle;
146 struct tipc_port publ; 127 spinlock_t *lock;
128 int connected;
129 u32 conn_type;
130 u32 conn_instance;
131 u32 conn_unacked;
132 int published;
133 u32 congested;
134 u32 max_pkt;
135 u32 ref;
136 struct tipc_msg phdr;
147 struct list_head port_list; 137 struct list_head port_list;
148 u32 (*dispatcher)(struct tipc_port *, struct sk_buff *); 138 u32 (*dispatcher)(struct tipc_port *, struct sk_buff *);
149 void (*wakeup)(struct tipc_port *); 139 void (*wakeup)(struct tipc_port *);
@@ -156,7 +146,6 @@ struct port {
156 u32 pub_count; 146 u32 pub_count;
157 u32 probing_state; 147 u32 probing_state;
158 u32 probing_interval; 148 u32 probing_interval;
159 u32 last_in_seqno;
160 struct timer_list timer; 149 struct timer_list timer;
161 struct tipc_node_subscr subscription; 150 struct tipc_node_subscr subscription;
162}; 151};
@@ -230,7 +219,7 @@ int tipc_send_buf2port(u32 portref, struct tipc_portid const *dest,
230int tipc_multicast(u32 portref, struct tipc_name_seq const *seq, 219int tipc_multicast(u32 portref, struct tipc_name_seq const *seq,
231 unsigned int section_count, struct iovec const *msg); 220 unsigned int section_count, struct iovec const *msg);
232 221
233int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr, 222int tipc_port_reject_sections(struct tipc_port *p_ptr, struct tipc_msg *hdr,
234 struct iovec const *msg_sect, u32 num_sect, 223 struct iovec const *msg_sect, u32 num_sect,
235 int err); 224 int err);
236struct sk_buff *tipc_port_get_ports(void); 225struct sk_buff *tipc_port_get_ports(void);
@@ -242,9 +231,9 @@ void tipc_port_reinit(void);
242 * tipc_port_lock - lock port instance referred to and return its pointer 231 * tipc_port_lock - lock port instance referred to and return its pointer
243 */ 232 */
244 233
245static inline struct port *tipc_port_lock(u32 ref) 234static inline struct tipc_port *tipc_port_lock(u32 ref)
246{ 235{
247 return (struct port *)tipc_ref_lock(ref); 236 return (struct tipc_port *)tipc_ref_lock(ref);
248} 237}
249 238
250/** 239/**
@@ -253,27 +242,27 @@ static inline struct port *tipc_port_lock(u32 ref)
253 * Can use pointer instead of tipc_ref_unlock() since port is already locked. 242 * Can use pointer instead of tipc_ref_unlock() since port is already locked.
254 */ 243 */
255 244
256static inline void tipc_port_unlock(struct port *p_ptr) 245static inline void tipc_port_unlock(struct tipc_port *p_ptr)
257{ 246{
258 spin_unlock_bh(p_ptr->publ.lock); 247 spin_unlock_bh(p_ptr->lock);
259} 248}
260 249
261static inline struct port *tipc_port_deref(u32 ref) 250static inline struct tipc_port *tipc_port_deref(u32 ref)
262{ 251{
263 return (struct port *)tipc_ref_deref(ref); 252 return (struct tipc_port *)tipc_ref_deref(ref);
264} 253}
265 254
266static inline u32 tipc_peer_port(struct port *p_ptr) 255static inline u32 tipc_peer_port(struct tipc_port *p_ptr)
267{ 256{
268 return msg_destport(&p_ptr->publ.phdr); 257 return msg_destport(&p_ptr->phdr);
269} 258}
270 259
271static inline u32 tipc_peer_node(struct port *p_ptr) 260static inline u32 tipc_peer_node(struct tipc_port *p_ptr)
272{ 261{
273 return msg_destnode(&p_ptr->publ.phdr); 262 return msg_destnode(&p_ptr->phdr);
274} 263}
275 264
276static inline int tipc_port_congested(struct port *p_ptr) 265static inline int tipc_port_congested(struct tipc_port *p_ptr)
277{ 266{
278 return (p_ptr->sent - p_ptr->acked) >= (TIPC_FLOW_CONTROL_WIN * 2); 267 return (p_ptr->sent - p_ptr->acked) >= (TIPC_FLOW_CONTROL_WIN * 2);
279} 268}
@@ -284,7 +273,7 @@ static inline int tipc_port_congested(struct port *p_ptr)
284 273
285static inline int tipc_port_recv_msg(struct sk_buff *buf) 274static inline int tipc_port_recv_msg(struct sk_buff *buf)
286{ 275{
287 struct port *p_ptr; 276 struct tipc_port *p_ptr;
288 struct tipc_msg *msg = buf_msg(buf); 277 struct tipc_msg *msg = buf_msg(buf);
289 u32 destport = msg_destport(msg); 278 u32 destport = msg_destport(msg);
290 u32 dsz = msg_data_sz(msg); 279 u32 dsz = msg_data_sz(msg);
@@ -299,7 +288,7 @@ static inline int tipc_port_recv_msg(struct sk_buff *buf)
299 /* validate destination & pass to port, otherwise reject message */ 288 /* validate destination & pass to port, otherwise reject message */
300 p_ptr = tipc_port_lock(destport); 289 p_ptr = tipc_port_lock(destport);
301 if (likely(p_ptr)) { 290 if (likely(p_ptr)) {
302 if (likely(p_ptr->publ.connected)) { 291 if (likely(p_ptr->connected)) {
303 if ((unlikely(msg_origport(msg) != tipc_peer_port(p_ptr))) || 292 if ((unlikely(msg_origport(msg) != tipc_peer_port(p_ptr))) ||
304 (unlikely(msg_orignode(msg) != tipc_peer_node(p_ptr))) || 293 (unlikely(msg_orignode(msg) != tipc_peer_node(p_ptr))) ||
305 (unlikely(!msg_connected(msg)))) { 294 (unlikely(!msg_connected(msg)))) {
@@ -308,7 +297,7 @@ static inline int tipc_port_recv_msg(struct sk_buff *buf)
308 goto reject; 297 goto reject;
309 } 298 }
310 } 299 }
311 err = p_ptr->dispatcher(&p_ptr->publ, buf); 300 err = p_ptr->dispatcher(p_ptr, buf);
312 tipc_port_unlock(p_ptr); 301 tipc_port_unlock(p_ptr);
313 if (likely(!err)) 302 if (likely(!err))
314 return dsz; 303 return dsz;
diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index 2b02a3a80313..125dcb0737b2 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -2,7 +2,7 @@
2 * net/tipc/socket.c: TIPC socket API 2 * net/tipc/socket.c: TIPC socket API
3 * 3 *
4 * Copyright (c) 2001-2007, Ericsson AB 4 * Copyright (c) 2001-2007, Ericsson AB
5 * Copyright (c) 2004-2008, Wind River Systems 5 * Copyright (c) 2004-2008, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -241,7 +241,6 @@ static int tipc_create(struct net *net, struct socket *sock, int protocol,
241 tipc_set_portunreliable(tp_ptr->ref, 1); 241 tipc_set_portunreliable(tp_ptr->ref, 1);
242 } 242 }
243 243
244 atomic_inc(&tipc_user_count);
245 return 0; 244 return 0;
246} 245}
247 246
@@ -321,7 +320,6 @@ static int release(struct socket *sock)
321 sock_put(sk); 320 sock_put(sk);
322 sock->sk = NULL; 321 sock->sk = NULL;
323 322
324 atomic_dec(&tipc_user_count);
325 return res; 323 return res;
326} 324}
327 325
@@ -495,6 +493,8 @@ static int dest_name_check(struct sockaddr_tipc *dest, struct msghdr *m)
495 if (likely(dest->addr.name.name.type != TIPC_CFG_SRV)) 493 if (likely(dest->addr.name.name.type != TIPC_CFG_SRV))
496 return -EACCES; 494 return -EACCES;
497 495
496 if (!m->msg_iovlen || (m->msg_iov[0].iov_len < sizeof(hdr)))
497 return -EMSGSIZE;
498 if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr))) 498 if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr)))
499 return -EFAULT; 499 return -EFAULT;
500 if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN))) 500 if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN)))
diff --git a/net/tipc/subscr.c b/net/tipc/subscr.c
index ca04479c3d42..aae9eae13404 100644
--- a/net/tipc/subscr.c
+++ b/net/tipc/subscr.c
@@ -2,7 +2,7 @@
2 * net/tipc/subscr.c: TIPC network topology service 2 * net/tipc/subscr.c: TIPC network topology service
3 * 3 *
4 * Copyright (c) 2000-2006, Ericsson AB 4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2005-2007, Wind River Systems 5 * Copyright (c) 2005-2007, 2010-2011, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
@@ -160,7 +160,7 @@ void tipc_subscr_report_overlap(struct subscription *sub,
160 160
161static void subscr_timeout(struct subscription *sub) 161static void subscr_timeout(struct subscription *sub)
162{ 162{
163 struct port *server_port; 163 struct tipc_port *server_port;
164 164
165 /* Validate server port reference (in case subscriber is terminating) */ 165 /* Validate server port reference (in case subscriber is terminating) */
166 166
@@ -472,8 +472,6 @@ static void subscr_named_msg_event(void *usr_handle,
472 struct tipc_portid const *orig, 472 struct tipc_portid const *orig,
473 struct tipc_name_seq const *dest) 473 struct tipc_name_seq const *dest)
474{ 474{
475 static struct iovec msg_sect = {NULL, 0};
476
477 struct subscriber *subscriber; 475 struct subscriber *subscriber;
478 u32 server_port_ref; 476 u32 server_port_ref;
479 477
@@ -508,7 +506,7 @@ static void subscr_named_msg_event(void *usr_handle,
508 506
509 /* Lock server port (& save lock address for future use) */ 507 /* Lock server port (& save lock address for future use) */
510 508
511 subscriber->lock = tipc_port_lock(subscriber->port_ref)->publ.lock; 509 subscriber->lock = tipc_port_lock(subscriber->port_ref)->lock;
512 510
513 /* Add subscriber to topology server's subscriber list */ 511 /* Add subscriber to topology server's subscriber list */
514 512
@@ -523,7 +521,7 @@ static void subscr_named_msg_event(void *usr_handle,
523 521
524 /* Send an ACK- to complete connection handshaking */ 522 /* Send an ACK- to complete connection handshaking */
525 523
526 tipc_send(server_port_ref, 1, &msg_sect); 524 tipc_send(server_port_ref, 0, NULL);
527 525
528 /* Handle optional subscription request */ 526 /* Handle optional subscription request */
529 527
@@ -542,7 +540,6 @@ int tipc_subscr_start(void)
542 spin_lock_init(&topsrv.lock); 540 spin_lock_init(&topsrv.lock);
543 INIT_LIST_HEAD(&topsrv.subscriber_list); 541 INIT_LIST_HEAD(&topsrv.subscriber_list);
544 542
545 spin_lock_bh(&topsrv.lock);
546 res = tipc_createport(NULL, 543 res = tipc_createport(NULL,
547 TIPC_CRITICAL_IMPORTANCE, 544 TIPC_CRITICAL_IMPORTANCE,
548 NULL, 545 NULL,
@@ -563,12 +560,10 @@ int tipc_subscr_start(void)
563 goto failed; 560 goto failed;
564 } 561 }
565 562
566 spin_unlock_bh(&topsrv.lock);
567 return 0; 563 return 0;
568 564
569failed: 565failed:
570 err("Failed to create subscription service\n"); 566 err("Failed to create subscription service\n");
571 spin_unlock_bh(&topsrv.lock);
572 return res; 567 return res;
573} 568}
574 569
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-03 07:40:32 -0400