git.openwrt.org Git - openwrt/staging/blogic.git/blob

1 /*

2 * net/tipc/msg.h: Include file for TIPC message header routines

3 *

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 */

37 #ifndef _TIPC_MSG_H

38 #define _TIPC_MSG_H

40 #include <linux/tipc.h>

41 #include "core.h"

43 /*

44 * Constants and routines used to read and write TIPC payload message headers

45 *

46 * Note: Some items are also used with TIPC internal message headers

47 */

48 #define TIPC_VERSION 2

49 struct plist;

51 /*

52 * Payload message users are defined in TIPC's public API:

53 * - TIPC_LOW_IMPORTANCE

54 * - TIPC_MEDIUM_IMPORTANCE

55 * - TIPC_HIGH_IMPORTANCE

56 * - TIPC_CRITICAL_IMPORTANCE

57 */

58 #define TIPC_SYSTEM_IMPORTANCE 4

61 /*

62 * Payload message types

63 */

64 #define TIPC_CONN_MSG 0

65 #define TIPC_MCAST_MSG 1

66 #define TIPC_NAMED_MSG 2

67 #define TIPC_DIRECT_MSG 3

69 /*

70 * Internal message users

71 */

72 #define BCAST_PROTOCOL 5

73 #define MSG_BUNDLER 6

74 #define LINK_PROTOCOL 7

75 #define CONN_MANAGER 8

76 #define TUNNEL_PROTOCOL 10

77 #define NAME_DISTRIBUTOR 11

78 #define MSG_FRAGMENTER 12

79 #define LINK_CONFIG 13

80 #define SOCK_WAKEUP 14 /* pseudo user */

82 /*

83 * Message header sizes

84 */

85 #define SHORT_H_SIZE 24 /* In-cluster basic payload message */

86 #define BASIC_H_SIZE 32 /* Basic payload message */

87 #define NAMED_H_SIZE 40 /* Named payload message */

88 #define MCAST_H_SIZE 44 /* Multicast 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 */

93 #define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE)

95 #define TIPC_MEDIA_INFO_OFFSET 5

97 /**

98 * TIPC message buffer code

99 *

100 * TIPC message buffer headroom reserves space for the worst-case

101 * link-level device header (in case the message is sent off-node).

102 *

103 * Note: Headroom should be a multiple of 4 to ensure the TIPC header fields

104 * are word aligned for quicker access

105 */

106 #define BUF_HEADROOM (LL_MAX_HEADER + 48)

107

108 struct tipc_skb_cb {

109 void *handle;

110 struct sk_buff *tail;

111 bool validated;

112 bool wakeup_pending;

113 u16 chain_sz;

114 u16 chain_imp;

115 u16 ackers;

116 };

117

118 #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0]))

119

120 struct tipc_msg {

121 __be32 hdr[15];

122 };

123

124 static inline struct tipc_msg *buf_msg(struct sk_buff *skb)

125 {

126 return (struct tipc_msg *)skb->data;

127 }

128

129 static inline u32 msg_word(struct tipc_msg *m, u32 pos)

130 {

131 return ntohl(m->hdr[pos]);

132 }

133

134 static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val)

135 {

136 m->hdr[w] = htonl(val);

137 }

138

139 static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)

140 {

141 return (msg_word(m, w) >> pos) & mask;

142 }

143

144 static inline void msg_set_bits(struct tipc_msg *m, u32 w,

145 u32 pos, u32 mask, u32 val)

146 {

147 val = (val & mask) << pos;

148 mask = mask << pos;

149 m->hdr[w] &= ~htonl(mask);

150 m->hdr[w] |= htonl(val);

151 }

152

153 static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b)

154 {

155 u32 temp = msg->hdr[a];

156

157 msg->hdr[a] = msg->hdr[b];

158 msg->hdr[b] = temp;

159 }

160

161 /*

162 * Word 0

163 */

164 static inline u32 msg_version(struct tipc_msg *m)

165 {

166 return msg_bits(m, 0, 29, 7);

167 }

168

169 static inline void msg_set_version(struct tipc_msg *m)

170 {

171 msg_set_bits(m, 0, 29, 7, TIPC_VERSION);

172 }

173

174 static inline u32 msg_user(struct tipc_msg *m)

