1
2
3
4
5
6
7
8
9
10
11
12#include <linux/slab.h>
13#include <linux/file.h>
14#include <linux/sched.h>
15#include <linux/sunrpc/clnt.h>
16#include <linux/nfs3.h>
17#include <linux/nfs4.h>
18#include <linux/nfs_page.h>
19#include <linux/nfs_fs.h>
20#include <linux/nfs_mount.h>
21
22#include "internal.h"
23
24static struct kmem_cache *nfs_page_cachep;
25
26static inline struct nfs_page *
27nfs_page_alloc(void)
28{
29 struct nfs_page *p;
30 p = kmem_cache_alloc(nfs_page_cachep, GFP_KERNEL);
31 if (p) {
32 memset(p, 0, sizeof(*p));
33 INIT_LIST_HEAD(&p->wb_list);
34 }
35 return p;
36}
37
38static inline void
39nfs_page_free(struct nfs_page *p)
40{
41 kmem_cache_free(nfs_page_cachep, p);
42}
43
44
45
46
47
48
49
50
51
52
53
54
55
56struct nfs_page *
57nfs_create_request(struct nfs_open_context *ctx, struct inode *inode,
58 struct page *page,
59 unsigned int offset, unsigned int count)
60{
61 struct nfs_page *req;
62
63 for (;;) {
64
65 req = nfs_page_alloc();
66 if (req != NULL)
67 break;
68
69 if (fatal_signal_pending(current))
70 return ERR_PTR(-ERESTARTSYS);
71 yield();
72 }
73
74
75
76
77 req->wb_page = page;
78 atomic_set(&req->wb_complete, 0);
79 req->wb_index = page->index;
80 page_cache_get(page);
81 BUG_ON(PagePrivate(page));
82 BUG_ON(!PageLocked(page));
83 BUG_ON(page->mapping->host != inode);
84 req->wb_offset = offset;
85 req->wb_pgbase = offset;
86 req->wb_bytes = count;
87 req->wb_context = get_nfs_open_context(ctx);
88 kref_init(&req->wb_kref);
89 return req;
90}
91
92
93
94
95
96void nfs_unlock_request(struct nfs_page *req)
97{
98 if (!NFS_WBACK_BUSY(req)) {
99 printk(KERN_ERR "NFS: Invalid unlock attempted\n");
100 BUG();
101 }
102 smp_mb__before_clear_bit();
103 clear_bit(PG_BUSY, &req->wb_flags);
104 smp_mb__after_clear_bit();
105 wake_up_bit(&req->wb_flags, PG_BUSY);
106 nfs_release_request(req);
107}
108
109
110
111
112
113int nfs_set_page_tag_locked(struct nfs_page *req)
114{
115 struct nfs_inode *nfsi = NFS_I(req->wb_context->path.dentry->d_inode);
116
117 if (!nfs_lock_request_dontget(req))
118 return 0;
119 if (req->wb_page != NULL)
120 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
121 return 1;
122}
123
124
125
126
127void nfs_clear_page_tag_locked(struct nfs_page *req)
128{
129 struct inode *inode = req->wb_context->path.dentry->d_inode;
130 struct nfs_inode *nfsi = NFS_I(inode);
131
132 if (req->wb_page != NULL) {
133 spin_lock(&inode->i_lock);
134 radix_tree_tag_clear(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
135 nfs_unlock_request(req);
136 spin_unlock(&inode->i_lock);
137 } else
138 nfs_unlock_request(req);
139}
140
141
142
143
144
145
146
147
148void nfs_clear_request(struct nfs_page *req)
149{
150 struct page *page = req->wb_page;
151 if (page != NULL) {
152 page_cache_release(page);
153 req->wb_page = NULL;
154 }
155}
156
157
158
159
160
161
162
163
164static void nfs_free_request(struct kref *kref)
165{
166 struct nfs_page *req = container_of(kref, struct nfs_page, wb_kref);
167
168
169 nfs_clear_request(req);
170 put_nfs_open_context(req->wb_context);
171 nfs_page_free(req);
172}
173
174void nfs_release_request(struct nfs_page *req)
175{
176 kref_put(&req->wb_kref, nfs_free_request);
177}
178
179
180
181
182
183
184
185
186int
187nfs_wait_on_request(struct nfs_page *req)
188{
189 int ret = 0;
190
191 if (!test_bit(PG_BUSY, &req->wb_flags))
192 goto out;
193 ret = out_of_line_wait_on_bit(&req->wb_flags, PG_BUSY,
194 nfs_wait_bit_killable, TASK_KILLABLE);
195out:
196 return ret;
197}
198
199
200
201
202
203
204
205
206
207void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
208 struct inode *inode,
209 int (*doio)(struct inode *, struct list_head *, unsigned int, size_t, int),
210 size_t bsize,
211 int io_flags)
212{
213 INIT_LIST_HEAD(&desc->pg_list);
214 desc->pg_bytes_written = 0;
215 desc->pg_count = 0;
216 desc->pg_bsize = bsize;
217 desc->pg_base = 0;
218 desc->pg_inode = inode;
219 desc->pg_doio = doio;
220 desc->pg_ioflags = io_flags;
221 desc->pg_error = 0;
222}
223
224
225
226
227
228
229
230
231
232
233
234
235static int nfs_can_coalesce_requests(struct nfs_page *prev,
236 struct nfs_page *req)
237{
238 if (req->wb_context->cred != prev->wb_context->cred)
239 return 0;
240 if (req->wb_context->lockowner != prev->wb_context->lockowner)
241 return 0;
242 if (req->wb_context->state != prev->wb_context->state)
243 return 0;
244 if (req->wb_index != (prev->wb_index + 1))
245 return 0;
246 if (req->wb_pgbase != 0)
247 return 0;
248 if (prev->wb_pgbase + prev->wb_bytes != PAGE_CACHE_SIZE)
249 return 0;
250 return 1;
251}
252
253
254
255
256
257
258
259
260
261static int nfs_pageio_do_add_request(struct nfs_pageio_descriptor *desc,
262 struct nfs_page *req)
263{
264 size_t newlen = req->wb_bytes;
265
266 if (desc->pg_count != 0) {
267 struct nfs_page *prev;
268
269
270
271
272
273
274
275
276 if (desc->pg_bsize < PAGE_SIZE)
277 return 0;
278 newlen += desc->pg_count;
279 if (newlen > desc->pg_bsize)
280 return 0;
281 prev = nfs_list_entry(desc->pg_list.prev);
282 if (!nfs_can_coalesce_requests(prev, req))
283 return 0;
284 } else
285 desc->pg_base = req->wb_pgbase;
286 nfs_list_remove_request(req);
287 nfs_list_add_request(req, &desc->pg_list);
288 desc->pg_count = newlen;
289 return 1;
290}
291
292
293
294
295static void nfs_pageio_doio(struct nfs_pageio_descriptor *desc)
296{
297 if (!list_empty(&desc->pg_list)) {
298 int error = desc->pg_doio(desc->pg_inode,
299 &desc->pg_list,
300 nfs_page_array_len(desc->pg_base,
301 desc->pg_count),
302 desc->pg_count,
303 desc->pg_ioflags);
304 if (error < 0)
305 desc->pg_error = error;
306 else
307 desc->pg_bytes_written += desc->pg_count;
308 }
309 if (list_empty(&desc->pg_list)) {
310 desc->pg_count = 0;
311 desc->pg_base = 0;
312 }
313}
314
315
316
317
318
319
320
321
322
323int nfs_pageio_add_request(struct nfs_pageio_descriptor *desc,
324 struct nfs_page *req)
325{
326 while (!nfs_pageio_do_add_request(desc, req)) {
327 nfs_pageio_doio(desc);
328 if (desc->pg_error < 0)
329 return 0;
330 }
331 return 1;
332}
333
334
335
336
337
338void nfs_pageio_complete(struct nfs_pageio_descriptor *desc)
339{
340 nfs_pageio_doio(desc);
341}
342
343
344
345
346
347
348
349
350
351
352
353
354void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *desc, pgoff_t index)
355{
356 if (!list_empty(&desc->pg_list)) {
357 struct nfs_page *prev = nfs_list_entry(desc->pg_list.prev);
358 if (index != prev->wb_index + 1)
359 nfs_pageio_doio(desc);
360 }
361}
362
363#define NFS_SCAN_MAXENTRIES 16
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378int nfs_scan_list(struct nfs_inode *nfsi,
379 struct list_head *dst, pgoff_t idx_start,
380 unsigned int npages, int tag)
381{
382 struct nfs_page *pgvec[NFS_SCAN_MAXENTRIES];
383 struct nfs_page *req;
384 pgoff_t idx_end;
385 int found, i;
386 int res;
387
388 res = 0;
389 if (npages == 0)
390 idx_end = ~0;
391 else
392 idx_end = idx_start + npages - 1;
393
394 for (;;) {
395 found = radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree,
396 (void **)&pgvec[0], idx_start,
397 NFS_SCAN_MAXENTRIES, tag);
398 if (found <= 0)
399 break;
400 for (i = 0; i < found; i++) {
401 req = pgvec[i];
402 if (req->wb_index > idx_end)
403 goto out;
404 idx_start = req->wb_index + 1;
405 if (nfs_set_page_tag_locked(req)) {
406 kref_get(&req->wb_kref);
407 nfs_list_remove_request(req);
408 radix_tree_tag_clear(&nfsi->nfs_page_tree,
409 req->wb_index, tag);
410 nfs_list_add_request(req, dst);
411 res++;
412 if (res == INT_MAX)
413 goto out;
414 }
415 }
416
417 cond_resched_lock(&nfsi->vfs_inode.i_lock);
418 }
419out:
420 return res;
421}
422
423int __init nfs_init_nfspagecache(void)
424{
425 nfs_page_cachep = kmem_cache_create("nfs_page",
426 sizeof(struct nfs_page),
427 0, SLAB_HWCACHE_ALIGN,
428 NULL);
429 if (nfs_page_cachep == NULL)
430 return -ENOMEM;
431
432 return 0;
433}
434
435void nfs_destroy_nfspagecache(void)
436{
437 kmem_cache_destroy(nfs_page_cachep);
438}
439
440