1994-05-24 10:09:53 +00:00
|
|
|
/*-
|
2017-11-20 19:43:44 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1991, 1993, 1994
|
|
|
|
|
* 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.
|
2017-02-28 23:42:47 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-24 10:09:53 +00: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.
|
|
|
|
|
*
|
1997-02-10 02:22:35 +00:00
|
|
|
* @(#)ffs_extern.h 8.6 (Berkeley) 3/30/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
1996-05-01 02:16:17 +00:00
|
|
|
#ifndef _UFS_FFS_EXTERN_H
|
|
|
|
|
#define _UFS_FFS_EXTERN_H
|
|
|
|
|
|
2011-06-16 23:40:10 +00:00
|
|
|
#ifndef _KERNEL
|
|
|
|
|
#error "No user-serving parts inside"
|
|
|
|
|
#else
|
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
struct buf;
|
2001-05-30 23:08:40 +00:00
|
|
|
struct cg;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fid;
|
|
|
|
|
struct fs;
|
|
|
|
|
struct inode;
|
1998-02-03 21:52:02 +00:00
|
|
|
struct malloc_type;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mount;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread;
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct statfs;
|
1998-02-03 21:52:02 +00:00
|
|
|
struct ucred;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vnode;
|
1998-03-23 14:12:37 +00:00
|
|
|
struct vop_fsync_args;
|
1998-02-03 21:52:02 +00:00
|
|
|
struct vop_reallocblks_args;
|
2010-04-24 07:05:35 +00:00
|
|
|
struct workhead;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2009-01-27 21:48:47 +00:00
|
|
|
int ffs_alloc(struct inode *, ufs2_daddr_t, ufs2_daddr_t, int, int,
|
|
|
|
|
struct ucred *, ufs2_daddr_t *);
|
2002-06-21 06:18:05 +00:00
|
|
|
int ffs_balloc_ufs1(struct vnode *a_vp, off_t a_startoffset, int a_size,
|
|
|
|
|
struct ucred *a_cred, int a_flags, struct buf **a_bpp);
|
|
|
|
|
int ffs_balloc_ufs2(struct vnode *a_vp, off_t a_startoffset, int a_size,
|
2002-03-19 22:40:48 +00:00
|
|
|
struct ucred *a_cred, int a_flags, struct buf **a_bpp);
|
2005-01-24 10:02:11 +00:00
|
|
|
void ffs_blkfree(struct ufsmount *, struct fs *, struct vnode *,
|
2018-08-18 22:21:59 +00:00
|
|
|
ufs2_daddr_t, long, ino_t, enum vtype, struct workhead *, u_long);
|
2002-06-21 06:18:05 +00:00
|
|
|
ufs2_daddr_t ffs_blkpref_ufs1(struct inode *, ufs_lbn_t, int, ufs1_daddr_t *);
|
|
|
|
|
ufs2_daddr_t ffs_blkpref_ufs2(struct inode *, ufs_lbn_t, int, ufs2_daddr_t *);
|
2018-08-18 22:21:59 +00:00
|
|
|
void ffs_blkrelease_finish(struct ufsmount *, u_long);
|
|
|
|
|
u_long ffs_blkrelease_start(struct ufsmount *, struct vnode *, ino_t);
|
2018-11-25 18:01:15 +00:00
|
|
|
uint32_t ffs_calc_sbhash(struct fs *);
|
2003-02-22 00:29:51 +00:00
|
|
|
int ffs_checkfreefile(struct fs *, struct vnode *, ino_t);
|
2002-06-21 06:18:05 +00:00
|
|
|
void ffs_clrblock(struct fs *, u_char *, ufs1_daddr_t);
|
2010-04-24 07:05:35 +00:00
|
|
|
void ffs_clusteracct(struct fs *, struct cg *, ufs1_daddr_t, int);
|
Cylinder group bitmaps and blocks containing inode for a snapshot
file are after snaplock, while other ffs device buffers are before
snaplock in global lock order. By itself, this could cause deadlock
when bdwrite() tries to flush dirty buffers on snapshotted ffs. If,
during the flush, COW activity for snapshot needs to allocate block
and ffs_alloccg() selects the cylinder group that is being written
by bdwrite(), then kernel would panic due to recursive buffer lock
acquision.
Avoid dealing with buffers in bdwrite() that are from other side of
snaplock divisor in the lock order then the buffer being written. Add
new BOP, bop_bdwrite(), to do dirty buffer flushing for same vnode in
the bdwrite(). Default implementation, bufbdflush(), refactors the code
from bdwrite(). For ffs device buffers, specialized implementation is
used.
Reviewed by: tegge, jeff, Russell Cattelan (cattelan xfs org, xfs changes)
Tested by: Peter Holm
X-MFC after: 3 weeks (if ever: it changes ABI)
2007-01-23 10:01:19 +00:00
|
|
|
void ffs_bdflush(struct bufobj *, struct buf *);
|
2004-10-26 06:25:56 +00:00
|
|
|
int ffs_copyonwrite(struct vnode *, struct buf *);
|
2002-03-19 22:40:48 +00:00
|
|
|
int ffs_flushfiles(struct mount *, int, struct thread *);
|
|
|
|
|
void ffs_fragacct(struct fs *, int, int32_t [], int);
|
2005-01-24 10:02:11 +00:00
|
|
|
int ffs_freefile(struct ufsmount *, struct fs *, struct vnode *, ino_t,
|
2010-04-24 07:05:35 +00:00
|
|
|
int, struct workhead *);
|
2011-06-15 18:05:08 +00:00
|
|
|
void ffs_fserr(struct fs *, ino_t, char *);
|
2019-10-04 05:28:36 +00:00
|
|
|
int ffs_getcg(struct fs *, struct vnode *, u_int, int, struct buf **,
|
2017-06-28 17:32:09 +00:00
|
|
|
struct cg **);
|
2002-06-21 06:18:05 +00:00
|
|
|
int ffs_isblock(struct fs *, u_char *, ufs1_daddr_t);
|
2010-04-24 07:05:35 +00:00
|
|
|
int ffs_isfreeblock(struct fs *, u_char *, ufs1_daddr_t);
|
|
|
|
|
void ffs_oldfscompat_write(struct fs *, struct ufsmount *);
|
2012-11-18 18:57:19 +00:00
|
|
|
int ffs_own_mount(const struct mount *mp);
|
2002-03-19 22:40:48 +00:00
|
|
|
int ffs_reallocblks(struct vop_reallocblks_args *);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
int ffs_realloccg(struct inode *, ufs2_daddr_t, ufs2_daddr_t,
|
2009-01-27 21:48:47 +00:00
|
|
|
ufs2_daddr_t, int, int, int, struct ucred *, struct buf **);
|
2012-11-18 18:57:19 +00:00
|
|
|
int ffs_reload(struct mount *, struct thread *, int);
|
2018-01-26 00:58:32 +00:00
|
|
|
int ffs_sbget(void *, struct fs **, off_t, struct malloc_type *,
|
|
|
|
|
int (*)(void *, off_t, void **, int));
|
|
|
|
|
int ffs_sbput(void *, struct fs *, off_t, int (*)(void *, off_t, void *,
|
|
|
|
|
int));
|
2006-10-31 21:48:54 +00:00
|
|
|
int ffs_sbupdate(struct ufsmount *, int, int);
|
2002-06-21 06:18:05 +00:00
|
|
|
void ffs_setblock(struct fs *, u_char *, ufs1_daddr_t);
|
2011-06-12 19:27:05 +00:00
|
|
|
int ffs_snapblkfree(struct fs *, struct vnode *, ufs2_daddr_t, long, ino_t,
|
2011-06-15 23:19:09 +00:00
|
|
|
enum vtype, struct workhead *);
|
2002-03-19 22:40:48 +00:00
|
|
|
void ffs_snapremove(struct vnode *vp);
|
|
|
|
|
int ffs_snapshot(struct mount *mp, char *snapfile);
|
|
|
|
|
void ffs_snapshot_mount(struct mount *mp);
|
|
|
|
|
void ffs_snapshot_unmount(struct mount *mp);
|
2018-01-26 00:58:32 +00:00
|
|
|
void ffs_susp_initialize(void);
|
|
|
|
|
void ffs_susp_uninitialize(void);
|
2011-06-12 19:27:05 +00:00
|
|
|
void ffs_sync_snap(struct mount *, int);
|
2012-03-25 00:02:37 +00:00
|
|
|
int ffs_syncvnode(struct vnode *vp, int waitfor, int flags);
|
2012-04-23 13:21:28 +00:00
|
|
|
int ffs_truncate(struct vnode *, off_t, int, struct ucred *);
|
2002-03-19 22:40:48 +00:00
|
|
|
int ffs_update(struct vnode *, int);
|
2018-12-11 22:14:37 +00:00
|
|
|
void ffs_update_dinode_ckhash(struct fs *, struct ufs2_dinode *);
|
|
|
|
|
int ffs_verify_dinode_ckhash(struct fs *, struct ufs2_dinode *);
|
2002-03-19 22:40:48 +00:00
|
|
|
int ffs_valloc(struct vnode *, int, struct ucred *, struct vnode **);
|
|
|
|
|
int ffs_vfree(struct vnode *, ino_t, int);
|
2002-08-13 10:05:50 +00:00
|
|
|
vfs_vget_t ffs_vget;
|
2008-08-28 09:18:20 +00:00
|
|
|
int ffs_vgetf(struct mount *, ino_t, int, struct vnode **, int);
|
2018-01-26 00:58:32 +00:00
|
|
|
void process_deferred_inactive(struct mount *mp);
|
This commit enables a UFS filesystem to do a forcible unmount when
the underlying media fails or becomes inaccessible. For example
when a USB flash memory card hosting a UFS filesystem is unplugged.
The strategy for handling disk I/O errors when soft updates are
enabled is to stop writing to the disk of the affected file system
but continue to accept I/O requests and report that all future
writes by the file system to that disk actually succeed. Then
initiate an asynchronous forced unmount of the affected file system.
There are two cases for disk I/O errors:
- ENXIO, which means that this disk is gone and the lower layers
of the storage stack already guarantee that no future I/O to
this disk will succeed.
- EIO (or most other errors), which means that this particular
I/O request has failed but subsequent I/O requests to this
disk might still succeed.
For ENXIO, we can just clear the error and continue, because we
know that the file system cannot affect the on-disk state after we
see this error. For EIO or other errors, we arrange for the geom_vfs
layer to reject all future I/O requests with ENXIO just like is
done when the geom_vfs is orphaned. In both cases, the file system
code can just clear the error and proceed with the forcible unmount.
This new treatment of I/O errors is needed for writes of any buffer
that is involved in a dependency. Most dependencies are described
by a structure attached to the buffer's b_dep field. But some are
created and processed as a result of the completion of the dependencies
attached to the buffer.
Clearing of some dependencies require a read. For example if there
is a dependency that requires an inode to be written, the disk block
containing that inode must be read, the updated inode copied into
place in that buffer, and the buffer then written back to disk.
Often the needed buffer is already in memory and can be used. But
if it needs to be read from the disk, the read will fail, so we
fabricate a buffer full of zeroes and pretend that the read succeeded.
This zero'ed buffer can be updated and written back to disk.
The only case where a buffer full of zeros causes the code to do
the wrong thing is when reading an inode buffer containing an inode
that still has an inode dependency in memory that will reinitialize
the effective link count (i_effnlink) based on the actual link count
(i_nlink) that we read. To handle this case we now store the i_nlink
value that we wrote in the inode dependency so that it can be
restored into the zero'ed buffer thus keeping the tracking of the
inode link count consistent.
Because applications depend on knowing when an attempt to write
their data to stable storage has failed, the fsync(2) and msync(2)
system calls need to return errors if data fails to be written to
stable storage. So these operations return ENXIO for every call
made on files in a file system where we have otherwise been ignoring
I/O errors.
Coauthered by: mckusick
Reviewed by: kib
Tested by: Peter Holm
Approved by: mckusick (mentor)
Sponsored by: Netflix
Differential Revision: https://reviews.freebsd.org/D24088
2020-05-25 23:47:31 +00:00
|
|
|
int ffs_fsfail_cleanup(struct ufsmount *, int);
|
|
|
|
|
int ffs_fsfail_cleanup_locked(struct ufsmount *, int);
|
|
|
|
|
int ffs_breadz(struct ufsmount *, struct vnode *, daddr_t, daddr_t, int,
|
|
|
|
|
daddr_t *, int *, int, struct ucred *, int, void (*)(struct buf *),
|
|
|
|
|
struct buf **);
|
2008-08-28 09:18:20 +00:00
|
|
|
|
2018-08-18 22:21:59 +00:00
|
|
|
/*
|
|
|
|
|
* Flags to ffs_vgetf
|
|
|
|
|
*/
|
2008-08-28 09:18:20 +00:00
|
|
|
#define FFSV_FORCEINSMQ 0x0001
|
2019-08-29 07:45:23 +00:00
|
|
|
#define FFSV_REPLACE 0x0002
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2018-08-18 22:21:59 +00:00
|
|
|
/*
|
|
|
|
|
* Flags to ffs_reload
|
|
|
|
|
*/
|
2016-09-08 12:01:28 +00:00
|
|
|
#define FFSR_FORCE 0x0001
|
|
|
|
|
#define FFSR_UNSUSPEND 0x0002
|
|
|
|
|
|
Normally when an attempt is made to mount a UFS/FFS filesystem whose
superblock has a check-hash error, an error message noting the
superblock check-hash failure is printed and the mount fails. The
administrator then runs fsck to repair the filesystem and when
successful, the filesystem can once again be mounted.
This approach fails if the filesystem in question is a root filesystem
from which you are trying to boot. Here, the loader fails when trying
to access the filesystem to get the kernel to boot. So it is necessary
to allow the loader to ignore the superblock check-hash error and make
a best effort to read the kernel. The filesystem may be suffiently
corrupted that the read attempt fails, but there is no harm in trying
since the loader makes no attempt to write to the filesystem.
Once the kernel is loaded and starts to run, it attempts to mount its
root filesystem. Once again, failure means that it breaks to its prompt
to ask where to get its root filesystem. Unless you have an alternate
root filesystem, you are stuck.
Since the root filesystem is initially mounted read-only, it is
safe to make an attempt to mount the root filesystem with the failed
superblock check-hash. Thus, when asked to mount a root filesystem
with a failed superblock check-hash, the kernel prints a warning
message that the root filesystem superblock check-hash needs repair,
but notes that it is ignoring the error and proceeding. It does
mark the filesystem as needing an fsck which prevents it from being
enabled for writing until fsck has been run on it. The net effect
is that the reboot fails to single user, but at least at that point
the administrator has the tools at hand to fix the problem.
Reported by: Rick Macklem (rmacklem@)
Discussed with: Warner Losh (imp@)
Sponsored by: Netflix
2018-12-06 00:09:39 +00:00
|
|
|
/*
|
|
|
|
|
* Request standard superblock location in ffs_sbget
|
|
|
|
|
*/
|
|
|
|
|
#define STDSB -1 /* Fail if check-hash is bad */
|
|
|
|
|
#define STDSB_NOHASHFAIL -2 /* Ignore check-hash failure */
|
|
|
|
|
|
2018-08-18 22:21:59 +00:00
|
|
|
/*
|
|
|
|
|
* Definitions for TRIM interface
|
|
|
|
|
*
|
|
|
|
|
* Special keys and recommended hash table size
|
|
|
|
|
*/
|
|
|
|
|
#define NOTRIM_KEY 1 /* never written, so don't call trim for it */
|
|
|
|
|
#define SINGLETON_KEY 2 /* only block being freed, so trim it now */
|
|
|
|
|
#define FIRST_VALID_KEY 3 /* first valid key describing a block range */
|
|
|
|
|
#define MAXTRIMIO 1024 /* maximum expected outstanding trim requests */
|
|
|
|
|
|
2005-02-08 21:03:52 +00:00
|
|
|
extern struct vop_vector ffs_vnodeops1;
|
|
|
|
|
extern struct vop_vector ffs_fifoops1;
|
|
|
|
|
extern struct vop_vector ffs_vnodeops2;
|
|
|
|
|
extern struct vop_vector ffs_fifoops2;
|
1996-05-01 02:16:17 +00:00
|
|
|
|
1998-03-08 09:59:44 +00:00
|
|
|
/*
|
|
|
|
|
* Soft update function prototypes.
|
|
|
|
|
*/
|
2006-03-08 23:43:39 +00:00
|
|
|
|
|
|
|
|
int softdep_check_suspend(struct mount *, struct vnode *,
|
|
|
|
|
int, int, int, int);
|
|
|
|
|
void softdep_get_depcounts(struct mount *, int *, int *);
|
2002-03-19 22:40:48 +00:00
|
|
|
void softdep_initialize(void);
|
2002-07-01 11:00:47 +00:00
|
|
|
void softdep_uninitialize(void);
|
2002-03-19 22:40:48 +00:00
|
|
|
int softdep_mount(struct vnode *, struct mount *, struct fs *,
|
|
|
|
|
struct ucred *);
|
2010-04-24 07:05:35 +00:00
|
|
|
void softdep_unmount(struct mount *);
|
This commit enables a UFS filesystem to do a forcible unmount when
the underlying media fails or becomes inaccessible. For example
when a USB flash memory card hosting a UFS filesystem is unplugged.
The strategy for handling disk I/O errors when soft updates are
enabled is to stop writing to the disk of the affected file system
but continue to accept I/O requests and report that all future
writes by the file system to that disk actually succeed. Then
initiate an asynchronous forced unmount of the affected file system.
There are two cases for disk I/O errors:
- ENXIO, which means that this disk is gone and the lower layers
of the storage stack already guarantee that no future I/O to
this disk will succeed.
- EIO (or most other errors), which means that this particular
I/O request has failed but subsequent I/O requests to this
disk might still succeed.
For ENXIO, we can just clear the error and continue, because we
know that the file system cannot affect the on-disk state after we
see this error. For EIO or other errors, we arrange for the geom_vfs
layer to reject all future I/O requests with ENXIO just like is
done when the geom_vfs is orphaned. In both cases, the file system
code can just clear the error and proceed with the forcible unmount.
This new treatment of I/O errors is needed for writes of any buffer
that is involved in a dependency. Most dependencies are described
by a structure attached to the buffer's b_dep field. But some are
created and processed as a result of the completion of the dependencies
attached to the buffer.
Clearing of some dependencies require a read. For example if there
is a dependency that requires an inode to be written, the disk block
containing that inode must be read, the updated inode copied into
place in that buffer, and the buffer then written back to disk.
Often the needed buffer is already in memory and can be used. But
if it needs to be read from the disk, the read will fail, so we
fabricate a buffer full of zeroes and pretend that the read succeeded.
This zero'ed buffer can be updated and written back to disk.
The only case where a buffer full of zeros causes the code to do
the wrong thing is when reading an inode buffer containing an inode
that still has an inode dependency in memory that will reinitialize
the effective link count (i_effnlink) based on the actual link count
(i_nlink) that we read. To handle this case we now store the i_nlink
value that we wrote in the inode dependency so that it can be
restored into the zero'ed buffer thus keeping the tracking of the
inode link count consistent.
Because applications depend on knowing when an attempt to write
their data to stable storage has failed, the fsync(2) and msync(2)
system calls need to return errors if data fails to be written to
stable storage. So these operations return ENXIO for every call
made on files in a file system where we have otherwise been ignoring
I/O errors.
Coauthered by: mckusick
Reviewed by: kib
Tested by: Peter Holm
Approved by: mckusick (mentor)
Sponsored by: Netflix
Differential Revision: https://reviews.freebsd.org/D24088
2020-05-25 23:47:31 +00:00
|
|
|
void softdep_handle_error(struct buf *);
|
2010-04-24 07:05:35 +00:00
|
|
|
int softdep_move_dependencies(struct buf *, struct buf *);
|
2002-03-19 22:40:48 +00:00
|
|
|
int softdep_flushworklist(struct mount *, int *, struct thread *);
|
|
|
|
|
int softdep_flushfiles(struct mount *, int, struct thread *);
|
|
|
|
|
void softdep_update_inodeblock(struct inode *, struct buf *, int);
|
|
|
|
|
void softdep_load_inodeblock(struct inode *);
|
|
|
|
|
void softdep_freefile(struct vnode *, ino_t, int);
|
2011-04-05 21:26:05 +00:00
|
|
|
int softdep_request_cleanup(struct fs *, struct vnode *,
|
|
|
|
|
struct ucred *, int);
|
Handle LoR in flush_pagedep_deps().
When operating in SU or SU+J mode, ffs_syncvnode() might need to
instantiate other vnode by inode number while owning syncing vnode
lock. Typically this other vnode is the parent of our vnode, but due
to renames occuring right before fsync (or during fsync when we drop
the syncing vnode lock, see below) it might be no longer parent.
More, the called function flush_pagedep_deps() needs to lock other
vnode while owning the lock for vnode which owns the buffer, for which
the dependencies are flushed. This creates another instance of the
same LoR as was fixed in softdep_sync().
Put the generic code for safe relocking into new SU helper
get_parent_vp() and use it in flush_pagedep_deps(). The case for safe
relocking of two vnodes with undefined lock order was extracted into
vn helper vn_lock_pair().
Due to call sequence
ffs_syncvnode()->softdep_sync_buf()->flush_pagedep_deps(),
ffs_syncvnode() indicates with ERELOOKUP that passed vnode was
unlocked in process, and can return ENOENT if the passed vnode
reclaimed. All callers of the function were inspected.
Because UFS namei lookups store auxiliary information about directory
entry in in-memory directory inode, and this information is then used
by UFS code that creates/removed directory entry in the actual
mutating VOPs, it is critical that directory vnode lock is not dropped
between lookup and VOP. For softdep_prelink(), which ensures that
later link/unlink operation can proceed without overflowing the
journal, calls were moved to the place where it is safe to drop
processing VOP because mutations are not yet applied. Then, ERELOOKUP
causes restart of the whole VFS operation (typically VFS syscall) at
top level, including the re-lookup of the involved pathes. [Note that
we already do the same restart for failing calls to vn_start_write(),
so formally this patch does not introduce new behavior.]
Similarly, unsafe calls to fsync in snapshot creation code were
plugged. A possible view on these failures is that it does not make
sense to continue creating snapshot if the snapshot vnode was
reclaimed due to forced unmount.
It is possible that relock/ERELOOKUP situation occurs in
ffs_truncate() called from ufs_inactive(). In this case, dropping the
vnode lock is not safe. Detect the situation with VI_DOINGINACT and
reschedule inactivation by setting VI_OWEINACT. ufs_inactive()
rechecks VI_OWEINACT and avoids reclaiming vnode is truncation failed
this way.
In ffs_truncate(), allocation of the EOF block for partial truncation
is re-done after vnode is synced, since we cannot leave the buffer
locked through ffs_syncvnode().
In collaboration with: pho
Reviewed by: mckusick (previous version), markj
Tested by: markj (syzkaller), pho
Sponsored by: The FreeBSD Foundation
Differential revision: https://reviews.freebsd.org/D26136
2020-11-14 05:30:10 +00:00
|
|
|
int softdep_prerename(struct vnode *, struct vnode *, struct vnode *,
|
|
|
|
|
struct vnode *);
|
|
|
|
|
int softdep_prelink(struct vnode *, struct vnode *, int);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
void softdep_setup_freeblocks(struct inode *, off_t, int);
|
2011-06-20 03:25:09 +00:00
|
|
|
void softdep_setup_inomapdep(struct buf *, struct inode *, ino_t, int);
|
2010-04-24 07:05:35 +00:00
|
|
|
void softdep_setup_blkmapdep(struct buf *, struct mount *, ufs2_daddr_t,
|
|
|
|
|
int, int);
|
2002-06-21 06:18:05 +00:00
|
|
|
void softdep_setup_allocdirect(struct inode *, ufs_lbn_t, ufs2_daddr_t,
|
|
|
|
|
ufs2_daddr_t, long, long, struct buf *);
|
Add support to UFS2 to provide storage for extended attributes.
As this code is not actually used by any of the existing
interfaces, it seems unlikely to break anything (famous
last words).
The internal kernel interface to manipulate these attributes
is invoked using two new IO_ flags: IO_NORMAL and IO_EXT.
These flags may be specified in the ioflags word of VOP_READ,
VOP_WRITE, and VOP_TRUNCATE. Specifying IO_NORMAL means that
you want to do I/O to the normal data part of the file and
IO_EXT means that you want to do I/O to the extended attributes
part of the file. IO_NORMAL and IO_EXT are mutually exclusive
for VOP_READ and VOP_WRITE, but may be specified individually
or together in the case of VOP_TRUNCATE. For example, when
removing a file, VOP_TRUNCATE is called with both IO_NORMAL
and IO_EXT set. For backward compatibility, if neither IO_NORMAL
nor IO_EXT is set, then IO_NORMAL is assumed.
Note that the BA_ and IO_ flags have been `merged' so that they
may both be used in the same flags word. This merger is possible
by assigning the IO_ flags to the low sixteen bits and the BA_
flags the high sixteen bits. This works because the high sixteen
bits of the IO_ word is reserved for read-ahead and help with
write clustering so will never be used for flags. This merge
lets us get away from code of the form:
if (ioflags & IO_SYNC)
flags |= BA_SYNC;
For the future, I have considered adding a new field to the
vattr structure, va_extsize. This addition could then be
exported through the stat structure to allow applications to
find out the size of the extended attribute storage and also
would provide a more standard interface for truncating them
(via VOP_SETATTR rather than VOP_TRUNCATE).
I am also contemplating adding a pathconf parameter (for
concreteness, lets call it _PC_MAX_EXTSIZE) which would
let an application determine the maximum size of the extended
atribute storage.
Sponsored by: DARPA & NAI Labs.
2002-07-19 07:29:39 +00:00
|
|
|
void softdep_setup_allocext(struct inode *, ufs_lbn_t, ufs2_daddr_t,
|
|
|
|
|
ufs2_daddr_t, long, long, struct buf *);
|
2002-03-19 22:40:48 +00:00
|
|
|
void softdep_setup_allocindir_meta(struct buf *, struct inode *,
|
2002-06-21 06:18:05 +00:00
|
|
|
struct buf *, int, ufs2_daddr_t);
|
2002-03-19 22:40:48 +00:00
|
|
|
void softdep_setup_allocindir_page(struct inode *, ufs_lbn_t,
|
2002-06-21 06:18:05 +00:00
|
|
|
struct buf *, int, ufs2_daddr_t, ufs2_daddr_t, struct buf *);
|
2010-04-24 07:05:35 +00:00
|
|
|
void softdep_setup_blkfree(struct mount *, struct buf *, ufs2_daddr_t, int,
|
|
|
|
|
struct workhead *);
|
|
|
|
|
void softdep_setup_inofree(struct mount *, struct buf *, ino_t,
|
|
|
|
|
struct workhead *);
|
|
|
|
|
void softdep_setup_sbupdate(struct ufsmount *, struct fs *, struct buf *);
|
2002-03-19 22:40:48 +00:00
|
|
|
void softdep_fsync_mountdev(struct vnode *);
|
2005-02-08 16:25:50 +00:00
|
|
|
int softdep_sync_metadata(struct vnode *);
|
2011-06-10 22:48:35 +00:00
|
|
|
int softdep_sync_buf(struct vnode *, struct buf *, int);
|
2006-03-02 05:50:23 +00:00
|
|
|
int softdep_fsync(struct vnode *);
|
2010-04-24 07:05:35 +00:00
|
|
|
int softdep_prealloc(struct vnode *, int);
|
|
|
|
|
int softdep_journal_lookup(struct mount *, struct vnode **);
|
2011-06-10 22:48:35 +00:00
|
|
|
void softdep_journal_freeblocks(struct inode *, struct ucred *, off_t, int);
|
|
|
|
|
void softdep_journal_fsync(struct inode *);
|
2011-06-12 19:27:05 +00:00
|
|
|
void softdep_buf_append(struct buf *, struct workhead *);
|
|
|
|
|
void softdep_inode_append(struct inode *, struct ucred *, struct workhead *);
|
|
|
|
|
void softdep_freework(struct workhead *);
|
2011-06-10 22:48:35 +00:00
|
|
|
|
2011-03-23 05:13:54 +00:00
|
|
|
/*
|
|
|
|
|
* Things to request flushing in softdep_request_cleanup()
|
|
|
|
|
*/
|
2014-03-02 02:52:34 +00:00
|
|
|
#define FLUSH_INODES 1
|
|
|
|
|
#define FLUSH_INODES_WAIT 2
|
|
|
|
|
#define FLUSH_BLOCKS 3
|
|
|
|
|
#define FLUSH_BLOCKS_WAIT 4
|
2012-03-01 18:45:25 +00:00
|
|
|
/*
|
2012-03-25 00:02:37 +00:00
|
|
|
* Flag to ffs_syncvnode() to request flushing of data only,
|
2012-03-01 18:45:25 +00:00
|
|
|
* but skip the ffs_update() on the inode itself. Used to avoid
|
|
|
|
|
* deadlock when flushing snapshot inodes while holding snaplk.
|
|
|
|
|
*/
|
2012-03-25 00:02:37 +00:00
|
|
|
#define NO_INO_UPDT 0x00000001
|
2016-08-15 19:22:23 +00:00
|
|
|
/*
|
|
|
|
|
* Request data sync only from ffs_syncvnode(), not touching even more
|
|
|
|
|
* metadata than NO_INO_UPDT.
|
|
|
|
|
*/
|
|
|
|
|
#define DATA_ONLY 0x00000002
|
1998-03-08 09:59:44 +00:00
|
|
|
|
2008-09-16 10:59:35 +00:00
|
|
|
int ffs_rdonly(struct inode *);
|
|
|
|
|
|
2011-06-12 19:27:05 +00:00
|
|
|
TAILQ_HEAD(snaphead, inode);
|
|
|
|
|
|
|
|
|
|
struct snapdata {
|
|
|
|
|
LIST_ENTRY(snapdata) sn_link;
|
|
|
|
|
struct snaphead sn_head;
|
|
|
|
|
daddr_t sn_listsize;
|
|
|
|
|
daddr_t *sn_blklist;
|
|
|
|
|
struct lock sn_lock;
|
|
|
|
|
};
|
2011-06-16 23:40:10 +00:00
|
|
|
|
2011-06-13 16:05:41 +00:00
|
|
|
#endif /* _KERNEL */
|
2011-06-12 19:27:05 +00:00
|
|
|
|
1996-05-01 02:16:17 +00:00
|
|
|
#endif /* !_UFS_FFS_EXTERN_H */
|