175 {

176 return msg_bits(m, 0, 25, 0xf);

177 }

178

179 static inline u32 msg_isdata(struct tipc_msg *m)

180 {

181 return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE;

182 }

183

184 static inline void msg_set_user(struct tipc_msg *m, u32 n)

185 {

186 msg_set_bits(m, 0, 25, 0xf, n);

187 }

188

189 static inline u32 msg_hdr_sz(struct tipc_msg *m)

190 {

191 return msg_bits(m, 0, 21, 0xf) << 2;

192 }

193

194 static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n)

195 {

196 msg_set_bits(m, 0, 21, 0xf, n>>2);

197 }

198

199 static inline u32 msg_size(struct tipc_msg *m)

200 {

201 return msg_bits(m, 0, 0, 0x1ffff);

202 }

203

204 static inline u32 msg_data_sz(struct tipc_msg *m)

205 {

206 return msg_size(m) - msg_hdr_sz(m);

207 }

208

209 static inline int msg_non_seq(struct tipc_msg *m)

210 {

211 return msg_bits(m, 0, 20, 1);

212 }

213

214 static inline void msg_set_non_seq(struct tipc_msg *m, u32 n)

215 {

216 msg_set_bits(m, 0, 20, 1, n);

217 }

218

219 static inline int msg_dest_droppable(struct tipc_msg *m)

220 {

221 return msg_bits(m, 0, 19, 1);

222 }

223

224 static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d)

225 {

226 msg_set_bits(m, 0, 19, 1, d);

227 }

228

229 static inline int msg_src_droppable(struct tipc_msg *m)

230 {

231 return msg_bits(m, 0, 18, 1);

232 }

233

234 static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d)

235 {

236 msg_set_bits(m, 0, 18, 1, d);

237 }

238

239 static inline void msg_set_size(struct tipc_msg *m, u32 sz)

240 {

241 m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz);

242 }

243

244 static inline unchar *msg_data(struct tipc_msg *m)

245 {

246 return ((unchar *)m) + msg_hdr_sz(m);

247 }

248

249 static inline struct tipc_msg *msg_get_wrapped(struct tipc_msg *m)

250 {

251 return (struct tipc_msg *)msg_data(m);

252 }

253

254 /*

255 * Word 1

256 */

257 static inline u32 msg_type(struct tipc_msg *m)

258 {

259 return msg_bits(m, 1, 29, 0x7);

260 }

261

262 static inline void msg_set_type(struct tipc_msg *m, u32 n)

263 {

264 msg_set_bits(m, 1, 29, 0x7, n);

265 }

266

267 static inline u32 msg_named(struct tipc_msg *m)

268 {

269 return msg_type(m) == TIPC_NAMED_MSG;

270 }

271

272 static inline u32 msg_mcast(struct tipc_msg *m)

273 {

274 return msg_type(m) == TIPC_MCAST_MSG;

275 }

276

277 static inline u32 msg_connected(struct tipc_msg *m)

278 {

279 return msg_type(m) == TIPC_CONN_MSG;

280 }

281

282 static inline u32 msg_errcode(struct tipc_msg *m)

283 {

284 return msg_bits(m, 1, 25, 0xf);

285 }

286

287 static inline void msg_set_errcode(struct tipc_msg *m, u32 err)

288 {

289 msg_set_bits(m, 1, 25, 0xf, err);

290 }

291

292 static inline u32 msg_reroute_cnt(struct tipc_msg *m)

293 {

294 return msg_bits(m, 1, 21, 0xf);

295 }

296

297 static inline void msg_incr_reroute_cnt(struct tipc_msg *m)

298 {

299 msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1);

300 }

301

302 static inline void msg_reset_reroute_cnt(struct tipc_msg *m)

303 {

304 msg_set_bits(m, 1, 21, 0xf, 0);

305 }

306

307 static inline u32 msg_lookup_scope(struct tipc_msg *m)

308 {

309 return msg_bits(m, 1, 19, 0x3);

310 }

311

312 static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n)

313 {

314 msg_set_bits(m, 1, 19, 0x3, n);

315 }

316

317 static inline u16 msg_bcast_ack(struct tipc_msg *m)

318 {

319 return msg_bits(m, 1, 0, 0xffff);

320 }

321

322 static inline void msg_set_bcast_ack(struct tipc_msg *m, u16 n)

