linux-imx

/* AF_RXRPC sendmsg() implementation.

 *

 * Copyright (C) 2007, 2016 Red Hat, Inc. All Rights Reserved.

 * Written by David Howells (dhowells@redhat.com)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public Licence

 * as published by the Free Software Foundation; either version

 * 2 of the Licence, or (at your option) any later version.

 */

​

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

​

#include <linux/net.h>

#include <linux/gfp.h>

#include <linux/skbuff.h>

#include <linux/export.h>

#include <linux/sched/signal.h>

​

#include <net/sock.h>

#include <net/af_rxrpc.h>

#include "ar-internal.h"

​

/*

 * Wait for space to appear in the Tx queue or a signal to occur.

 */

static int rxrpc_wait_for_tx_window_intr(struct rxrpc_sock *rx,

                     struct rxrpc_call *call,

                     long *timeo)

{

    for (;;) {

        set_current_state(TASK_INTERRUPTIBLE);

        if (call->tx_top - call->tx_hard_ack <

            min_t(unsigned int, call->tx_winsize,

              call->cong_cwnd + call->cong_extra))

            return 0;

​

        if (call->state >= RXRPC_CALL_COMPLETE)

            return call->error;

​

        if (signal_pending(current))

            return sock_intr_errno(*timeo);

​

        trace_rxrpc_transmit(call, rxrpc_transmit_wait);

        mutex_unlock(&call->user_mutex);

        *timeo = schedule_timeout(*timeo);

        if (mutex_lock_interruptible(&call->user_mutex) < 0)

            return sock_intr_errno(*timeo);

    }

}

​

/*

 * Wait for space to appear in the Tx queue uninterruptibly, but with

 * a timeout of 2*RTT if no progress was made and a signal occurred.

 */

static int rxrpc_wait_for_tx_window_nonintr(struct rxrpc_sock *rx,

                        struct rxrpc_call *call)

{

    rxrpc_seq_t tx_start, tx_win;

    signed long rtt2, timeout;

    u64 rtt;

​

    rtt = READ_ONCE(call->peer->rtt);

    rtt2 = nsecs_to_jiffies64(rtt) * 2;

    if (rtt2 < 1)

        rtt2 = 1;

​

    timeout = rtt2;

    tx_start = READ_ONCE(call->tx_hard_ack);

​

    for (;;) {

        set_current_state(TASK_UNINTERRUPTIBLE);

​

        tx_win = READ_ONCE(call->tx_hard_ack);

        if (call->tx_top - tx_win <

            min_t(unsigned int, call->tx_winsize,

              call->cong_cwnd + call->cong_extra))

            return 0;

​

        if (call->state >= RXRPC_CALL_COMPLETE)

            return call->error;

​

        if (timeout == 0 &&

            tx_win == tx_start && signal_pending(current))

            return -EINTR;

​

        if (tx_win != tx_start) {

            timeout = rtt2;

            tx_start = tx_win;

        }

​

        trace_rxrpc_transmit(call, rxrpc_transmit_wait);