Update files for OpenSSL-1.0.0g import.
[dragonfly.git] / sys / kern / vfs_vm.c
1 /*
2  * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34
35 /*
36  * Implements new VFS/VM coherency functions.  For conforming VFSs
37  * we treat the backing VM object slightly differently.  Instead of
38  * maintaining a number of pages to exactly fit the size of the file
39  * we instead maintain pages to fit the entire contents of the last
40  * buffer cache buffer used by the file.
41  *
42  * For VFSs like NFS and HAMMER which use (generally speaking) fixed
43  * sized buffers this greatly reduces the complexity of VFS/VM interactions.
44  *
45  * Truncations no longer invalidate pages covered by the buffer cache
46  * beyond the file EOF which still fit within the file's last buffer.
47  * We simply unmap them and do not allow userland to fault them in.
48  *
49  * The VFS is no longer responsible for zero-filling buffers during a
50  * truncation, the last buffer will be automatically zero-filled by
51  * nvtruncbuf().
52  *
53  * This code is intended to (eventually) replace vtruncbuf() and
54  * vnode_pager_setsize().
55  */
56
57 #include <sys/param.h>
58 #include <sys/systm.h>
59 #include <sys/buf.h>
60 #include <sys/conf.h>
61 #include <sys/fcntl.h>
62 #include <sys/file.h>
63 #include <sys/kernel.h>
64 #include <sys/malloc.h>
65 #include <sys/mount.h>
66 #include <sys/proc.h>
67 #include <sys/socket.h>
68 #include <sys/stat.h>
69 #include <sys/sysctl.h>
70 #include <sys/unistd.h>
71 #include <sys/vmmeter.h>
72 #include <sys/vnode.h>
73
74 #include <machine/limits.h>
75
76 #include <vm/vm.h>
77 #include <vm/vm_object.h>
78 #include <vm/vm_extern.h>
79 #include <vm/vm_kern.h>
80 #include <vm/pmap.h>
81 #include <vm/vm_map.h>
82 #include <vm/vm_page.h>
83 #include <vm/vm_pager.h>
84 #include <vm/vnode_pager.h>
85 #include <vm/vm_zone.h>
86
87 #include <sys/buf2.h>
88 #include <sys/thread2.h>
89 #include <sys/sysref2.h>
90
91 static int nvtruncbuf_bp_trunc_cmp(struct buf *bp, void *data);
92 static int nvtruncbuf_bp_trunc(struct buf *bp, void *data);
93 static int nvtruncbuf_bp_metasync_cmp(struct buf *bp, void *data);
94 static int nvtruncbuf_bp_metasync(struct buf *bp, void *data);
95
96 /*
97  * Truncate a file's buffer and pages to a specified length. The
98  * byte-granular length of the file is specified along with the block
99  * size of the buffer containing that offset.
100  *
101  * If the last buffer straddles the length its contents will be zero-filled
102  * as appropriate.  All buffers and pages after the last buffer will be
103  * destroyed.  The last buffer itself will be destroyed only if the length
104  * is exactly aligned with it.
105  *
106  * UFS typically passes the old block size prior to the actual truncation,
107  * then later resizes the block based on the new file size.  NFS uses a
108  * fixed block size and doesn't care.  HAMMER uses a block size based on
109  * the offset which is fixed for any particular offset.
110  *
111  * When zero-filling we must bdwrite() to avoid a window of opportunity
112  * where the kernel might throw away a clean buffer and the filesystem
113  * then attempts to bread() it again before completing (or as part of)
114  * the extension.  The filesystem is still responsible for zero-filling
115  * any remainder when writing to the media in the strategy function when
116  * it is able to do so without the page being mapped.  The page may still
117  * be mapped by userland here.
118  *
119  * When modifying a buffer we must clear any cached raw disk offset.
120  * bdwrite() will call BMAP on it again.  Some filesystems, like HAMMER,
121  * never overwrite existing data blocks.
122  */
123
124 struct truncbuf_info {
125         struct vnode *vp;
126         off_t truncloffset;     /* truncation point */
127         int clean;              /* clean tree, else dirty tree */
128 };
129
130 int
131 nvtruncbuf(struct vnode *vp, off_t length, int blksize, int boff)
132 {
133         struct truncbuf_info info;
134         off_t truncboffset;
135         const char *filename;
136         struct buf *bp;
137         int count;
138         int error;
139
140         /*
141          * Round up to the *next* block, then destroy the buffers in question.
142          * Since we are only removing some of the buffers we must rely on the
143          * scan count to determine whether a loop is necessary.
144          *
145          * Destroy any pages beyond the last buffer.
146          */
147         if (boff < 0)
148                 boff = (int)(length % blksize);
149         if (boff)
150                 info.truncloffset = length + (blksize - boff);
151         else
152                 info.truncloffset = length;
153         info.vp = vp;
154         lwkt_gettoken(&vp->v_token);
155         do {
156                 info.clean = 1;
157                 count = RB_SCAN(buf_rb_tree, &vp->v_rbclean_tree,
158                                 nvtruncbuf_bp_trunc_cmp,
159                                 nvtruncbuf_bp_trunc, &info);
160                 info.clean = 0;
161                 count += RB_SCAN(buf_rb_tree, &vp->v_rbdirty_tree,
162                                 nvtruncbuf_bp_trunc_cmp,
163                                 nvtruncbuf_bp_trunc, &info);
164         } while(count);
165
166         nvnode_pager_setsize(vp, length, blksize, boff);
167
168         /*
169          * Zero-fill the area beyond the file EOF that still fits within
170          * the last buffer.  We must mark the buffer as dirty even though
171          * the modified area is beyond EOF to avoid races where the kernel
172          * might flush the buffer before the filesystem is able to reallocate
173          * the block.
174          *
175          * The VFS is responsible for dealing with the actual truncation.
176          */
177         if (boff) {
178                 truncboffset = length - boff;
179                 error = bread(vp, truncboffset, blksize, &bp);
180                 if (error == 0) {
181                         bzero(bp->b_data + boff, blksize - boff);
182                         if (bp->b_flags & B_DELWRI) {
183                                 if (bp->b_dirtyoff > boff)
184                                         bp->b_dirtyoff = boff;
185                                 if (bp->b_dirtyend > boff)
186                                         bp->b_dirtyend = boff;
187                         }
188                         bp->b_bio2.bio_offset = NOOFFSET;
189                         bdwrite(bp);
190                 }
191         } else {
192                 error = 0;
193         }
194
195         /*
196          * For safety, fsync any remaining metadata if the file is not being
197          * truncated to 0.  Since the metadata does not represent the entire
198          * dirty list we have to rely on the hit count to ensure that we get
199          * all of it.
200          *
201          * This is typically applicable only to UFS.  NFS and HAMMER do
202          * not store indirect blocks in the per-vnode buffer cache.
203          */
204         if (length > 0) {
205                 do {
206                         count = RB_SCAN(buf_rb_tree, &vp->v_rbdirty_tree,
207                                         nvtruncbuf_bp_metasync_cmp,
208                                         nvtruncbuf_bp_metasync, &info);
209                 } while (count);
210         }
211
212         /*
213          * It is possible to have in-progress I/O from buffers that were
214          * not part of the truncation.  This should not happen if we
215          * are truncating to 0-length.
216          */
217         bio_track_wait(&vp->v_track_write, 0, 0);
218
219         /*
220          * Debugging only
221          */
222         spin_lock(&vp->v_spin);
223         filename = TAILQ_FIRST(&vp->v_namecache) ?
224                    TAILQ_FIRST(&vp->v_namecache)->nc_name : "?";
225         spin_unlock(&vp->v_spin);
226
227         /*
228          * Make sure no buffers were instantiated while we were trying
229          * to clean out the remaining VM pages.  This could occur due
230          * to busy dirty VM pages being flushed out to disk.
231          */
232         do {
233                 info.clean = 1;
234                 count = RB_SCAN(buf_rb_tree, &vp->v_rbclean_tree,
235                                 nvtruncbuf_bp_trunc_cmp,
236                                 nvtruncbuf_bp_trunc, &info);
237                 info.clean = 0;
238                 count += RB_SCAN(buf_rb_tree, &vp->v_rbdirty_tree,
239                                 nvtruncbuf_bp_trunc_cmp,
240                                 nvtruncbuf_bp_trunc, &info);
241                 if (count) {
242                         kprintf("Warning: vtruncbuf():  Had to re-clean %d "
243                                "left over buffers in %s\n", count, filename);
244                 }
245         } while(count);
246
247         lwkt_reltoken(&vp->v_token);
248
249         return (error);
250 }
251
252 /*
253  * The callback buffer is beyond the new file EOF and must be destroyed.
254  * Note that the compare function must conform to the RB_SCAN's requirements.
255  */
256 static
257 int
258 nvtruncbuf_bp_trunc_cmp(struct buf *bp, void *data)
259 {
260         struct truncbuf_info *info = data;
261
262         if (bp->b_loffset >= info->truncloffset)
263                 return(0);
264         return(-1);
265 }
266
267 static
268 int
269 nvtruncbuf_bp_trunc(struct buf *bp, void *data)
270 {
271         struct truncbuf_info *info = data;
272
273         /*
274          * Do not try to use a buffer we cannot immediately lock,
275          * but sleep anyway to prevent a livelock.  The code will
276          * loop until all buffers can be acted upon.
277          */
278         if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
279                 atomic_add_int(&bp->b_refs, 1);
280                 if (BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL) == 0)
281                         BUF_UNLOCK(bp);
282                 atomic_subtract_int(&bp->b_refs, 1);
283         } else if ((info->clean && (bp->b_flags & B_DELWRI)) ||
284                    (info->clean == 0 && (bp->b_flags & B_DELWRI) == 0) ||
285                    bp->b_vp != info->vp ||
286                    nvtruncbuf_bp_trunc_cmp(bp, data)) {
287                 BUF_UNLOCK(bp);
288         } else {
289                 bremfree(bp);
290                 bp->b_flags |= (B_INVAL | B_RELBUF | B_NOCACHE);
291                 brelse(bp);
292         }
293         return(1);
294 }
295
296 /*
297  * Fsync all meta-data after truncating a file to be non-zero.  Only metadata
298  * blocks (with a negative loffset) are scanned.
299  * Note that the compare function must conform to the RB_SCAN's requirements.
300  */
301 static int
302 nvtruncbuf_bp_metasync_cmp(struct buf *bp, void *data __unused)
303 {
304         if (bp->b_loffset < 0)
305                 return(0);
306         return(1);
307 }
308
309 static int
310 nvtruncbuf_bp_metasync(struct buf *bp, void *data)
311 {
312         struct truncbuf_info *info = data;
313
314         /*
315          * Do not try to use a buffer we cannot immediately lock,
316          * but sleep anyway to prevent a livelock.  The code will
317          * loop until all buffers can be acted upon.
318          */
319         if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
320                 atomic_add_int(&bp->b_refs, 1);
321                 if (BUF_LOCK(bp, LK_EXCLUSIVE|LK_SLEEPFAIL) == 0)
322                         BUF_UNLOCK(bp);
323                 atomic_subtract_int(&bp->b_refs, 1);
324         } else if ((bp->b_flags & B_DELWRI) == 0 ||
325                    bp->b_vp != info->vp ||
326                    nvtruncbuf_bp_metasync_cmp(bp, data)) {
327                 BUF_UNLOCK(bp);
328         } else {
329                 bremfree(bp);
330                 bawrite(bp);
331         }
332         return(1);
333 }
334
335 /*
336  * Extend a file's buffer and pages to a new, larger size.  The block size
337  * at both the old and new length must be passed, but buffer cache operations
338  * will only be performed on the old block.  The new nlength/nblksize will
339  * be used to properly set the VM object size.
340  *
341  * To make this explicit we require the old length to passed even though
342  * we can acquire it from vp->v_filesize, which also avoids potential
343  * corruption if the filesystem and vp get desynchronized somehow.
344  *
345  * If the caller intends to immediately write into the newly extended
346  * space pass trivial == 1.  If trivial is 0 the original buffer will be
347  * zero-filled as necessary to clean out any junk in the extended space.
348  *
349  * When zero-filling we must bdwrite() to avoid a window of opportunity
350  * where the kernel might throw away a clean buffer and the filesystem
351  * then attempts to bread() it again before completing (or as part of)
352  * the extension.  The filesystem is still responsible for zero-filling
353  * any remainder when writing to the media in the strategy function when
354  * it is able to do so without the page being mapped.  The page may still
355  * be mapped by userland here.
356  *
357  * When modifying a buffer we must clear any cached raw disk offset.
358  * bdwrite() will call BMAP on it again.  Some filesystems, like HAMMER,
359  * never overwrite existing data blocks.
360  */
361 int
362 nvextendbuf(struct vnode *vp, off_t olength, off_t nlength,
363             int oblksize, int nblksize, int oboff, int nboff, int trivial)
364 {
365         off_t truncboffset;
366         struct buf *bp;
367         int error;
368
369         error = 0;
370         nvnode_pager_setsize(vp, nlength, nblksize, nboff);
371         if (trivial == 0) {
372                 if (oboff < 0)
373                         oboff = (int)(olength % oblksize);
374                 truncboffset = olength - oboff;
375
376                 if (oboff) {
377                         error = bread(vp, truncboffset, oblksize, &bp);
378                         if (error == 0) {
379                                 bzero(bp->b_data + oboff, oblksize - oboff);
380                                 bp->b_bio2.bio_offset = NOOFFSET;
381                                 bdwrite(bp);
382                         }
383                 }
384         }
385         return (error);
386 }
387
388 /*
389  * Set vp->v_filesize and vp->v_object->size, destroy pages beyond
390  * the last buffer when truncating.
391  *
392  * This function does not do any zeroing or invalidating of partially
393  * overlapping pages.  Zeroing is the responsibility of nvtruncbuf().
394  * However, it does unmap VM pages from the user address space on a
395  * page-granular (verses buffer cache granular) basis.
396  *
397  * If boff is passed as -1 the base offset of the buffer cache buffer is
398  * calculated from length and blksize.  Filesystems such as UFS which deal
399  * with fragments have to specify a boff >= 0 since the base offset cannot
400  * be calculated from length and blksize.
401  *
402  * For UFS blksize is the 'new' blocksize, used only to determine how large
403  * the VM object must become.
404  */
405 void
406 nvnode_pager_setsize(struct vnode *vp, off_t length, int blksize, int boff)
407 {
408         vm_pindex_t nobjsize;
409         vm_pindex_t oobjsize;
410         vm_pindex_t pi;
411         vm_object_t object;
412         vm_page_t m;
413         off_t truncboffset;
414
415         /*
416          * Degenerate conditions
417          */
418         if ((object = vp->v_object) == NULL)
419                 return;
420         vm_object_hold(object);
421         if (length == vp->v_filesize) {
422                 vm_object_drop(object);
423                 return;
424         }
425
426         /*
427          * Calculate the size of the VM object, coverage includes
428          * the buffer straddling EOF.  If EOF is buffer-aligned
429          * we don't bother.
430          *
431          * Buffers do not have to be page-aligned.  Make sure
432          * nobjsize is beyond the last page of the buffer.
433          */
434         if (boff < 0)
435                 boff = (int)(length % blksize);
436         truncboffset = length - boff;
437         oobjsize = object->size;
438         if (boff)
439                 nobjsize = OFF_TO_IDX(truncboffset + blksize + PAGE_MASK);
440         else
441                 nobjsize = OFF_TO_IDX(truncboffset + PAGE_MASK);
442         object->size = nobjsize;
443
444         if (length < vp->v_filesize) {
445                 /*
446                  * File has shrunk, toss any cached pages beyond
447                  * the end of the buffer (blksize aligned) for the
448                  * new EOF.
449                  */
450                 vp->v_filesize = length;
451                 if (nobjsize < oobjsize) {
452                         vm_object_page_remove(object, nobjsize, oobjsize,
453                                               FALSE);
454                 }
455
456                 /*
457                  * Unmap any pages (page aligned) beyond the new EOF.
458                  * The pages remain part of the (last) buffer and are not
459                  * invalidated.
460                  */
461                 pi = OFF_TO_IDX(length + PAGE_MASK);
462                 while (pi < nobjsize) {
463                         m = vm_page_lookup_busy_wait(object, pi, FALSE, "vmpg");
464                         if (m) {
465                                 vm_page_protect(m, VM_PROT_NONE);
466                                 vm_page_wakeup(m);
467                         }
468                         ++pi;
469                 }
470         } else {
471                 /*
472                  * File has expanded.
473                  */
474                 vp->v_filesize = length;
475         }
476         vm_object_drop(object);
477 }