323 {

324 msg_set_bits(m, 1, 0, 0xffff, n);

325 }

326

327

328 /*

329 * Word 2

330 */

331 static inline u16 msg_ack(struct tipc_msg *m)

332 {

333 return msg_bits(m, 2, 16, 0xffff);

334 }

335

336 static inline void msg_set_ack(struct tipc_msg *m, u16 n)

337 {

338 msg_set_bits(m, 2, 16, 0xffff, n);

339 }

340

341 static inline u16 msg_seqno(struct tipc_msg *m)

342 {

343 return msg_bits(m, 2, 0, 0xffff);

344 }

345

346 static inline void msg_set_seqno(struct tipc_msg *m, u16 n)

347 {

348 msg_set_bits(m, 2, 0, 0xffff, n);

349 }

350

351 /*

352 * Words 3-10

353 */

354 static inline u32 msg_importance(struct tipc_msg *m)

355 {

356 int usr = msg_user(m);

357

358 if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m)))

359 return usr;

360 if ((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER))

361 return msg_bits(m, 9, 0, 0x7);

362 return TIPC_SYSTEM_IMPORTANCE;

363 }

364

365 static inline void msg_set_importance(struct tipc_msg *m, u32 i)

366 {

367 int usr = msg_user(m);

368

369 if (likely((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER)))

370 msg_set_bits(m, 9, 0, 0x7, i);

371 else if (i < TIPC_SYSTEM_IMPORTANCE)

372 msg_set_user(m, i);

373 else

374 pr_warn("Trying to set illegal importance in message\n");

375 }

376

377 static inline u32 msg_prevnode(struct tipc_msg *m)

378 {

379 return msg_word(m, 3);

380 }

381

382 static inline void msg_set_prevnode(struct tipc_msg *m, u32 a)

383 {

384 msg_set_word(m, 3, a);

385 }

386

387 static inline u32 msg_origport(struct tipc_msg *m)

388 {

389 if (msg_user(m) == MSG_FRAGMENTER)

390 m = msg_get_wrapped(m);

391 return msg_word(m, 4);

392 }

393

394 static inline void msg_set_origport(struct tipc_msg *m, u32 p)

395 {

396 msg_set_word(m, 4, p);

397 }

398

399 static inline u32 msg_destport(struct tipc_msg *m)

400 {

401 return msg_word(m, 5);

402 }

403

404 static inline void msg_set_destport(struct tipc_msg *m, u32 p)

405 {

406 msg_set_word(m, 5, p);

407 }

408

409 static inline u32 msg_mc_netid(struct tipc_msg *m)

410 {

411 return msg_word(m, 5);

412 }

413

414 static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p)

415 {

416 msg_set_word(m, 5, p);

417 }

418

419 static inline int msg_short(struct tipc_msg *m)

420 {

421 return msg_hdr_sz(m) == SHORT_H_SIZE;

422 }

423

424 static inline u32 msg_orignode(struct tipc_msg *m)

425 {

426 if (likely(msg_short(m)))

427 return msg_prevnode(m);

428 return msg_word(m, 6);

429 }

430

431 static inline void msg_set_orignode(struct tipc_msg *m, u32 a)

432 {

433 msg_set_word(m, 6, a);

434 }

435

436 static inline u32 msg_destnode(struct tipc_msg *m)

437 {

438 return msg_word(m, 7);

439 }

440

441 static inline void msg_set_destnode(struct tipc_msg *m, u32 a)

442 {

443 msg_set_word(m, 7, a);

444 }

445

446 static inline u32 msg_nametype(struct tipc_msg *m)

447 {

448 return msg_word(m, 8);

449 }

450

451 static inline void msg_set_nametype(struct tipc_msg *m, u32 n)

452 {

453 msg_set_word(m, 8, n);

454 }

455

456 static inline u32 msg_nameinst(struct tipc_msg *m)

457 {

458 return msg_word(m, 9);

459 }

460

461 static inline u32 msg_namelower(struct tipc_msg *m)

462 {

463 return msg_nameinst(m);

464 }

465

466 static inline void msg_set_namelower(struct tipc_msg *m, u32 n)

467 {

468 msg_set_word(m, 9, n);

469 }

470

471 static inline void msg_set_nameinst(struct tipc_msg *m, u32 n)

