msg.h 29 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310
  1. /*
  2. * net/tipc/msg.h: Include file for TIPC message header routines
  3. *
  4. * Copyright (c) 2000-2007, 2014-2017 Ericsson AB
  5. * Copyright (c) 2005-2008, 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. #ifndef _TIPC_MSG_H
  37. #define _TIPC_MSG_H
  38. #include <linux/tipc.h>
  39. #include "core.h"
  40. /*
  41. * Constants and routines used to read and write TIPC payload message headers
  42. *
  43. * Note: Some items are also used with TIPC internal message headers
  44. */
  45. #define TIPC_VERSION 2
  46. struct plist;
  47. /*
  48. * Payload message users are defined in TIPC's public API:
  49. * - TIPC_LOW_IMPORTANCE
  50. * - TIPC_MEDIUM_IMPORTANCE
  51. * - TIPC_HIGH_IMPORTANCE
  52. * - TIPC_CRITICAL_IMPORTANCE
  53. */
  54. #define TIPC_SYSTEM_IMPORTANCE 4
  55. /*
  56. * Payload message types
  57. */
  58. #define TIPC_CONN_MSG 0
  59. #define TIPC_MCAST_MSG 1
  60. #define TIPC_NAMED_MSG 2
  61. #define TIPC_DIRECT_MSG 3
  62. #define TIPC_GRP_MEMBER_EVT 4
  63. #define TIPC_GRP_BCAST_MSG 5
  64. #define TIPC_GRP_MCAST_MSG 6
  65. #define TIPC_GRP_UCAST_MSG 7
  66. /*
  67. * Internal message users
  68. */
  69. #define BCAST_PROTOCOL 5
  70. #define MSG_BUNDLER 6
  71. #define LINK_PROTOCOL 7
  72. #define CONN_MANAGER 8
  73. #define GROUP_PROTOCOL 9
  74. #define TUNNEL_PROTOCOL 10
  75. #define NAME_DISTRIBUTOR 11
  76. #define MSG_FRAGMENTER 12
  77. #define LINK_CONFIG 13
  78. #define MSG_CRYPTO 14
  79. #define SOCK_WAKEUP 14 /* pseudo user */
  80. #define TOP_SRV 15 /* pseudo user */
  81. /*
  82. * Message header sizes
  83. */
  84. #define SHORT_H_SIZE 24 /* In-cluster basic payload message */
  85. #define BASIC_H_SIZE 32 /* Basic payload message */
  86. #define NAMED_H_SIZE 40 /* Named payload message */
  87. #define MCAST_H_SIZE 44 /* Multicast payload message */
  88. #define GROUP_H_SIZE 44 /* Group payload message */
  89. #define INT_H_SIZE 40 /* Internal messages */
  90. #define MIN_H_SIZE 24 /* Smallest legal TIPC header size */
  91. #define MAX_H_SIZE 60 /* Largest possible TIPC header size */
  92. #define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)
  93. #define TIPC_MEDIA_INFO_OFFSET 5
  94. extern const int one_page_mtu;
  95. struct tipc_skb_cb {
  96. union {
  97. struct {
  98. struct sk_buff *tail;
  99. unsigned long nxt_retr;
  100. unsigned long retr_stamp;
  101. u32 bytes_read;
  102. u32 orig_member;
  103. u16 chain_imp;
  104. u16 ackers;
  105. u16 retr_cnt;
  106. } __packed;
  107. #ifdef CONFIG_TIPC_CRYPTO
  108. struct {
  109. struct tipc_crypto *rx;
  110. struct tipc_aead *last;
  111. u8 recurs;
  112. } tx_clone_ctx __packed;
  113. #endif
  114. } __packed;
  115. union {
  116. struct {
  117. u8 validated:1;
  118. #ifdef CONFIG_TIPC_CRYPTO
  119. u8 encrypted:1;
  120. u8 decrypted:1;
  121. #define SKB_PROBING 1
  122. #define SKB_GRACING 2
  123. u8 xmit_type:2;
  124. u8 tx_clone_deferred:1;
  125. #endif
  126. };
  127. u8 flags;
  128. };
  129. u8 reserved;
  130. #ifdef CONFIG_TIPC_CRYPTO
  131. void *crypto_ctx;
  132. #endif
  133. } __packed;
  134. #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0]))
  135. struct tipc_msg {
  136. __be32 hdr[15];
  137. };
  138. /* struct tipc_gap_ack - TIPC Gap ACK block
  139. * @ack: seqno of the last consecutive packet in link deferdq
  140. * @gap: number of gap packets since the last ack
  141. *
  142. * E.g:
  143. * link deferdq: 1 2 3 4 10 11 13 14 15 20
  144. * --> Gap ACK blocks: <4, 5>, <11, 1>, <15, 4>, <20, 0>
  145. */
  146. struct tipc_gap_ack {
  147. __be16 ack;
  148. __be16 gap;
  149. };
  150. /* struct tipc_gap_ack_blks
  151. * @len: actual length of the record
  152. * @ugack_cnt: number of Gap ACK blocks for unicast (following the broadcast
  153. * ones)
  154. * @start_index: starting index for "valid" broadcast Gap ACK blocks
  155. * @bgack_cnt: number of Gap ACK blocks for broadcast in the record
  156. * @gacks: array of Gap ACK blocks
  157. *
  158. * 31 16 15 0
  159. * +-------------+-------------+-------------+-------------+
  160. * | bgack_cnt | ugack_cnt | len |
  161. * +-------------+-------------+-------------+-------------+ -
  162. * | gap | ack | |
  163. * +-------------+-------------+-------------+-------------+ > bc gacks
  164. * : : : |
  165. * +-------------+-------------+-------------+-------------+ -
  166. * | gap | ack | |
  167. * +-------------+-------------+-------------+-------------+ > uc gacks
  168. * : : : |
  169. * +-------------+-------------+-------------+-------------+ -
  170. */
  171. struct tipc_gap_ack_blks {
  172. __be16 len;
  173. union {
  174. u8 ugack_cnt;
  175. u8 start_index;
  176. };
  177. u8 bgack_cnt;
  178. struct tipc_gap_ack gacks[];
  179. };
  180. #define MAX_GAP_ACK_BLKS 128
  181. #define MAX_GAP_ACK_BLKS_SZ (sizeof(struct tipc_gap_ack_blks) + \
  182. sizeof(struct tipc_gap_ack) * MAX_GAP_ACK_BLKS)
  183. static inline struct tipc_msg *buf_msg(struct sk_buff *skb)
  184. {
  185. return (struct tipc_msg *)skb->data;
  186. }
  187. static inline u32 msg_word(struct tipc_msg *m, u32 pos)
  188. {
  189. return ntohl(m->hdr[pos]);
  190. }
  191. static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val)
  192. {
  193. m->hdr[w] = htonl(val);
  194. }
  195. static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
  196. {
  197. return (msg_word(m, w) >> pos) & mask;
  198. }
  199. static inline void msg_set_bits(struct tipc_msg *m, u32 w,
  200. u32 pos, u32 mask, u32 val)
  201. {
  202. val = (val & mask) << pos;
  203. mask = mask << pos;
  204. m->hdr[w] &= ~htonl(mask);
  205. m->hdr[w] |= htonl(val);
  206. }
  207. /*
  208. * Word 0
  209. */
  210. static inline u32 msg_version(struct tipc_msg *m)
  211. {
  212. return msg_bits(m, 0, 29, 7);
  213. }
  214. static inline void msg_set_version(struct tipc_msg *m)
  215. {
  216. msg_set_bits(m, 0, 29, 7, TIPC_VERSION);
  217. }
  218. static inline u32 msg_user(struct tipc_msg *m)
  219. {
  220. return msg_bits(m, 0, 25, 0xf);
  221. }
  222. static inline u32 msg_isdata(struct tipc_msg *m)
  223. {
  224. return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE;
  225. }
  226. static inline void msg_set_user(struct tipc_msg *m, u32 n)
  227. {
  228. msg_set_bits(m, 0, 25, 0xf, n);
  229. }
  230. static inline u32 msg_hdr_sz(struct tipc_msg *m)
  231. {
  232. return msg_bits(m, 0, 21, 0xf) << 2;
  233. }
  234. static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n)
  235. {
  236. msg_set_bits(m, 0, 21, 0xf, n>>2);
  237. }
  238. static inline u32 msg_size(struct tipc_msg *m)
  239. {
  240. return msg_bits(m, 0, 0, 0x1ffff);
  241. }
  242. static inline u32 msg_blocks(struct tipc_msg *m)
  243. {
  244. return (msg_size(m) / 1024) + 1;
  245. }
  246. static inline u32 msg_data_sz(struct tipc_msg *m)
  247. {
  248. return msg_size(m) - msg_hdr_sz(m);
  249. }
  250. static inline int msg_non_seq(struct tipc_msg *m)
  251. {
  252. return msg_bits(m, 0, 20, 1);
  253. }
  254. static inline void msg_set_non_seq(struct tipc_msg *m, u32 n)
  255. {
  256. msg_set_bits(m, 0, 20, 1, n);
  257. }
  258. static inline int msg_is_syn(struct tipc_msg *m)
  259. {
  260. return msg_bits(m, 0, 17, 1);
  261. }
  262. static inline void msg_set_syn(struct tipc_msg *m, u32 d)
  263. {
  264. msg_set_bits(m, 0, 17, 1, d);
  265. }
  266. static inline int msg_dest_droppable(struct tipc_msg *m)
  267. {
  268. return msg_bits(m, 0, 19, 1);
  269. }
  270. static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d)
  271. {
  272. msg_set_bits(m, 0, 19, 1, d);
  273. }
  274. static inline int msg_is_keepalive(struct tipc_msg *m)
  275. {
  276. return msg_bits(m, 0, 19, 1);
  277. }
  278. static inline void msg_set_is_keepalive(struct tipc_msg *m, u32 d)
  279. {
  280. msg_set_bits(m, 0, 19, 1, d);
  281. }
  282. static inline int msg_src_droppable(struct tipc_msg *m)
  283. {
  284. return msg_bits(m, 0, 18, 1);
  285. }
  286. static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d)
  287. {
  288. msg_set_bits(m, 0, 18, 1, d);
  289. }
  290. static inline int msg_ack_required(struct tipc_msg *m)
  291. {
  292. return msg_bits(m, 0, 18, 1);
  293. }
  294. static inline void msg_set_ack_required(struct tipc_msg *m)
  295. {
  296. msg_set_bits(m, 0, 18, 1, 1);
  297. }
  298. static inline int msg_nagle_ack(struct tipc_msg *m)
  299. {
  300. return msg_bits(m, 0, 18, 1);
  301. }
  302. static inline void msg_set_nagle_ack(struct tipc_msg *m)
  303. {
  304. msg_set_bits(m, 0, 18, 1, 1);
  305. }
  306. static inline bool msg_is_rcast(struct tipc_msg *m)
  307. {
  308. return msg_bits(m, 0, 18, 0x1);
  309. }
  310. static inline void msg_set_is_rcast(struct tipc_msg *m, bool d)
  311. {
  312. msg_set_bits(m, 0, 18, 0x1, d);
  313. }
  314. static inline void msg_set_size(struct tipc_msg *m, u32 sz)
  315. {
  316. m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz);
  317. }
  318. static inline unchar *msg_data(struct tipc_msg *m)
  319. {
  320. return ((unchar *)m) + msg_hdr_sz(m);
  321. }
  322. static inline struct tipc_msg *msg_inner_hdr(struct tipc_msg *m)
  323. {
  324. return (struct tipc_msg *)msg_data(m);
  325. }
  326. /*
  327. * Word 1
  328. */
  329. static inline u32 msg_type(struct tipc_msg *m)
  330. {
  331. return msg_bits(m, 1, 29, 0x7);
  332. }
  333. static inline void msg_set_type(struct tipc_msg *m, u32 n)
  334. {
  335. msg_set_bits(m, 1, 29, 0x7, n);
  336. }
  337. static inline int msg_in_group(struct tipc_msg *m)
  338. {
  339. int mtyp = msg_type(m);
  340. return mtyp >= TIPC_GRP_MEMBER_EVT && mtyp <= TIPC_GRP_UCAST_MSG;
  341. }
  342. static inline bool msg_is_grp_evt(struct tipc_msg *m)
  343. {
  344. return msg_type(m) == TIPC_GRP_MEMBER_EVT;
  345. }
  346. static inline u32 msg_named(struct tipc_msg *m)
  347. {
  348. return msg_type(m) == TIPC_NAMED_MSG;
  349. }
  350. static inline u32 msg_mcast(struct tipc_msg *m)
  351. {
  352. int mtyp = msg_type(m);
  353. return ((mtyp == TIPC_MCAST_MSG) || (mtyp == TIPC_GRP_BCAST_MSG) ||
  354. (mtyp == TIPC_GRP_MCAST_MSG));
  355. }
  356. static inline u32 msg_connected(struct tipc_msg *m)
  357. {
  358. return msg_type(m) == TIPC_CONN_MSG;
  359. }
  360. static inline u32 msg_direct(struct tipc_msg *m)
  361. {
  362. return msg_type(m) == TIPC_DIRECT_MSG;
  363. }
  364. static inline u32 msg_errcode(struct tipc_msg *m)
  365. {
  366. return msg_bits(m, 1, 25, 0xf);
  367. }
  368. static inline void msg_set_errcode(struct tipc_msg *m, u32 err)
  369. {
  370. msg_set_bits(m, 1, 25, 0xf, err);
  371. }
  372. static inline void msg_set_bulk(struct tipc_msg *m)
  373. {
  374. msg_set_bits(m, 1, 28, 0x1, 1);
  375. }
  376. static inline u32 msg_is_bulk(struct tipc_msg *m)
  377. {
  378. return msg_bits(m, 1, 28, 0x1);
  379. }
  380. static inline void msg_set_last_bulk(struct tipc_msg *m)
  381. {
  382. msg_set_bits(m, 1, 27, 0x1, 1);
  383. }
  384. static inline u32 msg_is_last_bulk(struct tipc_msg *m)
  385. {
  386. return msg_bits(m, 1, 27, 0x1);
  387. }
  388. static inline void msg_set_non_legacy(struct tipc_msg *m)
  389. {
  390. msg_set_bits(m, 1, 26, 0x1, 1);
  391. }
  392. static inline u32 msg_is_legacy(struct tipc_msg *m)
  393. {
  394. return !msg_bits(m, 1, 26, 0x1);
  395. }
  396. static inline u32 msg_reroute_cnt(struct tipc_msg *m)
  397. {
  398. return msg_bits(m, 1, 21, 0xf);
  399. }
  400. static inline void msg_incr_reroute_cnt(struct tipc_msg *m)
  401. {
  402. msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1);
  403. }
  404. static inline u32 msg_lookup_scope(struct tipc_msg *m)
  405. {
  406. return msg_bits(m, 1, 19, 0x3);
  407. }
  408. static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n)
  409. {
  410. msg_set_bits(m, 1, 19, 0x3, n);
  411. }
  412. static inline u16 msg_bcast_ack(struct tipc_msg *m)
  413. {
  414. return msg_bits(m, 1, 0, 0xffff);
  415. }
  416. static inline void msg_set_bcast_ack(struct tipc_msg *m, u16 n)
  417. {
  418. msg_set_bits(m, 1, 0, 0xffff, n);
  419. }
  420. /* Note: reusing bits in word 1 for ACTIVATE_MSG only, to re-synch
  421. * link peer session number
  422. */
  423. static inline bool msg_dest_session_valid(struct tipc_msg *m)
  424. {
  425. return msg_bits(m, 1, 16, 0x1);
  426. }
  427. static inline void msg_set_dest_session_valid(struct tipc_msg *m, bool valid)
  428. {
  429. msg_set_bits(m, 1, 16, 0x1, valid);
  430. }
  431. static inline u16 msg_dest_session(struct tipc_msg *m)
  432. {
  433. return msg_bits(m, 1, 0, 0xffff);
  434. }
  435. static inline void msg_set_dest_session(struct tipc_msg *m, u16 n)
  436. {
  437. msg_set_bits(m, 1, 0, 0xffff, n);
  438. }
  439. /*
  440. * Word 2
  441. */
  442. static inline u16 msg_ack(struct tipc_msg *m)
  443. {
  444. return msg_bits(m, 2, 16, 0xffff);
  445. }
  446. static inline void msg_set_ack(struct tipc_msg *m, u16 n)
  447. {
  448. msg_set_bits(m, 2, 16, 0xffff, n);
  449. }
  450. static inline u16 msg_seqno(struct tipc_msg *m)
  451. {
  452. return msg_bits(m, 2, 0, 0xffff);
  453. }
  454. static inline void msg_set_seqno(struct tipc_msg *m, u16 n)
  455. {
  456. msg_set_bits(m, 2, 0, 0xffff, n);
  457. }
  458. /*
  459. * Words 3-10
  460. */
  461. static inline u32 msg_importance(struct tipc_msg *m)
  462. {
  463. int usr = msg_user(m);
  464. if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m)))
  465. return usr;
  466. if ((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER))
  467. return msg_bits(m, 9, 0, 0x7);
  468. return TIPC_SYSTEM_IMPORTANCE;
  469. }
  470. static inline void msg_set_importance(struct tipc_msg *m, u32 i)
  471. {
  472. int usr = msg_user(m);
  473. if (likely((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER)))
  474. msg_set_bits(m, 9, 0, 0x7, i);
  475. else if (i < TIPC_SYSTEM_IMPORTANCE)
  476. msg_set_user(m, i);
  477. else
  478. pr_warn("Trying to set illegal importance in message\n");
  479. }
  480. static inline u32 msg_prevnode(struct tipc_msg *m)
  481. {
  482. return msg_word(m, 3);
  483. }
  484. static inline void msg_set_prevnode(struct tipc_msg *m, u32 a)
  485. {
  486. msg_set_word(m, 3, a);
  487. }
  488. static inline u32 msg_origport(struct tipc_msg *m)
  489. {
  490. if (msg_user(m) == MSG_FRAGMENTER)
  491. m = msg_inner_hdr(m);
  492. return msg_word(m, 4);
  493. }
  494. static inline void msg_set_origport(struct tipc_msg *m, u32 p)
  495. {
  496. msg_set_word(m, 4, p);
  497. }
  498. static inline u16 msg_named_seqno(struct tipc_msg *m)
  499. {
  500. return msg_bits(m, 4, 0, 0xffff);
  501. }
  502. static inline void msg_set_named_seqno(struct tipc_msg *m, u16 n)
  503. {
  504. msg_set_bits(m, 4, 0, 0xffff, n);
  505. }
  506. static inline u32 msg_destport(struct tipc_msg *m)
  507. {
  508. return msg_word(m, 5);
  509. }
  510. static inline void msg_set_destport(struct tipc_msg *m, u32 p)
  511. {
  512. msg_set_word(m, 5, p);
  513. }
  514. static inline u32 msg_mc_netid(struct tipc_msg *m)
  515. {
  516. return msg_word(m, 5);
  517. }
  518. static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p)
  519. {
  520. msg_set_word(m, 5, p);
  521. }
  522. static inline int msg_short(struct tipc_msg *m)
  523. {
  524. return msg_hdr_sz(m) == SHORT_H_SIZE;
  525. }
  526. static inline u32 msg_orignode(struct tipc_msg *m)
  527. {
  528. if (likely(msg_short(m)))
  529. return msg_prevnode(m);
  530. return msg_word(m, 6);
  531. }
  532. static inline void msg_set_orignode(struct tipc_msg *m, u32 a)
  533. {
  534. msg_set_word(m, 6, a);
  535. }
  536. static inline u32 msg_destnode(struct tipc_msg *m)
  537. {
  538. return msg_word(m, 7);
  539. }
  540. static inline void msg_set_destnode(struct tipc_msg *m, u32 a)
  541. {
  542. msg_set_word(m, 7, a);
  543. }
  544. static inline u32 msg_nametype(struct tipc_msg *m)
  545. {
  546. return msg_word(m, 8);
  547. }
  548. static inline void msg_set_nametype(struct tipc_msg *m, u32 n)
  549. {
  550. msg_set_word(m, 8, n);
  551. }
  552. static inline u32 msg_nameinst(struct tipc_msg *m)
  553. {
  554. return msg_word(m, 9);
  555. }
  556. static inline u32 msg_namelower(struct tipc_msg *m)
  557. {
  558. return msg_nameinst(m);
  559. }
  560. static inline void msg_set_namelower(struct tipc_msg *m, u32 n)
  561. {
  562. msg_set_word(m, 9, n);
  563. }
  564. static inline void msg_set_nameinst(struct tipc_msg *m, u32 n)
  565. {
  566. msg_set_namelower(m, n);
  567. }
  568. static inline u32 msg_nameupper(struct tipc_msg *m)
  569. {
  570. return msg_word(m, 10);
  571. }
  572. static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)
  573. {
  574. msg_set_word(m, 10, n);
  575. }
  576. /*
  577. * Constants and routines used to read and write TIPC internal message headers
  578. */
  579. /*
  580. * Connection management protocol message types
  581. */
  582. #define CONN_PROBE 0
  583. #define CONN_PROBE_REPLY 1
  584. #define CONN_ACK 2
  585. /*
  586. * Name distributor message types
  587. */
  588. #define PUBLICATION 0
  589. #define WITHDRAWAL 1
  590. /*
  591. * Segmentation message types
  592. */
  593. #define FIRST_FRAGMENT 0
  594. #define FRAGMENT 1
  595. #define LAST_FRAGMENT 2
  596. /*
  597. * Link management protocol message types
  598. */
  599. #define STATE_MSG 0
  600. #define RESET_MSG 1
  601. #define ACTIVATE_MSG 2
  602. /*
  603. * Changeover tunnel message types
  604. */
  605. #define SYNCH_MSG 0
  606. #define FAILOVER_MSG 1
  607. /*
  608. * Config protocol message types
  609. */
  610. #define DSC_REQ_MSG 0
  611. #define DSC_RESP_MSG 1
  612. #define DSC_TRIAL_MSG 2
  613. #define DSC_TRIAL_FAIL_MSG 3
  614. /*
  615. * Group protocol message types
  616. */
  617. #define GRP_JOIN_MSG 0
  618. #define GRP_LEAVE_MSG 1
  619. #define GRP_ADV_MSG 2
  620. #define GRP_ACK_MSG 3
  621. #define GRP_RECLAIM_MSG 4
  622. #define GRP_REMIT_MSG 5
  623. /* Crypto message types */
  624. #define KEY_DISTR_MSG 0
  625. /*
  626. * Word 1
  627. */
  628. static inline u32 msg_seq_gap(struct tipc_msg *m)
  629. {
  630. return msg_bits(m, 1, 16, 0x1fff);
  631. }
  632. static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)
  633. {
  634. msg_set_bits(m, 1, 16, 0x1fff, n);
  635. }
  636. static inline u32 msg_node_sig(struct tipc_msg *m)
  637. {
  638. return msg_bits(m, 1, 0, 0xffff);
  639. }
  640. static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)
  641. {
  642. msg_set_bits(m, 1, 0, 0xffff, n);
  643. }
  644. static inline u32 msg_node_capabilities(struct tipc_msg *m)
  645. {
  646. return msg_bits(m, 1, 15, 0x1fff);
  647. }
  648. static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n)
  649. {
  650. msg_set_bits(m, 1, 15, 0x1fff, n);
  651. }
  652. /*
  653. * Word 2
  654. */
  655. static inline u32 msg_dest_domain(struct tipc_msg *m)
  656. {
  657. return msg_word(m, 2);
  658. }
  659. static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)
  660. {
  661. msg_set_word(m, 2, n);
  662. }
  663. static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)
  664. {
  665. msg_set_bits(m, 2, 16, 0xffff, n);
  666. }
  667. static inline u32 msg_bcgap_to(struct tipc_msg *m)
  668. {
  669. return msg_bits(m, 2, 0, 0xffff);
  670. }
  671. static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)
  672. {
  673. msg_set_bits(m, 2, 0, 0xffff, n);
  674. }
  675. /*
  676. * Word 4
  677. */
  678. static inline u32 msg_last_bcast(struct tipc_msg *m)
  679. {
  680. return msg_bits(m, 4, 16, 0xffff);
  681. }
  682. static inline u32 msg_bc_snd_nxt(struct tipc_msg *m)
  683. {
  684. return msg_last_bcast(m) + 1;
  685. }
  686. static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)
  687. {
  688. msg_set_bits(m, 4, 16, 0xffff, n);
  689. }
  690. static inline u32 msg_nof_fragms(struct tipc_msg *m)
  691. {
  692. return msg_bits(m, 4, 0, 0xffff);
  693. }
  694. static inline void msg_set_nof_fragms(struct tipc_msg *m, u32 n)
  695. {
  696. msg_set_bits(m, 4, 0, 0xffff, n);
  697. }
  698. static inline u32 msg_fragm_no(struct tipc_msg *m)
  699. {
  700. return msg_bits(m, 4, 16, 0xffff);
  701. }
  702. static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)
  703. {
  704. msg_set_bits(m, 4, 16, 0xffff, n);
  705. }
  706. static inline u16 msg_next_sent(struct tipc_msg *m)
  707. {
  708. return msg_bits(m, 4, 0, 0xffff);
  709. }
  710. static inline void msg_set_next_sent(struct tipc_msg *m, u16 n)
  711. {
  712. msg_set_bits(m, 4, 0, 0xffff, n);
  713. }
  714. static inline u32 msg_bc_netid(struct tipc_msg *m)
  715. {
  716. return msg_word(m, 4);
  717. }
  718. static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)
  719. {
  720. msg_set_word(m, 4, id);
  721. }
  722. static inline u32 msg_link_selector(struct tipc_msg *m)
  723. {
  724. if (msg_user(m) == MSG_FRAGMENTER)
  725. m = (void *)msg_data(m);
  726. return msg_bits(m, 4, 0, 1);
  727. }
  728. /*
  729. * Word 5
  730. */
  731. static inline u16 msg_session(struct tipc_msg *m)
  732. {
  733. return msg_bits(m, 5, 16, 0xffff);
  734. }
  735. static inline void msg_set_session(struct tipc_msg *m, u16 n)
  736. {
  737. msg_set_bits(m, 5, 16, 0xffff, n);
  738. }
  739. static inline u32 msg_probe(struct tipc_msg *m)
  740. {
  741. return msg_bits(m, 5, 0, 1);
  742. }
  743. static inline void msg_set_probe(struct tipc_msg *m, u32 val)
  744. {
  745. msg_set_bits(m, 5, 0, 1, val);
  746. }
  747. static inline char msg_net_plane(struct tipc_msg *m)
  748. {
  749. return msg_bits(m, 5, 1, 7) + 'A';
  750. }
  751. static inline void msg_set_net_plane(struct tipc_msg *m, char n)
  752. {
  753. msg_set_bits(m, 5, 1, 7, (n - 'A'));
  754. }
  755. static inline u32 msg_linkprio(struct tipc_msg *m)
  756. {
  757. return msg_bits(m, 5, 4, 0x1f);
  758. }
  759. static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)
  760. {
  761. msg_set_bits(m, 5, 4, 0x1f, n);
  762. }
  763. static inline u32 msg_bearer_id(struct tipc_msg *m)
  764. {
  765. return msg_bits(m, 5, 9, 0x7);
  766. }
  767. static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)
  768. {
  769. msg_set_bits(m, 5, 9, 0x7, n);
  770. }
  771. static inline u32 msg_redundant_link(struct tipc_msg *m)
  772. {
  773. return msg_bits(m, 5, 12, 0x1);
  774. }
  775. static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)
  776. {
  777. msg_set_bits(m, 5, 12, 0x1, r);
  778. }
  779. static inline u32 msg_peer_stopping(struct tipc_msg *m)
  780. {
  781. return msg_bits(m, 5, 13, 0x1);
  782. }
  783. static inline void msg_set_peer_stopping(struct tipc_msg *m, u32 s)
  784. {
  785. msg_set_bits(m, 5, 13, 0x1, s);
  786. }
  787. static inline bool msg_bc_ack_invalid(struct tipc_msg *m)
  788. {
  789. switch (msg_user(m)) {
  790. case BCAST_PROTOCOL:
  791. case NAME_DISTRIBUTOR:
  792. case LINK_PROTOCOL:
  793. return msg_bits(m, 5, 14, 0x1);
  794. default:
  795. return false;
  796. }
  797. }
  798. static inline void msg_set_bc_ack_invalid(struct tipc_msg *m, bool invalid)
  799. {
  800. msg_set_bits(m, 5, 14, 0x1, invalid);
  801. }
  802. static inline char *msg_media_addr(struct tipc_msg *m)
  803. {
  804. return (char *)&m->hdr[TIPC_MEDIA_INFO_OFFSET];
  805. }
  806. static inline u32 msg_bc_gap(struct tipc_msg *m)
  807. {
  808. return msg_bits(m, 8, 0, 0x3ff);
  809. }
  810. static inline void msg_set_bc_gap(struct tipc_msg *m, u32 n)
  811. {
  812. msg_set_bits(m, 8, 0, 0x3ff, n);
  813. }
  814. /*
  815. * Word 9
  816. */
  817. static inline u16 msg_msgcnt(struct tipc_msg *m)
  818. {
  819. return msg_bits(m, 9, 16, 0xffff);
  820. }
  821. static inline void msg_set_msgcnt(struct tipc_msg *m, u16 n)
  822. {
  823. msg_set_bits(m, 9, 16, 0xffff, n);
  824. }
  825. static inline u16 msg_syncpt(struct tipc_msg *m)
  826. {
  827. return msg_bits(m, 9, 16, 0xffff);
  828. }
  829. static inline void msg_set_syncpt(struct tipc_msg *m, u16 n)
  830. {
  831. msg_set_bits(m, 9, 16, 0xffff, n);
  832. }
  833. static inline u32 msg_conn_ack(struct tipc_msg *m)
  834. {
  835. return msg_bits(m, 9, 16, 0xffff);
  836. }
  837. static inline void msg_set_conn_ack(struct tipc_msg *m, u32 n)
  838. {
  839. msg_set_bits(m, 9, 16, 0xffff, n);
  840. }
  841. static inline u16 msg_adv_win(struct tipc_msg *m)
  842. {
  843. return msg_bits(m, 9, 0, 0xffff);
  844. }
  845. static inline void msg_set_adv_win(struct tipc_msg *m, u16 n)
  846. {
  847. msg_set_bits(m, 9, 0, 0xffff, n);
  848. }
  849. static inline u32 msg_max_pkt(struct tipc_msg *m)
  850. {
  851. return msg_bits(m, 9, 16, 0xffff) * 4;
  852. }
  853. static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)
  854. {
  855. msg_set_bits(m, 9, 16, 0xffff, (n / 4));
  856. }
  857. static inline u32 msg_link_tolerance(struct tipc_msg *m)
  858. {
  859. return msg_bits(m, 9, 0, 0xffff);
  860. }
  861. static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)
  862. {
  863. msg_set_bits(m, 9, 0, 0xffff, n);
  864. }
  865. static inline u16 msg_grp_bc_syncpt(struct tipc_msg *m)
  866. {
  867. return msg_bits(m, 9, 16, 0xffff);
  868. }
  869. static inline void msg_set_grp_bc_syncpt(struct tipc_msg *m, u16 n)
  870. {
  871. msg_set_bits(m, 9, 16, 0xffff, n);
  872. }
  873. static inline u16 msg_grp_bc_acked(struct tipc_msg *m)
  874. {
  875. return msg_bits(m, 9, 16, 0xffff);
  876. }
  877. static inline void msg_set_grp_bc_acked(struct tipc_msg *m, u16 n)
  878. {
  879. msg_set_bits(m, 9, 16, 0xffff, n);
  880. }
  881. static inline u16 msg_grp_remitted(struct tipc_msg *m)
  882. {
  883. return msg_bits(m, 9, 16, 0xffff);
  884. }
  885. static inline void msg_set_grp_remitted(struct tipc_msg *m, u16 n)
  886. {
  887. msg_set_bits(m, 9, 16, 0xffff, n);
  888. }
  889. /* Word 10
  890. */
  891. static inline u16 msg_grp_evt(struct tipc_msg *m)
  892. {
  893. return msg_bits(m, 10, 0, 0x3);
  894. }
  895. static inline void msg_set_grp_evt(struct tipc_msg *m, int n)
  896. {
  897. msg_set_bits(m, 10, 0, 0x3, n);
  898. }
  899. static inline u16 msg_grp_bc_ack_req(struct tipc_msg *m)
  900. {
  901. return msg_bits(m, 10, 0, 0x1);
  902. }
  903. static inline void msg_set_grp_bc_ack_req(struct tipc_msg *m, bool n)
  904. {
  905. msg_set_bits(m, 10, 0, 0x1, n);
  906. }
  907. static inline u16 msg_grp_bc_seqno(struct tipc_msg *m)
  908. {
  909. return msg_bits(m, 10, 16, 0xffff);
  910. }
  911. static inline void msg_set_grp_bc_seqno(struct tipc_msg *m, u32 n)
  912. {
  913. msg_set_bits(m, 10, 16, 0xffff, n);
  914. }
  915. static inline bool msg_peer_link_is_up(struct tipc_msg *m)
  916. {
  917. if (likely(msg_user(m) != LINK_PROTOCOL))
  918. return true;
  919. if (msg_type(m) == STATE_MSG)
  920. return true;
  921. return false;
  922. }
  923. static inline bool msg_peer_node_is_up(struct tipc_msg *m)
  924. {
  925. if (msg_peer_link_is_up(m))
  926. return true;
  927. return msg_redundant_link(m);
  928. }
  929. static inline bool msg_is_reset(struct tipc_msg *hdr)
  930. {
  931. return (msg_user(hdr) == LINK_PROTOCOL) && (msg_type(hdr) == RESET_MSG);
  932. }
  933. /* Word 13
  934. */
  935. static inline void msg_set_peer_net_hash(struct tipc_msg *m, u32 n)
  936. {
  937. msg_set_word(m, 13, n);
  938. }
  939. static inline u32 msg_peer_net_hash(struct tipc_msg *m)
  940. {
  941. return msg_word(m, 13);
  942. }
  943. /* Word 14
  944. */
  945. static inline u32 msg_sugg_node_addr(struct tipc_msg *m)
  946. {
  947. return msg_word(m, 14);
  948. }
  949. static inline void msg_set_sugg_node_addr(struct tipc_msg *m, u32 n)
  950. {
  951. msg_set_word(m, 14, n);
  952. }
  953. static inline void msg_set_node_id(struct tipc_msg *hdr, u8 *id)
  954. {
  955. memcpy(msg_data(hdr), id, 16);
  956. }
  957. static inline u8 *msg_node_id(struct tipc_msg *hdr)
  958. {
  959. return (u8 *)msg_data(hdr);
  960. }
  961. struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp);
  962. bool tipc_msg_validate(struct sk_buff **_skb);
  963. bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err);
  964. void tipc_skb_reject(struct net *net, int err, struct sk_buff *skb,
  965. struct sk_buff_head *xmitq);
  966. void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type,
  967. u32 hsize, u32 destnode);
  968. struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,
  969. uint data_sz, u32 dnode, u32 onode,
  970. u32 dport, u32 oport, int errcode);
  971. int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf);
  972. bool tipc_msg_try_bundle(struct sk_buff *tskb, struct sk_buff **skb, u32 mss,
  973. u32 dnode, bool *new_bundle);
  974. bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos);
  975. int tipc_msg_fragment(struct sk_buff *skb, const struct tipc_msg *hdr,
  976. int pktmax, struct sk_buff_head *frags);
  977. int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,
  978. int offset, int dsz, int mtu, struct sk_buff_head *list);
  979. int tipc_msg_append(struct tipc_msg *hdr, struct msghdr *m, int dlen,
  980. int mss, struct sk_buff_head *txq);
  981. bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err);
  982. bool tipc_msg_assemble(struct sk_buff_head *list);
  983. bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq);
  984. bool tipc_msg_pskb_copy(u32 dst, struct sk_buff_head *msg,
  985. struct sk_buff_head *cpy);
  986. bool __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno,
  987. struct sk_buff *skb);
  988. bool tipc_msg_skb_clone(struct sk_buff_head *msg, struct sk_buff_head *cpy);
  989. static inline u16 buf_seqno(struct sk_buff *skb)
  990. {
  991. return msg_seqno(buf_msg(skb));
  992. }
  993. static inline int buf_roundup_len(struct sk_buff *skb)
  994. {
  995. return (skb->len / 1024 + 1) * 1024;
  996. }
  997. /* tipc_skb_peek(): peek and reserve first buffer in list
  998. * @list: list to be peeked in
  999. * Returns pointer to first buffer in list, if any
  1000. */
  1001. static inline struct sk_buff *tipc_skb_peek(struct sk_buff_head *list,
  1002. spinlock_t *lock)
  1003. {
  1004. struct sk_buff *skb;
  1005. spin_lock_bh(lock);
  1006. skb = skb_peek(list);
  1007. if (skb)
  1008. skb_get(skb);
  1009. spin_unlock_bh(lock);
  1010. return skb;
  1011. }
  1012. /* tipc_skb_peek_port(): find a destination port, ignoring all destinations
  1013. * up to and including 'filter'.
  1014. * Note: ignoring previously tried destinations minimizes the risk of
  1015. * contention on the socket lock
  1016. * @list: list to be peeked in
  1017. * @filter: last destination to be ignored from search
  1018. * Returns a destination port number, of applicable.
  1019. */
  1020. static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter)
  1021. {
  1022. struct sk_buff *skb;
  1023. u32 dport = 0;
  1024. bool ignore = true;
  1025. spin_lock_bh(&list->lock);
  1026. skb_queue_walk(list, skb) {
  1027. dport = msg_destport(buf_msg(skb));
  1028. if (!filter || skb_queue_is_last(list, skb))
  1029. break;
  1030. if (dport == filter)
  1031. ignore = false;
  1032. else if (!ignore)
  1033. break;
  1034. }
  1035. spin_unlock_bh(&list->lock);
  1036. return dport;
  1037. }
  1038. /* tipc_skb_dequeue(): unlink first buffer with dest 'dport' from list
  1039. * @list: list to be unlinked from
  1040. * @dport: selection criteria for buffer to unlink
  1041. */
  1042. static inline struct sk_buff *tipc_skb_dequeue(struct sk_buff_head *list,
  1043. u32 dport)
  1044. {
  1045. struct sk_buff *_skb, *tmp, *skb = NULL;
  1046. spin_lock_bh(&list->lock);
  1047. skb_queue_walk_safe(list, _skb, tmp) {
  1048. if (msg_destport(buf_msg(_skb)) == dport) {
  1049. __skb_unlink(_skb, list);
  1050. skb = _skb;
  1051. break;
  1052. }
  1053. }
  1054. spin_unlock_bh(&list->lock);
  1055. return skb;
  1056. }
  1057. /* tipc_skb_queue_splice_tail - append an skb list to lock protected list
  1058. * @list: the new list to append. Not lock protected
  1059. * @head: target list. Lock protected.
  1060. */
  1061. static inline void tipc_skb_queue_splice_tail(struct sk_buff_head *list,
  1062. struct sk_buff_head *head)
  1063. {
  1064. spin_lock_bh(&head->lock);
  1065. skb_queue_splice_tail(list, head);
  1066. spin_unlock_bh(&head->lock);
  1067. }
  1068. /* tipc_skb_queue_splice_tail_init - merge two lock protected skb lists
  1069. * @list: the new list to add. Lock protected. Will be reinitialized
  1070. * @head: target list. Lock protected.
  1071. */
  1072. static inline void tipc_skb_queue_splice_tail_init(struct sk_buff_head *list,
  1073. struct sk_buff_head *head)
  1074. {
  1075. struct sk_buff_head tmp;
  1076. __skb_queue_head_init(&tmp);
  1077. spin_lock_bh(&list->lock);
  1078. skb_queue_splice_tail_init(list, &tmp);
  1079. spin_unlock_bh(&list->lock);
  1080. tipc_skb_queue_splice_tail(&tmp, head);
  1081. }
  1082. /* __tipc_skb_dequeue() - dequeue the head skb according to expected seqno
  1083. * @list: list to be dequeued from
  1084. * @seqno: seqno of the expected msg
  1085. *
  1086. * returns skb dequeued from the list if its seqno is less than or equal to
  1087. * the expected one, otherwise the skb is still hold
  1088. *
  1089. * Note: must be used with appropriate locks held only
  1090. */
  1091. static inline struct sk_buff *__tipc_skb_dequeue(struct sk_buff_head *list,
  1092. u16 seqno)
  1093. {
  1094. struct sk_buff *skb = skb_peek(list);
  1095. if (skb && less_eq(buf_seqno(skb), seqno)) {
  1096. __skb_unlink(skb, list);
  1097. return skb;
  1098. }
  1099. return NULL;
  1100. }
  1101. #endif