2008-11-20 20:01:55 +00:00
|
|
|
/*
|
|
|
|
|
* CDDL HEADER START
|
|
|
|
|
*
|
|
|
|
|
* The contents of this file are subject to the terms of the
|
|
|
|
|
* Common Development and Distribution License (the "License").
|
|
|
|
|
* You may not use this file except in compliance with the License.
|
|
|
|
|
*
|
|
|
|
|
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
|
|
|
* or http://www.opensolaris.org/os/licensing.
|
|
|
|
|
* See the License for the specific language governing permissions
|
|
|
|
|
* and limitations under the License.
|
|
|
|
|
*
|
|
|
|
|
* When distributing Covered Code, include this CDDL HEADER in each
|
|
|
|
|
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
|
|
|
* If applicable, add the following below this CDDL HEADER, with the
|
|
|
|
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
|
|
|
|
* information: Portions Copyright [yyyy] [name of copyright owner]
|
|
|
|
|
*
|
|
|
|
|
* CDDL HEADER END
|
|
|
|
|
*/
|
|
|
|
|
/*
|
2010-08-26 21:24:34 +00:00
|
|
|
* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
|
2018-10-01 22:13:12 +00:00
|
|
|
* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
|
2017-01-27 19:46:39 +00:00
|
|
|
* Copyright 2016 Nexenta Systems, Inc. All rights reserved.
|
2008-11-20 20:01:55 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _SYS_FS_ZFS_ZNODE_H
|
|
|
|
|
#define _SYS_FS_ZFS_ZNODE_H
|
|
|
|
|
|
|
|
|
|
#ifdef _KERNEL
|
|
|
|
|
#include <sys/isa_defs.h>
|
|
|
|
|
#include <sys/types32.h>
|
|
|
|
|
#include <sys/list.h>
|
|
|
|
|
#include <sys/dmu.h>
|
2010-05-28 20:45:14 +00:00
|
|
|
#include <sys/sa.h>
|
2008-11-20 20:01:55 +00:00
|
|
|
#include <sys/zfs_vfsops.h>
|
|
|
|
|
#include <sys/rrwlock.h>
|
2010-05-28 20:45:14 +00:00
|
|
|
#include <sys/zfs_sa.h>
|
2010-08-26 21:24:34 +00:00
|
|
|
#include <sys/zfs_stat.h>
|
2016-04-11 21:53:48 +00:00
|
|
|
#include <sys/zfs_rlock.h>
|
2008-11-20 20:01:55 +00:00
|
|
|
#endif
|
|
|
|
|
#include <sys/zfs_acl.h>
|
|
|
|
|
#include <sys/zil.h>
|
2018-02-13 22:54:54 +00:00
|
|
|
#include <sys/zfs_project.h>
|
2008-11-20 20:01:55 +00:00
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Additional file level attributes, that are stored
|
|
|
|
|
* in the upper half of zp_flags
|
|
|
|
|
*/
|
2010-08-26 16:52:39 +00:00
|
|
|
#define ZFS_READONLY 0x0000000100000000ull
|
|
|
|
|
#define ZFS_HIDDEN 0x0000000200000000ull
|
|
|
|
|
#define ZFS_SYSTEM 0x0000000400000000ull
|
|
|
|
|
#define ZFS_ARCHIVE 0x0000000800000000ull
|
|
|
|
|
#define ZFS_IMMUTABLE 0x0000001000000000ull
|
|
|
|
|
#define ZFS_NOUNLINK 0x0000002000000000ull
|
|
|
|
|
#define ZFS_APPENDONLY 0x0000004000000000ull
|
|
|
|
|
#define ZFS_NODUMP 0x0000008000000000ull
|
|
|
|
|
#define ZFS_OPAQUE 0x0000010000000000ull
|
2011-03-01 20:24:09 +00:00
|
|
|
#define ZFS_AV_QUARANTINED 0x0000020000000000ull
|
|
|
|
|
#define ZFS_AV_MODIFIED 0x0000040000000000ull
|
2010-08-26 16:52:39 +00:00
|
|
|
#define ZFS_REPARSE 0x0000080000000000ull
|
|
|
|
|
#define ZFS_OFFLINE 0x0000100000000000ull
|
|
|
|
|
#define ZFS_SPARSE 0x0000200000000000ull
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2018-02-13 22:54:54 +00:00
|
|
|
/*
|
|
|
|
|
* PROJINHERIT attribute is used to indicate that the child object under the
|
|
|
|
|
* directory which has the PROJINHERIT attribute needs to inherit its parent
|
|
|
|
|
* project ID that is used by project quota.
|
|
|
|
|
*/
|
|
|
|
|
#define ZFS_PROJINHERIT 0x0000400000000000ull
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* PROJID attr is used internally to indicate that the object has project ID.
|
|
|
|
|
*/
|
|
|
|
|
#define ZFS_PROJID 0x0000800000000000ull
|
|
|
|
|
|
2010-05-28 20:45:14 +00:00
|
|
|
#define ZFS_ATTR_SET(zp, attr, value, pflags, tx) \
|
2008-11-20 20:01:55 +00:00
|
|
|
{ \
|
|
|
|
|
if (value) \
|
2010-05-28 20:45:14 +00:00
|
|
|
pflags |= attr; \
|
2008-11-20 20:01:55 +00:00
|
|
|
else \
|
2010-05-28 20:45:14 +00:00
|
|
|
pflags &= ~attr; \
|
2011-03-01 20:24:09 +00:00
|
|
|
VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_FLAGS(ZTOZSB(zp)), \
|
2010-05-28 20:45:14 +00:00
|
|
|
&pflags, sizeof (pflags), tx)); \
|
2008-11-20 20:01:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Define special zfs pflags
|
|
|
|
|
*/
|
|
|
|
|
#define ZFS_XATTR 0x1 /* is an extended attribute */
|
|
|
|
|
#define ZFS_INHERIT_ACE 0x2 /* ace has inheritable ACEs */
|
2011-03-01 20:24:09 +00:00
|
|
|
#define ZFS_ACL_TRIVIAL 0x4 /* files ACL is trivial */
|
|
|
|
|
#define ZFS_ACL_OBJ_ACE 0x8 /* ACL has CMPLX Object ACE */
|
2008-11-20 20:01:55 +00:00
|
|
|
#define ZFS_ACL_PROTECTED 0x10 /* ACL protected */
|
|
|
|
|
#define ZFS_ACL_DEFAULTED 0x20 /* ACL should be defaulted */
|
|
|
|
|
#define ZFS_ACL_AUTO_INHERIT 0x40 /* ACL should be inherited */
|
|
|
|
|
#define ZFS_BONUS_SCANSTAMP 0x80 /* Scanstamp in bonus area */
|
2009-08-18 18:43:27 +00:00
|
|
|
#define ZFS_NO_EXECS_DENIED 0x100 /* exec was given to everyone */
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2010-05-28 20:45:14 +00:00
|
|
|
#define SA_ZPL_ATIME(z) z->z_attr_table[ZPL_ATIME]
|
|
|
|
|
#define SA_ZPL_MTIME(z) z->z_attr_table[ZPL_MTIME]
|
|
|
|
|
#define SA_ZPL_CTIME(z) z->z_attr_table[ZPL_CTIME]
|
|
|
|
|
#define SA_ZPL_CRTIME(z) z->z_attr_table[ZPL_CRTIME]
|
|
|
|
|
#define SA_ZPL_GEN(z) z->z_attr_table[ZPL_GEN]
|
|
|
|
|
#define SA_ZPL_DACL_ACES(z) z->z_attr_table[ZPL_DACL_ACES]
|
|
|
|
|
#define SA_ZPL_XATTR(z) z->z_attr_table[ZPL_XATTR]
|
|
|
|
|
#define SA_ZPL_SYMLINK(z) z->z_attr_table[ZPL_SYMLINK]
|
|
|
|
|
#define SA_ZPL_RDEV(z) z->z_attr_table[ZPL_RDEV]
|
|
|
|
|
#define SA_ZPL_SCANSTAMP(z) z->z_attr_table[ZPL_SCANSTAMP]
|
|
|
|
|
#define SA_ZPL_UID(z) z->z_attr_table[ZPL_UID]
|
|
|
|
|
#define SA_ZPL_GID(z) z->z_attr_table[ZPL_GID]
|
|
|
|
|
#define SA_ZPL_PARENT(z) z->z_attr_table[ZPL_PARENT]
|
|
|
|
|
#define SA_ZPL_LINKS(z) z->z_attr_table[ZPL_LINKS]
|
|
|
|
|
#define SA_ZPL_MODE(z) z->z_attr_table[ZPL_MODE]
|
|
|
|
|
#define SA_ZPL_DACL_COUNT(z) z->z_attr_table[ZPL_DACL_COUNT]
|
|
|
|
|
#define SA_ZPL_FLAGS(z) z->z_attr_table[ZPL_FLAGS]
|
|
|
|
|
#define SA_ZPL_SIZE(z) z->z_attr_table[ZPL_SIZE]
|
|
|
|
|
#define SA_ZPL_ZNODE_ACL(z) z->z_attr_table[ZPL_ZNODE_ACL]
|
2011-10-24 23:55:20 +00:00
|
|
|
#define SA_ZPL_DXATTR(z) z->z_attr_table[ZPL_DXATTR]
|
2010-05-28 20:45:14 +00:00
|
|
|
#define SA_ZPL_PAD(z) z->z_attr_table[ZPL_PAD]
|
2018-02-13 22:54:54 +00:00
|
|
|
#define SA_ZPL_PROJID(z) z->z_attr_table[ZPL_PROJID]
|
2010-05-28 20:45:14 +00:00
|
|
|
|
2008-11-20 20:01:55 +00:00
|
|
|
/*
|
|
|
|
|
* Is ID ephemeral?
|
|
|
|
|
*/
|
|
|
|
|
#define IS_EPHEMERAL(x) (x > MAXUID)
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Should we use FUIDs?
|
|
|
|
|
*/
|
2010-05-28 20:45:14 +00:00
|
|
|
#define USE_FUIDS(version, os) (version >= ZPL_VERSION_FUID && \
|
2008-11-20 20:01:55 +00:00
|
|
|
spa_version(dmu_objset_spa(os)) >= SPA_VERSION_FUID)
|
2010-05-28 20:45:14 +00:00
|
|
|
#define USE_SA(version, os) (version >= ZPL_VERSION_SA && \
|
|
|
|
|
spa_version(dmu_objset_spa(os)) >= SPA_VERSION_SA)
|
2008-11-20 20:01:55 +00:00
|
|
|
|
|
|
|
|
#define MASTER_NODE_OBJ 1
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Special attributes for master node.
|
2018-02-13 22:54:54 +00:00
|
|
|
* "userquota@", "groupquota@" and "projectquota@" are also valid (from
|
2009-07-02 22:44:48 +00:00
|
|
|
* zfs_userquota_prop_prefixes[]).
|
2008-11-20 20:01:55 +00:00
|
|
|
*/
|
|
|
|
|
#define ZFS_FSID "FSID"
|
|
|
|
|
#define ZFS_UNLINKED_SET "DELETE_QUEUE"
|
|
|
|
|
#define ZFS_ROOT_OBJ "ROOT"
|
|
|
|
|
#define ZPL_VERSION_STR "VERSION"
|
|
|
|
|
#define ZFS_FUID_TABLES "FUID"
|
2009-07-02 22:44:48 +00:00
|
|
|
#define ZFS_SHARES_DIR "SHARES"
|
2010-05-28 20:45:14 +00:00
|
|
|
#define ZFS_SA_ATTRS "SA_ATTRS"
|
2008-11-20 20:01:55 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Convert mode bits (zp_mode) to BSD-style DT_* values for storing in
|
2010-08-26 18:54:51 +00:00
|
|
|
* the directory entries. On Linux systems this value is already
|
|
|
|
|
* defined correctly as part of the /usr/include/dirent.h header file.
|
2008-11-20 20:01:55 +00:00
|
|
|
*/
|
2010-08-26 18:54:51 +00:00
|
|
|
#ifndef IFTODT
|
2008-11-20 20:01:55 +00:00
|
|
|
#define IFTODT(mode) (((mode) & S_IFMT) >> 12)
|
2010-08-26 18:54:51 +00:00
|
|
|
#endif
|
2008-11-20 20:01:55 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The directory entry has the type (currently unused on Solaris) in the
|
|
|
|
|
* top 4 bits, and the object number in the low 48 bits. The "middle"
|
|
|
|
|
* 12 bits are unused.
|
|
|
|
|
*/
|
|
|
|
|
#define ZFS_DIRENT_TYPE(de) BF64_GET(de, 60, 4)
|
|
|
|
|
#define ZFS_DIRENT_OBJ(de) BF64_GET(de, 0, 48)
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Directory entry locks control access to directory entries.
|
|
|
|
|
* They are used to protect creates, deletes, and renames.
|
|
|
|
|
* Each directory znode has a mutex and a list of locked names.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef _KERNEL
|
|
|
|
|
typedef struct zfs_dirlock {
|
|
|
|
|
char *dl_name; /* directory entry being locked */
|
|
|
|
|
uint32_t dl_sharecnt; /* 0 if exclusive, > 0 if shared */
|
2010-05-28 20:45:14 +00:00
|
|
|
uint8_t dl_namelock; /* 1 if z_name_lock is NOT held */
|
2008-11-20 20:01:55 +00:00
|
|
|
uint16_t dl_namesize; /* set if dl_name was allocated */
|
|
|
|
|
kcondvar_t dl_cv; /* wait for entry to be unlocked */
|
|
|
|
|
struct znode *dl_dzp; /* directory znode */
|
|
|
|
|
struct zfs_dirlock *dl_next; /* next in z_dirlocks list */
|
|
|
|
|
} zfs_dirlock_t;
|
|
|
|
|
|
|
|
|
|
typedef struct znode {
|
|
|
|
|
uint64_t z_id; /* object ID for this znode */
|
|
|
|
|
kmutex_t z_lock; /* znode modification lock */
|
|
|
|
|
krwlock_t z_parent_lock; /* parent lock for directories */
|
|
|
|
|
krwlock_t z_name_lock; /* "master" lock for dirent locks */
|
|
|
|
|
zfs_dirlock_t *z_dirlocks; /* directory entry lock list */
|
2019-11-01 17:37:33 +00:00
|
|
|
zfs_rangelock_t z_rangelock; /* file range locks */
|
2019-08-13 13:58:02 +00:00
|
|
|
boolean_t z_unlinked; /* file has been unlinked */
|
|
|
|
|
boolean_t z_atime_dirty; /* atime needs to be synced */
|
|
|
|
|
boolean_t z_zn_prefetch; /* Prefetch znodes? */
|
|
|
|
|
boolean_t z_moved; /* Has this znode been moved? */
|
|
|
|
|
boolean_t z_is_sa; /* are we native sa? */
|
|
|
|
|
boolean_t z_is_mapped; /* are we mmap'ed */
|
|
|
|
|
boolean_t z_is_ctldir; /* are we .zfs entry */
|
|
|
|
|
boolean_t z_is_stale; /* are we stale due to rollback? */
|
2019-08-27 16:55:51 +00:00
|
|
|
boolean_t z_suspended; /* extra ref from a suspend? */
|
2008-11-20 20:01:55 +00:00
|
|
|
uint_t z_blksz; /* block size in bytes */
|
|
|
|
|
uint_t z_seq; /* modification sequence number */
|
|
|
|
|
uint64_t z_mapcnt; /* number of pages mapped to file */
|
Implement large_dnode pool feature
Justification
-------------
This feature adds support for variable length dnodes. Our motivation is
to eliminate the overhead associated with using spill blocks. Spill
blocks are used to store system attribute data (i.e. file metadata) that
does not fit in the dnode's bonus buffer. By allowing a larger bonus
buffer area the use of a spill block can be avoided. Spill blocks
potentially incur an additional read I/O for every dnode in a dnode
block. As a worst case example, reading 32 dnodes from a 16k dnode block
and all of the spill blocks could issue 33 separate reads. Now suppose
those dnodes have size 1024 and therefore don't need spill blocks. Then
the worst case number of blocks read is reduced to from 33 to two--one
per dnode block. In practice spill blocks may tend to be co-located on
disk with the dnode blocks so the reduction in I/O would not be this
drastic. In a badly fragmented pool, however, the improvement could be
significant.
ZFS-on-Linux systems that make heavy use of extended attributes would
benefit from this feature. In particular, ZFS-on-Linux supports the
xattr=sa dataset property which allows file extended attribute data
to be stored in the dnode bonus buffer as an alternative to the
traditional directory-based format. Workloads such as SELinux and the
Lustre distributed filesystem often store enough xattr data to force
spill bocks when xattr=sa is in effect. Large dnodes may therefore
provide a performance benefit to such systems.
Other use cases that may benefit from this feature include files with
large ACLs and symbolic links with long target names. Furthermore,
this feature may be desirable on other platforms in case future
applications or features are developed that could make use of a
larger bonus buffer area.
Implementation
--------------
The size of a dnode may be a multiple of 512 bytes up to the size of
a dnode block (currently 16384 bytes). A dn_extra_slots field was
added to the current on-disk dnode_phys_t structure to describe the
size of the physical dnode on disk. The 8 bits for this field were
taken from the zero filled dn_pad2 field. The field represents how
many "extra" dnode_phys_t slots a dnode consumes in its dnode block.
This convention results in a value of 0 for 512 byte dnodes which
preserves on-disk format compatibility with older software.
Similarly, the in-memory dnode_t structure has a new dn_num_slots field
to represent the total number of dnode_phys_t slots consumed on disk.
Thus dn->dn_num_slots is 1 greater than the corresponding
dnp->dn_extra_slots. This difference in convention was adopted
because, unlike on-disk structures, backward compatibility is not a
concern for in-memory objects, so we used a more natural way to
represent size for a dnode_t.
The default size for newly created dnodes is determined by the value of
a new "dnodesize" dataset property. By default the property is set to
"legacy" which is compatible with older software. Setting the property
to "auto" will allow the filesystem to choose the most suitable dnode
size. Currently this just sets the default dnode size to 1k, but future
code improvements could dynamically choose a size based on observed
workload patterns. Dnodes of varying sizes can coexist within the same
dataset and even within the same dnode block. For example, to enable
automatically-sized dnodes, run
# zfs set dnodesize=auto tank/fish
The user can also specify literal values for the dnodesize property.
These are currently limited to powers of two from 1k to 16k. The
power-of-2 limitation is only for simplicity of the user interface.
Internally the implementation can handle any multiple of 512 up to 16k,
and consumers of the DMU API can specify any legal dnode value.
The size of a new dnode is determined at object allocation time and
stored as a new field in the znode in-memory structure. New DMU
interfaces are added to allow the consumer to specify the dnode size
that a newly allocated object should use. Existing interfaces are
unchanged to avoid having to update every call site and to preserve
compatibility with external consumers such as Lustre. The new
interfaces names are given below. The versions of these functions that
don't take a dnodesize parameter now just call the _dnsize() versions
with a dnodesize of 0, which means use the legacy dnode size.
New DMU interfaces:
dmu_object_alloc_dnsize()
dmu_object_claim_dnsize()
dmu_object_reclaim_dnsize()
New ZAP interfaces:
zap_create_dnsize()
zap_create_norm_dnsize()
zap_create_flags_dnsize()
zap_create_claim_norm_dnsize()
zap_create_link_dnsize()
The constant DN_MAX_BONUSLEN is renamed to DN_OLD_MAX_BONUSLEN. The
spa_maxdnodesize() function should be used to determine the maximum
bonus length for a pool.
These are a few noteworthy changes to key functions:
* The prototype for dnode_hold_impl() now takes a "slots" parameter.
When the DNODE_MUST_BE_FREE flag is set, this parameter is used to
ensure the hole at the specified object offset is large enough to
hold the dnode being created. The slots parameter is also used
to ensure a dnode does not span multiple dnode blocks. In both of
these cases, if a failure occurs, ENOSPC is returned. Keep in mind,
these failure cases are only possible when using DNODE_MUST_BE_FREE.
If the DNODE_MUST_BE_ALLOCATED flag is set, "slots" must be 0.
dnode_hold_impl() will check if the requested dnode is already
consumed as an extra dnode slot by an large dnode, in which case
it returns ENOENT.
* The function dmu_object_alloc() advances to the next dnode block
if dnode_hold_impl() returns an error for a requested object.
This is because the beginning of the next dnode block is the only
location it can safely assume to either be a hole or a valid
starting point for a dnode.
* dnode_next_offset_level() and other functions that iterate
through dnode blocks may no longer use a simple array indexing
scheme. These now use the current dnode's dn_num_slots field to
advance to the next dnode in the block. This is to ensure we
properly skip the current dnode's bonus area and don't interpret it
as a valid dnode.
zdb
---
The zdb command was updated to display a dnode's size under the
"dnsize" column when the object is dumped.
For ZIL create log records, zdb will now display the slot count for
the object.
ztest
-----
Ztest chooses a random dnodesize for every newly created object. The
random distribution is more heavily weighted toward small dnodes to
better simulate real-world datasets.
Unused bonus buffer space is filled with non-zero values computed from
the object number, dataset id, offset, and generation number. This
helps ensure that the dnode traversal code properly skips the interior
regions of large dnodes, and that these interior regions are not
overwritten by data belonging to other dnodes. A new test visits each
object in a dataset. It verifies that the actual dnode size matches what
was stored in the ztest block tag when it was created. It also verifies
that the unused bonus buffer space is filled with the expected data
patterns.
ZFS Test Suite
--------------
Added six new large dnode-specific tests, and integrated the dnodesize
property into existing tests for zfs allow and send/recv.
Send/Receive
------------
ZFS send streams for datasets containing large dnodes cannot be received
on pools that don't support the large_dnode feature. A send stream with
large dnodes sets a DMU_BACKUP_FEATURE_LARGE_DNODE flag which will be
unrecognized by an incompatible receiving pool so that the zfs receive
will fail gracefully.
While not implemented here, it may be possible to generate a
backward-compatible send stream from a dataset containing large
dnodes. The implementation may be tricky, however, because the send
object record for a large dnode would need to be resized to a 512
byte dnode, possibly kicking in a spill block in the process. This
means we would need to construct a new SA layout and possibly
register it in the SA layout object. The SA layout is normally just
sent as an ordinary object record. But if we are constructing new
layouts while generating the send stream we'd have to build the SA
layout object dynamically and send it at the end of the stream.
For sending and receiving between pools that do support large dnodes,
the drr_object send record type is extended with a new field to store
the dnode slot count. This field was repurposed from unused padding
in the structure.
ZIL Replay
----------
The dnode slot count is stored in the uppermost 8 bits of the lr_foid
field. The bits were unused as the object id is currently capped at
48 bits.
Resizing Dnodes
---------------
It should be possible to resize a dnode when it is dirtied if the
current dnodesize dataset property differs from the dnode's size, but
this functionality is not currently implemented. Clearly a dnode can
only grow if there are sufficient contiguous unused slots in the
dnode block, but it should always be possible to shrink a dnode.
Growing dnodes may be useful to reduce fragmentation in a pool with
many spill blocks in use. Shrinking dnodes may be useful to allow
sending a dataset to a pool that doesn't support the large_dnode
feature.
Feature Reference Counting
--------------------------
The reference count for the large_dnode pool feature tracks the
number of datasets that have ever contained a dnode of size larger
than 512 bytes. The first time a large dnode is created in a dataset
the dataset is converted to an extensible dataset. This is a one-way
operation and the only way to decrement the feature count is to
destroy the dataset, even if the dataset no longer contains any large
dnodes. The complexity of reference counting on a per-dnode basis was
too high, so we chose to track it on a per-dataset basis similarly to
the large_block feature.
Signed-off-by: Ned Bass <bass6@llnl.gov>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #3542
2016-03-17 01:25:34 +00:00
|
|
|
uint64_t z_dnodesize; /* dnode size */
|
2010-05-28 20:45:14 +00:00
|
|
|
uint64_t z_size; /* file size (cached) */
|
|
|
|
|
uint64_t z_pflags; /* pflags (cached) */
|
2008-11-20 20:01:55 +00:00
|
|
|
uint32_t z_sync_cnt; /* synchronous open count */
|
2014-01-07 22:16:46 +00:00
|
|
|
mode_t z_mode; /* mode (cached) */
|
2008-11-20 20:01:55 +00:00
|
|
|
kmutex_t z_acl_lock; /* acl data lock */
|
2009-08-18 18:43:27 +00:00
|
|
|
zfs_acl_t *z_acl_cached; /* cached acl */
|
2011-10-24 23:55:20 +00:00
|
|
|
krwlock_t z_xattr_lock; /* xattr data lock */
|
2013-11-01 19:26:11 +00:00
|
|
|
nvlist_t *z_xattr_cached; /* cached xattrs */
|
2016-10-13 00:30:46 +00:00
|
|
|
uint64_t z_xattr_parent; /* parent obj for this xattr */
|
2018-02-13 22:54:54 +00:00
|
|
|
uint64_t z_projid; /* project ID */
|
2008-11-20 20:01:55 +00:00
|
|
|
list_node_t z_link_node; /* all znodes in fs link */
|
2010-05-28 20:45:14 +00:00
|
|
|
sa_handle_t *z_sa_hdl; /* handle to sa data */
|
2011-01-05 21:16:12 +00:00
|
|
|
struct inode z_inode; /* generic vfs inode */
|
2008-11-20 20:01:55 +00:00
|
|
|
} znode_t;
|
|
|
|
|
|
2015-12-22 21:47:38 +00:00
|
|
|
typedef struct znode_hold {
|
|
|
|
|
uint64_t zh_obj; /* object id */
|
|
|
|
|
kmutex_t zh_lock; /* lock serializing object access */
|
|
|
|
|
avl_node_t zh_node; /* avl tree linkage */
|
2018-09-26 17:29:26 +00:00
|
|
|
zfs_refcount_t zh_refcount; /* active consumer reference count */
|
2015-12-22 21:47:38 +00:00
|
|
|
} znode_hold_t;
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2018-02-13 22:54:54 +00:00
|
|
|
static inline uint64_t
|
|
|
|
|
zfs_inherit_projid(znode_t *dzp)
|
|
|
|
|
{
|
|
|
|
|
return ((dzp->z_pflags & ZFS_PROJINHERIT) ? dzp->z_projid :
|
|
|
|
|
ZFS_DEFAULT_PROJID);
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-20 20:01:55 +00:00
|
|
|
/*
|
|
|
|
|
* Range locking rules
|
|
|
|
|
* --------------------
|
|
|
|
|
* 1. When truncating a file (zfs_create, zfs_setattr, zfs_space) the whole
|
|
|
|
|
* file range needs to be locked as RL_WRITER. Only then can the pages be
|
|
|
|
|
* freed etc and zp_size reset. zp_size must be set within range lock.
|
|
|
|
|
* 2. For writes and punching holes (zfs_write & zfs_space) just the range
|
|
|
|
|
* being written or freed needs to be locked as RL_WRITER.
|
|
|
|
|
* Multiple writes at the end of the file must coordinate zp_size updates
|
|
|
|
|
* to ensure data isn't lost. A compare and swap loop is currently used
|
|
|
|
|
* to ensure the file size is at least the offset last written.
|
|
|
|
|
* 3. For reads (zfs_read, zfs_get_data & zfs_putapage) just the range being
|
|
|
|
|
* read needs to be locked as RL_READER. A check against zp_size can then
|
|
|
|
|
* be made for reading beyond end of file.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
2011-01-05 21:16:12 +00:00
|
|
|
* Convert between znode pointers and inode pointers
|
2008-11-20 20:01:55 +00:00
|
|
|
*/
|
2011-02-08 19:16:06 +00:00
|
|
|
#define ZTOI(znode) (&((znode)->z_inode))
|
|
|
|
|
#define ITOZ(inode) (container_of((inode), znode_t, z_inode))
|
2017-03-08 00:21:37 +00:00
|
|
|
#define ZTOZSB(znode) ((zfsvfs_t *)(ZTOI(znode)->i_sb->s_fs_info))
|
|
|
|
|
#define ITOZSB(inode) ((zfsvfs_t *)((inode)->i_sb->s_fs_info))
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2019-10-02 16:15:12 +00:00
|
|
|
#define ZTOTYPE(zp) (ZTOI(zp)->i_mode)
|
|
|
|
|
#define ZTOGID(zp) (ZTOI(zp)->i_gid)
|
|
|
|
|
#define ZTOUID(zp) (ZTOI(zp)->i_uid)
|
|
|
|
|
#define ZTONLNK(zp) (ZTOI(zp)->i_nlink)
|
|
|
|
|
|
|
|
|
|
#define Z_ISBLK(type) S_ISBLK(type)
|
|
|
|
|
#define Z_ISCHR(type) S_ISCHR(type)
|
|
|
|
|
#define Z_ISLNK(type) S_ISLNK(type)
|
|
|
|
|
#define S_ISDEV(type) (S_ISCHR(type) || S_ISBLK(type) || S_ISFIFO(type))
|
2011-01-05 21:16:12 +00:00
|
|
|
|
2018-08-02 21:03:56 +00:00
|
|
|
/* Called on entry to each ZFS inode and vfs operation. */
|
|
|
|
|
#define ZFS_ENTER_ERROR(zfsvfs, error) \
|
|
|
|
|
do { \
|
|
|
|
|
rrm_enter_read(&(zfsvfs)->z_teardown_lock, FTAG); \
|
|
|
|
|
if ((zfsvfs)->z_unmounted) { \
|
|
|
|
|
ZFS_EXIT(zfsvfs); \
|
|
|
|
|
return (error); \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
#define ZFS_ENTER(zfsvfs) ZFS_ENTER_ERROR(zfsvfs, EIO)
|
|
|
|
|
#define ZPL_ENTER(zfsvfs) ZFS_ENTER_ERROR(zfsvfs, -EIO)
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2018-08-02 21:03:56 +00:00
|
|
|
/* Must be called before exiting the operation. */
|
|
|
|
|
#define ZFS_EXIT(zfsvfs) \
|
|
|
|
|
do { \
|
|
|
|
|
rrm_exit(&(zfsvfs)->z_teardown_lock, FTAG); \
|
|
|
|
|
} while (0)
|
|
|
|
|
#define ZPL_EXIT(zfsvfs) ZFS_EXIT(zfsvfs)
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2018-08-02 21:03:56 +00:00
|
|
|
/* Verifies the znode is valid. */
|
|
|
|
|
#define ZFS_VERIFY_ZP_ERROR(zp, error) \
|
|
|
|
|
do { \
|
|
|
|
|
if ((zp)->z_sa_hdl == NULL) { \
|
|
|
|
|
ZFS_EXIT(ZTOZSB(zp)); \
|
|
|
|
|
return (error); \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
#define ZFS_VERIFY_ZP(zp) ZFS_VERIFY_ZP_ERROR(zp, EIO)
|
|
|
|
|
#define ZPL_VERIFY_ZP(zp) ZFS_VERIFY_ZP_ERROR(zp, -EIO)
|
2008-11-20 20:01:55 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Macros for dealing with dmu_buf_hold
|
|
|
|
|
*/
|
2015-12-22 21:47:38 +00:00
|
|
|
#define ZFS_OBJ_MTX_SZ 64
|
|
|
|
|
#define ZFS_OBJ_MTX_MAX (1024 * 1024)
|
2017-03-08 00:21:37 +00:00
|
|
|
#define ZFS_OBJ_HASH(zfsvfs, obj) ((obj) & ((zfsvfs->z_hold_size) - 1))
|
2015-12-18 20:19:14 +00:00
|
|
|
|
|
|
|
|
extern unsigned int zfs_object_mutex_size;
|
|
|
|
|
|
2018-06-20 04:51:18 +00:00
|
|
|
/*
|
|
|
|
|
* Encode ZFS stored time values from a struct timespec / struct timespec64.
|
|
|
|
|
*/
|
2008-11-20 20:01:55 +00:00
|
|
|
#define ZFS_TIME_ENCODE(tp, stmp) \
|
2018-06-20 04:51:18 +00:00
|
|
|
do { \
|
2008-12-03 20:09:06 +00:00
|
|
|
(stmp)[0] = (uint64_t)(tp)->tv_sec; \
|
2008-11-20 20:01:55 +00:00
|
|
|
(stmp)[1] = (uint64_t)(tp)->tv_nsec; \
|
2018-06-20 04:51:18 +00:00
|
|
|
} while (0)
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2018-06-20 04:51:18 +00:00
|
|
|
#if defined(HAVE_INODE_TIMESPEC64_TIMES)
|
|
|
|
|
/*
|
|
|
|
|
* Decode ZFS stored time values to a struct timespec64
|
|
|
|
|
* 4.18 and newer kernels.
|
|
|
|
|
*/
|
2008-11-20 20:01:55 +00:00
|
|
|
#define ZFS_TIME_DECODE(tp, stmp) \
|
2018-06-20 04:51:18 +00:00
|
|
|
do { \
|
|
|
|
|
(tp)->tv_sec = (time64_t)(stmp)[0]; \
|
|
|
|
|
(tp)->tv_nsec = (long)(stmp)[1]; \
|
|
|
|
|
} while (0)
|
|
|
|
|
#else
|
|
|
|
|
/*
|
|
|
|
|
* Decode ZFS stored time values to a struct timespec
|
|
|
|
|
* 4.17 and older kernels.
|
|
|
|
|
*/
|
|
|
|
|
#define ZFS_TIME_DECODE(tp, stmp) \
|
|
|
|
|
do { \
|
|
|
|
|
(tp)->tv_sec = (time_t)(stmp)[0]; \
|
|
|
|
|
(tp)->tv_nsec = (long)(stmp)[1]; \
|
|
|
|
|
} while (0)
|
|
|
|
|
#endif /* HAVE_INODE_TIMESPEC64_TIMES */
|
2008-11-20 20:01:55 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Timestamp defines
|
|
|
|
|
*/
|
2011-02-08 19:16:06 +00:00
|
|
|
#define ACCESSED (ATTR_ATIME)
|
|
|
|
|
#define STATE_CHANGED (ATTR_CTIME)
|
|
|
|
|
#define CONTENT_MODIFIED (ATTR_MTIME | ATTR_CTIME)
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2017-03-08 00:21:37 +00:00
|
|
|
extern int zfs_init_fs(zfsvfs_t *, znode_t **);
|
2008-11-20 20:01:55 +00:00
|
|
|
extern void zfs_set_dataprop(objset_t *);
|
|
|
|
|
extern void zfs_create_fs(objset_t *os, cred_t *cr, nvlist_t *,
|
|
|
|
|
dmu_tx_t *tx);
|
2010-05-28 20:45:14 +00:00
|
|
|
extern void zfs_tstamp_update_setup(znode_t *, uint_t, uint64_t [2],
|
Fix atime handling and relatime
The problem for atime:
We have 3 places for atime: inode->i_atime, znode->z_atime and SA. And its
handling is a mess. A huge part of mess regarding atime comes from
zfs_tstamp_update_setup, zfs_inode_update, and zfs_getattr, which behave
inconsistently with those three values.
zfs_tstamp_update_setup clears z_atime_dirty unconditionally as long as you
don't pass ATTR_ATIME. Which means every write(2) operation which only updates
ctime and mtime will cause atime changes to not be written to disk.
Also zfs_inode_update from write(2) will replace inode->i_atime with what's
inside SA(stale). But doesn't touch z_atime. So after read(2) and write(2).
You'll have i_atime(stale), z_atime(new), SA(stale) and z_atime_dirty=0.
Now, if you do stat(2), zfs_getattr will actually replace i_atime with what's
inside, z_atime. So you will have now you'll have i_atime(new), z_atime(new),
SA(stale) and z_atime_dirty=0. These will all gone after umount. And you'll
leave with a stale atime.
The problem for relatime:
We do have a relatime config inside ZFS dataset, but how it should interact
with the mount flag MS_RELATIME is not well defined. It seems it wanted
relatime mount option to override the dataset config by showing it as
temporary in `zfs get`. But at the same time, `zfs set relatime=on|off` would
also seems to want to override the mount option. Not to mention that
MS_RELATIME flag is actually never passed into ZFS, so it never really worked.
How Linux handles atime:
The Linux kernel actually handles atime completely in VFS, except for writing
it to disk. So if we remove the atime handling in ZFS, things would just work,
no matter it's strictatime, relatime, noatime, or even O_NOATIME. And whenever
VFS updates the i_atime, it will notify the underlying filesystem via
sb->dirty_inode().
And also there's one thing to note about atime flags like MS_RELATIME and
other flags like MS_NODEV, etc. They are mount point flags rather than
filesystem(sb) flags. Since native linux filesystem can be mounted at multiple
places at the same time, they can all have different atime settings. So these
flags are never passed down to filesystem drivers.
What this patch tries to do:
We remove znode->z_atime, since we won't gain anything from it. We remove most
of the atime handling and leave it to VFS. The only thing we do with atime is
to write it when dirty_inode() or setattr() is called. We also add
file_accessed() in zpl_read() since it's not provided in vfs_read().
After this patch, only the MS_RELATIME flag will have effect. The setting in
dataset won't do anything. We will make zfstuil to mount ZFS with MS_RELATIME
set according to the setting in dataset in future patch.
Signed-off-by: Chunwei Chen <david.chen@osnexus.com>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Issue #4482
2016-03-30 00:53:34 +00:00
|
|
|
uint64_t [2]);
|
2008-11-20 20:01:55 +00:00
|
|
|
extern void zfs_grow_blocksize(znode_t *, uint64_t, dmu_tx_t *);
|
|
|
|
|
extern int zfs_freesp(znode_t *, uint64_t, uint64_t, int, boolean_t);
|
|
|
|
|
extern void zfs_znode_init(void);
|
|
|
|
|
extern void zfs_znode_fini(void);
|
2015-12-22 21:47:38 +00:00
|
|
|
extern int zfs_znode_hold_compare(const void *, const void *);
|
2017-03-08 00:21:37 +00:00
|
|
|
extern int zfs_zget(zfsvfs_t *, uint64_t, znode_t **);
|
2008-11-20 20:01:55 +00:00
|
|
|
extern int zfs_rezget(znode_t *);
|
|
|
|
|
extern void zfs_zinactive(znode_t *);
|
|
|
|
|
extern void zfs_znode_delete(znode_t *, dmu_tx_t *);
|
2010-08-26 16:52:41 +00:00
|
|
|
extern void zfs_remove_op_tables(void);
|
|
|
|
|
extern int zfs_create_op_tables(void);
|
2011-03-15 19:03:42 +00:00
|
|
|
extern int zfs_sync(struct super_block *, int, cred_t *);
|
2008-11-20 20:01:55 +00:00
|
|
|
extern dev_t zfs_cmpldev(uint64_t);
|
|
|
|
|
extern int zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value);
|
|
|
|
|
extern int zfs_get_stats(objset_t *os, nvlist_t *nv);
|
2017-01-27 19:46:39 +00:00
|
|
|
extern boolean_t zfs_get_vfs_flag_unmounted(objset_t *os);
|
2008-11-20 20:01:55 +00:00
|
|
|
extern void zfs_znode_dmu_fini(znode_t *);
|
2011-02-08 19:16:06 +00:00
|
|
|
extern int zfs_inode_alloc(struct super_block *, struct inode **ip);
|
|
|
|
|
extern void zfs_inode_destroy(struct inode *);
|
2011-01-05 22:27:30 +00:00
|
|
|
extern void zfs_inode_update(znode_t *);
|
2014-07-15 20:29:57 +00:00
|
|
|
extern void zfs_mark_inode_dirty(struct inode *);
|
Fix `zfs set atime|relatime=off|on` behavior on inherited datasets
`zfs set atime|relatime=off|on` doesn't disable or enable the property
on read for datasets whose property was inherited from parent, until
a dataset is once unmounted and mounted again.
(The properties start to work properly if a dataset is once unmounted
and mounted again. The difference comes from regular mount process,
e.g. via zpool import, uses mount options based on properties read
from ondisk layout for each dataset, whereas
`zfs set atime|relatime=off|on` just remounts a specified dataset.)
--
# zpool create p1 <device>
# zfs create p1/f1
# zfs set atime=off p1
# echo test > /p1/f1/test
# sync
# zfs list
NAME USED AVAIL REFER MOUNTPOINT
p1 176K 18.9G 25.5K /p1
p1/f1 26K 18.9G 26K /p1/f1
# zfs get atime
NAME PROPERTY VALUE SOURCE
p1 atime off local
p1/f1 atime off inherited from p1
# stat /p1/f1/test | grep Access | tail -1
Access: 2019-04-26 23:32:33.741205192 +0900
# cat /p1/f1/test
test
# stat /p1/f1/test | grep Access | tail -1
Access: 2019-04-26 23:32:50.173231861 +0900
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ changed by read(2)
--
The problem is that zfsvfs::z_atime which was probably intended to keep
incore atime state just gets updated by a callback function of "atime"
property change, atime_changed_cb(), and never used for anything else.
Since now that all file read and atime update use a common function
zpl_iter_read_common() -> file_accessed(), and whether to update atime
via ->dirty_inode() is determined by atime_needs_update(),
atime_needs_update() needs to return false once atime is turned off.
It currently continues to return true on `zfs set atime=off`.
Fix atime_changed_cb() by setting or dropping SB_NOATIME in VFS super
block depending on a new atime value, so that atime_needs_update() works
as expected after property change.
The same problem applies to "relatime" except that a self contained
relatime test is needed. This is because relatime_need_update() is based
on a mount option flag MNT_RELATIME, which doesn't exist in datasets
with inherited "relatime" property via `zfs set relatime=...`, hence it
needs its own relatime test zfs_relatime_need_update().
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Tomohiro Kusumi <kusumi.tomohiro@gmail.com>
Closes #8674
Closes #8675
2019-05-07 17:06:30 +00:00
|
|
|
extern boolean_t zfs_relatime_need_update(const struct inode *);
|
2008-11-20 20:01:55 +00:00
|
|
|
|
|
|
|
|
extern void zfs_log_create(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
|
|
|
|
|
znode_t *dzp, znode_t *zp, char *name, vsecattr_t *, zfs_fuid_info_t *,
|
|
|
|
|
vattr_t *vap);
|
|
|
|
|
extern int zfs_log_create_txtype(zil_create_t, vsecattr_t *vsecp,
|
|
|
|
|
vattr_t *vap);
|
|
|
|
|
extern void zfs_log_remove(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
|
2019-08-14 03:21:27 +00:00
|
|
|
znode_t *dzp, char *name, uint64_t foid, boolean_t unlinked);
|
2010-08-26 21:24:34 +00:00
|
|
|
#define ZFS_NO_OBJECT 0 /* no object id */
|
2008-11-20 20:01:55 +00:00
|
|
|
extern void zfs_log_link(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
|
|
|
|
|
znode_t *dzp, znode_t *zp, char *name);
|
|
|
|
|
extern void zfs_log_symlink(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
|
|
|
|
|
znode_t *dzp, znode_t *zp, char *name, char *link);
|
|
|
|
|
extern void zfs_log_rename(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype,
|
|
|
|
|
znode_t *sdzp, char *sname, znode_t *tdzp, char *dname, znode_t *szp);
|
|
|
|
|
extern void zfs_log_write(zilog_t *zilog, dmu_tx_t *tx, int txtype,
|
Only commit the ZIL once in zpl_writepages() (msync() case).
Currently, using msync() results in the following code path:
sys_msync -> zpl_fsync -> filemap_write_and_wait_range -> zpl_writepages -> write_cache_pages -> zpl_putpage
In such a code path, zil_commit() is called as part of zpl_putpage().
This means that for each page, the write is handed to the DMU, the ZIL
is committed, and only then do we move on to the next page. As one might
imagine, this results in atrocious performance where there is a large
number of pages to write: instead of committing a batch of N writes,
we do N commits containing one page each. In some extreme cases this
can result in msync() being ~700 times slower than it should be, as well
as very inefficient use of ZIL resources.
This patch fixes this issue by making sure that the requested writes
are batched and then committed only once. Unfortunately, the
implementation is somewhat non-trivial because there is no way to run
write_cache_pages in SYNC mode (so that we get all pages) without
making it wait on the writeback tag for each page.
The solution implemented here is composed of two parts:
- I added a new callback system to the ZIL, which allows the caller to
be notified when its ITX gets written to stable storage. One nice
thing is that the callback is called not only in zil_commit() but
in zil_sync() as well, which means that the caller doesn't have to
care whether the write ended up in the ZIL or the DMU: it will get
notified as soon as it's safe, period. This is an improvement over
dmu_tx_callback_register() that was used previously, which only
supports DMU writes. The rationale for this change is to allow
zpl_putpage() to be notified when a ZIL commit is completed without
having to block on zil_commit() itself.
- zpl_writepages() now calls write_cache_pages in non-SYNC mode, which
will prevent (1) write_cache_pages from blocking, and (2) zpl_putpage
from issuing ZIL commits. zpl_writepages() will issue the commit
itself instead of relying on zpl_putpage() to do it, thus nicely
batching the writes. Note, however, that we still have to call
write_cache_pages() again in SYNC mode because there is an edge case
documented in the implementation of write_cache_pages() whereas it
will not give us all dirty pages when running in non-SYNC mode. Thus
we need to run it at least once in SYNC mode to make sure we honor
persistency guarantees. This only happens when the pages are
modified at the same time msync() is running, which should be rare.
In most cases there won't be any additional pages and this second
call will do nothing.
Note that this change also fixes a bug related to #907 whereas calling
msync() on pages that were already handed over to the DMU in a previous
writepages() call would make msync() block until the next TXG sync
instead of returning as soon as the ZIL commit is complete. The new
callback system fixes that problem.
Signed-off-by: Richard Yao <ryao@gentoo.org>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #1849
Closes #907
2013-11-10 15:00:11 +00:00
|
|
|
znode_t *zp, offset_t off, ssize_t len, int ioflag,
|
|
|
|
|
zil_callback_t callback, void *callback_data);
|
2008-11-20 20:01:55 +00:00
|
|
|
extern void zfs_log_truncate(zilog_t *zilog, dmu_tx_t *tx, int txtype,
|
|
|
|
|
znode_t *zp, uint64_t off, uint64_t len);
|
|
|
|
|
extern void zfs_log_setattr(zilog_t *zilog, dmu_tx_t *tx, int txtype,
|
2011-03-01 20:24:09 +00:00
|
|
|
znode_t *zp, vattr_t *vap, uint_t mask_applied, zfs_fuid_info_t *fuidp);
|
2008-11-20 20:01:55 +00:00
|
|
|
extern void zfs_log_acl(zilog_t *zilog, dmu_tx_t *tx, znode_t *zp,
|
|
|
|
|
vsecattr_t *vsecp, zfs_fuid_info_t *fuidp);
|
2010-05-28 20:45:14 +00:00
|
|
|
extern void zfs_xvattr_set(znode_t *zp, xvattr_t *xvap, dmu_tx_t *tx);
|
2017-03-08 00:21:37 +00:00
|
|
|
extern void zfs_upgrade(zfsvfs_t *zfsvfs, dmu_tx_t *tx);
|
2008-11-20 20:01:55 +00:00
|
|
|
|
2010-08-26 18:45:02 +00:00
|
|
|
#if defined(HAVE_UIO_RW)
|
2008-12-03 20:09:06 +00:00
|
|
|
extern caddr_t zfs_map_page(page_t *, enum seg_rw);
|
|
|
|
|
extern void zfs_unmap_page(page_t *, caddr_t);
|
2010-08-26 18:45:02 +00:00
|
|
|
#endif /* HAVE_UIO_RW */
|
2008-12-03 20:09:06 +00:00
|
|
|
|
2008-11-20 20:01:55 +00:00
|
|
|
extern zil_get_data_t zfs_get_data;
|
2017-10-27 19:46:35 +00:00
|
|
|
extern zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE];
|
2008-11-20 20:01:55 +00:00
|
|
|
extern int zfsfstype;
|
|
|
|
|
|
|
|
|
|
#endif /* _KERNEL */
|
|
|
|
|
|
|
|
|
|
extern int zfs_obj_to_path(objset_t *osp, uint64_t obj, char *buf, int len);
|
|
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#endif /* _SYS_FS_ZFS_ZNODE_H */
|