472 {

473 msg_set_namelower(m, n);

474 }

475

476 static inline u32 msg_nameupper(struct tipc_msg *m)

477 {

478 return msg_word(m, 10);

479 }

480

481 static inline void msg_set_nameupper(struct tipc_msg *m, u32 n)

482 {

483 msg_set_word(m, 10, n);

484 }

485

486 /*

487 * Constants and routines used to read and write TIPC internal message headers

488 */

489

490 /*

491 * Connection management protocol message types

492 */

493 #define CONN_PROBE 0

494 #define CONN_PROBE_REPLY 1

495 #define CONN_ACK 2

496

497 /*

498 * Name distributor message types

499 */

500 #define PUBLICATION 0

501 #define WITHDRAWAL 1

502

503 /*

504 * Segmentation message types

505 */

506 #define FIRST_FRAGMENT 0

507 #define FRAGMENT 1

508 #define LAST_FRAGMENT 2

509

510 /*

511 * Link management protocol message types

512 */

513 #define STATE_MSG 0

514 #define RESET_MSG 1

515 #define ACTIVATE_MSG 2

516

517 /*

518 * Changeover tunnel message types

519 */

520 #define SYNCH_MSG 0

521 #define FAILOVER_MSG 1

522

523 /*

524 * Config protocol message types

525 */

526 #define DSC_REQ_MSG 0

527 #define DSC_RESP_MSG 1

528

529 /*

530 * Word 1

531 */

532 static inline u32 msg_seq_gap(struct tipc_msg *m)

533 {

534 return msg_bits(m, 1, 16, 0x1fff);

535 }

536

537 static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n)

538 {

539 msg_set_bits(m, 1, 16, 0x1fff, n);

540 }

541

542 static inline u32 msg_node_sig(struct tipc_msg *m)

543 {

544 return msg_bits(m, 1, 0, 0xffff);

545 }

546

547 static inline void msg_set_node_sig(struct tipc_msg *m, u32 n)

548 {

549 msg_set_bits(m, 1, 0, 0xffff, n);

550 }

551

552 static inline u32 msg_node_capabilities(struct tipc_msg *m)

553 {

554 return msg_bits(m, 1, 15, 0x1fff);

555 }

556

557 static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n)

558 {

559 msg_set_bits(m, 1, 15, 0x1fff, n);

560 }

561

562 /*

563 * Word 2

564 */

565 static inline u32 msg_dest_domain(struct tipc_msg *m)

566 {

567 return msg_word(m, 2);

568 }

569

570 static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n)

571 {

572 msg_set_word(m, 2, n);

573 }

574

575 static inline u32 msg_bcgap_after(struct tipc_msg *m)

576 {

577 return msg_bits(m, 2, 16, 0xffff);

578 }

579

580 static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n)

581 {

582 msg_set_bits(m, 2, 16, 0xffff, n);

583 }

584

585 static inline u32 msg_bcgap_to(struct tipc_msg *m)

586 {

587 return msg_bits(m, 2, 0, 0xffff);

588 }

589

590 static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n)

591 {

592 msg_set_bits(m, 2, 0, 0xffff, n);

593 }

594

595

596 /*

597 * Word 4

598 */

599 static inline u32 msg_last_bcast(struct tipc_msg *m)

600 {

601 return msg_bits(m, 4, 16, 0xffff);

602 }

603

604 static inline u32 msg_bc_snd_nxt(struct tipc_msg *m)

605 {

606 return msg_last_bcast(m) + 1;

607 }

608

609 static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n)

610 {

611 msg_set_bits(m, 4, 16, 0xffff, n);

612 }

613

614 static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n)

615 {

616 msg_set_bits(m, 4, 16, 0xffff, n);

617 }

618

619

620 static inline u16 msg_next_sent(struct tipc_msg *m)

621 {

622 return msg_bits(m, 4, 0, 0xffff);

623 }

624

625 static inline void msg_set_next_sent(struct tipc_msg *m, u16 n)

626 {

627 msg_set_bits(m, 4, 0, 0xffff, n);

628 }

629

630 static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n)

631 {

632 msg_set_bits(m, 4, 0, 0xffff, n);

633 }

634

635 static inline u32 msg_bc_netid(struct tipc_msg *m)

