2018-08-20 19:52:37 +03: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
|
2022-07-12 00:16:13 +03:00
|
|
|
* or https://opensource.org/licenses/CDDL-1.0.
|
2018-08-20 19:52:37 +03:00
|
|
|
* 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
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2018 by Delphix. All rights reserved.
|
2019-02-12 21:41:15 +03:00
|
|
|
* Copyright (c) 2018 Datto Inc.
|
2018-08-20 19:52:37 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <sys/dataset_kstats.h>
|
|
|
|
|
#include <sys/dmu_objset.h>
|
|
|
|
|
#include <sys/dsl_dataset.h>
|
|
|
|
|
#include <sys/spa.h>
|
|
|
|
|
|
|
|
|
|
static dataset_kstat_values_t empty_dataset_kstats = {
|
|
|
|
|
{ "dataset_name", KSTAT_DATA_STRING },
|
|
|
|
|
{ "writes", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "nwritten", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "reads", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "nread", KSTAT_DATA_UINT64 },
|
2019-02-12 21:41:15 +03:00
|
|
|
{ "nunlinks", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "nunlinked", KSTAT_DATA_UINT64 },
|
2022-07-21 03:14:06 +03:00
|
|
|
{
|
|
|
|
|
{ "zil_commit_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_commit_writer_count", KSTAT_DATA_UINT64 },
|
2024-08-15 00:18:46 +03:00
|
|
|
{ "zil_commit_error_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_commit_stall_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_commit_suspend_count", KSTAT_DATA_UINT64 },
|
2022-07-21 03:14:06 +03:00
|
|
|
{ "zil_itx_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_indirect_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_indirect_bytes", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_copied_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_copied_bytes", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_needcopy_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_needcopy_bytes", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_metaslab_normal_count", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_metaslab_normal_bytes", KSTAT_DATA_UINT64 },
|
2023-05-25 23:51:53 +03:00
|
|
|
{ "zil_itx_metaslab_normal_write", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_metaslab_normal_alloc", KSTAT_DATA_UINT64 },
|
2022-07-21 03:14:06 +03:00
|
|
|
{ "zil_itx_metaslab_slog_count", KSTAT_DATA_UINT64 },
|
2023-05-25 23:51:53 +03:00
|
|
|
{ "zil_itx_metaslab_slog_bytes", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_metaslab_slog_write", KSTAT_DATA_UINT64 },
|
|
|
|
|
{ "zil_itx_metaslab_slog_alloc", KSTAT_DATA_UINT64 }
|
2022-07-21 03:14:06 +03:00
|
|
|
}
|
2018-08-20 19:52:37 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
dataset_kstats_update(kstat_t *ksp, int rw)
|
|
|
|
|
{
|
|
|
|
|
dataset_kstats_t *dk = ksp->ks_private;
|
2022-07-21 03:14:06 +03:00
|
|
|
dataset_kstat_values_t *dkv = ksp->ks_data;
|
|
|
|
|
ASSERT3P(dk->dk_kstats->ks_data, ==, dkv);
|
2018-08-20 19:52:37 +03:00
|
|
|
|
|
|
|
|
if (rw == KSTAT_WRITE)
|
|
|
|
|
return (EACCES);
|
|
|
|
|
|
|
|
|
|
dkv->dkv_writes.value.ui64 =
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_value(&dk->dk_sums.dss_writes);
|
2018-08-20 19:52:37 +03:00
|
|
|
dkv->dkv_nwritten.value.ui64 =
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_value(&dk->dk_sums.dss_nwritten);
|
2018-08-20 19:52:37 +03:00
|
|
|
dkv->dkv_reads.value.ui64 =
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_value(&dk->dk_sums.dss_reads);
|
2018-08-20 19:52:37 +03:00
|
|
|
dkv->dkv_nread.value.ui64 =
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_value(&dk->dk_sums.dss_nread);
|
2019-02-12 21:41:15 +03:00
|
|
|
dkv->dkv_nunlinks.value.ui64 =
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_value(&dk->dk_sums.dss_nunlinks);
|
2019-02-12 21:41:15 +03:00
|
|
|
dkv->dkv_nunlinked.value.ui64 =
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_value(&dk->dk_sums.dss_nunlinked);
|
2018-08-20 19:52:37 +03:00
|
|
|
|
2022-07-21 03:14:06 +03:00
|
|
|
zil_kstat_values_update(&dkv->dkv_zil_stats, &dk->dk_zil_sums);
|
|
|
|
|
|
2018-08-20 19:52:37 +03:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2022-07-21 03:14:06 +03:00
|
|
|
int
|
2018-08-20 19:52:37 +03:00
|
|
|
dataset_kstats_create(dataset_kstats_t *dk, objset_t *objset)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* There should not be anything wrong with having kstats for
|
|
|
|
|
* snapshots. Since we are not sure how useful they would be
|
|
|
|
|
* though nor how much their memory overhead would matter in
|
|
|
|
|
* a filesystem with many snapshots, we skip them for now.
|
|
|
|
|
*/
|
|
|
|
|
if (dmu_objset_is_snapshot(objset))
|
2022-07-21 03:14:06 +03:00
|
|
|
return (0);
|
2018-08-20 19:52:37 +03:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* At the time of this writing, KSTAT_STRLEN is 255 in Linux,
|
|
|
|
|
* and the spa_name can theoretically be up to 256 characters.
|
|
|
|
|
* In reality though the spa_name can be 240 characters max
|
|
|
|
|
* [see origin directory name check in pool_namecheck()]. Thus,
|
|
|
|
|
* the naming scheme for the module name below should not cause
|
|
|
|
|
* any truncations. In the event that a truncation does happen
|
|
|
|
|
* though, due to some future change, we silently skip creating
|
|
|
|
|
* the kstat and log the event.
|
|
|
|
|
*/
|
|
|
|
|
char kstat_module_name[KSTAT_STRLEN];
|
|
|
|
|
int n = snprintf(kstat_module_name, sizeof (kstat_module_name),
|
|
|
|
|
"zfs/%s", spa_name(dmu_objset_spa(objset)));
|
|
|
|
|
if (n < 0) {
|
|
|
|
|
zfs_dbgmsg("failed to create dataset kstat for objset %lld: "
|
|
|
|
|
" snprintf() for kstat module name returned %d",
|
|
|
|
|
(unsigned long long)dmu_objset_id(objset), n);
|
2022-07-21 03:14:06 +03:00
|
|
|
return (SET_ERROR(EINVAL));
|
2018-08-20 19:52:37 +03:00
|
|
|
} else if (n >= KSTAT_STRLEN) {
|
|
|
|
|
zfs_dbgmsg("failed to create dataset kstat for objset %lld: "
|
|
|
|
|
"kstat module name length (%d) exceeds limit (%d)",
|
|
|
|
|
(unsigned long long)dmu_objset_id(objset),
|
|
|
|
|
n, KSTAT_STRLEN);
|
2022-07-21 03:14:06 +03:00
|
|
|
return (SET_ERROR(ENAMETOOLONG));
|
2018-08-20 19:52:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char kstat_name[KSTAT_STRLEN];
|
|
|
|
|
n = snprintf(kstat_name, sizeof (kstat_name), "objset-0x%llx",
|
|
|
|
|
(unsigned long long)dmu_objset_id(objset));
|
|
|
|
|
if (n < 0) {
|
|
|
|
|
zfs_dbgmsg("failed to create dataset kstat for objset %lld: "
|
|
|
|
|
" snprintf() for kstat name returned %d",
|
|
|
|
|
(unsigned long long)dmu_objset_id(objset), n);
|
2022-07-21 03:14:06 +03:00
|
|
|
return (SET_ERROR(EINVAL));
|
Introduce kmem_scnprintf()
`snprintf()` is meant to protect against buffer overflows, but operating
on the buffer using its return value, possibly by calling it again, can
cause a buffer overflow, because it will return how many characters it
would have written if it had enough space even when it did not. In a
number of places, we repeatedly call snprintf() by successively
incrementing a buffer offset and decrementing a buffer length, by its
return value. This is a potentially unsafe usage of `snprintf()`
whenever the buffer length is reached. CodeQL complained about this.
To fix this, we introduce `kmem_scnprintf()`, which will return 0 when
the buffer is zero or the number of written characters, minus 1 to
exclude the NULL character, when the buffer was too small. In all other
cases, it behaves like snprintf(). The name is inspired by the Linux and
XNU kernels' `scnprintf()`. The implementation was written before I
thought to look at `scnprintf()` and had a good name for it, but it
turned out to have identical semantics to the Linux kernel version.
That lead to the name, `kmem_scnprintf()`.
CodeQL only catches this issue in loops, so repeated use of snprintf()
outside of a loop was not caught. As a result, a thorough audit of the
codebase was done to examine all instances of `snprintf()` usage for
potential problems and a few were caught. Fixes for them are included in
this patch.
Unfortunately, ZED is one of the places where `snprintf()` is
potentially used incorrectly. Since using `kmem_scnprintf()` in it would
require changing how it is linked, we modify its usage to make it safe,
no matter what buffer length is used. In addition, there was a bug in
the use of the return value where the NULL format character was not
being written by pwrite(). That has been fixed.
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Richard Yao <richard.yao@alumni.stonybrook.edu>
Closes #14098
2022-10-27 21:16:04 +03:00
|
|
|
} else if (n >= KSTAT_STRLEN) {
|
|
|
|
|
zfs_dbgmsg("failed to create dataset kstat for objset %lld: "
|
|
|
|
|
"kstat name length (%d) exceeds limit (%d)",
|
|
|
|
|
(unsigned long long)dmu_objset_id(objset),
|
|
|
|
|
n, KSTAT_STRLEN);
|
|
|
|
|
return (SET_ERROR(ENAMETOOLONG));
|
2018-08-20 19:52:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
kstat_t *kstat = kstat_create(kstat_module_name, 0, kstat_name,
|
|
|
|
|
"dataset", KSTAT_TYPE_NAMED,
|
|
|
|
|
sizeof (empty_dataset_kstats) / sizeof (kstat_named_t),
|
|
|
|
|
KSTAT_FLAG_VIRTUAL);
|
|
|
|
|
if (kstat == NULL)
|
2022-07-21 03:14:06 +03:00
|
|
|
return (SET_ERROR(ENOMEM));
|
2018-08-20 19:52:37 +03:00
|
|
|
|
|
|
|
|
dataset_kstat_values_t *dk_kstats =
|
|
|
|
|
kmem_alloc(sizeof (empty_dataset_kstats), KM_SLEEP);
|
2022-02-25 16:26:54 +03:00
|
|
|
memcpy(dk_kstats, &empty_dataset_kstats,
|
2018-08-20 19:52:37 +03:00
|
|
|
sizeof (empty_dataset_kstats));
|
|
|
|
|
|
|
|
|
|
char *ds_name = kmem_zalloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
|
|
|
|
|
dsl_dataset_name(objset->os_dsl_dataset, ds_name);
|
|
|
|
|
KSTAT_NAMED_STR_PTR(&dk_kstats->dkv_ds_name) = ds_name;
|
|
|
|
|
KSTAT_NAMED_STR_BUFLEN(&dk_kstats->dkv_ds_name) =
|
|
|
|
|
ZFS_MAX_DATASET_NAME_LEN;
|
|
|
|
|
|
|
|
|
|
kstat->ks_data = dk_kstats;
|
|
|
|
|
kstat->ks_update = dataset_kstats_update;
|
|
|
|
|
kstat->ks_private = dk;
|
2019-09-03 22:12:31 +03:00
|
|
|
kstat->ks_data_size += ZFS_MAX_DATASET_NAME_LEN;
|
2018-08-20 19:52:37 +03:00
|
|
|
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_init(&dk->dk_sums.dss_writes, 0);
|
|
|
|
|
wmsum_init(&dk->dk_sums.dss_nwritten, 0);
|
|
|
|
|
wmsum_init(&dk->dk_sums.dss_reads, 0);
|
|
|
|
|
wmsum_init(&dk->dk_sums.dss_nread, 0);
|
|
|
|
|
wmsum_init(&dk->dk_sums.dss_nunlinks, 0);
|
|
|
|
|
wmsum_init(&dk->dk_sums.dss_nunlinked, 0);
|
2022-07-21 03:14:06 +03:00
|
|
|
zil_sums_init(&dk->dk_zil_sums);
|
|
|
|
|
|
|
|
|
|
dk->dk_kstats = kstat;
|
|
|
|
|
kstat_install(kstat);
|
|
|
|
|
return (0);
|
2018-08-20 19:52:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
dataset_kstats_destroy(dataset_kstats_t *dk)
|
|
|
|
|
{
|
|
|
|
|
if (dk->dk_kstats == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
dataset_kstat_values_t *dkv = dk->dk_kstats->ks_data;
|
2022-07-21 03:14:06 +03:00
|
|
|
kstat_delete(dk->dk_kstats);
|
|
|
|
|
dk->dk_kstats = NULL;
|
2018-08-20 19:52:37 +03:00
|
|
|
kmem_free(KSTAT_NAMED_STR_PTR(&dkv->dkv_ds_name),
|
|
|
|
|
KSTAT_NAMED_STR_BUFLEN(&dkv->dkv_ds_name));
|
|
|
|
|
kmem_free(dkv, sizeof (empty_dataset_kstats));
|
|
|
|
|
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_fini(&dk->dk_sums.dss_writes);
|
|
|
|
|
wmsum_fini(&dk->dk_sums.dss_nwritten);
|
|
|
|
|
wmsum_fini(&dk->dk_sums.dss_reads);
|
|
|
|
|
wmsum_fini(&dk->dk_sums.dss_nread);
|
|
|
|
|
wmsum_fini(&dk->dk_sums.dss_nunlinks);
|
|
|
|
|
wmsum_fini(&dk->dk_sums.dss_nunlinked);
|
2022-07-21 03:14:06 +03:00
|
|
|
zil_sums_fini(&dk->dk_zil_sums);
|
2018-08-20 19:52:37 +03:00
|
|
|
}
|
|
|
|
|
|
2023-11-07 22:34:50 +03:00
|
|
|
void
|
|
|
|
|
dataset_kstats_rename(dataset_kstats_t *dk, const char *name)
|
|
|
|
|
{
|
Fix null ptr deref when renaming a zvol with snaps and snapdev=visible (#16316)
If a zvol is renamed, and it has one or more snapshots, and
snapdev=visible is true for the zvol, then the rename causes a kernel
null pointer dereference error. This has the effect (on Linux, anyway)
of killing the z_zvol taskq kthread, with locks still held; which in
turn causes a variety of zvol-related operations afterward to hang
indefinitely (such as udev workers, among other things).
The problem occurs because of an oversight in #15486
(e36ff84c338d2f7b15aef2538f6a9507115bbf4a). As documented in
dataset_kstats_create, some datasets may not actually have kstats
allocated for them; and at least at the present time, this is true for
snapshots. In practical terms, this means that for snapshots,
dk->dk_kstats will be NULL. The dataset_kstats_rename function
introduced in the patch above does not first check whether dk->dk_kstats
is NULL before proceeding, unlike e.g. the nearby
dataset_kstats_update_* functions.
In the very particular circumstance in which a zvol is renamed, AND that
zvol has one or more snapshots, AND that zvol also has snapdev=visible,
zvol_rename_minors_impl will loop over not just the zvol dataset itself,
but each of the zvol's snapshots as well, so that their device nodes
will be renamed as well. This results in dataset_kstats_create being
called for snapshots, where, as we've established, dk->dk_kstats is
NULL.
Fix this by simply adding a NULL check before doing anything in
dataset_kstats_rename.
This still allows the dataset_name kstat value for the zvol to be
updated (as was the intent of the original patch), and merely blocks
attempts by the code to act upon the zvol's non-kstat-having snapshots.
If at some future time, kstats are added for snapshots, then things
should work as intended in that case as well.
Signed-off-by: Justin Gottula <justin@jgottula.com>
Reviewed-by: Rob Norris <robn@despairlabs.com>
Reviewed-by: Alexander Motin <mav@FreeBSD.org>
Reviewed-by: Alan Somers <asomers@gmail.com>
Reviewed-by: Allan Jude <allan@klarasystems.com>
Reviewed-by: Tony Hutter <hutter2@llnl.gov>
2024-08-16 00:13:18 +03:00
|
|
|
if (dk->dk_kstats == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2023-11-07 22:34:50 +03:00
|
|
|
dataset_kstat_values_t *dkv = dk->dk_kstats->ks_data;
|
|
|
|
|
char *ds_name;
|
|
|
|
|
|
|
|
|
|
ds_name = KSTAT_NAMED_STR_PTR(&dkv->dkv_ds_name);
|
|
|
|
|
ASSERT3S(ds_name, !=, NULL);
|
|
|
|
|
(void) strlcpy(ds_name, name,
|
|
|
|
|
KSTAT_NAMED_STR_BUFLEN(&dkv->dkv_ds_name));
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-20 19:52:37 +03:00
|
|
|
void
|
Adding Direct IO Support
Adding O_DIRECT support to ZFS to bypass the ARC for writes/reads.
O_DIRECT support in ZFS will always ensure there is coherency between
buffered and O_DIRECT IO requests. This ensures that all IO requests,
whether buffered or direct, will see the same file contents at all
times. Just as in other FS's , O_DIRECT does not imply O_SYNC. While
data is written directly to VDEV disks, metadata will not be synced
until the associated TXG is synced.
For both O_DIRECT read and write request the offset and request sizes,
at a minimum, must be PAGE_SIZE aligned. In the event they are not,
then EINVAL is returned unless the direct property is set to always (see
below).
For O_DIRECT writes:
The request also must be block aligned (recordsize) or the write
request will take the normal (buffered) write path. In the event that
request is block aligned and a cached copy of the buffer in the ARC,
then it will be discarded from the ARC forcing all further reads to
retrieve the data from disk.
For O_DIRECT reads:
The only alignment restrictions are PAGE_SIZE alignment. In the event
that the requested data is in buffered (in the ARC) it will just be
copied from the ARC into the user buffer.
For both O_DIRECT writes and reads the O_DIRECT flag will be ignored in
the event that file contents are mmap'ed. In this case, all requests
that are at least PAGE_SIZE aligned will just fall back to the buffered
paths. If the request however is not PAGE_SIZE aligned, EINVAL will
be returned as always regardless if the file's contents are mmap'ed.
Since O_DIRECT writes go through the normal ZIO pipeline, the
following operations are supported just as with normal buffered writes:
Checksum
Compression
Encryption
Erasure Coding
There is one caveat for the data integrity of O_DIRECT writes that is
distinct for each of the OS's supported by ZFS.
FreeBSD - FreeBSD is able to place user pages under write protection so
any data in the user buffers and written directly down to the
VDEV disks is guaranteed to not change. There is no concern
with data integrity and O_DIRECT writes.
Linux - Linux is not able to place anonymous user pages under write
protection. Because of this, if the user decides to manipulate
the page contents while the write operation is occurring, data
integrity can not be guaranteed. However, there is a module
parameter `zfs_vdev_direct_write_verify` that controls the
if a O_DIRECT writes that can occur to a top-level VDEV before
a checksum verify is run before the contents of the I/O buffer
are committed to disk. In the event of a checksum verification
failure the write will return EIO. The number of O_DIRECT write
checksum verification errors can be observed by doing
`zpool status -d`, which will list all verification errors that
have occurred on a top-level VDEV. Along with `zpool status`, a
ZED event will be issues as `dio_verify` when a checksum
verification error occurs.
ZVOLs and dedup is not currently supported with Direct I/O.
A new dataset property `direct` has been added with the following 3
allowable values:
disabled - Accepts O_DIRECT flag, but silently ignores it and treats
the request as a buffered IO request.
standard - Follows the alignment restrictions outlined above for
write/read IO requests when the O_DIRECT flag is used.
always - Treats every write/read IO request as though it passed
O_DIRECT and will do O_DIRECT if the alignment restrictions
are met otherwise will redirect through the ARC. This
property will not allow a request to fail.
There is also a module parameter zfs_dio_enabled that can be used to
force all reads and writes through the ARC. By setting this module
parameter to 0, it mimics as if the direct dataset property is set to
disabled.
Reviewed-by: Brian Behlendorf <behlendorf@llnl.gov>
Reviewed-by: Alexander Motin <mav@FreeBSD.org>
Reviewed-by: Tony Hutter <hutter2@llnl.gov>
Signed-off-by: Brian Atkinson <batkinson@lanl.gov>
Co-authored-by: Mark Maybee <mark.maybee@delphix.com>
Co-authored-by: Matt Macy <mmacy@FreeBSD.org>
Co-authored-by: Brian Behlendorf <behlendorf@llnl.gov>
Closes #10018
2024-09-14 23:47:59 +03:00
|
|
|
dataset_kstats_update_write_kstats(dataset_kstats_t *dk, int64_t nwritten)
|
2018-08-20 19:52:37 +03:00
|
|
|
{
|
|
|
|
|
ASSERT3S(nwritten, >=, 0);
|
|
|
|
|
|
|
|
|
|
if (dk->dk_kstats == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_add(&dk->dk_sums.dss_writes, 1);
|
|
|
|
|
wmsum_add(&dk->dk_sums.dss_nwritten, nwritten);
|
2018-08-20 19:52:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
Adding Direct IO Support
Adding O_DIRECT support to ZFS to bypass the ARC for writes/reads.
O_DIRECT support in ZFS will always ensure there is coherency between
buffered and O_DIRECT IO requests. This ensures that all IO requests,
whether buffered or direct, will see the same file contents at all
times. Just as in other FS's , O_DIRECT does not imply O_SYNC. While
data is written directly to VDEV disks, metadata will not be synced
until the associated TXG is synced.
For both O_DIRECT read and write request the offset and request sizes,
at a minimum, must be PAGE_SIZE aligned. In the event they are not,
then EINVAL is returned unless the direct property is set to always (see
below).
For O_DIRECT writes:
The request also must be block aligned (recordsize) or the write
request will take the normal (buffered) write path. In the event that
request is block aligned and a cached copy of the buffer in the ARC,
then it will be discarded from the ARC forcing all further reads to
retrieve the data from disk.
For O_DIRECT reads:
The only alignment restrictions are PAGE_SIZE alignment. In the event
that the requested data is in buffered (in the ARC) it will just be
copied from the ARC into the user buffer.
For both O_DIRECT writes and reads the O_DIRECT flag will be ignored in
the event that file contents are mmap'ed. In this case, all requests
that are at least PAGE_SIZE aligned will just fall back to the buffered
paths. If the request however is not PAGE_SIZE aligned, EINVAL will
be returned as always regardless if the file's contents are mmap'ed.
Since O_DIRECT writes go through the normal ZIO pipeline, the
following operations are supported just as with normal buffered writes:
Checksum
Compression
Encryption
Erasure Coding
There is one caveat for the data integrity of O_DIRECT writes that is
distinct for each of the OS's supported by ZFS.
FreeBSD - FreeBSD is able to place user pages under write protection so
any data in the user buffers and written directly down to the
VDEV disks is guaranteed to not change. There is no concern
with data integrity and O_DIRECT writes.
Linux - Linux is not able to place anonymous user pages under write
protection. Because of this, if the user decides to manipulate
the page contents while the write operation is occurring, data
integrity can not be guaranteed. However, there is a module
parameter `zfs_vdev_direct_write_verify` that controls the
if a O_DIRECT writes that can occur to a top-level VDEV before
a checksum verify is run before the contents of the I/O buffer
are committed to disk. In the event of a checksum verification
failure the write will return EIO. The number of O_DIRECT write
checksum verification errors can be observed by doing
`zpool status -d`, which will list all verification errors that
have occurred on a top-level VDEV. Along with `zpool status`, a
ZED event will be issues as `dio_verify` when a checksum
verification error occurs.
ZVOLs and dedup is not currently supported with Direct I/O.
A new dataset property `direct` has been added with the following 3
allowable values:
disabled - Accepts O_DIRECT flag, but silently ignores it and treats
the request as a buffered IO request.
standard - Follows the alignment restrictions outlined above for
write/read IO requests when the O_DIRECT flag is used.
always - Treats every write/read IO request as though it passed
O_DIRECT and will do O_DIRECT if the alignment restrictions
are met otherwise will redirect through the ARC. This
property will not allow a request to fail.
There is also a module parameter zfs_dio_enabled that can be used to
force all reads and writes through the ARC. By setting this module
parameter to 0, it mimics as if the direct dataset property is set to
disabled.
Reviewed-by: Brian Behlendorf <behlendorf@llnl.gov>
Reviewed-by: Alexander Motin <mav@FreeBSD.org>
Reviewed-by: Tony Hutter <hutter2@llnl.gov>
Signed-off-by: Brian Atkinson <batkinson@lanl.gov>
Co-authored-by: Mark Maybee <mark.maybee@delphix.com>
Co-authored-by: Matt Macy <mmacy@FreeBSD.org>
Co-authored-by: Brian Behlendorf <behlendorf@llnl.gov>
Closes #10018
2024-09-14 23:47:59 +03:00
|
|
|
dataset_kstats_update_read_kstats(dataset_kstats_t *dk, int64_t nread)
|
2018-08-20 19:52:37 +03:00
|
|
|
{
|
|
|
|
|
ASSERT3S(nread, >=, 0);
|
|
|
|
|
|
|
|
|
|
if (dk->dk_kstats == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_add(&dk->dk_sums.dss_reads, 1);
|
|
|
|
|
wmsum_add(&dk->dk_sums.dss_nread, nread);
|
2018-08-20 19:52:37 +03:00
|
|
|
}
|
2019-02-12 21:41:15 +03:00
|
|
|
|
|
|
|
|
void
|
|
|
|
|
dataset_kstats_update_nunlinks_kstat(dataset_kstats_t *dk, int64_t delta)
|
|
|
|
|
{
|
|
|
|
|
if (dk->dk_kstats == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_add(&dk->dk_sums.dss_nunlinks, delta);
|
2019-02-12 21:41:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
dataset_kstats_update_nunlinked_kstat(dataset_kstats_t *dk, int64_t delta)
|
|
|
|
|
{
|
|
|
|
|
if (dk->dk_kstats == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2021-05-27 23:27:29 +03:00
|
|
|
wmsum_add(&dk->dk_sums.dss_nunlinked, delta);
|
2019-02-12 21:41:15 +03:00
|
|
|
}
|