1 /* 2 * net/tipc/msg.c: TIPC message header routines 3 * 4 * Copyright (c) 2000-2006, 2014, Ericsson AB 5 * Copyright (c) 2005, 2010-2011, Wind River Systems 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the names of the copyright holders nor the names of its 17 * contributors may be used to endorse or promote products derived from 18 * this software without specific prior written permission. 19 * 20 * Alternatively, this software may be distributed under the terms of the 21 * GNU General Public License ("GPL") version 2 as published by the Free 22 * Software Foundation. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #include "core.h" 38 #include "msg.h" 39 40 u32 tipc_msg_tot_importance(struct tipc_msg *m) 41 { 42 if (likely(msg_isdata(m))) { 43 if (likely(msg_orignode(m) == tipc_own_addr)) 44 return msg_importance(m); 45 return msg_importance(m) + 4; 46 } 47 if ((msg_user(m) == MSG_FRAGMENTER) && 48 (msg_type(m) == FIRST_FRAGMENT)) 49 return msg_importance(msg_get_wrapped(m)); 50 return msg_importance(m); 51 } 52 53 54 void tipc_msg_init(struct tipc_msg *m, u32 user, u32 type, u32 hsize, 55 u32 destnode) 56 { 57 memset(m, 0, hsize); 58 msg_set_version(m); 59 msg_set_user(m, user); 60 msg_set_hdr_sz(m, hsize); 61 msg_set_size(m, hsize); 62 msg_set_prevnode(m, tipc_own_addr); 63 msg_set_type(m, type); 64 msg_set_orignode(m, tipc_own_addr); 65 msg_set_destnode(m, destnode); 66 } 67 68 /** 69 * tipc_msg_build - create message using specified header and data 70 * 71 * Note: Caller must not hold any locks in case copy_from_user() is interrupted! 72 * 73 * Returns message data size or errno 74 */ 75 int tipc_msg_build(struct tipc_msg *hdr, struct iovec const *msg_sect, 76 unsigned int len, int max_size, struct sk_buff **buf) 77 { 78 int dsz, sz, hsz; 79 unsigned char *to; 80 81 dsz = len; 82 hsz = msg_hdr_sz(hdr); 83 sz = hsz + dsz; 84 msg_set_size(hdr, sz); 85 if (unlikely(sz > max_size)) { 86 *buf = NULL; 87 return dsz; 88 } 89 90 *buf = tipc_buf_acquire(sz); 91 if (!(*buf)) 92 return -ENOMEM; 93 skb_copy_to_linear_data(*buf, hdr, hsz); 94 to = (*buf)->data + hsz; 95 if (len && memcpy_fromiovecend(to, msg_sect, 0, dsz)) { 96 kfree_skb(*buf); 97 *buf = NULL; 98 return -EFAULT; 99 } 100 return dsz; 101 } 102 103 /* tipc_buf_append(): Append a buffer to the fragment list of another buffer 104 * @*headbuf: in: NULL for first frag, otherwise value returned from prev call 105 * out: set when successful non-complete reassembly, otherwise NULL 106 * @*buf: in: the buffer to append. Always defined 107 * out: head buf after sucessful complete reassembly, otherwise NULL 108 * Returns 1 when reassembly complete, otherwise 0 109 */ 110 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf) 111 { 112 struct sk_buff *head = *headbuf; 113 struct sk_buff *frag = *buf; 114 struct sk_buff *tail; 115 struct tipc_msg *msg = buf_msg(frag); 116 u32 fragid = msg_type(msg); 117 bool headstolen; 118 int delta; 119 120 skb_pull(frag, msg_hdr_sz(msg)); 121 122 if (fragid == FIRST_FRAGMENT) { 123 if (head || skb_unclone(frag, GFP_ATOMIC)) 124 goto out_free; 125 head = *headbuf = frag; 126 skb_frag_list_init(head); 127 *buf = NULL; 128 return 0; 129 } 130 if (!head) 131 goto out_free; 132 tail = TIPC_SKB_CB(head)->tail; 133 if (skb_try_coalesce(head, frag, &headstolen, &delta)) { 134 kfree_skb_partial(frag, headstolen); 135 } else { 136 if (!skb_has_frag_list(head)) 137 skb_shinfo(head)->frag_list = frag; 138 else 139 tail->next = frag; 140 head->truesize += frag->truesize; 141 head->data_len += frag->len; 142 head->len += frag->len; 143 TIPC_SKB_CB(head)->tail = frag; 144 } 145 if (fragid == LAST_FRAGMENT) { 146 *buf = head; 147 TIPC_SKB_CB(head)->tail = NULL; 148 *headbuf = NULL; 149 return 1; 150 } 151 *buf = NULL; 152 return 0; 153 out_free: 154 pr_warn_ratelimited("Unable to build fragment list\n"); 155 kfree_skb(*buf); 156 kfree_skb(*headbuf); 157 *buf = *headbuf = NULL; 158 return 0; 159 } 160