[net-next-2.6.git] / include / linux / rds.h

/*
 * Copyright (c) 2008 Oracle.  All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */

#ifndef _LINUX_RDS_H
#define _LINUX_RDS_H

#include <linux/types.h>

/* These sparse annotated types shouldn't be in any user
 * visible header file. We should clean this up rather
 * than kludging around them. */
#ifndef __KERNEL__
#define __be16	u_int16_t
#define __be32	u_int32_t
#define __be64	u_int64_t
#endif

#define RDS_IB_ABI_VERSION		0x301

/*
 * setsockopt/getsockopt for SOL_RDS
 */
#define RDS_CANCEL_SENT_TO      	1
#define RDS_GET_MR			2
#define RDS_FREE_MR			3
/* deprecated: RDS_BARRIER 4 */
#define RDS_RECVERR			5
#define RDS_CONG_MONITOR		6

/*
 * Control message types for SOL_RDS.
 *
 * CMSG_RDMA_ARGS (sendmsg)
 *	Request a RDMA transfer to/from the specified
 *	memory ranges.
 *	The cmsg_data is a struct rds_rdma_args.
 * RDS_CMSG_RDMA_DEST (recvmsg, sendmsg)
 *	Kernel informs application about intended
 *	source/destination of a RDMA transfer
 * RDS_CMSG_RDMA_MAP (sendmsg)
 *	Application asks kernel to map the given
 *	memory range into a IB MR, and send the
 *	R_Key along in an RDS extension header.
 *	The cmsg_data is a struct rds_get_mr_args,
 *	the same as for the GET_MR setsockopt.
 * RDS_CMSG_RDMA_STATUS (recvmsg)
 *	Returns the status of a completed RDMA operation.
 */
#define RDS_CMSG_RDMA_ARGS		1
#define RDS_CMSG_RDMA_DEST		2
#define RDS_CMSG_RDMA_MAP		3
#define RDS_CMSG_RDMA_STATUS		4
#define RDS_CMSG_CONG_UPDATE		5

#define RDS_INFO_FIRST			10000
#define RDS_INFO_COUNTERS		10000
#define RDS_INFO_CONNECTIONS		10001
/* 10002 aka RDS_INFO_FLOWS is deprecated */
#define RDS_INFO_SEND_MESSAGES		10003
#define RDS_INFO_RETRANS_MESSAGES       10004
#define RDS_INFO_RECV_MESSAGES          10005
#define RDS_INFO_SOCKETS                10006
#define RDS_INFO_TCP_SOCKETS            10007
#define RDS_INFO_IB_CONNECTIONS		10008
#define RDS_INFO_CONNECTION_STATS	10009
#define RDS_INFO_IWARP_CONNECTIONS	10010
#define RDS_INFO_LAST			10010

struct rds_info_counter {
	u_int8_t	name[32];
	u_int64_t	value;
} __attribute__((packed));

#define RDS_INFO_CONNECTION_FLAG_SENDING	0x01
#define RDS_INFO_CONNECTION_FLAG_CONNECTING	0x02
#define RDS_INFO_CONNECTION_FLAG_CONNECTED	0x04

#define TRANSNAMSIZ	16

struct rds_info_connection {
	u_int64_t	next_tx_seq;
	u_int64_t	next_rx_seq;
	__be32		laddr;
	__be32		faddr;
	u_int8_t	transport[TRANSNAMSIZ];		/* null term ascii */
	u_int8_t	flags;
} __attribute__((packed));

struct rds_info_flow {
	__be32		laddr;
	__be32		faddr;
	u_int32_t	bytes;
	__be16		lport;
	__be16		fport;
} __attribute__((packed));

#define RDS_INFO_MESSAGE_FLAG_ACK               0x01
#define RDS_INFO_MESSAGE_FLAG_FAST_ACK          0x02

struct rds_info_message {
	u_int64_t	seq;
	u_int32_t	len;
	__be32		laddr;
	__be32		faddr;
	__be16		lport;
	__be16		fport;
	u_int8_t	flags;
} __attribute__((packed));

struct rds_info_socket {
	u_int32_t	sndbuf;
	__be32		bound_addr;
	__be32		connected_addr;
	__be16		bound_port;
	__be16		connected_port;
	u_int32_t	rcvbuf;
	u_int64_t	inum;
} __attribute__((packed));

struct rds_info_tcp_socket {
	__be32          local_addr;
	__be16          local_port;
	__be32          peer_addr;
	__be16          peer_port;
	u_int64_t       hdr_rem;
	u_int64_t       data_rem;
	u_int32_t       last_sent_nxt;
	u_int32_t       last_expected_una;
	u_int32_t       last_seen_una;
} __attribute__((packed));

