Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
link.c
Go to the documentation of this file.
1 /*
2  * net/tipc/link.c: TIPC link code
3  *
4  * Copyright (c) 1996-2007, Ericsson AB
5  * Copyright (c) 2004-2007, 2010-2011, Wind River Systems
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  * notice, this list of conditions and the following disclaimer in the
15  * documentation and/or other materials provided with the distribution.
16  * 3. Neither the names of the copyright holders nor the names of its
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * Alternatively, this software may be distributed under the terms of the
21  * GNU General Public License ("GPL") version 2 as published by the Free
22  * Software Foundation.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  * POSSIBILITY OF SUCH DAMAGE.
35  */
36 
37 #include "core.h"
38 #include "link.h"
39 #include "port.h"
40 #include "name_distr.h"
41 #include "discover.h"
42 #include "config.h"
43 
44 /*
45  * Error message prefixes
46  */
47 static const char *link_co_err = "Link changeover error, ";
48 static const char *link_rst_msg = "Resetting link ";
49 static const char *link_unk_evt = "Unknown link event ";
50 
51 /*
52  * Out-of-range value for link session numbers
53  */
54 #define INVALID_SESSION 0x10000
55 
56 /*
57  * Link state events:
58  */
59 #define STARTING_EVT 856384768 /* link processing trigger */
60 #define TRAFFIC_MSG_EVT 560815u /* rx'd ??? */
61 #define TIMEOUT_EVT 560817u /* link timer expired */
62 
63 /*
64  * The following two 'message types' is really just implementation
65  * data conveniently stored in the message header.
66  * They must not be considered part of the protocol
67  */
68 #define OPEN_MSG 0
69 #define CLOSED_MSG 1
70 
71 /*
72  * State value stored in 'exp_msg_count'
73  */
74 #define START_CHANGEOVER 100000u
75 
88 };
89 
90 static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
91  struct sk_buff *buf);
92 static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf);
93 static int link_recv_changeover_msg(struct tipc_link **l_ptr,
94  struct sk_buff **buf);
95 static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance);
96 static int link_send_sections_long(struct tipc_port *sender,
97  struct iovec const *msg_sect,
98  u32 num_sect, unsigned int total_len,
99  u32 destnode);
100 static void link_check_defragm_bufs(struct tipc_link *l_ptr);
101 static void link_state_event(struct tipc_link *l_ptr, u32 event);
102 static void link_reset_statistics(struct tipc_link *l_ptr);
103 static void link_print(struct tipc_link *l_ptr, const char *str);
104 static void link_start(struct tipc_link *l_ptr);
105 static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf);
106 
107 /*
108  * Simple link routines
109  */
110 static unsigned int align(unsigned int i)
111 {
112  return (i + 3) & ~3u;
113 }
114 
115 static void link_init_max_pkt(struct tipc_link *l_ptr)
116 {
117  u32 max_pkt;
118 
119  max_pkt = (l_ptr->b_ptr->mtu & ~3);
120  if (max_pkt > MAX_MSG_SIZE)
121  max_pkt = MAX_MSG_SIZE;
122 
123  l_ptr->max_pkt_target = max_pkt;
124  if (l_ptr->max_pkt_target < MAX_PKT_DEFAULT)
125  l_ptr->max_pkt = l_ptr->max_pkt_target;
126  else
127  l_ptr->max_pkt = MAX_PKT_DEFAULT;
128 
129  l_ptr->max_pkt_probes = 0;
130 }
131 
132 static u32 link_next_sent(struct tipc_link *l_ptr)
133 {
134  if (l_ptr->next_out)
135  return buf_seqno(l_ptr->next_out);
136  return mod(l_ptr->next_out_no);
137 }
138 
139 static u32 link_last_sent(struct tipc_link *l_ptr)
140 {
141  return mod(link_next_sent(l_ptr) - 1);
142 }
143 
144 /*
145  * Simple non-static link routines (i.e. referenced outside this file)
146  */
147 int tipc_link_is_up(struct tipc_link *l_ptr)
148 {
149  if (!l_ptr)
150  return 0;
151  return link_working_working(l_ptr) || link_working_unknown(l_ptr);
152 }
153 
154 int tipc_link_is_active(struct tipc_link *l_ptr)
155 {
156  return (l_ptr->owner->active_links[0] == l_ptr) ||
157  (l_ptr->owner->active_links[1] == l_ptr);
158 }
159 
167 static int link_name_validate(const char *name,
168  struct tipc_link_name *name_parts)
169 {
170  char name_copy[TIPC_MAX_LINK_NAME];
171  char *addr_local;
172  char *if_local;
173  char *addr_peer;
174  char *if_peer;
175  char dummy;
176  u32 z_local, c_local, n_local;
177  u32 z_peer, c_peer, n_peer;
178  u32 if_local_len;
179  u32 if_peer_len;
180 
181  /* copy link name & ensure length is OK */
182  name_copy[TIPC_MAX_LINK_NAME - 1] = 0;
183  /* need above in case non-Posix strncpy() doesn't pad with nulls */
184  strncpy(name_copy, name, TIPC_MAX_LINK_NAME);
185  if (name_copy[TIPC_MAX_LINK_NAME - 1] != 0)
186  return 0;
187 
188  /* ensure all component parts of link name are present */
189  addr_local = name_copy;
190  if_local = strchr(addr_local, ':');
191  if (if_local == NULL)
192  return 0;
193  *(if_local++) = 0;
194  addr_peer = strchr(if_local, '-');
195  if (addr_peer == NULL)
196  return 0;
197  *(addr_peer++) = 0;
198  if_local_len = addr_peer - if_local;
199  if_peer = strchr(addr_peer, ':');
200  if (if_peer == NULL)
201  return 0;
202  *(if_peer++) = 0;
203  if_peer_len = strlen(if_peer) + 1;
204 
205  /* validate component parts of link name */
206  if ((sscanf(addr_local, "%u.%u.%u%c",
207  &z_local, &c_local, &n_local, &dummy) != 3) ||
208  (sscanf(addr_peer, "%u.%u.%u%c",
209  &z_peer, &c_peer, &n_peer, &dummy) != 3) ||
210  (z_local > 255) || (c_local > 4095) || (n_local > 4095) ||
211  (z_peer > 255) || (c_peer > 4095) || (n_peer > 4095) ||
212  (if_local_len <= 1) || (if_local_len > TIPC_MAX_IF_NAME) ||
213  (if_peer_len <= 1) || (if_peer_len > TIPC_MAX_IF_NAME))
214  return 0;
215 
216  /* return link name components, if necessary */
217  if (name_parts) {
218  name_parts->addr_local = tipc_addr(z_local, c_local, n_local);
219  strcpy(name_parts->if_local, if_local);
220  name_parts->addr_peer = tipc_addr(z_peer, c_peer, n_peer);
221  strcpy(name_parts->if_peer, if_peer);
222  }
223  return 1;
224 }
225 
235 static void link_timeout(struct tipc_link *l_ptr)
236 {
237  tipc_node_lock(l_ptr->owner);
238 
239  /* update counters used in statistical profiling of send traffic */
240  l_ptr->stats.accu_queue_sz += l_ptr->out_queue_size;
241  l_ptr->stats.queue_sz_counts++;
242 
243  if (l_ptr->first_out) {
244  struct tipc_msg *msg = buf_msg(l_ptr->first_out);
245  u32 length = msg_size(msg);
246 
247  if ((msg_user(msg) == MSG_FRAGMENTER) &&
248  (msg_type(msg) == FIRST_FRAGMENT)) {
249  length = msg_size(msg_get_wrapped(msg));
250  }
251  if (length) {
252  l_ptr->stats.msg_lengths_total += length;
253  l_ptr->stats.msg_length_counts++;
254  if (length <= 64)
255  l_ptr->stats.msg_length_profile[0]++;
256  else if (length <= 256)
257  l_ptr->stats.msg_length_profile[1]++;
258  else if (length <= 1024)
259  l_ptr->stats.msg_length_profile[2]++;
260  else if (length <= 4096)
261  l_ptr->stats.msg_length_profile[3]++;
262  else if (length <= 16384)
263  l_ptr->stats.msg_length_profile[4]++;
264  else if (length <= 32768)
265  l_ptr->stats.msg_length_profile[5]++;
266  else
267  l_ptr->stats.msg_length_profile[6]++;
268  }
269  }
270 
271  /* do all other link processing performed on a periodic basis */
272  link_check_defragm_bufs(l_ptr);
273 
274  link_state_event(l_ptr, TIMEOUT_EVT);
275 
276  if (l_ptr->next_out)
277  tipc_link_push_queue(l_ptr);
278 
279  tipc_node_unlock(l_ptr->owner);
280 }
281 
282 static void link_set_timer(struct tipc_link *l_ptr, u32 time)
283 {
284  k_start_timer(&l_ptr->timer, time);
285 }
286 
295 struct tipc_link *tipc_link_create(struct tipc_node *n_ptr,
296  struct tipc_bearer *b_ptr,
297  const struct tipc_media_addr *media_addr)
298 {
299  struct tipc_link *l_ptr;
300  struct tipc_msg *msg;
301  char *if_name;
302  char addr_string[16];
303  u32 peer = n_ptr->addr;
304 
305  if (n_ptr->link_cnt >= 2) {
306  tipc_addr_string_fill(addr_string, n_ptr->addr);
307  pr_err("Attempt to establish third link to %s\n", addr_string);
308  return NULL;
309  }
310 
311  if (n_ptr->links[b_ptr->identity]) {
312  tipc_addr_string_fill(addr_string, n_ptr->addr);
313  pr_err("Attempt to establish second link on <%s> to %s\n",
314  b_ptr->name, addr_string);
315  return NULL;
316  }
317 
318  l_ptr = kzalloc(sizeof(*l_ptr), GFP_ATOMIC);
319  if (!l_ptr) {
320  pr_warn("Link creation failed, no memory\n");
321  return NULL;
322  }
323 
324  l_ptr->addr = peer;
325  if_name = strchr(b_ptr->name, ':') + 1;
326  sprintf(l_ptr->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
327  tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
328  tipc_node(tipc_own_addr),
329  if_name,
330  tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
331  /* note: peer i/f name is updated by reset/activate message */
332  memcpy(&l_ptr->media_addr, media_addr, sizeof(*media_addr));
333  l_ptr->owner = n_ptr;
334  l_ptr->checkpoint = 1;
335  l_ptr->peer_session = INVALID_SESSION;
336  l_ptr->b_ptr = b_ptr;
337  link_set_supervision_props(l_ptr, b_ptr->tolerance);
338  l_ptr->state = RESET_UNKNOWN;
339 
340  l_ptr->pmsg = (struct tipc_msg *)&l_ptr->proto_msg;
341  msg = l_ptr->pmsg;
343  msg_set_size(msg, sizeof(l_ptr->proto_msg));
344  msg_set_session(msg, (tipc_random & 0xffff));
345  msg_set_bearer_id(msg, b_ptr->identity);
346  strcpy((char *)msg_data(msg), if_name);
347 
348  l_ptr->priority = b_ptr->priority;
349  tipc_link_set_queue_limits(l_ptr, b_ptr->window);
350 
351  link_init_max_pkt(l_ptr);
352 
353  l_ptr->next_out_no = 1;
354  INIT_LIST_HEAD(&l_ptr->waiting_ports);
355 
356  link_reset_statistics(l_ptr);
357 
358  tipc_node_attach_link(n_ptr, l_ptr);
359 
360  k_init_timer(&l_ptr->timer, (Handler)link_timeout, (unsigned long)l_ptr);
361  list_add_tail(&l_ptr->link_list, &b_ptr->links);
362  tipc_k_signal((Handler)link_start, (unsigned long)l_ptr);
363 
364  return l_ptr;
365 }
366 
375 void tipc_link_delete(struct tipc_link *l_ptr)
376 {
377  if (!l_ptr) {
378  pr_err("Attempt to delete non-existent link\n");
379  return;
380  }
381 
382  k_cancel_timer(&l_ptr->timer);
383 
384  tipc_node_lock(l_ptr->owner);
385  tipc_link_reset(l_ptr);
386  tipc_node_detach_link(l_ptr->owner, l_ptr);
387  tipc_link_stop(l_ptr);
388  list_del_init(&l_ptr->link_list);
389  tipc_node_unlock(l_ptr->owner);
390  k_term_timer(&l_ptr->timer);
391  kfree(l_ptr);
392 }
393 
394 static void link_start(struct tipc_link *l_ptr)
395 {
396  tipc_node_lock(l_ptr->owner);
397  link_state_event(l_ptr, STARTING_EVT);
398  tipc_node_unlock(l_ptr->owner);
399 }
400 
410 static int link_schedule_port(struct tipc_link *l_ptr, u32 origport, u32 sz)
411 {
412  struct tipc_port *p_ptr;
413 
414  spin_lock_bh(&tipc_port_list_lock);
415  p_ptr = tipc_port_lock(origport);
416  if (p_ptr) {
417  if (!p_ptr->wakeup)
418  goto exit;
419  if (!list_empty(&p_ptr->wait_list))
420  goto exit;
421  p_ptr->congested = 1;
422  p_ptr->waiting_pkts = 1 + ((sz - 1) / l_ptr->max_pkt);
423  list_add_tail(&p_ptr->wait_list, &l_ptr->waiting_ports);
424  l_ptr->stats.link_congs++;
425 exit:
426  tipc_port_unlock(p_ptr);
427  }
428  spin_unlock_bh(&tipc_port_list_lock);
429  return -ELINKCONG;
430 }
431 
432 void tipc_link_wakeup_ports(struct tipc_link *l_ptr, int all)
433 {
434  struct tipc_port *p_ptr;
435  struct tipc_port *temp_p_ptr;
436  int win = l_ptr->queue_limit[0] - l_ptr->out_queue_size;
437 
438  if (all)
439  win = 100000;
440  if (win <= 0)
441  return;
442  if (!spin_trylock_bh(&tipc_port_list_lock))
443  return;
444  if (link_congested(l_ptr))
445  goto exit;
446  list_for_each_entry_safe(p_ptr, temp_p_ptr, &l_ptr->waiting_ports,
447  wait_list) {
448  if (win <= 0)
449  break;
450  list_del_init(&p_ptr->wait_list);
451  spin_lock_bh(p_ptr->lock);
452  p_ptr->congested = 0;
453  p_ptr->wakeup(p_ptr);
454  win -= p_ptr->waiting_pkts;
455  spin_unlock_bh(p_ptr->lock);
456  }
457 
458 exit:
459  spin_unlock_bh(&tipc_port_list_lock);
460 }
461 
466 static void link_release_outqueue(struct tipc_link *l_ptr)
467 {
468  struct sk_buff *buf = l_ptr->first_out;
469  struct sk_buff *next;
470 
471  while (buf) {
472  next = buf->next;
473  kfree_skb(buf);
474  buf = next;
475  }
476  l_ptr->first_out = NULL;
477  l_ptr->out_queue_size = 0;
478 }
479 
485 {
486  struct sk_buff *buf = l_ptr->defragm_buf;
487  struct sk_buff *next;
488 
489  while (buf) {
490  next = buf->next;
491  kfree_skb(buf);
492  buf = next;
493  }
494  l_ptr->defragm_buf = NULL;
495 }
496 
501 void tipc_link_stop(struct tipc_link *l_ptr)
502 {
503  struct sk_buff *buf;
504  struct sk_buff *next;
505 
506  buf = l_ptr->oldest_deferred_in;
507  while (buf) {
508  next = buf->next;
509  kfree_skb(buf);
510  buf = next;
511  }
512 
513  buf = l_ptr->first_out;
514  while (buf) {
515  next = buf->next;
516  kfree_skb(buf);
517  buf = next;
518  }
519 
521 
522  kfree_skb(l_ptr->proto_msg_queue);
523  l_ptr->proto_msg_queue = NULL;
524 }
525 
526 void tipc_link_reset(struct tipc_link *l_ptr)
527 {
528  struct sk_buff *buf;
529  u32 prev_state = l_ptr->state;
530  u32 checkpoint = l_ptr->next_in_no;
531  int was_active_link = tipc_link_is_active(l_ptr);
532 
533  msg_set_session(l_ptr->pmsg, ((msg_session(l_ptr->pmsg) + 1) & 0xffff));
534 
535  /* Link is down, accept any session */
536  l_ptr->peer_session = INVALID_SESSION;
537 
538  /* Prepare for max packet size negotiation */
539  link_init_max_pkt(l_ptr);
540 
541  l_ptr->state = RESET_UNKNOWN;
542 
543  if ((prev_state == RESET_UNKNOWN) || (prev_state == RESET_RESET))
544  return;
545 
546  tipc_node_link_down(l_ptr->owner, l_ptr);
547  tipc_bearer_remove_dest(l_ptr->b_ptr, l_ptr->addr);
548 
549  if (was_active_link && tipc_node_active_links(l_ptr->owner) &&
550  l_ptr->owner->permit_changeover) {
551  l_ptr->reset_checkpoint = checkpoint;
553  }
554 
555  /* Clean up all queues: */
556  link_release_outqueue(l_ptr);
557  kfree_skb(l_ptr->proto_msg_queue);
558  l_ptr->proto_msg_queue = NULL;
559  buf = l_ptr->oldest_deferred_in;
560  while (buf) {
561  struct sk_buff *next = buf->next;
562  kfree_skb(buf);
563  buf = next;
564  }
565  if (!list_empty(&l_ptr->waiting_ports))
566  tipc_link_wakeup_ports(l_ptr, 1);
567 
568  l_ptr->retransm_queue_head = 0;
569  l_ptr->retransm_queue_size = 0;
570  l_ptr->last_out = NULL;
571  l_ptr->first_out = NULL;
572  l_ptr->next_out = NULL;
573  l_ptr->unacked_window = 0;
574  l_ptr->checkpoint = 1;
575  l_ptr->next_out_no = 1;
576  l_ptr->deferred_inqueue_sz = 0;
577  l_ptr->oldest_deferred_in = NULL;
578  l_ptr->newest_deferred_in = NULL;
579  l_ptr->fsm_msg_cnt = 0;
580  l_ptr->stale_count = 0;
581  link_reset_statistics(l_ptr);
582 }
583 
584 
585 static void link_activate(struct tipc_link *l_ptr)
586 {
587  l_ptr->next_in_no = l_ptr->stats.recv_info = 1;
588  tipc_node_link_up(l_ptr->owner, l_ptr);
589  tipc_bearer_add_dest(l_ptr->b_ptr, l_ptr->addr);
590 }
591 
597 static void link_state_event(struct tipc_link *l_ptr, unsigned int event)
598 {
599  struct tipc_link *other;
600  u32 cont_intv = l_ptr->continuity_interval;
601 
602  if (!l_ptr->started && (event != STARTING_EVT))
603  return; /* Not yet. */
604 
605  if (link_blocked(l_ptr)) {
606  if (event == TIMEOUT_EVT)
607  link_set_timer(l_ptr, cont_intv);
608  return; /* Changeover going on */
609  }
610 
611  switch (l_ptr->state) {
612  case WORKING_WORKING:
613  switch (event) {
614  case TRAFFIC_MSG_EVT:
615  case ACTIVATE_MSG:
616  break;
617  case TIMEOUT_EVT:
618  if (l_ptr->next_in_no != l_ptr->checkpoint) {
619  l_ptr->checkpoint = l_ptr->next_in_no;
620  if (tipc_bclink_acks_missing(l_ptr->owner)) {
622  0, 0, 0, 0, 0);
623  l_ptr->fsm_msg_cnt++;
624  } else if (l_ptr->max_pkt < l_ptr->max_pkt_target) {
626  1, 0, 0, 0, 0);
627  l_ptr->fsm_msg_cnt++;
628  }
629  link_set_timer(l_ptr, cont_intv);
630  break;
631  }
632  l_ptr->state = WORKING_UNKNOWN;
633  l_ptr->fsm_msg_cnt = 0;
634  tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
635  l_ptr->fsm_msg_cnt++;
636  link_set_timer(l_ptr, cont_intv / 4);
637  break;
638  case RESET_MSG:
639  pr_info("%s<%s>, requested by peer\n", link_rst_msg,
640  l_ptr->name);
641  tipc_link_reset(l_ptr);
642  l_ptr->state = RESET_RESET;
643  l_ptr->fsm_msg_cnt = 0;
644  tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
645  l_ptr->fsm_msg_cnt++;
646  link_set_timer(l_ptr, cont_intv);
647  break;
648  default:
649  pr_err("%s%u in WW state\n", link_unk_evt, event);
650  }
651  break;
652  case WORKING_UNKNOWN:
653  switch (event) {
654  case TRAFFIC_MSG_EVT:
655  case ACTIVATE_MSG:
656  l_ptr->state = WORKING_WORKING;
657  l_ptr->fsm_msg_cnt = 0;
658  link_set_timer(l_ptr, cont_intv);
659  break;
660  case RESET_MSG:
661  pr_info("%s<%s>, requested by peer while probing\n",
662  link_rst_msg, l_ptr->name);
663  tipc_link_reset(l_ptr);
664  l_ptr->state = RESET_RESET;
665  l_ptr->fsm_msg_cnt = 0;
666  tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
667  l_ptr->fsm_msg_cnt++;
668  link_set_timer(l_ptr, cont_intv);
669  break;
670  case TIMEOUT_EVT:
671  if (l_ptr->next_in_no != l_ptr->checkpoint) {
672  l_ptr->state = WORKING_WORKING;
673  l_ptr->fsm_msg_cnt = 0;
674  l_ptr->checkpoint = l_ptr->next_in_no;
675  if (tipc_bclink_acks_missing(l_ptr->owner)) {
677  0, 0, 0, 0, 0);
678  l_ptr->fsm_msg_cnt++;
679  }
680  link_set_timer(l_ptr, cont_intv);
681  } else if (l_ptr->fsm_msg_cnt < l_ptr->abort_limit) {
683  1, 0, 0, 0, 0);
684  l_ptr->fsm_msg_cnt++;
685  link_set_timer(l_ptr, cont_intv / 4);
686  } else { /* Link has failed */
687  pr_warn("%s<%s>, peer not responding\n",
688  link_rst_msg, l_ptr->name);
689  tipc_link_reset(l_ptr);
690  l_ptr->state = RESET_UNKNOWN;
691  l_ptr->fsm_msg_cnt = 0;
693  0, 0, 0, 0, 0);
694  l_ptr->fsm_msg_cnt++;
695  link_set_timer(l_ptr, cont_intv);
696  }
697  break;
698  default:
699  pr_err("%s%u in WU state\n", link_unk_evt, event);
700  }
701  break;
702  case RESET_UNKNOWN:
703  switch (event) {
704  case TRAFFIC_MSG_EVT:
705  break;
706  case ACTIVATE_MSG:
707  other = l_ptr->owner->active_links[0];
708  if (other && link_working_unknown(other))
709  break;
710  l_ptr->state = WORKING_WORKING;
711  l_ptr->fsm_msg_cnt = 0;
712  link_activate(l_ptr);
713  tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
714  l_ptr->fsm_msg_cnt++;
715  link_set_timer(l_ptr, cont_intv);
716  break;
717  case RESET_MSG:
718  l_ptr->state = RESET_RESET;
719  l_ptr->fsm_msg_cnt = 0;
720  tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 1, 0, 0, 0, 0);
721  l_ptr->fsm_msg_cnt++;
722  link_set_timer(l_ptr, cont_intv);
723  break;
724  case STARTING_EVT:
725  l_ptr->started = 1;
726  /* fall through */
727  case TIMEOUT_EVT:
728  tipc_link_send_proto_msg(l_ptr, RESET_MSG, 0, 0, 0, 0, 0);
729  l_ptr->fsm_msg_cnt++;
730  link_set_timer(l_ptr, cont_intv);
731  break;
732  default:
733  pr_err("%s%u in RU state\n", link_unk_evt, event);
734  }
735  break;
736  case RESET_RESET:
737  switch (event) {
738  case TRAFFIC_MSG_EVT:
739  case ACTIVATE_MSG:
740  other = l_ptr->owner->active_links[0];
741  if (other && link_working_unknown(other))
742  break;
743  l_ptr->state = WORKING_WORKING;
744  l_ptr->fsm_msg_cnt = 0;
745  link_activate(l_ptr);
746  tipc_link_send_proto_msg(l_ptr, STATE_MSG, 1, 0, 0, 0, 0);
747  l_ptr->fsm_msg_cnt++;
748  link_set_timer(l_ptr, cont_intv);
749  break;
750  case RESET_MSG:
751  break;
752  case TIMEOUT_EVT:
753  tipc_link_send_proto_msg(l_ptr, ACTIVATE_MSG, 0, 0, 0, 0, 0);
754  l_ptr->fsm_msg_cnt++;
755  link_set_timer(l_ptr, cont_intv);
756  break;
757  default:
758  pr_err("%s%u in RR state\n", link_unk_evt, event);
759  }
760  break;
761  default:
762  pr_err("Unknown link state %u/%u\n", l_ptr->state, event);
763  }
764 }
765 
766 /*
767  * link_bundle_buf(): Append contents of a buffer to
768  * the tail of an existing one.
769  */
770 static int link_bundle_buf(struct tipc_link *l_ptr,
771  struct sk_buff *bundler,
772  struct sk_buff *buf)
773 {
774  struct tipc_msg *bundler_msg = buf_msg(bundler);
775  struct tipc_msg *msg = buf_msg(buf);
776  u32 size = msg_size(msg);
777  u32 bundle_size = msg_size(bundler_msg);
778  u32 to_pos = align(bundle_size);
779  u32 pad = to_pos - bundle_size;
780 
781  if (msg_user(bundler_msg) != MSG_BUNDLER)
782  return 0;
783  if (msg_type(bundler_msg) != OPEN_MSG)
784  return 0;
785  if (skb_tailroom(bundler) < (pad + size))
786  return 0;
787  if (l_ptr->max_pkt < (to_pos + size))
788  return 0;
789 
790  skb_put(bundler, pad + size);
791  skb_copy_to_linear_data_offset(bundler, to_pos, buf->data, size);
792  msg_set_size(bundler_msg, to_pos + size);
793  msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1);
794  kfree_skb(buf);
795  l_ptr->stats.sent_bundled++;
796  return 1;
797 }
798 
799 static void link_add_to_outqueue(struct tipc_link *l_ptr,
800  struct sk_buff *buf,
801  struct tipc_msg *msg)
802 {
803  u32 ack = mod(l_ptr->next_in_no - 1);
804  u32 seqno = mod(l_ptr->next_out_no++);
805 
806  msg_set_word(msg, 2, ((ack << 16) | seqno));
807  msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
808  buf->next = NULL;
809  if (l_ptr->first_out) {
810  l_ptr->last_out->next = buf;
811  l_ptr->last_out = buf;
812  } else
813  l_ptr->first_out = l_ptr->last_out = buf;
814 
815  l_ptr->out_queue_size++;
816  if (l_ptr->out_queue_size > l_ptr->stats.max_queue_sz)
817  l_ptr->stats.max_queue_sz = l_ptr->out_queue_size;
818 }
819 
820 static void link_add_chain_to_outqueue(struct tipc_link *l_ptr,
821  struct sk_buff *buf_chain,
822  u32 long_msgno)
823 {
824  struct sk_buff *buf;
825  struct tipc_msg *msg;
826 
827  if (!l_ptr->next_out)
828  l_ptr->next_out = buf_chain;
829  while (buf_chain) {
830  buf = buf_chain;
831  buf_chain = buf_chain->next;
832 
833  msg = buf_msg(buf);
834  msg_set_long_msgno(msg, long_msgno);
835  link_add_to_outqueue(l_ptr, buf, msg);
836  }
837 }
838 
839 /*
840  * tipc_link_send_buf() is the 'full path' for messages, called from
841  * inside TIPC when the 'fast path' in tipc_send_buf
842  * has failed, and from link_send()
843  */
844 int tipc_link_send_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
845 {
846  struct tipc_msg *msg = buf_msg(buf);
847  u32 size = msg_size(msg);
848  u32 dsz = msg_data_sz(msg);
849  u32 queue_size = l_ptr->out_queue_size;
850  u32 imp = tipc_msg_tot_importance(msg);
851  u32 queue_limit = l_ptr->queue_limit[imp];
852  u32 max_packet = l_ptr->max_pkt;
853 
854  /* Match msg importance against queue limits: */
855  if (unlikely(queue_size >= queue_limit)) {
856  if (imp <= TIPC_CRITICAL_IMPORTANCE) {
857  link_schedule_port(l_ptr, msg_origport(msg), size);
858  kfree_skb(buf);
859  return -ELINKCONG;
860  }
861  kfree_skb(buf);
862  if (imp > CONN_MANAGER) {
863  pr_warn("%s<%s>, send queue full", link_rst_msg,
864  l_ptr->name);
865  tipc_link_reset(l_ptr);
866  }
867  return dsz;
868  }
869 
870  /* Fragmentation needed ? */
871  if (size > max_packet)
872  return link_send_long_buf(l_ptr, buf);
873 
874  /* Packet can be queued or sent. */
875  if (likely(!tipc_bearer_congested(l_ptr->b_ptr, l_ptr) &&
876  !link_congested(l_ptr))) {
877  link_add_to_outqueue(l_ptr, buf, msg);
878 
879  if (likely(tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr))) {
880  l_ptr->unacked_window = 0;
881  } else {
882  tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
883  l_ptr->stats.bearer_congs++;
884  l_ptr->next_out = buf;
885  }
886  return dsz;
887  }
888  /* Congestion: can message be bundled ? */
889  if ((msg_user(msg) != CHANGEOVER_PROTOCOL) &&
890  (msg_user(msg) != MSG_FRAGMENTER)) {
891 
892  /* Try adding message to an existing bundle */
893  if (l_ptr->next_out &&
894  link_bundle_buf(l_ptr, l_ptr->last_out, buf)) {
895  tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
896  return dsz;
897  }
898 
899  /* Try creating a new bundle */
900  if (size <= max_packet * 2 / 3) {
901  struct sk_buff *bundler = tipc_buf_acquire(max_packet);
902  struct tipc_msg bundler_hdr;
903 
904  if (bundler) {
905  tipc_msg_init(&bundler_hdr, MSG_BUNDLER, OPEN_MSG,
906  INT_H_SIZE, l_ptr->addr);
907  skb_copy_to_linear_data(bundler, &bundler_hdr,
908  INT_H_SIZE);
909  skb_trim(bundler, INT_H_SIZE);
910  link_bundle_buf(l_ptr, bundler, buf);
911  buf = bundler;
912  msg = buf_msg(buf);
913  l_ptr->stats.sent_bundles++;
914  }
915  }
916  }
917  if (!l_ptr->next_out)
918  l_ptr->next_out = buf;
919  link_add_to_outqueue(l_ptr, buf, msg);
920  tipc_bearer_resolve_congestion(l_ptr->b_ptr, l_ptr);
921  return dsz;
922 }
923 
924 /*
925  * tipc_link_send(): same as tipc_link_send_buf(), but the link to use has
926  * not been selected yet, and the the owner node is not locked
927  * Called by TIPC internal users, e.g. the name distributor
928  */
930 {
931  struct tipc_link *l_ptr;
932  struct tipc_node *n_ptr;
933  int res = -ELINKCONG;
934 
936  n_ptr = tipc_node_find(dest);
937  if (n_ptr) {
938  tipc_node_lock(n_ptr);
939  l_ptr = n_ptr->active_links[selector & 1];
940  if (l_ptr)
941  res = tipc_link_send_buf(l_ptr, buf);
942  else
943  kfree_skb(buf);
944  tipc_node_unlock(n_ptr);
945  } else {
946  kfree_skb(buf);
947  }
949  return res;
950 }
951 
961 void tipc_link_send_names(struct list_head *message_list, u32 dest)
962 {
963  struct tipc_node *n_ptr;
964  struct tipc_link *l_ptr;
965  struct sk_buff *buf;
966  struct sk_buff *temp_buf;
967 
968  if (list_empty(message_list))
969  return;
970 
972  n_ptr = tipc_node_find(dest);
973  if (n_ptr) {
974  tipc_node_lock(n_ptr);
975  l_ptr = n_ptr->active_links[0];
976  if (l_ptr) {
977  /* convert circular list to linear list */
978  ((struct sk_buff *)message_list->prev)->next = NULL;
979  link_add_chain_to_outqueue(l_ptr,
980  (struct sk_buff *)message_list->next, 0);
981  tipc_link_push_queue(l_ptr);
982  INIT_LIST_HEAD(message_list);
983  }
984  tipc_node_unlock(n_ptr);
985  }
987 
988  /* discard the messages if they couldn't be sent */
989  list_for_each_safe(buf, temp_buf, ((struct sk_buff *)message_list)) {
990  list_del((struct list_head *)buf);
991  kfree_skb(buf);
992  }
993 }
994 
995 /*
996  * link_send_buf_fast: Entry for data messages where the
997  * destination link is known and the header is complete,
998  * inclusive total message length. Very time critical.
999  * Link is locked. Returns user data length.
1000  */
1001 static int link_send_buf_fast(struct tipc_link *l_ptr, struct sk_buff *buf,
1002  u32 *used_max_pkt)
1003 {
1004  struct tipc_msg *msg = buf_msg(buf);
1005  int res = msg_data_sz(msg);
1006 
1007  if (likely(!link_congested(l_ptr))) {
1008  if (likely(msg_size(msg) <= l_ptr->max_pkt)) {
1009  if (likely(list_empty(&l_ptr->b_ptr->cong_links))) {
1010  link_add_to_outqueue(l_ptr, buf, msg);
1011  if (likely(tipc_bearer_send(l_ptr->b_ptr, buf,
1012  &l_ptr->media_addr))) {
1013  l_ptr->unacked_window = 0;
1014  return res;
1015  }
1016  tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
1017  l_ptr->stats.bearer_congs++;
1018  l_ptr->next_out = buf;
1019  return res;
1020  }
1021  } else
1022  *used_max_pkt = l_ptr->max_pkt;
1023  }
1024  return tipc_link_send_buf(l_ptr, buf); /* All other cases */
1025 }
1026 
1027 /*
1028  * tipc_send_buf_fast: Entry for data messages where the
1029  * destination node is known and the header is complete,
1030  * inclusive total message length.
1031  * Returns user data length.
1032  */
1033 int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode)
1034 {
1035  struct tipc_link *l_ptr;
1036  struct tipc_node *n_ptr;
1037  int res;
1038  u32 selector = msg_origport(buf_msg(buf)) & 1;
1039  u32 dummy;
1040 
1042  n_ptr = tipc_node_find(destnode);
1043  if (likely(n_ptr)) {
1044  tipc_node_lock(n_ptr);
1045  l_ptr = n_ptr->active_links[selector];
1046  if (likely(l_ptr)) {
1047  res = link_send_buf_fast(l_ptr, buf, &dummy);
1048  tipc_node_unlock(n_ptr);
1050  return res;
1051  }
1052  tipc_node_unlock(n_ptr);
1053  }
1055  res = msg_data_sz(buf_msg(buf));
1057  return res;
1058 }
1059 
1060 
1061 /*
1062  * tipc_link_send_sections_fast: Entry for messages where the
1063  * destination processor is known and the header is complete,
1064  * except for total message length.
1065  * Returns user data length or errno.
1066  */
1068  struct iovec const *msg_sect,
1069  const u32 num_sect,
1070  unsigned int total_len,
1071  u32 destaddr)
1072 {
1073  struct tipc_msg *hdr = &sender->phdr;
1074  struct tipc_link *l_ptr;
1075  struct sk_buff *buf;
1076  struct tipc_node *node;
1077  int res;
1078  u32 selector = msg_origport(hdr) & 1;
1079 
1080 again:
1081  /*
1082  * Try building message using port's max_pkt hint.
1083  * (Must not hold any locks while building message.)
1084  */
1085  res = tipc_msg_build(hdr, msg_sect, num_sect, total_len,
1086  sender->max_pkt, !sender->user_port, &buf);
1087 
1089  node = tipc_node_find(destaddr);
1090  if (likely(node)) {
1091  tipc_node_lock(node);
1092  l_ptr = node->active_links[selector];
1093  if (likely(l_ptr)) {
1094  if (likely(buf)) {
1095  res = link_send_buf_fast(l_ptr, buf,
1096  &sender->max_pkt);
1097 exit:
1098  tipc_node_unlock(node);
1100  return res;
1101  }
1102 
1103  /* Exit if build request was invalid */
1104  if (unlikely(res < 0))
1105  goto exit;
1106 
1107  /* Exit if link (or bearer) is congested */
1108  if (link_congested(l_ptr) ||
1109  !list_empty(&l_ptr->b_ptr->cong_links)) {
1110  res = link_schedule_port(l_ptr,
1111  sender->ref, res);
1112  goto exit;
1113  }
1114 
1115  /*
1116  * Message size exceeds max_pkt hint; update hint,
1117  * then re-try fast path or fragment the message
1118  */
1119  sender->max_pkt = l_ptr->max_pkt;
1120  tipc_node_unlock(node);
1122 
1123 
1124  if ((msg_hdr_sz(hdr) + res) <= sender->max_pkt)
1125  goto again;
1126 
1127  return link_send_sections_long(sender, msg_sect,
1128  num_sect, total_len,
1129  destaddr);
1130  }
1131  tipc_node_unlock(node);
1132  }
1134 
1135  /* Couldn't find a link to the destination node */
1136  if (buf)
1137  return tipc_reject_msg(buf, TIPC_ERR_NO_NODE);
1138  if (res >= 0)
1139  return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
1140  total_len, TIPC_ERR_NO_NODE);
1141  return res;
1142 }
1143 
1144 /*
1145  * link_send_sections_long(): Entry for long messages where the
1146  * destination node is known and the header is complete,
1147  * inclusive total message length.
1148  * Link and bearer congestion status have been checked to be ok,
1149  * and are ignored if they change.
1150  *
1151  * Note that fragments do not use the full link MTU so that they won't have
1152  * to undergo refragmentation if link changeover causes them to be sent
1153  * over another link with an additional tunnel header added as prefix.
1154  * (Refragmentation will still occur if the other link has a smaller MTU.)
1155  *
1156  * Returns user data length or errno.
1157  */
1158 static int link_send_sections_long(struct tipc_port *sender,
1159  struct iovec const *msg_sect,
1160  u32 num_sect,
1161  unsigned int total_len,
1162  u32 destaddr)
1163 {
1164  struct tipc_link *l_ptr;
1165  struct tipc_node *node;
1166  struct tipc_msg *hdr = &sender->phdr;
1167  u32 dsz = total_len;
1168  u32 max_pkt, fragm_sz, rest;
1169  struct tipc_msg fragm_hdr;
1170  struct sk_buff *buf, *buf_chain, *prev;
1171  u32 fragm_crs, fragm_rest, hsz, sect_rest;
1172  const unchar *sect_crs;
1173  int curr_sect;
1174  u32 fragm_no;
1175 
1176 again:
1177  fragm_no = 1;
1178  max_pkt = sender->max_pkt - INT_H_SIZE;
1179  /* leave room for tunnel header in case of link changeover */
1180  fragm_sz = max_pkt - INT_H_SIZE;
1181  /* leave room for fragmentation header in each fragment */
1182  rest = dsz;
1183  fragm_crs = 0;
1184  fragm_rest = 0;
1185  sect_rest = 0;
1186  sect_crs = NULL;
1187  curr_sect = -1;
1188 
1189  /* Prepare reusable fragment header */
1191  INT_H_SIZE, msg_destnode(hdr));
1192  msg_set_size(&fragm_hdr, max_pkt);
1193  msg_set_fragm_no(&fragm_hdr, 1);
1194 
1195  /* Prepare header of first fragment */
1196  buf_chain = buf = tipc_buf_acquire(max_pkt);
1197  if (!buf)
1198  return -ENOMEM;
1199  buf->next = NULL;
1200  skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
1201  hsz = msg_hdr_sz(hdr);
1202  skb_copy_to_linear_data_offset(buf, INT_H_SIZE, hdr, hsz);
1203 
1204  /* Chop up message */
1205  fragm_crs = INT_H_SIZE + hsz;
1206  fragm_rest = fragm_sz - hsz;
1207 
1208  do { /* For all sections */
1209  u32 sz;
1210 
1211  if (!sect_rest) {
1212  sect_rest = msg_sect[++curr_sect].iov_len;
1213  sect_crs = (const unchar *)msg_sect[curr_sect].iov_base;
1214  }
1215 
1216  if (sect_rest < fragm_rest)
1217  sz = sect_rest;
1218  else
1219  sz = fragm_rest;
1220 
1221  if (likely(!sender->user_port)) {
1222  if (copy_from_user(buf->data + fragm_crs, sect_crs, sz)) {
1223 error:
1224  for (; buf_chain; buf_chain = buf) {
1225  buf = buf_chain->next;
1226  kfree_skb(buf_chain);
1227  }
1228  return -EFAULT;
1229  }
1230  } else
1231  skb_copy_to_linear_data_offset(buf, fragm_crs,
1232  sect_crs, sz);
1233  sect_crs += sz;
1234  sect_rest -= sz;
1235  fragm_crs += sz;
1236  fragm_rest -= sz;
1237  rest -= sz;
1238 
1239  if (!fragm_rest && rest) {
1240 
1241  /* Initiate new fragment: */
1242  if (rest <= fragm_sz) {
1243  fragm_sz = rest;
1244  msg_set_type(&fragm_hdr, LAST_FRAGMENT);
1245  } else {
1246  msg_set_type(&fragm_hdr, FRAGMENT);
1247  }
1248  msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
1249  msg_set_fragm_no(&fragm_hdr, ++fragm_no);
1250  prev = buf;
1251  buf = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
1252  if (!buf)
1253  goto error;
1254 
1255  buf->next = NULL;
1256  prev->next = buf;
1257  skb_copy_to_linear_data(buf, &fragm_hdr, INT_H_SIZE);
1258  fragm_crs = INT_H_SIZE;
1259  fragm_rest = fragm_sz;
1260  }
1261  } while (rest > 0);
1262 
1263  /*
1264  * Now we have a buffer chain. Select a link and check
1265  * that packet size is still OK
1266  */
1267  node = tipc_node_find(destaddr);
1268  if (likely(node)) {
1269  tipc_node_lock(node);
1270  l_ptr = node->active_links[sender->ref & 1];
1271  if (!l_ptr) {
1272  tipc_node_unlock(node);
1273  goto reject;
1274  }
1275  if (l_ptr->max_pkt < max_pkt) {
1276  sender->max_pkt = l_ptr->max_pkt;
1277  tipc_node_unlock(node);
1278  for (; buf_chain; buf_chain = buf) {
1279  buf = buf_chain->next;
1280  kfree_skb(buf_chain);
1281  }
1282  goto again;
1283  }
1284  } else {
1285 reject:
1286  for (; buf_chain; buf_chain = buf) {
1287  buf = buf_chain->next;
1288  kfree_skb(buf_chain);
1289  }
1290  return tipc_port_reject_sections(sender, hdr, msg_sect, num_sect,
1291  total_len, TIPC_ERR_NO_NODE);
1292  }
1293 
1294  /* Append chain of fragments to send queue & send them */
1295  l_ptr->long_msg_seq_no++;
1296  link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
1297  l_ptr->stats.sent_fragments += fragm_no;
1298  l_ptr->stats.sent_fragmented++;
1299  tipc_link_push_queue(l_ptr);
1300  tipc_node_unlock(node);
1301  return dsz;
1302 }
1303 
1304 /*
1305  * tipc_link_push_packet: Push one unsent packet to the media
1306  */
1308 {
1309  struct sk_buff *buf = l_ptr->first_out;
1310  u32 r_q_size = l_ptr->retransm_queue_size;
1311  u32 r_q_head = l_ptr->retransm_queue_head;
1312 
1313  /* Step to position where retransmission failed, if any, */
1314  /* consider that buffers may have been released in meantime */
1315  if (r_q_size && buf) {
1316  u32 last = lesser(mod(r_q_head + r_q_size),
1317  link_last_sent(l_ptr));
1318  u32 first = buf_seqno(buf);
1319 
1320  while (buf && less(first, r_q_head)) {
1321  first = mod(first + 1);
1322  buf = buf->next;
1323  }
1324  l_ptr->retransm_queue_head = r_q_head = first;
1325  l_ptr->retransm_queue_size = r_q_size = mod(last - first);
1326  }
1327 
1328  /* Continue retransmission now, if there is anything: */
1329  if (r_q_size && buf) {
1330  msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
1331  msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
1332  if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
1333  l_ptr->retransm_queue_head = mod(++r_q_head);
1334  l_ptr->retransm_queue_size = --r_q_size;
1335  l_ptr->stats.retransmitted++;
1336  return 0;
1337  } else {
1338  l_ptr->stats.bearer_congs++;
1339  return PUSH_FAILED;
1340  }
1341  }
1342 
1343  /* Send deferred protocol message, if any: */
1344  buf = l_ptr->proto_msg_queue;
1345  if (buf) {
1346  msg_set_ack(buf_msg(buf), mod(l_ptr->next_in_no - 1));
1347  msg_set_bcast_ack(buf_msg(buf), l_ptr->owner->bclink.last_in);
1348  if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
1349  l_ptr->unacked_window = 0;
1350  kfree_skb(buf);
1351  l_ptr->proto_msg_queue = NULL;
1352  return 0;
1353  } else {
1354  l_ptr->stats.bearer_congs++;
1355  return PUSH_FAILED;
1356  }
1357  }
1358 
1359  /* Send one deferred data message, if send window not full: */
1360  buf = l_ptr->next_out;
1361  if (buf) {
1362  struct tipc_msg *msg = buf_msg(buf);
1363  u32 next = msg_seqno(msg);
1364  u32 first = buf_seqno(l_ptr->first_out);
1365 
1366  if (mod(next - first) < l_ptr->queue_limit[0]) {
1367  msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1368  msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
1369  if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
1370  if (msg_user(msg) == MSG_BUNDLER)
1371  msg_set_type(msg, CLOSED_MSG);
1372  l_ptr->next_out = buf->next;
1373  return 0;
1374  } else {
1375  l_ptr->stats.bearer_congs++;
1376  return PUSH_FAILED;
1377  }
1378  }
1379  }
1380  return PUSH_FINISHED;
1381 }
1382 
1383 /*
1384  * push_queue(): push out the unsent messages of a link where
1385  * congestion has abated. Node is locked
1386  */
1387 void tipc_link_push_queue(struct tipc_link *l_ptr)
1388 {
1389  u32 res;
1390 
1391  if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr))
1392  return;
1393 
1394  do {
1395  res = tipc_link_push_packet(l_ptr);
1396  } while (!res);
1397 
1398  if (res == PUSH_FAILED)
1399  tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
1400 }
1401 
1402 static void link_reset_all(unsigned long addr)
1403 {
1404  struct tipc_node *n_ptr;
1405  char addr_string[16];
1406  u32 i;
1407 
1408  read_lock_bh(&tipc_net_lock);
1409  n_ptr = tipc_node_find((u32)addr);
1410  if (!n_ptr) {
1411  read_unlock_bh(&tipc_net_lock);
1412  return; /* node no longer exists */
1413  }
1414 
1415  tipc_node_lock(n_ptr);
1416 
1417  pr_warn("Resetting all links to %s\n",
1418  tipc_addr_string_fill(addr_string, n_ptr->addr));
1419 
1420  for (i = 0; i < MAX_BEARERS; i++) {
1421  if (n_ptr->links[i]) {
1422  link_print(n_ptr->links[i], "Resetting link\n");
1423  tipc_link_reset(n_ptr->links[i]);
1424  }
1425  }
1426 
1427  tipc_node_unlock(n_ptr);
1428  read_unlock_bh(&tipc_net_lock);
1429 }
1430 
1431 static void link_retransmit_failure(struct tipc_link *l_ptr,
1432  struct sk_buff *buf)
1433 {
1434  struct tipc_msg *msg = buf_msg(buf);
1435 
1436  pr_warn("Retransmission failure on link <%s>\n", l_ptr->name);
1437 
1438  if (l_ptr->addr) {
1439  /* Handle failure on standard link */
1440  link_print(l_ptr, "Resetting link\n");
1441  tipc_link_reset(l_ptr);
1442 
1443  } else {
1444  /* Handle failure on broadcast link */
1445  struct tipc_node *n_ptr;
1446  char addr_string[16];
1447 
1448  pr_info("Msg seq number: %u, ", msg_seqno(msg));
1449  pr_cont("Outstanding acks: %lu\n",
1450  (unsigned long) TIPC_SKB_CB(buf)->handle);
1451 
1452  n_ptr = tipc_bclink_retransmit_to();
1453  tipc_node_lock(n_ptr);
1454 
1455  tipc_addr_string_fill(addr_string, n_ptr->addr);
1456  pr_info("Broadcast link info for %s\n", addr_string);
1457  pr_info("Supportable: %d, Supported: %d, Acked: %u\n",
1458  n_ptr->bclink.supportable,
1459  n_ptr->bclink.supported,
1460  n_ptr->bclink.acked);
1461  pr_info("Last in: %u, Oos state: %u, Last sent: %u\n",
1462  n_ptr->bclink.last_in,
1463  n_ptr->bclink.oos_state,
1464  n_ptr->bclink.last_sent);
1465 
1466  tipc_k_signal((Handler)link_reset_all, (unsigned long)n_ptr->addr);
1467 
1468  tipc_node_unlock(n_ptr);
1469 
1470  l_ptr->stale_count = 0;
1471  }
1472 }
1473 
1474 void tipc_link_retransmit(struct tipc_link *l_ptr, struct sk_buff *buf,
1475  u32 retransmits)
1476 {
1477  struct tipc_msg *msg;
1478 
1479  if (!buf)
1480  return;
1481 
1482  msg = buf_msg(buf);
1483 
1484  if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
1485  if (l_ptr->retransm_queue_size == 0) {
1486  l_ptr->retransm_queue_head = msg_seqno(msg);
1487  l_ptr->retransm_queue_size = retransmits;
1488  } else {
1489  pr_err("Unexpected retransmit on link %s (qsize=%d)\n",
1490  l_ptr->name, l_ptr->retransm_queue_size);
1491  }
1492  return;
1493  } else {
1494  /* Detect repeated retransmit failures on uncongested bearer */
1495  if (l_ptr->last_retransmitted == msg_seqno(msg)) {
1496  if (++l_ptr->stale_count > 100) {
1497  link_retransmit_failure(l_ptr, buf);
1498  return;
1499  }
1500  } else {
1501  l_ptr->last_retransmitted = msg_seqno(msg);
1502  l_ptr->stale_count = 1;
1503  }
1504  }
1505 
1506  while (retransmits && (buf != l_ptr->next_out) && buf) {
1507  msg = buf_msg(buf);
1508  msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1509  msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
1510  if (tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
1511  buf = buf->next;
1512  retransmits--;
1513  l_ptr->stats.retransmitted++;
1514  } else {
1515  tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
1516  l_ptr->stats.bearer_congs++;
1517  l_ptr->retransm_queue_head = buf_seqno(buf);
1518  l_ptr->retransm_queue_size = retransmits;
1519  return;
1520  }
1521  }
1522 
1523  l_ptr->retransm_queue_head = l_ptr->retransm_queue_size = 0;
1524 }
1525 
1529 static struct sk_buff *link_insert_deferred_queue(struct tipc_link *l_ptr,
1530  struct sk_buff *buf)
1531 {
1532  u32 seq_no;
1533 
1534  if (l_ptr->oldest_deferred_in == NULL)
1535  return buf;
1536 
1537  seq_no = buf_seqno(l_ptr->oldest_deferred_in);
1538  if (seq_no == mod(l_ptr->next_in_no)) {
1539  l_ptr->newest_deferred_in->next = buf;
1540  buf = l_ptr->oldest_deferred_in;
1541  l_ptr->oldest_deferred_in = NULL;
1542  l_ptr->deferred_inqueue_sz = 0;
1543  }
1544  return buf;
1545 }
1546 
1559 static int link_recv_buf_validate(struct sk_buff *buf)
1560 {
1561  static u32 min_data_hdr_size[8] = {
1563  MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE, MAX_H_SIZE
1564  };
1565 
1566  struct tipc_msg *msg;
1567  u32 tipc_hdr[2];
1568  u32 size;
1569  u32 hdr_size;
1570  u32 min_hdr_size;
1571 
1572  if (unlikely(buf->len < MIN_H_SIZE))
1573  return 0;
1574 
1575  msg = skb_header_pointer(buf, 0, sizeof(tipc_hdr), tipc_hdr);
1576  if (msg == NULL)
1577  return 0;
1578 
1579  if (unlikely(msg_version(msg) != TIPC_VERSION))
1580  return 0;
1581 
1582  size = msg_size(msg);
1583  hdr_size = msg_hdr_sz(msg);
1584  min_hdr_size = msg_isdata(msg) ?
1585  min_data_hdr_size[msg_type(msg)] : INT_H_SIZE;
1586 
1587  if (unlikely((hdr_size < min_hdr_size) ||
1588  (size < hdr_size) ||
1589  (buf->len < size) ||
1590  (size - hdr_size > TIPC_MAX_USER_MSG_SIZE)))
1591  return 0;
1592 
1593  return pskb_may_pull(buf, hdr_size);
1594 }
1595 
1604 void tipc_recv_msg(struct sk_buff *head, struct tipc_bearer *b_ptr)
1605 {
1607  while (head) {
1608  struct tipc_node *n_ptr;
1609  struct tipc_link *l_ptr;
1610  struct sk_buff *crs;
1611  struct sk_buff *buf = head;
1612  struct tipc_msg *msg;
1613  u32 seq_no;
1614  u32 ackd;
1615  u32 released = 0;
1616  int type;
1617 
1618  head = head->next;
1619 
1620  /* Ensure bearer is still enabled */
1621  if (unlikely(!b_ptr->active))
1622  goto cont;
1623 
1624  /* Ensure message is well-formed */
1625  if (unlikely(!link_recv_buf_validate(buf)))
1626  goto cont;
1627 
1628  /* Ensure message data is a single contiguous unit */
1629  if (unlikely(skb_linearize(buf)))
1630  goto cont;
1631 
1632  /* Handle arrival of a non-unicast link message */
1633  msg = buf_msg(buf);
1634 
1635  if (unlikely(msg_non_seq(msg))) {
1636  if (msg_user(msg) == LINK_CONFIG)
1637  tipc_disc_recv_msg(buf, b_ptr);
1638  else
1639  tipc_bclink_recv_pkt(buf);
1640  continue;
1641  }
1642 
1643  /* Discard unicast link messages destined for another node */
1644  if (unlikely(!msg_short(msg) &&
1645  (msg_destnode(msg) != tipc_own_addr)))
1646  goto cont;
1647 
1648  /* Locate neighboring node that sent message */
1649  n_ptr = tipc_node_find(msg_prevnode(msg));
1650  if (unlikely(!n_ptr))
1651  goto cont;
1652  tipc_node_lock(n_ptr);
1653 
1654  /* Locate unicast link endpoint that should handle message */
1655  l_ptr = n_ptr->links[b_ptr->identity];
1656  if (unlikely(!l_ptr)) {
1657  tipc_node_unlock(n_ptr);
1658  goto cont;
1659  }
1660 
1661  /* Verify that communication with node is currently allowed */
1662  if ((n_ptr->block_setup & WAIT_PEER_DOWN) &&
1663  msg_user(msg) == LINK_PROTOCOL &&
1664  (msg_type(msg) == RESET_MSG ||
1665  msg_type(msg) == ACTIVATE_MSG) &&
1666  !msg_redundant_link(msg))
1667  n_ptr->block_setup &= ~WAIT_PEER_DOWN;
1668 
1669  if (n_ptr->block_setup) {
1670  tipc_node_unlock(n_ptr);
1671  goto cont;
1672  }
1673 
1674  /* Validate message sequence number info */
1675  seq_no = msg_seqno(msg);
1676  ackd = msg_ack(msg);
1677 
1678  /* Release acked messages */
1679  if (n_ptr->bclink.supported)
1680  tipc_bclink_acknowledge(n_ptr, msg_bcast_ack(msg));
1681 
1682  crs = l_ptr->first_out;
1683  while ((crs != l_ptr->next_out) &&
1684  less_eq(buf_seqno(crs), ackd)) {
1685  struct sk_buff *next = crs->next;
1686 
1687  kfree_skb(crs);
1688  crs = next;
1689  released++;
1690  }
1691  if (released) {
1692  l_ptr->first_out = crs;
1693  l_ptr->out_queue_size -= released;
1694  }
1695 
1696  /* Try sending any messages link endpoint has pending */
1697  if (unlikely(l_ptr->next_out))
1698  tipc_link_push_queue(l_ptr);
1699  if (unlikely(!list_empty(&l_ptr->waiting_ports)))
1700  tipc_link_wakeup_ports(l_ptr, 0);
1701  if (unlikely(++l_ptr->unacked_window >= TIPC_MIN_LINK_WIN)) {
1702  l_ptr->stats.sent_acks++;
1703  tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
1704  }
1705 
1706  /* Now (finally!) process the incoming message */
1707 protocol_check:
1708  if (likely(link_working_working(l_ptr))) {
1709  if (likely(seq_no == mod(l_ptr->next_in_no))) {
1710  l_ptr->next_in_no++;
1711  if (unlikely(l_ptr->oldest_deferred_in))
1712  head = link_insert_deferred_queue(l_ptr,
1713  head);
1714 deliver:
1715  if (likely(msg_isdata(msg))) {
1716  tipc_node_unlock(n_ptr);
1717  tipc_port_recv_msg(buf);
1718  continue;
1719  }
1720  switch (msg_user(msg)) {
1721  int ret;
1722  case MSG_BUNDLER:
1723  l_ptr->stats.recv_bundles++;
1724  l_ptr->stats.recv_bundled +=
1725  msg_msgcnt(msg);
1726  tipc_node_unlock(n_ptr);
1727  tipc_link_recv_bundle(buf);
1728  continue;
1729  case NAME_DISTRIBUTOR:
1730  tipc_node_unlock(n_ptr);
1731  tipc_named_recv(buf);
1732  continue;
1733  case CONN_MANAGER:
1734  tipc_node_unlock(n_ptr);
1736  continue;
1737  case MSG_FRAGMENTER:
1738  l_ptr->stats.recv_fragments++;
1740  &l_ptr->defragm_buf,
1741  &buf, &msg);
1742  if (ret == 1) {
1743  l_ptr->stats.recv_fragmented++;
1744  goto deliver;
1745  }
1746  if (ret == -1)
1747  l_ptr->next_in_no--;
1748  break;
1749  case CHANGEOVER_PROTOCOL:
1750  type = msg_type(msg);
1751  if (link_recv_changeover_msg(&l_ptr,
1752  &buf)) {
1753  msg = buf_msg(buf);
1754  seq_no = msg_seqno(msg);
1755  if (type == ORIGINAL_MSG)
1756  goto deliver;
1757  goto protocol_check;
1758  }
1759  break;
1760  default:
1761  kfree_skb(buf);
1762  buf = NULL;
1763  break;
1764  }
1765  tipc_node_unlock(n_ptr);
1766  tipc_net_route_msg(buf);
1767  continue;
1768  }
1769  link_handle_out_of_seq_msg(l_ptr, buf);
1770  head = link_insert_deferred_queue(l_ptr, head);
1771  tipc_node_unlock(n_ptr);
1772  continue;
1773  }
1774 
1775  if (msg_user(msg) == LINK_PROTOCOL) {
1776  link_recv_proto_msg(l_ptr, buf);
1777  head = link_insert_deferred_queue(l_ptr, head);
1778  tipc_node_unlock(n_ptr);
1779  continue;
1780  }
1781  link_state_event(l_ptr, TRAFFIC_MSG_EVT);
1782 
1783  if (link_working_working(l_ptr)) {
1784  /* Re-insert in front of queue */
1785  buf->next = head;
1786  head = buf;
1787  tipc_node_unlock(n_ptr);
1788  continue;
1789  }
1790  tipc_node_unlock(n_ptr);
1791 cont:
1792  kfree_skb(buf);
1793  }
1795 }
1796 
1803  struct sk_buff *buf)
1804 {
1805  struct sk_buff *queue_buf;
1806  struct sk_buff **prev;
1807  u32 seq_no = buf_seqno(buf);
1808 
1809  buf->next = NULL;
1810 
1811  /* Empty queue ? */
1812  if (*head == NULL) {
1813  *head = *tail = buf;
1814  return 1;
1815  }
1816 
1817  /* Last ? */
1818  if (less(buf_seqno(*tail), seq_no)) {
1819  (*tail)->next = buf;
1820  *tail = buf;
1821  return 1;
1822  }
1823 
1824  /* Locate insertion point in queue, then insert; discard if duplicate */
1825  prev = head;
1826  queue_buf = *head;
1827  for (;;) {
1828  u32 curr_seqno = buf_seqno(queue_buf);
1829 
1830  if (seq_no == curr_seqno) {
1831  kfree_skb(buf);
1832  return 0;
1833  }
1834 
1835  if (less(seq_no, curr_seqno))
1836  break;
1837 
1838  prev = &queue_buf->next;
1839  queue_buf = queue_buf->next;
1840  }
1841 
1842  buf->next = queue_buf;
1843  *prev = buf;
1844  return 1;
1845 }
1846 
1847 /*
1848  * link_handle_out_of_seq_msg - handle arrival of out-of-sequence packet
1849  */
1850 static void link_handle_out_of_seq_msg(struct tipc_link *l_ptr,
1851  struct sk_buff *buf)
1852 {
1853  u32 seq_no = buf_seqno(buf);
1854 
1855  if (likely(msg_user(buf_msg(buf)) == LINK_PROTOCOL)) {
1856  link_recv_proto_msg(l_ptr, buf);
1857  return;
1858  }
1859 
1860  /* Record OOS packet arrival (force mismatch on next timeout) */
1861  l_ptr->checkpoint--;
1862 
1863  /*
1864  * Discard packet if a duplicate; otherwise add it to deferred queue
1865  * and notify peer of gap as per protocol specification
1866  */
1867  if (less(seq_no, mod(l_ptr->next_in_no))) {
1868  l_ptr->stats.duplicates++;
1869  kfree_skb(buf);
1870  return;
1871  }
1872 
1874  &l_ptr->newest_deferred_in, buf)) {
1875  l_ptr->deferred_inqueue_sz++;
1876  l_ptr->stats.deferred_recv++;
1877  if ((l_ptr->deferred_inqueue_sz % 16) == 1)
1878  tipc_link_send_proto_msg(l_ptr, STATE_MSG, 0, 0, 0, 0, 0);
1879  } else
1880  l_ptr->stats.duplicates++;
1881 }
1882 
1883 /*
1884  * Send protocol message to the other endpoint.
1885  */
1886 void tipc_link_send_proto_msg(struct tipc_link *l_ptr, u32 msg_typ,
1887  int probe_msg, u32 gap, u32 tolerance,
1888  u32 priority, u32 ack_mtu)
1889 {
1890  struct sk_buff *buf = NULL;
1891  struct tipc_msg *msg = l_ptr->pmsg;
1892  u32 msg_size = sizeof(l_ptr->proto_msg);
1893  int r_flag;
1894 
1895  /* Discard any previous message that was deferred due to congestion */
1896  if (l_ptr->proto_msg_queue) {
1897  kfree_skb(l_ptr->proto_msg_queue);
1898  l_ptr->proto_msg_queue = NULL;
1899  }
1900 
1901  if (link_blocked(l_ptr))
1902  return;
1903 
1904  /* Abort non-RESET send if communication with node is prohibited */
1905  if ((l_ptr->owner->block_setup) && (msg_typ != RESET_MSG))
1906  return;
1907 
1908  /* Create protocol message with "out-of-sequence" sequence number */
1909  msg_set_type(msg, msg_typ);
1910  msg_set_net_plane(msg, l_ptr->b_ptr->net_plane);
1911  msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
1912  msg_set_last_bcast(msg, tipc_bclink_get_last_sent());
1913 
1914  if (msg_typ == STATE_MSG) {
1915  u32 next_sent = mod(l_ptr->next_out_no);
1916 
1917  if (!tipc_link_is_up(l_ptr))
1918  return;
1919  if (l_ptr->next_out)
1920  next_sent = buf_seqno(l_ptr->next_out);
1921  msg_set_next_sent(msg, next_sent);
1922  if (l_ptr->oldest_deferred_in) {
1923  u32 rec = buf_seqno(l_ptr->oldest_deferred_in);
1924  gap = mod(rec - mod(l_ptr->next_in_no));
1925  }
1926  msg_set_seq_gap(msg, gap);
1927  if (gap)
1928  l_ptr->stats.sent_nacks++;
1929  msg_set_link_tolerance(msg, tolerance);
1930  msg_set_linkprio(msg, priority);
1931  msg_set_max_pkt(msg, ack_mtu);
1932  msg_set_ack(msg, mod(l_ptr->next_in_no - 1));
1933  msg_set_probe(msg, probe_msg != 0);
1934  if (probe_msg) {
1935  u32 mtu = l_ptr->max_pkt;
1936 
1937  if ((mtu < l_ptr->max_pkt_target) &&
1938  link_working_working(l_ptr) &&
1939  l_ptr->fsm_msg_cnt) {
1940  msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
1941  if (l_ptr->max_pkt_probes == 10) {
1942  l_ptr->max_pkt_target = (msg_size - 4);
1943  l_ptr->max_pkt_probes = 0;
1944  msg_size = (mtu + (l_ptr->max_pkt_target - mtu)/2 + 2) & ~3;
1945  }
1946  l_ptr->max_pkt_probes++;
1947  }
1948 
1949  l_ptr->stats.sent_probes++;
1950  }
1951  l_ptr->stats.sent_states++;
1952  } else { /* RESET_MSG or ACTIVATE_MSG */
1953  msg_set_ack(msg, mod(l_ptr->reset_checkpoint - 1));
1954  msg_set_seq_gap(msg, 0);
1955  msg_set_next_sent(msg, 1);
1956  msg_set_probe(msg, 0);
1957  msg_set_link_tolerance(msg, l_ptr->tolerance);
1958  msg_set_linkprio(msg, l_ptr->priority);
1959  msg_set_max_pkt(msg, l_ptr->max_pkt_target);
1960  }
1961 
1962  r_flag = (l_ptr->owner->working_links > tipc_link_is_up(l_ptr));
1963  msg_set_redundant_link(msg, r_flag);
1964  msg_set_linkprio(msg, l_ptr->priority);
1965  msg_set_size(msg, msg_size);
1966 
1967  msg_set_seqno(msg, mod(l_ptr->next_out_no + (0xffff/2)));
1968 
1969  buf = tipc_buf_acquire(msg_size);
1970  if (!buf)
1971  return;
1972 
1973  skb_copy_to_linear_data(buf, msg, sizeof(l_ptr->proto_msg));
1974 
1975  /* Defer message if bearer is already congested */
1976  if (tipc_bearer_congested(l_ptr->b_ptr, l_ptr)) {
1977  l_ptr->proto_msg_queue = buf;
1978  return;
1979  }
1980 
1981  /* Defer message if attempting to send results in bearer congestion */
1982  if (!tipc_bearer_send(l_ptr->b_ptr, buf, &l_ptr->media_addr)) {
1983  tipc_bearer_schedule(l_ptr->b_ptr, l_ptr);
1984  l_ptr->proto_msg_queue = buf;
1985  l_ptr->stats.bearer_congs++;
1986  return;
1987  }
1988 
1989  /* Discard message if it was sent successfully */
1990  l_ptr->unacked_window = 0;
1991  kfree_skb(buf);
1992 }
1993 
1994 /*
1995  * Receive protocol message :
1996  * Note that network plane id propagates through the network, and may
1997  * change at any time. The node with lowest address rules
1998  */
1999 static void link_recv_proto_msg(struct tipc_link *l_ptr, struct sk_buff *buf)
2000 {
2001  u32 rec_gap = 0;
2002  u32 max_pkt_info;
2003  u32 max_pkt_ack;
2004  u32 msg_tol;
2005  struct tipc_msg *msg = buf_msg(buf);
2006 
2007  if (link_blocked(l_ptr))
2008  goto exit;
2009 
2010  /* record unnumbered packet arrival (force mismatch on next timeout) */
2011  l_ptr->checkpoint--;
2012 
2013  if (l_ptr->b_ptr->net_plane != msg_net_plane(msg))
2014  if (tipc_own_addr > msg_prevnode(msg))
2015  l_ptr->b_ptr->net_plane = msg_net_plane(msg);
2016 
2017  l_ptr->owner->permit_changeover = msg_redundant_link(msg);
2018 
2019  switch (msg_type(msg)) {
2020 
2021  case RESET_MSG:
2022  if (!link_working_unknown(l_ptr) &&
2023  (l_ptr->peer_session != INVALID_SESSION)) {
2024  if (less_eq(msg_session(msg), l_ptr->peer_session))
2025  break; /* duplicate or old reset: ignore */
2026  }
2027 
2028  if (!msg_redundant_link(msg) && (link_working_working(l_ptr) ||
2029  link_working_unknown(l_ptr))) {
2030  /*
2031  * peer has lost contact -- don't allow peer's links
2032  * to reactivate before we recognize loss & clean up
2033  */
2034  l_ptr->owner->block_setup = WAIT_NODE_DOWN;
2035  }
2036 
2037  link_state_event(l_ptr, RESET_MSG);
2038 
2039  /* fall thru' */
2040  case ACTIVATE_MSG:
2041  /* Update link settings according other endpoint's values */
2042  strcpy((strrchr(l_ptr->name, ':') + 1), (char *)msg_data(msg));
2043 
2044  msg_tol = msg_link_tolerance(msg);
2045  if (msg_tol > l_ptr->tolerance)
2046  link_set_supervision_props(l_ptr, msg_tol);
2047 
2048  if (msg_linkprio(msg) > l_ptr->priority)
2049  l_ptr->priority = msg_linkprio(msg);
2050 
2051  max_pkt_info = msg_max_pkt(msg);
2052  if (max_pkt_info) {
2053  if (max_pkt_info < l_ptr->max_pkt_target)
2054  l_ptr->max_pkt_target = max_pkt_info;
2055  if (l_ptr->max_pkt > l_ptr->max_pkt_target)
2056  l_ptr->max_pkt = l_ptr->max_pkt_target;
2057  } else {
2058  l_ptr->max_pkt = l_ptr->max_pkt_target;
2059  }
2060  l_ptr->owner->bclink.supportable = (max_pkt_info != 0);
2061 
2062  /* Synchronize broadcast link info, if not done previously */
2063  if (!tipc_node_is_up(l_ptr->owner)) {
2064  l_ptr->owner->bclink.last_sent =
2065  l_ptr->owner->bclink.last_in =
2066  msg_last_bcast(msg);
2067  l_ptr->owner->bclink.oos_state = 0;
2068  }
2069 
2070  l_ptr->peer_session = msg_session(msg);
2071  l_ptr->peer_bearer_id = msg_bearer_id(msg);
2072 
2073  if (msg_type(msg) == ACTIVATE_MSG)
2074  link_state_event(l_ptr, ACTIVATE_MSG);
2075  break;
2076  case STATE_MSG:
2077 
2078  msg_tol = msg_link_tolerance(msg);
2079  if (msg_tol)
2080  link_set_supervision_props(l_ptr, msg_tol);
2081 
2082  if (msg_linkprio(msg) &&
2083  (msg_linkprio(msg) != l_ptr->priority)) {
2084  pr_warn("%s<%s>, priority change %u->%u\n",
2085  link_rst_msg, l_ptr->name, l_ptr->priority,
2086  msg_linkprio(msg));
2087  l_ptr->priority = msg_linkprio(msg);
2088  tipc_link_reset(l_ptr); /* Enforce change to take effect */
2089  break;
2090  }
2091  link_state_event(l_ptr, TRAFFIC_MSG_EVT);
2092  l_ptr->stats.recv_states++;
2093  if (link_reset_unknown(l_ptr))
2094  break;
2095 
2096  if (less_eq(mod(l_ptr->next_in_no), msg_next_sent(msg))) {
2097  rec_gap = mod(msg_next_sent(msg) -
2098  mod(l_ptr->next_in_no));
2099  }
2100 
2101  max_pkt_ack = msg_max_pkt(msg);
2102  if (max_pkt_ack > l_ptr->max_pkt) {
2103  l_ptr->max_pkt = max_pkt_ack;
2104  l_ptr->max_pkt_probes = 0;
2105  }
2106 
2107  max_pkt_ack = 0;
2108  if (msg_probe(msg)) {
2109  l_ptr->stats.recv_probes++;
2110  if (msg_size(msg) > sizeof(l_ptr->proto_msg))
2111  max_pkt_ack = msg_size(msg);
2112  }
2113 
2114  /* Protocol message before retransmits, reduce loss risk */
2115  if (l_ptr->owner->bclink.supported)
2117  msg_last_bcast(msg));
2118 
2119  if (rec_gap || (msg_probe(msg))) {
2121  0, rec_gap, 0, 0, max_pkt_ack);
2122  }
2123  if (msg_seq_gap(msg)) {
2124  l_ptr->stats.recv_nacks++;
2125  tipc_link_retransmit(l_ptr, l_ptr->first_out,
2126  msg_seq_gap(msg));
2127  }
2128  break;
2129  }
2130 exit:
2131  kfree_skb(buf);
2132 }
2133 
2134 
2135 /*
2136  * tipc_link_tunnel(): Send one message via a link belonging to
2137  * another bearer. Owner node is locked.
2138  */
2139 static void tipc_link_tunnel(struct tipc_link *l_ptr,
2140  struct tipc_msg *tunnel_hdr,
2141  struct tipc_msg *msg,
2142  u32 selector)
2143 {
2144  struct tipc_link *tunnel;
2145  struct sk_buff *buf;
2146  u32 length = msg_size(msg);
2147 
2148  tunnel = l_ptr->owner->active_links[selector & 1];
2149  if (!tipc_link_is_up(tunnel)) {
2150  pr_warn("%stunnel link no longer available\n", link_co_err);
2151  return;
2152  }
2153  msg_set_size(tunnel_hdr, length + INT_H_SIZE);
2154  buf = tipc_buf_acquire(length + INT_H_SIZE);
2155  if (!buf) {
2156  pr_warn("%sunable to send tunnel msg\n", link_co_err);
2157  return;
2158  }
2159  skb_copy_to_linear_data(buf, tunnel_hdr, INT_H_SIZE);
2160  skb_copy_to_linear_data_offset(buf, INT_H_SIZE, msg, length);
2161  tipc_link_send_buf(tunnel, buf);
2162 }
2163 
2164 
2165 
2166 /*
2167  * changeover(): Send whole message queue via the remaining link
2168  * Owner node is locked.
2169  */
2170 void tipc_link_changeover(struct tipc_link *l_ptr)
2171 {
2172  u32 msgcount = l_ptr->out_queue_size;
2173  struct sk_buff *crs = l_ptr->first_out;
2174  struct tipc_link *tunnel = l_ptr->owner->active_links[0];
2175  struct tipc_msg tunnel_hdr;
2176  int split_bundles;
2177 
2178  if (!tunnel)
2179  return;
2180 
2181  if (!l_ptr->owner->permit_changeover) {
2182  pr_warn("%speer did not permit changeover\n", link_co_err);
2183  return;
2184  }
2185 
2186  tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
2187  ORIGINAL_MSG, INT_H_SIZE, l_ptr->addr);
2188  msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2189  msg_set_msgcnt(&tunnel_hdr, msgcount);
2190 
2191  if (!l_ptr->first_out) {
2192  struct sk_buff *buf;
2193 
2194  buf = tipc_buf_acquire(INT_H_SIZE);
2195  if (buf) {
2196  skb_copy_to_linear_data(buf, &tunnel_hdr, INT_H_SIZE);
2197  msg_set_size(&tunnel_hdr, INT_H_SIZE);
2198  tipc_link_send_buf(tunnel, buf);
2199  } else {
2200  pr_warn("%sunable to send changeover msg\n",
2201  link_co_err);
2202  }
2203  return;
2204  }
2205 
2206  split_bundles = (l_ptr->owner->active_links[0] !=
2207  l_ptr->owner->active_links[1]);
2208 
2209  while (crs) {
2210  struct tipc_msg *msg = buf_msg(crs);
2211 
2212  if ((msg_user(msg) == MSG_BUNDLER) && split_bundles) {
2213  struct tipc_msg *m = msg_get_wrapped(msg);
2214  unchar *pos = (unchar *)m;
2215 
2216  msgcount = msg_msgcnt(msg);
2217  while (msgcount--) {
2218  msg_set_seqno(m, msg_seqno(msg));
2219  tipc_link_tunnel(l_ptr, &tunnel_hdr, m,
2220  msg_link_selector(m));
2221  pos += align(msg_size(m));
2222  m = (struct tipc_msg *)pos;
2223  }
2224  } else {
2225  tipc_link_tunnel(l_ptr, &tunnel_hdr, msg,
2226  msg_link_selector(msg));
2227  }
2228  crs = crs->next;
2229  }
2230 }
2231 
2232 void tipc_link_send_duplicate(struct tipc_link *l_ptr, struct tipc_link *tunnel)
2233 {
2234  struct sk_buff *iter;
2235  struct tipc_msg tunnel_hdr;
2236 
2237  tipc_msg_init(&tunnel_hdr, CHANGEOVER_PROTOCOL,
2238  DUPLICATE_MSG, INT_H_SIZE, l_ptr->addr);
2239  msg_set_msgcnt(&tunnel_hdr, l_ptr->out_queue_size);
2240  msg_set_bearer_id(&tunnel_hdr, l_ptr->peer_bearer_id);
2241  iter = l_ptr->first_out;
2242  while (iter) {
2243  struct sk_buff *outbuf;
2244  struct tipc_msg *msg = buf_msg(iter);
2245  u32 length = msg_size(msg);
2246 
2247  if (msg_user(msg) == MSG_BUNDLER)
2248  msg_set_type(msg, CLOSED_MSG);
2249  msg_set_ack(msg, mod(l_ptr->next_in_no - 1)); /* Update */
2250  msg_set_bcast_ack(msg, l_ptr->owner->bclink.last_in);
2251  msg_set_size(&tunnel_hdr, length + INT_H_SIZE);
2252  outbuf = tipc_buf_acquire(length + INT_H_SIZE);
2253  if (outbuf == NULL) {
2254  pr_warn("%sunable to send duplicate msg\n",
2255  link_co_err);
2256  return;
2257  }
2258  skb_copy_to_linear_data(outbuf, &tunnel_hdr, INT_H_SIZE);
2259  skb_copy_to_linear_data_offset(outbuf, INT_H_SIZE, iter->data,
2260  length);
2261  tipc_link_send_buf(tunnel, outbuf);
2262  if (!tipc_link_is_up(l_ptr))
2263  return;
2264  iter = iter->next;
2265  }
2266 }
2267 
2276 static struct sk_buff *buf_extract(struct sk_buff *skb, u32 from_pos)
2277 {
2278  struct tipc_msg *msg = (struct tipc_msg *)(skb->data + from_pos);
2279  u32 size = msg_size(msg);
2280  struct sk_buff *eb;
2281 
2282  eb = tipc_buf_acquire(size);
2283  if (eb)
2284  skb_copy_to_linear_data(eb, msg, size);
2285  return eb;
2286 }
2287 
2288 /*
2289  * link_recv_changeover_msg(): Receive tunneled packet sent
2290  * via other link. Node is locked. Return extracted buffer.
2291  */
2292 static int link_recv_changeover_msg(struct tipc_link **l_ptr,
2293  struct sk_buff **buf)
2294 {
2295  struct sk_buff *tunnel_buf = *buf;
2296  struct tipc_link *dest_link;
2297  struct tipc_msg *msg;
2298  struct tipc_msg *tunnel_msg = buf_msg(tunnel_buf);
2299  u32 msg_typ = msg_type(tunnel_msg);
2300  u32 msg_count = msg_msgcnt(tunnel_msg);
2301 
2302  dest_link = (*l_ptr)->owner->links[msg_bearer_id(tunnel_msg)];
2303  if (!dest_link)
2304  goto exit;
2305  if (dest_link == *l_ptr) {
2306  pr_err("Unexpected changeover message on link <%s>\n",
2307  (*l_ptr)->name);
2308  goto exit;
2309  }
2310  *l_ptr = dest_link;
2311  msg = msg_get_wrapped(tunnel_msg);
2312 
2313  if (msg_typ == DUPLICATE_MSG) {
2314  if (less(msg_seqno(msg), mod(dest_link->next_in_no)))
2315  goto exit;
2316  *buf = buf_extract(tunnel_buf, INT_H_SIZE);
2317  if (*buf == NULL) {
2318  pr_warn("%sduplicate msg dropped\n", link_co_err);
2319  goto exit;
2320  }
2321  kfree_skb(tunnel_buf);
2322  return 1;
2323  }
2324 
2325  /* First original message ?: */
2326  if (tipc_link_is_up(dest_link)) {
2327  pr_info("%s<%s>, changeover initiated by peer\n", link_rst_msg,
2328  dest_link->name);
2329  tipc_link_reset(dest_link);
2330  dest_link->exp_msg_count = msg_count;
2331  if (!msg_count)
2332  goto exit;
2333  } else if (dest_link->exp_msg_count == START_CHANGEOVER) {
2334  dest_link->exp_msg_count = msg_count;
2335  if (!msg_count)
2336  goto exit;
2337  }
2338 
2339  /* Receive original message */
2340  if (dest_link->exp_msg_count == 0) {
2341  pr_warn("%sgot too many tunnelled messages\n", link_co_err);
2342  goto exit;
2343  }
2344  dest_link->exp_msg_count--;
2345  if (less(msg_seqno(msg), dest_link->reset_checkpoint)) {
2346  goto exit;
2347  } else {
2348  *buf = buf_extract(tunnel_buf, INT_H_SIZE);
2349  if (*buf != NULL) {
2350  kfree_skb(tunnel_buf);
2351  return 1;
2352  } else {
2353  pr_warn("%soriginal msg dropped\n", link_co_err);
2354  }
2355  }
2356 exit:
2357  *buf = NULL;
2358  kfree_skb(tunnel_buf);
2359  return 0;
2360 }
2361 
2362 /*
2363  * Bundler functionality:
2364  */
2366 {
2367  u32 msgcount = msg_msgcnt(buf_msg(buf));
2368  u32 pos = INT_H_SIZE;
2369  struct sk_buff *obuf;
2370 
2371  while (msgcount--) {
2372  obuf = buf_extract(buf, pos);
2373  if (obuf == NULL) {
2374  pr_warn("Link unable to unbundle message(s)\n");
2375  break;
2376  }
2377  pos += align(msg_size(buf_msg(obuf)));
2378  tipc_net_route_msg(obuf);
2379  }
2380  kfree_skb(buf);
2381 }
2382 
2383 /*
2384  * Fragmentation/defragmentation:
2385  */
2386 
2387 /*
2388  * link_send_long_buf: Entry for buffers needing fragmentation.
2389  * The buffer is complete, inclusive total message length.
2390  * Returns user data length.
2391  */
2392 static int link_send_long_buf(struct tipc_link *l_ptr, struct sk_buff *buf)
2393 {
2394  struct sk_buff *buf_chain = NULL;
2395  struct sk_buff *buf_chain_tail = (struct sk_buff *)&buf_chain;
2396  struct tipc_msg *inmsg = buf_msg(buf);
2397  struct tipc_msg fragm_hdr;
2398  u32 insize = msg_size(inmsg);
2399  u32 dsz = msg_data_sz(inmsg);
2400  unchar *crs = buf->data;
2401  u32 rest = insize;
2402  u32 pack_sz = l_ptr->max_pkt;
2403  u32 fragm_sz = pack_sz - INT_H_SIZE;
2404  u32 fragm_no = 0;
2405  u32 destaddr;
2406 
2407  if (msg_short(inmsg))
2408  destaddr = l_ptr->addr;
2409  else
2410  destaddr = msg_destnode(inmsg);
2411 
2412  /* Prepare reusable fragment header: */
2414  INT_H_SIZE, destaddr);
2415 
2416  /* Chop up message: */
2417  while (rest > 0) {
2418  struct sk_buff *fragm;
2419 
2420  if (rest <= fragm_sz) {
2421  fragm_sz = rest;
2422  msg_set_type(&fragm_hdr, LAST_FRAGMENT);
2423  }
2424  fragm = tipc_buf_acquire(fragm_sz + INT_H_SIZE);
2425  if (fragm == NULL) {
2426  kfree_skb(buf);
2427  while (buf_chain) {
2428  buf = buf_chain;
2429  buf_chain = buf_chain->next;
2430  kfree_skb(buf);
2431  }
2432  return -ENOMEM;
2433  }
2434  msg_set_size(&fragm_hdr, fragm_sz + INT_H_SIZE);
2435  fragm_no++;
2436  msg_set_fragm_no(&fragm_hdr, fragm_no);
2437  skb_copy_to_linear_data(fragm, &fragm_hdr, INT_H_SIZE);
2438  skb_copy_to_linear_data_offset(fragm, INT_H_SIZE, crs,
2439  fragm_sz);
2440  buf_chain_tail->next = fragm;
2441  buf_chain_tail = fragm;
2442 
2443  rest -= fragm_sz;
2444  crs += fragm_sz;
2445  msg_set_type(&fragm_hdr, FRAGMENT);
2446  }
2447  kfree_skb(buf);
2448 
2449  /* Append chain of fragments to send queue & send them */
2450  l_ptr->long_msg_seq_no++;
2451  link_add_chain_to_outqueue(l_ptr, buf_chain, l_ptr->long_msg_seq_no);
2452  l_ptr->stats.sent_fragments += fragm_no;
2453  l_ptr->stats.sent_fragmented++;
2454  tipc_link_push_queue(l_ptr);
2455 
2456  return dsz;
2457 }
2458 
2459 /*
2460  * A pending message being re-assembled must store certain values
2461  * to handle subsequent fragments correctly. The following functions
2462  * help storing these values in unused, available fields in the
2463  * pending message. This makes dynamic memory allocation unnecessary.
2464  */
2465 static void set_long_msg_seqno(struct sk_buff *buf, u32 seqno)
2466 {
2467  msg_set_seqno(buf_msg(buf), seqno);
2468 }
2469 
2470 static u32 get_fragm_size(struct sk_buff *buf)
2471 {
2472  return msg_ack(buf_msg(buf));
2473 }
2474 
2475 static void set_fragm_size(struct sk_buff *buf, u32 sz)
2476 {
2477  msg_set_ack(buf_msg(buf), sz);
2478 }
2479 
2480 static u32 get_expected_frags(struct sk_buff *buf)
2481 {
2482  return msg_bcast_ack(buf_msg(buf));
2483 }
2484 
2485 static void set_expected_frags(struct sk_buff *buf, u32 exp)
2486 {
2487  msg_set_bcast_ack(buf_msg(buf), exp);
2488 }
2489 
2490 static u32 get_timer_cnt(struct sk_buff *buf)
2491 {
2492  return msg_reroute_cnt(buf_msg(buf));
2493 }
2494 
2495 static void incr_timer_cnt(struct sk_buff *buf)
2496 {
2497  msg_incr_reroute_cnt(buf_msg(buf));
2498 }
2499 
2500 /*
2501  * tipc_link_recv_fragment(): Called with node lock on. Returns
2502  * the reassembled buffer if message is complete.
2503  */
2504 int tipc_link_recv_fragment(struct sk_buff **pending, struct sk_buff **fb,
2505  struct tipc_msg **m)
2506 {
2507  struct sk_buff *prev = NULL;
2508  struct sk_buff *fbuf = *fb;
2509  struct tipc_msg *fragm = buf_msg(fbuf);
2510  struct sk_buff *pbuf = *pending;
2511  u32 long_msg_seq_no = msg_long_msgno(fragm);
2512 
2513  *fb = NULL;
2514 
2515  /* Is there an incomplete message waiting for this fragment? */
2516  while (pbuf && ((buf_seqno(pbuf) != long_msg_seq_no) ||
2517  (msg_orignode(fragm) != msg_orignode(buf_msg(pbuf))))) {
2518  prev = pbuf;
2519  pbuf = pbuf->next;
2520  }
2521 
2522  if (!pbuf && (msg_type(fragm) == FIRST_FRAGMENT)) {
2523  struct tipc_msg *imsg = (struct tipc_msg *)msg_data(fragm);
2524  u32 msg_sz = msg_size(imsg);
2525  u32 fragm_sz = msg_data_sz(fragm);
2526  u32 exp_fragm_cnt = msg_sz/fragm_sz + !!(msg_sz % fragm_sz);
2528  if (msg_type(imsg) == TIPC_MCAST_MSG)
2530  if (msg_size(imsg) > max) {
2531  kfree_skb(fbuf);
2532  return 0;
2533  }
2534  pbuf = tipc_buf_acquire(msg_size(imsg));
2535  if (pbuf != NULL) {
2536  pbuf->next = *pending;
2537  *pending = pbuf;
2538  skb_copy_to_linear_data(pbuf, imsg,
2539  msg_data_sz(fragm));
2540  /* Prepare buffer for subsequent fragments. */
2541  set_long_msg_seqno(pbuf, long_msg_seq_no);
2542  set_fragm_size(pbuf, fragm_sz);
2543  set_expected_frags(pbuf, exp_fragm_cnt - 1);
2544  } else {
2545  pr_debug("Link unable to reassemble fragmented message\n");
2546  kfree_skb(fbuf);
2547  return -1;
2548  }
2549  kfree_skb(fbuf);
2550  return 0;
2551  } else if (pbuf && (msg_type(fragm) != FIRST_FRAGMENT)) {
2552  u32 dsz = msg_data_sz(fragm);
2553  u32 fsz = get_fragm_size(pbuf);
2554  u32 crs = ((msg_fragm_no(fragm) - 1) * fsz);
2555  u32 exp_frags = get_expected_frags(pbuf) - 1;
2556  skb_copy_to_linear_data_offset(pbuf, crs,
2557  msg_data(fragm), dsz);
2558  kfree_skb(fbuf);
2559 
2560  /* Is message complete? */
2561  if (exp_frags == 0) {
2562  if (prev)
2563  prev->next = pbuf->next;
2564  else
2565  *pending = pbuf->next;
2566  msg_reset_reroute_cnt(buf_msg(pbuf));
2567  *fb = pbuf;
2568  *m = buf_msg(pbuf);
2569  return 1;
2570  }
2571  set_expected_frags(pbuf, exp_frags);
2572  return 0;
2573  }
2574  kfree_skb(fbuf);
2575  return 0;
2576 }
2577 
2582 static void link_check_defragm_bufs(struct tipc_link *l_ptr)
2583 {
2584  struct sk_buff *prev = NULL;
2585  struct sk_buff *next = NULL;
2586  struct sk_buff *buf = l_ptr->defragm_buf;
2587 
2588  if (!buf)
2589  return;
2590  if (!link_working_working(l_ptr))
2591  return;
2592  while (buf) {
2593  u32 cnt = get_timer_cnt(buf);
2594 
2595  next = buf->next;
2596  if (cnt < 4) {
2597  incr_timer_cnt(buf);
2598  prev = buf;
2599  } else {
2600  if (prev)
2601  prev->next = buf->next;
2602  else
2603  l_ptr->defragm_buf = buf->next;
2604  kfree_skb(buf);
2605  }
2606  buf = next;
2607  }
2608 }
2609 
2610 static void link_set_supervision_props(struct tipc_link *l_ptr, u32 tolerance)
2611 {
2612  if ((tolerance < TIPC_MIN_LINK_TOL) || (tolerance > TIPC_MAX_LINK_TOL))
2613  return;
2614 
2615  l_ptr->tolerance = tolerance;
2616  l_ptr->continuity_interval =
2617  ((tolerance / 4) > 500) ? 500 : tolerance / 4;
2618  l_ptr->abort_limit = tolerance / (l_ptr->continuity_interval / 4);
2619 }
2620 
2622 {
2623  /* Data messages from this node, inclusive FIRST_FRAGM */
2625  l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE] = (window / 3) * 4;
2626  l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE] = (window / 3) * 5;
2627  l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE] = (window / 3) * 6;
2628  /* Transiting data messages,inclusive FIRST_FRAGM */
2629  l_ptr->queue_limit[TIPC_LOW_IMPORTANCE + 4] = 300;
2630  l_ptr->queue_limit[TIPC_MEDIUM_IMPORTANCE + 4] = 600;
2631  l_ptr->queue_limit[TIPC_HIGH_IMPORTANCE + 4] = 900;
2632  l_ptr->queue_limit[TIPC_CRITICAL_IMPORTANCE + 4] = 1200;
2633  l_ptr->queue_limit[CONN_MANAGER] = 1200;
2634  l_ptr->queue_limit[CHANGEOVER_PROTOCOL] = 2500;
2635  l_ptr->queue_limit[NAME_DISTRIBUTOR] = 3000;
2636  /* FRAGMENT and LAST_FRAGMENT packets */
2637  l_ptr->queue_limit[MSG_FRAGMENTER] = 4000;
2638 }
2639 
2650 static struct tipc_link *link_find_link(const char *name,
2651  struct tipc_node **node)
2652 {
2653  struct tipc_link_name link_name_parts;
2654  struct tipc_bearer *b_ptr;
2655  struct tipc_link *l_ptr;
2656 
2657  if (!link_name_validate(name, &link_name_parts))
2658  return NULL;
2659 
2660  b_ptr = tipc_bearer_find_interface(link_name_parts.if_local);
2661  if (!b_ptr)
2662  return NULL;
2663 
2664  *node = tipc_node_find(link_name_parts.addr_peer);
2665  if (!*node)
2666  return NULL;
2667 
2668  l_ptr = (*node)->links[b_ptr->identity];
2669  if (!l_ptr || strcmp(l_ptr->name, name))
2670  return NULL;
2671 
2672  return l_ptr;
2673 }
2674 
2683 static int link_value_is_valid(u16 cmd, u32 new_value)
2684 {
2685  switch (cmd) {
2686  case TIPC_CMD_SET_LINK_TOL:
2687  return (new_value >= TIPC_MIN_LINK_TOL) &&
2688  (new_value <= TIPC_MAX_LINK_TOL);
2689  case TIPC_CMD_SET_LINK_PRI:
2690  return (new_value <= TIPC_MAX_LINK_PRI);
2692  return (new_value >= TIPC_MIN_LINK_WIN) &&
2693  (new_value <= TIPC_MAX_LINK_WIN);
2694  }
2695  return 0;
2696 }
2697 
2708 static int link_cmd_set_value(const char *name, u32 new_value, u16 cmd)
2709 {
2710  struct tipc_node *node;
2711  struct tipc_link *l_ptr;
2712  struct tipc_bearer *b_ptr;
2713  struct tipc_media *m_ptr;
2714 
2715  l_ptr = link_find_link(name, &node);
2716  if (l_ptr) {
2717  /*
2718  * acquire node lock for tipc_link_send_proto_msg().
2719  * see "TIPC locking policy" in net.c.
2720  */
2721  tipc_node_lock(node);
2722  switch (cmd) {
2723  case TIPC_CMD_SET_LINK_TOL:
2724  link_set_supervision_props(l_ptr, new_value);
2726  STATE_MSG, 0, 0, new_value, 0, 0);
2727  break;
2728  case TIPC_CMD_SET_LINK_PRI:
2729  l_ptr->priority = new_value;
2731  STATE_MSG, 0, 0, 0, new_value, 0);
2732  break;
2734  tipc_link_set_queue_limits(l_ptr, new_value);
2735  break;
2736  }
2737  tipc_node_unlock(node);
2738  return 0;
2739  }
2740 
2741  b_ptr = tipc_bearer_find(name);
2742  if (b_ptr) {
2743  switch (cmd) {
2744  case TIPC_CMD_SET_LINK_TOL:
2745  b_ptr->tolerance = new_value;
2746  return 0;
2747  case TIPC_CMD_SET_LINK_PRI:
2748  b_ptr->priority = new_value;
2749  return 0;
2751  b_ptr->window = new_value;
2752  return 0;
2753  }
2754  return -EINVAL;
2755  }
2756 
2757  m_ptr = tipc_media_find(name);
2758  if (!m_ptr)
2759  return -ENODEV;
2760  switch (cmd) {
2761  case TIPC_CMD_SET_LINK_TOL:
2762  m_ptr->tolerance = new_value;
2763  return 0;
2764  case TIPC_CMD_SET_LINK_PRI:
2765  m_ptr->priority = new_value;
2766  return 0;
2768  m_ptr->window = new_value;
2769  return 0;
2770  }
2771  return -EINVAL;
2772 }
2773 
2774 struct sk_buff *tipc_link_cmd_config(const void *req_tlv_area, int req_tlv_space,
2775  u16 cmd)
2776 {
2777  struct tipc_link_config *args;
2778  u32 new_value;
2779  int res;
2780 
2781  if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_CONFIG))
2782  return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
2783 
2784  args = (struct tipc_link_config *)TLV_DATA(req_tlv_area);
2785  new_value = ntohl(args->value);
2786 
2787  if (!link_value_is_valid(cmd, new_value))
2788  return tipc_cfg_reply_error_string(
2789  "cannot change, value invalid");
2790 
2791  if (!strcmp(args->name, tipc_bclink_name)) {
2792  if ((cmd == TIPC_CMD_SET_LINK_WINDOW) &&
2793  (tipc_bclink_set_queue_limits(new_value) == 0))
2794  return tipc_cfg_reply_none();
2795  return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
2796  " (cannot change setting on broadcast link)");
2797  }
2798 
2800  res = link_cmd_set_value(args->name, new_value, cmd);
2802  if (res)
2803  return tipc_cfg_reply_error_string("cannot change link setting");
2804 
2805  return tipc_cfg_reply_none();
2806 }
2807 
2812 static void link_reset_statistics(struct tipc_link *l_ptr)
2813 {
2814  memset(&l_ptr->stats, 0, sizeof(l_ptr->stats));
2815  l_ptr->stats.sent_info = l_ptr->next_out_no;
2816  l_ptr->stats.recv_info = l_ptr->next_in_no;
2817 }
2818 
2819 struct sk_buff *tipc_link_cmd_reset_stats(const void *req_tlv_area, int req_tlv_space)
2820 {
2821  char *link_name;
2822  struct tipc_link *l_ptr;
2823  struct tipc_node *node;
2824 
2825  if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
2826  return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
2827 
2828  link_name = (char *)TLV_DATA(req_tlv_area);
2829  if (!strcmp(link_name, tipc_bclink_name)) {
2831  return tipc_cfg_reply_error_string("link not found");
2832  return tipc_cfg_reply_none();
2833  }
2834 
2836  l_ptr = link_find_link(link_name, &node);
2837  if (!l_ptr) {
2839  return tipc_cfg_reply_error_string("link not found");
2840  }
2841 
2842  tipc_node_lock(node);
2843  link_reset_statistics(l_ptr);
2844  tipc_node_unlock(node);
2846  return tipc_cfg_reply_none();
2847 }
2848 
2852 static u32 percent(u32 count, u32 total)
2853 {
2854  return (count * 100 + (total / 2)) / total;
2855 }
2856 
2865 static int tipc_link_stats(const char *name, char *buf, const u32 buf_size)
2866 {
2867  struct tipc_link *l;
2868  struct tipc_stats *s;
2869  struct tipc_node *node;
2870  char *status;
2871  u32 profile_total = 0;
2872  int ret;
2873 
2874  if (!strcmp(name, tipc_bclink_name))
2875  return tipc_bclink_stats(buf, buf_size);
2876 
2877  read_lock_bh(&tipc_net_lock);
2878  l = link_find_link(name, &node);
2879  if (!l) {
2880  read_unlock_bh(&tipc_net_lock);
2881  return 0;
2882  }
2883  tipc_node_lock(node);
2884  s = &l->stats;
2885 
2886  if (tipc_link_is_active(l))
2887  status = "ACTIVE";
2888  else if (tipc_link_is_up(l))
2889  status = "STANDBY";
2890  else
2891  status = "DEFUNCT";
2892 
2893  ret = tipc_snprintf(buf, buf_size, "Link <%s>\n"
2894  " %s MTU:%u Priority:%u Tolerance:%u ms"
2895  " Window:%u packets\n",
2896  l->name, status, l->max_pkt, l->priority,
2897  l->tolerance, l->queue_limit[0]);
2898 
2899  ret += tipc_snprintf(buf + ret, buf_size - ret,
2900  " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
2901  l->next_in_no - s->recv_info, s->recv_fragments,
2903  s->recv_bundled);
2904 
2905  ret += tipc_snprintf(buf + ret, buf_size - ret,
2906  " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
2907  l->next_out_no - s->sent_info, s->sent_fragments,
2909  s->sent_bundled);
2910 
2911  profile_total = s->msg_length_counts;
2912  if (!profile_total)
2913  profile_total = 1;
2914 
2915  ret += tipc_snprintf(buf + ret, buf_size - ret,
2916  " TX profile sample:%u packets average:%u octets\n"
2917  " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% "
2918  "-16384:%u%% -32768:%u%% -66000:%u%%\n",
2919  s->msg_length_counts,
2920  s->msg_lengths_total / profile_total,
2921  percent(s->msg_length_profile[0], profile_total),
2922  percent(s->msg_length_profile[1], profile_total),
2923  percent(s->msg_length_profile[2], profile_total),
2924  percent(s->msg_length_profile[3], profile_total),
2925  percent(s->msg_length_profile[4], profile_total),
2926  percent(s->msg_length_profile[5], profile_total),
2927  percent(s->msg_length_profile[6], profile_total));
2928 
2929  ret += tipc_snprintf(buf + ret, buf_size - ret,
2930  " RX states:%u probes:%u naks:%u defs:%u"
2931  " dups:%u\n", s->recv_states, s->recv_probes,
2932  s->recv_nacks, s->deferred_recv, s->duplicates);
2933 
2934  ret += tipc_snprintf(buf + ret, buf_size - ret,
2935  " TX states:%u probes:%u naks:%u acks:%u"
2936  " dups:%u\n", s->sent_states, s->sent_probes,
2937  s->sent_nacks, s->sent_acks, s->retransmitted);
2938 
2939  ret += tipc_snprintf(buf + ret, buf_size - ret,
2940  " Congestion bearer:%u link:%u Send queue"
2941  " max:%u avg:%u\n", s->bearer_congs, s->link_congs,
2942  s->max_queue_sz, s->queue_sz_counts ?
2943  (s->accu_queue_sz / s->queue_sz_counts) : 0);
2944 
2945  tipc_node_unlock(node);
2946  read_unlock_bh(&tipc_net_lock);
2947  return ret;
2948 }
2949 
2950 struct sk_buff *tipc_link_cmd_show_stats(const void *req_tlv_area, int req_tlv_space)
2951 {
2952  struct sk_buff *buf;
2953  struct tlv_desc *rep_tlv;
2954  int str_len;
2955  int pb_len;
2956  char *pb;
2957 
2958  if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_LINK_NAME))
2959  return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
2960 
2962  if (!buf)
2963  return NULL;
2964 
2965  rep_tlv = (struct tlv_desc *)buf->data;
2966  pb = TLV_DATA(rep_tlv);
2967  pb_len = ULTRA_STRING_MAX_LEN;
2968  str_len = tipc_link_stats((char *)TLV_DATA(req_tlv_area),
2969  pb, pb_len);
2970  if (!str_len) {
2971  kfree_skb(buf);
2972  return tipc_cfg_reply_error_string("link not found");
2973  }
2974  str_len += 1; /* for "\0" */
2975  skb_put(buf, TLV_SPACE(str_len));
2976  TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
2977 
2978  return buf;
2979 }
2980 
2989 {
2990  struct tipc_node *n_ptr;
2991  struct tipc_link *l_ptr;
2992  u32 res = MAX_PKT_DEFAULT;
2993 
2994  if (dest == tipc_own_addr)
2995  return MAX_MSG_SIZE;
2996 
2998  n_ptr = tipc_node_find(dest);
2999  if (n_ptr) {
3000  tipc_node_lock(n_ptr);
3001  l_ptr = n_ptr->active_links[selector & 1];
3002  if (l_ptr)
3003  res = l_ptr->max_pkt;
3004  tipc_node_unlock(n_ptr);
3005  }
3007  return res;
3008 }
3009 
3010 static void link_print(struct tipc_link *l_ptr, const char *str)
3011 {
3012  pr_info("%s Link %x<%s>:", str, l_ptr->addr, l_ptr->b_ptr->name);
3013 
3014  if (link_working_unknown(l_ptr))
3015  pr_cont(":WU\n");
3016  else if (link_reset_reset(l_ptr))
3017  pr_cont(":RR\n");
3018  else if (link_reset_unknown(l_ptr))
3019  pr_cont(":RU\n");
3020  else if (link_working_working(l_ptr))
3021  pr_cont(":WW\n");
3022  else
3023  pr_cont("\n");
3024 }