[deliverable/linux.git] / drivers / s390 / scsi / zfcp_reqlist.h

/*
 * zfcp device driver
 *
 * Data structure and helper functions for tracking pending FSF
 * requests.
 *
 * Copyright IBM Corp. 2009
 */

#ifndef ZFCP_REQLIST_H
#define ZFCP_REQLIST_H

/* number of hash buckets */
#define ZFCP_REQ_LIST_BUCKETS 128

/**
 * struct zfcp_reqlist - Container for request list (reqlist)
 * @lock: Spinlock for protecting the hash list
 * @list: Array of hashbuckets, each is a list of requests in this bucket
 */
struct zfcp_reqlist {
	spinlock_t lock;
	struct list_head buckets[ZFCP_REQ_LIST_BUCKETS];
};

static inline int zfcp_reqlist_hash(unsigned long req_id)
{
	return req_id % ZFCP_REQ_LIST_BUCKETS;
}

/**
 * zfcp_reqlist_alloc - Allocate and initialize reqlist
 *
 * Returns pointer to allocated reqlist on success, or NULL on
 * allocation failure.
 */
static inline struct zfcp_reqlist *zfcp_reqlist_alloc(void)
{
	unsigned int i;
	struct zfcp_reqlist *rl;

	rl = kzalloc(sizeof(struct zfcp_reqlist), GFP_KERNEL);
	if (!rl)
		return NULL;

	spin_lock_init(&rl->lock);

	for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
		INIT_LIST_HEAD(&rl->buckets[i]);

	return rl;
}

/**
 * zfcp_reqlist_isempty - Check whether the request list empty
 * @rl: pointer to reqlist
 *
 * Returns: 1 if list is empty, 0 if not
 */
static inline int zfcp_reqlist_isempty(struct zfcp_reqlist *rl)
{
	unsigned int i;

	for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
		if (!list_empty(&rl->buckets[i]))
			return 0;
	return 1;
}

/**
 * zfcp_reqlist_free - Free allocated memory for reqlist
 * @rl: The reqlist where to free memory
 */
static inline void zfcp_reqlist_free(struct zfcp_reqlist *rl)
{
	/* sanity check */
	BUG_ON(!zfcp_reqlist_isempty(rl));

	kfree(rl);
}

static inline struct zfcp_fsf_req *
_zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
{
	struct zfcp_fsf_req *req;
	unsigned int i;

	i = zfcp_reqlist_hash(req_id);
	list_for_each_entry(req, &rl->buckets[i], list)
		if (req->req_id == req_id)
			return req;
	return NULL;
}

/**
 * zfcp_reqlist_find - Lookup FSF request by its request id
 * @rl: The reqlist where to lookup the FSF request
 * @req_id: The request id to look for
 *
 * Returns a pointer to the FSF request with the specified request id
 * or NULL if there is no known FSF request with this id.
 */
static inline struct zfcp_fsf_req *
zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
{
	unsigned long flags;
	struct zfcp_fsf_req *req;

	spin_lock_irqsave(&rl->lock, flags);
	req = _zfcp_reqlist_find(rl, req_id);
	spin_unlock_irqrestore(&rl->lock, flags);

	return req;
}

/**
 * zfcp_reqlist_find_rm - Lookup request by id and remove it from reqlist
 * @rl: reqlist where to search and remove entry
 * @req_id: The request id of the request to look for
 *
 * This functions tries to find the FSF request with the specified
 * id and then removes it from the reqlist. The reqlist lock is held
 * during both steps of the operation.
 *
 * Returns: Pointer to the FSF request if the request has been found,
 * NULL if it has not been found.
 */
static inline struct zfcp_fsf_req *
zfcp_reqlist_find_rm(struct zfcp_reqlist *rl, unsigned long req_id)
{
	unsigned long flags;
	struct zfcp_fsf_req *req;

	spin_lock_irqsave(&rl->lock, flags);
	req = _zfcp_reqlist_find(rl, req_id);
	if (req)
		list_del(&req->list);
	spin_unlock_irqrestore(&rl->lock, flags);

	return req;
}

