link.c 53 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000
  1. /*
  2. * net/tipc/link.c: TIPC link code
  3. *
  4. * Copyright (c) 1996-2007, 2012-2016, Ericsson AB
  5. * Copyright (c) 2004-2007, 2010-2013, Wind River Systems
  6. * All rights reserved.
  7. *
  8. * Redistribution and use in source and binary forms, with or without
  9. * modification, are permitted provided that the following conditions are met:
  10. *
  11. * 1. Redistributions of source code must retain the above copyright
  12. * notice, this list of conditions and the following disclaimer.
  13. * 2. Redistributions in binary form must reproduce the above copyright
  14. * notice, this list of conditions and the following disclaimer in the
  15. * documentation and/or other materials provided with the distribution.
  16. * 3. Neither the names of the copyright holders nor the names of its
  17. * contributors may be used to endorse or promote products derived from
  18. * this software without specific prior written permission.
  19. *
  20. * Alternatively, this software may be distributed under the terms of the
  21. * GNU General Public License ("GPL") version 2 as published by the Free
  22. * Software Foundation.
  23. *
  24. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27. * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  28. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31. * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32. * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34. * POSSIBILITY OF SUCH DAMAGE.
  35. */
  36. #include "core.h"
  37. #include "subscr.h"
  38. #include "link.h"
  39. #include "bcast.h"
  40. #include "socket.h"
  41. #include "name_distr.h"
  42. #include "discover.h"
  43. #include "netlink.h"
  44. #include <linux/pkt_sched.h>
  45. struct tipc_stats {
  46. u32 sent_info; /* used in counting # sent packets */
  47. u32 recv_info; /* used in counting # recv'd packets */
  48. u32 sent_states;
  49. u32 recv_states;
  50. u32 sent_probes;
  51. u32 recv_probes;
  52. u32 sent_nacks;
  53. u32 recv_nacks;
  54. u32 sent_acks;
  55. u32 sent_bundled;
  56. u32 sent_bundles;
  57. u32 recv_bundled;
  58. u32 recv_bundles;
  59. u32 retransmitted;
  60. u32 sent_fragmented;
  61. u32 sent_fragments;
  62. u32 recv_fragmented;
  63. u32 recv_fragments;
  64. u32 link_congs; /* # port sends blocked by congestion */
  65. u32 deferred_recv;
  66. u32 duplicates;
  67. u32 max_queue_sz; /* send queue size high water mark */
  68. u32 accu_queue_sz; /* used for send queue size profiling */
  69. u32 queue_sz_counts; /* used for send queue size profiling */
  70. u32 msg_length_counts; /* used for message length profiling */
  71. u32 msg_lengths_total; /* used for message length profiling */
  72. u32 msg_length_profile[7]; /* used for msg. length profiling */
  73. };
  74. /**
  75. * struct tipc_link - TIPC link data structure
  76. * @addr: network address of link's peer node
  77. * @name: link name character string
  78. * @media_addr: media address to use when sending messages over link
  79. * @timer: link timer
  80. * @net: pointer to namespace struct
  81. * @refcnt: reference counter for permanent references (owner node & timer)
  82. * @peer_session: link session # being used by peer end of link
  83. * @peer_bearer_id: bearer id used by link's peer endpoint
  84. * @bearer_id: local bearer id used by link
  85. * @tolerance: minimum link continuity loss needed to reset link [in ms]
  86. * @keepalive_intv: link keepalive timer interval
  87. * @abort_limit: # of unacknowledged continuity probes needed to reset link
  88. * @state: current state of link FSM
  89. * @peer_caps: bitmap describing capabilities of peer node
  90. * @silent_intv_cnt: # of timer intervals without any reception from peer
  91. * @proto_msg: template for control messages generated by link
  92. * @pmsg: convenience pointer to "proto_msg" field
  93. * @priority: current link priority
  94. * @net_plane: current link network plane ('A' through 'H')
  95. * @backlog_limit: backlog queue congestion thresholds (indexed by importance)
  96. * @exp_msg_count: # of tunnelled messages expected during link changeover
  97. * @reset_rcv_checkpt: seq # of last acknowledged message at time of link reset
  98. * @mtu: current maximum packet size for this link
  99. * @advertised_mtu: advertised own mtu when link is being established
  100. * @transmitq: queue for sent, non-acked messages
  101. * @backlogq: queue for messages waiting to be sent
  102. * @snt_nxt: next sequence number to use for outbound messages
  103. * @last_retransmitted: sequence number of most recently retransmitted message
  104. * @stale_count: # of identical retransmit requests made by peer
  105. * @ackers: # of peers that needs to ack each packet before it can be released
  106. * @acked: # last packet acked by a certain peer. Used for broadcast.
  107. * @rcv_nxt: next sequence number to expect for inbound messages
  108. * @deferred_queue: deferred queue saved OOS b'cast message received from node
  109. * @unacked_window: # of inbound messages rx'd without ack'ing back to peer
  110. * @inputq: buffer queue for messages to be delivered upwards
  111. * @namedq: buffer queue for name table messages to be delivered upwards
  112. * @next_out: ptr to first unsent outbound message in queue
  113. * @wakeupq: linked list of wakeup msgs waiting for link congestion to abate
  114. * @long_msg_seq_no: next identifier to use for outbound fragmented messages
  115. * @reasm_buf: head of partially reassembled inbound message fragments
  116. * @bc_rcvr: marks that this is a broadcast receiver link
  117. * @stats: collects statistics regarding link activity
  118. */
  119. struct tipc_link {
  120. u32 addr;
  121. char name[TIPC_MAX_LINK_NAME];
  122. struct net *net;
  123. /* Management and link supervision data */
  124. u32 peer_session;
  125. u32 session;
  126. u32 peer_bearer_id;
  127. u32 bearer_id;
  128. u32 tolerance;
  129. unsigned long keepalive_intv;
  130. u32 abort_limit;
  131. u32 state;
  132. u16 peer_caps;
  133. bool active;
  134. u32 silent_intv_cnt;
  135. char if_name[TIPC_MAX_IF_NAME];
  136. u32 priority;
  137. char net_plane;
  138. /* Failover/synch */
  139. u16 drop_point;
  140. struct sk_buff *failover_reasm_skb;
  141. /* Max packet negotiation */
  142. u16 mtu;
  143. u16 advertised_mtu;
  144. /* Sending */
  145. struct sk_buff_head transmq;
  146. struct sk_buff_head backlogq;
  147. struct {
  148. u16 len;
  149. u16 limit;
  150. } backlog[5];
  151. u16 snd_nxt;
  152. u16 last_retransm;
  153. u16 window;
  154. u32 stale_count;
  155. /* Reception */
  156. u16 rcv_nxt;
  157. u32 rcv_unacked;
  158. struct sk_buff_head deferdq;
  159. struct sk_buff_head *inputq;
  160. struct sk_buff_head *namedq;
  161. /* Congestion handling */
  162. struct sk_buff_head wakeupq;
  163. /* Fragmentation/reassembly */
  164. struct sk_buff *reasm_buf;
  165. /* Broadcast */
  166. u16 ackers;
  167. u16 acked;
  168. struct tipc_link *bc_rcvlink;
  169. struct tipc_link *bc_sndlink;
  170. int nack_state;
  171. bool bc_peer_is_up;
  172. /* Statistics */
  173. struct tipc_stats stats;
  174. };
  175. /*
  176. * Error message prefixes
  177. */
  178. static const char *link_co_err = "Link tunneling error, ";
  179. static const char *link_rst_msg = "Resetting link ";
  180. /* Send states for broadcast NACKs
  181. */
  182. enum {
  183. BC_NACK_SND_CONDITIONAL,
  184. BC_NACK_SND_UNCONDITIONAL,
  185. BC_NACK_SND_SUPPRESS,
  186. };
  187. /*
  188. * Interval between NACKs when packets arrive out of order
  189. */
  190. #define TIPC_NACK_INTV (TIPC_MIN_LINK_WIN * 2)
  191. /* Wildcard value for link session numbers. When it is known that
  192. * peer endpoint is down, any session number must be accepted.
  193. */
  194. #define ANY_SESSION 0x10000
  195. /* Link FSM states:
  196. */
  197. enum {
  198. LINK_ESTABLISHED = 0xe,
  199. LINK_ESTABLISHING = 0xe << 4,
  200. LINK_RESET = 0x1 << 8,
  201. LINK_RESETTING = 0x2 << 12,
  202. LINK_PEER_RESET = 0xd << 16,
  203. LINK_FAILINGOVER = 0xf << 20,
  204. LINK_SYNCHING = 0xc << 24
  205. };
  206. /* Link FSM state checking routines
  207. */
  208. static int link_is_up(struct tipc_link *l)
  209. {
  210. return l->state & (LINK_ESTABLISHED | LINK_SYNCHING);
  211. }
  212. static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
  213. struct sk_buff_head *xmitq);
  214. static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
  215. u16 rcvgap, int tolerance, int priority,
  216. struct sk_buff_head *xmitq);
  217. static void link_print(struct tipc_link *l, const char *str);
  218. static void tipc_link_build_nack_msg(struct tipc_link *l,
  219. struct sk_buff_head *xmitq);
  220. static void tipc_link_build_bc_init_msg(struct tipc_link *l,
  221. struct sk_buff_head *xmitq);
  222. static bool tipc_link_release_pkts(struct tipc_link *l, u16 to);
  223. /*
  224. * Simple non-static link routines (i.e. referenced outside this file)
  225. */
  226. bool tipc_link_is_up(struct tipc_link *l)
  227. {
  228. return link_is_up(l);
  229. }
  230. bool tipc_link_peer_is_down(struct tipc_link *l)
  231. {
  232. return l->state == LINK_PEER_RESET;
  233. }
  234. bool tipc_link_is_reset(struct tipc_link *l)
  235. {
  236. return l->state & (LINK_RESET | LINK_FAILINGOVER | LINK_ESTABLISHING);
  237. }
  238. bool tipc_link_is_establishing(struct tipc_link *l)
  239. {
  240. return l->state == LINK_ESTABLISHING;
  241. }
  242. bool tipc_link_is_synching(struct tipc_link *l)
  243. {
  244. return l->state == LINK_SYNCHING;
  245. }
  246. bool tipc_link_is_failingover(struct tipc_link *l)
  247. {
  248. return l->state == LINK_FAILINGOVER;
  249. }
  250. bool tipc_link_is_blocked(struct tipc_link *l)
  251. {
  252. return l->state & (LINK_RESETTING | LINK_PEER_RESET | LINK_FAILINGOVER);
  253. }
  254. static bool link_is_bc_sndlink(struct tipc_link *l)
  255. {
  256. return !l->bc_sndlink;
  257. }
  258. static bool link_is_bc_rcvlink(struct tipc_link *l)
  259. {
  260. return ((l->bc_rcvlink == l) && !link_is_bc_sndlink(l));
  261. }
  262. int tipc_link_is_active(struct tipc_link *l)
  263. {
  264. return l->active;
  265. }
  266. void tipc_link_set_active(struct tipc_link *l, bool active)
  267. {
  268. l->active = active;
  269. }
  270. u32 tipc_link_id(struct tipc_link *l)
  271. {
  272. return l->peer_bearer_id << 16 | l->bearer_id;
  273. }
  274. int tipc_link_window(struct tipc_link *l)
  275. {
  276. return l->window;
  277. }
  278. int tipc_link_prio(struct tipc_link *l)
  279. {
  280. return l->priority;
  281. }
  282. unsigned long tipc_link_tolerance(struct tipc_link *l)
  283. {
  284. return l->tolerance;
  285. }
  286. struct sk_buff_head *tipc_link_inputq(struct tipc_link *l)
  287. {
  288. return l->inputq;
  289. }
  290. char tipc_link_plane(struct tipc_link *l)
  291. {
  292. return l->net_plane;
  293. }
  294. void tipc_link_add_bc_peer(struct tipc_link *snd_l,
  295. struct tipc_link *uc_l,
  296. struct sk_buff_head *xmitq)
  297. {
  298. struct tipc_link *rcv_l = uc_l->bc_rcvlink;
  299. snd_l->ackers++;
  300. rcv_l->acked = snd_l->snd_nxt - 1;
  301. snd_l->state = LINK_ESTABLISHED;
  302. tipc_link_build_bc_init_msg(uc_l, xmitq);
  303. }
  304. void tipc_link_remove_bc_peer(struct tipc_link *snd_l,
  305. struct tipc_link *rcv_l,
  306. struct sk_buff_head *xmitq)
  307. {
  308. u16 ack = snd_l->snd_nxt - 1;
  309. snd_l->ackers--;
  310. tipc_link_bc_ack_rcv(rcv_l, ack, xmitq);
  311. tipc_link_reset(rcv_l);
  312. rcv_l->state = LINK_RESET;
  313. if (!snd_l->ackers) {
  314. tipc_link_reset(snd_l);
  315. snd_l->state = LINK_RESET;
  316. __skb_queue_purge(xmitq);
  317. }
  318. }
  319. int tipc_link_bc_peers(struct tipc_link *l)
  320. {
  321. return l->ackers;
  322. }
  323. void tipc_link_set_mtu(struct tipc_link *l, int mtu)
  324. {
  325. l->mtu = mtu;
  326. }
  327. int tipc_link_mtu(struct tipc_link *l)
  328. {
  329. return l->mtu;
  330. }
  331. u16 tipc_link_rcv_nxt(struct tipc_link *l)
  332. {
  333. return l->rcv_nxt;
  334. }
  335. u16 tipc_link_acked(struct tipc_link *l)
  336. {
  337. return l->acked;
  338. }
  339. char *tipc_link_name(struct tipc_link *l)
  340. {
  341. return l->name;
  342. }
  343. /**
  344. * tipc_link_create - create a new link
  345. * @n: pointer to associated node
  346. * @if_name: associated interface name
  347. * @bearer_id: id (index) of associated bearer
  348. * @tolerance: link tolerance to be used by link
  349. * @net_plane: network plane (A,B,c..) this link belongs to
  350. * @mtu: mtu to be advertised by link
  351. * @priority: priority to be used by link
  352. * @window: send window to be used by link
  353. * @session: session to be used by link
  354. * @ownnode: identity of own node
  355. * @peer: node id of peer node
  356. * @peer_caps: bitmap describing peer node capabilities
  357. * @bc_sndlink: the namespace global link used for broadcast sending
  358. * @bc_rcvlink: the peer specific link used for broadcast reception
  359. * @inputq: queue to put messages ready for delivery
  360. * @namedq: queue to put binding table update messages ready for delivery
  361. * @link: return value, pointer to put the created link
  362. *
  363. * Returns true if link was created, otherwise false
  364. */
  365. bool tipc_link_create(struct net *net, char *if_name, int bearer_id,
  366. int tolerance, char net_plane, u32 mtu, int priority,
  367. int window, u32 session, u32 ownnode, u32 peer,
  368. u16 peer_caps,
  369. struct tipc_link *bc_sndlink,
  370. struct tipc_link *bc_rcvlink,
  371. struct sk_buff_head *inputq,
  372. struct sk_buff_head *namedq,
  373. struct tipc_link **link)
  374. {
  375. struct tipc_link *l;
  376. l = kzalloc(sizeof(*l), GFP_ATOMIC);
  377. if (!l)
  378. return false;
  379. *link = l;
  380. l->session = session;
  381. /* Note: peer i/f name is completed by reset/activate message */
  382. sprintf(l->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
  383. tipc_zone(ownnode), tipc_cluster(ownnode), tipc_node(ownnode),
  384. if_name, tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
  385. strcpy(l->if_name, if_name);
  386. l->addr = peer;
  387. l->peer_caps = peer_caps;
  388. l->net = net;
  389. l->peer_session = ANY_SESSION;
  390. l->bearer_id = bearer_id;
  391. l->tolerance = tolerance;
  392. l->net_plane = net_plane;
  393. l->advertised_mtu = mtu;
  394. l->mtu = mtu;
  395. l->priority = priority;
  396. tipc_link_set_queue_limits(l, window);
  397. l->ackers = 1;
  398. l->bc_sndlink = bc_sndlink;
  399. l->bc_rcvlink = bc_rcvlink;
  400. l->inputq = inputq;
  401. l->namedq = namedq;
  402. l->state = LINK_RESETTING;
  403. __skb_queue_head_init(&l->transmq);
  404. __skb_queue_head_init(&l->backlogq);
  405. __skb_queue_head_init(&l->deferdq);
  406. skb_queue_head_init(&l->wakeupq);
  407. skb_queue_head_init(l->inputq);
  408. return true;
  409. }
  410. /**
  411. * tipc_link_bc_create - create new link to be used for broadcast
  412. * @n: pointer to associated node
  413. * @mtu: mtu to be used
  414. * @window: send window to be used
  415. * @inputq: queue to put messages ready for delivery
  416. * @namedq: queue to put binding table update messages ready for delivery
  417. * @link: return value, pointer to put the created link
  418. *
  419. * Returns true if link was created, otherwise false
  420. */
  421. bool tipc_link_bc_create(struct net *net, u32 ownnode, u32 peer,
  422. int mtu, int window, u16 peer_caps,
  423. struct sk_buff_head *inputq,
  424. struct sk_buff_head *namedq,
  425. struct tipc_link *bc_sndlink,
  426. struct tipc_link **link)
  427. {
  428. struct tipc_link *l;
  429. if (!tipc_link_create(net, "", MAX_BEARERS, 0, 'Z', mtu, 0, window,
  430. 0, ownnode, peer, peer_caps, bc_sndlink,
  431. NULL, inputq, namedq, link))
  432. return false;
  433. l = *link;
  434. strcpy(l->name, tipc_bclink_name);
  435. tipc_link_reset(l);
  436. l->state = LINK_RESET;
  437. l->ackers = 0;
  438. l->bc_rcvlink = l;
  439. /* Broadcast send link is always up */
  440. if (link_is_bc_sndlink(l))
  441. l->state = LINK_ESTABLISHED;
  442. return true;
  443. }
  444. /**
  445. * tipc_link_fsm_evt - link finite state machine
  446. * @l: pointer to link
  447. * @evt: state machine event to be processed
  448. */
  449. int tipc_link_fsm_evt(struct tipc_link *l, int evt)
  450. {
  451. int rc = 0;
  452. switch (l->state) {
  453. case LINK_RESETTING:
  454. switch (evt) {
  455. case LINK_PEER_RESET_EVT:
  456. l->state = LINK_PEER_RESET;
  457. break;
  458. case LINK_RESET_EVT:
  459. l->state = LINK_RESET;
  460. break;
  461. case LINK_FAILURE_EVT:
  462. case LINK_FAILOVER_BEGIN_EVT:
  463. case LINK_ESTABLISH_EVT:
  464. case LINK_FAILOVER_END_EVT:
  465. case LINK_SYNCH_BEGIN_EVT:
  466. case LINK_SYNCH_END_EVT:
  467. default:
  468. goto illegal_evt;
  469. }
  470. break;
  471. case LINK_RESET:
  472. switch (evt) {
  473. case LINK_PEER_RESET_EVT:
  474. l->state = LINK_ESTABLISHING;
  475. break;
  476. case LINK_FAILOVER_BEGIN_EVT:
  477. l->state = LINK_FAILINGOVER;
  478. case LINK_FAILURE_EVT:
  479. case LINK_RESET_EVT:
  480. case LINK_ESTABLISH_EVT:
  481. case LINK_FAILOVER_END_EVT:
  482. break;
  483. case LINK_SYNCH_BEGIN_EVT:
  484. case LINK_SYNCH_END_EVT:
  485. default:
  486. goto illegal_evt;
  487. }
  488. break;
  489. case LINK_PEER_RESET:
  490. switch (evt) {
  491. case LINK_RESET_EVT:
  492. l->state = LINK_ESTABLISHING;
  493. break;
  494. case LINK_PEER_RESET_EVT:
  495. case LINK_ESTABLISH_EVT:
  496. case LINK_FAILURE_EVT:
  497. break;
  498. case LINK_SYNCH_BEGIN_EVT:
  499. case LINK_SYNCH_END_EVT:
  500. case LINK_FAILOVER_BEGIN_EVT:
  501. case LINK_FAILOVER_END_EVT:
  502. default:
  503. goto illegal_evt;
  504. }
  505. break;
  506. case LINK_FAILINGOVER:
  507. switch (evt) {
  508. case LINK_FAILOVER_END_EVT:
  509. l->state = LINK_RESET;
  510. break;
  511. case LINK_PEER_RESET_EVT:
  512. case LINK_RESET_EVT:
  513. case LINK_ESTABLISH_EVT:
  514. case LINK_FAILURE_EVT:
  515. break;
  516. case LINK_FAILOVER_BEGIN_EVT:
  517. case LINK_SYNCH_BEGIN_EVT:
  518. case LINK_SYNCH_END_EVT:
  519. default:
  520. goto illegal_evt;
  521. }
  522. break;
  523. case LINK_ESTABLISHING:
  524. switch (evt) {
  525. case LINK_ESTABLISH_EVT:
  526. l->state = LINK_ESTABLISHED;
  527. break;
  528. case LINK_FAILOVER_BEGIN_EVT:
  529. l->state = LINK_FAILINGOVER;
  530. break;
  531. case LINK_RESET_EVT:
  532. l->state = LINK_RESET;
  533. break;
  534. case LINK_FAILURE_EVT:
  535. case LINK_PEER_RESET_EVT:
  536. case LINK_SYNCH_BEGIN_EVT:
  537. case LINK_FAILOVER_END_EVT:
  538. break;
  539. case LINK_SYNCH_END_EVT:
  540. default:
  541. goto illegal_evt;
  542. }
  543. break;
  544. case LINK_ESTABLISHED:
  545. switch (evt) {
  546. case LINK_PEER_RESET_EVT:
  547. l->state = LINK_PEER_RESET;
  548. rc |= TIPC_LINK_DOWN_EVT;
  549. break;
  550. case LINK_FAILURE_EVT:
  551. l->state = LINK_RESETTING;
  552. rc |= TIPC_LINK_DOWN_EVT;
  553. break;
  554. case LINK_RESET_EVT:
  555. l->state = LINK_RESET;
  556. break;
  557. case LINK_ESTABLISH_EVT:
  558. case LINK_SYNCH_END_EVT:
  559. break;
  560. case LINK_SYNCH_BEGIN_EVT:
  561. l->state = LINK_SYNCHING;
  562. break;
  563. case LINK_FAILOVER_BEGIN_EVT:
  564. case LINK_FAILOVER_END_EVT:
  565. default:
  566. goto illegal_evt;
  567. }
  568. break;
  569. case LINK_SYNCHING:
  570. switch (evt) {
  571. case LINK_PEER_RESET_EVT:
  572. l->state = LINK_PEER_RESET;
  573. rc |= TIPC_LINK_DOWN_EVT;
  574. break;
  575. case LINK_FAILURE_EVT:
  576. l->state = LINK_RESETTING;
  577. rc |= TIPC_LINK_DOWN_EVT;
  578. break;
  579. case LINK_RESET_EVT:
  580. l->state = LINK_RESET;
  581. break;
  582. case LINK_ESTABLISH_EVT:
  583. case LINK_SYNCH_BEGIN_EVT:
  584. break;
  585. case LINK_SYNCH_END_EVT:
  586. l->state = LINK_ESTABLISHED;
  587. break;
  588. case LINK_FAILOVER_BEGIN_EVT:
  589. case LINK_FAILOVER_END_EVT:
  590. default:
  591. goto illegal_evt;
  592. }
  593. break;
  594. default:
  595. pr_err("Unknown FSM state %x in %s\n", l->state, l->name);
  596. }
  597. return rc;
  598. illegal_evt:
  599. pr_err("Illegal FSM event %x in state %x on link %s\n",
  600. evt, l->state, l->name);
  601. return rc;
  602. }
  603. /* link_profile_stats - update statistical profiling of traffic
  604. */
  605. static void link_profile_stats(struct tipc_link *l)
  606. {
  607. struct sk_buff *skb;
  608. struct tipc_msg *msg;
  609. int length;
  610. /* Update counters used in statistical profiling of send traffic */
  611. l->stats.accu_queue_sz += skb_queue_len(&l->transmq);
  612. l->stats.queue_sz_counts++;
  613. skb = skb_peek(&l->transmq);
  614. if (!skb)
  615. return;
  616. msg = buf_msg(skb);
  617. length = msg_size(msg);
  618. if (msg_user(msg) == MSG_FRAGMENTER) {
  619. if (msg_type(msg) != FIRST_FRAGMENT)
  620. return;
  621. length = msg_size(msg_get_wrapped(msg));
  622. }
  623. l->stats.msg_lengths_total += length;
  624. l->stats.msg_length_counts++;
  625. if (length <= 64)
  626. l->stats.msg_length_profile[0]++;
  627. else if (length <= 256)
  628. l->stats.msg_length_profile[1]++;
  629. else if (length <= 1024)
  630. l->stats.msg_length_profile[2]++;
  631. else if (length <= 4096)
  632. l->stats.msg_length_profile[3]++;
  633. else if (length <= 16384)
  634. l->stats.msg_length_profile[4]++;
  635. else if (length <= 32768)
  636. l->stats.msg_length_profile[5]++;
  637. else
  638. l->stats.msg_length_profile[6]++;
  639. }
  640. /* tipc_link_timeout - perform periodic task as instructed from node timeout
  641. */
  642. /* tipc_link_timeout - perform periodic task as instructed from node timeout
  643. */
  644. int tipc_link_timeout(struct tipc_link *l, struct sk_buff_head *xmitq)
  645. {
  646. int rc = 0;
  647. int mtyp = STATE_MSG;
  648. bool xmit = false;
  649. bool prb = false;
  650. u16 bc_snt = l->bc_sndlink->snd_nxt - 1;
  651. u16 bc_acked = l->bc_rcvlink->acked;
  652. bool bc_up = link_is_up(l->bc_rcvlink);
  653. link_profile_stats(l);
  654. switch (l->state) {
  655. case LINK_ESTABLISHED:
  656. case LINK_SYNCHING:
  657. if (!l->silent_intv_cnt) {
  658. if (bc_up && (bc_acked != bc_snt))
  659. xmit = true;
  660. } else if (l->silent_intv_cnt <= l->abort_limit) {
  661. xmit = true;
  662. prb = true;
  663. } else {
  664. rc |= tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
  665. }
  666. l->silent_intv_cnt++;
  667. break;
  668. case LINK_RESET:
  669. xmit = true;
  670. mtyp = RESET_MSG;
  671. break;
  672. case LINK_ESTABLISHING:
  673. xmit = true;
  674. mtyp = ACTIVATE_MSG;
  675. break;
  676. case LINK_PEER_RESET:
  677. case LINK_RESETTING:
  678. case LINK_FAILINGOVER:
  679. break;
  680. default:
  681. break;
  682. }
  683. if (xmit)
  684. tipc_link_build_proto_msg(l, mtyp, prb, 0, 0, 0, xmitq);
  685. return rc;
  686. }
  687. /**
  688. * link_schedule_user - schedule a message sender for wakeup after congestion
  689. * @link: congested link
  690. * @list: message that was attempted sent
  691. * Create pseudo msg to send back to user when congestion abates
  692. * Does not consume buffer list
  693. */
  694. static int link_schedule_user(struct tipc_link *link, struct sk_buff_head *list)
  695. {
  696. struct tipc_msg *msg = buf_msg(skb_peek(list));
  697. int imp = msg_importance(msg);
  698. u32 oport = msg_origport(msg);
  699. u32 addr = tipc_own_addr(link->net);
  700. struct sk_buff *skb;
  701. /* This really cannot happen... */
  702. if (unlikely(imp > TIPC_CRITICAL_IMPORTANCE)) {
  703. pr_warn("%s<%s>, send queue full", link_rst_msg, link->name);
  704. return -ENOBUFS;
  705. }
  706. /* Non-blocking sender: */
  707. if (TIPC_SKB_CB(skb_peek(list))->wakeup_pending)
  708. return -ELINKCONG;
  709. /* Create and schedule wakeup pseudo message */
  710. skb = tipc_msg_create(SOCK_WAKEUP, 0, INT_H_SIZE, 0,
  711. addr, addr, oport, 0, 0);
  712. if (!skb)
  713. return -ENOBUFS;
  714. TIPC_SKB_CB(skb)->chain_sz = skb_queue_len(list);
  715. TIPC_SKB_CB(skb)->chain_imp = imp;
  716. skb_queue_tail(&link->wakeupq, skb);
  717. link->stats.link_congs++;
  718. return -ELINKCONG;
  719. }
  720. /**
  721. * link_prepare_wakeup - prepare users for wakeup after congestion
  722. * @link: congested link
  723. * Move a number of waiting users, as permitted by available space in
  724. * the send queue, from link wait queue to node wait queue for wakeup
  725. */
  726. void link_prepare_wakeup(struct tipc_link *l)
  727. {
  728. int pnd[TIPC_SYSTEM_IMPORTANCE + 1] = {0,};
  729. int imp, lim;
  730. struct sk_buff *skb, *tmp;
  731. skb_queue_walk_safe(&l->wakeupq, skb, tmp) {
  732. imp = TIPC_SKB_CB(skb)->chain_imp;
  733. lim = l->window + l->backlog[imp].limit;
  734. pnd[imp] += TIPC_SKB_CB(skb)->chain_sz;
  735. if ((pnd[imp] + l->backlog[imp].len) >= lim)
  736. break;
  737. skb_unlink(skb, &l->wakeupq);
  738. skb_queue_tail(l->inputq, skb);
  739. }
  740. }
  741. void tipc_link_reset(struct tipc_link *l)
  742. {
  743. l->peer_session = ANY_SESSION;
  744. l->session++;
  745. l->mtu = l->advertised_mtu;
  746. __skb_queue_purge(&l->transmq);
  747. __skb_queue_purge(&l->deferdq);
  748. skb_queue_splice_init(&l->wakeupq, l->inputq);
  749. __skb_queue_purge(&l->backlogq);
  750. l->backlog[TIPC_LOW_IMPORTANCE].len = 0;
  751. l->backlog[TIPC_MEDIUM_IMPORTANCE].len = 0;
  752. l->backlog[TIPC_HIGH_IMPORTANCE].len = 0;
  753. l->backlog[TIPC_CRITICAL_IMPORTANCE].len = 0;
  754. l->backlog[TIPC_SYSTEM_IMPORTANCE].len = 0;
  755. kfree_skb(l->reasm_buf);
  756. kfree_skb(l->failover_reasm_skb);
  757. l->reasm_buf = NULL;
  758. l->failover_reasm_skb = NULL;
  759. l->rcv_unacked = 0;
  760. l->snd_nxt = 1;
  761. l->rcv_nxt = 1;
  762. l->acked = 0;
  763. l->silent_intv_cnt = 0;
  764. l->stats.recv_info = 0;
  765. l->stale_count = 0;
  766. l->bc_peer_is_up = false;
  767. tipc_link_reset_stats(l);
  768. }
  769. /**
  770. * tipc_link_xmit(): enqueue buffer list according to queue situation
  771. * @link: link to use
  772. * @list: chain of buffers containing message
  773. * @xmitq: returned list of packets to be sent by caller
  774. *
  775. * Consumes the buffer chain, except when returning -ELINKCONG,
  776. * since the caller then may want to make more send attempts.
  777. * Returns 0 if success, or errno: -ELINKCONG, -EMSGSIZE or -ENOBUFS
  778. * Messages at TIPC_SYSTEM_IMPORTANCE are always accepted
  779. */
  780. int tipc_link_xmit(struct tipc_link *l, struct sk_buff_head *list,
  781. struct sk_buff_head *xmitq)
  782. {
  783. struct tipc_msg *hdr = buf_msg(skb_peek(list));
  784. unsigned int maxwin = l->window;
  785. unsigned int i, imp = msg_importance(hdr);
  786. unsigned int mtu = l->mtu;
  787. u16 ack = l->rcv_nxt - 1;
  788. u16 seqno = l->snd_nxt;
  789. u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
  790. struct sk_buff_head *transmq = &l->transmq;
  791. struct sk_buff_head *backlogq = &l->backlogq;
  792. struct sk_buff *skb, *_skb, *bskb;
  793. /* Match msg importance against this and all higher backlog limits: */
  794. for (i = imp; i <= TIPC_SYSTEM_IMPORTANCE; i++) {
  795. if (unlikely(l->backlog[i].len >= l->backlog[i].limit))
  796. return link_schedule_user(l, list);
  797. }
  798. if (unlikely(msg_size(hdr) > mtu)) {
  799. skb_queue_purge(list);
  800. return -EMSGSIZE;
  801. }
  802. /* Prepare each packet for sending, and add to relevant queue: */
  803. while (skb_queue_len(list)) {
  804. skb = skb_peek(list);
  805. hdr = buf_msg(skb);
  806. msg_set_seqno(hdr, seqno);
  807. msg_set_ack(hdr, ack);
  808. msg_set_bcast_ack(hdr, bc_ack);
  809. if (likely(skb_queue_len(transmq) < maxwin)) {
  810. _skb = skb_clone(skb, GFP_ATOMIC);
  811. if (!_skb) {
  812. skb_queue_purge(list);
  813. return -ENOBUFS;
  814. }
  815. __skb_dequeue(list);
  816. __skb_queue_tail(transmq, skb);
  817. __skb_queue_tail(xmitq, _skb);
  818. TIPC_SKB_CB(skb)->ackers = l->ackers;
  819. l->rcv_unacked = 0;
  820. seqno++;
  821. continue;
  822. }
  823. if (tipc_msg_bundle(skb_peek_tail(backlogq), hdr, mtu)) {
  824. kfree_skb(__skb_dequeue(list));
  825. l->stats.sent_bundled++;
  826. continue;
  827. }
  828. if (tipc_msg_make_bundle(&bskb, hdr, mtu, l->addr)) {
  829. kfree_skb(__skb_dequeue(list));
  830. __skb_queue_tail(backlogq, bskb);
  831. l->backlog[msg_importance(buf_msg(bskb))].len++;
  832. l->stats.sent_bundled++;
  833. l->stats.sent_bundles++;
  834. continue;
  835. }
  836. l->backlog[imp].len += skb_queue_len(list);
  837. skb_queue_splice_tail_init(list, backlogq);
  838. }
  839. l->snd_nxt = seqno;
  840. return 0;
  841. }
  842. void tipc_link_advance_backlog(struct tipc_link *l, struct sk_buff_head *xmitq)
  843. {
  844. struct sk_buff *skb, *_skb;
  845. struct tipc_msg *hdr;
  846. u16 seqno = l->snd_nxt;
  847. u16 ack = l->rcv_nxt - 1;
  848. u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
  849. while (skb_queue_len(&l->transmq) < l->window) {
  850. skb = skb_peek(&l->backlogq);
  851. if (!skb)
  852. break;
  853. _skb = skb_clone(skb, GFP_ATOMIC);
  854. if (!_skb)
  855. break;
  856. __skb_dequeue(&l->backlogq);
  857. hdr = buf_msg(skb);
  858. l->backlog[msg_importance(hdr)].len--;
  859. __skb_queue_tail(&l->transmq, skb);
  860. __skb_queue_tail(xmitq, _skb);
  861. TIPC_SKB_CB(skb)->ackers = l->ackers;
  862. msg_set_seqno(hdr, seqno);
  863. msg_set_ack(hdr, ack);
  864. msg_set_bcast_ack(hdr, bc_ack);
  865. l->rcv_unacked = 0;
  866. seqno++;
  867. }
  868. l->snd_nxt = seqno;
  869. }
  870. static void link_retransmit_failure(struct tipc_link *l, struct sk_buff *skb)
  871. {
  872. struct tipc_msg *hdr = buf_msg(skb);
  873. pr_warn("Retransmission failure on link <%s>\n", l->name);
  874. link_print(l, "Resetting link ");
  875. pr_info("Failed msg: usr %u, typ %u, len %u, err %u\n",
  876. msg_user(hdr), msg_type(hdr), msg_size(hdr), msg_errcode(hdr));
  877. pr_info("sqno %u, prev: %x, src: %x\n",
  878. msg_seqno(hdr), msg_prevnode(hdr), msg_orignode(hdr));
  879. }
  880. int tipc_link_retrans(struct tipc_link *l, u16 from, u16 to,
  881. struct sk_buff_head *xmitq)
  882. {
  883. struct sk_buff *_skb, *skb = skb_peek(&l->transmq);
  884. struct tipc_msg *hdr;
  885. u16 ack = l->rcv_nxt - 1;
  886. u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
  887. if (!skb)
  888. return 0;
  889. /* Detect repeated retransmit failures on same packet */
  890. if (likely(l->last_retransm != buf_seqno(skb))) {
  891. l->last_retransm = buf_seqno(skb);
  892. l->stale_count = 1;
  893. } else if (++l->stale_count > 100) {
  894. link_retransmit_failure(l, skb);
  895. return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
  896. }
  897. /* Move forward to where retransmission should start */
  898. skb_queue_walk(&l->transmq, skb) {
  899. if (!less(buf_seqno(skb), from))
  900. break;
  901. }
  902. skb_queue_walk_from(&l->transmq, skb) {
  903. if (more(buf_seqno(skb), to))
  904. break;
  905. hdr = buf_msg(skb);
  906. _skb = __pskb_copy(skb, MIN_H_SIZE, GFP_ATOMIC);
  907. if (!_skb)
  908. return 0;
  909. hdr = buf_msg(_skb);
  910. msg_set_ack(hdr, ack);
  911. msg_set_bcast_ack(hdr, bc_ack);
  912. _skb->priority = TC_PRIO_CONTROL;
  913. __skb_queue_tail(xmitq, _skb);
  914. l->stats.retransmitted++;
  915. }
  916. return 0;
  917. }
  918. /* tipc_data_input - deliver data and name distr msgs to upper layer
  919. *
  920. * Consumes buffer if message is of right type
  921. * Node lock must be held
  922. */
  923. static bool tipc_data_input(struct tipc_link *l, struct sk_buff *skb,
  924. struct sk_buff_head *inputq)
  925. {
  926. switch (msg_user(buf_msg(skb))) {
  927. case TIPC_LOW_IMPORTANCE:
  928. case TIPC_MEDIUM_IMPORTANCE:
  929. case TIPC_HIGH_IMPORTANCE:
  930. case TIPC_CRITICAL_IMPORTANCE:
  931. case CONN_MANAGER:
  932. skb_queue_tail(inputq, skb);
  933. return true;
  934. case NAME_DISTRIBUTOR:
  935. l->bc_rcvlink->state = LINK_ESTABLISHED;
  936. skb_queue_tail(l->namedq, skb);
  937. return true;
  938. case MSG_BUNDLER:
  939. case TUNNEL_PROTOCOL:
  940. case MSG_FRAGMENTER:
  941. case BCAST_PROTOCOL:
  942. return false;
  943. default:
  944. pr_warn("Dropping received illegal msg type\n");
  945. kfree_skb(skb);
  946. return false;
  947. };
  948. }
  949. /* tipc_link_input - process packet that has passed link protocol check
  950. *
  951. * Consumes buffer
  952. */
  953. static int tipc_link_input(struct tipc_link *l, struct sk_buff *skb,
  954. struct sk_buff_head *inputq)
  955. {
  956. struct tipc_msg *hdr = buf_msg(skb);
  957. struct sk_buff **reasm_skb = &l->reasm_buf;
  958. struct sk_buff *iskb;
  959. struct sk_buff_head tmpq;
  960. int usr = msg_user(hdr);
  961. int rc = 0;
  962. int pos = 0;
  963. int ipos = 0;
  964. if (unlikely(usr == TUNNEL_PROTOCOL)) {
  965. if (msg_type(hdr) == SYNCH_MSG) {
  966. __skb_queue_purge(&l->deferdq);
  967. goto drop;
  968. }
  969. if (!tipc_msg_extract(skb, &iskb, &ipos))
  970. return rc;
  971. kfree_skb(skb);
  972. skb = iskb;
  973. hdr = buf_msg(skb);
  974. if (less(msg_seqno(hdr), l->drop_point))
  975. goto drop;
  976. if (tipc_data_input(l, skb, inputq))
  977. return rc;
  978. usr = msg_user(hdr);
  979. reasm_skb = &l->failover_reasm_skb;
  980. }
  981. if (usr == MSG_BUNDLER) {
  982. skb_queue_head_init(&tmpq);
  983. l->stats.recv_bundles++;
  984. l->stats.recv_bundled += msg_msgcnt(hdr);
  985. while (tipc_msg_extract(skb, &iskb, &pos))
  986. tipc_data_input(l, iskb, &tmpq);
  987. tipc_skb_queue_splice_tail(&tmpq, inputq);
  988. return 0;
  989. } else if (usr == MSG_FRAGMENTER) {
  990. l->stats.recv_fragments++;
  991. if (tipc_buf_append(reasm_skb, &skb)) {
  992. l->stats.recv_fragmented++;
  993. tipc_data_input(l, skb, inputq);
  994. } else if (!*reasm_skb && !link_is_bc_rcvlink(l)) {
  995. pr_warn_ratelimited("Unable to build fragment list\n");
  996. return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
  997. }
  998. return 0;
  999. } else if (usr == BCAST_PROTOCOL) {
  1000. tipc_bcast_lock(l->net);
  1001. tipc_link_bc_init_rcv(l->bc_rcvlink, hdr);
  1002. tipc_bcast_unlock(l->net);
  1003. }
  1004. drop:
  1005. kfree_skb(skb);
  1006. return 0;
  1007. }
  1008. static bool tipc_link_release_pkts(struct tipc_link *l, u16 acked)
  1009. {
  1010. bool released = false;
  1011. struct sk_buff *skb, *tmp;
  1012. skb_queue_walk_safe(&l->transmq, skb, tmp) {
  1013. if (more(buf_seqno(skb), acked))
  1014. break;
  1015. __skb_unlink(skb, &l->transmq);
  1016. kfree_skb(skb);
  1017. released = true;
  1018. }
  1019. return released;
  1020. }
  1021. /* tipc_link_build_ack_msg: prepare link acknowledge message for transmission
  1022. *
  1023. * Note that sending of broadcast ack is coordinated among nodes, to reduce
  1024. * risk of ack storms towards the sender
  1025. */
  1026. int tipc_link_build_ack_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
  1027. {
  1028. if (!l)
  1029. return 0;
  1030. /* Broadcast ACK must be sent via a unicast link => defer to caller */
  1031. if (link_is_bc_rcvlink(l)) {
  1032. if (((l->rcv_nxt ^ tipc_own_addr(l->net)) & 0xf) != 0xf)
  1033. return 0;
  1034. l->rcv_unacked = 0;
  1035. return TIPC_LINK_SND_BC_ACK;
  1036. }
  1037. /* Unicast ACK */
  1038. l->rcv_unacked = 0;
  1039. l->stats.sent_acks++;
  1040. tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, xmitq);
  1041. return 0;
  1042. }
  1043. /* tipc_link_build_reset_msg: prepare link RESET or ACTIVATE message
  1044. */
  1045. void tipc_link_build_reset_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
  1046. {
  1047. int mtyp = RESET_MSG;
  1048. if (l->state == LINK_ESTABLISHING)
  1049. mtyp = ACTIVATE_MSG;
  1050. tipc_link_build_proto_msg(l, mtyp, 0, 0, 0, 0, xmitq);
  1051. }
  1052. /* tipc_link_build_nack_msg: prepare link nack message for transmission
  1053. */
  1054. static void tipc_link_build_nack_msg(struct tipc_link *l,
  1055. struct sk_buff_head *xmitq)
  1056. {
  1057. u32 def_cnt = ++l->stats.deferred_recv;
  1058. if (link_is_bc_rcvlink(l))
  1059. return;
  1060. if ((skb_queue_len(&l->deferdq) == 1) || !(def_cnt % TIPC_NACK_INTV))
  1061. tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, xmitq);
  1062. }
  1063. /* tipc_link_rcv - process TIPC packets/messages arriving from off-node
  1064. * @l: the link that should handle the message
  1065. * @skb: TIPC packet
  1066. * @xmitq: queue to place packets to be sent after this call
  1067. */
  1068. int tipc_link_rcv(struct tipc_link *l, struct sk_buff *skb,
  1069. struct sk_buff_head *xmitq)
  1070. {
  1071. struct sk_buff_head *defq = &l->deferdq;
  1072. struct tipc_msg *hdr;
  1073. u16 seqno, rcv_nxt, win_lim;
  1074. int rc = 0;
  1075. do {
  1076. hdr = buf_msg(skb);
  1077. seqno = msg_seqno(hdr);
  1078. rcv_nxt = l->rcv_nxt;
  1079. win_lim = rcv_nxt + TIPC_MAX_LINK_WIN;
  1080. /* Verify and update link state */
  1081. if (unlikely(msg_user(hdr) == LINK_PROTOCOL))
  1082. return tipc_link_proto_rcv(l, skb, xmitq);
  1083. if (unlikely(!link_is_up(l))) {
  1084. if (l->state == LINK_ESTABLISHING)
  1085. rc = TIPC_LINK_UP_EVT;
  1086. goto drop;
  1087. }
  1088. /* Don't send probe at next timeout expiration */
  1089. l->silent_intv_cnt = 0;
  1090. /* Drop if outside receive window */
  1091. if (unlikely(less(seqno, rcv_nxt) || more(seqno, win_lim))) {
  1092. l->stats.duplicates++;
  1093. goto drop;
  1094. }
  1095. /* Forward queues and wake up waiting users */
  1096. if (likely(tipc_link_release_pkts(l, msg_ack(hdr)))) {
  1097. tipc_link_advance_backlog(l, xmitq);
  1098. if (unlikely(!skb_queue_empty(&l->wakeupq)))
  1099. link_prepare_wakeup(l);
  1100. }
  1101. /* Defer delivery if sequence gap */
  1102. if (unlikely(seqno != rcv_nxt)) {
  1103. __tipc_skb_queue_sorted(defq, seqno, skb);
  1104. tipc_link_build_nack_msg(l, xmitq);
  1105. break;
  1106. }
  1107. /* Deliver packet */
  1108. l->rcv_nxt++;
  1109. l->stats.recv_info++;
  1110. if (!tipc_data_input(l, skb, l->inputq))
  1111. rc |= tipc_link_input(l, skb, l->inputq);
  1112. if (unlikely(++l->rcv_unacked >= TIPC_MIN_LINK_WIN))
  1113. rc |= tipc_link_build_ack_msg(l, xmitq);
  1114. if (unlikely(rc & ~TIPC_LINK_SND_BC_ACK))
  1115. break;
  1116. } while ((skb = __skb_dequeue(defq)));
  1117. return rc;
  1118. drop:
  1119. kfree_skb(skb);
  1120. return rc;
  1121. }
  1122. static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
  1123. u16 rcvgap, int tolerance, int priority,
  1124. struct sk_buff_head *xmitq)
  1125. {
  1126. struct sk_buff *skb;
  1127. struct tipc_msg *hdr;
  1128. struct sk_buff_head *dfq = &l->deferdq;
  1129. bool node_up = link_is_up(l->bc_rcvlink);
  1130. /* Don't send protocol message during reset or link failover */
  1131. if (tipc_link_is_blocked(l))
  1132. return;
  1133. if (!tipc_link_is_up(l) && (mtyp == STATE_MSG))
  1134. return;
  1135. if (!skb_queue_empty(dfq))
  1136. rcvgap = buf_seqno(skb_peek(dfq)) - l->rcv_nxt;
  1137. skb = tipc_msg_create(LINK_PROTOCOL, mtyp, INT_H_SIZE,
  1138. TIPC_MAX_IF_NAME, l->addr,
  1139. tipc_own_addr(l->net), 0, 0, 0);
  1140. if (!skb)
  1141. return;
  1142. hdr = buf_msg(skb);
  1143. msg_set_session(hdr, l->session);
  1144. msg_set_bearer_id(hdr, l->bearer_id);
  1145. msg_set_net_plane(hdr, l->net_plane);
  1146. msg_set_next_sent(hdr, l->snd_nxt);
  1147. msg_set_ack(hdr, l->rcv_nxt - 1);
  1148. msg_set_bcast_ack(hdr, l->bc_rcvlink->rcv_nxt - 1);
  1149. msg_set_last_bcast(hdr, l->bc_sndlink->snd_nxt - 1);
  1150. msg_set_link_tolerance(hdr, tolerance);
  1151. msg_set_linkprio(hdr, priority);
  1152. msg_set_redundant_link(hdr, node_up);
  1153. msg_set_seq_gap(hdr, 0);
  1154. msg_set_seqno(hdr, l->snd_nxt + U16_MAX / 2);
  1155. if (mtyp == STATE_MSG) {
  1156. msg_set_seq_gap(hdr, rcvgap);
  1157. msg_set_size(hdr, INT_H_SIZE);
  1158. msg_set_probe(hdr, probe);
  1159. l->stats.sent_states++;
  1160. l->rcv_unacked = 0;
  1161. } else {
  1162. /* RESET_MSG or ACTIVATE_MSG */
  1163. msg_set_max_pkt(hdr, l->advertised_mtu);
  1164. strcpy(msg_data(hdr), l->if_name);
  1165. }
  1166. if (probe)
  1167. l->stats.sent_probes++;
  1168. if (rcvgap)
  1169. l->stats.sent_nacks++;
  1170. skb->priority = TC_PRIO_CONTROL;
  1171. __skb_queue_tail(xmitq, skb);
  1172. }
  1173. /* tipc_link_tnl_prepare(): prepare and return a list of tunnel packets
  1174. * with contents of the link's transmit and backlog queues.
  1175. */
  1176. void tipc_link_tnl_prepare(struct tipc_link *l, struct tipc_link *tnl,
  1177. int mtyp, struct sk_buff_head *xmitq)
  1178. {
  1179. struct sk_buff *skb, *tnlskb;
  1180. struct tipc_msg *hdr, tnlhdr;
  1181. struct sk_buff_head *queue = &l->transmq;
  1182. struct sk_buff_head tmpxq, tnlq;
  1183. u16 pktlen, pktcnt, seqno = l->snd_nxt;
  1184. if (!tnl)
  1185. return;
  1186. skb_queue_head_init(&tnlq);
  1187. skb_queue_head_init(&tmpxq);
  1188. /* At least one packet required for safe algorithm => add dummy */
  1189. skb = tipc_msg_create(TIPC_LOW_IMPORTANCE, TIPC_DIRECT_MSG,
  1190. BASIC_H_SIZE, 0, l->addr, tipc_own_addr(l->net),
  1191. 0, 0, TIPC_ERR_NO_PORT);
  1192. if (!skb) {
  1193. pr_warn("%sunable to create tunnel packet\n", link_co_err);
  1194. return;
  1195. }
  1196. skb_queue_tail(&tnlq, skb);
  1197. tipc_link_xmit(l, &tnlq, &tmpxq);
  1198. __skb_queue_purge(&tmpxq);
  1199. /* Initialize reusable tunnel packet header */
  1200. tipc_msg_init(tipc_own_addr(l->net), &tnlhdr, TUNNEL_PROTOCOL,
  1201. mtyp, INT_H_SIZE, l->addr);
  1202. pktcnt = skb_queue_len(&l->transmq) + skb_queue_len(&l->backlogq);
  1203. msg_set_msgcnt(&tnlhdr, pktcnt);
  1204. msg_set_bearer_id(&tnlhdr, l->peer_bearer_id);
  1205. tnl:
  1206. /* Wrap each packet into a tunnel packet */
  1207. skb_queue_walk(queue, skb) {
  1208. hdr = buf_msg(skb);
  1209. if (queue == &l->backlogq)
  1210. msg_set_seqno(hdr, seqno++);
  1211. pktlen = msg_size(hdr);
  1212. msg_set_size(&tnlhdr, pktlen + INT_H_SIZE);
  1213. tnlskb = tipc_buf_acquire(pktlen + INT_H_SIZE);
  1214. if (!tnlskb) {
  1215. pr_warn("%sunable to send packet\n", link_co_err);
  1216. return;
  1217. }
  1218. skb_copy_to_linear_data(tnlskb, &tnlhdr, INT_H_SIZE);
  1219. skb_copy_to_linear_data_offset(tnlskb, INT_H_SIZE, hdr, pktlen);
  1220. __skb_queue_tail(&tnlq, tnlskb);
  1221. }
  1222. if (queue != &l->backlogq) {
  1223. queue = &l->backlogq;
  1224. goto tnl;
  1225. }
  1226. tipc_link_xmit(tnl, &tnlq, xmitq);
  1227. if (mtyp == FAILOVER_MSG) {
  1228. tnl->drop_point = l->rcv_nxt;
  1229. tnl->failover_reasm_skb = l->reasm_buf;
  1230. l->reasm_buf = NULL;
  1231. }
  1232. }
  1233. /* tipc_link_proto_rcv(): receive link level protocol message :
  1234. * Note that network plane id propagates through the network, and may
  1235. * change at any time. The node with lowest numerical id determines
  1236. * network plane
  1237. */
  1238. static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
  1239. struct sk_buff_head *xmitq)
  1240. {
  1241. struct tipc_msg *hdr = buf_msg(skb);
  1242. u16 rcvgap = 0;
  1243. u16 ack = msg_ack(hdr);
  1244. u16 gap = msg_seq_gap(hdr);
  1245. u16 peers_snd_nxt = msg_next_sent(hdr);
  1246. u16 peers_tol = msg_link_tolerance(hdr);
  1247. u16 peers_prio = msg_linkprio(hdr);
  1248. u16 rcv_nxt = l->rcv_nxt;
  1249. int mtyp = msg_type(hdr);
  1250. char *if_name;
  1251. int rc = 0;
  1252. if (tipc_link_is_blocked(l) || !xmitq)
  1253. goto exit;
  1254. if (tipc_own_addr(l->net) > msg_prevnode(hdr))
  1255. l->net_plane = msg_net_plane(hdr);
  1256. switch (mtyp) {
  1257. case RESET_MSG:
  1258. /* Ignore duplicate RESET with old session number */
  1259. if ((less_eq(msg_session(hdr), l->peer_session)) &&
  1260. (l->peer_session != ANY_SESSION))
  1261. break;
  1262. /* fall thru' */
  1263. case ACTIVATE_MSG:
  1264. skb_linearize(skb);
  1265. hdr = buf_msg(skb);
  1266. /* Complete own link name with peer's interface name */
  1267. if_name = strrchr(l->name, ':') + 1;
  1268. if (sizeof(l->name) - (if_name - l->name) <= TIPC_MAX_IF_NAME)
  1269. break;
  1270. if (msg_data_sz(hdr) < TIPC_MAX_IF_NAME)
  1271. break;
  1272. strncpy(if_name, msg_data(hdr), TIPC_MAX_IF_NAME);
  1273. /* Update own tolerance if peer indicates a non-zero value */
  1274. if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL))
  1275. l->tolerance = peers_tol;
  1276. /* Update own priority if peer's priority is higher */
  1277. if (in_range(peers_prio, l->priority + 1, TIPC_MAX_LINK_PRI))
  1278. l->priority = peers_prio;
  1279. /* ACTIVATE_MSG serves as PEER_RESET if link is already down */
  1280. if ((mtyp == RESET_MSG) || !link_is_up(l))
  1281. rc = tipc_link_fsm_evt(l, LINK_PEER_RESET_EVT);
  1282. /* ACTIVATE_MSG takes up link if it was already locally reset */
  1283. if ((mtyp == ACTIVATE_MSG) && (l->state == LINK_ESTABLISHING))
  1284. rc = TIPC_LINK_UP_EVT;
  1285. l->peer_session = msg_session(hdr);
  1286. l->peer_bearer_id = msg_bearer_id(hdr);
  1287. if (l->mtu > msg_max_pkt(hdr))
  1288. l->mtu = msg_max_pkt(hdr);
  1289. break;
  1290. case STATE_MSG:
  1291. /* Update own tolerance if peer indicates a non-zero value */
  1292. if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL))
  1293. l->tolerance = peers_tol;
  1294. if (peers_prio && in_range(peers_prio, TIPC_MIN_LINK_PRI,
  1295. TIPC_MAX_LINK_PRI)) {
  1296. l->priority = peers_prio;
  1297. rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
  1298. }
  1299. l->silent_intv_cnt = 0;
  1300. l->stats.recv_states++;
  1301. if (msg_probe(hdr))
  1302. l->stats.recv_probes++;
  1303. if (!link_is_up(l)) {
  1304. if (l->state == LINK_ESTABLISHING)
  1305. rc = TIPC_LINK_UP_EVT;
  1306. break;
  1307. }
  1308. /* Send NACK if peer has sent pkts we haven't received yet */
  1309. if (more(peers_snd_nxt, rcv_nxt) && !tipc_link_is_synching(l))
  1310. rcvgap = peers_snd_nxt - l->rcv_nxt;
  1311. if (rcvgap || (msg_probe(hdr)))
  1312. tipc_link_build_proto_msg(l, STATE_MSG, 0, rcvgap,
  1313. 0, 0, xmitq);
  1314. tipc_link_release_pkts(l, ack);
  1315. /* If NACK, retransmit will now start at right position */
  1316. if (gap) {
  1317. rc = tipc_link_retrans(l, ack + 1, ack + gap, xmitq);
  1318. l->stats.recv_nacks++;
  1319. }
  1320. tipc_link_advance_backlog(l, xmitq);
  1321. if (unlikely(!skb_queue_empty(&l->wakeupq)))
  1322. link_prepare_wakeup(l);
  1323. }
  1324. exit:
  1325. kfree_skb(skb);
  1326. return rc;
  1327. }
  1328. /* tipc_link_build_bc_proto_msg() - create broadcast protocol message
  1329. */
  1330. static bool tipc_link_build_bc_proto_msg(struct tipc_link *l, bool bcast,
  1331. u16 peers_snd_nxt,
  1332. struct sk_buff_head *xmitq)
  1333. {
  1334. struct sk_buff *skb;
  1335. struct tipc_msg *hdr;
  1336. struct sk_buff *dfrd_skb = skb_peek(&l->deferdq);
  1337. u16 ack = l->rcv_nxt - 1;
  1338. u16 gap_to = peers_snd_nxt - 1;
  1339. skb = tipc_msg_create(BCAST_PROTOCOL, STATE_MSG, INT_H_SIZE,
  1340. 0, l->addr, tipc_own_addr(l->net), 0, 0, 0);
  1341. if (!skb)
  1342. return false;
  1343. hdr = buf_msg(skb);
  1344. msg_set_last_bcast(hdr, l->bc_sndlink->snd_nxt - 1);
  1345. msg_set_bcast_ack(hdr, ack);
  1346. msg_set_bcgap_after(hdr, ack);
  1347. if (dfrd_skb)
  1348. gap_to = buf_seqno(dfrd_skb) - 1;
  1349. msg_set_bcgap_to(hdr, gap_to);
  1350. msg_set_non_seq(hdr, bcast);
  1351. __skb_queue_tail(xmitq, skb);
  1352. return true;
  1353. }
  1354. /* tipc_link_build_bc_init_msg() - synchronize broadcast link endpoints.
  1355. *
  1356. * Give a newly added peer node the sequence number where it should
  1357. * start receiving and acking broadcast packets.
  1358. */
  1359. static void tipc_link_build_bc_init_msg(struct tipc_link *l,
  1360. struct sk_buff_head *xmitq)
  1361. {
  1362. struct sk_buff_head list;
  1363. __skb_queue_head_init(&list);
  1364. if (!tipc_link_build_bc_proto_msg(l->bc_rcvlink, false, 0, &list))
  1365. return;
  1366. tipc_link_xmit(l, &list, xmitq);
  1367. }
  1368. /* tipc_link_bc_init_rcv - receive initial broadcast synch data from peer
  1369. */
  1370. void tipc_link_bc_init_rcv(struct tipc_link *l, struct tipc_msg *hdr)
  1371. {
  1372. int mtyp = msg_type(hdr);
  1373. u16 peers_snd_nxt = msg_bc_snd_nxt(hdr);
  1374. if (link_is_up(l))
  1375. return;
  1376. if (msg_user(hdr) == BCAST_PROTOCOL) {
  1377. l->rcv_nxt = peers_snd_nxt;
  1378. l->state = LINK_ESTABLISHED;
  1379. return;
  1380. }
  1381. if (l->peer_caps & TIPC_BCAST_SYNCH)
  1382. return;
  1383. if (msg_peer_node_is_up(hdr))
  1384. return;
  1385. /* Compatibility: accept older, less safe initial synch data */
  1386. if ((mtyp == RESET_MSG) || (mtyp == ACTIVATE_MSG))
  1387. l->rcv_nxt = peers_snd_nxt;
  1388. }
  1389. /* tipc_link_bc_sync_rcv - update rcv link according to peer's send state
  1390. */
  1391. void tipc_link_bc_sync_rcv(struct tipc_link *l, struct tipc_msg *hdr,
  1392. struct sk_buff_head *xmitq)
  1393. {
  1394. u16 peers_snd_nxt = msg_bc_snd_nxt(hdr);
  1395. if (!link_is_up(l))
  1396. return;
  1397. if (!msg_peer_node_is_up(hdr))
  1398. return;
  1399. l->bc_peer_is_up = true;
  1400. /* Ignore if peers_snd_nxt goes beyond receive window */
  1401. if (more(peers_snd_nxt, l->rcv_nxt + l->window))
  1402. return;
  1403. if (!more(peers_snd_nxt, l->rcv_nxt)) {
  1404. l->nack_state = BC_NACK_SND_CONDITIONAL;
  1405. return;
  1406. }
  1407. /* Don't NACK if one was recently sent or peeked */
  1408. if (l->nack_state == BC_NACK_SND_SUPPRESS) {
  1409. l->nack_state = BC_NACK_SND_UNCONDITIONAL;
  1410. return;
  1411. }
  1412. /* Conditionally delay NACK sending until next synch rcv */
  1413. if (l->nack_state == BC_NACK_SND_CONDITIONAL) {
  1414. l->nack_state = BC_NACK_SND_UNCONDITIONAL;
  1415. if ((peers_snd_nxt - l->rcv_nxt) < TIPC_MIN_LINK_WIN)
  1416. return;
  1417. }
  1418. /* Send NACK now but suppress next one */
  1419. tipc_link_build_bc_proto_msg(l, true, peers_snd_nxt, xmitq);
  1420. l->nack_state = BC_NACK_SND_SUPPRESS;
  1421. }
  1422. void tipc_link_bc_ack_rcv(struct tipc_link *l, u16 acked,
  1423. struct sk_buff_head *xmitq)
  1424. {
  1425. struct sk_buff *skb, *tmp;
  1426. struct tipc_link *snd_l = l->bc_sndlink;
  1427. if (!link_is_up(l) || !l->bc_peer_is_up)
  1428. return;
  1429. if (!more(acked, l->acked))
  1430. return;
  1431. /* Skip over packets peer has already acked */
  1432. skb_queue_walk(&snd_l->transmq, skb) {
  1433. if (more(buf_seqno(skb), l->acked))
  1434. break;
  1435. }
  1436. /* Update/release the packets peer is acking now */
  1437. skb_queue_walk_from_safe(&snd_l->transmq, skb, tmp) {
  1438. if (more(buf_seqno(skb), acked))
  1439. break;
  1440. if (!--TIPC_SKB_CB(skb)->ackers) {
  1441. __skb_unlink(skb, &snd_l->transmq);
  1442. kfree_skb(skb);
  1443. }
  1444. }
  1445. l->acked = acked;
  1446. tipc_link_advance_backlog(snd_l, xmitq);
  1447. if (unlikely(!skb_queue_empty(&snd_l->wakeupq)))
  1448. link_prepare_wakeup(snd_l);
  1449. }
  1450. /* tipc_link_bc_nack_rcv(): receive broadcast nack message
  1451. */
  1452. int tipc_link_bc_nack_rcv(struct tipc_link *l, struct sk_buff *skb,
  1453. struct sk_buff_head *xmitq)
  1454. {
  1455. struct tipc_msg *hdr = buf_msg(skb);
  1456. u32 dnode = msg_destnode(hdr);
  1457. int mtyp = msg_type(hdr);
  1458. u16 acked = msg_bcast_ack(hdr);
  1459. u16 from = acked + 1;
  1460. u16 to = msg_bcgap_to(hdr);
  1461. u16 peers_snd_nxt = to + 1;
  1462. int rc = 0;
  1463. kfree_skb(skb);
  1464. if (!tipc_link_is_up(l) || !l->bc_peer_is_up)
  1465. return 0;
  1466. if (mtyp != STATE_MSG)
  1467. return 0;
  1468. if (dnode == tipc_own_addr(l->net)) {
  1469. tipc_link_bc_ack_rcv(l, acked, xmitq);
  1470. rc = tipc_link_retrans(l->bc_sndlink, from, to, xmitq);
  1471. l->stats.recv_nacks++;
  1472. return rc;
  1473. }
  1474. /* Msg for other node => suppress own NACK at next sync if applicable */
  1475. if (more(peers_snd_nxt, l->rcv_nxt) && !less(l->rcv_nxt, from))
  1476. l->nack_state = BC_NACK_SND_SUPPRESS;
  1477. return 0;
  1478. }
  1479. void tipc_link_set_queue_limits(struct tipc_link *l, u32 win)
  1480. {
  1481. int max_bulk = TIPC_MAX_PUBLICATIONS / (l->mtu / ITEM_SIZE);
  1482. l->window = win;
  1483. l->backlog[TIPC_LOW_IMPORTANCE].limit = win / 2;
  1484. l->backlog[TIPC_MEDIUM_IMPORTANCE].limit = win;
  1485. l->backlog[TIPC_HIGH_IMPORTANCE].limit = win / 2 * 3;
  1486. l->backlog[TIPC_CRITICAL_IMPORTANCE].limit = win * 2;
  1487. l->backlog[TIPC_SYSTEM_IMPORTANCE].limit = max_bulk;
  1488. }
  1489. /**
  1490. * link_reset_stats - reset link statistics
  1491. * @l: pointer to link
  1492. */
  1493. void tipc_link_reset_stats(struct tipc_link *l)
  1494. {
  1495. memset(&l->stats, 0, sizeof(l->stats));
  1496. if (!link_is_bc_sndlink(l)) {
  1497. l->stats.sent_info = l->snd_nxt;
  1498. l->stats.recv_info = l->rcv_nxt;
  1499. }
  1500. }
  1501. static void link_print(struct tipc_link *l, const char *str)
  1502. {
  1503. struct sk_buff *hskb = skb_peek(&l->transmq);
  1504. u16 head = hskb ? msg_seqno(buf_msg(hskb)) : l->snd_nxt - 1;
  1505. u16 tail = l->snd_nxt - 1;
  1506. pr_info("%s Link <%s> state %x\n", str, l->name, l->state);
  1507. pr_info("XMTQ: %u [%u-%u], BKLGQ: %u, SNDNX: %u, RCVNX: %u\n",
  1508. skb_queue_len(&l->transmq), head, tail,
  1509. skb_queue_len(&l->backlogq), l->snd_nxt, l->rcv_nxt);
  1510. }
  1511. /* Parse and validate nested (link) properties valid for media, bearer and link
  1512. */
  1513. int tipc_nl_parse_link_prop(struct nlattr *prop, struct nlattr *props[])
  1514. {
  1515. int err;
  1516. err = nla_parse_nested(props, TIPC_NLA_PROP_MAX, prop,
  1517. tipc_nl_prop_policy);
  1518. if (err)
  1519. return err;
  1520. if (props[TIPC_NLA_PROP_PRIO]) {
  1521. u32 prio;
  1522. prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
  1523. if (prio > TIPC_MAX_LINK_PRI)
  1524. return -EINVAL;
  1525. }
  1526. if (props[TIPC_NLA_PROP_TOL]) {
  1527. u32 tol;
  1528. tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
  1529. if ((tol < TIPC_MIN_LINK_TOL) || (tol > TIPC_MAX_LINK_TOL))
  1530. return -EINVAL;
  1531. }
  1532. if (props[TIPC_NLA_PROP_WIN]) {
  1533. u32 win;
  1534. win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
  1535. if ((win < TIPC_MIN_LINK_WIN) || (win > TIPC_MAX_LINK_WIN))
  1536. return -EINVAL;
  1537. }
  1538. return 0;
  1539. }
  1540. static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s)
  1541. {
  1542. int i;
  1543. struct nlattr *stats;
  1544. struct nla_map {
  1545. u32 key;
  1546. u32 val;
  1547. };
  1548. struct nla_map map[] = {
  1549. {TIPC_NLA_STATS_RX_INFO, s->recv_info},
  1550. {TIPC_NLA_STATS_RX_FRAGMENTS, s->recv_fragments},
  1551. {TIPC_NLA_STATS_RX_FRAGMENTED, s->recv_fragmented},
  1552. {TIPC_NLA_STATS_RX_BUNDLES, s->recv_bundles},
  1553. {TIPC_NLA_STATS_RX_BUNDLED, s->recv_bundled},
  1554. {TIPC_NLA_STATS_TX_INFO, s->sent_info},
  1555. {TIPC_NLA_STATS_TX_FRAGMENTS, s->sent_fragments},
  1556. {TIPC_NLA_STATS_TX_FRAGMENTED, s->sent_fragmented},
  1557. {TIPC_NLA_STATS_TX_BUNDLES, s->sent_bundles},
  1558. {TIPC_NLA_STATS_TX_BUNDLED, s->sent_bundled},
  1559. {TIPC_NLA_STATS_MSG_PROF_TOT, (s->msg_length_counts) ?
  1560. s->msg_length_counts : 1},
  1561. {TIPC_NLA_STATS_MSG_LEN_CNT, s->msg_length_counts},
  1562. {TIPC_NLA_STATS_MSG_LEN_TOT, s->msg_lengths_total},
  1563. {TIPC_NLA_STATS_MSG_LEN_P0, s->msg_length_profile[0]},
  1564. {TIPC_NLA_STATS_MSG_LEN_P1, s->msg_length_profile[1]},
  1565. {TIPC_NLA_STATS_MSG_LEN_P2, s->msg_length_profile[2]},
  1566. {TIPC_NLA_STATS_MSG_LEN_P3, s->msg_length_profile[3]},
  1567. {TIPC_NLA_STATS_MSG_LEN_P4, s->msg_length_profile[4]},
  1568. {TIPC_NLA_STATS_MSG_LEN_P5, s->msg_length_profile[5]},
  1569. {TIPC_NLA_STATS_MSG_LEN_P6, s->msg_length_profile[6]},
  1570. {TIPC_NLA_STATS_RX_STATES, s->recv_states},
  1571. {TIPC_NLA_STATS_RX_PROBES, s->recv_probes},
  1572. {TIPC_NLA_STATS_RX_NACKS, s->recv_nacks},
  1573. {TIPC_NLA_STATS_RX_DEFERRED, s->deferred_recv},
  1574. {TIPC_NLA_STATS_TX_STATES, s->sent_states},
  1575. {TIPC_NLA_STATS_TX_PROBES, s->sent_probes},
  1576. {TIPC_NLA_STATS_TX_NACKS, s->sent_nacks},
  1577. {TIPC_NLA_STATS_TX_ACKS, s->sent_acks},
  1578. {TIPC_NLA_STATS_RETRANSMITTED, s->retransmitted},
  1579. {TIPC_NLA_STATS_DUPLICATES, s->duplicates},
  1580. {TIPC_NLA_STATS_LINK_CONGS, s->link_congs},
  1581. {TIPC_NLA_STATS_MAX_QUEUE, s->max_queue_sz},
  1582. {TIPC_NLA_STATS_AVG_QUEUE, s->queue_sz_counts ?
  1583. (s->accu_queue_sz / s->queue_sz_counts) : 0}
  1584. };
  1585. stats = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
  1586. if (!stats)
  1587. return -EMSGSIZE;
  1588. for (i = 0; i < ARRAY_SIZE(map); i++)
  1589. if (nla_put_u32(skb, map[i].key, map[i].val))
  1590. goto msg_full;
  1591. nla_nest_end(skb, stats);
  1592. return 0;
  1593. msg_full:
  1594. nla_nest_cancel(skb, stats);
  1595. return -EMSGSIZE;
  1596. }
  1597. /* Caller should hold appropriate locks to protect the link */
  1598. int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
  1599. struct tipc_link *link, int nlflags)
  1600. {
  1601. int err;
  1602. void *hdr;
  1603. struct nlattr *attrs;
  1604. struct nlattr *prop;
  1605. struct tipc_net *tn = net_generic(net, tipc_net_id);
  1606. hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
  1607. nlflags, TIPC_NL_LINK_GET);
  1608. if (!hdr)
  1609. return -EMSGSIZE;
  1610. attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
  1611. if (!attrs)
  1612. goto msg_full;
  1613. if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, link->name))
  1614. goto attr_msg_full;
  1615. if (nla_put_u32(msg->skb, TIPC_NLA_LINK_DEST,
  1616. tipc_cluster_mask(tn->own_addr)))
  1617. goto attr_msg_full;
  1618. if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->mtu))
  1619. goto attr_msg_full;
  1620. if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, link->rcv_nxt))
  1621. goto attr_msg_full;
  1622. if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, link->snd_nxt))
  1623. goto attr_msg_full;
  1624. if (tipc_link_is_up(link))
  1625. if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
  1626. goto attr_msg_full;
  1627. if (link->active)
  1628. if (nla_put_flag(msg->skb, TIPC_NLA_LINK_ACTIVE))
  1629. goto attr_msg_full;
  1630. prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
  1631. if (!prop)
  1632. goto attr_msg_full;
  1633. if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
  1634. goto prop_msg_full;
  1635. if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, link->tolerance))
  1636. goto prop_msg_full;
  1637. if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN,
  1638. link->window))
  1639. goto prop_msg_full;
  1640. if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
  1641. goto prop_msg_full;
  1642. nla_nest_end(msg->skb, prop);
  1643. err = __tipc_nl_add_stats(msg->skb, &link->stats);
  1644. if (err)
  1645. goto attr_msg_full;
  1646. nla_nest_end(msg->skb, attrs);
  1647. genlmsg_end(msg->skb, hdr);
  1648. return 0;
  1649. prop_msg_full:
  1650. nla_nest_cancel(msg->skb, prop);
  1651. attr_msg_full:
  1652. nla_nest_cancel(msg->skb, attrs);
  1653. msg_full:
  1654. genlmsg_cancel(msg->skb, hdr);
  1655. return -EMSGSIZE;
  1656. }
  1657. static int __tipc_nl_add_bc_link_stat(struct sk_buff *skb,
  1658. struct tipc_stats *stats)
  1659. {
  1660. int i;
  1661. struct nlattr *nest;
  1662. struct nla_map {
  1663. __u32 key;
  1664. __u32 val;
  1665. };
  1666. struct nla_map map[] = {
  1667. {TIPC_NLA_STATS_RX_INFO, stats->recv_info},
  1668. {TIPC_NLA_STATS_RX_FRAGMENTS, stats->recv_fragments},
  1669. {TIPC_NLA_STATS_RX_FRAGMENTED, stats->recv_fragmented},
  1670. {TIPC_NLA_STATS_RX_BUNDLES, stats->recv_bundles},
  1671. {TIPC_NLA_STATS_RX_BUNDLED, stats->recv_bundled},
  1672. {TIPC_NLA_STATS_TX_INFO, stats->sent_info},
  1673. {TIPC_NLA_STATS_TX_FRAGMENTS, stats->sent_fragments},
  1674. {TIPC_NLA_STATS_TX_FRAGMENTED, stats->sent_fragmented},
  1675. {TIPC_NLA_STATS_TX_BUNDLES, stats->sent_bundles},
  1676. {TIPC_NLA_STATS_TX_BUNDLED, stats->sent_bundled},
  1677. {TIPC_NLA_STATS_RX_NACKS, stats->recv_nacks},
  1678. {TIPC_NLA_STATS_RX_DEFERRED, stats->deferred_recv},
  1679. {TIPC_NLA_STATS_TX_NACKS, stats->sent_nacks},
  1680. {TIPC_NLA_STATS_TX_ACKS, stats->sent_acks},
  1681. {TIPC_NLA_STATS_RETRANSMITTED, stats->retransmitted},
  1682. {TIPC_NLA_STATS_DUPLICATES, stats->duplicates},
  1683. {TIPC_NLA_STATS_LINK_CONGS, stats->link_congs},
  1684. {TIPC_NLA_STATS_MAX_QUEUE, stats->max_queue_sz},
  1685. {TIPC_NLA_STATS_AVG_QUEUE, stats->queue_sz_counts ?
  1686. (stats->accu_queue_sz / stats->queue_sz_counts) : 0}
  1687. };
  1688. nest = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
  1689. if (!nest)
  1690. return -EMSGSIZE;
  1691. for (i = 0; i < ARRAY_SIZE(map); i++)
  1692. if (nla_put_u32(skb, map[i].key, map[i].val))
  1693. goto msg_full;
  1694. nla_nest_end(skb, nest);
  1695. return 0;
  1696. msg_full:
  1697. nla_nest_cancel(skb, nest);
  1698. return -EMSGSIZE;
  1699. }
  1700. int tipc_nl_add_bc_link(struct net *net, struct tipc_nl_msg *msg)
  1701. {
  1702. int err;
  1703. void *hdr;
  1704. struct nlattr *attrs;
  1705. struct nlattr *prop;
  1706. struct tipc_net *tn = net_generic(net, tipc_net_id);
  1707. struct tipc_link *bcl = tn->bcl;
  1708. if (!bcl)
  1709. return 0;
  1710. tipc_bcast_lock(net);
  1711. hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
  1712. NLM_F_MULTI, TIPC_NL_LINK_GET);
  1713. if (!hdr) {
  1714. tipc_bcast_unlock(net);
  1715. return -EMSGSIZE;
  1716. }
  1717. attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
  1718. if (!attrs)
  1719. goto msg_full;
  1720. /* The broadcast link is always up */
  1721. if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
  1722. goto attr_msg_full;
  1723. if (nla_put_flag(msg->skb, TIPC_NLA_LINK_BROADCAST))
  1724. goto attr_msg_full;
  1725. if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, bcl->name))
  1726. goto attr_msg_full;
  1727. if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, bcl->rcv_nxt))
  1728. goto attr_msg_full;
  1729. if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, bcl->snd_nxt))
  1730. goto attr_msg_full;
  1731. prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
  1732. if (!prop)
  1733. goto attr_msg_full;
  1734. if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bcl->window))
  1735. goto prop_msg_full;
  1736. nla_nest_end(msg->skb, prop);
  1737. err = __tipc_nl_add_bc_link_stat(msg->skb, &bcl->stats);
  1738. if (err)
  1739. goto attr_msg_full;
  1740. tipc_bcast_unlock(net);
  1741. nla_nest_end(msg->skb, attrs);
  1742. genlmsg_end(msg->skb, hdr);
  1743. return 0;
  1744. prop_msg_full:
  1745. nla_nest_cancel(msg->skb, prop);
  1746. attr_msg_full:
  1747. nla_nest_cancel(msg->skb, attrs);
  1748. msg_full:
  1749. tipc_bcast_unlock(net);
  1750. genlmsg_cancel(msg->skb, hdr);
  1751. return -EMSGSIZE;
  1752. }
  1753. void tipc_link_set_tolerance(struct tipc_link *l, u32 tol,
  1754. struct sk_buff_head *xmitq)
  1755. {
  1756. l->tolerance = tol;
  1757. tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, tol, 0, xmitq);
  1758. }
  1759. void tipc_link_set_prio(struct tipc_link *l, u32 prio,
  1760. struct sk_buff_head *xmitq)
  1761. {
  1762. l->priority = prio;
  1763. tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, prio, xmitq);
  1764. }
  1765. void tipc_link_set_abort_limit(struct tipc_link *l, u32 limit)
  1766. {
  1767. l->abort_limit = limit;
  1768. }