#define RDS_IB_GID_LEN	16
struct rds_info_rdma_connection {
	__be32		src_addr;
	__be32		dst_addr;
	uint8_t		src_gid[RDS_IB_GID_LEN];
	uint8_t		dst_gid[RDS_IB_GID_LEN];

	uint32_t	max_send_wr;
	uint32_t	max_recv_wr;
	uint32_t	max_send_sge;
	uint32_t	rdma_mr_max;
	uint32_t	rdma_mr_size;
};

/*
 * Congestion monitoring.
 * Congestion control in RDS happens at the host connection
 * level by exchanging a bitmap marking congested ports.
 * By default, a process sleeping in poll() is always woken
 * up when the congestion map is updated.
 * With explicit monitoring, an application can have more
 * fine-grained control.
 * The application installs a 64bit mask value in the socket,
 * where each bit corresponds to a group of ports.
 * When a congestion update arrives, RDS checks the set of
 * ports that are now uncongested against the list bit mask
 * installed in the socket, and if they overlap, we queue a
 * cong_notification on the socket.
 *
 * To install the congestion monitor bitmask, use RDS_CONG_MONITOR
 * with the 64bit mask.
 * Congestion updates are received via RDS_CMSG_CONG_UPDATE
 * control messages.
 *
 * The correspondence between bits and ports is
 *	1 << (portnum % 64)
 */
#define RDS_CONG_MONITOR_SIZE	64
#define RDS_CONG_MONITOR_BIT(port)  (((unsigned int) port) % RDS_CONG_MONITOR_SIZE)
#define RDS_CONG_MONITOR_MASK(port) (1ULL << RDS_CONG_MONITOR_BIT(port))

/*
 * RDMA related types
 */

/*
 * This encapsulates a remote memory location.
 * In the current implementation, it contains the R_Key
 * of the remote memory region, and the offset into it
 * (so that the application does not have to worry about
 * alignment).
 */
typedef u_int64_t	rds_rdma_cookie_t;

struct rds_iovec {
	u_int64_t	addr;
	u_int64_t	bytes;
};

struct rds_get_mr_args {
	struct rds_iovec vec;
	u_int64_t	cookie_addr;
	uint64_t	flags;
};

struct rds_free_mr_args {
	rds_rdma_cookie_t cookie;
	u_int64_t	flags;
};

struct rds_rdma_args {
	rds_rdma_cookie_t cookie;
	struct rds_iovec remote_vec;
	u_int64_t	local_vec_addr;
	u_int64_t	nr_local;
	u_int64_t	flags;
	u_int64_t	user_token;
};

struct rds_rdma_notify {
	u_int64_t	user_token;
	int32_t		status;
};

#define RDS_RDMA_SUCCESS	0
#define RDS_RDMA_REMOTE_ERROR	1
#define RDS_RDMA_CANCELED	2
#define RDS_RDMA_DROPPED	3
#define RDS_RDMA_OTHER_ERROR	4

/*
 * Common set of flags for all RDMA related structs
 */
#define RDS_RDMA_READWRITE	0x0001
#define RDS_RDMA_FENCE		0x0002	/* use FENCE for immediate send */
#define RDS_RDMA_INVALIDATE	0x0004	/* invalidate R_Key after freeing MR */
#define RDS_RDMA_USE_ONCE	0x0008	/* free MR after use */
#define RDS_RDMA_DONTWAIT	0x0010	/* Don't wait in SET_BARRIER */
#define RDS_RDMA_NOTIFY_ME	0x0020	/* Notify when operation completes */

