net/rxrpc/recvmsg.c

   1 /* RxRPC recvmsg() implementation
   2  *
   3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/net.h>
  15 #include <linux/skbuff.h>
  16 #include <linux/export.h>
  17 #include <net/sock.h>
  18 #include <net/af_rxrpc.h>
  19 #include "ar-internal.h"
  20
  21 /*
  22  * removal a call's user ID from the socket tree to make the user ID available
  23  * again and so that it won't be seen again in association with that call
  24  */
  25 void rxrpc_remove_user_ID(struct rxrpc_sock *rx, struct rxrpc_call *call)
  26 {
  27         _debug("RELEASE CALL %d", call->debug_id);
  28
  29         if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
  30                 write_lock_bh(&rx->call_lock);
  31                 rb_erase(&call->sock_node, &call->socket->calls);
  32                 clear_bit(RXRPC_CALL_HAS_USERID, &call->flags);
  33                 write_unlock_bh(&rx->call_lock);
  34         }
  35
  36         read_lock_bh(&call->state_lock);
  37         if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
  38             !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))
  39                 rxrpc_queue_call(call);
  40         read_unlock_bh(&call->state_lock);
  41 }
  42
  43 /*
  44  * receive a message from an RxRPC socket
  45  * - we need to be careful about two or more threads calling recvmsg
  46  *   simultaneously
  47  */
  48 int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
  49                   int flags)
  50 {
  51         struct rxrpc_skb_priv *sp;
  52         struct rxrpc_call *call = NULL, *continue_call = NULL;
  53         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
  54         struct sk_buff *skb;
  55         long timeo;
  56         int copy, ret, ullen, offset, copied = 0;
  57         u32 abort_code;
  58
  59         DEFINE_WAIT(wait);
  60
  61         _enter(",,,%zu,%d", len, flags);
  62
  63         if (flags & (MSG_OOB | MSG_TRUNC))
  64                 return -EOPNOTSUPP;
  65
  66         ullen = msg->msg_flags & MSG_CMSG_COMPAT ? 4 : sizeof(unsigned long);
  67
  68         timeo = sock_rcvtimeo(&rx->sk, flags & MSG_DONTWAIT);
  69         msg->msg_flags |= MSG_MORE;
  70
  71         lock_sock(&rx->sk);
  72
  73         for (;;) {
  74                 /* return immediately if a client socket has no outstanding
  75                  * calls */
  76                 if (RB_EMPTY_ROOT(&rx->calls)) {
  77                         if (copied)
  78                                 goto out;
  79                         if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) {
  80                                 release_sock(&rx->sk);
  81                                 if (continue_call)
  82                                         rxrpc_put_call(continue_call);
  83                                 return -ENODATA;
  84                         }
  85                 }
  86
  87                 /* get the next message on the Rx queue */
  88                 skb = skb_peek(&rx->sk.sk_receive_queue);
  89                 if (!skb) {
  90                         /* nothing remains on the queue */
  91                         if (copied &&
  92                             (flags & MSG_PEEK || timeo == 0))
  93                                 goto out;
  94
  95                         /* wait for a message to turn up */
  96                         release_sock(&rx->sk);
  97                         prepare_to_wait_exclusive(sk_sleep(&rx->sk), &wait,
  98                                                   TASK_INTERRUPTIBLE);
  99                         ret = sock_error(&rx->sk);
 100                         if (ret)
 101                                 goto wait_error;
 102
 103                         if (skb_queue_empty(&rx->sk.sk_receive_queue)) {
 104                                 if (signal_pending(current))
 105                                         goto wait_interrupted;
 106                                 timeo = schedule_timeout(timeo);
 107                         }
 108                         finish_wait(sk_sleep(&rx->sk), &wait);
 109                         lock_sock(&rx->sk);
 110                         continue;
 111                 }
 112
 113         peek_next_packet:
 114                 sp = rxrpc_skb(skb);
 115                 call = sp->call;
 116                 ASSERT(call != NULL);
 117
 118                 _debug("next pkt %s", rxrpc_pkts[sp->hdr.type]);
 119
 120                 /* make sure we wait for the state to be updated in this call */
 121                 spin_lock_bh(&call->lock);
 122                 spin_unlock_bh(&call->lock);
 123
 124                 if (test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
 125                         _debug("packet from released call");
 126                         if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
 127                                 BUG();
 128                         rxrpc_free_skb(skb);
 129                         continue;
 130                 }
 131
 132                 /* determine whether to continue last data receive */
 133                 if (continue_call) {
 134                         _debug("maybe cont");
 135                         if (call != continue_call ||
 136                             skb->mark != RXRPC_SKB_MARK_DATA) {
 137                                 release_sock(&rx->sk);
 138                                 rxrpc_put_call(continue_call);
 139                                 _leave(" = %d [noncont]", copied);
 140                                 return copied;
 141                         }
 142                 }
 143
 144                 rxrpc_get_call(call);
 145
 146                 /* copy the peer address and timestamp */
 147                 if (!continue_call) {
 148                         if (msg->msg_name) {
 149                                 size_t len =
 150                                         sizeof(call->conn->params.peer->srx);
 151                                 memcpy(msg->msg_name,
 152                                        &call->conn->params.peer->srx, len);
 153                                 msg->msg_namelen = len;
 154                         }
 155                         sock_recv_timestamp(msg, &rx->sk, skb);
 156                 }
 157
 158                 /* receive the message */
 159                 if (skb->mark != RXRPC_SKB_MARK_DATA)
 160                         goto receive_non_data_message;
 161
 162                 _debug("recvmsg DATA #%u { %d, %d }",
 163                        sp->hdr.seq, skb->len, sp->offset);
 164
 165                 if (!continue_call) {
 166                         /* only set the control data once per recvmsg() */
 167                         ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
 168                                        ullen, &call->user_call_ID);
 169                         if (ret < 0)
 170                                 goto copy_error;
 171                         ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
 172                 }
 173
 174                 ASSERTCMP(sp->hdr.seq, >=, call->rx_data_recv);
 175                 ASSERTCMP(sp->hdr.seq, <=, call->rx_data_recv + 1);
 176                 call->rx_data_recv = sp->hdr.seq;
 177
 178                 ASSERTCMP(sp->hdr.seq, >, call->rx_data_eaten);
 179
 180                 offset = sp->offset;
 181                 copy = skb->len - offset;
 182                 if (copy > len - copied)
 183                         copy = len - copied;
 184
 185                 ret = skb_copy_datagram_msg(skb, offset, msg, copy);
 186
 187                 if (ret < 0)
 188                         goto copy_error;
 189
 190                 /* handle piecemeal consumption of data packets */
 191                 _debug("copied %d+%d", copy, copied);
 192
 193                 offset += copy;
 194                 copied += copy;
 195
 196                 if (!(flags & MSG_PEEK))
 197                         sp->offset = offset;
 198
 199                 if (sp->offset < skb->len) {
 200                         _debug("buffer full");
 201                         ASSERTCMP(copied, ==, len);
 202                         break;
 203                 }
 204
 205                 /* we transferred the whole data packet */
 206                 if (!(flags & MSG_PEEK))
 207                         rxrpc_kernel_data_consumed(call, skb);
 208
 209                 if (sp->hdr.flags & RXRPC_LAST_PACKET) {
 210                         _debug("last");
 211                         if (rxrpc_conn_is_client(call->conn)) {
 212                                  /* last byte of reply received */
 213                                 ret = copied;
 214                                 goto terminal_message;
 215                         }
 216
 217                         /* last bit of request received */
 218                         if (!(flags & MSG_PEEK)) {
 219                                 _debug("eat packet");
 220                                 if (skb_dequeue(&rx->sk.sk_receive_queue) !=
 221                                     skb)
 222                                         BUG();
 223                                 rxrpc_free_skb(skb);
 224                         }
 225                         msg->msg_flags &= ~MSG_MORE;
 226                         break;
 227                 }
 228
 229                 /* move on to the next data message */
 230                 _debug("next");
 231                 if (!continue_call)
 232                         continue_call = sp->call;
 233                 else
 234                         rxrpc_put_call(call);
 235                 call = NULL;
 236
 237                 if (flags & MSG_PEEK) {
 238                         _debug("peek next");
 239                         skb = skb->next;
 240                         if (skb == (struct sk_buff *) &rx->sk.sk_receive_queue)
 241                                 break;
 242                         goto peek_next_packet;
 243                 }
 244
 245                 _debug("eat packet");
 246                 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
 247                         BUG();
 248                 rxrpc_free_skb(skb);
 249         }
 250
 251         /* end of non-terminal data packet reception for the moment */
 252         _debug("end rcv data");
 253 out:
 254         release_sock(&rx->sk);
 255         if (call)
 256                 rxrpc_put_call(call);
 257         if (continue_call)
 258                 rxrpc_put_call(continue_call);
 259         _leave(" = %d [data]", copied);
 260         return copied;
 261
 262         /* handle non-DATA messages such as aborts, incoming connections and
 263          * final ACKs */
 264 receive_non_data_message:
 265         _debug("non-data");
 266
 267         if (skb->mark == RXRPC_SKB_MARK_NEW_CALL) {
 268                 _debug("RECV NEW CALL");
 269                 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NEW_CALL, 0, &abort_code);
 270                 if (ret < 0)
 271                         goto copy_error;
 272                 if (!(flags & MSG_PEEK)) {
 273                         if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
 274                                 BUG();
 275                         rxrpc_free_skb(skb);
 276                 }
 277                 goto out;
 278         }
 279
 280         ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
 281                        ullen, &call->user_call_ID);
 282         if (ret < 0)
 283                 goto copy_error;
 284         ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
 285
 286         switch (skb->mark) {
 287         case RXRPC_SKB_MARK_DATA:
 288                 BUG();
 289         case RXRPC_SKB_MARK_FINAL_ACK:
 290                 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ACK, 0, &abort_code);
 291                 break;
 292         case RXRPC_SKB_MARK_BUSY:
 293                 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_BUSY, 0, &abort_code);
 294                 break;
 295         case RXRPC_SKB_MARK_REMOTE_ABORT:
 296                 abort_code = call->remote_abort;
 297                 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &abort_code);
 298                 break;
 299         case RXRPC_SKB_MARK_LOCAL_ABORT:
 300                 abort_code = call->local_abort;
 301                 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &abort_code);
 302                 break;
 303         case RXRPC_SKB_MARK_NET_ERROR:
 304                 _debug("RECV NET ERROR %d", sp->error);
 305                 abort_code = sp->error;
 306                 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NET_ERROR, 4, &abort_code);
 307                 break;
 308         case RXRPC_SKB_MARK_LOCAL_ERROR:
 309                 _debug("RECV LOCAL ERROR %d", sp->error);
 310                 abort_code = sp->error;
 311                 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_LOCAL_ERROR, 4,
 312                                &abort_code);
 313                 break;
 314         default:
 315                 pr_err("Unknown packet mark %u\n", skb->mark);
 316                 BUG();
 317                 break;
 318         }
 319
 320         if (ret < 0)
 321                 goto copy_error;
 322
 323 terminal_message:
 324         _debug("terminal");
 325         msg->msg_flags &= ~MSG_MORE;
 326         msg->msg_flags |= MSG_EOR;
 327
 328         if (!(flags & MSG_PEEK)) {
 329                 _net("free terminal skb %p", skb);
 330                 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
 331                         BUG();
 332                 rxrpc_free_skb(skb);
 333                 rxrpc_remove_user_ID(rx, call);
 334         }
 335
 336         release_sock(&rx->sk);
 337         rxrpc_put_call(call);
 338         if (continue_call)
 339                 rxrpc_put_call(continue_call);
 340         _leave(" = %d", ret);
 341         return ret;
 342
 343 copy_error:
 344         _debug("copy error");
 345         release_sock(&rx->sk);
 346         rxrpc_put_call(call);
 347         if (continue_call)
 348                 rxrpc_put_call(continue_call);
 349         _leave(" = %d", ret);
 350         return ret;
 351
 352 wait_interrupted:
 353         ret = sock_intr_errno(timeo);
 354 wait_error:
 355         finish_wait(sk_sleep(&rx->sk), &wait);
 356         if (continue_call)
 357                 rxrpc_put_call(continue_call);
 358         if (copied)
 359                 copied = ret;
 360         _leave(" = %d [waitfail %d]", copied, ret);
 361         return copied;
 362
 363 }
 364
 365 /**
 366  * rxrpc_kernel_is_data_last - Determine if data message is last one
 367  * @skb: Message holding data
 368  *
 369  * Determine if data message is last one for the parent call.
 370  */
 371 bool rxrpc_kernel_is_data_last(struct sk_buff *skb)
 372 {
 373         struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 374
 375         ASSERTCMP(skb->mark, ==, RXRPC_SKB_MARK_DATA);
 376
 377         return sp->hdr.flags & RXRPC_LAST_PACKET;
 378 }
 379
 380 EXPORT_SYMBOL(rxrpc_kernel_is_data_last);
 381
 382 /**
 383  * rxrpc_kernel_get_abort_code - Get the abort code from an RxRPC abort message
 384  * @skb: Message indicating an abort
 385  *
 386  * Get the abort code from an RxRPC abort message.
 387  */
 388 u32 rxrpc_kernel_get_abort_code(struct sk_buff *skb)
 389 {
 390         struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 391
 392         switch (skb->mark) {
 393         case RXRPC_SKB_MARK_REMOTE_ABORT:
 394                 return sp->call->remote_abort;
 395         case RXRPC_SKB_MARK_LOCAL_ABORT:
 396                 return sp->call->local_abort;
 397         default:
 398                 BUG();
 399         }
 400 }
 401
 402 EXPORT_SYMBOL(rxrpc_kernel_get_abort_code);
 403
 404 /**
 405  * rxrpc_kernel_get_error - Get the error number from an RxRPC error message
 406  * @skb: Message indicating an error
 407  *
 408  * Get the error number from an RxRPC error message.
 409  */
 410 int rxrpc_kernel_get_error_number(struct sk_buff *skb)
 411 {
 412         struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 413
 414         return sp->error;
 415 }
 416
 417 EXPORT_SYMBOL(rxrpc_kernel_get_error_number);