636 {

637 return msg_word(m, 4);

638 }

639

640 static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id)

641 {

642 msg_set_word(m, 4, id);

643 }

644

645 static inline u32 msg_link_selector(struct tipc_msg *m)

646 {

647 return msg_bits(m, 4, 0, 1);

648 }

649

650 static inline void msg_set_link_selector(struct tipc_msg *m, u32 n)

651 {

652 msg_set_bits(m, 4, 0, 1, n);

653 }

654

655 /*

656 * Word 5

657 */

658 static inline u16 msg_session(struct tipc_msg *m)

659 {

660 return msg_bits(m, 5, 16, 0xffff);

661 }

662

663 static inline void msg_set_session(struct tipc_msg *m, u16 n)

664 {

665 msg_set_bits(m, 5, 16, 0xffff, n);

666 }

667

668 static inline u32 msg_probe(struct tipc_msg *m)

669 {

670 return msg_bits(m, 5, 0, 1);

671 }

672

673 static inline void msg_set_probe(struct tipc_msg *m, u32 val)

674 {

675 msg_set_bits(m, 5, 0, 1, val);

676 }

677

678 static inline char msg_net_plane(struct tipc_msg *m)

679 {

680 return msg_bits(m, 5, 1, 7) + 'A';

681 }

682

683 static inline void msg_set_net_plane(struct tipc_msg *m, char n)

684 {

685 msg_set_bits(m, 5, 1, 7, (n - 'A'));

686 }

687

688 static inline u32 msg_linkprio(struct tipc_msg *m)

689 {

690 return msg_bits(m, 5, 4, 0x1f);

691 }

692

693 static inline void msg_set_linkprio(struct tipc_msg *m, u32 n)

694 {

695 msg_set_bits(m, 5, 4, 0x1f, n);

696 }

697

698 static inline u32 msg_bearer_id(struct tipc_msg *m)

699 {

700 return msg_bits(m, 5, 9, 0x7);

701 }

702

703 static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n)

704 {

705 msg_set_bits(m, 5, 9, 0x7, n);

706 }

707

708 static inline u32 msg_redundant_link(struct tipc_msg *m)

709 {

710 return msg_bits(m, 5, 12, 0x1);

711 }

712

713 static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r)

714 {

715 msg_set_bits(m, 5, 12, 0x1, r);

716 }

717

718 static inline char *msg_media_addr(struct tipc_msg *m)

719 {

720 return (char *)&m->hdr[TIPC_MEDIA_INFO_OFFSET];

721 }

722

723 /*

724 * Word 9

725 */

726 static inline u16 msg_msgcnt(struct tipc_msg *m)

727 {

728 return msg_bits(m, 9, 16, 0xffff);

729 }

730

731 static inline void msg_set_msgcnt(struct tipc_msg *m, u16 n)

732 {

733 msg_set_bits(m, 9, 16, 0xffff, n);

734 }

735

736 static inline u32 msg_bcast_tag(struct tipc_msg *m)

737 {

738 return msg_bits(m, 9, 16, 0xffff);

739 }

740

741 static inline void msg_set_bcast_tag(struct tipc_msg *m, u32 n)

742 {

743 msg_set_bits(m, 9, 16, 0xffff, n);

744 }

745

746 static inline u32 msg_max_pkt(struct tipc_msg *m)

747 {

748 return msg_bits(m, 9, 16, 0xffff) * 4;

749 }

750

751 static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n)

752 {

753 msg_set_bits(m, 9, 16, 0xffff, (n / 4));

754 }

755

756 static inline u32 msg_link_tolerance(struct tipc_msg *m)

757 {

758 return msg_bits(m, 9, 0, 0xffff);

759 }

760

761 static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n)

762 {

763 msg_set_bits(m, 9, 0, 0xffff, n);

764 }

765

766 static inline bool msg_peer_link_is_up(struct tipc_msg *m)

767 {

768 if (likely(msg_user(m) != LINK_PROTOCOL))

769 return true;

770 if (msg_type(m) == STATE_MSG)

771 return true;

772 return false;

773 }

774

775 static inline bool msg_peer_node_is_up(struct tipc_msg *m)

776 {

777 if (msg_peer_link_is_up(m))

778 return true;

779 return msg_redundant_link(m);

780 }

781

