[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / 9p / trans_common.c

/*
 * Copyright IBM Corporation, 2010
 * Author Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2.1 of the GNU Lesser General Public License
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

#include <linux/slab.h>
#include <linux/module.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include <linux/scatterlist.h>
#include "trans_common.h"

/**
 *  p9_release_req_pages - Release pages after the transaction.
 *  @*private: PDU's private page of struct trans_rpage_info
 */
void
p9_release_req_pages(struct trans_rpage_info *rpinfo)
{
	int i = 0;

	while (rpinfo->rp_data[i] && rpinfo->rp_nr_pages--) {
		put_page(rpinfo->rp_data[i]);
		i++;
	}
}
EXPORT_SYMBOL(p9_release_req_pages);

/**
 * p9_nr_pages - Return number of pages needed to accommodate the payload.
 */
int
p9_nr_pages(struct p9_req_t *req)
{
	unsigned long start_page, end_page;
	start_page =  (unsigned long)req->tc->pubuf >> PAGE_SHIFT;
	end_page = ((unsigned long)req->tc->pubuf + req->tc->pbuf_size +
			PAGE_SIZE - 1) >> PAGE_SHIFT;
	return end_page - start_page;
}
EXPORT_SYMBOL(p9_nr_pages);

/**
 * payload_gup - Translates user buffer into kernel pages and
 * pins them either for read/write through get_user_pages_fast().
 * @req: Request to be sent to server.
 * @pdata_off: data offset into the first page after translation (gup).
 * @pdata_len: Total length of the IO. gup may not return requested # of pages.
 * @nr_pages: number of pages to accommodate the payload
 * @rw: Indicates if the pages are for read or write.
 */
int
p9_payload_gup(struct p9_req_t *req, size_t *pdata_off, int *pdata_len,
		int nr_pages, u8 rw)
{
	uint32_t first_page_bytes = 0;
	int32_t pdata_mapped_pages;
	struct trans_rpage_info  *rpinfo;

	*pdata_off = (__force size_t)req->tc->pubuf & (PAGE_SIZE-1);

	if (*pdata_off)
		first_page_bytes = min(((size_t)PAGE_SIZE - *pdata_off),
				       req->tc->pbuf_size);

	rpinfo = req->tc->private;
	pdata_mapped_pages = get_user_pages_fast((unsigned long)req->tc->pubuf,
			nr_pages, rw, &rpinfo->rp_data[0]);
	if (pdata_mapped_pages <= 0)
		return pdata_mapped_pages;

	rpinfo->rp_nr_pages = pdata_mapped_pages;
	if (*pdata_off) {
		*pdata_len = first_page_bytes;
		*pdata_len += min((req->tc->pbuf_size - *pdata_len),
				((size_t)pdata_mapped_pages - 1) << PAGE_SHIFT);
	} else {
		*pdata_len = min(req->tc->pbuf_size,
				(size_t)pdata_mapped_pages << PAGE_SHIFT);
	}
	return 0;
}
EXPORT_SYMBOL(p9_payload_gup);
Commit	Line	Data
022cae36 VJJ	1	/*
	2	* Copyright IBM Corporation, 2010
	3	* Author Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of version 2.1 of the GNU Lesser General Public License
	7	* as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it would be useful, but
	10	* WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	12	*
	13	*/
	14
	15	#include <linux/slab.h>
	16	#include <linux/module.h>
	17	#include <net/9p/9p.h>
	18	#include <net/9p/client.h>
	19	#include <linux/scatterlist.h>
	20	#include "trans_common.h"
	21
	22	/**
	23	* p9_release_req_pages - Release pages after the transaction.
	24	* @*private: PDU's private page of struct trans_rpage_info
	25	*/
	26	void
	27	p9_release_req_pages(struct trans_rpage_info *rpinfo)
	28	{
	29	int i = 0;
	30
	31	while (rpinfo->rp_data[i] && rpinfo->rp_nr_pages--) {
	32	put_page(rpinfo->rp_data[i]);
	33	i++;
	34	}
	35	}
	36	EXPORT_SYMBOL(p9_release_req_pages);
	37
	38	/**
25985edc	39	* p9_nr_pages - Return number of pages needed to accommodate the payload.
022cae36 VJJ	40	*/
	41	int
	42	p9_nr_pages(struct p9_req_t *req)
	43	{
472e7f9f AK	44	unsigned long start_page, end_page;
	45	start_page = (unsigned long)req->tc->pubuf >> PAGE_SHIFT;
	46	end_page = ((unsigned long)req->tc->pubuf + req->tc->pbuf_size +
022cae36 VJJ	47	PAGE_SIZE - 1) >> PAGE_SHIFT;
	48	return end_page - start_page;
	49	}
	50	EXPORT_SYMBOL(p9_nr_pages);
	51
	52	/**
	53	* payload_gup - Translates user buffer into kernel pages and
	54	* pins them either for read/write through get_user_pages_fast().
	55	* @req: Request to be sent to server.
	56	* @pdata_off: data offset into the first page after translation (gup).
	57	* @pdata_len: Total length of the IO. gup may not return requested # of pages.
25985edc	58	* @nr_pages: number of pages to accommodate the payload
022cae36 VJJ	59	* @rw: Indicates if the pages are for read or write.
	60	*/
	61	int
	62	p9_payload_gup(struct p9_req_t req, size_t pdata_off, int *pdata_len,
	63	int nr_pages, u8 rw)
	64	{
	65	uint32_t first_page_bytes = 0;
3cd79678	66	int32_t pdata_mapped_pages;
022cae36 VJJ	67	struct trans_rpage_info *rpinfo;
022cae36 VJJ	68
bd8c8ade	69	*pdata_off = (__force size_t)req->tc->pubuf & (PAGE_SIZE-1);
022cae36 VJJ	70
022cae36 VJJ	71	if (*pdata_off)
472e7f9f AK	72	first_page_bytes = min(((size_t)PAGE_SIZE - *pdata_off),
472e7f9f AK	73	req->tc->pbuf_size);
022cae36 VJJ	74
	75	rpinfo = req->tc->private;
	76	pdata_mapped_pages = get_user_pages_fast((unsigned long)req->tc->pubuf,
	77	nr_pages, rw, &rpinfo->rp_data[0]);
3cd79678 MK	78	if (pdata_mapped_pages <= 0)
3cd79678 MK	79	return pdata_mapped_pages;
022cae36	80
022cae36 VJJ	81	rpinfo->rp_nr_pages = pdata_mapped_pages;
	82	if (*pdata_off) {
	83	*pdata_len = first_page_bytes;
	84	pdata_len += min((req->tc->pbuf_size - pdata_len),
	85	((size_t)pdata_mapped_pages - 1) << PAGE_SHIFT);
	86	} else {
	87	*pdata_len = min(req->tc->pbuf_size,
	88	(size_t)pdata_mapped_pages << PAGE_SHIFT);
	89	}
	90	return 0;
	91	}
	92	EXPORT_SYMBOL(p9_payload_gup);