Whamcloud - gitweb
81c7b9eef5e32b813acf12e855f3f51be25bc36b
[fs/lustre-release.git] / lustre / llite / llite_mmap.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2015, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #include <linux/kernel.h>
38 #include <linux/mm.h>
39 #include <linux/string.h>
40 #include <linux/stat.h>
41 #include <linux/errno.h>
42 #include <linux/unistd.h>
43 #include <linux/version.h>
44 #include <asm/uaccess.h>
45
46 #include <linux/fs.h>
47 #include <linux/stat.h>
48 #include <asm/uaccess.h>
49 #include <linux/mm.h>
50 #include <linux/pagemap.h>
51
52 #define DEBUG_SUBSYSTEM S_LLITE
53
54 #include "llite_internal.h"
55 #include <lustre_compat.h>
56
57 static const struct vm_operations_struct ll_file_vm_ops;
58
59 void policy_from_vma(union ldlm_policy_data *policy, struct vm_area_struct *vma,
60                      unsigned long addr, size_t count)
61 {
62         policy->l_extent.start = ((addr - vma->vm_start) & PAGE_MASK) +
63                                  (vma->vm_pgoff << PAGE_CACHE_SHIFT);
64         policy->l_extent.end = (policy->l_extent.start + count - 1) |
65                                ~PAGE_MASK;
66 }
67
68 struct vm_area_struct *our_vma(struct mm_struct *mm, unsigned long addr,
69                                size_t count)
70 {
71         struct vm_area_struct *vma, *ret = NULL;
72         ENTRY;
73
74         /* mmap_sem must have been held by caller. */
75         LASSERT(!down_write_trylock(&mm->mmap_sem));
76
77         for(vma = find_vma(mm, addr);
78             vma != NULL && vma->vm_start < (addr + count); vma = vma->vm_next) {
79                 if (vma->vm_ops && vma->vm_ops == &ll_file_vm_ops &&
80                     vma->vm_flags & VM_SHARED) {
81                         ret = vma;
82                         break;
83                 }
84         }
85         RETURN(ret);
86 }
87
88 /**
89  * API independent part for page fault initialization.
90  * \param env - corespondent lu_env to processing
91  * \param vma - virtual memory area addressed to page fault
92  * \param index - page index corespondent to fault.
93  * \parm ra_flags - vma readahead flags.
94  *
95  * \return error codes from cl_io_init.
96  */
97 static struct cl_io *
98 ll_fault_io_init(struct lu_env *env, struct vm_area_struct *vma,
99                  pgoff_t index, unsigned long *ra_flags)
100 {
101         struct file            *file = vma->vm_file;
102         struct inode           *inode = file_inode(file);
103         struct cl_io           *io;
104         struct cl_fault_io     *fio;
105         int                     rc;
106         ENTRY;
107
108         if (ll_file_nolock(file))
109                 RETURN(ERR_PTR(-EOPNOTSUPP));
110
111 restart:
112         io = vvp_env_thread_io(env);
113         io->ci_obj = ll_i2info(inode)->lli_clob;
114         LASSERT(io->ci_obj != NULL);
115
116         fio = &io->u.ci_fault;
117         fio->ft_index      = index;
118         fio->ft_executable = vma->vm_flags&VM_EXEC;
119
120         /*
121          * disable VM_SEQ_READ and use VM_RAND_READ to make sure that
122          * the kernel will not read other pages not covered by ldlm in
123          * filemap_nopage. we do our readahead in ll_readpage.
124          */
125         if (ra_flags != NULL)
126                 *ra_flags = vma->vm_flags & (VM_RAND_READ|VM_SEQ_READ);
127         vma->vm_flags &= ~VM_SEQ_READ;
128         vma->vm_flags |= VM_RAND_READ;
129
130         CDEBUG(D_MMAP, "vm_flags: %lx (%lu %d)\n", vma->vm_flags,
131                fio->ft_index, fio->ft_executable);
132
133         rc = cl_io_init(env, io, CIT_FAULT, io->ci_obj);
134         if (rc == 0) {
135                 struct vvp_io *vio = vvp_env_io(env);
136                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
137
138                 LASSERT(vio->vui_cl.cis_io == io);
139
140                 /* mmap lock must be MANDATORY it has to cache
141                  * pages. */
142                 io->ci_lockreq = CILR_MANDATORY;
143                 vio->vui_fd = fd;
144         } else {
145                 LASSERT(rc < 0);
146                 cl_io_fini(env, io);
147                 if (io->ci_need_restart)
148                         goto restart;
149
150                 io = ERR_PTR(rc);
151         }
152
153         RETURN(io);
154 }
155
156 /* Sharing code of page_mkwrite method for rhel5 and rhel6 */
157 static int ll_page_mkwrite0(struct vm_area_struct *vma, struct page *vmpage,
158                             bool *retry)
159 {
160         struct lu_env           *env;
161         struct cl_io            *io;
162         struct vvp_io           *vio;
163         int                      result;
164         __u16                    refcheck;
165         sigset_t                 set;
166         struct inode             *inode;
167         struct ll_inode_info     *lli;
168         ENTRY;
169
170         LASSERT(vmpage != NULL);
171         env = cl_env_get(&refcheck);
172         if (IS_ERR(env))
173                 RETURN(PTR_ERR(env));
174
175         io = ll_fault_io_init(env, vma, vmpage->index, NULL);
176         if (IS_ERR(io))
177                 GOTO(out, result = PTR_ERR(io));
178
179         result = io->ci_result;
180         if (result < 0)
181                 GOTO(out_io, result);
182
183         io->u.ci_fault.ft_mkwrite = 1;
184         io->u.ci_fault.ft_writable = 1;
185
186         vio = vvp_env_io(env);
187         vio->u.fault.ft_vma    = vma;
188         vio->u.fault.ft_vmpage = vmpage;
189
190         set = cfs_block_sigsinv(sigmask(SIGKILL) | sigmask(SIGTERM));
191
192         inode = vvp_object_inode(io->ci_obj);
193         lli = ll_i2info(inode);
194
195         result = cl_io_loop(env, io);
196
197         cfs_restore_sigs(set);
198
199         if (result == 0) {
200                 lock_page(vmpage);
201                 if (vmpage->mapping == NULL) {
202                         unlock_page(vmpage);
203
204                         /* page was truncated and lock was cancelled, return
205                          * ENODATA so that VM_FAULT_NOPAGE will be returned
206                          * to handle_mm_fault(). */
207                         if (result == 0)
208                                 result = -ENODATA;
209                 } else if (!PageDirty(vmpage)) {
210                         /* race, the page has been cleaned by ptlrpcd after
211                          * it was unlocked, it has to be added into dirty
212                          * cache again otherwise this soon-to-dirty page won't
213                          * consume any grants, even worse if this page is being
214                          * transferred because it will break RPC checksum.
215                          */
216                         unlock_page(vmpage);
217
218                         CDEBUG(D_MMAP, "Race on page_mkwrite %p/%lu, page has "
219                                "been written out, retry.\n",
220                                vmpage, vmpage->index);
221
222                         *retry = true;
223                         result = -EAGAIN;
224                 }
225
226                 if (result == 0)
227                         ll_file_set_flag(lli, LLIF_DATA_MODIFIED);
228         }
229         EXIT;
230
231 out_io:
232         cl_io_fini(env, io);
233 out:
234         cl_env_put(env, &refcheck);
235         CDEBUG(D_MMAP, "%s mkwrite with %d\n", current->comm, result);
236         LASSERT(ergo(result == 0, PageLocked(vmpage)));
237
238         return result;
239 }
240
241 static inline int to_fault_error(int result)
242 {
243         switch(result) {
244         case 0:
245                 result = VM_FAULT_LOCKED;
246                 break;
247         case -EFAULT:
248                 result = VM_FAULT_NOPAGE;
249                 break;
250         case -ENOMEM:
251                 result = VM_FAULT_OOM;
252                 break;
253         default:
254                 result = VM_FAULT_SIGBUS;
255                 break;
256         }
257         return result;
258 }
259
260 /**
261  * Lustre implementation of a vm_operations_struct::fault() method, called by
262  * VM to server page fault (both in kernel and user space).
263  *
264  * \param vma - is virtiual area struct related to page fault
265  * \param vmf - structure which describe type and address where hit fault
266  *
267  * \return allocated and filled _locked_ page for address
268  * \retval VM_FAULT_ERROR on general error
269  * \retval NOPAGE_OOM not have memory for allocate new page
270  */
271 static int ll_fault0(struct vm_area_struct *vma, struct vm_fault *vmf)
272 {
273         struct lu_env           *env;
274         struct cl_io            *io;
275         struct vvp_io           *vio = NULL;
276         struct page             *vmpage;
277         unsigned long            ra_flags;
278         int                      result = 0;
279         int                      fault_ret = 0;
280         __u16                    refcheck;
281         ENTRY;
282
283         env = cl_env_get(&refcheck);
284         if (IS_ERR(env))
285                 RETURN(PTR_ERR(env));
286
287         if (ll_sbi_has_fast_read(ll_i2sbi(file_inode(vma->vm_file)))) {
288                 /* do fast fault */
289                 ll_cl_add(vma->vm_file, env, NULL, LCC_MMAP);
290                 fault_ret = filemap_fault(vma, vmf);
291                 ll_cl_remove(vma->vm_file, env);
292
293                 /* - If there is no error, then the page was found in cache and
294                  *   uptodate;
295                  * - If VM_FAULT_RETRY is set, the page existed but failed to
296                  *   lock. It will return to kernel and retry;
297                  * - Otherwise, it should try normal fault under DLM lock. */
298                 if ((fault_ret & VM_FAULT_RETRY) ||
299                     !(fault_ret & VM_FAULT_ERROR))
300                         GOTO(out, result = 0);
301
302                 fault_ret = 0;
303         }
304
305         io = ll_fault_io_init(env, vma, vmf->pgoff, &ra_flags);
306         if (IS_ERR(io))
307                 GOTO(out, result = PTR_ERR(io));
308
309         result = io->ci_result;
310         if (result == 0) {
311                 vio = vvp_env_io(env);
312                 vio->u.fault.ft_vma       = vma;
313                 vio->u.fault.ft_vmpage    = NULL;
314                 vio->u.fault.ft_vmf = vmf;
315                 vio->u.fault.ft_flags = 0;
316                 vio->u.fault.ft_flags_valid = 0;
317
318                 /* May call ll_readpage() */
319                 ll_cl_add(vma->vm_file, env, io, LCC_MMAP);
320
321                 result = cl_io_loop(env, io);
322
323                 ll_cl_remove(vma->vm_file, env);
324
325                 /* ft_flags are only valid if we reached
326                  * the call to filemap_fault */
327                 if (vio->u.fault.ft_flags_valid)
328                         fault_ret = vio->u.fault.ft_flags;
329
330                 vmpage = vio->u.fault.ft_vmpage;
331                 if (result != 0 && vmpage != NULL) {
332                         page_cache_release(vmpage);
333                         vmf->page = NULL;
334                 }
335         }
336         cl_io_fini(env, io);
337
338         vma->vm_flags |= ra_flags;
339
340 out:
341         cl_env_put(env, &refcheck);
342         if (result != 0 && !(fault_ret & VM_FAULT_RETRY))
343                 fault_ret |= to_fault_error(result);
344
345         CDEBUG(D_MMAP, "%s fault %d/%d\n", current->comm, fault_ret, result);
346         RETURN(fault_ret);
347 }
348
349 static int ll_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
350 {
351         int count = 0;
352         bool printed = false;
353         int result;
354         sigset_t set;
355
356         /* Only SIGKILL and SIGTERM is allowed for fault/nopage/mkwrite
357          * so that it can be killed by admin but not cause segfault by
358          * other signals. */
359         set = cfs_block_sigsinv(sigmask(SIGKILL) | sigmask(SIGTERM));
360
361         ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
362                            LPROC_LL_FAULT, 1);
363
364 restart:
365         result = ll_fault0(vma, vmf);
366         if (!(result & (VM_FAULT_RETRY | VM_FAULT_ERROR | VM_FAULT_LOCKED))) {
367                 struct page *vmpage = vmf->page;
368
369                 /* check if this page has been truncated */
370                 lock_page(vmpage);
371                 if (unlikely(vmpage->mapping == NULL)) { /* unlucky */
372                         unlock_page(vmpage);
373                         page_cache_release(vmpage);
374                         vmf->page = NULL;
375
376                         if (!printed && ++count > 16) {
377                                 CWARN("the page is under heavy contention,"
378                                       "maybe your app(%s) needs revising :-)\n",
379                                       current->comm);
380                                 printed = true;
381                         }
382
383                         goto restart;
384                 }
385
386                 result |= VM_FAULT_LOCKED;
387         }
388         cfs_restore_sigs(set);
389         return result;
390 }
391
392 static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
393 {
394         int count = 0;
395         bool printed = false;
396         bool retry;
397         int result;
398
399         ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
400                            LPROC_LL_MKWRITE, 1);
401
402         file_update_time(vma->vm_file);
403         do {
404                 retry = false;
405                 result = ll_page_mkwrite0(vma, vmf->page, &retry);
406
407                 if (!printed && ++count > 16) {
408                         const struct dentry *de = file_dentry(vma->vm_file);
409
410                         CWARN("app(%s): the page %lu of file "DFID" is under"
411                               " heavy contention\n",
412                               current->comm, vmf->pgoff,
413                               PFID(ll_inode2fid(de->d_inode)));
414                         printed = true;
415                 }
416         } while (retry);
417
418         switch(result) {
419         case 0:
420                 LASSERT(PageLocked(vmf->page));
421                 result = VM_FAULT_LOCKED;
422                 break;
423         case -ENODATA:
424         case -EFAULT:
425                 result = VM_FAULT_NOPAGE;
426                 break;
427         case -ENOMEM:
428                 result = VM_FAULT_OOM;
429                 break;
430         case -EAGAIN:
431                 result = VM_FAULT_RETRY;
432                 break;
433         default:
434                 result = VM_FAULT_SIGBUS;
435                 break;
436         }
437
438         return result;
439 }
440
441 /**
442  *  To avoid cancel the locks covering mmapped region for lock cache pressure,
443  *  we track the mapped vma count in vvp_object::vob_mmap_cnt.
444  */
445 static void ll_vm_open(struct vm_area_struct * vma)
446 {
447         struct inode *inode    = file_inode(vma->vm_file);
448         struct vvp_object *vob = cl_inode2vvp(inode);
449
450         ENTRY;
451         LASSERT(vma->vm_file);
452         LASSERT(atomic_read(&vob->vob_mmap_cnt) >= 0);
453         atomic_inc(&vob->vob_mmap_cnt);
454         EXIT;
455 }
456
457 /**
458  * Dual to ll_vm_open().
459  */
460 static void ll_vm_close(struct vm_area_struct *vma)
461 {
462         struct inode      *inode = file_inode(vma->vm_file);
463         struct vvp_object *vob   = cl_inode2vvp(inode);
464
465         ENTRY;
466         LASSERT(vma->vm_file);
467         atomic_dec(&vob->vob_mmap_cnt);
468         LASSERT(atomic_read(&vob->vob_mmap_cnt) >= 0);
469         EXIT;
470 }
471
472 /* XXX put nice comment here.  talk about __free_pte -> dirty pages and
473  * nopage's reference passing to the pte */
474 int ll_teardown_mmaps(struct address_space *mapping, __u64 first, __u64 last)
475 {
476         int rc = -ENOENT;
477         ENTRY;
478
479         LASSERTF(last > first, "last "LPU64" first "LPU64"\n", last, first);
480         if (mapping_mapped(mapping)) {
481                 rc = 0;
482                 unmap_mapping_range(mapping, first + PAGE_CACHE_SIZE - 1,
483                                     last - first + 1, 0);
484         }
485
486         RETURN(rc);
487 }
488
489 static const struct vm_operations_struct ll_file_vm_ops = {
490         .fault                  = ll_fault,
491         .page_mkwrite           = ll_page_mkwrite,
492         .open                   = ll_vm_open,
493         .close                  = ll_vm_close,
494 };
495
496 int ll_file_mmap(struct file *file, struct vm_area_struct * vma)
497 {
498         struct inode *inode = file_inode(file);
499         int rc;
500         ENTRY;
501
502         if (ll_file_nolock(file))
503                 RETURN(-EOPNOTSUPP);
504
505         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_MAP, 1);
506         rc = generic_file_mmap(file, vma);
507         if (rc == 0) {
508                 vma->vm_ops = &ll_file_vm_ops;
509                 vma->vm_ops->open(vma);
510                 /* update the inode's size and mtime */
511                 rc = ll_glimpse_size(inode);
512         }
513
514         RETURN(rc);
515 }