#endif /* IB_RDS_H */
Commit	Line	Data
db49b9d2 AG	1	/*
	2	* Copyright (c) 2008 Oracle. All rights reserved.
	3	*
	4	* This software is available to you under a choice of one of two
	5	* licenses. You may choose to be licensed under the terms of the GNU
	6	* General Public License (GPL) Version 2, available from the file
	7	* COPYING in the main directory of this source tree, or the
	8	* OpenIB.org BSD license below:
	9	*
	10	* Redistribution and use in source and binary forms, with or
	11	* without modification, are permitted provided that the following
	12	* conditions are met:
	13	*
	14	* - Redistributions of source code must retain the above
	15	* copyright notice, this list of conditions and the following
	16	* disclaimer.
	17	*
	18	* - Redistributions in binary form must reproduce the above
	19	* copyright notice, this list of conditions and the following
	20	* disclaimer in the documentation and/or other materials
	21	* provided with the distribution.
	22	*
	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	25	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	26	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	27	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	28	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	29	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	30	* SOFTWARE.
	31	*
	32	*/
	33
	34	#ifndef _LINUX_RDS_H
	35	#define _LINUX_RDS_H
	36
	37	#include <linux/types.h>
	38
	39	/* These sparse annotated types shouldn't be in any user
	40	* visible header file. We should clean this up rather
	41	* than kludging around them. */
	42	#ifndef __KERNEL__
	43	#define __be16 u_int16_t
	44	#define __be32 u_int32_t
	45	#define __be64 u_int64_t
	46	#endif
	47
	48	#define RDS_IB_ABI_VERSION 0x301
	49
	50	/*
	51	* setsockopt/getsockopt for SOL_RDS
	52	*/
	53	#define RDS_CANCEL_SENT_TO 1
	54	#define RDS_GET_MR 2
	55	#define RDS_FREE_MR 3
	56	/* deprecated: RDS_BARRIER 4 */
	57	#define RDS_RECVERR 5
	58	#define RDS_CONG_MONITOR 6
	59
	60	/*
	61	* Control message types for SOL_RDS.
	62	*
	63	* CMSG_RDMA_ARGS (sendmsg)
	64	* Request a RDMA transfer to/from the specified
65	* memory ranges.
66	* The cmsg_data is a struct rds_rdma_args.
67	* RDS_CMSG_RDMA_DEST (recvmsg, sendmsg)
68	* Kernel informs application about intended
69	* source/destination of a RDMA transfer
70	* RDS_CMSG_RDMA_MAP (sendmsg)
71	* Application asks kernel to map the given
72	* memory range into a IB MR, and send the
73	* R_Key along in an RDS extension header.
74	* The cmsg_data is a struct rds_get_mr_args,
75	* the same as for the GET_MR setsockopt.
76	* RDS_CMSG_RDMA_STATUS (recvmsg)
77	* Returns the status of a completed RDMA operation.
78	*/
79	#define RDS_CMSG_RDMA_ARGS 1
80	#define RDS_CMSG_RDMA_DEST 2
81	#define RDS_CMSG_RDMA_MAP 3
82	#define RDS_CMSG_RDMA_STATUS 4
83	#define RDS_CMSG_CONG_UPDATE 5
84
85	#define RDS_INFO_FIRST 10000
86	#define RDS_INFO_COUNTERS 10000
87	#define RDS_INFO_CONNECTIONS 10001
88	/* 10002 aka RDS_INFO_FLOWS is deprecated */
89	#define RDS_INFO_SEND_MESSAGES 10003
90	#define RDS_INFO_RETRANS_MESSAGES 10004
91	#define RDS_INFO_RECV_MESSAGES 10005
92	#define RDS_INFO_SOCKETS 10006
93	#define RDS_INFO_TCP_SOCKETS 10007
94	#define RDS_INFO_IB_CONNECTIONS 10008
95	#define RDS_INFO_CONNECTION_STATS 10009
96	#define RDS_INFO_IWARP_CONNECTIONS 10010
97	#define RDS_INFO_LAST 10010
98
99	struct rds_info_counter {
100	u_int8_t name[32];
101	u_int64_t value;
102	} __attribute__((packed));
103
104	#define RDS_INFO_CONNECTION_FLAG_SENDING 0x01
105	#define RDS_INFO_CONNECTION_FLAG_CONNECTING 0x02
106	#define RDS_INFO_CONNECTION_FLAG_CONNECTED 0x04
107
108	#define TRANSNAMSIZ 16
109
110	struct rds_info_connection {
111	u_int64_t next_tx_seq;
112	u_int64_t next_rx_seq;
113	__be32 laddr;
114	__be32 faddr;
115	u_int8_t transport[TRANSNAMSIZ]; /* null term ascii */
116	u_int8_t flags;
117	} __attribute__((packed));
118
119	struct rds_info_flow {
120	__be32 laddr;
121	__be32 faddr;
122	u_int32_t bytes;
123	__be16 lport;
124	__be16 fport;
125	} __attribute__((packed));
126
127	#define RDS_INFO_MESSAGE_FLAG_ACK 0x01
128	#define RDS_INFO_MESSAGE_FLAG_FAST_ACK 0x02
129
130	struct rds_info_message {
131	u_int64_t seq;
132	u_int32_t len;
133	__be32 laddr;
134	__be32 faddr;
135	__be16 lport;
136	__be16 fport;
137	u_int8_t flags;
138	} __attribute__((packed));
139
140	struct rds_info_socket {
141	u_int32_t sndbuf;
142	__be32 bound_addr;
143	__be32 connected_addr;
144	__be16 bound_port;
145	__be16 connected_port;
146	u_int32_t rcvbuf;
147	u_int64_t inum;
148	} __attribute__((packed));
149
70041088 AG	150	struct rds_info_tcp_socket {
	151	__be32 local_addr;
	152	__be16 local_port;
	153	__be32 peer_addr;
	154	__be16 peer_port;
	155	u_int64_t hdr_rem;
	156	u_int64_t data_rem;
	157	u_int32_t last_sent_nxt;
	158	u_int32_t last_expected_una;
	159	u_int32_t last_seen_una;
	160	} __attribute__((packed));
	161
