1// SPDX-License-Identifier: GPL-2.0
2#include <linux/ceph/ceph_debug.h>
3
4#include <linux/module.h>
5#include <linux/sched.h>
6#include <linux/slab.h>
7#include <linux/file.h>
8#include <linux/namei.h>
9#include <linux/writeback.h>
10
11#include <linux/ceph/libceph.h>
12
13void ceph_put_page_vector(struct page **pages, int num_pages, bool dirty)
14{
15	int i;
16
17	for (i = 0; i < num_pages; i++) {
18		if (dirty)
19			set_page_dirty_lock(pages[i]);
20		put_page(pages[i]);
21	}
22	kvfree(pages);
23}
24EXPORT_SYMBOL(ceph_put_page_vector);
25
26void ceph_release_page_vector(struct page **pages, int num_pages)
27{
28	int i;
29
30	for (i = 0; i < num_pages; i++)
31		__free_pages(pages[i], 0);
32	kfree(pages);
33}
34EXPORT_SYMBOL(ceph_release_page_vector);
35
36/*
37 * allocate a vector new pages
38 */
39struct page **ceph_alloc_page_vector(int num_pages, gfp_t flags)
40{
41	struct page **pages;
42	int i;
43
44	pages = kmalloc_array(num_pages, sizeof(*pages), flags);
45	if (!pages)
46		return ERR_PTR(-ENOMEM);
47	for (i = 0; i < num_pages; i++) {
48		pages[i] = __page_cache_alloc(flags);
49		if (pages[i] == NULL) {
50			ceph_release_page_vector(pages, i);
51			return ERR_PTR(-ENOMEM);
52		}
53	}
54	return pages;
55}
56EXPORT_SYMBOL(ceph_alloc_page_vector);
57
58/*
59 * copy user data into a page vector
60 */
61int ceph_copy_user_to_page_vector(struct page **pages,
62					 const void __user *data,
63					 loff_t off, size_t len)
64{
65	int i = 0;
66	int po = off & ~PAGE_MASK;
67	int left = len;
68	int l, bad;
69
70	while (left > 0) {
71		l = min_t(int, PAGE_SIZE-po, left);
72		bad = copy_from_user(page_address(pages[i]) + po, data, l);
73		if (bad == l)
74			return -EFAULT;
75		data += l - bad;
76		left -= l - bad;
77		po += l - bad;
78		if (po == PAGE_SIZE) {
79			po = 0;
80			i++;
81		}
82	}
83	return len;
84}
85EXPORT_SYMBOL(ceph_copy_user_to_page_vector);
86
87void ceph_copy_to_page_vector(struct page **pages,
88				    const void *data,
89				    loff_t off, size_t len)
90{
91	int i = 0;
92	size_t po = off & ~PAGE_MASK;
93	size_t left = len;
94
95	while (left > 0) {
96		size_t l = min_t(size_t, PAGE_SIZE-po, left);
97
98		memcpy(page_address(pages[i]) + po, data, l);
99		data += l;
100		left -= l;
101		po += l;
102		if (po == PAGE_SIZE) {
103			po = 0;
104			i++;
105		}
106	}
107}
108EXPORT_SYMBOL(ceph_copy_to_page_vector);
109
110void ceph_copy_from_page_vector(struct page **pages,
111				    void *data,
112				    loff_t off, size_t len)
113{
114	int i = 0;
115	size_t po = off & ~PAGE_MASK;
116	size_t left = len;
117
118	while (left > 0) {
119		size_t l = min_t(size_t, PAGE_SIZE-po, left);
120
121		memcpy(data, page_address(pages[i]) + po, l);
122		data += l;
123		left -= l;
124		po += l;
125		if (po == PAGE_SIZE) {
126			po = 0;
127			i++;
128		}
129	}
130}
131EXPORT_SYMBOL(ceph_copy_from_page_vector);
132
133/*
134 * Zero an extent within a page vector.  Offset is relative to the
135 * start of the first page.
136 */
137void ceph_zero_page_vector_range(int off, int len, struct page **pages)
138{
139	int i = off >> PAGE_SHIFT;
140
141	off &= ~PAGE_MASK;
142
143	dout("zero_page_vector_page %u~%u\n", off, len);
144
145	/* leading partial page? */
146	if (off) {
147		int end = min((int)PAGE_SIZE, off + len);
148		dout("zeroing %d %p head from %d\n", i, pages[i],
149		     (int)off);
150		zero_user_segment(pages[i], off, end);
151		len -= (end - off);
152		i++;
153	}
154	while (len >= PAGE_SIZE) {
155		dout("zeroing %d %p len=%d\n", i, pages[i], len);
156		zero_user_segment(pages[i], 0, PAGE_SIZE);
157		len -= PAGE_SIZE;
158		i++;
159	}
160	/* trailing partial page? */
161	if (len) {
162		dout("zeroing %d %p tail to %d\n", i, pages[i], (int)len);
163		zero_user_segment(pages[i], 0, len);
164	}
165}
166EXPORT_SYMBOL(ceph_zero_page_vector_range);
167