1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/net/sunrpc/socklib.c 4 * 5 * Common socket helper routines for RPC client and server 6 * 7 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 8 */ 9 10 #include <linux/compiler.h> 11 #include <linux/netdevice.h> 12 #include <linux/gfp.h> 13 #include <linux/skbuff.h> 14 #include <linux/types.h> 15 #include <linux/pagemap.h> 16 #include <linux/udp.h> 17 #include <linux/sunrpc/msg_prot.h> 18 #include <linux/sunrpc/sched.h> 19 #include <linux/sunrpc/xdr.h> 20 #include <linux/export.h> 21 22 #include "socklib.h" 23 24 /* 25 * Helper structure for copying from an sk_buff. 26 */ 27 struct xdr_skb_reader { 28 struct sk_buff *skb; 29 unsigned int offset; 30 size_t count; 31 __wsum csum; 32 }; 33 34 typedef size_t (*xdr_skb_read_actor)(struct xdr_skb_reader *desc, void *to, 35 size_t len); 36 37 /** 38 * xdr_skb_read_bits - copy some data bits from skb to internal buffer 39 * @desc: sk_buff copy helper 40 * @to: copy destination 41 * @len: number of bytes to copy 42 * 43 * Possibly called several times to iterate over an sk_buff and copy 44 * data out of it. 45 */ 46 static size_t 47 xdr_skb_read_bits(struct xdr_skb_reader *desc, void *to, size_t len) 48 { 49 if (len > desc->count) 50 len = desc->count; 51 if (unlikely(skb_copy_bits(desc->skb, desc->offset, to, len))) 52 return 0; 53 desc->count -= len; 54 desc->offset += len; 55 return len; 56 } 57 58 /** 59 * xdr_skb_read_and_csum_bits - copy and checksum from skb to buffer 60 * @desc: sk_buff copy helper 61 * @to: copy destination 62 * @len: number of bytes to copy 63 * 64 * Same as skb_read_bits, but calculate a checksum at the same time. 65 */ 66 static size_t xdr_skb_read_and_csum_bits(struct xdr_skb_reader *desc, void *to, size_t len) 67 { 68 unsigned int pos; 69 __wsum csum2; 70 71 if (len > desc->count) 72 len = desc->count; 73 pos = desc->offset; 74 csum2 = skb_copy_and_csum_bits(desc->skb, pos, to, len); 75 desc->csum = csum_block_add(desc->csum, csum2, pos); 76 desc->count -= len; 77 desc->offset += len; 78 return len; 79 } 80 81 /** 82 * xdr_partial_copy_from_skb - copy data out of an skb 83 * @xdr: target XDR buffer 84 * @base: starting offset 85 * @desc: sk_buff copy helper 86 * @copy_actor: virtual method for copying data 87 * 88 */ 89 static ssize_t 90 xdr_partial_copy_from_skb(struct xdr_buf *xdr, unsigned int base, struct xdr_skb_reader *desc, xdr_skb_read_actor copy_actor) 91 { 92 struct page **ppage = xdr->pages; 93 unsigned int len, pglen = xdr->page_len; 94 ssize_t copied = 0; 95 size_t ret; 96 97 len = xdr->head[0].iov_len; 98 if (base < len) { 99 len -= base; 100 ret = copy_actor(desc, (char *)xdr->head[0].iov_base + base, len); 101 copied += ret; 102 if (ret != len || !desc->count) 103 goto out; 104 base = 0; 105 } else 106 base -= len; 107 108 if (unlikely(pglen == 0)) 109 goto copy_tail; 110 if (unlikely(base >= pglen)) { 111 base -= pglen; 112 goto copy_tail; 113 } 114 if (base || xdr->page_base) { 115 pglen -= base; 116 base += xdr->page_base; 117 ppage += base >> PAGE_SHIFT; 118 base &= ~PAGE_MASK; 119 } 120 do { 121 char *kaddr; 122 123 /* ACL likes to be lazy in allocating pages - ACLs 124 * are small by default but can get huge. */ 125 if ((xdr->flags & XDRBUF_SPARSE_PAGES) && *ppage == NULL) { 126 *ppage = alloc_page(GFP_NOWAIT | __GFP_NOWARN); 127 if (unlikely(*ppage == NULL)) { 128 if (copied == 0) 129 copied = -ENOMEM; 130 goto out; 131 } 132 } 133 134 len = PAGE_SIZE; 135 kaddr = kmap_atomic(*ppage); 136 if (base) { 137 len -= base; 138 if (pglen < len) 139 len = pglen; 140 ret = copy_actor(desc, kaddr + base, len); 141 base = 0; 142 } else { 143 if (pglen < len) 144 len = pglen; 145 ret = copy_actor(desc, kaddr, len); 146 } 147 flush_dcache_page(*ppage); 148 kunmap_atomic(kaddr); 149 copied += ret; 150 if (ret != len || !desc->count) 151 goto out; 152 ppage++; 153 } while ((pglen -= len) != 0); 154 copy_tail: 155 len = xdr->tail[0].iov_len; 156 if (base < len) 157 copied += copy_actor(desc, (char *)xdr->tail[0].iov_base + base, len - base); 158 out: 159 return copied; 160 } 161 162 /** 163 * csum_partial_copy_to_xdr - checksum and copy data 164 * @xdr: target XDR buffer 165 * @skb: source skb 166 * 167 * We have set things up such that we perform the checksum of the UDP 168 * packet in parallel with the copies into the RPC client iovec. -DaveM 169 */ 170 int csum_partial_copy_to_xdr(struct xdr_buf *xdr, struct sk_buff *skb) 171 { 172 struct xdr_skb_reader desc; 173 174 desc.skb = skb; 175 desc.offset = 0; 176 desc.count = skb->len - desc.offset; 177 178 if (skb_csum_unnecessary(skb)) 179 goto no_checksum; 180 181 desc.csum = csum_partial(skb->data, desc.offset, skb->csum); 182 if (xdr_partial_copy_from_skb(xdr, 0, &desc, xdr_skb_read_and_csum_bits) < 0) 183 return -1; 184 if (desc.offset != skb->len) { 185 __wsum csum2; 186 csum2 = skb_checksum(skb, desc.offset, skb->len - desc.offset, 0); 187 desc.csum = csum_block_add(desc.csum, csum2, desc.offset); 188 } 189 if (desc.count) 190 return -1; 191 if (csum_fold(desc.csum)) 192 return -1; 193 if (unlikely(skb->ip_summed == CHECKSUM_COMPLETE) && 194 !skb->csum_complete_sw) 195 netdev_rx_csum_fault(skb->dev, skb); 196 return 0; 197 no_checksum: 198 if (xdr_partial_copy_from_skb(xdr, 0, &desc, xdr_skb_read_bits) < 0) 199 return -1; 200 if (desc.count) 201 return -1; 202 return 0; 203 } 204 EXPORT_SYMBOL_GPL(csum_partial_copy_to_xdr); 205 206 static inline int xprt_sendmsg(struct socket *sock, struct msghdr *msg, 207 size_t seek) 208 { 209 if (seek) 210 iov_iter_advance(&msg->msg_iter, seek); 211 return sock_sendmsg(sock, msg); 212 } 213 214 static int xprt_send_kvec(struct socket *sock, struct msghdr *msg, 215 struct kvec *vec, size_t seek) 216 { 217 iov_iter_kvec(&msg->msg_iter, ITER_SOURCE, vec, 1, vec->iov_len); 218 return xprt_sendmsg(sock, msg, seek); 219 } 220 221 static int xprt_send_pagedata(struct socket *sock, struct msghdr *msg, 222 struct xdr_buf *xdr, size_t base) 223 { 224 iov_iter_bvec(&msg->msg_iter, ITER_SOURCE, xdr->bvec, xdr_buf_pagecount(xdr), 225 xdr->page_len + xdr->page_base); 226 return xprt_sendmsg(sock, msg, base + xdr->page_base); 227 } 228 229 /* Common case: 230 * - stream transport 231 * - sending from byte 0 of the message 232 * - the message is wholly contained in @xdr's head iovec 233 */ 234 static int xprt_send_rm_and_kvec(struct socket *sock, struct msghdr *msg, 235 rpc_fraghdr marker, struct kvec *vec, 236 size_t base) 237 { 238 struct kvec iov[2] = { 239 [0] = { 240 .iov_base = &marker, 241 .iov_len = sizeof(marker) 242 }, 243 [1] = *vec, 244 }; 245 size_t len = iov[0].iov_len + iov[1].iov_len; 246 247 iov_iter_kvec(&msg->msg_iter, ITER_SOURCE, iov, 2, len); 248 return xprt_sendmsg(sock, msg, base); 249 } 250 251 /** 252 * xprt_sock_sendmsg - write an xdr_buf directly to a socket 253 * @sock: open socket to send on 254 * @msg: socket message metadata 255 * @xdr: xdr_buf containing this request 256 * @base: starting position in the buffer 257 * @marker: stream record marker field 258 * @sent_p: return the total number of bytes successfully queued for sending 259 * 260 * Return values: 261 * On success, returns zero and fills in @sent_p. 262 * %-ENOTSOCK if @sock is not a struct socket. 263 */ 264 int xprt_sock_sendmsg(struct socket *sock, struct msghdr *msg, 265 struct xdr_buf *xdr, unsigned int base, 266 rpc_fraghdr marker, unsigned int *sent_p) 267 { 268 unsigned int rmsize = marker ? sizeof(marker) : 0; 269 unsigned int remainder = rmsize + xdr->len - base; 270 unsigned int want; 271 int err = 0; 272 273 *sent_p = 0; 274 275 if (unlikely(!sock)) 276 return -ENOTSOCK; 277 278 msg->msg_flags |= MSG_MORE; 279 want = xdr->head[0].iov_len + rmsize; 280 if (base < want) { 281 unsigned int len = want - base; 282 283 remainder -= len; 284 if (remainder == 0) 285 msg->msg_flags &= ~MSG_MORE; 286 if (rmsize) 287 err = xprt_send_rm_and_kvec(sock, msg, marker, 288 &xdr->head[0], base); 289 else 290 err = xprt_send_kvec(sock, msg, &xdr->head[0], base); 291 if (remainder == 0 || err != len) 292 goto out; 293 *sent_p += err; 294 base = 0; 295 } else { 296 base -= want; 297 } 298 299 if (base < xdr->page_len) { 300 unsigned int len = xdr->page_len - base; 301 302 remainder -= len; 303 if (remainder == 0) 304 msg->msg_flags &= ~MSG_MORE; 305 err = xprt_send_pagedata(sock, msg, xdr, base); 306 if (remainder == 0 || err != len) 307 goto out; 308 *sent_p += err; 309 base = 0; 310 } else { 311 base -= xdr->page_len; 312 } 313 314 if (base >= xdr->tail[0].iov_len) 315 return 0; 316 msg->msg_flags &= ~MSG_MORE; 317 err = xprt_send_kvec(sock, msg, &xdr->tail[0], base); 318 out: 319 if (err > 0) { 320 *sent_p += err; 321 err = 0; 322 } 323 return err; 324 } 325