/**
 * zfcp_reqlist_add - Add entry to reqlist
 * @rl: reqlist where to add the entry
 * @req: The entry to add
 *
 * The request id always increases. As an optimization new requests
 * are added here with list_add_tail at the end of the bucket lists
 * while old requests are looked up starting at the beginning of the
 * lists.
 */
static inline void zfcp_reqlist_add(struct zfcp_reqlist *rl,
				    struct zfcp_fsf_req *req)
{
	unsigned int i;
	unsigned long flags;

	i = zfcp_reqlist_hash(req->req_id);

	spin_lock_irqsave(&rl->lock, flags);
	list_add_tail(&req->list, &rl->buckets[i]);
	spin_unlock_irqrestore(&rl->lock, flags);
}

/**
 * zfcp_reqlist_move - Move all entries from reqlist to simple list
 * @rl: The zfcp_reqlist where to remove all entries
 * @list: The list where to move all entries
 */
static inline void zfcp_reqlist_move(struct zfcp_reqlist *rl,
				     struct list_head *list)
{
	unsigned int i;
	unsigned long flags;

	spin_lock_irqsave(&rl->lock, flags);
	for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
		list_splice_init(&rl->buckets[i], list);
	spin_unlock_irqrestore(&rl->lock, flags);
}

#endif /* ZFCP_REQLIST_H */
Commit	Line	Data
b6bd2fb9 CS	1	/*
	2	* zfcp device driver
	3	*
	4	* Data structure and helper functions for tracking pending FSF
	5	* requests.
	6	*
a53c8fab	7	* Copyright IBM Corp. 2009
b6bd2fb9 CS	8	*/
	9
	10	#ifndef ZFCP_REQLIST_H
	11	#define ZFCP_REQLIST_H
	12
	13	/* number of hash buckets */
	14	#define ZFCP_REQ_LIST_BUCKETS 128
	15
	16	/**
	17	* struct zfcp_reqlist - Container for request list (reqlist)
	18	* @lock: Spinlock for protecting the hash list
	19	* @list: Array of hashbuckets, each is a list of requests in this bucket
	20	*/
	21	struct zfcp_reqlist {
	22	spinlock_t lock;
	23	struct list_head buckets[ZFCP_REQ_LIST_BUCKETS];
	24	};
	25
	26	static inline int zfcp_reqlist_hash(unsigned long req_id)
	27	{
	28	return req_id % ZFCP_REQ_LIST_BUCKETS;
	29	}
	30
	31	/**
	32	* zfcp_reqlist_alloc - Allocate and initialize reqlist
	33	*
	34	* Returns pointer to allocated reqlist on success, or NULL on
	35	* allocation failure.
	36	*/
	37	static inline struct zfcp_reqlist *zfcp_reqlist_alloc(void)
	38	{
	39	unsigned int i;
	40	struct zfcp_reqlist *rl;
	41
	42	rl = kzalloc(sizeof(struct zfcp_reqlist), GFP_KERNEL);
	43	if (!rl)
	44	return NULL;
	45
	46	spin_lock_init(&rl->lock);
	47
	48	for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
	49	INIT_LIST_HEAD(&rl->buckets[i]);
	50
	51	return rl;
	52	}
	53
	54	/**
	55	* zfcp_reqlist_isempty - Check whether the request list empty
	56	* @rl: pointer to reqlist
	57	*
	58	* Returns: 1 if list is empty, 0 if not
	59	*/
	60	static inline int zfcp_reqlist_isempty(struct zfcp_reqlist *rl)
	61	{
	62	unsigned int i;
	63
	64	for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
	65	if (!list_empty(&rl->buckets[i]))
	66	return 0;
	67	return 1;
	68	}
	69
	70	/**
	71	* zfcp_reqlist_free - Free allocated memory for reqlist
72	* @rl: The reqlist where to free memory
73	*/
74	static inline void zfcp_reqlist_free(struct zfcp_reqlist *rl)
75	{
76	/* sanity check */
77	BUG_ON(!zfcp_reqlist_isempty(rl));
78
79	kfree(rl);
80	}
81
82	static inline struct zfcp_fsf_req *
83	_zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
84	{
85	struct zfcp_fsf_req *req;
86	unsigned int i;
87
88	i = zfcp_reqlist_hash(req_id);
89	list_for_each_entry(req, &rl->buckets[i], list)
90	if (req->req_id == req_id)
91	return req;
92	return NULL;
93	}
94
95	/**
96	* zfcp_reqlist_find - Lookup FSF request by its request id
97	* @rl: The reqlist where to lookup the FSF request
98	* @req_id: The request id to look for
99	*
100	* Returns a pointer to the FSF request with the specified request id
101	* or NULL if there is no known FSF request with this id.
102	*/
103	static inline struct zfcp_fsf_req *
104	zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
105	{
106	unsigned long flags;
107	struct zfcp_fsf_req *req;
108
109	spin_lock_irqsave(&rl->lock, flags);
110	req = _zfcp_reqlist_find(rl, req_id);
111	spin_unlock_irqrestore(&rl->lock, flags);
112
113	return req;
114	}
115
116	/**
117	* zfcp_reqlist_find_rm - Lookup request by id and remove it from reqlist
118	* @rl: reqlist where to search and remove entry
119	* @req_id: The request id of the request to look for
120	*
121	* This functions tries to find the FSF request with the specified
122	* id and then removes it from the reqlist. The reqlist lock is held
123	* during both steps of the operation.
124	*
125	* Returns: Pointer to the FSF request if the request has been found,
126	* NULL if it has not been found.
127	*/
128	static inline struct zfcp_fsf_req *
129	zfcp_reqlist_find_rm(struct zfcp_reqlist *rl, unsigned long req_id)
130	{
131	unsigned long flags;
132	struct zfcp_fsf_req *req;
133
134	spin_lock_irqsave(&rl->lock, flags);
135	req = _zfcp_reqlist_find(rl, req_id);
136	if (req)
137	list_del(&req->list);
138	spin_unlock_irqrestore(&rl->lock, flags);
139
140	return req;
141	}
142
143	/**
144	* zfcp_reqlist_add - Add entry to reqlist
145	* @rl: reqlist where to add the entry
146	* @req: The entry to add
147	*
148	* The request id always increases. As an optimization new requests
149	* are added here with list_add_tail at the end of the bucket lists
150	* while old requests are looked up starting at the beginning of the
151	* lists.
152	*/
153	static inline void zfcp_reqlist_add(struct zfcp_reqlist *rl,
154	struct zfcp_fsf_req *req)
155	{
156	unsigned int i;
157	unsigned long flags;
158
159	i = zfcp_reqlist_hash(req->req_id);
160
161	spin_lock_irqsave(&rl->lock, flags);
162	list_add_tail(&req->list, &rl->buckets[i]);
163	spin_unlock_irqrestore(&rl->lock, flags);
164	}
165
166	/**
167	* zfcp_reqlist_move - Move all entries from reqlist to simple list
168	* @rl: The zfcp_reqlist where to remove all entries
169	* @list: The list where to move all entries
170	*/
171	static inline void zfcp_reqlist_move(struct zfcp_reqlist *rl,
172	struct list_head *list)
173	{
174	unsigned int i;
175	unsigned long flags;
176
177	spin_lock_irqsave(&rl->lock, flags);
178	for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
179	list_splice_init(&rl->buckets[i], list);
180	spin_unlock_irqrestore(&rl->lock, flags);
181	}
182
183	#endif /* ZFCP_REQLIST_H */