lfs_vnops.c revision 1.213.2.2 1 /* $NetBSD: lfs_vnops.c,v 1.213.2.2 2007/12/19 00:02:02 ad Exp $ */
2
3 /*-
4 * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Konrad E. Schroder <perseant (at) hhhh.org>.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38 /*
39 * Copyright (c) 1986, 1989, 1991, 1993, 1995
40 * The Regents of the University of California. All rights reserved.
41 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 * notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 * notice, this list of conditions and the following disclaimer in the
49 * documentation and/or other materials provided with the distribution.
50 * 3. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95
67 */
68
69 #include <sys/cdefs.h>
70 __KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.213.2.2 2007/12/19 00:02:02 ad Exp $");
71
72 #ifdef _KERNEL_OPT
73 #include "opt_compat_netbsd.h"
74 #endif
75
76 #include <sys/param.h>
77 #include <sys/systm.h>
78 #include <sys/namei.h>
79 #include <sys/resourcevar.h>
80 #include <sys/kernel.h>
81 #include <sys/file.h>
82 #include <sys/stat.h>
83 #include <sys/buf.h>
84 #include <sys/proc.h>
85 #include <sys/mount.h>
86 #include <sys/vnode.h>
87 #include <sys/pool.h>
88 #include <sys/signalvar.h>
89 #include <sys/kauth.h>
90 #include <sys/syslog.h>
91 #include <sys/fstrans.h>
92
93 #include <miscfs/fifofs/fifo.h>
94 #include <miscfs/genfs/genfs.h>
95 #include <miscfs/specfs/specdev.h>
96
97 #include <ufs/ufs/inode.h>
98 #include <ufs/ufs/dir.h>
99 #include <ufs/ufs/ufsmount.h>
100 #include <ufs/ufs/ufs_extern.h>
101
102 #include <uvm/uvm.h>
103 #include <uvm/uvm_pmap.h>
104 #include <uvm/uvm_stat.h>
105 #include <uvm/uvm_pager.h>
106
107 #include <ufs/lfs/lfs.h>
108 #include <ufs/lfs/lfs_extern.h>
109
110 extern pid_t lfs_writer_daemon;
111 int lfs_ignore_lazy_sync = 1;
112
113 /* Global vfs data structures for lfs. */
114 int (**lfs_vnodeop_p)(void *);
115 const struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
116 { &vop_default_desc, vn_default_error },
117 { &vop_lookup_desc, ufs_lookup }, /* lookup */
118 { &vop_create_desc, lfs_create }, /* create */
119 { &vop_whiteout_desc, ufs_whiteout }, /* whiteout */
120 { &vop_mknod_desc, lfs_mknod }, /* mknod */
121 { &vop_open_desc, ufs_open }, /* open */
122 { &vop_close_desc, lfs_close }, /* close */
123 { &vop_access_desc, ufs_access }, /* access */
124 { &vop_getattr_desc, lfs_getattr }, /* getattr */
125 { &vop_setattr_desc, lfs_setattr }, /* setattr */
126 { &vop_read_desc, lfs_read }, /* read */
127 { &vop_write_desc, lfs_write }, /* write */
128 { &vop_lease_desc, ufs_lease_check }, /* lease */
129 { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
130 { &vop_fcntl_desc, lfs_fcntl }, /* fcntl */
131 { &vop_poll_desc, ufs_poll }, /* poll */
132 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */
133 { &vop_revoke_desc, ufs_revoke }, /* revoke */
134 { &vop_mmap_desc, lfs_mmap }, /* mmap */
135 { &vop_fsync_desc, lfs_fsync }, /* fsync */
136 { &vop_seek_desc, ufs_seek }, /* seek */
137 { &vop_remove_desc, lfs_remove }, /* remove */
138 { &vop_link_desc, lfs_link }, /* link */
139 { &vop_rename_desc, lfs_rename }, /* rename */
140 { &vop_mkdir_desc, lfs_mkdir }, /* mkdir */
141 { &vop_rmdir_desc, lfs_rmdir }, /* rmdir */
142 { &vop_symlink_desc, lfs_symlink }, /* symlink */
143 { &vop_readdir_desc, ufs_readdir }, /* readdir */
144 { &vop_readlink_desc, ufs_readlink }, /* readlink */
145 { &vop_abortop_desc, ufs_abortop }, /* abortop */
146 { &vop_inactive_desc, lfs_inactive }, /* inactive */
147 { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
148 { &vop_lock_desc, ufs_lock }, /* lock */
149 { &vop_unlock_desc, ufs_unlock }, /* unlock */
150 { &vop_bmap_desc, ufs_bmap }, /* bmap */
151 { &vop_strategy_desc, lfs_strategy }, /* strategy */
152 { &vop_print_desc, ufs_print }, /* print */
153 { &vop_islocked_desc, ufs_islocked }, /* islocked */
154 { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
155 { &vop_advlock_desc, ufs_advlock }, /* advlock */
156 { &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
157 { &vop_getpages_desc, lfs_getpages }, /* getpages */
158 { &vop_putpages_desc, lfs_putpages }, /* putpages */
159 { NULL, NULL }
160 };
161 const struct vnodeopv_desc lfs_vnodeop_opv_desc =
162 { &lfs_vnodeop_p, lfs_vnodeop_entries };
163
164 int (**lfs_specop_p)(void *);
165 const struct vnodeopv_entry_desc lfs_specop_entries[] = {
166 { &vop_default_desc, vn_default_error },
167 { &vop_lookup_desc, spec_lookup }, /* lookup */
168 { &vop_create_desc, spec_create }, /* create */
169 { &vop_mknod_desc, spec_mknod }, /* mknod */
170 { &vop_open_desc, spec_open }, /* open */
171 { &vop_close_desc, lfsspec_close }, /* close */
172 { &vop_access_desc, ufs_access }, /* access */
173 { &vop_getattr_desc, lfs_getattr }, /* getattr */
174 { &vop_setattr_desc, lfs_setattr }, /* setattr */
175 { &vop_read_desc, ufsspec_read }, /* read */
176 { &vop_write_desc, ufsspec_write }, /* write */
177 { &vop_lease_desc, spec_lease_check }, /* lease */
178 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
179 { &vop_fcntl_desc, ufs_fcntl }, /* fcntl */
180 { &vop_poll_desc, spec_poll }, /* poll */
181 { &vop_kqfilter_desc, spec_kqfilter }, /* kqfilter */
182 { &vop_revoke_desc, spec_revoke }, /* revoke */
183 { &vop_mmap_desc, spec_mmap }, /* mmap */
184 { &vop_fsync_desc, spec_fsync }, /* fsync */
185 { &vop_seek_desc, spec_seek }, /* seek */
186 { &vop_remove_desc, spec_remove }, /* remove */
187 { &vop_link_desc, spec_link }, /* link */
188 { &vop_rename_desc, spec_rename }, /* rename */
189 { &vop_mkdir_desc, spec_mkdir }, /* mkdir */
190 { &vop_rmdir_desc, spec_rmdir }, /* rmdir */
191 { &vop_symlink_desc, spec_symlink }, /* symlink */
192 { &vop_readdir_desc, spec_readdir }, /* readdir */
193 { &vop_readlink_desc, spec_readlink }, /* readlink */
194 { &vop_abortop_desc, spec_abortop }, /* abortop */
195 { &vop_inactive_desc, lfs_inactive }, /* inactive */
196 { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
197 { &vop_lock_desc, ufs_lock }, /* lock */
198 { &vop_unlock_desc, ufs_unlock }, /* unlock */
199 { &vop_bmap_desc, spec_bmap }, /* bmap */
200 { &vop_strategy_desc, spec_strategy }, /* strategy */
201 { &vop_print_desc, ufs_print }, /* print */
202 { &vop_islocked_desc, ufs_islocked }, /* islocked */
203 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
204 { &vop_advlock_desc, spec_advlock }, /* advlock */
205 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
206 { &vop_getpages_desc, spec_getpages }, /* getpages */
207 { &vop_putpages_desc, spec_putpages }, /* putpages */
208 { NULL, NULL }
209 };
210 const struct vnodeopv_desc lfs_specop_opv_desc =
211 { &lfs_specop_p, lfs_specop_entries };
212
213 int (**lfs_fifoop_p)(void *);
214 const struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
215 { &vop_default_desc, vn_default_error },
216 { &vop_lookup_desc, fifo_lookup }, /* lookup */
217 { &vop_create_desc, fifo_create }, /* create */
218 { &vop_mknod_desc, fifo_mknod }, /* mknod */
219 { &vop_open_desc, fifo_open }, /* open */
220 { &vop_close_desc, lfsfifo_close }, /* close */
221 { &vop_access_desc, ufs_access }, /* access */
222 { &vop_getattr_desc, lfs_getattr }, /* getattr */
223 { &vop_setattr_desc, lfs_setattr }, /* setattr */
224 { &vop_read_desc, ufsfifo_read }, /* read */
225 { &vop_write_desc, ufsfifo_write }, /* write */
226 { &vop_lease_desc, fifo_lease_check }, /* lease */
227 { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
228 { &vop_fcntl_desc, ufs_fcntl }, /* fcntl */
229 { &vop_poll_desc, fifo_poll }, /* poll */
230 { &vop_kqfilter_desc, fifo_kqfilter }, /* kqfilter */
231 { &vop_revoke_desc, fifo_revoke }, /* revoke */
232 { &vop_mmap_desc, fifo_mmap }, /* mmap */
233 { &vop_fsync_desc, fifo_fsync }, /* fsync */
234 { &vop_seek_desc, fifo_seek }, /* seek */
235 { &vop_remove_desc, fifo_remove }, /* remove */
236 { &vop_link_desc, fifo_link }, /* link */
237 { &vop_rename_desc, fifo_rename }, /* rename */
238 { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
239 { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
240 { &vop_symlink_desc, fifo_symlink }, /* symlink */
241 { &vop_readdir_desc, fifo_readdir }, /* readdir */
242 { &vop_readlink_desc, fifo_readlink }, /* readlink */
243 { &vop_abortop_desc, fifo_abortop }, /* abortop */
244 { &vop_inactive_desc, lfs_inactive }, /* inactive */
245 { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
246 { &vop_lock_desc, ufs_lock }, /* lock */
247 { &vop_unlock_desc, ufs_unlock }, /* unlock */
248 { &vop_bmap_desc, fifo_bmap }, /* bmap */
249 { &vop_strategy_desc, fifo_strategy }, /* strategy */
250 { &vop_print_desc, ufs_print }, /* print */
251 { &vop_islocked_desc, ufs_islocked }, /* islocked */
252 { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
253 { &vop_advlock_desc, fifo_advlock }, /* advlock */
254 { &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
255 { &vop_putpages_desc, fifo_putpages }, /* putpages */
256 { NULL, NULL }
257 };
258 const struct vnodeopv_desc lfs_fifoop_opv_desc =
259 { &lfs_fifoop_p, lfs_fifoop_entries };
260
261 static int check_dirty(struct lfs *, struct vnode *, off_t, off_t, off_t, int, int, struct vm_page **);
262
263 #define LFS_READWRITE
264 #include <ufs/ufs/ufs_readwrite.c>
265 #undef LFS_READWRITE
266
267 /*
268 * Synch an open file.
269 */
270 /* ARGSUSED */
271 int
272 lfs_fsync(void *v)
273 {
274 struct vop_fsync_args /* {
275 struct vnode *a_vp;
276 kauth_cred_t a_cred;
277 int a_flags;
278 off_t offlo;
279 off_t offhi;
280 } */ *ap = v;
281 struct vnode *vp = ap->a_vp;
282 int error, wait;
283 struct inode *ip = VTOI(vp);
284 struct lfs *fs = ip->i_lfs;
285
286 /* If we're mounted read-only, don't try to sync. */
287 if (fs->lfs_ronly)
288 return 0;
289
290 /*
291 * Trickle sync simply adds this vnode to the pager list, as if
292 * the pagedaemon had requested a pageout.
293 */
294 if (ap->a_flags & FSYNC_LAZY) {
295 if (lfs_ignore_lazy_sync == 0) {
296 mutex_enter(&fs->lfs_interlock);
297 if (!(ip->i_flags & IN_PAGING)) {
298 ip->i_flags |= IN_PAGING;
299 TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip,
300 i_lfs_pchain);
301 }
302 mutex_exit(&fs->lfs_interlock);
303 mutex_enter(&lfs_subsys_lock);
304 wakeup(&lfs_writer_daemon);
305 mutex_exit(&lfs_subsys_lock);
306 }
307 return 0;
308 }
309
310 /*
311 * If a vnode is bring cleaned, flush it out before we try to
312 * reuse it. This prevents the cleaner from writing files twice
313 * in the same partial segment, causing an accounting underflow.
314 */
315 if (ap->a_flags & FSYNC_RECLAIM && ip->i_flags & IN_CLEANING) {
316 lfs_vflush(vp);
317 }
318
319 wait = (ap->a_flags & FSYNC_WAIT);
320 do {
321 mutex_enter(&vp->v_interlock);
322 error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo),
323 round_page(ap->a_offhi),
324 PGO_CLEANIT | (wait ? PGO_SYNCIO : 0));
325 if (error == EAGAIN) {
326 mutex_enter(&fs->lfs_interlock);
327 mtsleep(&fs->lfs_avail, PCATCH | PUSER, "lfs_fsync",
328 hz / 100 + 1, &fs->lfs_interlock);
329 mutex_exit(&fs->lfs_interlock);
330 }
331 } while (error == EAGAIN);
332 if (error)
333 return error;
334
335 if ((ap->a_flags & FSYNC_DATAONLY) == 0)
336 error = lfs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);
337
338 if (error == 0 && ap->a_flags & FSYNC_CACHE) {
339 int l = 0;
340 error = VOP_IOCTL(ip->i_devvp, DIOCCACHESYNC, &l, FWRITE,
341 curlwp->l_cred);
342 }
343 if (wait && !VPISEMPTY(vp))
344 LFS_SET_UINO(ip, IN_MODIFIED);
345
346 return error;
347 }
348
349 /*
350 * Take IN_ADIROP off, then call ufs_inactive.
351 */
352 int
353 lfs_inactive(void *v)
354 {
355 struct vop_inactive_args /* {
356 struct vnode *a_vp;
357 } */ *ap = v;
358
359 KASSERT(VTOI(ap->a_vp)->i_nlink == VTOI(ap->a_vp)->i_ffs_effnlink);
360
361 lfs_unmark_vnode(ap->a_vp);
362
363 /*
364 * The Ifile is only ever inactivated on unmount.
365 * Streamline this process by not giving it more dirty blocks.
366 */
367 if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM) {
368 mutex_enter(&VTOI(ap->a_vp)->i_lfs->lfs_interlock);
369 LFS_CLR_UINO(VTOI(ap->a_vp), IN_ALLMOD);
370 mutex_exit(&VTOI(ap->a_vp)->i_lfs->lfs_interlock);
371 VOP_UNLOCK(ap->a_vp, 0);
372 return 0;
373 }
374
375 return ufs_inactive(v);
376 }
377
378 /*
379 * These macros are used to bracket UFS directory ops, so that we can
380 * identify all the pages touched during directory ops which need to
381 * be ordered and flushed atomically, so that they may be recovered.
382 *
383 * Because we have to mark nodes VDIROP in order to prevent
384 * the cache from reclaiming them while a dirop is in progress, we must
385 * also manage the number of nodes so marked (otherwise we can run out).
386 * We do this by setting lfs_dirvcount to the number of marked vnodes; it
387 * is decremented during segment write, when VDIROP is taken off.
388 */
389 #define MARK_VNODE(vp) lfs_mark_vnode(vp)
390 #define UNMARK_VNODE(vp) lfs_unmark_vnode(vp)
391 #define SET_DIROP_CREATE(dvp, vpp) lfs_set_dirop_create((dvp), (vpp))
392 #define SET_DIROP_REMOVE(dvp, vp) lfs_set_dirop((dvp), (vp))
393 static int lfs_set_dirop_create(struct vnode *, struct vnode **);
394 static int lfs_set_dirop(struct vnode *, struct vnode *);
395
396 static int
397 lfs_set_dirop(struct vnode *dvp, struct vnode *vp)
398 {
399 struct lfs *fs;
400 int error;
401
402 KASSERT(VOP_ISLOCKED(dvp));
403 KASSERT(vp == NULL || VOP_ISLOCKED(vp));
404
405 fs = VTOI(dvp)->i_lfs;
406
407 ASSERT_NO_SEGLOCK(fs);
408 /*
409 * LFS_NRESERVE calculates direct and indirect blocks as well
410 * as an inode block; an overestimate in most cases.
411 */
412 if ((error = lfs_reserve(fs, dvp, vp, LFS_NRESERVE(fs))) != 0)
413 return (error);
414
415 restart:
416 mutex_enter(&fs->lfs_interlock);
417 if (fs->lfs_dirops == 0) {
418 mutex_exit(&fs->lfs_interlock);
419 lfs_check(dvp, LFS_UNUSED_LBN, 0);
420 mutex_enter(&fs->lfs_interlock);
421 }
422 while (fs->lfs_writer) {
423 error = mtsleep(&fs->lfs_dirops, (PRIBIO + 1) | PCATCH,
424 "lfs_sdirop", 0, &fs->lfs_interlock);
425 if (error == EINTR) {
426 mutex_exit(&fs->lfs_interlock);
427 goto unreserve;
428 }
429 }
430 mutex_enter(&lfs_subsys_lock);
431 if (lfs_dirvcount > LFS_MAX_DIROP && fs->lfs_dirops == 0) {
432 wakeup(&lfs_writer_daemon);
433 mutex_exit(&lfs_subsys_lock);
434 mutex_exit(&fs->lfs_interlock);
435 preempt();
436 goto restart;
437 }
438
439 if (lfs_dirvcount > LFS_MAX_DIROP) {
440 mutex_exit(&fs->lfs_interlock);
441 DLOG((DLOG_DIROP, "lfs_set_dirop: sleeping with dirops=%d, "
442 "dirvcount=%d\n", fs->lfs_dirops, lfs_dirvcount));
443 if ((error = mtsleep(&lfs_dirvcount,
444 PCATCH | PUSER | PNORELOCK, "lfs_maxdirop", 0,
445 &lfs_subsys_lock)) != 0) {
446 goto unreserve;
447 }
448 goto restart;
449 }
450 mutex_exit(&lfs_subsys_lock);
451
452 ++fs->lfs_dirops;
453 fs->lfs_doifile = 1;
454 mutex_exit(&fs->lfs_interlock);
455
456 /* Hold a reference so SET_ENDOP will be happy */
457 vref(dvp);
458 if (vp) {
459 vref(vp);
460 MARK_VNODE(vp);
461 }
462
463 MARK_VNODE(dvp);
464 return 0;
465
466 unreserve:
467 lfs_reserve(fs, dvp, vp, -LFS_NRESERVE(fs));
468 return error;
469 }
470
471 /*
472 * Get a new vnode *before* adjusting the dirop count, to avoid a deadlock
473 * in getnewvnode(), if we have a stacked filesystem mounted on top
474 * of us.
475 *
476 * NB: this means we have to clear the new vnodes on error. Fortunately
477 * SET_ENDOP is there to do that for us.
478 */
479 static int
480 lfs_set_dirop_create(struct vnode *dvp, struct vnode **vpp)
481 {
482 int error;
483 struct lfs *fs;
484
485 fs = VFSTOUFS(dvp->v_mount)->um_lfs;
486 ASSERT_NO_SEGLOCK(fs);
487 if (fs->lfs_ronly)
488 return EROFS;
489 if (vpp && (error = getnewvnode(VT_LFS, dvp->v_mount, lfs_vnodeop_p, vpp))) {
490 DLOG((DLOG_ALLOC, "lfs_set_dirop_create: dvp %p error %d\n",
491 dvp, error));
492 return error;
493 }
494 if ((error = lfs_set_dirop(dvp, NULL)) != 0) {
495 if (vpp) {
496 ungetnewvnode(*vpp);
497 *vpp = NULL;
498 }
499 return error;
500 }
501 return 0;
502 }
503
504 #define SET_ENDOP_BASE(fs, dvp, str) \
505 do { \
506 mutex_enter(&(fs)->lfs_interlock); \
507 --(fs)->lfs_dirops; \
508 if (!(fs)->lfs_dirops) { \
509 if ((fs)->lfs_nadirop) { \
510 panic("SET_ENDOP: %s: no dirops but " \
511 " nadirop=%d", (str), \
512 (fs)->lfs_nadirop); \
513 } \
514 wakeup(&(fs)->lfs_writer); \
515 mutex_exit(&(fs)->lfs_interlock); \
516 lfs_check((dvp), LFS_UNUSED_LBN, 0); \
517 } else \
518 mutex_exit(&(fs)->lfs_interlock); \
519 } while(0)
520 #define SET_ENDOP_CREATE(fs, dvp, nvpp, str) \
521 do { \
522 UNMARK_VNODE(dvp); \
523 if (nvpp && *nvpp) \
524 UNMARK_VNODE(*nvpp); \
525 /* Check for error return to stem vnode leakage */ \
526 if (nvpp && *nvpp && !((*nvpp)->v_uflag & VU_DIROP)) \
527 ungetnewvnode(*(nvpp)); \
528 SET_ENDOP_BASE((fs), (dvp), (str)); \
529 lfs_reserve((fs), (dvp), NULL, -LFS_NRESERVE(fs)); \
530 vrele(dvp); \
531 } while(0)
532 #define SET_ENDOP_CREATE_AP(ap, str) \
533 SET_ENDOP_CREATE(VTOI((ap)->a_dvp)->i_lfs, (ap)->a_dvp, \
534 (ap)->a_vpp, (str))
535 #define SET_ENDOP_REMOVE(fs, dvp, ovp, str) \
536 do { \
537 UNMARK_VNODE(dvp); \
538 if (ovp) \
539 UNMARK_VNODE(ovp); \
540 SET_ENDOP_BASE((fs), (dvp), (str)); \
541 lfs_reserve((fs), (dvp), (ovp), -LFS_NRESERVE(fs)); \
542 vrele(dvp); \
543 if (ovp) \
544 vrele(ovp); \
545 } while(0)
546
547 void
548 lfs_mark_vnode(struct vnode *vp)
549 {
550 struct inode *ip = VTOI(vp);
551 struct lfs *fs = ip->i_lfs;
552
553 mutex_enter(&fs->lfs_interlock);
554 if (!(ip->i_flag & IN_ADIROP)) {
555 if (!(vp->v_uflag & VU_DIROP)) {
556 mutex_enter(&vp->v_interlock);
557 (void)lfs_vref(vp);
558 mutex_enter(&lfs_subsys_lock);
559 ++lfs_dirvcount;
560 ++fs->lfs_dirvcount;
561 mutex_exit(&lfs_subsys_lock);
562 TAILQ_INSERT_TAIL(&fs->lfs_dchainhd, ip, i_lfs_dchain);
563 vp->v_uflag |= VU_DIROP;
564 }
565 ++fs->lfs_nadirop;
566 ip->i_flag |= IN_ADIROP;
567 } else
568 KASSERT(vp->v_uflag & VU_DIROP);
569 mutex_exit(&fs->lfs_interlock);
570 }
571
572 void
573 lfs_unmark_vnode(struct vnode *vp)
574 {
575 struct inode *ip = VTOI(vp);
576
577 if (ip && (ip->i_flag & IN_ADIROP)) {
578 KASSERT(vp->v_uflag & VU_DIROP);
579 mutex_enter(&ip->i_lfs->lfs_interlock);
580 --ip->i_lfs->lfs_nadirop;
581 mutex_exit(&ip->i_lfs->lfs_interlock);
582 ip->i_flag &= ~IN_ADIROP;
583 }
584 }
585
586 int
587 lfs_symlink(void *v)
588 {
589 struct vop_symlink_args /* {
590 struct vnode *a_dvp;
591 struct vnode **a_vpp;
592 struct componentname *a_cnp;
593 struct vattr *a_vap;
594 char *a_target;
595 } */ *ap = v;
596 int error;
597
598 if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
599 vput(ap->a_dvp);
600 return error;
601 }
602 error = ufs_symlink(ap);
603 SET_ENDOP_CREATE_AP(ap, "symlink");
604 return (error);
605 }
606
607 int
608 lfs_mknod(void *v)
609 {
610 struct vop_mknod_args /* {
611 struct vnode *a_dvp;
612 struct vnode **a_vpp;
613 struct componentname *a_cnp;
614 struct vattr *a_vap;
615 } */ *ap = v;
616 struct vattr *vap = ap->a_vap;
617 struct vnode **vpp = ap->a_vpp;
618 struct inode *ip;
619 int error;
620 struct mount *mp;
621 ino_t ino;
622
623 if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
624 vput(ap->a_dvp);
625 return error;
626 }
627 error = ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
628 ap->a_dvp, vpp, ap->a_cnp);
629
630 /* Either way we're done with the dirop at this point */
631 SET_ENDOP_CREATE_AP(ap, "mknod");
632
633 if (error)
634 return (error);
635
636 ip = VTOI(*vpp);
637 mp = (*vpp)->v_mount;
638 ino = ip->i_number;
639 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
640 if (vap->va_rdev != VNOVAL) {
641 /*
642 * Want to be able to use this to make badblock
643 * inodes, so don't truncate the dev number.
644 */
645 #if 0
646 ip->i_ffs1_rdev = ufs_rw32(vap->va_rdev,
647 UFS_MPNEEDSWAP((*vpp)->v_mount));
648 #else
649 ip->i_ffs1_rdev = vap->va_rdev;
650 #endif
651 }
652
653 /*
654 * Call fsync to write the vnode so that we don't have to deal with
655 * flushing it when it's marked VDIROP|VXLOCK.
656 *
657 * XXX KS - If we can't flush we also can't call vgone(), so must
658 * return. But, that leaves this vnode in limbo, also not good.
659 * Can this ever happen (barring hardware failure)?
660 */
661 if ((error = VOP_FSYNC(*vpp, NOCRED, FSYNC_WAIT, 0, 0)) != 0) {
662 panic("lfs_mknod: couldn't fsync (ino %llu)",
663 (unsigned long long)ino);
664 /* return (error); */
665 }
666 /*
667 * Remove vnode so that it will be reloaded by VFS_VGET and
668 * checked to see if it is an alias of an existing entry in
669 * the inode cache.
670 */
671 /* Used to be vput, but that causes us to call VOP_INACTIVE twice. */
672
673 VOP_UNLOCK(*vpp, 0);
674 lfs_vunref(*vpp); /* XXXAD */
675 (*vpp)->v_type = VNON;
676 vgone(*vpp);
677 error = VFS_VGET(mp, ino, vpp);
678
679 if (error != 0) {
680 *vpp = NULL;
681 return (error);
682 }
683 return (0);
684 }
685
686 int
687 lfs_create(void *v)
688 {
689 struct vop_create_args /* {
690 struct vnode *a_dvp;
691 struct vnode **a_vpp;
692 struct componentname *a_cnp;
693 struct vattr *a_vap;
694 } */ *ap = v;
695 int error;
696
697 if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
698 vput(ap->a_dvp);
699 return error;
700 }
701 error = ufs_create(ap);
702 SET_ENDOP_CREATE_AP(ap, "create");
703 return (error);
704 }
705
706 int
707 lfs_mkdir(void *v)
708 {
709 struct vop_mkdir_args /* {
710 struct vnode *a_dvp;
711 struct vnode **a_vpp;
712 struct componentname *a_cnp;
713 struct vattr *a_vap;
714 } */ *ap = v;
715 int error;
716
717 if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
718 vput(ap->a_dvp);
719 return error;
720 }
721 error = ufs_mkdir(ap);
722 SET_ENDOP_CREATE_AP(ap, "mkdir");
723 return (error);
724 }
725
726 int
727 lfs_remove(void *v)
728 {
729 struct vop_remove_args /* {
730 struct vnode *a_dvp;
731 struct vnode *a_vp;
732 struct componentname *a_cnp;
733 } */ *ap = v;
734 struct vnode *dvp, *vp;
735 struct inode *ip;
736 int error;
737
738 dvp = ap->a_dvp;
739 vp = ap->a_vp;
740 ip = VTOI(vp);
741 if ((error = SET_DIROP_REMOVE(dvp, vp)) != 0) {
742 if (dvp == vp)
743 vrele(vp);
744 else
745 vput(vp);
746 vput(dvp);
747 return error;
748 }
749 error = ufs_remove(ap);
750 if (ip->i_nlink == 0)
751 lfs_orphan(ip->i_lfs, ip->i_number);
752 SET_ENDOP_REMOVE(ip->i_lfs, dvp, ap->a_vp, "remove");
753 return (error);
754 }
755
756 int
757 lfs_rmdir(void *v)
758 {
759 struct vop_rmdir_args /* {
760 struct vnodeop_desc *a_desc;
761 struct vnode *a_dvp;
762 struct vnode *a_vp;
763 struct componentname *a_cnp;
764 } */ *ap = v;
765 struct vnode *vp;
766 struct inode *ip;
767 int error;
768
769 vp = ap->a_vp;
770 ip = VTOI(vp);
771 if ((error = SET_DIROP_REMOVE(ap->a_dvp, ap->a_vp)) != 0) {
772 if (ap->a_dvp == vp)
773 vrele(ap->a_dvp);
774 else
775 vput(ap->a_dvp);
776 vput(vp);
777 return error;
778 }
779 error = ufs_rmdir(ap);
780 if (ip->i_nlink == 0)
781 lfs_orphan(ip->i_lfs, ip->i_number);
782 SET_ENDOP_REMOVE(ip->i_lfs, ap->a_dvp, ap->a_vp, "rmdir");
783 return (error);
784 }
785
786 int
787 lfs_link(void *v)
788 {
789 struct vop_link_args /* {
790 struct vnode *a_dvp;
791 struct vnode *a_vp;
792 struct componentname *a_cnp;
793 } */ *ap = v;
794 int error;
795 struct vnode **vpp = NULL;
796
797 if ((error = SET_DIROP_CREATE(ap->a_dvp, vpp)) != 0) {
798 vput(ap->a_dvp);
799 return error;
800 }
801 error = ufs_link(ap);
802 SET_ENDOP_CREATE(VTOI(ap->a_dvp)->i_lfs, ap->a_dvp, vpp, "link");
803 return (error);
804 }
805
806 int
807 lfs_rename(void *v)
808 {
809 struct vop_rename_args /* {
810 struct vnode *a_fdvp;
811 struct vnode *a_fvp;
812 struct componentname *a_fcnp;
813 struct vnode *a_tdvp;
814 struct vnode *a_tvp;
815 struct componentname *a_tcnp;
816 } */ *ap = v;
817 struct vnode *tvp, *fvp, *tdvp, *fdvp;
818 struct componentname *tcnp, *fcnp;
819 int error;
820 struct lfs *fs;
821
822 fs = VTOI(ap->a_fdvp)->i_lfs;
823 tvp = ap->a_tvp;
824 tdvp = ap->a_tdvp;
825 tcnp = ap->a_tcnp;
826 fvp = ap->a_fvp;
827 fdvp = ap->a_fdvp;
828 fcnp = ap->a_fcnp;
829
830 /*
831 * Check for cross-device rename.
832 * If it is, we don't want to set dirops, just error out.
833 * (In particular note that MARK_VNODE(tdvp) will DTWT on
834 * a cross-device rename.)
835 *
836 * Copied from ufs_rename.
837 */
838 if ((fvp->v_mount != tdvp->v_mount) ||
839 (tvp && (fvp->v_mount != tvp->v_mount))) {
840 error = EXDEV;
841 goto errout;
842 }
843
844 /*
845 * Check to make sure we're not renaming a vnode onto itself
846 * (deleting a hard link by renaming one name onto another);
847 * if we are we can't recursively call VOP_REMOVE since that
848 * would leave us with an unaccounted-for number of live dirops.
849 *
850 * Inline the relevant section of ufs_rename here, *before*
851 * calling SET_DIROP_REMOVE.
852 */
853 if (tvp && ((VTOI(tvp)->i_flags & (IMMUTABLE | APPEND)) ||
854 (VTOI(tdvp)->i_flags & APPEND))) {
855 error = EPERM;
856 goto errout;
857 }
858 if (fvp == tvp) {
859 if (fvp->v_type == VDIR) {
860 error = EINVAL;
861 goto errout;
862 }
863
864 /* Release destination completely. */
865 VOP_ABORTOP(tdvp, tcnp);
866 vput(tdvp);
867 vput(tvp);
868
869 /* Delete source. */
870 vrele(fvp);
871 fcnp->cn_flags &= ~(MODMASK | SAVESTART);
872 fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
873 fcnp->cn_nameiop = DELETE;
874 vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
875 if ((error = relookup(fdvp, &fvp, fcnp))) {
876 vput(fdvp);
877 return (error);
878 }
879 return (VOP_REMOVE(fdvp, fvp, fcnp));
880 }
881
882 if ((error = SET_DIROP_REMOVE(tdvp, tvp)) != 0)
883 goto errout;
884 MARK_VNODE(fdvp);
885 MARK_VNODE(fvp);
886
887 error = ufs_rename(ap);
888 UNMARK_VNODE(fdvp);
889 UNMARK_VNODE(fvp);
890 SET_ENDOP_REMOVE(fs, tdvp, tvp, "rename");
891 return (error);
892
893 errout:
894 VOP_ABORTOP(tdvp, ap->a_tcnp); /* XXX, why not in NFS? */
895 if (tdvp == tvp)
896 vrele(tdvp);
897 else
898 vput(tdvp);
899 if (tvp)
900 vput(tvp);
901 VOP_ABORTOP(fdvp, ap->a_fcnp); /* XXX, why not in NFS? */
902 vrele(fdvp);
903 vrele(fvp);
904 return (error);
905 }
906
907 /* XXX hack to avoid calling ITIMES in getattr */
908 int
909 lfs_getattr(void *v)
910 {
911 struct vop_getattr_args /* {
912 struct vnode *a_vp;
913 struct vattr *a_vap;
914 kauth_cred_t a_cred;
915 } */ *ap = v;
916 struct vnode *vp = ap->a_vp;
917 struct inode *ip = VTOI(vp);
918 struct vattr *vap = ap->a_vap;
919 struct lfs *fs = ip->i_lfs;
920 /*
921 * Copy from inode table
922 */
923 vap->va_fsid = ip->i_dev;
924 vap->va_fileid = ip->i_number;
925 vap->va_mode = ip->i_mode & ~IFMT;
926 vap->va_nlink = ip->i_nlink;
927 vap->va_uid = ip->i_uid;
928 vap->va_gid = ip->i_gid;
929 vap->va_rdev = (dev_t)ip->i_ffs1_rdev;
930 vap->va_size = vp->v_size;
931 vap->va_atime.tv_sec = ip->i_ffs1_atime;
932 vap->va_atime.tv_nsec = ip->i_ffs1_atimensec;
933 vap->va_mtime.tv_sec = ip->i_ffs1_mtime;
934 vap->va_mtime.tv_nsec = ip->i_ffs1_mtimensec;
935 vap->va_ctime.tv_sec = ip->i_ffs1_ctime;
936 vap->va_ctime.tv_nsec = ip->i_ffs1_ctimensec;
937 vap->va_flags = ip->i_flags;
938 vap->va_gen = ip->i_gen;
939 /* this doesn't belong here */
940 if (vp->v_type == VBLK)
941 vap->va_blocksize = BLKDEV_IOSIZE;
942 else if (vp->v_type == VCHR)
943 vap->va_blocksize = MAXBSIZE;
944 else
945 vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
946 vap->va_bytes = fsbtob(fs, (u_quad_t)ip->i_lfs_effnblks);
947 vap->va_type = vp->v_type;
948 vap->va_filerev = ip->i_modrev;
949 return (0);
950 }
951
952 /*
953 * Check to make sure the inode blocks won't choke the buffer
954 * cache, then call ufs_setattr as usual.
955 */
956 int
957 lfs_setattr(void *v)
958 {
959 struct vop_setattr_args /* {
960 struct vnode *a_vp;
961 struct vattr *a_vap;
962 kauth_cred_t a_cred;
963 } */ *ap = v;
964 struct vnode *vp = ap->a_vp;
965
966 lfs_check(vp, LFS_UNUSED_LBN, 0);
967 return ufs_setattr(v);
968 }
969
970 /*
971 * Release the block we hold on lfs_newseg wrapping. Called on file close,
972 * or explicitly from LFCNWRAPGO. Called with the interlock held.
973 */
974 static int
975 lfs_wrapgo(struct lfs *fs, struct inode *ip, int waitfor)
976 {
977 if (fs->lfs_stoplwp != curlwp)
978 return EBUSY;
979
980 fs->lfs_stoplwp = NULL;
981 cv_signal(&fs->lfs_stopcv);
982
983 KASSERT(fs->lfs_nowrap > 0);
984 if (fs->lfs_nowrap <= 0) {
985 return 0;
986 }
987
988 if (--fs->lfs_nowrap == 0) {
989 log(LOG_NOTICE, "%s: re-enabled log wrap\n", fs->lfs_fsmnt);
990 wakeup(&fs->lfs_wrappass);
991 lfs_wakeup_cleaner(fs);
992 }
993 if (waitfor) {
994 mtsleep(&fs->lfs_nextseg, PCATCH | PUSER,
995 "segment", 0, &fs->lfs_interlock);
996 }
997
998 return 0;
999 }
1000
1001 /*
1002 * Close called
1003 */
1004 /* ARGSUSED */
1005 int
1006 lfs_close(void *v)
1007 {
1008 struct vop_close_args /* {
1009 struct vnode *a_vp;
1010 int a_fflag;
1011 kauth_cred_t a_cred;
1012 } */ *ap = v;
1013 struct vnode *vp = ap->a_vp;
1014 struct inode *ip = VTOI(vp);
1015 struct lfs *fs = ip->i_lfs;
1016
1017 if ((ip->i_number == ROOTINO || ip->i_number == LFS_IFILE_INUM) &&
1018 fs->lfs_stoplwp == curlwp) {
1019 mutex_enter(&fs->lfs_interlock);
1020 log(LOG_NOTICE, "lfs_close: releasing log wrap control\n");
1021 lfs_wrapgo(fs, ip, 0);
1022 mutex_exit(&fs->lfs_interlock);
1023 }
1024
1025 if (vp == ip->i_lfs->lfs_ivnode &&
1026 vp->v_mount->mnt_iflag & IMNT_UNMOUNT)
1027 return 0;
1028
1029 if (vp->v_usecount > 1 && vp != ip->i_lfs->lfs_ivnode) {
1030 LFS_ITIMES(ip, NULL, NULL, NULL);
1031 }
1032 return (0);
1033 }
1034
1035 /*
1036 * Close wrapper for special devices.
1037 *
1038 * Update the times on the inode then do device close.
1039 */
1040 int
1041 lfsspec_close(void *v)
1042 {
1043 struct vop_close_args /* {
1044 struct vnode *a_vp;
1045 int a_fflag;
1046 kauth_cred_t a_cred;
1047 } */ *ap = v;
1048 struct vnode *vp;
1049 struct inode *ip;
1050
1051 vp = ap->a_vp;
1052 ip = VTOI(vp);
1053 if (vp->v_usecount > 1) {
1054 LFS_ITIMES(ip, NULL, NULL, NULL);
1055 }
1056 return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap));
1057 }
1058
1059 /*
1060 * Close wrapper for fifo's.
1061 *
1062 * Update the times on the inode then do device close.
1063 */
1064 int
1065 lfsfifo_close(void *v)
1066 {
1067 struct vop_close_args /* {
1068 struct vnode *a_vp;
1069 int a_fflag;
1070 kauth_cred_ a_cred;
1071 } */ *ap = v;
1072 struct vnode *vp;
1073 struct inode *ip;
1074
1075 vp = ap->a_vp;
1076 ip = VTOI(vp);
1077 if (ap->a_vp->v_usecount > 1) {
1078 LFS_ITIMES(ip, NULL, NULL, NULL);
1079 }
1080 return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap));
1081 }
1082
1083 /*
1084 * Reclaim an inode so that it can be used for other purposes.
1085 */
1086
1087 int
1088 lfs_reclaim(void *v)
1089 {
1090 struct vop_reclaim_args /* {
1091 struct vnode *a_vp;
1092 } */ *ap = v;
1093 struct vnode *vp = ap->a_vp;
1094 struct inode *ip = VTOI(vp);
1095 struct lfs *fs = ip->i_lfs;
1096 int error;
1097
1098 KASSERT(ip->i_nlink == ip->i_ffs_effnlink);
1099
1100 mutex_enter(&fs->lfs_interlock);
1101 LFS_CLR_UINO(ip, IN_ALLMOD);
1102 mutex_exit(&fs->lfs_interlock);
1103 if ((error = ufs_reclaim(vp)))
1104 return (error);
1105
1106 /*
1107 * Take us off the paging and/or dirop queues if we were on them.
1108 * We shouldn't be on them.
1109 */
1110 mutex_enter(&fs->lfs_interlock);
1111 if (ip->i_flags & IN_PAGING) {
1112 log(LOG_WARNING, "%s: reclaimed vnode is IN_PAGING\n",
1113 fs->lfs_fsmnt);
1114 ip->i_flags &= ~IN_PAGING;
1115 TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
1116 }
1117 if (vp->v_uflag & VU_DIROP) {
1118 panic("reclaimed vnode is VDIROP");
1119 vp->v_uflag &= ~VU_DIROP;
1120 TAILQ_REMOVE(&fs->lfs_dchainhd, ip, i_lfs_dchain);
1121 }
1122 mutex_exit(&fs->lfs_interlock);
1123
1124 pool_put(&lfs_dinode_pool, ip->i_din.ffs1_din);
1125 lfs_deregister_all(vp);
1126 pool_put(&lfs_inoext_pool, ip->inode_ext.lfs);
1127 ip->inode_ext.lfs = NULL;
1128 genfs_node_destroy(vp);
1129 pool_put(&lfs_inode_pool, vp->v_data);
1130 vp->v_data = NULL;
1131 return (0);
1132 }
1133
1134 /*
1135 * Read a block from a storage device.
1136 * In order to avoid reading blocks that are in the process of being
1137 * written by the cleaner---and hence are not mutexed by the normal
1138 * buffer cache / page cache mechanisms---check for collisions before
1139 * reading.
1140 *
1141 * We inline ufs_strategy to make sure that the VOP_BMAP occurs *before*
1142 * the active cleaner test.
1143 *
1144 * XXX This code assumes that lfs_markv makes synchronous checkpoints.
1145 */
1146 int
1147 lfs_strategy(void *v)
1148 {
1149 struct vop_strategy_args /* {
1150 struct vnode *a_vp;
1151 struct buf *a_bp;
1152 } */ *ap = v;
1153 struct buf *bp;
1154 struct lfs *fs;
1155 struct vnode *vp;
1156 struct inode *ip;
1157 daddr_t tbn;
1158 int i, sn, error, slept;
1159
1160 bp = ap->a_bp;
1161 vp = ap->a_vp;
1162 ip = VTOI(vp);
1163 fs = ip->i_lfs;
1164
1165 /* lfs uses its strategy routine only for read */
1166 KASSERT(bp->b_flags & B_READ);
1167
1168 if (vp->v_type == VBLK || vp->v_type == VCHR)
1169 panic("lfs_strategy: spec");
1170 KASSERT(bp->b_bcount != 0);
1171 if (bp->b_blkno == bp->b_lblkno) {
1172 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno,
1173 NULL);
1174 if (error) {
1175 bp->b_error = error;
1176 bp->b_resid = bp->b_bcount;
1177 biodone(bp);
1178 return (error);
1179 }
1180 if ((long)bp->b_blkno == -1) /* no valid data */
1181 clrbuf(bp);
1182 }
1183 if ((long)bp->b_blkno < 0) { /* block is not on disk */
1184 bp->b_resid = bp->b_bcount;
1185 biodone(bp);
1186 return (0);
1187 }
1188
1189 slept = 1;
1190 mutex_enter(&fs->lfs_interlock);
1191 while (slept && fs->lfs_seglock) {
1192 mutex_exit(&fs->lfs_interlock);
1193 /*
1194 * Look through list of intervals.
1195 * There will only be intervals to look through
1196 * if the cleaner holds the seglock.
1197 * Since the cleaner is synchronous, we can trust
1198 * the list of intervals to be current.
1199 */
1200 tbn = dbtofsb(fs, bp->b_blkno);
1201 sn = dtosn(fs, tbn);
1202 slept = 0;
1203 for (i = 0; i < fs->lfs_cleanind; i++) {
1204 if (sn == dtosn(fs, fs->lfs_cleanint[i]) &&
1205 tbn >= fs->lfs_cleanint[i]) {
1206 DLOG((DLOG_CLEAN,
1207 "lfs_strategy: ino %d lbn %" PRId64
1208 " ind %d sn %d fsb %" PRIx32
1209 " given sn %d fsb %" PRIx64 "\n",
1210 ip->i_number, bp->b_lblkno, i,
1211 dtosn(fs, fs->lfs_cleanint[i]),
1212 fs->lfs_cleanint[i], sn, tbn));
1213 DLOG((DLOG_CLEAN,
1214 "lfs_strategy: sleeping on ino %d lbn %"
1215 PRId64 "\n", ip->i_number, bp->b_lblkno));
1216 mutex_enter(&fs->lfs_interlock);
1217 if (LFS_SEGLOCK_HELD(fs) && fs->lfs_iocount) {
1218 /* Cleaner can't wait for itself */
1219 mtsleep(&fs->lfs_iocount,
1220 (PRIBIO + 1) | PNORELOCK,
1221 "clean2", 0,
1222 &fs->lfs_interlock);
1223 slept = 1;
1224 break;
1225 } else if (fs->lfs_seglock) {
1226 mtsleep(&fs->lfs_seglock,
1227 (PRIBIO + 1) | PNORELOCK,
1228 "clean1", 0,
1229 &fs->lfs_interlock);
1230 slept = 1;
1231 break;
1232 }
1233 mutex_exit(&fs->lfs_interlock);
1234 }
1235 }
1236 mutex_enter(&fs->lfs_interlock);
1237 }
1238 mutex_exit(&fs->lfs_interlock);
1239
1240 vp = ip->i_devvp;
1241 VOP_STRATEGY(vp, bp);
1242 return (0);
1243 }
1244
1245 void
1246 lfs_flush_dirops(struct lfs *fs)
1247 {
1248 struct inode *ip, *nip;
1249 struct vnode *vp;
1250 extern int lfs_dostats;
1251 struct segment *sp;
1252 int waslocked;
1253
1254 ASSERT_MAYBE_SEGLOCK(fs);
1255 KASSERT(fs->lfs_nadirop == 0);
1256
1257 if (fs->lfs_ronly)
1258 return;
1259
1260 mutex_enter(&fs->lfs_interlock);
1261 if (TAILQ_FIRST(&fs->lfs_dchainhd) == NULL) {
1262 mutex_exit(&fs->lfs_interlock);
1263 return;
1264 } else
1265 mutex_exit(&fs->lfs_interlock);
1266
1267 if (lfs_dostats)
1268 ++lfs_stats.flush_invoked;
1269
1270 /*
1271 * Inline lfs_segwrite/lfs_writevnodes, but just for dirops.
1272 * Technically this is a checkpoint (the on-disk state is valid)
1273 * even though we are leaving out all the file data.
1274 */
1275 lfs_imtime(fs);
1276 lfs_seglock(fs, SEGM_CKP);
1277 sp = fs->lfs_sp;
1278
1279 /*
1280 * lfs_writevnodes, optimized to get dirops out of the way.
1281 * Only write dirops, and don't flush files' pages, only
1282 * blocks from the directories.
1283 *
1284 * We don't need to vref these files because they are
1285 * dirops and so hold an extra reference until the
1286 * segunlock clears them of that status.
1287 *
1288 * We don't need to check for IN_ADIROP because we know that
1289 * no dirops are active.
1290 *
1291 */
1292 mutex_enter(&fs->lfs_interlock);
1293 for (ip = TAILQ_FIRST(&fs->lfs_dchainhd); ip != NULL; ip = nip) {
1294 nip = TAILQ_NEXT(ip, i_lfs_dchain);
1295 mutex_exit(&fs->lfs_interlock);
1296 vp = ITOV(ip);
1297
1298 KASSERT((ip->i_flag & IN_ADIROP) == 0);
1299
1300 /*
1301 * All writes to directories come from dirops; all
1302 * writes to files' direct blocks go through the page
1303 * cache, which we're not touching. Reads to files
1304 * and/or directories will not be affected by writing
1305 * directory blocks inodes and file inodes. So we don't
1306 * really need to lock. If we don't lock, though,
1307 * make sure that we don't clear IN_MODIFIED
1308 * unnecessarily.
1309 */
1310 if (vp->v_iflag & VI_XLOCK) {
1311 mutex_enter(&fs->lfs_interlock);
1312 continue;
1313 }
1314 waslocked = VOP_ISLOCKED(vp);
1315 if (vp->v_type != VREG &&
1316 ((ip->i_flag & IN_ALLMOD) || !VPISEMPTY(vp))) {
1317 lfs_writefile(fs, sp, vp);
1318 if (!VPISEMPTY(vp) && !WRITEINPROG(vp) &&
1319 !(ip->i_flag & IN_ALLMOD)) {
1320 mutex_enter(&fs->lfs_interlock);
1321 LFS_SET_UINO(ip, IN_MODIFIED);
1322 mutex_exit(&fs->lfs_interlock);
1323 }
1324 }
1325 KDASSERT(ip->i_number != LFS_IFILE_INUM);
1326 (void) lfs_writeinode(fs, sp, ip);
1327 mutex_enter(&fs->lfs_interlock);
1328 if (waslocked == LK_EXCLOTHER)
1329 LFS_SET_UINO(ip, IN_MODIFIED);
1330 }
1331 mutex_exit(&fs->lfs_interlock);
1332 /* We've written all the dirops there are */
1333 ((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT);
1334 lfs_finalize_fs_seguse(fs);
1335 (void) lfs_writeseg(fs, sp);
1336 lfs_segunlock(fs);
1337 }
1338
1339 /*
1340 * Flush all vnodes for which the pagedaemon has requested pageouts.
1341 * Skip over any files that are marked VDIROP (since lfs_flush_dirop()
1342 * has just run, this would be an error). If we have to skip a vnode
1343 * for any reason, just skip it; if we have to wait for the cleaner,
1344 * abort. The writer daemon will call us again later.
1345 */
1346 void
1347 lfs_flush_pchain(struct lfs *fs)
1348 {
1349 struct inode *ip, *nip;
1350 struct vnode *vp;
1351 extern int lfs_dostats;
1352 struct segment *sp;
1353 int error;
1354
1355 ASSERT_NO_SEGLOCK(fs);
1356
1357 if (fs->lfs_ronly)
1358 return;
1359
1360 mutex_enter(&fs->lfs_interlock);
1361 if (TAILQ_FIRST(&fs->lfs_pchainhd) == NULL) {
1362 mutex_exit(&fs->lfs_interlock);
1363 return;
1364 } else
1365 mutex_exit(&fs->lfs_interlock);
1366
1367 /* Get dirops out of the way */
1368 lfs_flush_dirops(fs);
1369
1370 if (lfs_dostats)
1371 ++lfs_stats.flush_invoked;
1372
1373 /*
1374 * Inline lfs_segwrite/lfs_writevnodes, but just for pageouts.
1375 */
1376 lfs_imtime(fs);
1377 lfs_seglock(fs, 0);
1378 sp = fs->lfs_sp;
1379
1380 /*
1381 * lfs_writevnodes, optimized to clear pageout requests.
1382 * Only write non-dirop files that are in the pageout queue.
1383 * We're very conservative about what we write; we want to be
1384 * fast and async.
1385 */
1386 mutex_enter(&fs->lfs_interlock);
1387 top:
1388 for (ip = TAILQ_FIRST(&fs->lfs_pchainhd); ip != NULL; ip = nip) {
1389 nip = TAILQ_NEXT(ip, i_lfs_pchain);
1390 vp = ITOV(ip);
1391
1392 if (!(ip->i_flags & IN_PAGING))
1393 goto top;
1394
1395 mutex_enter(&vp->v_interlock);
1396 if ((vp->v_iflag & VI_XLOCK) || (vp->v_uflag & VU_DIROP) != 0) {
1397 mutex_exit(&vp->v_interlock);
1398 continue;
1399 }
1400 if (vp->v_type != VREG) {
1401 mutex_exit(&vp->v_interlock);
1402 continue;
1403 }
1404 if (lfs_vref(vp))
1405 continue;
1406 mutex_exit(&fs->lfs_interlock);
1407
1408 if (VOP_ISLOCKED(vp)) {
1409 lfs_vunref(vp);
1410 mutex_enter(&fs->lfs_interlock);
1411 continue;
1412 }
1413
1414 error = lfs_writefile(fs, sp, vp);
1415 if (!VPISEMPTY(vp) && !WRITEINPROG(vp) &&
1416 !(ip->i_flag & IN_ALLMOD)) {
1417 mutex_enter(&fs->lfs_interlock);
1418 LFS_SET_UINO(ip, IN_MODIFIED);
1419 mutex_exit(&fs->lfs_interlock);
1420 }
1421 KDASSERT(ip->i_number != LFS_IFILE_INUM);
1422 (void) lfs_writeinode(fs, sp, ip);
1423
1424 lfs_vunref(vp);
1425
1426 if (error == EAGAIN) {
1427 lfs_writeseg(fs, sp);
1428 mutex_enter(&fs->lfs_interlock);
1429 break;
1430 }
1431 mutex_enter(&fs->lfs_interlock);
1432 }
1433 mutex_exit(&fs->lfs_interlock);
1434 (void) lfs_writeseg(fs, sp);
1435 lfs_segunlock(fs);
1436 }
1437
1438 /*
1439 * Provide a fcntl interface to sys_lfs_{segwait,bmapv,markv}.
1440 */
1441 int
1442 lfs_fcntl(void *v)
1443 {
1444 struct vop_fcntl_args /* {
1445 struct vnode *a_vp;
1446 u_long a_command;
1447 void * a_data;
1448 int a_fflag;
1449 kauth_cred_t a_cred;
1450 } */ *ap = v;
1451 struct timeval *tvp;
1452 BLOCK_INFO *blkiov;
1453 CLEANERINFO *cip;
1454 SEGUSE *sup;
1455 int blkcnt, error, oclean;
1456 size_t fh_size;
1457 struct lfs_fcntl_markv blkvp;
1458 struct lwp *l;
1459 fsid_t *fsidp;
1460 struct lfs *fs;
1461 struct buf *bp;
1462 fhandle_t *fhp;
1463 daddr_t off;
1464
1465 /* Only respect LFS fcntls on fs root or Ifile */
1466 if (VTOI(ap->a_vp)->i_number != ROOTINO &&
1467 VTOI(ap->a_vp)->i_number != LFS_IFILE_INUM) {
1468 return ufs_fcntl(v);
1469 }
1470
1471 /* Avoid locking a draining lock */
1472 if (ap->a_vp->v_mount->mnt_iflag & IMNT_UNMOUNT) {
1473 return ESHUTDOWN;
1474 }
1475
1476 /* LFS control and monitoring fcntls are available only to root */
1477 l = curlwp;
1478 if (((ap->a_command & 0xff00) >> 8) == 'L' &&
1479 (error = kauth_authorize_generic(l->l_cred, KAUTH_GENERIC_ISSUSER,
1480 NULL)) != 0)
1481 return (error);
1482
1483 fs = VTOI(ap->a_vp)->i_lfs;
1484 fsidp = &ap->a_vp->v_mount->mnt_stat.f_fsidx;
1485
1486 error = 0;
1487 switch (ap->a_command) {
1488 case LFCNSEGWAITALL:
1489 case LFCNSEGWAITALL_COMPAT:
1490 fsidp = NULL;
1491 /* FALLSTHROUGH */
1492 case LFCNSEGWAIT:
1493 case LFCNSEGWAIT_COMPAT:
1494 tvp = (struct timeval *)ap->a_data;
1495 mutex_enter(&fs->lfs_interlock);
1496 ++fs->lfs_sleepers;
1497 mutex_exit(&fs->lfs_interlock);
1498
1499 error = lfs_segwait(fsidp, tvp);
1500
1501 mutex_enter(&fs->lfs_interlock);
1502 if (--fs->lfs_sleepers == 0)
1503 wakeup(&fs->lfs_sleepers);
1504 mutex_exit(&fs->lfs_interlock);
1505 return error;
1506
1507 case LFCNBMAPV:
1508 case LFCNMARKV:
1509 blkvp = *(struct lfs_fcntl_markv *)ap->a_data;
1510
1511 blkcnt = blkvp.blkcnt;
1512 if ((u_int) blkcnt > LFS_MARKV_MAXBLKCNT)
1513 return (EINVAL);
1514 blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);
1515 if ((error = copyin(blkvp.blkiov, blkiov,
1516 blkcnt * sizeof(BLOCK_INFO))) != 0) {
1517 lfs_free(fs, blkiov, LFS_NB_BLKIOV);
1518 return error;
1519 }
1520
1521 mutex_enter(&fs->lfs_interlock);
1522 ++fs->lfs_sleepers;
1523 mutex_exit(&fs->lfs_interlock);
1524 if (ap->a_command == LFCNBMAPV)
1525 error = lfs_bmapv(l->l_proc, fsidp, blkiov, blkcnt);
1526 else /* LFCNMARKV */
1527 error = lfs_markv(l->l_proc, fsidp, blkiov, blkcnt);
1528 if (error == 0)
1529 error = copyout(blkiov, blkvp.blkiov,
1530 blkcnt * sizeof(BLOCK_INFO));
1531 mutex_enter(&fs->lfs_interlock);
1532 if (--fs->lfs_sleepers == 0)
1533 wakeup(&fs->lfs_sleepers);
1534 mutex_exit(&fs->lfs_interlock);
1535 lfs_free(fs, blkiov, LFS_NB_BLKIOV);
1536 return error;
1537
1538 case LFCNRECLAIM:
1539 /*
1540 * Flush dirops and write Ifile, allowing empty segments
1541 * to be immediately reclaimed.
1542 */
1543 lfs_writer_enter(fs, "pndirop");
1544 off = fs->lfs_offset;
1545 lfs_seglock(fs, SEGM_FORCE_CKP | SEGM_CKP);
1546 lfs_flush_dirops(fs);
1547 LFS_CLEANERINFO(cip, fs, bp);
1548 oclean = cip->clean;
1549 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
1550 lfs_segwrite(ap->a_vp->v_mount, SEGM_FORCE_CKP);
1551 fs->lfs_sp->seg_flags |= SEGM_PROT;
1552 lfs_segunlock(fs);
1553 lfs_writer_leave(fs);
1554
1555 #ifdef DEBUG
1556 LFS_CLEANERINFO(cip, fs, bp);
1557 DLOG((DLOG_CLEAN, "lfs_fcntl: reclaim wrote %" PRId64
1558 " blocks, cleaned %" PRId32 " segments (activesb %d)\n",
1559 fs->lfs_offset - off, cip->clean - oclean,
1560 fs->lfs_activesb));
1561 LFS_SYNC_CLEANERINFO(cip, fs, bp, 0);
1562 #endif
1563
1564 return 0;
1565
1566 #ifdef COMPAT_30
1567 case LFCNIFILEFH_COMPAT:
1568 /* Return the filehandle of the Ifile */
1569 if ((error = kauth_authorize_generic(l->l_cred,
1570 KAUTH_GENERIC_ISSUSER, NULL)) != 0)
1571 return (error);
1572 fhp = (struct fhandle *)ap->a_data;
1573 fhp->fh_fsid = *fsidp;
1574 fh_size = 16; /* former VFS_MAXFIDSIZ */
1575 return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size);
1576 #endif
1577
1578 case LFCNIFILEFH_COMPAT2:
1579 case LFCNIFILEFH:
1580 /* Return the filehandle of the Ifile */
1581 fhp = (struct fhandle *)ap->a_data;
1582 fhp->fh_fsid = *fsidp;
1583 fh_size = sizeof(struct lfs_fhandle) -
1584 offsetof(fhandle_t, fh_fid);
1585 return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size);
1586
1587 case LFCNREWIND:
1588 /* Move lfs_offset to the lowest-numbered segment */
1589 return lfs_rewind(fs, *(int *)ap->a_data);
1590
1591 case LFCNINVAL:
1592 /* Mark a segment SEGUSE_INVAL */
1593 LFS_SEGENTRY(sup, fs, *(int *)ap->a_data, bp);
1594 if (sup->su_nbytes > 0) {
1595 brelse(bp, 0);
1596 lfs_unset_inval_all(fs);
1597 return EBUSY;
1598 }
1599 sup->su_flags |= SEGUSE_INVAL;
1600 VOP_BWRITE(bp);
1601 return 0;
1602
1603 case LFCNRESIZE:
1604 /* Resize the filesystem */
1605 return lfs_resize_fs(fs, *(int *)ap->a_data);
1606
1607 case LFCNWRAPSTOP:
1608 case LFCNWRAPSTOP_COMPAT:
1609 /*
1610 * Hold lfs_newseg at segment 0; if requested, sleep until
1611 * the filesystem wraps around. To support external agents
1612 * (dump, fsck-based regression test) that need to look at
1613 * a snapshot of the filesystem, without necessarily
1614 * requiring that all fs activity stops.
1615 */
1616 if (fs->lfs_stoplwp == curlwp)
1617 return EALREADY;
1618
1619 mutex_enter(&fs->lfs_interlock);
1620 while (fs->lfs_stoplwp != NULL)
1621 cv_wait(&fs->lfs_stopcv, &fs->lfs_interlock);
1622 fs->lfs_stoplwp = curlwp;
1623 if (fs->lfs_nowrap == 0)
1624 log(LOG_NOTICE, "%s: disabled log wrap\n", fs->lfs_fsmnt);
1625 ++fs->lfs_nowrap;
1626 if (*(int *)ap->a_data == 1 ||
1627 ap->a_command == LFCNWRAPSTOP_COMPAT) {
1628 log(LOG_NOTICE, "LFCNSTOPWRAP waiting for log wrap\n");
1629 error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER,
1630 "segwrap", 0, &fs->lfs_interlock);
1631 log(LOG_NOTICE, "LFCNSTOPWRAP done waiting\n");
1632 if (error) {
1633 lfs_wrapgo(fs, VTOI(ap->a_vp), 0);
1634 }
1635 }
1636 mutex_exit(&fs->lfs_interlock);
1637 return 0;
1638
1639 case LFCNWRAPGO:
1640 case LFCNWRAPGO_COMPAT:
1641 /*
1642 * Having done its work, the agent wakes up the writer.
1643 * If the argument is 1, it sleeps until a new segment
1644 * is selected.
1645 */
1646 mutex_enter(&fs->lfs_interlock);
1647 error = lfs_wrapgo(fs, VTOI(ap->a_vp),
1648 (ap->a_command == LFCNWRAPGO_COMPAT ? 1 :
1649 *((int *)ap->a_data)));
1650 mutex_exit(&fs->lfs_interlock);
1651 return error;
1652
1653 case LFCNWRAPPASS:
1654 if ((VTOI(ap->a_vp)->i_lfs_iflags & LFSI_WRAPWAIT))
1655 return EALREADY;
1656 mutex_enter(&fs->lfs_interlock);
1657 if (fs->lfs_stoplwp != curlwp) {
1658 mutex_exit(&fs->lfs_interlock);
1659 return EALREADY;
1660 }
1661 if (fs->lfs_nowrap == 0) {
1662 mutex_exit(&fs->lfs_interlock);
1663 return EBUSY;
1664 }
1665 fs->lfs_wrappass = 1;
1666 wakeup(&fs->lfs_wrappass);
1667 /* Wait for the log to wrap, if asked */
1668 if (*(int *)ap->a_data) {
1669 mutex_enter(&ap->a_vp->v_interlock);
1670 lfs_vref(ap->a_vp);
1671 VTOI(ap->a_vp)->i_lfs_iflags |= LFSI_WRAPWAIT;
1672 log(LOG_NOTICE, "LFCNPASS waiting for log wrap\n");
1673 error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER,
1674 "segwrap", 0, &fs->lfs_interlock);
1675 log(LOG_NOTICE, "LFCNPASS done waiting\n");
1676 VTOI(ap->a_vp)->i_lfs_iflags &= ~LFSI_WRAPWAIT;
1677 lfs_vunref(ap->a_vp);
1678 }
1679 mutex_exit(&fs->lfs_interlock);
1680 return error;
1681
1682 case LFCNWRAPSTATUS:
1683 mutex_enter(&fs->lfs_interlock);
1684 *(int *)ap->a_data = fs->lfs_wrapstatus;
1685 mutex_exit(&fs->lfs_interlock);
1686 return 0;
1687
1688 default:
1689 return ufs_fcntl(v);
1690 }
1691 return 0;
1692 }
1693
1694 int
1695 lfs_getpages(void *v)
1696 {
1697 struct vop_getpages_args /* {
1698 struct vnode *a_vp;
1699 voff_t a_offset;
1700 struct vm_page **a_m;
1701 int *a_count;
1702 int a_centeridx;
1703 vm_prot_t a_access_type;
1704 int a_advice;
1705 int a_flags;
1706 } */ *ap = v;
1707
1708 if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM &&
1709 (ap->a_access_type & VM_PROT_WRITE) != 0) {
1710 return EPERM;
1711 }
1712 if ((ap->a_access_type & VM_PROT_WRITE) != 0) {
1713 mutex_enter(&VTOI(ap->a_vp)->i_lfs->lfs_interlock);
1714 LFS_SET_UINO(VTOI(ap->a_vp), IN_MODIFIED);
1715 mutex_exit(&VTOI(ap->a_vp)->i_lfs->lfs_interlock);
1716 }
1717
1718 /*
1719 * we're relying on the fact that genfs_getpages() always read in
1720 * entire filesystem blocks.
1721 */
1722 return genfs_getpages(v);
1723 }
1724
1725 /*
1726 * Wait for a page to become unbusy, possibly printing diagnostic messages
1727 * as well.
1728 *
1729 * Called with vp->v_interlock held; return with it held.
1730 */
1731 static void
1732 wait_for_page(struct vnode *vp, struct vm_page *pg, const char *label)
1733 {
1734 if ((pg->flags & PG_BUSY) == 0)
1735 return; /* Nothing to wait for! */
1736
1737 #if defined(DEBUG) && defined(UVM_PAGE_TRKOWN)
1738 static struct vm_page *lastpg;
1739
1740 if (label != NULL && pg != lastpg) {
1741 if (pg->owner_tag) {
1742 printf("lfs_putpages[%d.%d]: %s: page %p owner %d.%d [%s]\n",
1743 curproc->p_pid, curlwp->l_lid, label,
1744 pg, pg->owner, pg->lowner, pg->owner_tag);
1745 } else {
1746 printf("lfs_putpages[%d.%d]: %s: page %p unowned?!\n",
1747 curproc->p_pid, curlwp->l_lid, label, pg);
1748 }
1749 }
1750 lastpg = pg;
1751 #endif
1752
1753 pg->flags |= PG_WANTED;
1754 UVM_UNLOCK_AND_WAIT(pg, &vp->v_interlock, 0, "lfsput", 0);
1755 mutex_enter(&vp->v_interlock);
1756 }
1757
1758 /*
1759 * This routine is called by lfs_putpages() when it can't complete the
1760 * write because a page is busy. This means that either (1) someone,
1761 * possibly the pagedaemon, is looking at this page, and will give it up
1762 * presently; or (2) we ourselves are holding the page busy in the
1763 * process of being written (either gathered or actually on its way to
1764 * disk). We don't need to give up the segment lock, but we might need
1765 * to call lfs_writeseg() to expedite the page's journey to disk.
1766 *
1767 * Called with vp->v_interlock held; return with it held.
1768 */
1769 /* #define BUSYWAIT */
1770 static void
1771 write_and_wait(struct lfs *fs, struct vnode *vp, struct vm_page *pg,
1772 int seglocked, const char *label)
1773 {
1774 #ifndef BUSYWAIT
1775 struct inode *ip = VTOI(vp);
1776 struct segment *sp = fs->lfs_sp;
1777 int count = 0;
1778
1779 if (pg == NULL)
1780 return;
1781
1782 while (pg->flags & PG_BUSY) {
1783 mutex_exit(&vp->v_interlock);
1784 if (sp->cbpp - sp->bpp > 1) {
1785 /* Write gathered pages */
1786 lfs_updatemeta(sp);
1787 lfs_release_finfo(fs);
1788 (void) lfs_writeseg(fs, sp);
1789
1790 /*
1791 * Reinitialize FIP
1792 */
1793 KASSERT(sp->vp == vp);
1794 lfs_acquire_finfo(fs, ip->i_number,
1795 ip->i_gen);
1796 }
1797 ++count;
1798 mutex_enter(&vp->v_interlock);
1799 wait_for_page(vp, pg, label);
1800 }
1801 if (label != NULL && count > 1)
1802 printf("lfs_putpages[%d]: %s: %sn = %d\n", curproc->p_pid,
1803 label, (count > 0 ? "looping, " : ""), count);
1804 #else
1805 preempt(1);
1806 #endif
1807 }
1808
1809 /*
1810 * Make sure that for all pages in every block in the given range,
1811 * either all are dirty or all are clean. If any of the pages
1812 * we've seen so far are dirty, put the vnode on the paging chain,
1813 * and mark it IN_PAGING.
1814 *
1815 * If checkfirst != 0, don't check all the pages but return at the
1816 * first dirty page.
1817 */
1818 static int
1819 check_dirty(struct lfs *fs, struct vnode *vp,
1820 off_t startoffset, off_t endoffset, off_t blkeof,
1821 int flags, int checkfirst, struct vm_page **pgp)
1822 {
1823 int by_list;
1824 struct vm_page *curpg = NULL; /* XXX: gcc */
1825 struct vm_page *pgs[MAXBSIZE / PAGE_SIZE], *pg;
1826 off_t soff = 0; /* XXX: gcc */
1827 voff_t off;
1828 int i;
1829 int nonexistent;
1830 int any_dirty; /* number of dirty pages */
1831 int dirty; /* number of dirty pages in a block */
1832 int tdirty;
1833 int pages_per_block = fs->lfs_bsize >> PAGE_SHIFT;
1834 int pagedaemon = (curlwp == uvm.pagedaemon_lwp);
1835
1836 ASSERT_MAYBE_SEGLOCK(fs);
1837 top:
1838 by_list = (vp->v_uobj.uo_npages <=
1839 ((endoffset - startoffset) >> PAGE_SHIFT) *
1840 UVM_PAGE_HASH_PENALTY);
1841 any_dirty = 0;
1842
1843 if (by_list) {
1844 curpg = TAILQ_FIRST(&vp->v_uobj.memq);
1845 } else {
1846 soff = startoffset;
1847 }
1848 while (by_list || soff < MIN(blkeof, endoffset)) {
1849 if (by_list) {
1850 /*
1851 * Find the first page in a block. Skip
1852 * blocks outside our area of interest or beyond
1853 * the end of file.
1854 */
1855 if (pages_per_block > 1) {
1856 while (curpg &&
1857 ((curpg->offset & fs->lfs_bmask) ||
1858 curpg->offset >= vp->v_size ||
1859 curpg->offset >= endoffset))
1860 curpg = TAILQ_NEXT(curpg, listq);
1861 }
1862 if (curpg == NULL)
1863 break;
1864 soff = curpg->offset;
1865 }
1866
1867 /*
1868 * Mark all pages in extended range busy; find out if any
1869 * of them are dirty.
1870 */
1871 nonexistent = dirty = 0;
1872 for (i = 0; i == 0 || i < pages_per_block; i++) {
1873 if (by_list && pages_per_block <= 1) {
1874 pgs[i] = pg = curpg;
1875 } else {
1876 off = soff + (i << PAGE_SHIFT);
1877 pgs[i] = pg = uvm_pagelookup(&vp->v_uobj, off);
1878 if (pg == NULL) {
1879 ++nonexistent;
1880 continue;
1881 }
1882 }
1883 KASSERT(pg != NULL);
1884
1885 /*
1886 * If we're holding the segment lock, we can deadlock
1887 * against a process that has our page and is waiting
1888 * for the cleaner, while the cleaner waits for the
1889 * segment lock. Just bail in that case.
1890 */
1891 if ((pg->flags & PG_BUSY) &&
1892 (pagedaemon || LFS_SEGLOCK_HELD(fs))) {
1893 if (i > 0)
1894 uvm_page_unbusy(pgs, i);
1895 DLOG((DLOG_PAGE, "lfs_putpages: avoiding 3-way or pagedaemon deadlock\n"));
1896 if (pgp)
1897 *pgp = pg;
1898 return -1;
1899 }
1900
1901 while (pg->flags & PG_BUSY) {
1902 wait_for_page(vp, pg, NULL);
1903 if (i > 0)
1904 uvm_page_unbusy(pgs, i);
1905 goto top;
1906 }
1907 pg->flags |= PG_BUSY;
1908 UVM_PAGE_OWN(pg, "lfs_putpages");
1909
1910 pmap_page_protect(pg, VM_PROT_NONE);
1911 tdirty = (pmap_clear_modify(pg) ||
1912 (pg->flags & PG_CLEAN) == 0);
1913 dirty += tdirty;
1914 }
1915 if (pages_per_block > 0 && nonexistent >= pages_per_block) {
1916 if (by_list) {
1917 curpg = TAILQ_NEXT(curpg, listq);
1918 } else {
1919 soff += fs->lfs_bsize;
1920 }
1921 continue;
1922 }
1923
1924 any_dirty += dirty;
1925 KASSERT(nonexistent == 0);
1926
1927 /*
1928 * If any are dirty make all dirty; unbusy them,
1929 * but if we were asked to clean, wire them so that
1930 * the pagedaemon doesn't bother us about them while
1931 * they're on their way to disk.
1932 */
1933 for (i = 0; i == 0 || i < pages_per_block; i++) {
1934 pg = pgs[i];
1935 KASSERT(!((pg->flags & PG_CLEAN) && (pg->flags & PG_DELWRI)));
1936 if (dirty) {
1937 pg->flags &= ~PG_CLEAN;
1938 if (flags & PGO_FREE) {
1939 /*
1940 * Wire the page so that
1941 * pdaemon doesn't see it again.
1942 */
1943 mutex_enter(&uvm_pageqlock);
1944 uvm_pagewire(pg);
1945 mutex_exit(&uvm_pageqlock);
1946
1947 /* Suspended write flag */
1948 pg->flags |= PG_DELWRI;
1949 }
1950 }
1951 if (pg->flags & PG_WANTED)
1952 wakeup(pg);
1953 pg->flags &= ~(PG_WANTED|PG_BUSY);
1954 UVM_PAGE_OWN(pg, NULL);
1955 }
1956
1957 if (checkfirst && any_dirty)
1958 break;
1959
1960 if (by_list) {
1961 curpg = TAILQ_NEXT(curpg, listq);
1962 } else {
1963 soff += MAX(PAGE_SIZE, fs->lfs_bsize);
1964 }
1965 }
1966
1967 return any_dirty;
1968 }
1969
1970 /*
1971 * lfs_putpages functions like genfs_putpages except that
1972 *
1973 * (1) It needs to bounds-check the incoming requests to ensure that
1974 * they are block-aligned; if they are not, expand the range and
1975 * do the right thing in case, e.g., the requested range is clean
1976 * but the expanded range is dirty.
1977 *
1978 * (2) It needs to explicitly send blocks to be written when it is done.
1979 * If VOP_PUTPAGES is called without the seglock held, we simply take
1980 * the seglock and let lfs_segunlock wait for us.
1981 * XXX There might be a bad situation if we have to flush a vnode while
1982 * XXX lfs_markv is in operation. As of this writing we panic in this
1983 * XXX case.
1984 *
1985 * Assumptions:
1986 *
1987 * (1) The caller does not hold any pages in this vnode busy. If it does,
1988 * there is a danger that when we expand the page range and busy the
1989 * pages we will deadlock.
1990 *
1991 * (2) We are called with vp->v_interlock held; we must return with it
1992 * released.
1993 *
1994 * (3) We don't absolutely have to free pages right away, provided that
1995 * the request does not have PGO_SYNCIO. When the pagedaemon gives
1996 * us a request with PGO_FREE, we take the pages out of the paging
1997 * queue and wake up the writer, which will handle freeing them for us.
1998 *
1999 * We ensure that for any filesystem block, all pages for that
2000 * block are either resident or not, even if those pages are higher
2001 * than EOF; that means that we will be getting requests to free
2002 * "unused" pages above EOF all the time, and should ignore them.
2003 *
2004 * (4) If we are called with PGO_LOCKED, the finfo array we are to write
2005 * into has been set up for us by lfs_writefile. If not, we will
2006 * have to handle allocating and/or freeing an finfo entry.
2007 *
2008 * XXX note that we're (ab)using PGO_LOCKED as "seglock held".
2009 */
2010
2011 /* How many times to loop before we should start to worry */
2012 #define TOOMANY 4
2013
2014 int
2015 lfs_putpages(void *v)
2016 {
2017 int error;
2018 struct vop_putpages_args /* {
2019 struct vnode *a_vp;
2020 voff_t a_offlo;
2021 voff_t a_offhi;
2022 int a_flags;
2023 } */ *ap = v;
2024 struct vnode *vp;
2025 struct inode *ip;
2026 struct lfs *fs;
2027 struct segment *sp;
2028 off_t origoffset, startoffset, endoffset, origendoffset, blkeof;
2029 off_t off, max_endoffset;
2030 bool seglocked, sync, pagedaemon;
2031 struct vm_page *pg, *busypg;
2032 UVMHIST_FUNC("lfs_putpages"); UVMHIST_CALLED(ubchist);
2033 #ifdef DEBUG
2034 int debug_n_again, debug_n_dirtyclean;
2035 #endif
2036
2037 vp = ap->a_vp;
2038 ip = VTOI(vp);
2039 fs = ip->i_lfs;
2040 sync = (ap->a_flags & PGO_SYNCIO) != 0;
2041 pagedaemon = (curlwp == uvm.pagedaemon_lwp);
2042
2043 /* Putpages does nothing for metadata. */
2044 if (vp == fs->lfs_ivnode || vp->v_type != VREG) {
2045 mutex_exit(&vp->v_interlock);
2046 return 0;
2047 }
2048
2049 /*
2050 * If there are no pages, don't do anything.
2051 */
2052 if (vp->v_uobj.uo_npages == 0) {
2053 if (TAILQ_EMPTY(&vp->v_uobj.memq) &&
2054 (vp->v_iflag & VI_ONWORKLST) &&
2055 LIST_FIRST(&vp->v_dirtyblkhd) == NULL) {
2056 vp->v_iflag &= ~VI_WRMAPDIRTY;
2057 vn_syncer_remove_from_worklist(vp);
2058 }
2059 mutex_exit(&vp->v_interlock);
2060
2061 /* Remove us from paging queue, if we were on it */
2062 mutex_enter(&fs->lfs_interlock);
2063 if (ip->i_flags & IN_PAGING) {
2064 ip->i_flags &= ~IN_PAGING;
2065 TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
2066 }
2067 mutex_exit(&fs->lfs_interlock);
2068 return 0;
2069 }
2070
2071 blkeof = blkroundup(fs, ip->i_size);
2072
2073 /*
2074 * Ignore requests to free pages past EOF but in the same block
2075 * as EOF, unless the request is synchronous. (If the request is
2076 * sync, it comes from lfs_truncate.)
2077 * XXXUBC Make these pages look "active" so the pagedaemon won't
2078 * XXXUBC bother us with them again.
2079 */
2080 if (!sync && ap->a_offlo >= ip->i_size && ap->a_offlo < blkeof) {
2081 origoffset = ap->a_offlo;
2082 for (off = origoffset; off < blkeof; off += fs->lfs_bsize) {
2083 pg = uvm_pagelookup(&vp->v_uobj, off);
2084 KASSERT(pg != NULL);
2085 while (pg->flags & PG_BUSY) {
2086 pg->flags |= PG_WANTED;
2087 UVM_UNLOCK_AND_WAIT(pg, &vp->v_interlock, 0,
2088 "lfsput2", 0);
2089 mutex_enter(&vp->v_interlock);
2090 }
2091 mutex_enter(&uvm_pageqlock);
2092 uvm_pageactivate(pg);
2093 mutex_exit(&uvm_pageqlock);
2094 }
2095 ap->a_offlo = blkeof;
2096 if (ap->a_offhi > 0 && ap->a_offhi <= ap->a_offlo) {
2097 mutex_exit(&vp->v_interlock);
2098 return 0;
2099 }
2100 }
2101
2102 /*
2103 * Extend page range to start and end at block boundaries.
2104 * (For the purposes of VOP_PUTPAGES, fragments don't exist.)
2105 */
2106 origoffset = ap->a_offlo;
2107 origendoffset = ap->a_offhi;
2108 startoffset = origoffset & ~(fs->lfs_bmask);
2109 max_endoffset = (trunc_page(LLONG_MAX) >> fs->lfs_bshift)
2110 << fs->lfs_bshift;
2111
2112 if (origendoffset == 0 || ap->a_flags & PGO_ALLPAGES) {
2113 endoffset = max_endoffset;
2114 origendoffset = endoffset;
2115 } else {
2116 origendoffset = round_page(ap->a_offhi);
2117 endoffset = round_page(blkroundup(fs, origendoffset));
2118 }
2119
2120 KASSERT(startoffset > 0 || endoffset >= startoffset);
2121 if (startoffset == endoffset) {
2122 /* Nothing to do, why were we called? */
2123 mutex_exit(&vp->v_interlock);
2124 DLOG((DLOG_PAGE, "lfs_putpages: startoffset = endoffset = %"
2125 PRId64 "\n", startoffset));
2126 return 0;
2127 }
2128
2129 ap->a_offlo = startoffset;
2130 ap->a_offhi = endoffset;
2131
2132 /*
2133 * If not cleaning, just send the pages through genfs_putpages
2134 * to be returned to the pool.
2135 */
2136 if (!(ap->a_flags & PGO_CLEANIT))
2137 return genfs_putpages(v);
2138
2139 /* Set PGO_BUSYFAIL to avoid deadlocks */
2140 ap->a_flags |= PGO_BUSYFAIL;
2141
2142 /*
2143 * Likewise, if we are asked to clean but the pages are not
2144 * dirty, we can just free them using genfs_putpages.
2145 */
2146 #ifdef DEBUG
2147 debug_n_dirtyclean = 0;
2148 #endif
2149 do {
2150 int r;
2151
2152 /* Count the number of dirty pages */
2153 r = check_dirty(fs, vp, startoffset, endoffset, blkeof,
2154 ap->a_flags, 1, NULL);
2155 if (r < 0) {
2156 /* Pages are busy with another process */
2157 mutex_exit(&vp->v_interlock);
2158 return EDEADLK;
2159 }
2160 if (r > 0) /* Some pages are dirty */
2161 break;
2162
2163 /*
2164 * Sometimes pages are dirtied between the time that
2165 * we check and the time we try to clean them.
2166 * Instruct lfs_gop_write to return EDEADLK in this case
2167 * so we can write them properly.
2168 */
2169 ip->i_lfs_iflags |= LFSI_NO_GOP_WRITE;
2170 r = genfs_do_putpages(vp, startoffset, endoffset,
2171 ap->a_flags, &busypg);
2172 ip->i_lfs_iflags &= ~LFSI_NO_GOP_WRITE;
2173 if (r != EDEADLK)
2174 return r;
2175
2176 /* One of the pages was busy. Start over. */
2177 mutex_enter(&vp->v_interlock);
2178 wait_for_page(vp, busypg, "dirtyclean");
2179 #ifdef DEBUG
2180 ++debug_n_dirtyclean;
2181 #endif
2182 } while(1);
2183
2184 #ifdef DEBUG
2185 if (debug_n_dirtyclean > TOOMANY)
2186 printf("lfs_putpages: dirtyclean: looping, n = %d\n",
2187 debug_n_dirtyclean);
2188 #endif
2189
2190 /*
2191 * Dirty and asked to clean.
2192 *
2193 * Pagedaemon can't actually write LFS pages; wake up
2194 * the writer to take care of that. The writer will
2195 * notice the pager inode queue and act on that.
2196 */
2197 if (pagedaemon) {
2198 mutex_enter(&fs->lfs_interlock);
2199 if (!(ip->i_flags & IN_PAGING)) {
2200 ip->i_flags |= IN_PAGING;
2201 TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip, i_lfs_pchain);
2202 }
2203 mutex_enter(&lfs_subsys_lock);
2204 wakeup(&lfs_writer_daemon);
2205 mutex_exit(&lfs_subsys_lock);
2206 mutex_exit(&fs->lfs_interlock);
2207 mutex_exit(&vp->v_interlock);
2208 preempt();
2209 return EWOULDBLOCK;
2210 }
2211
2212 /*
2213 * If this is a file created in a recent dirop, we can't flush its
2214 * inode until the dirop is complete. Drain dirops, then flush the
2215 * filesystem (taking care of any other pending dirops while we're
2216 * at it).
2217 */
2218 if ((ap->a_flags & (PGO_CLEANIT|PGO_LOCKED)) == PGO_CLEANIT &&
2219 (vp->v_uflag & VU_DIROP)) {
2220 int locked;
2221
2222 DLOG((DLOG_PAGE, "lfs_putpages: flushing VDIROP\n"));
2223 locked = (VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
2224 mutex_exit(&vp->v_interlock);
2225 lfs_writer_enter(fs, "ppdirop");
2226 if (locked)
2227 VOP_UNLOCK(vp, 0); /* XXX why? */
2228
2229 mutex_enter(&fs->lfs_interlock);
2230 lfs_flush_fs(fs, sync ? SEGM_SYNC : 0);
2231 mutex_exit(&fs->lfs_interlock);
2232
2233 mutex_enter(&vp->v_interlock);
2234 if (locked) {
2235 VOP_LOCK(vp, LK_EXCLUSIVE | LK_INTERLOCK);
2236 mutex_enter(&vp->v_interlock);
2237 }
2238 lfs_writer_leave(fs);
2239
2240 /* XXX the flush should have taken care of this one too! */
2241 }
2242
2243 /*
2244 * This is it. We are going to write some pages. From here on
2245 * down it's all just mechanics.
2246 *
2247 * Don't let genfs_putpages wait; lfs_segunlock will wait for us.
2248 */
2249 ap->a_flags &= ~PGO_SYNCIO;
2250
2251 /*
2252 * If we've already got the seglock, flush the node and return.
2253 * The FIP has already been set up for us by lfs_writefile,
2254 * and FIP cleanup and lfs_updatemeta will also be done there,
2255 * unless genfs_putpages returns EDEADLK; then we must flush
2256 * what we have, and correct FIP and segment header accounting.
2257 */
2258 get_seglock:
2259 /*
2260 * If we are not called with the segment locked, lock it.
2261 * Account for a new FIP in the segment header, and set sp->vp.
2262 * (This should duplicate the setup at the top of lfs_writefile().)
2263 */
2264 seglocked = (ap->a_flags & PGO_LOCKED) != 0;
2265 if (!seglocked) {
2266 mutex_exit(&vp->v_interlock);
2267 error = lfs_seglock(fs, SEGM_PROT | (sync ? SEGM_SYNC : 0));
2268 if (error != 0)
2269 return error;
2270 mutex_enter(&vp->v_interlock);
2271 lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
2272 }
2273 sp = fs->lfs_sp;
2274 KASSERT(sp->vp == NULL);
2275 sp->vp = vp;
2276
2277 /*
2278 * Ensure that the partial segment is marked SS_DIROP if this
2279 * vnode is a DIROP.
2280 */
2281 if (!seglocked && vp->v_uflag & VU_DIROP)
2282 ((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
2283
2284 /*
2285 * Loop over genfs_putpages until all pages are gathered.
2286 * genfs_putpages() drops the interlock, so reacquire it if necessary.
2287 * Whenever we lose the interlock we have to rerun check_dirty, as
2288 * well, since more pages might have been dirtied in our absence.
2289 */
2290 #ifdef DEBUG
2291 debug_n_again = 0;
2292 #endif
2293 do {
2294 busypg = NULL;
2295 if (check_dirty(fs, vp, startoffset, endoffset, blkeof,
2296 ap->a_flags, 0, &busypg) < 0) {
2297 mutex_exit(&vp->v_interlock);
2298
2299 mutex_enter(&vp->v_interlock);
2300 write_and_wait(fs, vp, busypg, seglocked, NULL);
2301 if (!seglocked) {
2302 lfs_release_finfo(fs);
2303 lfs_segunlock(fs);
2304 }
2305 sp->vp = NULL;
2306 goto get_seglock;
2307 }
2308
2309 busypg = NULL;
2310 error = genfs_do_putpages(vp, startoffset, endoffset,
2311 ap->a_flags, &busypg);
2312
2313 if (error == EDEADLK || error == EAGAIN) {
2314 DLOG((DLOG_PAGE, "lfs_putpages: genfs_putpages returned"
2315 " %d ino %d off %x (seg %d)\n", error,
2316 ip->i_number, fs->lfs_offset,
2317 dtosn(fs, fs->lfs_offset)));
2318
2319 mutex_enter(&vp->v_interlock);
2320 write_and_wait(fs, vp, busypg, seglocked, "again");
2321 }
2322 #ifdef DEBUG
2323 ++debug_n_again;
2324 #endif
2325 } while (error == EDEADLK);
2326 #ifdef DEBUG
2327 if (debug_n_again > TOOMANY)
2328 printf("lfs_putpages: again: looping, n = %d\n", debug_n_again);
2329 #endif
2330
2331 KASSERT(sp != NULL && sp->vp == vp);
2332 if (!seglocked) {
2333 sp->vp = NULL;
2334
2335 /* Write indirect blocks as well */
2336 lfs_gather(fs, fs->lfs_sp, vp, lfs_match_indir);
2337 lfs_gather(fs, fs->lfs_sp, vp, lfs_match_dindir);
2338 lfs_gather(fs, fs->lfs_sp, vp, lfs_match_tindir);
2339
2340 KASSERT(sp->vp == NULL);
2341 sp->vp = vp;
2342 }
2343
2344 /*
2345 * Blocks are now gathered into a segment waiting to be written.
2346 * All that's left to do is update metadata, and write them.
2347 */
2348 lfs_updatemeta(sp);
2349 KASSERT(sp->vp == vp);
2350 sp->vp = NULL;
2351
2352 /*
2353 * If we were called from lfs_writefile, we don't need to clean up
2354 * the FIP or unlock the segment lock. We're done.
2355 */
2356 if (seglocked)
2357 return error;
2358
2359 /* Clean up FIP and send it to disk. */
2360 lfs_release_finfo(fs);
2361 lfs_writeseg(fs, fs->lfs_sp);
2362
2363 /*
2364 * Remove us from paging queue if we wrote all our pages.
2365 */
2366 if (origendoffset == 0 || ap->a_flags & PGO_ALLPAGES) {
2367 mutex_enter(&fs->lfs_interlock);
2368 if (ip->i_flags & IN_PAGING) {
2369 ip->i_flags &= ~IN_PAGING;
2370 TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
2371 }
2372 mutex_exit(&fs->lfs_interlock);
2373 }
2374
2375 /*
2376 * XXX - with the malloc/copy writeseg, the pages are freed by now
2377 * even if we don't wait (e.g. if we hold a nested lock). This
2378 * will not be true if we stop using malloc/copy.
2379 */
2380 KASSERT(fs->lfs_sp->seg_flags & SEGM_PROT);
2381 lfs_segunlock(fs);
2382
2383 /*
2384 * Wait for v_numoutput to drop to zero. The seglock should
2385 * take care of this, but there is a slight possibility that
2386 * aiodoned might not have got around to our buffers yet.
2387 */
2388 if (sync) {
2389 mutex_enter(&vp->v_interlock);
2390 while (vp->v_numoutput > 0) {
2391 DLOG((DLOG_PAGE, "lfs_putpages: ino %d sleeping on"
2392 " num %d\n", ip->i_number, vp->v_numoutput));
2393 cv_wait(&vp->v_cv, &vp->v_interlock);
2394 }
2395 mutex_exit(&vp->v_interlock);
2396 }
2397 return error;
2398 }
2399
2400 /*
2401 * Return the last logical file offset that should be written for this file
2402 * if we're doing a write that ends at "size". If writing, we need to know
2403 * about sizes on disk, i.e. fragments if there are any; if reading, we need
2404 * to know about entire blocks.
2405 */
2406 void
2407 lfs_gop_size(struct vnode *vp, off_t size, off_t *eobp, int flags)
2408 {
2409 struct inode *ip = VTOI(vp);
2410 struct lfs *fs = ip->i_lfs;
2411 daddr_t olbn, nlbn;
2412
2413 olbn = lblkno(fs, ip->i_size);
2414 nlbn = lblkno(fs, size);
2415 if (!(flags & GOP_SIZE_MEM) && nlbn < NDADDR && olbn <= nlbn) {
2416 *eobp = fragroundup(fs, size);
2417 } else {
2418 *eobp = blkroundup(fs, size);
2419 }
2420 }
2421
2422 #ifdef DEBUG
2423 void lfs_dump_vop(void *);
2424
2425 void
2426 lfs_dump_vop(void *v)
2427 {
2428 struct vop_putpages_args /* {
2429 struct vnode *a_vp;
2430 voff_t a_offlo;
2431 voff_t a_offhi;
2432 int a_flags;
2433 } */ *ap = v;
2434
2435 #ifdef DDB
2436 vfs_vnode_print(ap->a_vp, 0, printf);
2437 #endif
2438 lfs_dump_dinode(VTOI(ap->a_vp)->i_din.ffs1_din);
2439 }
2440 #endif
2441
2442 int
2443 lfs_mmap(void *v)
2444 {
2445 struct vop_mmap_args /* {
2446 const struct vnodeop_desc *a_desc;
2447 struct vnode *a_vp;
2448 vm_prot_t a_prot;
2449 kauth_cred_t a_cred;
2450 } */ *ap = v;
2451
2452 if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM)
2453 return EOPNOTSUPP;
2454 return ufs_mmap(v);
2455 }
2456