2006-04-11 01:17:21 +04:00
|
|
|
/* $NetBSD: lfs_vnops.c,v 1.165 2006/04/10 21:17:21 perseant Exp $ */
|
1994-06-29 10:39:25 +04:00
|
|
|
|
1999-03-10 03:20:00 +03:00
|
|
|
/*-
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
|
1999-03-10 03:20:00 +03:00
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
|
|
|
* by Konrad E. Schroder <perseant@hhhh.org>.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
|
* must display the following acknowledgement:
|
2003-02-20 07:27:23 +03:00
|
|
|
* This product includes software developed by the NetBSD
|
|
|
|
|
* Foundation, Inc. and its contributors.
|
1999-03-10 03:20:00 +03:00
|
|
|
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
|
|
|
|
* contributors may be used to endorse or promote products derived
|
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
|
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
|
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
|
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
|
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
*/
|
1994-06-08 15:41:58 +04:00
|
|
|
/*
|
1998-03-01 05:20:01 +03:00
|
|
|
* Copyright (c) 1986, 1989, 1991, 1993, 1995
|
1994-06-08 15:41:58 +04:00
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2003-08-07 20:26:28 +04:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-06-08 15:41:58 +04:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
|
* without specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
|
*
|
1998-03-01 05:20:01 +03:00
|
|
|
* @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95
|
1994-06-08 15:41:58 +04:00
|
|
|
*/
|
|
|
|
|
|
2001-11-08 05:39:06 +03:00
|
|
|
#include <sys/cdefs.h>
|
2006-04-11 01:17:21 +04:00
|
|
|
__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.165 2006/04/10 21:17:21 perseant Exp $");
|
2001-11-08 05:39:06 +03:00
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/systm.h>
|
|
|
|
|
#include <sys/namei.h>
|
|
|
|
|
#include <sys/resourcevar.h>
|
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
|
#include <sys/file.h>
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
#include <sys/buf.h>
|
|
|
|
|
#include <sys/proc.h>
|
|
|
|
|
#include <sys/mount.h>
|
|
|
|
|
#include <sys/vnode.h>
|
1998-09-01 07:26:05 +04:00
|
|
|
#include <sys/pool.h>
|
1996-02-10 01:28:45 +03:00
|
|
|
#include <sys/signalvar.h>
|
1994-06-08 15:41:58 +04:00
|
|
|
|
|
|
|
|
#include <miscfs/fifofs/fifo.h>
|
1996-09-02 03:47:48 +04:00
|
|
|
#include <miscfs/genfs/genfs.h>
|
|
|
|
|
#include <miscfs/specfs/specdev.h>
|
1994-06-08 15:41:58 +04:00
|
|
|
|
|
|
|
|
#include <ufs/ufs/inode.h>
|
|
|
|
|
#include <ufs/ufs/dir.h>
|
|
|
|
|
#include <ufs/ufs/ufsmount.h>
|
|
|
|
|
#include <ufs/ufs/ufs_extern.h>
|
|
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
#include <uvm/uvm.h>
|
2003-03-09 00:46:04 +03:00
|
|
|
#include <uvm/uvm_pmap.h>
|
|
|
|
|
#include <uvm/uvm_stat.h>
|
|
|
|
|
#include <uvm/uvm_pager.h>
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
#include <ufs/lfs/lfs.h>
|
|
|
|
|
#include <ufs/lfs/lfs_extern.h>
|
|
|
|
|
|
2003-03-01 14:20:21 +03:00
|
|
|
extern pid_t lfs_writer_daemon;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
/* Global vfs data structures for lfs. */
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
int (**lfs_vnodeop_p)(void *);
|
2001-01-22 15:17:35 +03:00
|
|
|
const struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_default_desc, vn_default_error },
|
|
|
|
|
{ &vop_lookup_desc, ufs_lookup }, /* lookup */
|
1999-03-10 03:20:00 +03:00
|
|
|
{ &vop_create_desc, lfs_create }, /* create */
|
2003-01-30 17:18:32 +03:00
|
|
|
{ &vop_whiteout_desc, ufs_whiteout }, /* whiteout */
|
1999-03-10 03:20:00 +03:00
|
|
|
{ &vop_mknod_desc, lfs_mknod }, /* mknod */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_open_desc, ufs_open }, /* open */
|
|
|
|
|
{ &vop_close_desc, lfs_close }, /* close */
|
|
|
|
|
{ &vop_access_desc, ufs_access }, /* access */
|
|
|
|
|
{ &vop_getattr_desc, lfs_getattr }, /* getattr */
|
2002-02-11 05:47:29 +03:00
|
|
|
{ &vop_setattr_desc, lfs_setattr }, /* setattr */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_read_desc, lfs_read }, /* read */
|
|
|
|
|
{ &vop_write_desc, lfs_write }, /* write */
|
1994-12-13 23:14:30 +03:00
|
|
|
{ &vop_lease_desc, ufs_lease_check }, /* lease */
|
2003-02-26 02:12:06 +03:00
|
|
|
{ &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
|
|
|
|
|
{ &vop_fcntl_desc, lfs_fcntl }, /* fcntl */
|
1996-09-07 16:40:22 +04:00
|
|
|
{ &vop_poll_desc, ufs_poll }, /* poll */
|
2002-10-23 13:10:23 +04:00
|
|
|
{ &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */
|
1998-03-01 05:20:01 +03:00
|
|
|
{ &vop_revoke_desc, ufs_revoke }, /* revoke */
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
{ &vop_mmap_desc, lfs_mmap }, /* mmap */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_fsync_desc, lfs_fsync }, /* fsync */
|
|
|
|
|
{ &vop_seek_desc, ufs_seek }, /* seek */
|
1999-03-10 03:20:00 +03:00
|
|
|
{ &vop_remove_desc, lfs_remove }, /* remove */
|
|
|
|
|
{ &vop_link_desc, lfs_link }, /* link */
|
|
|
|
|
{ &vop_rename_desc, lfs_rename }, /* rename */
|
|
|
|
|
{ &vop_mkdir_desc, lfs_mkdir }, /* mkdir */
|
|
|
|
|
{ &vop_rmdir_desc, lfs_rmdir }, /* rmdir */
|
|
|
|
|
{ &vop_symlink_desc, lfs_symlink }, /* symlink */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_readdir_desc, ufs_readdir }, /* readdir */
|
|
|
|
|
{ &vop_readlink_desc, ufs_readlink }, /* readlink */
|
|
|
|
|
{ &vop_abortop_desc, ufs_abortop }, /* abortop */
|
2000-06-28 00:57:11 +04:00
|
|
|
{ &vop_inactive_desc, lfs_inactive }, /* inactive */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
|
|
|
|
|
{ &vop_lock_desc, ufs_lock }, /* lock */
|
|
|
|
|
{ &vop_unlock_desc, ufs_unlock }, /* unlock */
|
|
|
|
|
{ &vop_bmap_desc, ufs_bmap }, /* bmap */
|
2003-03-08 05:55:47 +03:00
|
|
|
{ &vop_strategy_desc, lfs_strategy }, /* strategy */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_print_desc, ufs_print }, /* print */
|
|
|
|
|
{ &vop_islocked_desc, ufs_islocked }, /* islocked */
|
|
|
|
|
{ &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
|
|
|
|
|
{ &vop_advlock_desc, ufs_advlock }, /* advlock */
|
|
|
|
|
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
|
2001-12-18 10:51:16 +03:00
|
|
|
{ &vop_getpages_desc, lfs_getpages }, /* getpages */
|
|
|
|
|
{ &vop_putpages_desc, lfs_putpages }, /* putpages */
|
2001-08-17 09:54:36 +04:00
|
|
|
{ NULL, NULL }
|
1994-06-08 15:41:58 +04:00
|
|
|
};
|
2001-01-22 15:17:35 +03:00
|
|
|
const struct vnodeopv_desc lfs_vnodeop_opv_desc =
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &lfs_vnodeop_p, lfs_vnodeop_entries };
|
|
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
int (**lfs_specop_p)(void *);
|
2001-01-22 15:17:35 +03:00
|
|
|
const struct vnodeopv_entry_desc lfs_specop_entries[] = {
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_default_desc, vn_default_error },
|
|
|
|
|
{ &vop_lookup_desc, spec_lookup }, /* lookup */
|
|
|
|
|
{ &vop_create_desc, spec_create }, /* create */
|
|
|
|
|
{ &vop_mknod_desc, spec_mknod }, /* mknod */
|
|
|
|
|
{ &vop_open_desc, spec_open }, /* open */
|
For synchronous writes, keep separate i/o counters for each write, so
processes don't have to wait for one another to finish (e.g., nfsd seems
to be a little happier now, though I haven't measured the difference).
Synchronous checkpoints, however, must always wait for all i/o to finish.
Take the contents of the callback functions and have them run in thread
context instead (aiodoned thread). lfs_iocount no longer has to be
protected in splbio(), and quite a bit less of the segment construction
loop needs to be in splbio() as well.
If lfs_markv is handed a block that is not the correct size according to
the inode, refuse to process it. (Formerly it was extended to the "correct"
size.) This is possibly more prone to deadlock, but less prone to corruption.
lfs_segclean now outright refuses to clean segments that appear to have live
bytes in them. Again this may be more prone to deadlock but avoids
corruption.
Replace ufsspec_close and ufsfifo_close with LFS equivalents; this means
that no UFS functions need to know about LFS_ITIMES any more. Remove
the reference from ufs/inode.h.
Tested on i386, test-compiled on alpha.
2002-06-16 04:13:15 +04:00
|
|
|
{ &vop_close_desc, lfsspec_close }, /* close */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_access_desc, ufs_access }, /* access */
|
|
|
|
|
{ &vop_getattr_desc, lfs_getattr }, /* getattr */
|
2002-02-11 05:47:29 +03:00
|
|
|
{ &vop_setattr_desc, lfs_setattr }, /* setattr */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_read_desc, ufsspec_read }, /* read */
|
|
|
|
|
{ &vop_write_desc, ufsspec_write }, /* write */
|
1994-12-13 23:14:30 +03:00
|
|
|
{ &vop_lease_desc, spec_lease_check }, /* lease */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_ioctl_desc, spec_ioctl }, /* ioctl */
|
1999-08-04 00:19:16 +04:00
|
|
|
{ &vop_fcntl_desc, ufs_fcntl }, /* fcntl */
|
1996-09-07 16:40:22 +04:00
|
|
|
{ &vop_poll_desc, spec_poll }, /* poll */
|
2002-10-23 13:10:23 +04:00
|
|
|
{ &vop_kqfilter_desc, spec_kqfilter }, /* kqfilter */
|
1998-03-01 05:20:01 +03:00
|
|
|
{ &vop_revoke_desc, spec_revoke }, /* revoke */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_mmap_desc, spec_mmap }, /* mmap */
|
|
|
|
|
{ &vop_fsync_desc, spec_fsync }, /* fsync */
|
|
|
|
|
{ &vop_seek_desc, spec_seek }, /* seek */
|
|
|
|
|
{ &vop_remove_desc, spec_remove }, /* remove */
|
|
|
|
|
{ &vop_link_desc, spec_link }, /* link */
|
|
|
|
|
{ &vop_rename_desc, spec_rename }, /* rename */
|
|
|
|
|
{ &vop_mkdir_desc, spec_mkdir }, /* mkdir */
|
|
|
|
|
{ &vop_rmdir_desc, spec_rmdir }, /* rmdir */
|
|
|
|
|
{ &vop_symlink_desc, spec_symlink }, /* symlink */
|
|
|
|
|
{ &vop_readdir_desc, spec_readdir }, /* readdir */
|
|
|
|
|
{ &vop_readlink_desc, spec_readlink }, /* readlink */
|
|
|
|
|
{ &vop_abortop_desc, spec_abortop }, /* abortop */
|
2000-06-28 00:57:11 +04:00
|
|
|
{ &vop_inactive_desc, lfs_inactive }, /* inactive */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
|
|
|
|
|
{ &vop_lock_desc, ufs_lock }, /* lock */
|
|
|
|
|
{ &vop_unlock_desc, ufs_unlock }, /* unlock */
|
|
|
|
|
{ &vop_bmap_desc, spec_bmap }, /* bmap */
|
|
|
|
|
{ &vop_strategy_desc, spec_strategy }, /* strategy */
|
|
|
|
|
{ &vop_print_desc, ufs_print }, /* print */
|
|
|
|
|
{ &vop_islocked_desc, ufs_islocked }, /* islocked */
|
|
|
|
|
{ &vop_pathconf_desc, spec_pathconf }, /* pathconf */
|
|
|
|
|
{ &vop_advlock_desc, spec_advlock }, /* advlock */
|
1999-09-04 02:48:51 +04:00
|
|
|
{ &vop_bwrite_desc, vn_bwrite }, /* bwrite */
|
2001-08-17 09:54:36 +04:00
|
|
|
{ &vop_getpages_desc, spec_getpages }, /* getpages */
|
|
|
|
|
{ &vop_putpages_desc, spec_putpages }, /* putpages */
|
|
|
|
|
{ NULL, NULL }
|
1994-06-08 15:41:58 +04:00
|
|
|
};
|
2001-01-22 15:17:35 +03:00
|
|
|
const struct vnodeopv_desc lfs_specop_opv_desc =
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &lfs_specop_p, lfs_specop_entries };
|
|
|
|
|
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
int (**lfs_fifoop_p)(void *);
|
2001-01-22 15:17:35 +03:00
|
|
|
const struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_default_desc, vn_default_error },
|
|
|
|
|
{ &vop_lookup_desc, fifo_lookup }, /* lookup */
|
|
|
|
|
{ &vop_create_desc, fifo_create }, /* create */
|
|
|
|
|
{ &vop_mknod_desc, fifo_mknod }, /* mknod */
|
|
|
|
|
{ &vop_open_desc, fifo_open }, /* open */
|
For synchronous writes, keep separate i/o counters for each write, so
processes don't have to wait for one another to finish (e.g., nfsd seems
to be a little happier now, though I haven't measured the difference).
Synchronous checkpoints, however, must always wait for all i/o to finish.
Take the contents of the callback functions and have them run in thread
context instead (aiodoned thread). lfs_iocount no longer has to be
protected in splbio(), and quite a bit less of the segment construction
loop needs to be in splbio() as well.
If lfs_markv is handed a block that is not the correct size according to
the inode, refuse to process it. (Formerly it was extended to the "correct"
size.) This is possibly more prone to deadlock, but less prone to corruption.
lfs_segclean now outright refuses to clean segments that appear to have live
bytes in them. Again this may be more prone to deadlock but avoids
corruption.
Replace ufsspec_close and ufsfifo_close with LFS equivalents; this means
that no UFS functions need to know about LFS_ITIMES any more. Remove
the reference from ufs/inode.h.
Tested on i386, test-compiled on alpha.
2002-06-16 04:13:15 +04:00
|
|
|
{ &vop_close_desc, lfsfifo_close }, /* close */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_access_desc, ufs_access }, /* access */
|
|
|
|
|
{ &vop_getattr_desc, lfs_getattr }, /* getattr */
|
2002-02-11 05:47:29 +03:00
|
|
|
{ &vop_setattr_desc, lfs_setattr }, /* setattr */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_read_desc, ufsfifo_read }, /* read */
|
|
|
|
|
{ &vop_write_desc, ufsfifo_write }, /* write */
|
1994-12-13 23:14:30 +03:00
|
|
|
{ &vop_lease_desc, fifo_lease_check }, /* lease */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
|
1999-08-04 00:19:16 +04:00
|
|
|
{ &vop_fcntl_desc, ufs_fcntl }, /* fcntl */
|
1996-09-07 16:40:22 +04:00
|
|
|
{ &vop_poll_desc, fifo_poll }, /* poll */
|
2002-10-23 13:10:23 +04:00
|
|
|
{ &vop_kqfilter_desc, fifo_kqfilter }, /* kqfilter */
|
1998-03-01 05:20:01 +03:00
|
|
|
{ &vop_revoke_desc, fifo_revoke }, /* revoke */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_mmap_desc, fifo_mmap }, /* mmap */
|
|
|
|
|
{ &vop_fsync_desc, fifo_fsync }, /* fsync */
|
|
|
|
|
{ &vop_seek_desc, fifo_seek }, /* seek */
|
|
|
|
|
{ &vop_remove_desc, fifo_remove }, /* remove */
|
|
|
|
|
{ &vop_link_desc, fifo_link }, /* link */
|
|
|
|
|
{ &vop_rename_desc, fifo_rename }, /* rename */
|
|
|
|
|
{ &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
|
|
|
|
|
{ &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
|
|
|
|
|
{ &vop_symlink_desc, fifo_symlink }, /* symlink */
|
|
|
|
|
{ &vop_readdir_desc, fifo_readdir }, /* readdir */
|
|
|
|
|
{ &vop_readlink_desc, fifo_readlink }, /* readlink */
|
|
|
|
|
{ &vop_abortop_desc, fifo_abortop }, /* abortop */
|
2000-06-28 00:57:11 +04:00
|
|
|
{ &vop_inactive_desc, lfs_inactive }, /* inactive */
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
|
|
|
|
|
{ &vop_lock_desc, ufs_lock }, /* lock */
|
|
|
|
|
{ &vop_unlock_desc, ufs_unlock }, /* unlock */
|
|
|
|
|
{ &vop_bmap_desc, fifo_bmap }, /* bmap */
|
|
|
|
|
{ &vop_strategy_desc, fifo_strategy }, /* strategy */
|
|
|
|
|
{ &vop_print_desc, ufs_print }, /* print */
|
|
|
|
|
{ &vop_islocked_desc, ufs_islocked }, /* islocked */
|
|
|
|
|
{ &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
|
|
|
|
|
{ &vop_advlock_desc, fifo_advlock }, /* advlock */
|
|
|
|
|
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
|
2003-02-20 07:27:23 +03:00
|
|
|
{ &vop_putpages_desc, fifo_putpages }, /* putpages */
|
2001-08-17 09:54:36 +04:00
|
|
|
{ NULL, NULL }
|
1994-06-08 15:41:58 +04:00
|
|
|
};
|
2001-01-22 15:17:35 +03:00
|
|
|
const struct vnodeopv_desc lfs_fifoop_opv_desc =
|
1994-06-08 15:41:58 +04:00
|
|
|
{ &lfs_fifoop_p, lfs_fifoop_entries };
|
|
|
|
|
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
static int check_dirty(struct lfs *, struct vnode *, off_t, off_t, off_t, int, int);
|
|
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
#define LFS_READWRITE
|
|
|
|
|
#include <ufs/ufs/ufs_readwrite.c>
|
|
|
|
|
#undef LFS_READWRITE
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Synch an open file.
|
|
|
|
|
*/
|
|
|
|
|
/* ARGSUSED */
|
1996-02-10 01:28:45 +03:00
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_fsync(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vop_fsync_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
struct ucred *a_cred;
|
1999-03-10 03:20:00 +03:00
|
|
|
int a_flags;
|
2000-11-18 05:11:23 +03:00
|
|
|
off_t offlo;
|
|
|
|
|
off_t offhi;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
2001-12-18 10:51:16 +03:00
|
|
|
struct vnode *vp = ap->a_vp;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
int error, wait;
|
|
|
|
|
|
2006-03-31 06:31:37 +04:00
|
|
|
/* If we're mounted read-only, don't try to sync. */
|
|
|
|
|
if (VTOI(vp)->i_lfs->lfs_ronly)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2003-02-20 07:27:23 +03:00
|
|
|
/*
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
* Trickle sync checks for need to do a checkpoint after possible
|
|
|
|
|
* activity from the pagedaemon.
|
2003-02-20 07:27:23 +03:00
|
|
|
*/
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
if (ap->a_flags & FSYNC_LAZY) {
|
2003-07-12 20:19:00 +04:00
|
|
|
simple_lock(&lfs_subsys_lock);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
wakeup(&lfs_writer_daemon);
|
2003-07-12 20:19:00 +04:00
|
|
|
simple_unlock(&lfs_subsys_lock);
|
2000-11-12 10:58:36 +03:00
|
|
|
return 0;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
2000-11-12 10:58:36 +03:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
wait = (ap->a_flags & FSYNC_WAIT);
|
2003-04-23 11:20:37 +04:00
|
|
|
simple_lock(&vp->v_interlock);
|
|
|
|
|
error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo),
|
|
|
|
|
round_page(ap->a_offhi),
|
|
|
|
|
PGO_CLEANIT | (wait ? PGO_SYNCIO : 0));
|
|
|
|
|
if (error)
|
|
|
|
|
return error;
|
2005-11-02 15:38:58 +03:00
|
|
|
error = lfs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);
|
2005-01-26 02:55:20 +03:00
|
|
|
if (error == 0 && ap->a_flags & FSYNC_CACHE) {
|
|
|
|
|
int l = 0;
|
|
|
|
|
error = VOP_IOCTL(VTOI(vp)->i_devvp, DIOCCACHESYNC, &l, FWRITE,
|
2005-12-11 15:16:03 +03:00
|
|
|
ap->a_l->l_proc->p_ucred, ap->a_l);
|
2005-01-26 02:55:20 +03:00
|
|
|
}
|
2003-04-23 11:20:37 +04:00
|
|
|
if (wait && !VPISEMPTY(vp))
|
|
|
|
|
LFS_SET_UINO(VTOI(vp), IN_MODIFIED);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
2002-05-15 00:03:53 +04:00
|
|
|
return error;
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
2000-06-28 00:57:11 +04:00
|
|
|
/*
|
|
|
|
|
* Take IN_ADIROP off, then call ufs_inactive.
|
|
|
|
|
*/
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_inactive(void *v)
|
2000-06-28 00:57:11 +04:00
|
|
|
{
|
|
|
|
|
struct vop_inactive_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
2000-06-28 00:57:11 +04:00
|
|
|
} */ *ap = v;
|
2002-12-28 18:12:26 +03:00
|
|
|
|
2003-04-02 14:39:19 +04:00
|
|
|
KASSERT(VTOI(ap->a_vp)->i_nlink == VTOI(ap->a_vp)->i_ffs_effnlink);
|
2003-01-08 18:40:54 +03:00
|
|
|
|
2003-01-08 18:40:04 +03:00
|
|
|
lfs_unmark_vnode(ap->a_vp);
|
|
|
|
|
|
2003-03-21 09:16:53 +03:00
|
|
|
/*
|
|
|
|
|
* The Ifile is only ever inactivated on unmount.
|
|
|
|
|
* Streamline this process by not giving it more dirty blocks.
|
|
|
|
|
*/
|
|
|
|
|
if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM) {
|
|
|
|
|
LFS_CLR_UINO(VTOI(ap->a_vp), IN_ALLMOD);
|
2003-03-23 00:31:41 +03:00
|
|
|
VOP_UNLOCK(ap->a_vp, 0);
|
2003-03-21 09:16:53 +03:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2002-12-29 10:05:55 +03:00
|
|
|
return ufs_inactive(v);
|
2000-06-28 00:57:11 +04:00
|
|
|
}
|
|
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
/*
|
|
|
|
|
* These macros are used to bracket UFS directory ops, so that we can
|
|
|
|
|
* identify all the pages touched during directory ops which need to
|
|
|
|
|
* be ordered and flushed atomically, so that they may be recovered.
|
2005-03-23 03:12:51 +03:00
|
|
|
*
|
|
|
|
|
* Because we have to mark nodes VDIROP in order to prevent
|
1999-03-10 03:20:00 +03:00
|
|
|
* the cache from reclaiming them while a dirop is in progress, we must
|
|
|
|
|
* also manage the number of nodes so marked (otherwise we can run out).
|
|
|
|
|
* We do this by setting lfs_dirvcount to the number of marked vnodes; it
|
|
|
|
|
* is decremented during segment write, when VDIROP is taken off.
|
|
|
|
|
*/
|
2005-03-23 03:12:51 +03:00
|
|
|
#define MARK_VNODE(vp) lfs_mark_vnode(vp)
|
|
|
|
|
#define UNMARK_VNODE(vp) lfs_unmark_vnode(vp)
|
|
|
|
|
#define SET_DIROP_CREATE(dvp, vpp) lfs_set_dirop_create((dvp), (vpp))
|
|
|
|
|
#define SET_DIROP_REMOVE(dvp, vp) lfs_set_dirop((dvp), (vp))
|
|
|
|
|
static int lfs_set_dirop_create(struct vnode *, struct vnode **);
|
2002-12-28 17:39:08 +03:00
|
|
|
static int lfs_set_dirop(struct vnode *, struct vnode *);
|
1999-03-26 01:33:03 +03:00
|
|
|
|
2000-10-15 03:22:14 +04:00
|
|
|
static int
|
2005-03-23 03:12:51 +03:00
|
|
|
lfs_set_dirop(struct vnode *dvp, struct vnode *vp)
|
1999-03-26 01:33:03 +03:00
|
|
|
{
|
2000-06-28 00:57:11 +04:00
|
|
|
struct lfs *fs;
|
1999-03-26 01:33:03 +03:00
|
|
|
int error;
|
|
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
KASSERT(VOP_ISLOCKED(dvp));
|
|
|
|
|
KASSERT(vp == NULL || VOP_ISLOCKED(vp));
|
2002-12-28 17:39:08 +03:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
fs = VTOI(dvp)->i_lfs;
|
2005-04-02 01:59:46 +04:00
|
|
|
|
|
|
|
|
ASSERT_NO_SEGLOCK(fs);
|
Various bug-fixes to LFS, to wit:
Kernel:
* Add runtime quantity lfs_ravail, the number of disk-blocks reserved
for writing. Writes to the filesystem first reserve a maximum amount
of blocks before their write is allowed to proceed; after the blocks
are allocated the reserved total is reduced by a corresponding amount.
If the lfs_reserve function cannot immediately reserve the requested
number of blocks, the inode is unlocked, and the thread sleeps until
the cleaner has made enough space available for the blocks to be
reserved. In this way large files can be written to the filesystem
(or, smaller files can be written to a nearly-full but thoroughly
clean filesystem) and the cleaner can still function properly.
* Remove explicit switching on dlfs_minfreeseg from the kernel code; it
is now merely a fs-creation parameter used to compute dlfs_avail and
dlfs_bfree (and used by fsck_lfs(8) to check their accuracy). Its
former role is better assumed by a properly computed dlfs_avail.
* Bounds-check inode numbers submitted through lfs_bmapv and lfs_markv.
This prevents a panic, but, if the cleaner is feeding the filesystem
the wrong data, you are still in a world of hurt.
* Cleanup: remove explicit references of DEV_BSIZE in favor of
btodb()/dbtob().
lfs_cleanerd:
* Make -n mean "send N segments' blocks through a single call to
lfs_markv". Previously it had meant "clean N segments though N calls
to lfs_markv, before looking again to see if more need to be cleaned".
The new behavior gives better packing of direct data on disk with as
little metadata as possible, largely alleviating the problem that the
cleaner can consume more disk through inefficient use of metadata than
it frees by moving dirty data away from clean "holes" to produce
entirely clean segments.
* Make -b mean "read as many segments as necessary to write N segments
of dirty data back to disk", rather than its former meaning of "read
as many segments as necessary to free N segments worth of space". The
new meaning, combined with the new -n behavior described above,
further aids in cleaning storage efficiency as entire segments can be
written at once, using as few blocks as possible for segment summaries
and inode blocks.
* Make the cleaner take note of segments which could not be cleaned due
to error, and not attempt to clean them until they are entirely free
of dirty blocks. This prevents the case in which a cleanerd running
with -n 1 and without -b (formerly the default) would spin trying
repeatedly to clean a corrupt segment, while the remaining space
filled and deadlocked the filesystem.
* Update the lfs_cleanerd manual page to describe all the options,
including the changes mentioned here (in particular, the -b and -n
flags were previously undocumented).
fsck_lfs:
* Check, and optionally fix, lfs_avail (to an exact figure) and
lfs_bfree (within a margin of error) in pass 5.
newfs_lfs:
* Reduce the default dlfs_minfreeseg to 1/20 of the total segments.
* Add a warning if the sgs disklabel field is 16 (the default for FFS'
cpg, but not usually desirable for LFS' sgs: 5--8 is a better range).
* Change the calculation of lfs_avail and lfs_bfree, corresponding to
the kernel changes mentioned above.
mount_lfs:
* Add -N and -b options to pass corresponding -n and -b options to
lfs_cleanerd.
* Default to calling lfs_cleanerd with "-b -n 4".
[All of these changes were largely tested in the 1.5 branch, with the
idea that they (along with previous un-pulled-up work) could be applied
to the branch while it was still in ALPHA2; however my test system has
experienced corruption on another filesystem (/dev/console has gone
missing :^), and, while I believe this unrelated to the LFS changes, I
cannot with good conscience request that the changes be pulled up.]
2000-09-09 08:49:54 +04:00
|
|
|
/*
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
* LFS_NRESERVE calculates direct and indirect blocks as well
|
|
|
|
|
* as an inode block; an overestimate in most cases.
|
Various bug-fixes to LFS, to wit:
Kernel:
* Add runtime quantity lfs_ravail, the number of disk-blocks reserved
for writing. Writes to the filesystem first reserve a maximum amount
of blocks before their write is allowed to proceed; after the blocks
are allocated the reserved total is reduced by a corresponding amount.
If the lfs_reserve function cannot immediately reserve the requested
number of blocks, the inode is unlocked, and the thread sleeps until
the cleaner has made enough space available for the blocks to be
reserved. In this way large files can be written to the filesystem
(or, smaller files can be written to a nearly-full but thoroughly
clean filesystem) and the cleaner can still function properly.
* Remove explicit switching on dlfs_minfreeseg from the kernel code; it
is now merely a fs-creation parameter used to compute dlfs_avail and
dlfs_bfree (and used by fsck_lfs(8) to check their accuracy). Its
former role is better assumed by a properly computed dlfs_avail.
* Bounds-check inode numbers submitted through lfs_bmapv and lfs_markv.
This prevents a panic, but, if the cleaner is feeding the filesystem
the wrong data, you are still in a world of hurt.
* Cleanup: remove explicit references of DEV_BSIZE in favor of
btodb()/dbtob().
lfs_cleanerd:
* Make -n mean "send N segments' blocks through a single call to
lfs_markv". Previously it had meant "clean N segments though N calls
to lfs_markv, before looking again to see if more need to be cleaned".
The new behavior gives better packing of direct data on disk with as
little metadata as possible, largely alleviating the problem that the
cleaner can consume more disk through inefficient use of metadata than
it frees by moving dirty data away from clean "holes" to produce
entirely clean segments.
* Make -b mean "read as many segments as necessary to write N segments
of dirty data back to disk", rather than its former meaning of "read
as many segments as necessary to free N segments worth of space". The
new meaning, combined with the new -n behavior described above,
further aids in cleaning storage efficiency as entire segments can be
written at once, using as few blocks as possible for segment summaries
and inode blocks.
* Make the cleaner take note of segments which could not be cleaned due
to error, and not attempt to clean them until they are entirely free
of dirty blocks. This prevents the case in which a cleanerd running
with -n 1 and without -b (formerly the default) would spin trying
repeatedly to clean a corrupt segment, while the remaining space
filled and deadlocked the filesystem.
* Update the lfs_cleanerd manual page to describe all the options,
including the changes mentioned here (in particular, the -b and -n
flags were previously undocumented).
fsck_lfs:
* Check, and optionally fix, lfs_avail (to an exact figure) and
lfs_bfree (within a margin of error) in pass 5.
newfs_lfs:
* Reduce the default dlfs_minfreeseg to 1/20 of the total segments.
* Add a warning if the sgs disklabel field is 16 (the default for FFS'
cpg, but not usually desirable for LFS' sgs: 5--8 is a better range).
* Change the calculation of lfs_avail and lfs_bfree, corresponding to
the kernel changes mentioned above.
mount_lfs:
* Add -N and -b options to pass corresponding -n and -b options to
lfs_cleanerd.
* Default to calling lfs_cleanerd with "-b -n 4".
[All of these changes were largely tested in the 1.5 branch, with the
idea that they (along with previous un-pulled-up work) could be applied
to the branch while it was still in ALPHA2; however my test system has
experienced corruption on another filesystem (/dev/console has gone
missing :^), and, while I believe this unrelated to the LFS changes, I
cannot with good conscience request that the changes be pulled up.]
2000-09-09 08:49:54 +04:00
|
|
|
*/
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = lfs_reserve(fs, dvp, vp, LFS_NRESERVE(fs))) != 0)
|
Various bug-fixes to LFS, to wit:
Kernel:
* Add runtime quantity lfs_ravail, the number of disk-blocks reserved
for writing. Writes to the filesystem first reserve a maximum amount
of blocks before their write is allowed to proceed; after the blocks
are allocated the reserved total is reduced by a corresponding amount.
If the lfs_reserve function cannot immediately reserve the requested
number of blocks, the inode is unlocked, and the thread sleeps until
the cleaner has made enough space available for the blocks to be
reserved. In this way large files can be written to the filesystem
(or, smaller files can be written to a nearly-full but thoroughly
clean filesystem) and the cleaner can still function properly.
* Remove explicit switching on dlfs_minfreeseg from the kernel code; it
is now merely a fs-creation parameter used to compute dlfs_avail and
dlfs_bfree (and used by fsck_lfs(8) to check their accuracy). Its
former role is better assumed by a properly computed dlfs_avail.
* Bounds-check inode numbers submitted through lfs_bmapv and lfs_markv.
This prevents a panic, but, if the cleaner is feeding the filesystem
the wrong data, you are still in a world of hurt.
* Cleanup: remove explicit references of DEV_BSIZE in favor of
btodb()/dbtob().
lfs_cleanerd:
* Make -n mean "send N segments' blocks through a single call to
lfs_markv". Previously it had meant "clean N segments though N calls
to lfs_markv, before looking again to see if more need to be cleaned".
The new behavior gives better packing of direct data on disk with as
little metadata as possible, largely alleviating the problem that the
cleaner can consume more disk through inefficient use of metadata than
it frees by moving dirty data away from clean "holes" to produce
entirely clean segments.
* Make -b mean "read as many segments as necessary to write N segments
of dirty data back to disk", rather than its former meaning of "read
as many segments as necessary to free N segments worth of space". The
new meaning, combined with the new -n behavior described above,
further aids in cleaning storage efficiency as entire segments can be
written at once, using as few blocks as possible for segment summaries
and inode blocks.
* Make the cleaner take note of segments which could not be cleaned due
to error, and not attempt to clean them until they are entirely free
of dirty blocks. This prevents the case in which a cleanerd running
with -n 1 and without -b (formerly the default) would spin trying
repeatedly to clean a corrupt segment, while the remaining space
filled and deadlocked the filesystem.
* Update the lfs_cleanerd manual page to describe all the options,
including the changes mentioned here (in particular, the -b and -n
flags were previously undocumented).
fsck_lfs:
* Check, and optionally fix, lfs_avail (to an exact figure) and
lfs_bfree (within a margin of error) in pass 5.
newfs_lfs:
* Reduce the default dlfs_minfreeseg to 1/20 of the total segments.
* Add a warning if the sgs disklabel field is 16 (the default for FFS'
cpg, but not usually desirable for LFS' sgs: 5--8 is a better range).
* Change the calculation of lfs_avail and lfs_bfree, corresponding to
the kernel changes mentioned above.
mount_lfs:
* Add -N and -b options to pass corresponding -n and -b options to
lfs_cleanerd.
* Default to calling lfs_cleanerd with "-b -n 4".
[All of these changes were largely tested in the 1.5 branch, with the
idea that they (along with previous un-pulled-up work) could be applied
to the branch while it was still in ALPHA2; however my test system has
experienced corruption on another filesystem (/dev/console has gone
missing :^), and, while I believe this unrelated to the LFS changes, I
cannot with good conscience request that the changes be pulled up.]
2000-09-09 08:49:54 +04:00
|
|
|
return (error);
|
2002-12-26 16:37:18 +03:00
|
|
|
|
2005-04-02 01:59:46 +04:00
|
|
|
restart:
|
2003-07-12 20:19:00 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2005-04-02 01:59:46 +04:00
|
|
|
if (fs->lfs_dirops == 0) {
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
|
|
|
|
lfs_check(dvp, LFS_UNUSED_LBN, 0);
|
|
|
|
|
simple_lock(&fs->lfs_interlock);
|
2003-07-12 20:19:00 +04:00
|
|
|
}
|
2005-04-02 01:59:46 +04:00
|
|
|
while (fs->lfs_writer)
|
|
|
|
|
ltsleep(&fs->lfs_dirops, (PRIBIO + 1), "lfs_sdirop", 0,
|
|
|
|
|
&fs->lfs_interlock);
|
2003-07-12 20:19:00 +04:00
|
|
|
simple_lock(&lfs_subsys_lock);
|
|
|
|
|
if (lfs_dirvcount > LFS_MAX_DIROP && fs->lfs_dirops == 0) {
|
|
|
|
|
wakeup(&lfs_writer_daemon);
|
|
|
|
|
simple_unlock(&lfs_subsys_lock);
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-10-21 04:39:03 +04:00
|
|
|
preempt(1);
|
2003-07-12 20:19:00 +04:00
|
|
|
goto restart;
|
|
|
|
|
}
|
1999-12-04 00:47:44 +03:00
|
|
|
|
2003-07-12 20:19:00 +04:00
|
|
|
if (lfs_dirvcount > LFS_MAX_DIROP) {
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_DIROP, "lfs_set_dirop: sleeping with dirops=%d, "
|
|
|
|
|
"dirvcount=%d\n", fs->lfs_dirops, lfs_dirvcount));
|
2003-07-12 20:19:00 +04:00
|
|
|
if ((error = ltsleep(&lfs_dirvcount,
|
|
|
|
|
PCATCH | PUSER | PNORELOCK, "lfs_maxdirop", 0,
|
|
|
|
|
&lfs_subsys_lock)) != 0) {
|
|
|
|
|
goto unreserve;
|
|
|
|
|
}
|
|
|
|
|
goto restart;
|
2005-02-27 01:31:44 +03:00
|
|
|
}
|
2003-07-12 20:19:00 +04:00
|
|
|
simple_unlock(&lfs_subsys_lock);
|
|
|
|
|
|
2005-02-27 01:31:44 +03:00
|
|
|
++fs->lfs_dirops;
|
|
|
|
|
fs->lfs_doifile = 1;
|
2003-07-12 20:19:00 +04:00
|
|
|
simple_unlock(&fs->lfs_interlock);
|
1999-03-26 01:33:03 +03:00
|
|
|
|
2000-10-15 03:22:14 +04:00
|
|
|
/* Hold a reference so SET_ENDOP will be happy */
|
2005-03-23 03:12:51 +03:00
|
|
|
vref(dvp);
|
|
|
|
|
if (vp) {
|
|
|
|
|
vref(vp);
|
|
|
|
|
MARK_VNODE(vp);
|
|
|
|
|
}
|
2000-10-15 03:22:14 +04:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
MARK_VNODE(dvp);
|
1999-03-26 01:33:03 +03:00
|
|
|
return 0;
|
2002-12-26 16:37:18 +03:00
|
|
|
|
|
|
|
|
unreserve:
|
2005-03-23 03:12:51 +03:00
|
|
|
lfs_reserve(fs, dvp, vp, -LFS_NRESERVE(fs));
|
2002-12-26 16:37:18 +03:00
|
|
|
return error;
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
/*
|
|
|
|
|
* Get a new vnode *before* adjusting the dirop count, to avoid a deadlock
|
|
|
|
|
* in getnewvnode(), if we have a stacked filesystem mounted on top
|
|
|
|
|
* of us.
|
|
|
|
|
*
|
|
|
|
|
* NB: this means we have to clear the new vnodes on error. Fortunately
|
|
|
|
|
* SET_ENDOP is there to do that for us.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
lfs_set_dirop_create(struct vnode *dvp, struct vnode **vpp)
|
|
|
|
|
{
|
|
|
|
|
int error;
|
|
|
|
|
struct lfs *fs;
|
|
|
|
|
|
|
|
|
|
fs = VFSTOUFS(dvp->v_mount)->um_lfs;
|
2005-04-02 01:59:46 +04:00
|
|
|
ASSERT_NO_SEGLOCK(fs);
|
2005-03-23 03:12:51 +03:00
|
|
|
if (fs->lfs_ronly)
|
|
|
|
|
return EROFS;
|
|
|
|
|
if (vpp && (error = getnewvnode(VT_LFS, dvp->v_mount, lfs_vnodeop_p, vpp))) {
|
|
|
|
|
DLOG((DLOG_ALLOC, "lfs_set_dirop_create: dvp %p error %d\n",
|
|
|
|
|
dvp, error));
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
if ((error = lfs_set_dirop(dvp, NULL)) != 0) {
|
|
|
|
|
if (vpp) {
|
|
|
|
|
ungetnewvnode(*vpp);
|
|
|
|
|
*vpp = NULL;
|
|
|
|
|
}
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
#define SET_ENDOP_BASE(fs, dvp, str) \
|
|
|
|
|
do { \
|
|
|
|
|
simple_lock(&(fs)->lfs_interlock); \
|
|
|
|
|
--(fs)->lfs_dirops; \
|
|
|
|
|
if (!(fs)->lfs_dirops) { \
|
|
|
|
|
if ((fs)->lfs_nadirop) { \
|
|
|
|
|
panic("SET_ENDOP: %s: no dirops but " \
|
|
|
|
|
" nadirop=%d", (str), \
|
|
|
|
|
(fs)->lfs_nadirop); \
|
|
|
|
|
} \
|
|
|
|
|
wakeup(&(fs)->lfs_writer); \
|
|
|
|
|
simple_unlock(&(fs)->lfs_interlock); \
|
|
|
|
|
lfs_check((dvp), LFS_UNUSED_LBN, 0); \
|
|
|
|
|
} else \
|
|
|
|
|
simple_unlock(&(fs)->lfs_interlock); \
|
|
|
|
|
} while(0)
|
|
|
|
|
#define SET_ENDOP_CREATE(fs, dvp, nvpp, str) \
|
|
|
|
|
do { \
|
|
|
|
|
UNMARK_VNODE(dvp); \
|
|
|
|
|
if (nvpp && *nvpp) \
|
|
|
|
|
UNMARK_VNODE(*nvpp); \
|
|
|
|
|
/* Check for error return to stem vnode leakage */ \
|
|
|
|
|
if (nvpp && *nvpp && !((*nvpp)->v_flag & VDIROP)) \
|
|
|
|
|
ungetnewvnode(*(nvpp)); \
|
|
|
|
|
SET_ENDOP_BASE((fs), (dvp), (str)); \
|
|
|
|
|
lfs_reserve((fs), (dvp), NULL, -LFS_NRESERVE(fs)); \
|
|
|
|
|
vrele(dvp); \
|
|
|
|
|
} while(0)
|
|
|
|
|
#define SET_ENDOP_CREATE_AP(ap, str) \
|
|
|
|
|
SET_ENDOP_CREATE(VTOI((ap)->a_dvp)->i_lfs, (ap)->a_dvp, \
|
|
|
|
|
(ap)->a_vpp, (str))
|
|
|
|
|
#define SET_ENDOP_REMOVE(fs, dvp, ovp, str) \
|
|
|
|
|
do { \
|
|
|
|
|
UNMARK_VNODE(dvp); \
|
|
|
|
|
if (ovp) \
|
|
|
|
|
UNMARK_VNODE(ovp); \
|
|
|
|
|
SET_ENDOP_BASE((fs), (dvp), (str)); \
|
|
|
|
|
lfs_reserve((fs), (dvp), (ovp), -LFS_NRESERVE(fs)); \
|
|
|
|
|
vrele(dvp); \
|
|
|
|
|
if (ovp) \
|
|
|
|
|
vrele(ovp); \
|
|
|
|
|
} while(0)
|
2000-06-28 00:57:11 +04:00
|
|
|
|
2003-09-23 09:26:49 +04:00
|
|
|
void
|
|
|
|
|
lfs_mark_vnode(struct vnode *vp)
|
2000-06-28 00:57:11 +04:00
|
|
|
{
|
2003-09-23 09:26:49 +04:00
|
|
|
struct inode *ip = VTOI(vp);
|
|
|
|
|
struct lfs *fs = ip->i_lfs;
|
|
|
|
|
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2003-09-23 09:26:49 +04:00
|
|
|
if (!(ip->i_flag & IN_ADIROP)) {
|
|
|
|
|
if (!(vp->v_flag & VDIROP)) {
|
|
|
|
|
(void)lfs_vref(vp);
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&lfs_subsys_lock);
|
2003-09-23 09:26:49 +04:00
|
|
|
++lfs_dirvcount;
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_unlock(&lfs_subsys_lock);
|
2003-09-23 09:26:49 +04:00
|
|
|
TAILQ_INSERT_TAIL(&fs->lfs_dchainhd, ip, i_lfs_dchain);
|
|
|
|
|
vp->v_flag |= VDIROP;
|
|
|
|
|
}
|
|
|
|
|
++fs->lfs_nadirop;
|
|
|
|
|
ip->i_flag |= IN_ADIROP;
|
|
|
|
|
} else
|
|
|
|
|
KASSERT(vp->v_flag & VDIROP);
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-09-23 09:26:49 +04:00
|
|
|
}
|
2000-06-28 00:57:11 +04:00
|
|
|
|
2003-09-23 09:26:49 +04:00
|
|
|
void
|
|
|
|
|
lfs_unmark_vnode(struct vnode *vp)
|
|
|
|
|
{
|
|
|
|
|
struct inode *ip = VTOI(vp);
|
2000-06-28 00:57:11 +04:00
|
|
|
|
2005-04-18 21:36:46 +04:00
|
|
|
if (ip && (ip->i_flag & IN_ADIROP)) {
|
2003-09-23 09:26:49 +04:00
|
|
|
KASSERT(vp->v_flag & VDIROP);
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&ip->i_lfs->lfs_interlock);
|
2000-06-28 00:57:11 +04:00
|
|
|
--ip->i_lfs->lfs_nadirop;
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_unlock(&ip->i_lfs->lfs_interlock);
|
2003-09-23 09:26:49 +04:00
|
|
|
ip->i_flag &= ~IN_ADIROP;
|
|
|
|
|
}
|
2000-06-28 00:57:11 +04:00
|
|
|
}
|
1998-03-01 05:20:01 +03:00
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_symlink(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vop_symlink_args /* {
|
|
|
|
|
struct vnode *a_dvp;
|
|
|
|
|
struct vnode **a_vpp;
|
|
|
|
|
struct componentname *a_cnp;
|
|
|
|
|
struct vattr *a_vap;
|
|
|
|
|
char *a_target;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
2000-05-27 04:19:52 +04:00
|
|
|
int error;
|
1994-06-08 15:41:58 +04:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
|
1999-12-15 10:19:07 +03:00
|
|
|
vput(ap->a_dvp);
|
2000-05-27 04:19:52 +04:00
|
|
|
return error;
|
1999-12-15 10:19:07 +03:00
|
|
|
}
|
2000-05-27 04:19:52 +04:00
|
|
|
error = ufs_symlink(ap);
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_CREATE_AP(ap, "symlink");
|
2000-05-27 04:19:52 +04:00
|
|
|
return (error);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_mknod(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1999-03-10 03:20:00 +03:00
|
|
|
struct vop_mknod_args /* {
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vnode *a_dvp;
|
|
|
|
|
struct vnode **a_vpp;
|
|
|
|
|
struct componentname *a_cnp;
|
|
|
|
|
struct vattr *a_vap;
|
1999-03-10 03:20:00 +03:00
|
|
|
} */ *ap = v;
|
2003-02-20 07:27:23 +03:00
|
|
|
struct vattr *vap = ap->a_vap;
|
|
|
|
|
struct vnode **vpp = ap->a_vpp;
|
|
|
|
|
struct inode *ip;
|
|
|
|
|
int error;
|
2005-02-27 01:31:44 +03:00
|
|
|
struct mount *mp;
|
2001-07-24 19:39:30 +04:00
|
|
|
ino_t ino;
|
1994-06-08 15:41:58 +04:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
|
1999-12-15 10:19:07 +03:00
|
|
|
vput(ap->a_dvp);
|
1999-09-04 02:48:51 +04:00
|
|
|
return error;
|
1999-12-15 10:19:07 +03:00
|
|
|
}
|
1999-09-04 02:48:51 +04:00
|
|
|
error = ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
|
2003-06-30 02:28:00 +04:00
|
|
|
ap->a_dvp, vpp, ap->a_cnp);
|
1999-09-04 02:48:51 +04:00
|
|
|
|
|
|
|
|
/* Either way we're done with the dirop at this point */
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_CREATE_AP(ap, "mknod");
|
1999-09-04 02:48:51 +04:00
|
|
|
|
2003-02-20 07:27:23 +03:00
|
|
|
if (error)
|
1999-09-04 02:48:51 +04:00
|
|
|
return (error);
|
|
|
|
|
|
2003-02-20 07:27:23 +03:00
|
|
|
ip = VTOI(*vpp);
|
2001-07-24 19:39:30 +04:00
|
|
|
mp = (*vpp)->v_mount;
|
|
|
|
|
ino = ip->i_number;
|
2003-02-20 07:27:23 +03:00
|
|
|
ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
|
|
|
|
|
if (vap->va_rdev != VNOVAL) {
|
|
|
|
|
/*
|
|
|
|
|
* Want to be able to use this to make badblock
|
|
|
|
|
* inodes, so don't truncate the dev number.
|
|
|
|
|
*/
|
1999-09-04 02:48:51 +04:00
|
|
|
#if 0
|
2003-04-02 14:39:19 +04:00
|
|
|
ip->i_ffs1_rdev = ufs_rw32(vap->va_rdev,
|
2003-02-20 07:27:23 +03:00
|
|
|
UFS_MPNEEDSWAP((*vpp)->v_mount));
|
1999-09-04 02:48:51 +04:00
|
|
|
#else
|
2003-04-02 14:39:19 +04:00
|
|
|
ip->i_ffs1_rdev = vap->va_rdev;
|
1999-09-04 02:48:51 +04:00
|
|
|
#endif
|
2003-02-20 07:27:23 +03:00
|
|
|
}
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
|
1999-09-04 02:48:51 +04:00
|
|
|
/*
|
|
|
|
|
* Call fsync to write the vnode so that we don't have to deal with
|
|
|
|
|
* flushing it when it's marked VDIROP|VXLOCK.
|
|
|
|
|
*
|
|
|
|
|
* XXX KS - If we can't flush we also can't call vgone(), so must
|
|
|
|
|
* return. But, that leaves this vnode in limbo, also not good.
|
|
|
|
|
* Can this ever happen (barring hardware failure)?
|
|
|
|
|
*/
|
2005-02-27 01:31:44 +03:00
|
|
|
if ((error = VOP_FSYNC(*vpp, NOCRED, FSYNC_WAIT, 0, 0,
|
2005-12-11 15:16:03 +03:00
|
|
|
curlwp)) != 0) {
|
2005-08-19 06:04:03 +04:00
|
|
|
panic("lfs_mknod: couldn't fsync (ino %llu)",
|
|
|
|
|
(unsigned long long)ino);
|
2005-03-08 03:18:19 +03:00
|
|
|
/* return (error); */
|
2000-06-28 00:57:11 +04:00
|
|
|
}
|
2003-02-20 07:27:23 +03:00
|
|
|
/*
|
|
|
|
|
* Remove vnode so that it will be reloaded by VFS_VGET and
|
|
|
|
|
* checked to see if it is an alias of an existing entry in
|
|
|
|
|
* the inode cache.
|
|
|
|
|
*/
|
1999-09-04 02:48:51 +04:00
|
|
|
/* Used to be vput, but that causes us to call VOP_INACTIVE twice. */
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
|
2000-06-28 00:57:11 +04:00
|
|
|
VOP_UNLOCK(*vpp, 0);
|
1999-09-04 02:48:51 +04:00
|
|
|
lfs_vunref(*vpp);
|
2003-02-20 07:27:23 +03:00
|
|
|
(*vpp)->v_type = VNON;
|
|
|
|
|
vgone(*vpp);
|
2003-06-29 22:43:21 +04:00
|
|
|
error = VFS_VGET(mp, ino, vpp);
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
|
2001-07-24 19:39:30 +04:00
|
|
|
if (error != 0) {
|
|
|
|
|
*vpp = NULL;
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
2003-02-20 07:27:23 +03:00
|
|
|
return (0);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_create(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1999-03-10 03:20:00 +03:00
|
|
|
struct vop_create_args /* {
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vnode *a_dvp;
|
|
|
|
|
struct vnode **a_vpp;
|
|
|
|
|
struct componentname *a_cnp;
|
|
|
|
|
struct vattr *a_vap;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
2000-05-27 04:19:52 +04:00
|
|
|
int error;
|
1994-06-08 15:41:58 +04:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
|
1999-12-15 10:19:07 +03:00
|
|
|
vput(ap->a_dvp);
|
2000-05-27 04:19:52 +04:00
|
|
|
return error;
|
1999-12-15 10:19:07 +03:00
|
|
|
}
|
2000-05-27 04:19:52 +04:00
|
|
|
error = ufs_create(ap);
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_CREATE_AP(ap, "create");
|
2000-05-27 04:19:52 +04:00
|
|
|
return (error);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_mkdir(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1999-03-10 03:20:00 +03:00
|
|
|
struct vop_mkdir_args /* {
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vnode *a_dvp;
|
|
|
|
|
struct vnode **a_vpp;
|
|
|
|
|
struct componentname *a_cnp;
|
|
|
|
|
struct vattr *a_vap;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
2000-05-27 04:19:52 +04:00
|
|
|
int error;
|
1994-06-08 15:41:58 +04:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_CREATE(ap->a_dvp, ap->a_vpp)) != 0) {
|
1999-12-15 10:19:07 +03:00
|
|
|
vput(ap->a_dvp);
|
2000-05-27 04:19:52 +04:00
|
|
|
return error;
|
1999-12-15 10:19:07 +03:00
|
|
|
}
|
2000-05-27 04:19:52 +04:00
|
|
|
error = ufs_mkdir(ap);
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_CREATE_AP(ap, "mkdir");
|
2000-05-27 04:19:52 +04:00
|
|
|
return (error);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_remove(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1999-03-10 03:20:00 +03:00
|
|
|
struct vop_remove_args /* {
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vnode *a_dvp;
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
struct componentname *a_cnp;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
1999-12-15 10:19:07 +03:00
|
|
|
struct vnode *dvp, *vp;
|
2000-05-27 04:19:52 +04:00
|
|
|
int error;
|
1999-12-15 10:19:07 +03:00
|
|
|
|
|
|
|
|
dvp = ap->a_dvp;
|
|
|
|
|
vp = ap->a_vp;
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_REMOVE(dvp, vp)) != 0) {
|
1999-12-15 10:19:07 +03:00
|
|
|
if (dvp == vp)
|
|
|
|
|
vrele(vp);
|
|
|
|
|
else
|
|
|
|
|
vput(vp);
|
|
|
|
|
vput(dvp);
|
2000-05-27 04:19:52 +04:00
|
|
|
return error;
|
1999-12-15 10:19:07 +03:00
|
|
|
}
|
2000-05-27 04:19:52 +04:00
|
|
|
error = ufs_remove(ap);
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_REMOVE(VTOI(dvp)->i_lfs, dvp, vp, "remove");
|
2000-05-27 04:19:52 +04:00
|
|
|
return (error);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_rmdir(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1999-03-10 03:20:00 +03:00
|
|
|
struct vop_rmdir_args /* {
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vnodeop_desc *a_desc;
|
|
|
|
|
struct vnode *a_dvp;
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
struct componentname *a_cnp;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
struct vnode *vp;
|
2000-05-27 04:19:52 +04:00
|
|
|
int error;
|
1994-06-08 15:41:58 +04:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
vp = ap->a_vp;
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_REMOVE(ap->a_dvp, ap->a_vp)) != 0) {
|
1999-12-15 10:19:07 +03:00
|
|
|
vrele(ap->a_dvp);
|
2002-11-24 11:23:41 +03:00
|
|
|
if (ap->a_vp != ap->a_dvp)
|
1999-12-15 10:19:07 +03:00
|
|
|
VOP_UNLOCK(ap->a_dvp, 0);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
vput(vp);
|
2000-05-27 04:19:52 +04:00
|
|
|
return error;
|
1999-12-15 10:19:07 +03:00
|
|
|
}
|
2000-05-27 04:19:52 +04:00
|
|
|
error = ufs_rmdir(ap);
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_REMOVE(VTOI(ap->a_dvp)->i_lfs, ap->a_dvp, vp, "rmdir");
|
2000-05-27 04:19:52 +04:00
|
|
|
return (error);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_link(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1999-03-10 03:20:00 +03:00
|
|
|
struct vop_link_args /* {
|
1996-02-09 17:45:36 +03:00
|
|
|
struct vnode *a_dvp;
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vnode *a_vp;
|
|
|
|
|
struct componentname *a_cnp;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
2000-05-27 04:19:52 +04:00
|
|
|
int error;
|
2005-03-23 03:12:51 +03:00
|
|
|
struct vnode **vpp = NULL;
|
1994-06-08 15:41:58 +04:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_CREATE(ap->a_dvp, vpp)) != 0) {
|
1999-12-15 10:19:07 +03:00
|
|
|
vput(ap->a_dvp);
|
2000-05-27 04:19:52 +04:00
|
|
|
return error;
|
1999-12-15 10:19:07 +03:00
|
|
|
}
|
2000-05-27 04:19:52 +04:00
|
|
|
error = ufs_link(ap);
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_CREATE(VTOI(ap->a_dvp)->i_lfs, ap->a_dvp, vpp, "link");
|
2000-05-27 04:19:52 +04:00
|
|
|
return (error);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
1999-03-10 03:20:00 +03:00
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_rename(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1999-03-10 03:20:00 +03:00
|
|
|
struct vop_rename_args /* {
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vnode *a_fdvp;
|
|
|
|
|
struct vnode *a_fvp;
|
|
|
|
|
struct componentname *a_fcnp;
|
|
|
|
|
struct vnode *a_tdvp;
|
|
|
|
|
struct vnode *a_tvp;
|
|
|
|
|
struct componentname *a_tcnp;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
1999-11-05 23:14:56 +03:00
|
|
|
struct vnode *tvp, *fvp, *tdvp, *fdvp;
|
2003-02-03 03:32:35 +03:00
|
|
|
struct componentname *tcnp, *fcnp;
|
1999-11-05 23:14:56 +03:00
|
|
|
int error;
|
1999-11-01 21:29:33 +03:00
|
|
|
struct lfs *fs;
|
|
|
|
|
|
|
|
|
|
fs = VTOI(ap->a_fdvp)->i_lfs;
|
1999-11-05 23:14:56 +03:00
|
|
|
tvp = ap->a_tvp;
|
|
|
|
|
tdvp = ap->a_tdvp;
|
2003-02-03 03:32:35 +03:00
|
|
|
tcnp = ap->a_tcnp;
|
1999-11-05 23:14:56 +03:00
|
|
|
fvp = ap->a_fvp;
|
|
|
|
|
fdvp = ap->a_fdvp;
|
2003-02-03 03:32:35 +03:00
|
|
|
fcnp = ap->a_fcnp;
|
1999-11-05 23:14:56 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check for cross-device rename.
|
|
|
|
|
* If it is, we don't want to set dirops, just error out.
|
|
|
|
|
* (In particular note that MARK_VNODE(tdvp) will DTWT on
|
|
|
|
|
* a cross-device rename.)
|
|
|
|
|
*
|
|
|
|
|
* Copied from ufs_rename.
|
|
|
|
|
*/
|
|
|
|
|
if ((fvp->v_mount != tdvp->v_mount) ||
|
|
|
|
|
(tvp && (fvp->v_mount != tvp->v_mount))) {
|
|
|
|
|
error = EXDEV;
|
1999-12-15 10:19:07 +03:00
|
|
|
goto errout;
|
1999-11-05 23:14:56 +03:00
|
|
|
}
|
2003-02-03 03:32:35 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check to make sure we're not renaming a vnode onto itself
|
|
|
|
|
* (deleting a hard link by renaming one name onto another);
|
|
|
|
|
* if we are we can't recursively call VOP_REMOVE since that
|
|
|
|
|
* would leave us with an unaccounted-for number of live dirops.
|
|
|
|
|
*
|
|
|
|
|
* Inline the relevant section of ufs_rename here, *before*
|
2005-03-23 03:12:51 +03:00
|
|
|
* calling SET_DIROP_REMOVE.
|
2003-02-03 03:32:35 +03:00
|
|
|
*/
|
2003-04-02 14:39:19 +04:00
|
|
|
if (tvp && ((VTOI(tvp)->i_flags & (IMMUTABLE | APPEND)) ||
|
|
|
|
|
(VTOI(tdvp)->i_flags & APPEND))) {
|
2003-02-03 03:32:35 +03:00
|
|
|
error = EPERM;
|
|
|
|
|
goto errout;
|
|
|
|
|
}
|
2003-02-20 07:27:23 +03:00
|
|
|
if (fvp == tvp) {
|
|
|
|
|
if (fvp->v_type == VDIR) {
|
|
|
|
|
error = EINVAL;
|
|
|
|
|
goto errout;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Release destination completely. */
|
|
|
|
|
VOP_ABORTOP(tdvp, tcnp);
|
|
|
|
|
vput(tdvp);
|
|
|
|
|
vput(tvp);
|
|
|
|
|
|
|
|
|
|
/* Delete source. */
|
|
|
|
|
vrele(fvp);
|
|
|
|
|
fcnp->cn_flags &= ~(MODMASK | SAVESTART);
|
|
|
|
|
fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
|
|
|
|
|
fcnp->cn_nameiop = DELETE;
|
|
|
|
|
if ((error = relookup(fdvp, &fvp, fcnp))){
|
|
|
|
|
/* relookup blew away fdvp */
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
return (VOP_REMOVE(fdvp, fvp, fcnp));
|
|
|
|
|
}
|
2003-02-03 03:32:35 +03:00
|
|
|
|
2005-03-23 03:12:51 +03:00
|
|
|
if ((error = SET_DIROP_REMOVE(tdvp, tvp)) != 0)
|
1999-12-15 10:19:07 +03:00
|
|
|
goto errout;
|
1999-11-05 23:14:56 +03:00
|
|
|
MARK_VNODE(fdvp);
|
2002-12-28 17:39:08 +03:00
|
|
|
MARK_VNODE(fvp);
|
2005-02-27 01:31:44 +03:00
|
|
|
|
1999-11-05 23:14:56 +03:00
|
|
|
error = ufs_rename(ap);
|
2000-05-27 04:19:52 +04:00
|
|
|
UNMARK_VNODE(fdvp);
|
2002-12-28 17:39:08 +03:00
|
|
|
UNMARK_VNODE(fvp);
|
2005-03-23 03:12:51 +03:00
|
|
|
SET_ENDOP_REMOVE(fs, tdvp, tvp, "rename");
|
1999-11-05 23:14:56 +03:00
|
|
|
return (error);
|
1999-12-15 10:19:07 +03:00
|
|
|
|
|
|
|
|
errout:
|
|
|
|
|
VOP_ABORTOP(tdvp, ap->a_tcnp); /* XXX, why not in NFS? */
|
|
|
|
|
if (tdvp == tvp)
|
|
|
|
|
vrele(tdvp);
|
|
|
|
|
else
|
|
|
|
|
vput(tdvp);
|
|
|
|
|
if (tvp)
|
|
|
|
|
vput(tvp);
|
|
|
|
|
VOP_ABORTOP(fdvp, ap->a_fcnp); /* XXX, why not in NFS? */
|
|
|
|
|
vrele(fdvp);
|
|
|
|
|
vrele(fvp);
|
|
|
|
|
return (error);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
1999-03-10 03:20:00 +03:00
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
/* XXX hack to avoid calling ITIMES in getattr */
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_getattr(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vop_getattr_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
struct vattr *a_vap;
|
|
|
|
|
struct ucred *a_cred;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
2000-03-30 16:41:09 +04:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
|
struct inode *ip = VTOI(vp);
|
|
|
|
|
struct vattr *vap = ap->a_vap;
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
struct lfs *fs = ip->i_lfs;
|
1994-06-08 15:41:58 +04:00
|
|
|
/*
|
|
|
|
|
* Copy from inode table
|
|
|
|
|
*/
|
|
|
|
|
vap->va_fsid = ip->i_dev;
|
|
|
|
|
vap->va_fileid = ip->i_number;
|
2003-04-02 14:39:19 +04:00
|
|
|
vap->va_mode = ip->i_mode & ~IFMT;
|
|
|
|
|
vap->va_nlink = ip->i_nlink;
|
|
|
|
|
vap->va_uid = ip->i_uid;
|
|
|
|
|
vap->va_gid = ip->i_gid;
|
|
|
|
|
vap->va_rdev = (dev_t)ip->i_ffs1_rdev;
|
a whole bunch of changes to improve performance and robustness under load:
- remove special treatment of pager_map mappings in pmaps. this is
required now, since I've removed the globals that expose the address range.
pager_map now uses pmap_kenter_pa() instead of pmap_enter(), so there's
no longer any need to special-case it.
- eliminate struct uvm_vnode by moving its fields into struct vnode.
- rewrite the pageout path. the pager is now responsible for handling the
high-level requests instead of only getting control after a bunch of work
has already been done on its behalf. this will allow us to UBCify LFS,
which needs tighter control over its pages than other filesystems do.
writing a page to disk no longer requires making it read-only, which
allows us to write wired pages without causing all kinds of havoc.
- use a new PG_PAGEOUT flag to indicate that a page should be freed
on behalf of the pagedaemon when it's unlocked. this flag is very similar
to PG_RELEASED, but unlike PG_RELEASED, PG_PAGEOUT can be cleared if the
pageout fails due to eg. an indirect-block buffer being locked.
this allows us to remove the "version" field from struct vm_page,
and together with shrinking "loan_count" from 32 bits to 16,
struct vm_page is now 4 bytes smaller.
- no longer use PG_RELEASED for swap-backed pages. if the page is busy
because it's being paged out, we can't release the swap slot to be
reallocated until that write is complete, but unlike with vnodes we
don't keep a count of in-progress writes so there's no good way to
know when the write is done. instead, when we need to free a busy
swap-backed page, just sleep until we can get it busy ourselves.
- implement a fast-path for extending writes which allows us to avoid
zeroing new pages. this substantially reduces cpu usage.
- encapsulate the data used by the genfs code in a struct genfs_node,
which must be the first element of the filesystem-specific vnode data
for filesystems which use genfs_{get,put}pages().
- eliminate many of the UVM pagerops, since they aren't needed anymore
now that the pager "put" operation is a higher-level operation.
- enhance the genfs code to allow NFS to use the genfs_{get,put}pages
instead of a modified copy.
- clean up struct vnode by removing all the fields that used to be used by
the vfs_cluster.c code (which we don't use anymore with UBC).
- remove kmem_object and mb_object since they were useless.
instead of allocating pages to these objects, we now just allocate
pages with no object. such pages are mapped in the kernel until they
are freed, so we can use the mapping to find the page to free it.
this allows us to remove splvm() protection in several places.
The sum of all these changes improves write throughput on my
decstation 5000/200 to within 1% of the rate of NetBSD 1.5
and reduces the elapsed time for "make release" of a NetBSD 1.5
source tree on my 128MB pc to 10% less than a 1.5 kernel took.
2001-09-16 00:36:31 +04:00
|
|
|
vap->va_size = vp->v_size;
|
2003-04-02 14:39:19 +04:00
|
|
|
vap->va_atime.tv_sec = ip->i_ffs1_atime;
|
|
|
|
|
vap->va_atime.tv_nsec = ip->i_ffs1_atimensec;
|
|
|
|
|
vap->va_mtime.tv_sec = ip->i_ffs1_mtime;
|
|
|
|
|
vap->va_mtime.tv_nsec = ip->i_ffs1_mtimensec;
|
|
|
|
|
vap->va_ctime.tv_sec = ip->i_ffs1_ctime;
|
|
|
|
|
vap->va_ctime.tv_nsec = ip->i_ffs1_ctimensec;
|
|
|
|
|
vap->va_flags = ip->i_flags;
|
|
|
|
|
vap->va_gen = ip->i_gen;
|
1994-06-08 15:41:58 +04:00
|
|
|
/* this doesn't belong here */
|
|
|
|
|
if (vp->v_type == VBLK)
|
|
|
|
|
vap->va_blocksize = BLKDEV_IOSIZE;
|
|
|
|
|
else if (vp->v_type == VCHR)
|
|
|
|
|
vap->va_blocksize = MAXBSIZE;
|
|
|
|
|
else
|
|
|
|
|
vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
vap->va_bytes = fsbtob(fs, (u_quad_t)ip->i_lfs_effnblks);
|
1994-06-08 15:41:58 +04:00
|
|
|
vap->va_type = vp->v_type;
|
|
|
|
|
vap->va_filerev = ip->i_modrev;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
1999-03-10 03:20:00 +03:00
|
|
|
|
2002-02-11 05:47:29 +03:00
|
|
|
/*
|
|
|
|
|
* Check to make sure the inode blocks won't choke the buffer
|
|
|
|
|
* cache, then call ufs_setattr as usual.
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
lfs_setattr(void *v)
|
|
|
|
|
{
|
2005-04-25 10:28:51 +04:00
|
|
|
struct vop_setattr_args /* {
|
2002-02-11 05:47:29 +03:00
|
|
|
struct vnode *a_vp;
|
|
|
|
|
struct vattr *a_vap;
|
|
|
|
|
struct ucred *a_cred;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
2002-02-11 05:47:29 +03:00
|
|
|
} */ *ap = v;
|
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
|
|
|
|
|
|
lfs_check(vp, LFS_UNUSED_LBN, 0);
|
|
|
|
|
return ufs_setattr(v);
|
|
|
|
|
}
|
|
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
/*
|
|
|
|
|
* Close called
|
|
|
|
|
*
|
|
|
|
|
* XXX -- we were using ufs_close, but since it updates the
|
|
|
|
|
* times on the inode, we might need to bump the uinodes
|
|
|
|
|
* count.
|
|
|
|
|
*/
|
|
|
|
|
/* ARGSUSED */
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_close(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vop_close_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
int a_fflag;
|
|
|
|
|
struct ucred *a_cred;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
2000-03-30 16:41:09 +04:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
|
struct inode *ip = VTOI(vp);
|
1994-06-08 15:41:58 +04:00
|
|
|
|
2003-03-21 09:16:53 +03:00
|
|
|
if (vp == ip->i_lfs->lfs_ivnode &&
|
2003-10-14 18:02:56 +04:00
|
|
|
vp->v_mount->mnt_iflag & IMNT_UNMOUNT)
|
2003-03-21 09:16:53 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (vp->v_usecount > 1 && vp != ip->i_lfs->lfs_ivnode) {
|
2005-09-12 20:24:41 +04:00
|
|
|
LFS_ITIMES(ip, NULL, NULL, NULL);
|
1994-06-08 15:41:58 +04:00
|
|
|
}
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
For synchronous writes, keep separate i/o counters for each write, so
processes don't have to wait for one another to finish (e.g., nfsd seems
to be a little happier now, though I haven't measured the difference).
Synchronous checkpoints, however, must always wait for all i/o to finish.
Take the contents of the callback functions and have them run in thread
context instead (aiodoned thread). lfs_iocount no longer has to be
protected in splbio(), and quite a bit less of the segment construction
loop needs to be in splbio() as well.
If lfs_markv is handed a block that is not the correct size according to
the inode, refuse to process it. (Formerly it was extended to the "correct"
size.) This is possibly more prone to deadlock, but less prone to corruption.
lfs_segclean now outright refuses to clean segments that appear to have live
bytes in them. Again this may be more prone to deadlock but avoids
corruption.
Replace ufsspec_close and ufsfifo_close with LFS equivalents; this means
that no UFS functions need to know about LFS_ITIMES any more. Remove
the reference from ufs/inode.h.
Tested on i386, test-compiled on alpha.
2002-06-16 04:13:15 +04:00
|
|
|
/*
|
|
|
|
|
* Close wrapper for special devices.
|
|
|
|
|
*
|
|
|
|
|
* Update the times on the inode then do device close.
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
lfsspec_close(void *v)
|
|
|
|
|
{
|
|
|
|
|
struct vop_close_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
int a_fflag;
|
|
|
|
|
struct ucred *a_cred;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
For synchronous writes, keep separate i/o counters for each write, so
processes don't have to wait for one another to finish (e.g., nfsd seems
to be a little happier now, though I haven't measured the difference).
Synchronous checkpoints, however, must always wait for all i/o to finish.
Take the contents of the callback functions and have them run in thread
context instead (aiodoned thread). lfs_iocount no longer has to be
protected in splbio(), and quite a bit less of the segment construction
loop needs to be in splbio() as well.
If lfs_markv is handed a block that is not the correct size according to
the inode, refuse to process it. (Formerly it was extended to the "correct"
size.) This is possibly more prone to deadlock, but less prone to corruption.
lfs_segclean now outright refuses to clean segments that appear to have live
bytes in them. Again this may be more prone to deadlock but avoids
corruption.
Replace ufsspec_close and ufsfifo_close with LFS equivalents; this means
that no UFS functions need to know about LFS_ITIMES any more. Remove
the reference from ufs/inode.h.
Tested on i386, test-compiled on alpha.
2002-06-16 04:13:15 +04:00
|
|
|
} */ *ap = v;
|
|
|
|
|
struct vnode *vp;
|
|
|
|
|
struct inode *ip;
|
|
|
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
|
ip = VTOI(vp);
|
|
|
|
|
if (vp->v_usecount > 1) {
|
2005-09-12 20:24:41 +04:00
|
|
|
LFS_ITIMES(ip, NULL, NULL, NULL);
|
For synchronous writes, keep separate i/o counters for each write, so
processes don't have to wait for one another to finish (e.g., nfsd seems
to be a little happier now, though I haven't measured the difference).
Synchronous checkpoints, however, must always wait for all i/o to finish.
Take the contents of the callback functions and have them run in thread
context instead (aiodoned thread). lfs_iocount no longer has to be
protected in splbio(), and quite a bit less of the segment construction
loop needs to be in splbio() as well.
If lfs_markv is handed a block that is not the correct size according to
the inode, refuse to process it. (Formerly it was extended to the "correct"
size.) This is possibly more prone to deadlock, but less prone to corruption.
lfs_segclean now outright refuses to clean segments that appear to have live
bytes in them. Again this may be more prone to deadlock but avoids
corruption.
Replace ufsspec_close and ufsfifo_close with LFS equivalents; this means
that no UFS functions need to know about LFS_ITIMES any more. Remove
the reference from ufs/inode.h.
Tested on i386, test-compiled on alpha.
2002-06-16 04:13:15 +04:00
|
|
|
}
|
|
|
|
|
return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Close wrapper for fifo's.
|
|
|
|
|
*
|
|
|
|
|
* Update the times on the inode then do device close.
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
lfsfifo_close(void *v)
|
|
|
|
|
{
|
|
|
|
|
struct vop_close_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
int a_fflag;
|
|
|
|
|
struct ucred *a_cred;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
For synchronous writes, keep separate i/o counters for each write, so
processes don't have to wait for one another to finish (e.g., nfsd seems
to be a little happier now, though I haven't measured the difference).
Synchronous checkpoints, however, must always wait for all i/o to finish.
Take the contents of the callback functions and have them run in thread
context instead (aiodoned thread). lfs_iocount no longer has to be
protected in splbio(), and quite a bit less of the segment construction
loop needs to be in splbio() as well.
If lfs_markv is handed a block that is not the correct size according to
the inode, refuse to process it. (Formerly it was extended to the "correct"
size.) This is possibly more prone to deadlock, but less prone to corruption.
lfs_segclean now outright refuses to clean segments that appear to have live
bytes in them. Again this may be more prone to deadlock but avoids
corruption.
Replace ufsspec_close and ufsfifo_close with LFS equivalents; this means
that no UFS functions need to know about LFS_ITIMES any more. Remove
the reference from ufs/inode.h.
Tested on i386, test-compiled on alpha.
2002-06-16 04:13:15 +04:00
|
|
|
} */ *ap = v;
|
|
|
|
|
struct vnode *vp;
|
|
|
|
|
struct inode *ip;
|
|
|
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
|
ip = VTOI(vp);
|
|
|
|
|
if (ap->a_vp->v_usecount > 1) {
|
2005-09-12 20:24:41 +04:00
|
|
|
LFS_ITIMES(ip, NULL, NULL, NULL);
|
For synchronous writes, keep separate i/o counters for each write, so
processes don't have to wait for one another to finish (e.g., nfsd seems
to be a little happier now, though I haven't measured the difference).
Synchronous checkpoints, however, must always wait for all i/o to finish.
Take the contents of the callback functions and have them run in thread
context instead (aiodoned thread). lfs_iocount no longer has to be
protected in splbio(), and quite a bit less of the segment construction
loop needs to be in splbio() as well.
If lfs_markv is handed a block that is not the correct size according to
the inode, refuse to process it. (Formerly it was extended to the "correct"
size.) This is possibly more prone to deadlock, but less prone to corruption.
lfs_segclean now outright refuses to clean segments that appear to have live
bytes in them. Again this may be more prone to deadlock but avoids
corruption.
Replace ufsspec_close and ufsfifo_close with LFS equivalents; this means
that no UFS functions need to know about LFS_ITIMES any more. Remove
the reference from ufs/inode.h.
Tested on i386, test-compiled on alpha.
2002-06-16 04:13:15 +04:00
|
|
|
}
|
|
|
|
|
return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap));
|
|
|
|
|
}
|
|
|
|
|
|
1994-06-08 15:41:58 +04:00
|
|
|
/*
|
1998-03-01 05:20:01 +03:00
|
|
|
* Reclaim an inode so that it can be used for other purposes.
|
1994-06-08 15:41:58 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int
|
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
2001-07-14 00:30:18 +04:00
|
|
|
lfs_reclaim(void *v)
|
1996-02-10 01:28:45 +03:00
|
|
|
{
|
1994-06-08 15:41:58 +04:00
|
|
|
struct vop_reclaim_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
1996-02-10 01:28:45 +03:00
|
|
|
} */ *ap = v;
|
1998-03-01 05:20:01 +03:00
|
|
|
struct vnode *vp = ap->a_vp;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
struct inode *ip = VTOI(vp);
|
1994-06-08 15:41:58 +04:00
|
|
|
int error;
|
|
|
|
|
|
2003-04-02 14:39:19 +04:00
|
|
|
KASSERT(ip->i_nlink == ip->i_ffs_effnlink);
|
2003-01-08 18:40:54 +03:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
LFS_CLR_UINO(ip, IN_ALLMOD);
|
2005-12-11 15:16:03 +03:00
|
|
|
if ((error = ufs_reclaim(vp, ap->a_l)))
|
1994-06-08 15:41:58 +04:00
|
|
|
return (error);
|
2005-04-14 04:44:16 +04:00
|
|
|
pool_put(&lfs_dinode_pool, ip->i_din.ffs1_din);
|
2005-04-16 21:35:58 +04:00
|
|
|
lfs_deregister_all(vp);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
pool_put(&lfs_inoext_pool, ip->inode_ext.lfs);
|
|
|
|
|
ip->inode_ext.lfs = NULL;
|
1998-09-01 07:26:05 +04:00
|
|
|
pool_put(&lfs_inode_pool, vp->v_data);
|
1994-06-08 15:41:58 +04:00
|
|
|
vp->v_data = NULL;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
2001-12-18 10:51:16 +03:00
|
|
|
|
2003-03-08 05:55:47 +03:00
|
|
|
/*
|
2003-04-01 18:31:50 +04:00
|
|
|
* Read a block from a storage device.
|
2003-03-08 05:55:47 +03:00
|
|
|
* In order to avoid reading blocks that are in the process of being
|
|
|
|
|
* written by the cleaner---and hence are not mutexed by the normal
|
|
|
|
|
* buffer cache / page cache mechanisms---check for collisions before
|
|
|
|
|
* reading.
|
|
|
|
|
*
|
|
|
|
|
* We inline ufs_strategy to make sure that the VOP_BMAP occurs *before*
|
|
|
|
|
* the active cleaner test.
|
|
|
|
|
*
|
|
|
|
|
* XXX This code assumes that lfs_markv makes synchronous checkpoints.
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
lfs_strategy(void *v)
|
|
|
|
|
{
|
|
|
|
|
struct vop_strategy_args /* {
|
2004-01-26 13:39:29 +03:00
|
|
|
struct vnode *a_vp;
|
2003-03-08 05:55:47 +03:00
|
|
|
struct buf *a_bp;
|
|
|
|
|
} */ *ap = v;
|
|
|
|
|
struct buf *bp;
|
|
|
|
|
struct lfs *fs;
|
|
|
|
|
struct vnode *vp;
|
|
|
|
|
struct inode *ip;
|
|
|
|
|
daddr_t tbn;
|
|
|
|
|
int i, sn, error, slept;
|
|
|
|
|
|
|
|
|
|
bp = ap->a_bp;
|
2004-01-26 13:39:29 +03:00
|
|
|
vp = ap->a_vp;
|
2003-03-08 05:55:47 +03:00
|
|
|
ip = VTOI(vp);
|
|
|
|
|
fs = ip->i_lfs;
|
|
|
|
|
|
2003-04-01 18:31:50 +04:00
|
|
|
/* lfs uses its strategy routine only for read */
|
|
|
|
|
KASSERT(bp->b_flags & B_READ);
|
|
|
|
|
|
2003-03-08 05:55:47 +03:00
|
|
|
if (vp->v_type == VBLK || vp->v_type == VCHR)
|
|
|
|
|
panic("lfs_strategy: spec");
|
|
|
|
|
KASSERT(bp->b_bcount != 0);
|
|
|
|
|
if (bp->b_blkno == bp->b_lblkno) {
|
|
|
|
|
error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno,
|
|
|
|
|
NULL);
|
|
|
|
|
if (error) {
|
|
|
|
|
bp->b_error = error;
|
|
|
|
|
bp->b_flags |= B_ERROR;
|
|
|
|
|
biodone(bp);
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
if ((long)bp->b_blkno == -1) /* no valid data */
|
|
|
|
|
clrbuf(bp);
|
|
|
|
|
}
|
|
|
|
|
if ((long)bp->b_blkno < 0) { /* block is not on disk */
|
|
|
|
|
biodone(bp);
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
slept = 1;
|
2003-03-15 09:58:49 +03:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2003-04-01 18:31:50 +04:00
|
|
|
while (slept && fs->lfs_seglock) {
|
2003-03-15 09:58:49 +03:00
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-03-08 05:55:47 +03:00
|
|
|
/*
|
|
|
|
|
* Look through list of intervals.
|
|
|
|
|
* There will only be intervals to look through
|
|
|
|
|
* if the cleaner holds the seglock.
|
|
|
|
|
* Since the cleaner is synchronous, we can trust
|
|
|
|
|
* the list of intervals to be current.
|
|
|
|
|
*/
|
|
|
|
|
tbn = dbtofsb(fs, bp->b_blkno);
|
|
|
|
|
sn = dtosn(fs, tbn);
|
|
|
|
|
slept = 0;
|
|
|
|
|
for (i = 0; i < fs->lfs_cleanind; i++) {
|
|
|
|
|
if (sn == dtosn(fs, fs->lfs_cleanint[i]) &&
|
|
|
|
|
tbn >= fs->lfs_cleanint[i]) {
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_CLEAN,
|
|
|
|
|
"lfs_strategy: ino %d lbn %" PRId64
|
2003-03-08 05:55:47 +03:00
|
|
|
" ind %d sn %d fsb %" PRIx32
|
|
|
|
|
" given sn %d fsb %" PRIx64 "\n",
|
|
|
|
|
ip->i_number, bp->b_lblkno, i,
|
|
|
|
|
dtosn(fs, fs->lfs_cleanint[i]),
|
2005-03-08 03:18:19 +03:00
|
|
|
fs->lfs_cleanint[i], sn, tbn));
|
|
|
|
|
DLOG((DLOG_CLEAN,
|
|
|
|
|
"lfs_strategy: sleeping on ino %d lbn %"
|
|
|
|
|
PRId64 "\n", ip->i_number, bp->b_lblkno));
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
if (fs->lfs_seglock)
|
|
|
|
|
ltsleep(&fs->lfs_seglock,
|
|
|
|
|
(PRIBIO + 1) | PNORELOCK,
|
|
|
|
|
"lfs_strategy", 0,
|
|
|
|
|
&fs->lfs_interlock);
|
2003-03-08 05:55:47 +03:00
|
|
|
/* Things may be different now; start over. */
|
|
|
|
|
slept = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-03-15 09:58:49 +03:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2003-03-08 05:55:47 +03:00
|
|
|
}
|
2003-03-15 09:58:49 +03:00
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-03-08 05:55:47 +03:00
|
|
|
|
|
|
|
|
vp = ip->i_devvp;
|
2004-01-25 21:06:48 +03:00
|
|
|
VOP_STRATEGY(vp, bp);
|
2003-03-08 05:55:47 +03:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2003-03-02 07:34:30 +03:00
|
|
|
static void
|
|
|
|
|
lfs_flush_dirops(struct lfs *fs)
|
|
|
|
|
{
|
|
|
|
|
struct inode *ip, *nip;
|
|
|
|
|
struct vnode *vp;
|
|
|
|
|
extern int lfs_dostats;
|
|
|
|
|
struct segment *sp;
|
|
|
|
|
int needunlock;
|
|
|
|
|
|
2006-04-08 03:59:28 +04:00
|
|
|
ASSERT_MAYBE_SEGLOCK(fs);
|
2005-04-02 01:59:46 +04:00
|
|
|
|
2003-03-02 07:34:30 +03:00
|
|
|
if (fs->lfs_ronly)
|
|
|
|
|
return;
|
|
|
|
|
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
if (TAILQ_FIRST(&fs->lfs_dchainhd) == NULL) {
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-03-02 07:34:30 +03:00
|
|
|
return;
|
2005-04-02 01:59:46 +04:00
|
|
|
} else
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-03-02 07:34:30 +03:00
|
|
|
|
|
|
|
|
if (lfs_dostats)
|
|
|
|
|
++lfs_stats.flush_invoked;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Inline lfs_segwrite/lfs_writevnodes, but just for dirops.
|
|
|
|
|
* Technically this is a checkpoint (the on-disk state is valid)
|
|
|
|
|
* even though we are leaving out all the file data.
|
|
|
|
|
*/
|
|
|
|
|
lfs_imtime(fs);
|
|
|
|
|
lfs_seglock(fs, SEGM_CKP);
|
|
|
|
|
sp = fs->lfs_sp;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lfs_writevnodes, optimized to get dirops out of the way.
|
|
|
|
|
* Only write dirops, and don't flush files' pages, only
|
|
|
|
|
* blocks from the directories.
|
|
|
|
|
*
|
|
|
|
|
* We don't need to vref these files because they are
|
|
|
|
|
* dirops and so hold an extra reference until the
|
|
|
|
|
* segunlock clears them of that status.
|
|
|
|
|
*
|
|
|
|
|
* We don't need to check for IN_ADIROP because we know that
|
|
|
|
|
* no dirops are active.
|
|
|
|
|
*
|
|
|
|
|
*/
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2003-03-02 07:34:30 +03:00
|
|
|
for (ip = TAILQ_FIRST(&fs->lfs_dchainhd); ip != NULL; ip = nip) {
|
|
|
|
|
nip = TAILQ_NEXT(ip, i_lfs_dchain);
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-03-02 07:34:30 +03:00
|
|
|
vp = ITOV(ip);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* All writes to directories come from dirops; all
|
|
|
|
|
* writes to files' direct blocks go through the page
|
|
|
|
|
* cache, which we're not touching. Reads to files
|
|
|
|
|
* and/or directories will not be affected by writing
|
|
|
|
|
* directory blocks inodes and file inodes. So we don't
|
|
|
|
|
* really need to lock. If we don't lock, though,
|
|
|
|
|
* make sure that we don't clear IN_MODIFIED
|
|
|
|
|
* unnecessarily.
|
|
|
|
|
*/
|
|
|
|
|
if (vp->v_flag & VXLOCK)
|
|
|
|
|
continue;
|
2005-03-24 07:00:33 +03:00
|
|
|
if (vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT) == 0) {
|
2003-03-02 07:34:30 +03:00
|
|
|
needunlock = 1;
|
|
|
|
|
} else {
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_VNODE, "lfs_flush_dirops: flushing locked ino %d\n",
|
|
|
|
|
VTOI(vp)->i_number));
|
2003-03-02 07:34:30 +03:00
|
|
|
needunlock = 0;
|
|
|
|
|
}
|
|
|
|
|
if (vp->v_type != VREG &&
|
|
|
|
|
((ip->i_flag & IN_ALLMOD) || !VPISEMPTY(vp))) {
|
|
|
|
|
lfs_writefile(fs, sp, vp);
|
|
|
|
|
if (!VPISEMPTY(vp) && !WRITEINPROG(vp) &&
|
|
|
|
|
!(ip->i_flag & IN_ALLMOD)) {
|
|
|
|
|
LFS_SET_UINO(ip, IN_MODIFIED);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
(void) lfs_writeinode(fs, sp, ip);
|
|
|
|
|
if (needunlock)
|
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
|
else
|
|
|
|
|
LFS_SET_UINO(ip, IN_MODIFIED);
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2003-03-02 07:34:30 +03:00
|
|
|
}
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-03-02 07:34:30 +03:00
|
|
|
/* We've written all the dirops there are */
|
|
|
|
|
((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT);
|
|
|
|
|
(void) lfs_writeseg(fs, sp);
|
|
|
|
|
lfs_segunlock(fs);
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-08 04:26:34 +04:00
|
|
|
/*
|
|
|
|
|
* Flush all vnodes for which the pagedaemon has requested pageouts.
|
|
|
|
|
* Skip over any files that are marked VDIROP (since lfs_flush_dirop()
|
|
|
|
|
* has just run, this would be an error). If we have to skip a vnode
|
|
|
|
|
* for any reason, just skip it; if we have to wait for the cleaner,
|
|
|
|
|
* abort. The writer daemon will call us again later.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
lfs_flush_pchain(struct lfs *fs)
|
|
|
|
|
{
|
|
|
|
|
struct inode *ip, *nip;
|
|
|
|
|
struct vnode *vp;
|
|
|
|
|
extern int lfs_dostats;
|
|
|
|
|
struct segment *sp;
|
|
|
|
|
int error;
|
|
|
|
|
|
|
|
|
|
ASSERT_NO_SEGLOCK(fs);
|
|
|
|
|
|
|
|
|
|
if (fs->lfs_ronly)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
if (TAILQ_FIRST(&fs->lfs_pchainhd) == NULL) {
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
|
|
|
|
return;
|
|
|
|
|
} else
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
|
|
|
|
|
|
|
|
|
/* Get dirops out of the way */
|
|
|
|
|
lfs_flush_dirops(fs);
|
|
|
|
|
|
|
|
|
|
if (lfs_dostats)
|
|
|
|
|
++lfs_stats.flush_invoked;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Inline lfs_segwrite/lfs_writevnodes, but just for pageouts.
|
|
|
|
|
*/
|
|
|
|
|
lfs_imtime(fs);
|
|
|
|
|
lfs_seglock(fs, 0);
|
|
|
|
|
sp = fs->lfs_sp;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lfs_writevnodes, optimized to clear pageout requests.
|
|
|
|
|
* Only write non-dirop files that are in the pageout queue.
|
|
|
|
|
* We're very conservative about what we write; we want to be
|
|
|
|
|
* fast and async.
|
|
|
|
|
*/
|
|
|
|
|
top:
|
2006-04-11 01:17:21 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2006-04-08 04:26:34 +04:00
|
|
|
for (ip = TAILQ_FIRST(&fs->lfs_pchainhd); ip != NULL; ip = nip) {
|
|
|
|
|
nip = TAILQ_NEXT(ip, i_lfs_pchain);
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
|
|
|
|
vp = ITOV(ip);
|
|
|
|
|
|
|
|
|
|
if (!(ip->i_flags & IN_PAGING))
|
|
|
|
|
goto top;
|
|
|
|
|
|
|
|
|
|
if (vp->v_flag & (VXLOCK|VDIROP))
|
|
|
|
|
continue;
|
|
|
|
|
if (vp->v_type != VREG)
|
|
|
|
|
continue;
|
|
|
|
|
if (lfs_vref(vp))
|
|
|
|
|
continue;
|
2006-04-11 01:17:21 +04:00
|
|
|
if (vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT) != 0) {
|
|
|
|
|
lfs_vunref(vp);
|
2006-04-08 04:26:34 +04:00
|
|
|
continue;
|
2006-04-11 01:17:21 +04:00
|
|
|
}
|
2006-04-08 04:26:34 +04:00
|
|
|
|
|
|
|
|
error = lfs_writefile(fs, sp, vp);
|
|
|
|
|
if (!VPISEMPTY(vp) && !WRITEINPROG(vp) &&
|
|
|
|
|
!(ip->i_flag & IN_ALLMOD)) {
|
|
|
|
|
LFS_SET_UINO(ip, IN_MODIFIED);
|
|
|
|
|
}
|
|
|
|
|
(void) lfs_writeinode(fs, sp, ip);
|
|
|
|
|
|
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
|
lfs_vunref(vp);
|
|
|
|
|
|
|
|
|
|
if (error == EAGAIN) {
|
|
|
|
|
lfs_writeseg(fs, sp);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
}
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
|
|
|
|
(void) lfs_writeseg(fs, sp);
|
|
|
|
|
lfs_segunlock(fs);
|
|
|
|
|
}
|
|
|
|
|
|
2003-02-24 11:42:49 +03:00
|
|
|
/*
|
2003-02-26 02:12:06 +03:00
|
|
|
* Provide a fcntl interface to sys_lfs_{segwait,bmapv,markv}.
|
2003-02-24 11:42:49 +03:00
|
|
|
*/
|
|
|
|
|
int
|
2003-02-26 02:12:06 +03:00
|
|
|
lfs_fcntl(void *v)
|
2003-02-24 11:42:49 +03:00
|
|
|
{
|
2005-03-08 07:49:35 +03:00
|
|
|
struct vop_fcntl_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
u_long a_command;
|
|
|
|
|
caddr_t a_data;
|
|
|
|
|
int a_fflag;
|
|
|
|
|
struct ucred *a_cred;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
2005-03-08 07:49:35 +03:00
|
|
|
} */ *ap = v;
|
2003-02-24 11:42:49 +03:00
|
|
|
struct timeval *tvp;
|
|
|
|
|
BLOCK_INFO *blkiov;
|
2003-03-02 07:34:30 +03:00
|
|
|
CLEANERINFO *cip;
|
2005-04-23 23:47:51 +04:00
|
|
|
SEGUSE *sup;
|
2003-03-02 07:34:30 +03:00
|
|
|
int blkcnt, error, oclean;
|
2003-02-26 02:12:06 +03:00
|
|
|
struct lfs_fcntl_markv blkvp;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct proc *p;
|
2003-02-24 11:42:49 +03:00
|
|
|
fsid_t *fsidp;
|
2003-03-02 07:34:30 +03:00
|
|
|
struct lfs *fs;
|
|
|
|
|
struct buf *bp;
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
fhandle_t *fhp;
|
2003-03-02 07:34:30 +03:00
|
|
|
daddr_t off;
|
2003-02-24 11:42:49 +03:00
|
|
|
|
2003-02-26 02:12:06 +03:00
|
|
|
/* Only respect LFS fcntls on fs root or Ifile */
|
2003-02-24 11:42:49 +03:00
|
|
|
if (VTOI(ap->a_vp)->i_number != ROOTINO &&
|
|
|
|
|
VTOI(ap->a_vp)->i_number != LFS_IFILE_INUM) {
|
2003-02-26 02:12:06 +03:00
|
|
|
return ufs_fcntl(v);
|
2003-02-24 11:42:49 +03:00
|
|
|
}
|
|
|
|
|
|
2003-03-28 11:03:38 +03:00
|
|
|
/* Avoid locking a draining lock */
|
2003-10-14 18:02:56 +04:00
|
|
|
if (ap->a_vp->v_mount->mnt_iflag & IMNT_UNMOUNT) {
|
2003-03-28 11:03:38 +03:00
|
|
|
return ESHUTDOWN;
|
|
|
|
|
}
|
|
|
|
|
|
2005-12-11 15:16:03 +03:00
|
|
|
p = ap->a_l->l_proc;
|
2003-03-28 11:03:38 +03:00
|
|
|
fs = VTOI(ap->a_vp)->i_lfs;
|
2004-04-21 05:05:31 +04:00
|
|
|
fsidp = &ap->a_vp->v_mount->mnt_stat.f_fsidx;
|
2003-02-24 11:42:49 +03:00
|
|
|
|
2003-03-21 09:26:36 +03:00
|
|
|
switch (ap->a_command) {
|
2003-02-26 02:12:06 +03:00
|
|
|
case LFCNSEGWAITALL:
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
case LFCNSEGWAITALL_COMPAT:
|
2003-02-24 11:42:49 +03:00
|
|
|
fsidp = NULL;
|
|
|
|
|
/* FALLSTHROUGH */
|
2003-02-26 02:12:06 +03:00
|
|
|
case LFCNSEGWAIT:
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
case LFCNSEGWAIT_COMPAT:
|
2003-02-24 11:42:49 +03:00
|
|
|
tvp = (struct timeval *)ap->a_data;
|
2003-03-28 11:03:38 +03:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
++fs->lfs_sleepers;
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-02-26 02:12:06 +03:00
|
|
|
VOP_UNLOCK(ap->a_vp, 0);
|
2003-03-28 11:03:38 +03:00
|
|
|
|
2003-02-26 02:12:06 +03:00
|
|
|
error = lfs_segwait(fsidp, tvp);
|
2003-03-28 11:03:38 +03:00
|
|
|
|
2003-02-26 02:12:06 +03:00
|
|
|
VOP_LOCK(ap->a_vp, LK_EXCLUSIVE);
|
2003-03-28 11:03:38 +03:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
if (--fs->lfs_sleepers == 0)
|
|
|
|
|
wakeup(&fs->lfs_sleepers);
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-02-26 02:12:06 +03:00
|
|
|
return error;
|
2003-02-24 11:42:49 +03:00
|
|
|
|
2003-02-26 02:12:06 +03:00
|
|
|
case LFCNBMAPV:
|
|
|
|
|
case LFCNMARKV:
|
2005-12-11 15:16:03 +03:00
|
|
|
if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
|
2003-02-24 11:42:49 +03:00
|
|
|
return (error);
|
2003-02-26 02:12:06 +03:00
|
|
|
blkvp = *(struct lfs_fcntl_markv *)ap->a_data;
|
2003-02-24 11:42:49 +03:00
|
|
|
|
|
|
|
|
blkcnt = blkvp.blkcnt;
|
|
|
|
|
if ((u_int) blkcnt > LFS_MARKV_MAXBLKCNT)
|
|
|
|
|
return (EINVAL);
|
2005-04-16 21:28:37 +04:00
|
|
|
blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);
|
2003-02-24 11:42:49 +03:00
|
|
|
if ((error = copyin(blkvp.blkiov, blkiov,
|
|
|
|
|
blkcnt * sizeof(BLOCK_INFO))) != 0) {
|
2005-04-16 21:28:37 +04:00
|
|
|
lfs_free(fs, blkiov, LFS_NB_BLKIOV);
|
2003-02-24 11:42:49 +03:00
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
2003-03-28 11:03:38 +03:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
++fs->lfs_sleepers;
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-02-26 02:12:06 +03:00
|
|
|
VOP_UNLOCK(ap->a_vp, 0);
|
|
|
|
|
if (ap->a_command == LFCNBMAPV)
|
2005-12-11 15:16:03 +03:00
|
|
|
error = lfs_bmapv(p, fsidp, blkiov, blkcnt);
|
2003-02-26 02:12:06 +03:00
|
|
|
else /* LFCNMARKV */
|
2005-12-11 15:16:03 +03:00
|
|
|
error = lfs_markv(p, fsidp, blkiov, blkcnt);
|
2003-02-24 11:42:49 +03:00
|
|
|
if (error == 0)
|
|
|
|
|
error = copyout(blkiov, blkvp.blkiov,
|
|
|
|
|
blkcnt * sizeof(BLOCK_INFO));
|
2003-02-26 02:12:06 +03:00
|
|
|
VOP_LOCK(ap->a_vp, LK_EXCLUSIVE);
|
2003-03-28 11:03:38 +03:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
if (--fs->lfs_sleepers == 0)
|
|
|
|
|
wakeup(&fs->lfs_sleepers);
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2005-04-16 21:28:37 +04:00
|
|
|
lfs_free(fs, blkiov, LFS_NB_BLKIOV);
|
2003-02-24 11:42:49 +03:00
|
|
|
return error;
|
|
|
|
|
|
2003-03-02 07:34:30 +03:00
|
|
|
case LFCNRECLAIM:
|
|
|
|
|
/*
|
|
|
|
|
* Flush dirops and write Ifile, allowing empty segments
|
|
|
|
|
* to be immediately reclaimed.
|
|
|
|
|
*/
|
2005-03-24 07:00:33 +03:00
|
|
|
VOP_UNLOCK(ap->a_vp, 0);
|
2003-07-02 17:40:51 +04:00
|
|
|
lfs_writer_enter(fs, "pndirop");
|
2003-03-02 07:34:30 +03:00
|
|
|
off = fs->lfs_offset;
|
|
|
|
|
lfs_seglock(fs, SEGM_FORCE_CKP | SEGM_CKP);
|
|
|
|
|
lfs_flush_dirops(fs);
|
|
|
|
|
LFS_CLEANERINFO(cip, fs, bp);
|
|
|
|
|
oclean = cip->clean;
|
|
|
|
|
LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
|
|
|
|
|
lfs_segwrite(ap->a_vp->v_mount, SEGM_FORCE_CKP);
|
2006-03-24 23:05:32 +03:00
|
|
|
fs->lfs_sp->seg_flags |= SEGM_PROT;
|
2003-03-02 07:34:30 +03:00
|
|
|
lfs_segunlock(fs);
|
2003-07-02 17:40:51 +04:00
|
|
|
lfs_writer_leave(fs);
|
2003-03-02 07:34:30 +03:00
|
|
|
|
2005-03-08 03:18:19 +03:00
|
|
|
#ifdef DEBUG
|
2003-03-02 07:34:30 +03:00
|
|
|
LFS_CLEANERINFO(cip, fs, bp);
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_CLEAN, "lfs_fcntl: reclaim wrote %" PRId64
|
|
|
|
|
" blocks, cleaned %" PRId32 " segments (activesb %d)\n",
|
|
|
|
|
fs->lfs_offset - off, cip->clean - oclean,
|
|
|
|
|
fs->lfs_activesb));
|
2003-03-02 07:34:30 +03:00
|
|
|
LFS_SYNC_CLEANERINFO(cip, fs, bp, 0);
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-03-24 07:00:33 +03:00
|
|
|
VOP_LOCK(ap->a_vp, LK_EXCLUSIVE);
|
2003-03-02 07:34:30 +03:00
|
|
|
return 0;
|
|
|
|
|
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
case LFCNIFILEFH:
|
|
|
|
|
/* Return the filehandle of the Ifile */
|
2005-12-11 15:16:03 +03:00
|
|
|
if ((error = suser(ap->a_l->l_proc->p_ucred, &ap->a_l->l_proc->p_acflag)) != 0)
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
return (error);
|
|
|
|
|
fhp = (struct fhandle *)ap->a_data;
|
|
|
|
|
fhp->fh_fsid = *fsidp;
|
|
|
|
|
return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid));
|
|
|
|
|
|
2005-04-23 23:47:51 +04:00
|
|
|
case LFCNREWIND:
|
|
|
|
|
/* Move lfs_offset to the lowest-numbered segment */
|
|
|
|
|
return lfs_rewind(fs, *(int *)ap->a_data);
|
|
|
|
|
|
|
|
|
|
case LFCNINVAL:
|
|
|
|
|
/* Mark a segment SEGUSE_INVAL */
|
|
|
|
|
LFS_SEGENTRY(sup, fs, *(int *)ap->a_data, bp);
|
|
|
|
|
if (sup->su_nbytes > 0) {
|
|
|
|
|
brelse(bp);
|
|
|
|
|
lfs_unset_inval_all(fs);
|
|
|
|
|
return EBUSY;
|
|
|
|
|
}
|
|
|
|
|
sup->su_flags |= SEGUSE_INVAL;
|
|
|
|
|
VOP_BWRITE(bp);
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
case LFCNRESIZE:
|
|
|
|
|
/* Resize the filesystem */
|
|
|
|
|
return lfs_resize_fs(fs, *(int *)ap->a_data);
|
|
|
|
|
|
2003-02-24 11:42:49 +03:00
|
|
|
default:
|
2003-02-26 02:12:06 +03:00
|
|
|
return ufs_fcntl(v);
|
2003-02-24 11:42:49 +03:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2001-12-18 10:51:16 +03:00
|
|
|
int
|
|
|
|
|
lfs_getpages(void *v)
|
|
|
|
|
{
|
|
|
|
|
struct vop_getpages_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
voff_t a_offset;
|
|
|
|
|
struct vm_page **a_m;
|
|
|
|
|
int *a_count;
|
|
|
|
|
int a_centeridx;
|
|
|
|
|
vm_prot_t a_access_type;
|
|
|
|
|
int a_advice;
|
|
|
|
|
int a_flags;
|
|
|
|
|
} */ *ap = v;
|
|
|
|
|
|
2003-03-21 09:16:53 +03:00
|
|
|
if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM &&
|
|
|
|
|
(ap->a_access_type & VM_PROT_WRITE) != 0) {
|
|
|
|
|
return EPERM;
|
|
|
|
|
}
|
2001-12-18 10:51:16 +03:00
|
|
|
if ((ap->a_access_type & VM_PROT_WRITE) != 0) {
|
|
|
|
|
LFS_SET_UINO(VTOI(ap->a_vp), IN_MODIFIED);
|
|
|
|
|
}
|
2003-09-20 21:51:55 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* we're relying on the fact that genfs_getpages() always read in
|
|
|
|
|
* entire filesystem blocks.
|
|
|
|
|
*/
|
2003-03-09 00:46:04 +03:00
|
|
|
return genfs_getpages(v);
|
2001-12-18 10:51:16 +03:00
|
|
|
}
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Make sure that for all pages in every block in the given range,
|
|
|
|
|
* either all are dirty or all are clean. If any of the pages
|
|
|
|
|
* we've seen so far are dirty, put the vnode on the paging chain,
|
|
|
|
|
* and mark it IN_PAGING.
|
2003-05-02 05:47:39 +04:00
|
|
|
*
|
|
|
|
|
* If checkfirst != 0, don't check all the pages but return at the
|
|
|
|
|
* first dirty page.
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
check_dirty(struct lfs *fs, struct vnode *vp,
|
|
|
|
|
off_t startoffset, off_t endoffset, off_t blkeof,
|
2003-04-23 11:20:37 +04:00
|
|
|
int flags, int checkfirst)
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
{
|
2003-02-20 07:27:23 +03:00
|
|
|
int by_list;
|
2003-10-25 22:26:46 +04:00
|
|
|
struct vm_page *curpg = NULL; /* XXX: gcc */
|
|
|
|
|
struct vm_page *pgs[MAXBSIZE / PAGE_SIZE], *pg;
|
|
|
|
|
off_t soff = 0; /* XXX: gcc */
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
voff_t off;
|
2003-09-20 21:51:55 +04:00
|
|
|
int i;
|
|
|
|
|
int nonexistent;
|
|
|
|
|
int any_dirty; /* number of dirty pages */
|
|
|
|
|
int dirty; /* number of dirty pages in a block */
|
|
|
|
|
int tdirty;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
int pages_per_block = fs->lfs_bsize >> PAGE_SHIFT;
|
2006-03-28 05:29:55 +04:00
|
|
|
int pagedaemon = (curproc == uvm.pagedaemon_proc);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
2005-04-02 01:59:46 +04:00
|
|
|
ASSERT_MAYBE_SEGLOCK(fs);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
top:
|
|
|
|
|
by_list = (vp->v_uobj.uo_npages <=
|
|
|
|
|
((endoffset - startoffset) >> PAGE_SHIFT) *
|
|
|
|
|
UVM_PAGE_HASH_PENALTY);
|
|
|
|
|
any_dirty = 0;
|
|
|
|
|
|
|
|
|
|
if (by_list) {
|
|
|
|
|
curpg = TAILQ_FIRST(&vp->v_uobj.memq);
|
|
|
|
|
} else {
|
|
|
|
|
soff = startoffset;
|
|
|
|
|
}
|
|
|
|
|
while (by_list || soff < MIN(blkeof, endoffset)) {
|
|
|
|
|
if (by_list) {
|
2003-09-20 21:51:55 +04:00
|
|
|
/*
|
2005-03-23 03:12:51 +03:00
|
|
|
* Find the first page in a block. Skip
|
|
|
|
|
* blocks outside our area of interest or beyond
|
|
|
|
|
* the end of file.
|
2003-09-20 21:51:55 +04:00
|
|
|
*/
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
if (pages_per_block > 1) {
|
2005-03-23 03:12:51 +03:00
|
|
|
while (curpg &&
|
|
|
|
|
((curpg->offset & fs->lfs_bmask) ||
|
2005-04-14 04:58:26 +04:00
|
|
|
curpg->offset >= vp->v_size ||
|
|
|
|
|
curpg->offset >= endoffset))
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
curpg = TAILQ_NEXT(curpg, listq);
|
|
|
|
|
}
|
|
|
|
|
if (curpg == NULL)
|
|
|
|
|
break;
|
|
|
|
|
soff = curpg->offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Mark all pages in extended range busy; find out if any
|
|
|
|
|
* of them are dirty.
|
|
|
|
|
*/
|
|
|
|
|
nonexistent = dirty = 0;
|
|
|
|
|
for (i = 0; i == 0 || i < pages_per_block; i++) {
|
|
|
|
|
if (by_list && pages_per_block <= 1) {
|
|
|
|
|
pgs[i] = pg = curpg;
|
|
|
|
|
} else {
|
|
|
|
|
off = soff + (i << PAGE_SHIFT);
|
|
|
|
|
pgs[i] = pg = uvm_pagelookup(&vp->v_uobj, off);
|
|
|
|
|
if (pg == NULL) {
|
|
|
|
|
++nonexistent;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
KASSERT(pg != NULL);
|
2006-03-24 23:05:32 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we're holding the segment lock, we can deadlocked
|
|
|
|
|
* against a process that has our page and is waiting
|
|
|
|
|
* for the cleaner, while the cleaner waits for the
|
|
|
|
|
* segment lock. Just bail in that case.
|
|
|
|
|
*/
|
2006-03-28 05:29:55 +04:00
|
|
|
if ((pg->flags & PG_BUSY) &&
|
|
|
|
|
(pagedaemon || LFS_SEGLOCK_HELD(fs))) {
|
|
|
|
|
if (by_list && i > 0)
|
|
|
|
|
uvm_page_unbusy(pgs, i);
|
|
|
|
|
DLOG((DLOG_PAGE, "lfs_putpages: avoiding 3-way or pagedaemon deadlock\n"));
|
|
|
|
|
return -1;
|
2006-03-24 23:05:32 +03:00
|
|
|
}
|
|
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
while (pg->flags & PG_BUSY) {
|
|
|
|
|
pg->flags |= PG_WANTED;
|
|
|
|
|
UVM_UNLOCK_AND_WAIT(pg, &vp->v_interlock, 0,
|
|
|
|
|
"lfsput", 0);
|
|
|
|
|
simple_lock(&vp->v_interlock);
|
2003-03-15 09:58:49 +03:00
|
|
|
if (by_list) {
|
|
|
|
|
if (i > 0)
|
|
|
|
|
uvm_page_unbusy(pgs, i);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
goto top;
|
2003-03-15 09:58:49 +03:00
|
|
|
}
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
|
|
|
|
pg->flags |= PG_BUSY;
|
|
|
|
|
UVM_PAGE_OWN(pg, "lfs_putpages");
|
|
|
|
|
|
|
|
|
|
pmap_page_protect(pg, VM_PROT_NONE);
|
|
|
|
|
tdirty = (pmap_clear_modify(pg) ||
|
|
|
|
|
(pg->flags & PG_CLEAN) == 0);
|
|
|
|
|
dirty += tdirty;
|
|
|
|
|
}
|
|
|
|
|
if (pages_per_block > 0 && nonexistent >= pages_per_block) {
|
|
|
|
|
if (by_list) {
|
|
|
|
|
curpg = TAILQ_NEXT(curpg, listq);
|
|
|
|
|
} else {
|
|
|
|
|
soff += fs->lfs_bsize;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
any_dirty += dirty;
|
|
|
|
|
KASSERT(nonexistent == 0);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If any are dirty make all dirty; unbusy them,
|
2003-02-23 03:22:33 +03:00
|
|
|
* but if we were asked to clean, wire them so that
|
|
|
|
|
* the pagedaemon doesn't bother us about them while
|
|
|
|
|
* they're on their way to disk.
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
|
|
|
|
for (i = 0; i == 0 || i < pages_per_block; i++) {
|
|
|
|
|
pg = pgs[i];
|
|
|
|
|
KASSERT(!((pg->flags & PG_CLEAN) && (pg->flags & PG_DELWRI)));
|
|
|
|
|
if (dirty) {
|
|
|
|
|
pg->flags &= ~PG_CLEAN;
|
|
|
|
|
if (flags & PGO_FREE) {
|
2003-02-19 15:22:51 +03:00
|
|
|
/*
|
2003-03-15 09:58:49 +03:00
|
|
|
* Wire the page so that
|
|
|
|
|
* pdaemon doesn't see it again.
|
2003-02-19 15:22:51 +03:00
|
|
|
*/
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
uvm_lock_pageq();
|
2003-02-19 15:22:51 +03:00
|
|
|
uvm_pagewire(pg);
|
|
|
|
|
uvm_unlock_pageq();
|
2003-02-23 03:22:33 +03:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
/* Suspended write flag */
|
|
|
|
|
pg->flags |= PG_DELWRI;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (pg->flags & PG_WANTED)
|
|
|
|
|
wakeup(pg);
|
|
|
|
|
pg->flags &= ~(PG_WANTED|PG_BUSY);
|
2003-02-19 15:22:51 +03:00
|
|
|
UVM_PAGE_OWN(pg, NULL);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
|
|
|
|
|
2003-04-23 11:20:37 +04:00
|
|
|
if (checkfirst && any_dirty)
|
2004-04-20 15:52:17 +04:00
|
|
|
break;
|
2003-04-23 11:20:37 +04:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
if (by_list) {
|
|
|
|
|
curpg = TAILQ_NEXT(curpg, listq);
|
|
|
|
|
} else {
|
|
|
|
|
soff += MAX(PAGE_SIZE, fs->lfs_bsize);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return any_dirty;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* lfs_putpages functions like genfs_putpages except that
|
2005-02-27 01:31:44 +03:00
|
|
|
*
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
* (1) It needs to bounds-check the incoming requests to ensure that
|
|
|
|
|
* they are block-aligned; if they are not, expand the range and
|
|
|
|
|
* do the right thing in case, e.g., the requested range is clean
|
|
|
|
|
* but the expanded range is dirty.
|
|
|
|
|
* (2) It needs to explicitly send blocks to be written when it is done.
|
|
|
|
|
* VOP_PUTPAGES is not ever called with the seglock held, so
|
|
|
|
|
* we simply take the seglock and let lfs_segunlock wait for us.
|
|
|
|
|
* XXX Actually we can be called with the seglock held, if we have
|
|
|
|
|
* XXX to flush a vnode while lfs_markv is in operation. As of this
|
|
|
|
|
* XXX writing we panic in this case.
|
|
|
|
|
*
|
|
|
|
|
* Assumptions:
|
|
|
|
|
*
|
|
|
|
|
* (1) The caller does not hold any pages in this vnode busy. If it does,
|
|
|
|
|
* there is a danger that when we expand the page range and busy the
|
|
|
|
|
* pages we will deadlock.
|
|
|
|
|
* (2) We are called with vp->v_interlock held; we must return with it
|
|
|
|
|
* released.
|
|
|
|
|
* (3) We don't absolutely have to free pages right away, provided that
|
|
|
|
|
* the request does not have PGO_SYNCIO. When the pagedaemon gives
|
|
|
|
|
* us a request with PGO_FREE, we take the pages out of the paging
|
|
|
|
|
* queue and wake up the writer, which will handle freeing them for us.
|
|
|
|
|
*
|
|
|
|
|
* We ensure that for any filesystem block, all pages for that
|
|
|
|
|
* block are either resident or not, even if those pages are higher
|
|
|
|
|
* than EOF; that means that we will be getting requests to free
|
|
|
|
|
* "unused" pages above EOF all the time, and should ignore them.
|
2003-09-20 21:51:55 +04:00
|
|
|
*
|
|
|
|
|
* XXX note that we're (ab)using PGO_LOCKED as "seglock held".
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
lfs_putpages(void *v)
|
|
|
|
|
{
|
|
|
|
|
int error;
|
|
|
|
|
struct vop_putpages_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
voff_t a_offlo;
|
|
|
|
|
voff_t a_offhi;
|
|
|
|
|
int a_flags;
|
|
|
|
|
} */ *ap = v;
|
|
|
|
|
struct vnode *vp;
|
|
|
|
|
struct inode *ip;
|
|
|
|
|
struct lfs *fs;
|
|
|
|
|
struct segment *sp;
|
|
|
|
|
off_t origoffset, startoffset, endoffset, origendoffset, blkeof;
|
2003-03-09 00:46:04 +03:00
|
|
|
off_t off, max_endoffset;
|
2003-12-16 16:47:48 +03:00
|
|
|
int s;
|
|
|
|
|
boolean_t seglocked, sync, pagedaemon;
|
2003-03-09 00:46:04 +03:00
|
|
|
struct vm_page *pg;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
UVMHIST_FUNC("lfs_putpages"); UVMHIST_CALLED(ubchist);
|
|
|
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
|
ip = VTOI(vp);
|
|
|
|
|
fs = ip->i_lfs;
|
2003-12-16 16:47:48 +03:00
|
|
|
sync = (ap->a_flags & PGO_SYNCIO) != 0;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
pagedaemon = (curproc == uvm.pagedaemon_proc);
|
|
|
|
|
|
|
|
|
|
/* Putpages does nothing for metadata. */
|
|
|
|
|
if (vp == fs->lfs_ivnode || vp->v_type != VREG) {
|
|
|
|
|
simple_unlock(&vp->v_interlock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If there are no pages, don't do anything.
|
|
|
|
|
*/
|
|
|
|
|
if (vp->v_uobj.uo_npages == 0) {
|
|
|
|
|
s = splbio();
|
|
|
|
|
if (LIST_FIRST(&vp->v_dirtyblkhd) == NULL &&
|
|
|
|
|
(vp->v_flag & VONWORKLST)) {
|
|
|
|
|
vp->v_flag &= ~VONWORKLST;
|
|
|
|
|
LIST_REMOVE(vp, v_synclist);
|
|
|
|
|
}
|
|
|
|
|
splx(s);
|
|
|
|
|
simple_unlock(&vp->v_interlock);
|
2006-04-08 04:26:34 +04:00
|
|
|
|
|
|
|
|
/* Remove us from paging queue, if we were on it */
|
|
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
if (ip->i_flags & IN_PAGING) {
|
|
|
|
|
ip->i_flags &= ~IN_PAGING;
|
|
|
|
|
TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
|
|
|
|
|
}
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2003-04-02 14:39:19 +04:00
|
|
|
blkeof = blkroundup(fs, ip->i_size);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Ignore requests to free pages past EOF but in the same block
|
2006-03-24 23:05:32 +03:00
|
|
|
* as EOF, unless the request is synchronous. (If the request is
|
|
|
|
|
* sync, it comes from lfs_truncate.)
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
* XXXUBC Make these pages look "active" so the pagedaemon won't
|
|
|
|
|
* XXXUBC bother us with them again.
|
|
|
|
|
*/
|
2003-04-02 14:39:19 +04:00
|
|
|
if (!sync && ap->a_offlo >= ip->i_size && ap->a_offlo < blkeof) {
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
origoffset = ap->a_offlo;
|
2003-03-09 00:46:04 +03:00
|
|
|
for (off = origoffset; off < blkeof; off += fs->lfs_bsize) {
|
|
|
|
|
pg = uvm_pagelookup(&vp->v_uobj, off);
|
|
|
|
|
KASSERT(pg != NULL);
|
|
|
|
|
while (pg->flags & PG_BUSY) {
|
|
|
|
|
pg->flags |= PG_WANTED;
|
|
|
|
|
UVM_UNLOCK_AND_WAIT(pg, &vp->v_interlock, 0,
|
|
|
|
|
"lfsput2", 0);
|
|
|
|
|
simple_lock(&vp->v_interlock);
|
|
|
|
|
}
|
|
|
|
|
uvm_lock_pageq();
|
|
|
|
|
uvm_pageactivate(pg);
|
|
|
|
|
uvm_unlock_pageq();
|
|
|
|
|
}
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
ap->a_offlo = blkeof;
|
|
|
|
|
if (ap->a_offhi > 0 && ap->a_offhi <= ap->a_offlo) {
|
|
|
|
|
simple_unlock(&vp->v_interlock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Extend page range to start and end at block boundaries.
|
|
|
|
|
* (For the purposes of VOP_PUTPAGES, fragments don't exist.)
|
|
|
|
|
*/
|
2003-02-20 07:27:23 +03:00
|
|
|
origoffset = ap->a_offlo;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
origendoffset = ap->a_offhi;
|
2003-02-20 07:27:23 +03:00
|
|
|
startoffset = origoffset & ~(fs->lfs_bmask);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
max_endoffset = (trunc_page(LLONG_MAX) >> fs->lfs_bshift)
|
|
|
|
|
<< fs->lfs_bshift;
|
|
|
|
|
|
|
|
|
|
if (origendoffset == 0 || ap->a_flags & PGO_ALLPAGES) {
|
2003-02-20 07:27:23 +03:00
|
|
|
endoffset = max_endoffset;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
origendoffset = endoffset;
|
2003-02-20 07:27:23 +03:00
|
|
|
} else {
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
origendoffset = round_page(ap->a_offhi);
|
|
|
|
|
endoffset = round_page(blkroundup(fs, origendoffset));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
KASSERT(startoffset > 0 || endoffset >= startoffset);
|
|
|
|
|
if (startoffset == endoffset) {
|
|
|
|
|
/* Nothing to do, why were we called? */
|
|
|
|
|
simple_unlock(&vp->v_interlock);
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_PAGE, "lfs_putpages: startoffset = endoffset = %"
|
|
|
|
|
PRId64 "\n", startoffset));
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ap->a_offlo = startoffset;
|
|
|
|
|
ap->a_offhi = endoffset;
|
|
|
|
|
|
|
|
|
|
if (!(ap->a_flags & PGO_CLEANIT))
|
|
|
|
|
return genfs_putpages(v);
|
|
|
|
|
|
|
|
|
|
/*
|
2003-04-23 11:20:37 +04:00
|
|
|
* If there are more than one page per block, we don't want
|
|
|
|
|
* to get caught locking them backwards; so set PGO_BUSYFAIL
|
|
|
|
|
* to avoid deadlocks.
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
2003-04-23 11:20:37 +04:00
|
|
|
ap->a_flags |= PGO_BUSYFAIL;
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
int r;
|
|
|
|
|
|
2003-04-27 10:47:45 +04:00
|
|
|
/* If no pages are dirty, we can just use genfs_putpages. */
|
2006-03-24 23:05:32 +03:00
|
|
|
r = check_dirty(fs, vp, startoffset, endoffset, blkeof,
|
|
|
|
|
ap->a_flags, 1);
|
|
|
|
|
if (r < 0) {
|
|
|
|
|
simple_unlock(&vp->v_interlock);
|
|
|
|
|
return EDEADLK;
|
|
|
|
|
}
|
|
|
|
|
if (r > 0)
|
2003-04-23 11:20:37 +04:00
|
|
|
break;
|
|
|
|
|
|
Various minor LFS improvements:
* Note when lfs_putpages(9) thinks it is not going to be writing any
pages before calling genfs_putpages(9). This prevents a situation in
which blocks can be queued for writing without a segment header.
* Correct computation of NRESERVE(), though it is still a gross
overestimate in most cases. Note that if NRESERVE() is too high, it
may be impossible to create files on the filesystem. We catch this
case on filesystem mount and refuse to mount r/w.
* Allow filesystems to be mounted whose block size is == MAXBSIZE.
* Somewhere along the line, ufs_bmaparray(9) started mangling UNWRITTEN
entries in indirect blocks again, triggering a failed assertion "daddr
<= LFS_MAX_DADDR". Explicitly convert to and from int32_t to correct
this.
* Add a high-water mark for the number of dirty pages any given LFS can
hold before triggering a flush. This is settable by sysctl, but off
(zero) by default.
* Be more careful about the MAX_BYTES and MAX_BUFS computations so we
shouldn't see "please increase to at least zero" messages.
* Note that VBLK and VCHR vnodes can have nonzero values in di_db[0]
even though their v_size == 0. Don't panic when we see this.
* Change lfs_bfree to a signed quantity. The manner in which it is
processed before being passed to the cleaner means that sometimes it
may drop below zero, and the cleaner must be aware of this.
* Never report bfree < 0 (or higher than lfs_dsize) through
lfs_statvfs(9). This prevents df(1) from ever telling us that our full
filesystems have 16TB free.
* Account space allocated through lfs_balloc(9) that does not have
associated buffer headers, so that the pagedaemon doesn't run us out
of segments.
* Return ENOSPC from lfs_balloc(9) when bfree drops to zero.
* Address a deadlock in lfs_bmapv/lfs_markv when the filesystem is being
unmounted. Because vfs_busy() is a shared lock, and
lfs_bmapv/lfs_markv mark the filesystem vfs_busy(), the cleaner can be
holding the lock that umount() is blocking on, then try to vfs_busy()
again in getnewvnode().
2005-02-26 08:40:42 +03:00
|
|
|
/*
|
|
|
|
|
* Sometimes pages are dirtied between the time that
|
|
|
|
|
* we check and the time we try to clean them.
|
|
|
|
|
* Instruct lfs_gop_write to return EDEADLK in this case
|
|
|
|
|
* so we can write them properly.
|
|
|
|
|
*/
|
|
|
|
|
ip->i_lfs_iflags |= LFSI_NO_GOP_WRITE;
|
|
|
|
|
r = genfs_putpages(v);
|
|
|
|
|
ip->i_lfs_iflags &= ~LFSI_NO_GOP_WRITE;
|
|
|
|
|
if (r != EDEADLK)
|
2003-04-23 11:20:37 +04:00
|
|
|
return r;
|
|
|
|
|
|
|
|
|
|
/* Start over. */
|
2003-10-21 04:39:03 +04:00
|
|
|
preempt(1);
|
2003-04-23 11:20:37 +04:00
|
|
|
simple_lock(&vp->v_interlock);
|
|
|
|
|
} while(1);
|
2005-02-27 01:31:44 +03:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
/*
|
|
|
|
|
* Dirty and asked to clean.
|
|
|
|
|
*
|
|
|
|
|
* Pagedaemon can't actually write LFS pages; wake up
|
|
|
|
|
* the writer to take care of that. The writer will
|
|
|
|
|
* notice the pager inode queue and act on that.
|
|
|
|
|
*/
|
|
|
|
|
if (pagedaemon) {
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
2006-04-08 04:26:34 +04:00
|
|
|
if (!(ip->i_flags & IN_PAGING)) {
|
|
|
|
|
ip->i_flags |= IN_PAGING;
|
|
|
|
|
TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip, i_lfs_pchain);
|
|
|
|
|
}
|
|
|
|
|
simple_lock(&lfs_subsys_lock);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
wakeup(&lfs_writer_daemon);
|
2006-04-08 04:26:34 +04:00
|
|
|
simple_unlock(&lfs_subsys_lock);
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2003-02-22 04:52:25 +03:00
|
|
|
simple_unlock(&vp->v_interlock);
|
2006-04-08 04:26:34 +04:00
|
|
|
preempt(1);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
return EWOULDBLOCK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If this is a file created in a recent dirop, we can't flush its
|
|
|
|
|
* inode until the dirop is complete. Drain dirops, then flush the
|
|
|
|
|
* filesystem (taking care of any other pending dirops while we're
|
|
|
|
|
* at it).
|
|
|
|
|
*/
|
|
|
|
|
if ((ap->a_flags & (PGO_CLEANIT|PGO_LOCKED)) == PGO_CLEANIT &&
|
|
|
|
|
(vp->v_flag & VDIROP)) {
|
|
|
|
|
int locked;
|
|
|
|
|
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_PAGE, "lfs_putpages: flushing VDIROP\n"));
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
locked = VOP_ISLOCKED(vp) && /* XXX */
|
|
|
|
|
vp->v_lock.lk_lockholder == curproc->p_pid;
|
2005-03-25 04:45:05 +03:00
|
|
|
simple_unlock(&vp->v_interlock);
|
|
|
|
|
lfs_writer_enter(fs, "ppdirop");
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
if (locked)
|
|
|
|
|
VOP_UNLOCK(vp, 0);
|
2005-02-27 01:31:44 +03:00
|
|
|
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_lock(&fs->lfs_interlock);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
lfs_flush_fs(fs, sync ? SEGM_SYNC : 0);
|
2005-04-02 01:59:46 +04:00
|
|
|
simple_unlock(&fs->lfs_interlock);
|
2005-02-27 01:31:44 +03:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
simple_lock(&vp->v_interlock);
|
2005-05-20 23:09:25 +04:00
|
|
|
if (locked) {
|
2005-04-28 00:35:10 +04:00
|
|
|
VOP_LOCK(vp, LK_EXCLUSIVE | LK_INTERLOCK);
|
2005-05-20 23:09:25 +04:00
|
|
|
simple_lock(&vp->v_interlock);
|
|
|
|
|
}
|
2003-07-02 17:40:51 +04:00
|
|
|
lfs_writer_leave(fs);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
|
|
|
|
/* XXX the flush should have taken care of this one too! */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2003-02-20 07:27:23 +03:00
|
|
|
* This is it. We are going to write some pages. From here on
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
* down it's all just mechanics.
|
|
|
|
|
*
|
2003-04-23 11:20:37 +04:00
|
|
|
* Don't let genfs_putpages wait; lfs_segunlock will wait for us.
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
|
|
|
|
ap->a_flags &= ~PGO_SYNCIO;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we've already got the seglock, flush the node and return.
|
|
|
|
|
* The FIP has already been set up for us by lfs_writefile,
|
|
|
|
|
* and FIP cleanup and lfs_updatemeta will also be done there,
|
|
|
|
|
* unless genfs_putpages returns EDEADLK; then we must flush
|
|
|
|
|
* what we have, and correct FIP and segment header accounting.
|
|
|
|
|
*/
|
|
|
|
|
|
2003-12-16 16:47:48 +03:00
|
|
|
seglocked = (ap->a_flags & PGO_LOCKED) != 0;
|
|
|
|
|
if (!seglocked) {
|
|
|
|
|
simple_unlock(&vp->v_interlock);
|
2003-04-23 11:20:37 +04:00
|
|
|
/*
|
2003-12-16 16:47:48 +03:00
|
|
|
* Take the seglock, because we are going to be writing pages.
|
2003-04-23 11:20:37 +04:00
|
|
|
*/
|
2003-12-16 16:47:48 +03:00
|
|
|
error = lfs_seglock(fs, SEGM_PROT | (sync ? SEGM_SYNC : 0));
|
|
|
|
|
if (error != 0)
|
|
|
|
|
return error;
|
|
|
|
|
simple_lock(&vp->v_interlock);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* VOP_PUTPAGES should not be called while holding the seglock.
|
2003-03-04 22:19:43 +03:00
|
|
|
* XXXUBC fix lfs_markv, or do this properly.
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
2005-04-02 01:59:46 +04:00
|
|
|
#ifdef notyet
|
|
|
|
|
KASSERT(fs->lfs_seglock == 1);
|
|
|
|
|
#endif /* notyet */
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We assume we're being called with sp->fip pointing at blank space.
|
|
|
|
|
* Account for a new FIP in the segment header, and set sp->vp.
|
|
|
|
|
* (This should duplicate the setup at the top of lfs_writefile().)
|
|
|
|
|
*/
|
|
|
|
|
sp = fs->lfs_sp;
|
2003-12-16 16:47:48 +03:00
|
|
|
if (!seglocked) {
|
|
|
|
|
if (sp->seg_bytes_left < fs->lfs_bsize ||
|
|
|
|
|
sp->sum_bytes_left < sizeof(struct finfo))
|
2005-02-27 01:31:44 +03:00
|
|
|
(void) lfs_writeseg(fs, fs->lfs_sp);
|
|
|
|
|
|
2003-12-16 16:47:48 +03:00
|
|
|
sp->sum_bytes_left -= FINFOSIZE;
|
|
|
|
|
++((SEGSUM *)(sp->segsum))->ss_nfinfo;
|
|
|
|
|
}
|
2003-10-18 19:52:42 +04:00
|
|
|
KASSERT(sp->vp == NULL);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
sp->vp = vp;
|
2005-02-27 01:31:44 +03:00
|
|
|
|
2003-12-16 16:47:48 +03:00
|
|
|
if (!seglocked) {
|
|
|
|
|
if (vp->v_flag & VDIROP)
|
|
|
|
|
((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
|
|
|
|
|
}
|
2005-02-27 01:31:44 +03:00
|
|
|
|
2003-02-20 07:27:23 +03:00
|
|
|
sp->fip->fi_nblocks = 0;
|
|
|
|
|
sp->fip->fi_ino = ip->i_number;
|
2003-04-02 14:39:19 +04:00
|
|
|
sp->fip->fi_version = ip->i_gen;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Loop through genfs_putpages until all pages are gathered.
|
2003-02-23 03:22:33 +03:00
|
|
|
* genfs_putpages() drops the interlock, so reacquire it if necessary.
|
2003-04-23 11:20:37 +04:00
|
|
|
* Whenever we lose the interlock we have to rerun check_dirty, as
|
|
|
|
|
* well.
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
2003-12-16 16:47:48 +03:00
|
|
|
again:
|
2006-03-24 23:05:32 +03:00
|
|
|
if (check_dirty(fs, vp, startoffset, endoffset, blkeof,
|
|
|
|
|
ap->a_flags, 0) < 0) {
|
|
|
|
|
simple_unlock(&vp->v_interlock);
|
|
|
|
|
sp->vp = NULL;
|
2006-04-01 04:13:01 +04:00
|
|
|
if (!seglocked)
|
|
|
|
|
lfs_segunlock(fs);
|
2006-03-24 23:05:32 +03:00
|
|
|
return EDEADLK;
|
|
|
|
|
}
|
2003-04-23 11:20:37 +04:00
|
|
|
|
2006-03-24 23:05:32 +03:00
|
|
|
error = genfs_putpages(v);
|
|
|
|
|
if (error == EDEADLK || error == EAGAIN) {
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_PAGE, "lfs_putpages: genfs_putpages returned"
|
|
|
|
|
" EDEADLK [2] ino %d off %x (seg %d)\n",
|
|
|
|
|
ip->i_number, fs->lfs_offset,
|
|
|
|
|
dtosn(fs, fs->lfs_offset)));
|
2003-02-23 03:22:33 +03:00
|
|
|
/* If nothing to write, short-circuit */
|
2004-02-27 01:41:36 +03:00
|
|
|
if (sp->cbpp - sp->bpp > 1) {
|
|
|
|
|
/* Write gathered pages */
|
|
|
|
|
lfs_updatemeta(sp);
|
|
|
|
|
(void) lfs_writeseg(fs, sp);
|
2005-02-27 01:31:44 +03:00
|
|
|
|
2004-02-27 01:41:36 +03:00
|
|
|
/*
|
|
|
|
|
* Reinitialize brand new FIP and add us to it.
|
|
|
|
|
* (This should duplicate the fixup in
|
|
|
|
|
* lfs_gatherpages().)
|
|
|
|
|
*/
|
|
|
|
|
KASSERT(sp->vp == vp);
|
|
|
|
|
sp->fip->fi_version = ip->i_gen;
|
|
|
|
|
sp->fip->fi_ino = ip->i_number;
|
|
|
|
|
/* Add us to the new segment summary. */
|
|
|
|
|
++((SEGSUM *)(sp->segsum))->ss_nfinfo;
|
|
|
|
|
sp->sum_bytes_left -= FINFOSIZE;
|
2003-02-23 03:22:33 +03:00
|
|
|
}
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
|
|
|
|
/* Give the write a chance to complete */
|
2003-10-21 04:39:03 +04:00
|
|
|
preempt(1);
|
2003-04-23 11:20:37 +04:00
|
|
|
|
|
|
|
|
/* We've lost the interlock. Start over. */
|
2003-12-16 16:47:48 +03:00
|
|
|
simple_lock(&vp->v_interlock);
|
2006-03-24 23:05:32 +03:00
|
|
|
if (error == EDEADLK)
|
|
|
|
|
goto again;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
|
|
|
|
|
2003-10-18 19:52:42 +04:00
|
|
|
KASSERT(sp->vp == vp);
|
2003-12-16 16:47:48 +03:00
|
|
|
if (!seglocked) {
|
|
|
|
|
sp->vp = NULL; /* XXX lfs_gather below will set this */
|
2003-10-18 19:52:42 +04:00
|
|
|
|
2003-12-16 16:47:48 +03:00
|
|
|
/* Write indirect blocks as well */
|
|
|
|
|
lfs_gather(fs, fs->lfs_sp, vp, lfs_match_indir);
|
|
|
|
|
lfs_gather(fs, fs->lfs_sp, vp, lfs_match_dindir);
|
|
|
|
|
lfs_gather(fs, fs->lfs_sp, vp, lfs_match_tindir);
|
|
|
|
|
|
|
|
|
|
KASSERT(sp->vp == NULL);
|
|
|
|
|
sp->vp = vp;
|
|
|
|
|
}
|
2003-04-23 11:20:37 +04:00
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
/*
|
|
|
|
|
* Blocks are now gathered into a segment waiting to be written.
|
|
|
|
|
* All that's left to do is update metadata, and write them.
|
|
|
|
|
*/
|
2003-10-18 19:52:42 +04:00
|
|
|
lfs_updatemeta(sp);
|
|
|
|
|
KASSERT(sp->vp == vp);
|
|
|
|
|
sp->vp = NULL;
|
|
|
|
|
|
2003-12-16 16:47:48 +03:00
|
|
|
if (seglocked) {
|
|
|
|
|
/* we're called by lfs_writefile. */
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
/*
|
2003-02-23 03:22:33 +03:00
|
|
|
* Clean up FIP, since we're done writing this file.
|
|
|
|
|
* This should duplicate cleanup at the end of lfs_writefile().
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
*/
|
2003-02-20 07:27:23 +03:00
|
|
|
if (sp->fip->fi_nblocks != 0) {
|
2003-11-25 18:14:57 +03:00
|
|
|
sp->fip = (FINFO*)((caddr_t)sp->fip + FINFOSIZE +
|
|
|
|
|
sizeof(int32_t) * sp->fip->fi_nblocks);
|
2003-02-20 07:27:23 +03:00
|
|
|
sp->start_lbp = &sp->fip->fi_blocks[0];
|
|
|
|
|
} else {
|
2003-11-25 18:14:57 +03:00
|
|
|
sp->sum_bytes_left += FINFOSIZE;
|
2003-02-20 07:27:23 +03:00
|
|
|
--((SEGSUM *)(sp->segsum))->ss_nfinfo;
|
|
|
|
|
}
|
2003-02-23 03:22:33 +03:00
|
|
|
lfs_writeseg(fs, fs->lfs_sp);
|
|
|
|
|
|
2006-04-08 04:26:34 +04:00
|
|
|
/*
|
|
|
|
|
* Remove us from paging queue, since we've now written all our
|
|
|
|
|
* pages.
|
|
|
|
|
*/
|
|
|
|
|
simple_lock(&fs->lfs_interlock);
|
|
|
|
|
if (ip->i_flags & IN_PAGING) {
|
|
|
|
|
ip->i_flags &= ~IN_PAGING;
|
|
|
|
|
TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
|
|
|
|
|
}
|
|
|
|
|
simple_unlock(&fs->lfs_interlock);
|
|
|
|
|
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
/*
|
|
|
|
|
* XXX - with the malloc/copy writeseg, the pages are freed by now
|
|
|
|
|
* even if we don't wait (e.g. if we hold a nested lock). This
|
|
|
|
|
* will not be true if we stop using malloc/copy.
|
|
|
|
|
*/
|
|
|
|
|
KASSERT(fs->lfs_sp->seg_flags & SEGM_PROT);
|
|
|
|
|
lfs_segunlock(fs);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Wait for v_numoutput to drop to zero. The seglock should
|
|
|
|
|
* take care of this, but there is a slight possibility that
|
|
|
|
|
* aiodoned might not have got around to our buffers yet.
|
|
|
|
|
*/
|
|
|
|
|
if (sync) {
|
|
|
|
|
s = splbio();
|
|
|
|
|
simple_lock(&global_v_numoutput_slock);
|
2003-03-21 09:26:36 +03:00
|
|
|
while (vp->v_numoutput > 0) {
|
2005-03-08 03:18:19 +03:00
|
|
|
DLOG((DLOG_PAGE, "lfs_putpages: ino %d sleeping on"
|
|
|
|
|
" num %d\n", ip->i_number, vp->v_numoutput));
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
vp->v_flag |= VBWAIT;
|
2003-02-22 04:52:25 +03:00
|
|
|
ltsleep(&vp->v_numoutput, PRIBIO + 1, "lfs_vn", 0,
|
|
|
|
|
&global_v_numoutput_slock);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
|
|
|
|
simple_unlock(&global_v_numoutput_slock);
|
|
|
|
|
splx(s);
|
|
|
|
|
}
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Return the last logical file offset that should be written for this file
|
2003-02-20 07:27:23 +03:00
|
|
|
* if we're doing a write that ends at "size". If writing, we need to know
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
* about sizes on disk, i.e. fragments if there are any; if reading, we need
|
|
|
|
|
* to know about entire blocks.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
lfs_gop_size(struct vnode *vp, off_t size, off_t *eobp, int flags)
|
|
|
|
|
{
|
|
|
|
|
struct inode *ip = VTOI(vp);
|
2005-02-27 01:31:44 +03:00
|
|
|
struct lfs *fs = ip->i_lfs;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
daddr_t olbn, nlbn;
|
|
|
|
|
|
2003-04-02 14:39:19 +04:00
|
|
|
olbn = lblkno(fs, ip->i_size);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
nlbn = lblkno(fs, size);
|
2003-09-24 14:22:53 +04:00
|
|
|
if (!(flags & GOP_SIZE_MEM) && nlbn < NDADDR && olbn <= nlbn) {
|
2003-02-20 07:27:23 +03:00
|
|
|
*eobp = fragroundup(fs, size);
|
|
|
|
|
} else {
|
|
|
|
|
*eobp = blkroundup(fs, size);
|
|
|
|
|
}
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
void lfs_dump_vop(void *);
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
lfs_dump_vop(void *v)
|
|
|
|
|
{
|
2003-02-20 07:27:23 +03:00
|
|
|
struct vop_putpages_args /* {
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
voff_t a_offlo;
|
|
|
|
|
voff_t a_offhi;
|
|
|
|
|
int a_flags;
|
|
|
|
|
} */ *ap = v;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
|
2003-05-07 22:49:29 +04:00
|
|
|
#ifdef DDB
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
vfs_vnode_print(ap->a_vp, 0, printf);
|
2003-05-07 22:49:29 +04:00
|
|
|
#endif
|
2003-04-02 14:39:19 +04:00
|
|
|
lfs_dump_dinode(VTOI(ap->a_vp)->i_din.ffs1_din);
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
lfs_mmap(void *v)
|
|
|
|
|
{
|
|
|
|
|
struct vop_mmap_args /* {
|
2003-02-20 07:27:23 +03:00
|
|
|
const struct vnodeop_desc *a_desc;
|
|
|
|
|
struct vnode *a_vp;
|
|
|
|
|
int a_fflags;
|
|
|
|
|
struct ucred *a_cred;
|
2005-12-11 15:16:03 +03:00
|
|
|
struct lwp *a_l;
|
Add code to UBCify LFS. This is still behind "#ifdef LFS_UBC" for now
(there are still some details to work out) but expect that to go
away soon. To support these basic changes (creation of lfs_putpages,
lfs_gop_write, mods to lfs_balloc) several other changes were made, to
wit:
* Create a writer daemon kernel thread whose purpose is to handle page
writes for the pagedaemon, but which also takes over some of the
functions of lfs_check(). This thread is started the first time an
LFS is mounted.
* Add a "flags" parameter to GOP_SIZE. Current values are
GOP_SIZE_READ, meaning that the call should return the size of the
in-core version of the file, and GOP_SIZE_WRITE, meaning that it
should return the on-disk size. One of GOP_SIZE_READ or
GOP_SIZE_WRITE must be specified.
* Instead of using malloc(...M_WAITOK) for everything, reserve enough
resources to get by and use malloc(...M_NOWAIT), using the reserves if
necessary. Use the pool subsystem for structures small enough that
this is feasible. This also obsoletes LFS_THROTTLE.
And a few that are not strictly necessary:
* Moves the LFS inode extensions off onto a separately allocated
structure; getting closer to LFS as an LKM. "Welcome to 1.6O."
* Unified GOP_ALLOC between FFS and LFS.
* Update LFS copyright headers to correct values.
* Actually cast to unsigned in lfs_shellsort, like the comment says.
* Keep track of which segments were empty before the previous
checkpoint; any segments that pass two checkpoints both dirty and
empty can be summarily cleaned. Do this. Right now lfs_segclean
still works, but this should be turned into an effectless
compatibility syscall.
2003-02-18 02:48:08 +03:00
|
|
|
} */ *ap = v;
|
|
|
|
|
|
|
|
|
|
if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM)
|
|
|
|
|
return EOPNOTSUPP;
|
|
|
|
|
return ufs_mmap(v);
|
|
|
|
|
}
|