[net-next-2.6.git] / net / rds / rdma.h

#ifndef _RDS_RDMA_H
#define _RDS_RDMA_H

#include <linux/rbtree.h>
#include <linux/spinlock.h>
#include <linux/scatterlist.h>

#include "rds.h"

struct rds_mr {
	struct rb_node		r_rb_node;
	atomic_t		r_refcount;
	u32			r_key;

	/* A copy of the creation flags */
	unsigned int		r_use_once:1;
	unsigned int		r_invalidate:1;
	unsigned int		r_write:1;

	/* This is for RDS_MR_DEAD.
	 * It would be nice & consistent to make this part of the above
	 * bit field here, but we need to use test_and_set_bit.
	 */
	unsigned long		r_state;
	struct rds_sock		*r_sock; /* back pointer to the socket that owns us */
	struct rds_transport	*r_trans;
	void			*r_trans_private;
};

/* Flags for mr->r_state */
#define RDS_MR_DEAD		0

struct rds_rdma_op {
	u32			r_key;
	u64			r_remote_addr;
	unsigned int		r_write:1;
	unsigned int		r_fence:1;
	unsigned int		r_notify:1;
	unsigned int		r_recverr:1;
	unsigned int		r_mapped:1;
	struct rds_notifier	*r_notifier;
	unsigned int		r_bytes;
	unsigned int		r_nents;
	unsigned int		r_count;
	struct scatterlist	r_sg[0];
};

static inline rds_rdma_cookie_t rds_rdma_make_cookie(u32 r_key, u32 offset)
{
	return r_key | (((u64) offset) << 32);
}

static inline u32 rds_rdma_cookie_key(rds_rdma_cookie_t cookie)
{
	return cookie;
}

static inline u32 rds_rdma_cookie_offset(rds_rdma_cookie_t cookie)
{
	return cookie >> 32;
}

int rds_get_mr(struct rds_sock *rs, char __user *optval, int optlen);
int rds_get_mr_for_dest(struct rds_sock *rs, char __user *optval, int optlen);
int rds_free_mr(struct rds_sock *rs, char __user *optval, int optlen);
void rds_rdma_drop_keys(struct rds_sock *rs);
int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
			  struct cmsghdr *cmsg);
int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
			  struct cmsghdr *cmsg);
int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
			  struct cmsghdr *cmsg);
int rds_cmsg_rdma_map(struct rds_sock *rs, struct rds_message *rm,
			  struct cmsghdr *cmsg);
void rds_rdma_free_op(struct rds_rdma_op *ro);
void rds_rdma_send_complete(struct rds_message *rm, int);

extern void __rds_put_mr_final(struct rds_mr *mr);
static inline void rds_mr_put(struct rds_mr *mr)
{
	if (atomic_dec_and_test(&mr->r_refcount))
		__rds_put_mr_final(mr);
}

#endif
Commit	Line	Data
eff5f53b AG	1	#ifndef _RDS_RDMA_H
	2	#define _RDS_RDMA_H
	3
	4	#include <linux/rbtree.h>
	5	#include <linux/spinlock.h>
	6	#include <linux/scatterlist.h>
	7
	8	#include "rds.h"
	9
	10	struct rds_mr {
	11	struct rb_node r_rb_node;
	12	atomic_t r_refcount;
	13	u32 r_key;
	14
	15	/* A copy of the creation flags */
	16	unsigned int r_use_once:1;
	17	unsigned int r_invalidate:1;
	18	unsigned int r_write:1;
	19
	20	/* This is for RDS_MR_DEAD.
	21	* It would be nice & consistent to make this part of the above
	22	* bit field here, but we need to use test_and_set_bit.
	23	*/
	24	unsigned long r_state;
	25	struct rds_sock r_sock; / back pointer to the socket that owns us */
	26	struct rds_transport *r_trans;
	27	void *r_trans_private;
	28	};
	29
	30	/* Flags for mr->r_state */
	31	#define RDS_MR_DEAD 0
	32
	33	struct rds_rdma_op {
	34	u32 r_key;
	35	u64 r_remote_addr;
	36	unsigned int r_write:1;
	37	unsigned int r_fence:1;
	38	unsigned int r_notify:1;
	39	unsigned int r_recverr:1;
	40	unsigned int r_mapped:1;
	41	struct rds_notifier *r_notifier;
	42	unsigned int r_bytes;
	43	unsigned int r_nents;
	44	unsigned int r_count;
	45	struct scatterlist r_sg[0];
	46	};
	47
	48	static inline rds_rdma_cookie_t rds_rdma_make_cookie(u32 r_key, u32 offset)
	49	{
	50	return r_key \| (((u64) offset) << 32);
	51	}
	52
	53	static inline u32 rds_rdma_cookie_key(rds_rdma_cookie_t cookie)
	54	{
	55	return cookie;
	56	}
	57
	58	static inline u32 rds_rdma_cookie_offset(rds_rdma_cookie_t cookie)
	59	{
	60	return cookie >> 32;
	61	}
	62
	63	int rds_get_mr(struct rds_sock rs, char __user optval, int optlen);
244546f0	64	int rds_get_mr_for_dest(struct rds_sock rs, char __user optval, int optlen);
eff5f53b AG	65	int rds_free_mr(struct rds_sock rs, char __user optval, int optlen);
	66	void rds_rdma_drop_keys(struct rds_sock *rs);
	67	int rds_cmsg_rdma_args(struct rds_sock rs, struct rds_message rm,
	68	struct cmsghdr *cmsg);
	69	int rds_cmsg_rdma_dest(struct rds_sock rs, struct rds_message rm,
	70	struct cmsghdr *cmsg);
	71	int rds_cmsg_rdma_args(struct rds_sock rs, struct rds_message rm,
	72	struct cmsghdr *cmsg);
	73	int rds_cmsg_rdma_map(struct rds_sock rs, struct rds_message rm,
	74	struct cmsghdr *cmsg);
	75	void rds_rdma_free_op(struct rds_rdma_op *ro);
	76	void rds_rdma_send_complete(struct rds_message *rm, int);
	77
	78	extern void __rds_put_mr_final(struct rds_mr *mr);
	79	static inline void rds_mr_put(struct rds_mr *mr)
	80	{
	81	if (atomic_dec_and_test(&mr->r_refcount))
	82	__rds_put_mr_final(mr);
	83	}
	84
	85	#endif