782 struct sk_buff *tipc_buf_acquire(u32 size);

783 bool tipc_msg_validate(struct sk_buff *skb);

784 bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err);

785 void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type,

786 u32 hsize, u32 destnode);

787 struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz,

788 uint data_sz, u32 dnode, u32 onode,

789 u32 dport, u32 oport, int errcode);

790 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf);

791 bool tipc_msg_bundle(struct sk_buff *skb, struct tipc_msg *msg, u32 mtu);

792 bool tipc_msg_make_bundle(struct sk_buff **skb, struct tipc_msg *msg,

793 u32 mtu, u32 dnode);

794 bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos);

795 int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m,

796 int offset, int dsz, int mtu, struct sk_buff_head *list);

797 bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err);

798 bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq);

799 void __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno,

800 struct sk_buff *skb);

801

802 static inline u16 buf_seqno(struct sk_buff *skb)

803 {

804 return msg_seqno(buf_msg(skb));

805 }

806

807 /* tipc_skb_peek(): peek and reserve first buffer in list

808 * @list: list to be peeked in

809 * Returns pointer to first buffer in list, if any

810 */

811 static inline struct sk_buff *tipc_skb_peek(struct sk_buff_head *list,

812 spinlock_t *lock)

813 {

814 struct sk_buff *skb;

815

816 spin_lock_bh(lock);

817 skb = skb_peek(list);

818 if (skb)

819 skb_get(skb);

820 spin_unlock_bh(lock);

821 return skb;

822 }

823

824 /* tipc_skb_peek_port(): find a destination port, ignoring all destinations

825 * up to and including 'filter'.

826 * Note: ignoring previously tried destinations minimizes the risk of

827 * contention on the socket lock

828 * @list: list to be peeked in

829 * @filter: last destination to be ignored from search

830 * Returns a destination port number, of applicable.

831 */

832 static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter)

833 {

834 struct sk_buff *skb;

835 u32 dport = 0;

836 bool ignore = true;

837

838 spin_lock_bh(&list->lock);

839 skb_queue_walk(list, skb) {

840 dport = msg_destport(buf_msg(skb));

841 if (!filter || skb_queue_is_last(list, skb))

842 break;

843 if (dport == filter)

844 ignore = false;

845 else if (!ignore)

846 break;

847 }

848 spin_unlock_bh(&list->lock);

849 return dport;

850 }

851

852 /* tipc_skb_dequeue(): unlink first buffer with dest 'dport' from list

853 * @list: list to be unlinked from

854 * @dport: selection criteria for buffer to unlink

855 */

856 static inline struct sk_buff *tipc_skb_dequeue(struct sk_buff_head *list,

857 u32 dport)

858 {

859 struct sk_buff *_skb, *tmp, *skb = NULL;

860

861 spin_lock_bh(&list->lock);

862 skb_queue_walk_safe(list, _skb, tmp) {

863 if (msg_destport(buf_msg(_skb)) == dport) {

864 __skb_unlink(_skb, list);

865 skb = _skb;

866 break;

867 }

868 }

869 spin_unlock_bh(&list->lock);

870 return skb;

871 }

872

873 /* tipc_skb_queue_splice_tail - append an skb list to lock protected list

874 * @list: the new list to append. Not lock protected

875 * @head: target list. Lock protected.

876 */

877 static inline void tipc_skb_queue_splice_tail(struct sk_buff_head *list,

878 struct sk_buff_head *head)

879 {

880 spin_lock_bh(&head->lock);

881 skb_queue_splice_tail(list, head);

882 spin_unlock_bh(&head->lock);

883 }

884

885 /* tipc_skb_queue_splice_tail_init - merge two lock protected skb lists

886 * @list: the new list to add. Lock protected. Will be reinitialized

887 * @head: target list. Lock protected.

888 */

889 static inline void tipc_skb_queue_splice_tail_init(struct sk_buff_head *list,

890 struct sk_buff_head *head)

891 {

892 struct sk_buff_head tmp;

893

894 __skb_queue_head_init(&tmp);

895

896 spin_lock_bh(&list->lock);

897 skb_queue_splice_tail_init(list, &tmp);

898 spin_unlock_bh(&list->lock);

899 tipc_skb_queue_splice_tail(&tmp, head);

900 }

901

902 #endif