db49b9d2 AG	162	#define RDS_IB_GID_LEN 16
	163	struct rds_info_rdma_connection {
	164	__be32 src_addr;
	165	__be32 dst_addr;
	166	uint8_t src_gid[RDS_IB_GID_LEN];
	167	uint8_t dst_gid[RDS_IB_GID_LEN];
	168
	169	uint32_t max_send_wr;
	170	uint32_t max_recv_wr;
	171	uint32_t max_send_sge;
	172	uint32_t rdma_mr_max;
	173	uint32_t rdma_mr_size;
	174	};
	175
	176	/*
	177	* Congestion monitoring.
	178	* Congestion control in RDS happens at the host connection
	179	* level by exchanging a bitmap marking congested ports.
	180	* By default, a process sleeping in poll() is always woken
	181	* up when the congestion map is updated.
	182	* With explicit monitoring, an application can have more
	183	* fine-grained control.
	184	* The application installs a 64bit mask value in the socket,
	185	* where each bit corresponds to a group of ports.
	186	* When a congestion update arrives, RDS checks the set of
	187	* ports that are now uncongested against the list bit mask
	188	* installed in the socket, and if they overlap, we queue a
	189	* cong_notification on the socket.
	190	*
	191	* To install the congestion monitor bitmask, use RDS_CONG_MONITOR
	192	* with the 64bit mask.
	193	* Congestion updates are received via RDS_CMSG_CONG_UPDATE
	194	* control messages.
	195	*
	196	* The correspondence between bits and ports is
	197	* 1 << (portnum % 64)
	198	*/
	199	#define RDS_CONG_MONITOR_SIZE 64
	200	#define RDS_CONG_MONITOR_BIT(port) (((unsigned int) port) % RDS_CONG_MONITOR_SIZE)
	201	#define RDS_CONG_MONITOR_MASK(port) (1ULL << RDS_CONG_MONITOR_BIT(port))
	202
	203	/*
	204	* RDMA related types
	205	*/
	206
	207	/*
	208	* This encapsulates a remote memory location.
	209	* In the current implementation, it contains the R_Key
	210	* of the remote memory region, and the offset into it
	211	* (so that the application does not have to worry about
	212	* alignment).
	213	*/
	214	typedef u_int64_t rds_rdma_cookie_t;
	215
	216	struct rds_iovec {
	217	u_int64_t addr;
	218	u_int64_t bytes;
	219	};
	220
	221	struct rds_get_mr_args {
	222	struct rds_iovec vec;
	223	u_int64_t cookie_addr;
	224	uint64_t flags;
	225	};
226
227	struct rds_free_mr_args {
228	rds_rdma_cookie_t cookie;
229	u_int64_t flags;
230	};
231
232	struct rds_rdma_args {
233	rds_rdma_cookie_t cookie;
234	struct rds_iovec remote_vec;
235	u_int64_t local_vec_addr;
236	u_int64_t nr_local;
237	u_int64_t flags;
238	u_int64_t user_token;
239	};
240
241	struct rds_rdma_notify {
242	u_int64_t user_token;
243	int32_t status;
244	};
245
246	#define RDS_RDMA_SUCCESS 0
247	#define RDS_RDMA_REMOTE_ERROR 1
248	#define RDS_RDMA_CANCELED 2
249	#define RDS_RDMA_DROPPED 3
250	#define RDS_RDMA_OTHER_ERROR 4
251
252	/*
253	* Common set of flags for all RDMA related structs
254	*/
255	#define RDS_RDMA_READWRITE 0x0001
256	#define RDS_RDMA_FENCE 0x0002 /* use FENCE for immediate send */
257	#define RDS_RDMA_INVALIDATE 0x0004 /* invalidate R_Key after freeing MR */
258	#define RDS_RDMA_USE_ONCE 0x0008 /* free MR after use */
259	#define RDS_RDMA_DONTWAIT 0x0010 /* Don't wait in SET_BARRIER */
260	#define RDS_RDMA_NOTIFY_ME 0x0020 /* Notify when operation completes */
261
262	#endif /* IB_RDS_H */