License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 22:07:57 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-08-12 04:25:47 +08:00
|
|
|
* linux/include/linux/sunrpc/xprt.h
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
|
* Declarations for the RPC transport interface.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _LINUX_SUNRPC_XPRT_H
|
|
|
|
|
#define _LINUX_SUNRPC_XPRT_H
|
|
|
|
|
|
|
|
|
|
#include <linux/uio.h>
|
|
|
|
|
#include <linux/socket.h>
|
|
|
|
|
#include <linux/in.h>
|
2010-05-08 01:34:47 +08:00
|
|
|
#include <linux/ktime.h>
|
2015-02-25 09:31:39 +08:00
|
|
|
#include <linux/kref.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/sunrpc/sched.h>
|
|
|
|
|
#include <linux/sunrpc/xdr.h>
|
2006-10-04 17:15:47 +08:00
|
|
|
#include <linux/sunrpc/msg_prot.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-07-08 19:08:54 +08:00
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define RPC_MIN_SLOT_TABLE (2U)
|
|
|
|
|
#define RPC_DEF_SLOT_TABLE (16U)
|
2011-07-18 06:11:30 +08:00
|
|
|
#define RPC_MAX_SLOT_TABLE_LIMIT (65536U)
|
2012-02-07 04:18:48 +08:00
|
|
|
#define RPC_MAX_SLOT_TABLE RPC_MAX_SLOT_TABLE_LIMIT
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-05-28 22:34:49 +08:00
|
|
|
#define RPC_CWNDSHIFT (8U)
|
|
|
|
|
#define RPC_CWNDSCALE (1U << RPC_CWNDSHIFT)
|
|
|
|
|
#define RPC_INITCWND RPC_CWNDSCALE
|
|
|
|
|
#define RPC_MAXCWND(xprt) ((xprt)->max_reqs << RPC_CWNDSHIFT)
|
|
|
|
|
#define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* This describes a timeout strategy
|
|
|
|
|
*/
|
|
|
|
|
struct rpc_timeout {
|
|
|
|
|
unsigned long to_initval, /* initial timeout */
|
|
|
|
|
to_maxval, /* max timeout */
|
|
|
|
|
to_increment; /* if !exponential */
|
|
|
|
|
unsigned int to_retries; /* max # of retries */
|
|
|
|
|
unsigned char to_exponential;
|
|
|
|
|
};
|
|
|
|
|
|
2006-08-23 08:06:18 +08:00
|
|
|
enum rpc_display_format_t {
|
|
|
|
|
RPC_DISPLAY_ADDR = 0,
|
|
|
|
|
RPC_DISPLAY_PORT,
|
|
|
|
|
RPC_DISPLAY_PROTO,
|
2007-08-06 23:57:02 +08:00
|
|
|
RPC_DISPLAY_HEX_ADDR,
|
|
|
|
|
RPC_DISPLAY_HEX_PORT,
|
2007-09-11 01:43:05 +08:00
|
|
|
RPC_DISPLAY_NETID,
|
2006-08-23 08:06:18 +08:00
|
|
|
RPC_DISPLAY_MAX,
|
|
|
|
|
};
|
|
|
|
|
|
2005-08-26 07:25:54 +08:00
|
|
|
struct rpc_task;
|
|
|
|
|
struct rpc_xprt;
|
2006-04-19 01:21:42 +08:00
|
|
|
struct seq_file;
|
2015-10-25 05:28:32 +08:00
|
|
|
struct svc_serv;
|
|
|
|
|
struct net;
|
2005-08-26 07:25:54 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* This describes a complete RPC request
|
|
|
|
|
*/
|
|
|
|
|
struct rpc_rqst {
|
|
|
|
|
/*
|
|
|
|
|
* This is the user-visible part
|
|
|
|
|
*/
|
|
|
|
|
struct rpc_xprt * rq_xprt; /* RPC client */
|
|
|
|
|
struct xdr_buf rq_snd_buf; /* send buffer */
|
|
|
|
|
struct xdr_buf rq_rcv_buf; /* recv buffer */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This is the private part
|
|
|
|
|
*/
|
|
|
|
|
struct rpc_task * rq_task; /* RPC task data */
|
2010-08-01 02:29:08 +08:00
|
|
|
struct rpc_cred * rq_cred; /* Bound cred */
|
2006-09-27 13:29:38 +08:00
|
|
|
__be32 rq_xid; /* request XID */
|
2005-04-17 06:20:36 +08:00
|
|
|
int rq_cong; /* has incremented xprt->cong */
|
|
|
|
|
u32 rq_seqno; /* gss seq no. used on req. */
|
2005-10-14 04:54:43 +08:00
|
|
|
int rq_enc_pages_num;
|
|
|
|
|
struct page **rq_enc_pages; /* scratch pages for use by
|
|
|
|
|
gss privacy code */
|
|
|
|
|
void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
|
2018-08-08 21:23:32 +08:00
|
|
|
|
|
|
|
|
union {
|
|
|
|
|
struct list_head rq_list; /* Slot allocation list */
|
2018-09-07 20:35:22 +08:00
|
|
|
struct rb_node rq_recv; /* Receive queue */
|
2018-08-08 21:23:32 +08:00
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-08-10 11:33:21 +08:00
|
|
|
struct list_head rq_xmit; /* Send queue */
|
2018-09-09 23:37:22 +08:00
|
|
|
struct list_head rq_xmit2; /* Send queue */
|
2018-08-10 11:33:21 +08:00
|
|
|
|
2016-09-15 22:55:12 +08:00
|
|
|
void *rq_buffer; /* Call XDR encode buffer */
|
2016-09-15 22:55:37 +08:00
|
|
|
size_t rq_callsize;
|
|
|
|
|
void *rq_rbuffer; /* Reply XDR decode buffer */
|
|
|
|
|
size_t rq_rcvsize;
|
2010-05-14 00:51:49 +08:00
|
|
|
size_t rq_xmit_bytes_sent; /* total bytes sent */
|
|
|
|
|
size_t rq_reply_bytes_recvd; /* total reply bytes */
|
|
|
|
|
/* received */
|
2006-01-03 16:55:49 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct xdr_buf rq_private_buf; /* The receive buffer
|
|
|
|
|
* used in the softirq.
|
|
|
|
|
*/
|
|
|
|
|
unsigned long rq_majortimeo; /* major timeout alarm */
|
|
|
|
|
unsigned long rq_timeout; /* Current timeout value */
|
2010-05-14 00:51:49 +08:00
|
|
|
ktime_t rq_rtt; /* round-trip time */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int rq_retries; /* # of retries */
|
2008-04-18 04:52:57 +08:00
|
|
|
unsigned int rq_connect_cookie;
|
|
|
|
|
/* A cookie used to track the
|
|
|
|
|
state of the transport
|
|
|
|
|
connection */
|
2018-08-07 00:55:34 +08:00
|
|
|
atomic_t rq_pin;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Partial send handling
|
|
|
|
|
*/
|
|
|
|
|
u32 rq_bytes_sent; /* Bytes we have sent */
|
|
|
|
|
|
2010-05-08 01:34:47 +08:00
|
|
|
ktime_t rq_xtime; /* transmit time stamp */
|
2005-04-17 06:20:36 +08:00
|
|
|
int rq_ntrans;
|
2009-04-01 21:22:58 +08:00
|
|
|
|
2011-07-14 07:20:49 +08:00
|
|
|
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
|
2009-04-01 21:22:58 +08:00
|
|
|
struct list_head rq_bc_list; /* Callback service list */
|
|
|
|
|
unsigned long rq_bc_pa_state; /* Backchannel prealloc state */
|
|
|
|
|
struct list_head rq_bc_pa_list; /* Backchannel prealloc list */
|
2011-07-14 07:20:49 +08:00
|
|
|
#endif /* CONFIG_SUNRPC_BACKCHANEL */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
#define rq_svec rq_snd_buf.head
|
|
|
|
|
#define rq_slen rq_snd_buf.len
|
|
|
|
|
|
2005-08-12 04:25:23 +08:00
|
|
|
struct rpc_xprt_ops {
|
2005-08-26 07:25:56 +08:00
|
|
|
void (*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
|
2011-07-18 04:01:03 +08:00
|
|
|
int (*reserve_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
|
2005-08-26 07:25:51 +08:00
|
|
|
void (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
|
2012-09-07 23:08:50 +08:00
|
|
|
void (*alloc_slot)(struct rpc_xprt *xprt, struct rpc_task *task);
|
2018-05-05 03:34:59 +08:00
|
|
|
void (*free_slot)(struct rpc_xprt *xprt,
|
|
|
|
|
struct rpc_rqst *req);
|
2006-08-23 08:06:16 +08:00
|
|
|
void (*rpcbind)(struct rpc_task *task);
|
2006-01-03 16:55:51 +08:00
|
|
|
void (*set_port)(struct rpc_xprt *xprt, unsigned short port);
|
2013-01-08 22:26:49 +08:00
|
|
|
void (*connect)(struct rpc_xprt *xprt, struct rpc_task *task);
|
2016-09-15 22:55:20 +08:00
|
|
|
int (*buf_alloc)(struct rpc_task *task);
|
2016-09-15 22:55:29 +08:00
|
|
|
void (*buf_free)(struct rpc_task *task);
|
2018-09-04 11:58:59 +08:00
|
|
|
int (*send_request)(struct rpc_rqst *req);
|
2005-08-26 07:25:50 +08:00
|
|
|
void (*set_retrans_timeout)(struct rpc_task *task);
|
2013-01-08 22:48:15 +08:00
|
|
|
void (*timer)(struct rpc_xprt *xprt, struct rpc_task *task);
|
2005-08-26 07:25:53 +08:00
|
|
|
void (*release_request)(struct rpc_task *task);
|
2005-08-12 04:25:23 +08:00
|
|
|
void (*close)(struct rpc_xprt *xprt);
|
|
|
|
|
void (*destroy)(struct rpc_xprt *xprt);
|
2017-02-09 00:17:54 +08:00
|
|
|
void (*set_connect_timeout)(struct rpc_xprt *xprt,
|
|
|
|
|
unsigned long connect_timeout,
|
|
|
|
|
unsigned long reconnect_timeout);
|
2006-03-21 02:44:16 +08:00
|
|
|
void (*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
|
2015-06-04 04:14:29 +08:00
|
|
|
int (*enable_swap)(struct rpc_xprt *xprt);
|
|
|
|
|
void (*disable_swap)(struct rpc_xprt *xprt);
|
2015-05-12 02:02:25 +08:00
|
|
|
void (*inject_disconnect)(struct rpc_xprt *xprt);
|
2015-10-25 05:27:35 +08:00
|
|
|
int (*bc_setup)(struct rpc_xprt *xprt,
|
|
|
|
|
unsigned int min_reqs);
|
2015-10-25 05:28:32 +08:00
|
|
|
int (*bc_up)(struct svc_serv *serv, struct net *net);
|
2016-05-03 02:40:40 +08:00
|
|
|
size_t (*bc_maxpayload)(struct rpc_xprt *xprt);
|
2015-10-25 05:27:35 +08:00
|
|
|
void (*bc_free_rqst)(struct rpc_rqst *rqst);
|
|
|
|
|
void (*bc_destroy)(struct rpc_xprt *xprt,
|
|
|
|
|
unsigned int max_reqs);
|
2005-08-12 04:25:23 +08:00
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-10 22:33:30 +08:00
|
|
|
/*
|
|
|
|
|
* RPC transport identifiers
|
|
|
|
|
*
|
|
|
|
|
* To preserve compatibility with the historical use of raw IP protocol
|
|
|
|
|
* id's for transport selection, UDP and TCP identifiers are specified
|
|
|
|
|
* with the previous values. No such restriction exists for new transports,
|
|
|
|
|
* except that they may not collide with these values (17 and 6,
|
|
|
|
|
* respectively).
|
|
|
|
|
*/
|
|
|
|
|
#define XPRT_TRANSPORT_BC (1 << 31)
|
|
|
|
|
enum xprt_transports {
|
|
|
|
|
XPRT_TRANSPORT_UDP = IPPROTO_UDP,
|
|
|
|
|
XPRT_TRANSPORT_TCP = IPPROTO_TCP,
|
|
|
|
|
XPRT_TRANSPORT_BC_TCP = IPPROTO_TCP | XPRT_TRANSPORT_BC,
|
2011-05-10 03:22:44 +08:00
|
|
|
XPRT_TRANSPORT_RDMA = 256,
|
2015-10-25 05:28:16 +08:00
|
|
|
XPRT_TRANSPORT_BC_RDMA = XPRT_TRANSPORT_RDMA | XPRT_TRANSPORT_BC,
|
2011-05-10 03:22:44 +08:00
|
|
|
XPRT_TRANSPORT_LOCAL = 257,
|
2009-09-10 22:33:30 +08:00
|
|
|
};
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct rpc_xprt {
|
2015-02-25 09:31:39 +08:00
|
|
|
struct kref kref; /* Reference count */
|
2017-08-02 00:00:39 +08:00
|
|
|
const struct rpc_xprt_ops *ops; /* transport methods */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-12-21 05:03:55 +08:00
|
|
|
const struct rpc_timeout *timeout; /* timeout parms */
|
2006-08-23 08:06:19 +08:00
|
|
|
struct sockaddr_storage addr; /* server address */
|
|
|
|
|
size_t addrlen; /* size of server address */
|
2005-04-17 06:20:36 +08:00
|
|
|
int prot; /* IP protocol */
|
|
|
|
|
|
|
|
|
|
unsigned long cong; /* current congestion */
|
|
|
|
|
unsigned long cwnd; /* congestion window */
|
|
|
|
|
|
|
|
|
|
size_t max_payload; /* largest RPC payload size,
|
|
|
|
|
in bytes */
|
2005-08-26 07:25:49 +08:00
|
|
|
unsigned int tsh_size; /* size of transport specific
|
|
|
|
|
header */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-23 08:06:15 +08:00
|
|
|
struct rpc_wait_queue binding; /* requests waiting on rpcbind */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct rpc_wait_queue sending; /* requests waiting to send */
|
|
|
|
|
struct rpc_wait_queue pending; /* requests in flight */
|
|
|
|
|
struct rpc_wait_queue backlog; /* waiting for slot */
|
|
|
|
|
struct list_head free; /* free slots */
|
2011-07-18 06:11:30 +08:00
|
|
|
unsigned int max_reqs; /* max number of slots */
|
|
|
|
|
unsigned int min_reqs; /* min number of slots */
|
2018-03-06 04:13:13 +08:00
|
|
|
unsigned int num_reqs; /* total slots */
|
2005-08-12 04:25:38 +08:00
|
|
|
unsigned long state; /* transport state */
|
2012-09-12 05:21:25 +08:00
|
|
|
unsigned char resvport : 1; /* use a reserved port */
|
2015-06-04 04:14:26 +08:00
|
|
|
atomic_t swapper; /* we're swapping over this
|
2012-08-01 07:45:12 +08:00
|
|
|
transport */
|
2007-03-30 04:48:04 +08:00
|
|
|
unsigned int bind_index; /* bind function index */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-02-15 09:31:59 +08:00
|
|
|
/*
|
|
|
|
|
* Multipath
|
|
|
|
|
*/
|
|
|
|
|
struct list_head xprt_switch;
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-08-12 04:25:47 +08:00
|
|
|
* Connection of transports
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-04-17 04:42:12 +08:00
|
|
|
unsigned long bind_timeout,
|
2005-08-26 07:25:55 +08:00
|
|
|
reestablish_timeout;
|
2008-04-18 04:52:57 +08:00
|
|
|
unsigned int connect_cookie; /* A cookie that gets bumped
|
|
|
|
|
every time the transport
|
|
|
|
|
is reconnected */
|
2005-08-26 07:25:55 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-08-12 04:25:47 +08:00
|
|
|
* Disconnection of idle transports
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
struct work_struct task_cleanup;
|
|
|
|
|
struct timer_list timer;
|
2005-08-26 07:25:55 +08:00
|
|
|
unsigned long last_used,
|
2016-08-04 12:08:45 +08:00
|
|
|
idle_timeout,
|
2017-02-09 00:17:54 +08:00
|
|
|
connect_timeout,
|
2016-08-04 12:08:45 +08:00
|
|
|
max_reconnect_timeout;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Send stuff
|
|
|
|
|
*/
|
2005-08-12 04:25:32 +08:00
|
|
|
spinlock_t transport_lock; /* lock transport info */
|
2005-08-12 04:25:35 +08:00
|
|
|
spinlock_t reserve_lock; /* lock slot table */
|
2018-08-31 22:21:00 +08:00
|
|
|
spinlock_t queue_lock; /* send/receive queue lock */
|
2006-10-18 02:44:24 +08:00
|
|
|
u32 xid; /* Next XID value to use */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct rpc_task * snd_task; /* Task blocked in send */
|
2018-08-10 11:33:21 +08:00
|
|
|
|
|
|
|
|
struct list_head xmit_queue; /* Send queue */
|
|
|
|
|
|
2009-09-10 22:32:28 +08:00
|
|
|
struct svc_xprt *bc_xprt; /* NFSv4.1 backchannel */
|
2011-07-14 07:20:49 +08:00
|
|
|
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
|
2009-04-01 21:22:58 +08:00
|
|
|
struct svc_serv *bc_serv; /* The RPC service which will */
|
|
|
|
|
/* process the callback */
|
2015-06-05 03:37:10 +08:00
|
|
|
int bc_alloc_count; /* Total number of preallocs */
|
|
|
|
|
atomic_t bc_free_slots;
|
2009-04-01 21:22:58 +08:00
|
|
|
spinlock_t bc_pa_lock; /* Protects the preallocated
|
|
|
|
|
* items */
|
|
|
|
|
struct list_head bc_pa_list; /* List of preallocated
|
|
|
|
|
* backchannel rpc_rqst's */
|
2011-07-14 07:20:49 +08:00
|
|
|
#endif /* CONFIG_SUNRPC_BACKCHANNEL */
|
2018-08-08 21:23:32 +08:00
|
|
|
|
2018-09-07 20:35:22 +08:00
|
|
|
struct rb_root recv_queue; /* Receive queue */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-21 02:44:16 +08:00
|
|
|
struct {
|
|
|
|
|
unsigned long bind_count, /* total number of binds */
|
|
|
|
|
connect_count, /* total number of connects */
|
|
|
|
|
connect_start, /* connect start timestamp */
|
|
|
|
|
connect_time, /* jiffies waiting for connect */
|
|
|
|
|
sends, /* how many complete requests */
|
|
|
|
|
recvs, /* how many complete requests */
|
2012-02-15 05:19:18 +08:00
|
|
|
bad_xids, /* lookup_rqst didn't find XID */
|
|
|
|
|
max_slots; /* max rpc_slots used */
|
2006-03-21 02:44:16 +08:00
|
|
|
|
|
|
|
|
unsigned long long req_u, /* average requests on the wire */
|
2012-02-15 05:19:18 +08:00
|
|
|
bklog_u, /* backlog queue utilization */
|
|
|
|
|
sending_u, /* send q utilization */
|
|
|
|
|
pending_u; /* pend q utilization */
|
2006-03-21 02:44:16 +08:00
|
|
|
} stat;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-09-29 20:05:43 +08:00
|
|
|
struct net *xprt_net;
|
2012-03-02 06:01:05 +08:00
|
|
|
const char *servername;
|
2008-01-08 07:34:48 +08:00
|
|
|
const char *address_strings[RPC_DISPLAY_MAX];
|
2014-11-27 03:44:44 +08:00
|
|
|
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
|
|
|
|
|
struct dentry *debugfs; /* debugfs directory */
|
2015-05-12 02:02:25 +08:00
|
|
|
atomic_t inject_disconnect;
|
2014-11-27 03:44:44 +08:00
|
|
|
#endif
|
2015-02-15 06:48:49 +08:00
|
|
|
struct rcu_head rcu;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2011-07-14 07:20:49 +08:00
|
|
|
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
|
2009-04-01 21:22:58 +08:00
|
|
|
/*
|
|
|
|
|
* Backchannel flags
|
|
|
|
|
*/
|
|
|
|
|
#define RPC_BC_PA_IN_USE 0x0001 /* Preallocated backchannel */
|
|
|
|
|
/* buffer in use */
|
2011-07-14 07:20:49 +08:00
|
|
|
#endif /* CONFIG_SUNRPC_BACKCHANNEL */
|
2009-04-01 21:22:58 +08:00
|
|
|
|
2011-07-14 07:20:49 +08:00
|
|
|
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
|
2009-04-01 21:23:03 +08:00
|
|
|
static inline int bc_prealloc(struct rpc_rqst *req)
|
|
|
|
|
{
|
|
|
|
|
return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static inline int bc_prealloc(struct rpc_rqst *req)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2011-07-14 07:20:49 +08:00
|
|
|
#endif /* CONFIG_SUNRPC_BACKCHANNEL */
|
2009-04-01 21:23:03 +08:00
|
|
|
|
2013-04-14 23:42:00 +08:00
|
|
|
#define XPRT_CREATE_INFINITE_SLOTS (1U)
|
2013-04-12 03:06:36 +08:00
|
|
|
#define XPRT_CREATE_NO_IDLE_TIMEOUT (1U << 1)
|
2013-04-14 23:42:00 +08:00
|
|
|
|
2007-09-11 01:47:07 +08:00
|
|
|
struct xprt_create {
|
2007-09-11 01:47:57 +08:00
|
|
|
int ident; /* XPRT_TRANSPORT identifier */
|
2010-09-29 20:05:12 +08:00
|
|
|
struct net * net;
|
2007-07-10 04:23:35 +08:00
|
|
|
struct sockaddr * srcaddr; /* optional local address */
|
2007-07-08 19:08:54 +08:00
|
|
|
struct sockaddr * dstaddr; /* remote peer address */
|
|
|
|
|
size_t addrlen;
|
2012-03-02 06:01:05 +08:00
|
|
|
const char *servername;
|
2009-09-10 22:33:30 +08:00
|
|
|
struct svc_xprt *bc_xprt; /* NFSv4.1 backchannel */
|
2016-05-18 00:38:21 +08:00
|
|
|
struct rpc_xprt_switch *bc_xps;
|
2013-04-14 23:42:00 +08:00
|
|
|
unsigned int flags;
|
2007-07-08 19:08:54 +08:00
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-09-11 01:46:00 +08:00
|
|
|
struct xprt_class {
|
|
|
|
|
struct list_head list;
|
2007-09-11 01:47:57 +08:00
|
|
|
int ident; /* XPRT_TRANSPORT identifier */
|
2007-09-11 01:47:07 +08:00
|
|
|
struct rpc_xprt * (*setup)(struct xprt_create *);
|
2007-09-11 01:46:00 +08:00
|
|
|
struct module *owner;
|
|
|
|
|
char name[32];
|
|
|
|
|
};
|
|
|
|
|
|
2005-08-12 04:25:47 +08:00
|
|
|
/*
|
|
|
|
|
* Generic internal transport functions
|
|
|
|
|
*/
|
2007-09-11 01:47:07 +08:00
|
|
|
struct rpc_xprt *xprt_create_transport(struct xprt_create *args);
|
2005-08-12 04:25:47 +08:00
|
|
|
void xprt_connect(struct rpc_task *task);
|
|
|
|
|
void xprt_reserve(struct rpc_task *task);
|
2013-04-14 22:49:37 +08:00
|
|
|
void xprt_retry_reserve(struct rpc_task *task);
|
2011-07-18 04:01:03 +08:00
|
|
|
int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
|
|
|
|
|
int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
|
2012-09-07 23:08:50 +08:00
|
|
|
void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task);
|
2018-05-05 03:34:59 +08:00
|
|
|
void xprt_free_slot(struct rpc_xprt *xprt,
|
|
|
|
|
struct rpc_rqst *req);
|
2013-09-26 00:17:18 +08:00
|
|
|
bool xprt_prepare_transmit(struct rpc_task *task);
|
2018-08-10 11:33:21 +08:00
|
|
|
void xprt_request_enqueue_transmit(struct rpc_task *task);
|
2018-08-23 05:55:46 +08:00
|
|
|
void xprt_request_enqueue_receive(struct rpc_task *task);
|
2018-08-23 12:03:43 +08:00
|
|
|
void xprt_request_wait_receive(struct rpc_task *task);
|
2018-08-25 04:28:28 +08:00
|
|
|
bool xprt_request_need_retransmit(struct rpc_task *task);
|
2005-08-12 04:25:47 +08:00
|
|
|
void xprt_transmit(struct rpc_task *task);
|
2006-07-28 05:22:50 +08:00
|
|
|
void xprt_end_transmit(struct rpc_task *task);
|
2005-04-17 06:20:36 +08:00
|
|
|
int xprt_adjust_timeout(struct rpc_rqst *req);
|
2005-08-26 07:25:51 +08:00
|
|
|
void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
|
|
|
|
|
void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
|
2005-08-12 04:25:47 +08:00
|
|
|
void xprt_release(struct rpc_task *task);
|
2015-02-25 09:31:39 +08:00
|
|
|
struct rpc_xprt * xprt_get(struct rpc_xprt *xprt);
|
2006-09-06 00:55:57 +08:00
|
|
|
void xprt_put(struct rpc_xprt *xprt);
|
2011-07-18 06:11:30 +08:00
|
|
|
struct rpc_xprt * xprt_alloc(struct net *net, size_t size,
|
|
|
|
|
unsigned int num_prealloc,
|
|
|
|
|
unsigned int max_req);
|
2010-09-29 20:03:13 +08:00
|
|
|
void xprt_free(struct rpc_xprt *);
|
2005-08-12 04:25:47 +08:00
|
|
|
|
2006-09-27 13:29:38 +08:00
|
|
|
static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *p)
|
2005-08-26 07:25:49 +08:00
|
|
|
{
|
|
|
|
|
return p + xprt->tsh_size;
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-04 04:14:29 +08:00
|
|
|
static inline int
|
|
|
|
|
xprt_enable_swap(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return xprt->ops->enable_swap(xprt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
xprt_disable_swap(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
xprt->ops->disable_swap(xprt);
|
|
|
|
|
}
|
|
|
|
|
|
2005-08-12 04:25:47 +08:00
|
|
|
/*
|
|
|
|
|
* Transport switch helper functions
|
|
|
|
|
*/
|
2007-09-11 01:46:00 +08:00
|
|
|
int xprt_register_transport(struct xprt_class *type);
|
|
|
|
|
int xprt_unregister_transport(struct xprt_class *type);
|
2009-03-12 02:37:56 +08:00
|
|
|
int xprt_load_transport(const char *);
|
2005-08-26 07:25:50 +08:00
|
|
|
void xprt_set_retrans_timeout_def(struct rpc_task *task);
|
|
|
|
|
void xprt_set_retrans_timeout_rtt(struct rpc_task *task);
|
2005-08-12 04:25:47 +08:00
|
|
|
void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
|
2018-09-04 11:39:27 +08:00
|
|
|
void xprt_wait_for_buffer_space(struct rpc_xprt *xprt);
|
|
|
|
|
bool xprt_write_space(struct rpc_xprt *xprt);
|
2013-01-08 22:48:15 +08:00
|
|
|
void xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result);
|
2006-09-27 13:29:38 +08:00
|
|
|
struct rpc_rqst * xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
|
2018-03-06 04:12:57 +08:00
|
|
|
void xprt_update_rtt(struct rpc_task *task);
|
2005-08-26 07:25:52 +08:00
|
|
|
void xprt_complete_rqst(struct rpc_task *task, int copied);
|
2017-08-13 22:03:59 +08:00
|
|
|
void xprt_pin_rqst(struct rpc_rqst *req);
|
|
|
|
|
void xprt_unpin_rqst(struct rpc_rqst *req);
|
2005-08-26 07:25:53 +08:00
|
|
|
void xprt_release_rqst_cong(struct rpc_task *task);
|
2018-09-04 05:37:36 +08:00
|
|
|
bool xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req);
|
2007-11-07 07:44:20 +08:00
|
|
|
void xprt_disconnect_done(struct rpc_xprt *xprt);
|
2007-11-06 23:18:36 +08:00
|
|
|
void xprt_force_disconnect(struct rpc_xprt *xprt);
|
2008-04-18 04:52:57 +08:00
|
|
|
void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
|
2005-08-12 04:25:47 +08:00
|
|
|
|
2015-02-09 07:19:25 +08:00
|
|
|
bool xprt_lock_connect(struct rpc_xprt *, struct rpc_task *, void *);
|
|
|
|
|
void xprt_unlock_connect(struct rpc_xprt *, void *);
|
|
|
|
|
|
2005-08-12 04:25:38 +08:00
|
|
|
/*
|
|
|
|
|
* Reserved bit positions in xprt->state
|
|
|
|
|
*/
|
|
|
|
|
#define XPRT_LOCKED (0)
|
|
|
|
|
#define XPRT_CONNECTED (1)
|
|
|
|
|
#define XPRT_CONNECTING (2)
|
2006-01-03 16:55:55 +08:00
|
|
|
#define XPRT_CLOSE_WAIT (3)
|
2006-08-23 08:06:15 +08:00
|
|
|
#define XPRT_BOUND (4)
|
2006-08-23 08:06:15 +08:00
|
|
|
#define XPRT_BINDING (5)
|
2007-11-06 06:42:39 +08:00
|
|
|
#define XPRT_CLOSING (6)
|
2013-04-14 22:49:37 +08:00
|
|
|
#define XPRT_CONGESTED (9)
|
2018-09-04 05:37:36 +08:00
|
|
|
#define XPRT_CWND_WAIT (10)
|
2018-09-04 11:39:27 +08:00
|
|
|
#define XPRT_WRITE_SPACE (11)
|
2005-08-12 04:25:38 +08:00
|
|
|
|
|
|
|
|
static inline void xprt_set_connected(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
set_bit(XPRT_CONNECTED, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void xprt_clear_connected(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
clear_bit(XPRT_CONNECTED, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int xprt_connected(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return test_bit(XPRT_CONNECTED, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int xprt_test_and_set_connected(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return test_and_set_bit(XPRT_CONNECTED, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int xprt_test_and_clear_connected(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return test_and_clear_bit(XPRT_CONNECTED, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void xprt_clear_connecting(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
2014-03-18 01:06:10 +08:00
|
|
|
smp_mb__before_atomic();
|
2005-08-12 04:25:38 +08:00
|
|
|
clear_bit(XPRT_CONNECTING, &xprt->state);
|
2014-03-18 01:06:10 +08:00
|
|
|
smp_mb__after_atomic();
|
2005-08-12 04:25:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int xprt_connecting(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return test_bit(XPRT_CONNECTING, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int xprt_test_and_set_connecting(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return test_and_set_bit(XPRT_CONNECTING, &xprt->state);
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-23 08:06:15 +08:00
|
|
|
static inline void xprt_set_bound(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
test_and_set_bit(XPRT_BOUND, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int xprt_bound(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return test_bit(XPRT_BOUND, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void xprt_clear_bound(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
clear_bit(XPRT_BOUND, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
2006-08-23 08:06:15 +08:00
|
|
|
static inline void xprt_clear_binding(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
2014-03-18 01:06:10 +08:00
|
|
|
smp_mb__before_atomic();
|
2006-08-23 08:06:15 +08:00
|
|
|
clear_bit(XPRT_BINDING, &xprt->state);
|
2014-03-18 01:06:10 +08:00
|
|
|
smp_mb__after_atomic();
|
2006-08-23 08:06:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int xprt_test_and_set_binding(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
return test_and_set_bit(XPRT_BINDING, &xprt->state);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-12 02:02:25 +08:00
|
|
|
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
|
|
|
|
|
extern unsigned int rpc_inject_disconnect;
|
|
|
|
|
static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
if (!rpc_inject_disconnect)
|
|
|
|
|
return;
|
|
|
|
|
if (atomic_dec_return(&xprt->inject_disconnect))
|
|
|
|
|
return;
|
|
|
|
|
atomic_set(&xprt->inject_disconnect, rpc_inject_disconnect);
|
|
|
|
|
xprt->ops->inject_disconnect(xprt);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* __KERNEL__*/
|
|
|
|
|
|
|
|
|
|
#endif /* _LINUX_SUNRPC_XPRT_H */
|