diff --git a/sys/conf/kern.pre.mk b/sys/conf/kern.pre.mk index 3ba837d9de1..337da3dd822 100644 --- a/sys/conf/kern.pre.mk +++ b/sys/conf/kern.pre.mk @@ -242,7 +242,7 @@ CDDL_C= ${CC} -c ${CDDL_CFLAGS} ${WERROR} ${.IMPSRC} # Special flags for managing the compat compiles for ZFS ZFS_CFLAGS+= ${CDDL_CFLAGS} -DBUILDING_ZFS -DHAVE_UIO_ZEROCOPY \ -DWITH_NETDUMP -D__KERNEL__ -D_SYS_CONDVAR_H_ -DSMP \ - -DIN_FREEBSD_BASE -DHAVE_KSID + -DIN_FREEBSD_BASE .if ${MACHINE_ARCH} == "amd64" ZFS_CFLAGS+= -DHAVE_AVX2 -DHAVE_AVX -D__x86_64 -DHAVE_SSE2 -DHAVE_AVX512F \ diff --git a/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml b/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml index 1a32e2e2293..0273610af04 100644 --- a/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml +++ b/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml @@ -60,7 +60,7 @@ jobs: - name: Tests run: | set -o pipefail - /usr/share/zfs/zfs-tests.sh -vR -s 3G | scripts/zfs-tests-color.sh + /usr/share/zfs/zfs-tests.sh -vKR -s 3G | scripts/zfs-tests-color.sh shell: bash timeout-minutes: 330 - name: Prepare artifacts diff --git a/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml b/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml index d10350d2961..73606f909e1 100644 --- a/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml +++ b/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml @@ -56,7 +56,7 @@ jobs: - name: Tests run: | set -o pipefail - /usr/share/zfs/zfs-tests.sh -vR -s 3G -r sanity | scripts/zfs-tests-color.sh + /usr/share/zfs/zfs-tests.sh -vKR -s 3G -r sanity | scripts/zfs-tests-color.sh shell: bash timeout-minutes: 330 - name: Prepare artifacts diff --git a/sys/contrib/openzfs/META b/sys/contrib/openzfs/META index aab6e2abe56..e9580350587 100644 --- a/sys/contrib/openzfs/META +++ b/sys/contrib/openzfs/META @@ -6,5 +6,5 @@ Release: 1 Release-Tags: relext License: CDDL Author: OpenZFS -Linux-Maximum: 5.15 +Linux-Maximum: 5.17 Linux-Minimum: 3.10 diff --git a/sys/contrib/openzfs/Makefile.am b/sys/contrib/openzfs/Makefile.am index 42330440a68..09835790291 100644 --- a/sys/contrib/openzfs/Makefile.am +++ b/sys/contrib/openzfs/Makefile.am @@ -103,7 +103,7 @@ endif endif PHONY += codecheck -codecheck: cstyle shellcheck checkbashisms flake8 mancheck testscheck vcscheck +codecheck: cstyle shellcheck checkbashisms flake8 mancheck testscheck vcscheck zstdcheck PHONY += checkstyle checkstyle: codecheck commitcheck @@ -125,6 +125,7 @@ cstyle: -o -type f -name '*.[hc]' \ ! -name 'zfs_config.*' ! -name '*.mod.c' \ ! -name 'opt_global.h' ! -name '*_if*.h' \ + ! -name 'zstd_compat_wrapper.h' \ ! -path './module/zstd/lib/*' \ ! -path './include/sys/lua/*' \ ! -path './module/lua/l*.[ch]' \ @@ -164,6 +165,10 @@ vcscheck: awk '{c++; print} END {if(c>0) exit 1}' ; \ fi +PHONY += zstdcheck +zstdcheck: + @$(MAKE) -C module/zstd checksymbols + PHONY += lint lint: cppcheck paxcheck diff --git a/sys/contrib/openzfs/cmd/raidz_test/raidz_bench.c b/sys/contrib/openzfs/cmd/raidz_test/raidz_bench.c index f44d6fbde70..76f8e353c7f 100644 --- a/sys/contrib/openzfs/cmd/raidz_test/raidz_bench.c +++ b/sys/contrib/openzfs/cmd/raidz_test/raidz_bench.c @@ -63,7 +63,7 @@ bench_fini_raidz_maps(void) { /* tear down golden zio */ raidz_free(zio_bench.io_abd, max_data_size); - bzero(&zio_bench, sizeof (zio_t)); + memset(&zio_bench, 0, sizeof (zio_t)); } static inline void diff --git a/sys/contrib/openzfs/cmd/raidz_test/raidz_test.c b/sys/contrib/openzfs/cmd/raidz_test/raidz_test.c index 8bb38f2f72c..a712b10b303 100644 --- a/sys/contrib/openzfs/cmd/raidz_test/raidz_test.c +++ b/sys/contrib/openzfs/cmd/raidz_test/raidz_test.c @@ -141,10 +141,9 @@ static void process_options(int argc, char **argv) { size_t value; int opt; - raidz_test_opts_t *o = &rto_opts; - bcopy(&rto_opts_defaults, o, sizeof (*o)); + memcpy(o, &rto_opts_defaults, sizeof (*o)); while ((opt = getopt(argc, argv, "TDBSvha:er:o:d:s:t:")) != -1) { value = 0; @@ -840,7 +839,7 @@ static kcondvar_t sem_cv; static int max_free_slots; static int free_slots; -static _Noreturn void +static __attribute__((noreturn)) void sweep_thread(void *arg) { int err = 0; diff --git a/sys/contrib/openzfs/cmd/raidz_test/raidz_test.h b/sys/contrib/openzfs/cmd/raidz_test/raidz_test.h index 40a8a85e5f6..7059d985b32 100644 --- a/sys/contrib/openzfs/cmd/raidz_test/raidz_test.h +++ b/sys/contrib/openzfs/cmd/raidz_test/raidz_test.h @@ -92,19 +92,19 @@ static inline size_t ilog2(size_t a) } -#define LOG(lvl, a...) \ +#define LOG(lvl, ...) \ { \ if (rto_opts.rto_v >= lvl) \ - (void) fprintf(stdout, a); \ + (void) fprintf(stdout, __VA_ARGS__); \ } \ -#define LOG_OPT(lvl, opt, a...) \ +#define LOG_OPT(lvl, opt, ...) \ { \ if (opt->rto_v >= lvl) \ - (void) fprintf(stdout, a); \ + (void) fprintf(stdout, __VA_ARGS__); \ } \ -#define ERR(a...) (void) fprintf(stderr, a) +#define ERR(...) (void) fprintf(stderr, __VA_ARGS__) #define DBLSEP "================\n" diff --git a/sys/contrib/openzfs/cmd/zdb/zdb.c b/sys/contrib/openzfs/cmd/zdb/zdb.c index 3fbe7510693..f18c9fd6b93 100644 --- a/sys/contrib/openzfs/cmd/zdb/zdb.c +++ b/sys/contrib/openzfs/cmd/zdb/zdb.c @@ -2035,11 +2035,8 @@ dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class) static void dump_all_ddts(spa_t *spa) { - ddt_histogram_t ddh_total; - ddt_stat_t dds_total; - - bzero(&ddh_total, sizeof (ddh_total)); - bzero(&dds_total, sizeof (dds_total)); + ddt_histogram_t ddh_total = {{{0}}}; + ddt_stat_t dds_total = {0}; for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) { ddt_t *ddt = spa->spa_ddt[c]; @@ -4360,7 +4357,7 @@ dump_l2arc_log_blocks(int fd, l2arc_dev_hdr_phys_t l2dhdr, if (!dump_opt['q']) print_l2arc_log_blocks(); - bcopy((&l2dhdr)->dh_start_lbps, lbps, sizeof (lbps)); + memcpy(lbps, l2dhdr.dh_start_lbps, sizeof (lbps)); dev.l2ad_evict = l2dhdr.dh_evict; dev.l2ad_start = l2dhdr.dh_start; @@ -4460,12 +4457,9 @@ dump_l2arc_log_blocks(int fd, l2arc_dev_hdr_phys_t l2dhdr, static int dump_l2arc_header(int fd) { - l2arc_dev_hdr_phys_t l2dhdr, rebuild; + l2arc_dev_hdr_phys_t l2dhdr = {0}, rebuild = {0}; int error = B_FALSE; - bzero(&l2dhdr, sizeof (l2dhdr)); - bzero(&rebuild, sizeof (rebuild)); - if (pread64(fd, &l2dhdr, sizeof (l2dhdr), VDEV_LABEL_START_SIZE) != sizeof (l2dhdr)) { error = B_TRUE; @@ -4820,7 +4814,7 @@ static int dump_label(const char *dev) { char path[MAXPATHLEN]; - zdb_label_t labels[VDEV_LABELS]; + zdb_label_t labels[VDEV_LABELS] = {{{{0}}}}; uint64_t psize, ashift, l2cache; struct stat64 statbuf; boolean_t config_found = B_FALSE; @@ -4831,8 +4825,6 @@ dump_label(const char *dev) void *node, *cookie; int fd; - bzero(labels, sizeof (labels)); - /* * Check if we were given absolute path and use it as is. * Otherwise if the provided vdev name doesn't point to a file, @@ -5746,14 +5738,13 @@ zdb_load_obsolete_counts(vdev_t *vd) static void zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb) { - ddt_bookmark_t ddb; + ddt_bookmark_t ddb = {0}; ddt_entry_t dde; int error; int p; ASSERT(!dump_opt['L']); - bzero(&ddb, sizeof (ddb)); while ((error = ddt_walk(spa, &ddb, &dde)) == 0) { blkptr_t blk; ddt_phys_t *ddp = dde.dde_phys; @@ -6413,7 +6404,7 @@ deleted_livelists_dump_mos(spa_t *spa) static int dump_block_stats(spa_t *spa) { - zdb_cb_t zcb; + zdb_cb_t zcb = {{{{0}}}}; zdb_blkstats_t *zb, *tzb; uint64_t norm_alloc, norm_space, total_alloc, total_found; int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | @@ -6422,7 +6413,6 @@ dump_block_stats(spa_t *spa) int e, c, err; bp_embedded_type_t i; - bzero(&zcb, sizeof (zcb)); (void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n", (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "", (dump_opt['c'] == 1) ? "metadata " : "", @@ -6442,7 +6432,6 @@ dump_block_stats(spa_t *spa) * pool claiming each block we discover, but we skip opening any space * maps. */ - bzero(&zcb, sizeof (zdb_cb_t)); zdb_leak_init(spa, &zcb); /* @@ -6815,11 +6804,9 @@ dump_simulated_ddt(spa_t *spa) avl_tree_t t; void *cookie = NULL; zdb_ddt_entry_t *zdde; - ddt_histogram_t ddh_total; - ddt_stat_t dds_total; + ddt_histogram_t ddh_total = {{{0}}}; + ddt_stat_t dds_total = {0}; - bzero(&ddh_total, sizeof (ddh_total)); - bzero(&dds_total, sizeof (dds_total)); avl_create(&t, ddt_entry_compare, sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node)); @@ -7654,8 +7641,7 @@ dump_log_spacemap_obsolete_stats(spa_t *spa) if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) return; - log_sm_obsolete_stats_arg_t lsos; - bzero(&lsos, sizeof (lsos)); + log_sm_obsolete_stats_arg_t lsos = {0}; (void) printf("Log Space Map Obsolete Entry Statistics:\n"); @@ -8050,7 +8036,7 @@ zdb_decompress_block(abd_t *pabd, void *buf, void *lbuf, uint64_t lsize, lbuf, psize, lsize, NULL) == 0 && zio_decompress_data(*cfuncp, pabd, lbuf2, psize, lsize, NULL) == 0 && - bcmp(lbuf, lbuf2, lsize) == 0) + memcmp(lbuf, lbuf2, lsize) == 0) break; } if (*cfuncp != 0) @@ -8368,12 +8354,11 @@ done: static void zdb_embedded_block(char *thing) { - blkptr_t bp; + blkptr_t bp = {{{{0}}}}; unsigned long long *words = (void *)&bp; char *buf; int err; - bzero(&bp, sizeof (bp)); err = sscanf(thing, "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx:" "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx", words + 0, words + 1, words + 2, words + 3, @@ -8566,7 +8551,7 @@ main(int argc, char **argv) } else { char **tmp = umem_alloc((nsearch + 1) * sizeof (char *), UMEM_NOFAIL); - bcopy(searchdirs, tmp, nsearch * + memcpy(tmp, searchdirs, nsearch * sizeof (char *)); umem_free(searchdirs, nsearch * sizeof (char *)); diff --git a/sys/contrib/openzfs/cmd/zed/agents/fmd_api.c b/sys/contrib/openzfs/cmd/zed/agents/fmd_api.c index 4095901dff0..e7eff16fdc0 100644 --- a/sys/contrib/openzfs/cmd/zed/agents/fmd_api.c +++ b/sys/contrib/openzfs/cmd/zed/agents/fmd_api.c @@ -38,7 +38,7 @@ #include #include #include -#include +#include #include #include "fmd_api.h" @@ -342,11 +342,11 @@ fmd_case_uuresolved(fmd_hdl_t *hdl, const char *uuid) fmd_hdl_debug(hdl, "case resolved by uuid (%s)", uuid); } -int +boolean_t fmd_case_solved(fmd_hdl_t *hdl, fmd_case_t *cp) { (void) hdl; - return ((cp->ci_state >= FMD_CASE_SOLVED) ? FMD_B_TRUE : FMD_B_FALSE); + return (cp->ci_state >= FMD_CASE_SOLVED); } void @@ -485,7 +485,7 @@ fmd_buf_read(fmd_hdl_t *hdl, fmd_case_t *cp, assert(cp->ci_bufptr != NULL); assert(size <= cp->ci_bufsiz); - bcopy(cp->ci_bufptr, buf, size); + memcpy(buf, cp->ci_bufptr, size); } void @@ -497,7 +497,7 @@ fmd_buf_write(fmd_hdl_t *hdl, fmd_case_t *cp, assert(cp->ci_bufptr != NULL); assert(cp->ci_bufsiz >= size); - bcopy(buf, cp->ci_bufptr, size); + memcpy(cp->ci_bufptr, buf, size); } /* SERD Engines */ @@ -560,7 +560,7 @@ fmd_serd_record(fmd_hdl_t *hdl, const char *name, fmd_event_t *ep) if ((sgp = fmd_serd_eng_lookup(&mp->mod_serds, name)) == NULL) { zed_log_msg(LOG_ERR, "failed to add record to SERD engine '%s'", name); - return (FMD_B_FALSE); + return (0); } err = fmd_serd_eng_record(sgp, ep->ev_hrt); @@ -581,7 +581,7 @@ _timer_notify(union sigval sv) fmd_hdl_debug(hdl, "timer fired (%p)", ftp->ft_tid); /* disarm the timer */ - bzero(&its, sizeof (struct itimerspec)); + memset(&its, 0, sizeof (struct itimerspec)); timer_settime(ftp->ft_tid, 0, &its, NULL); /* Note that the fmdo_timeout can remove this timer */ diff --git a/sys/contrib/openzfs/cmd/zed/agents/fmd_api.h b/sys/contrib/openzfs/cmd/zed/agents/fmd_api.h index 4f06fb244b7..2c55365c3db 100644 --- a/sys/contrib/openzfs/cmd/zed/agents/fmd_api.h +++ b/sys/contrib/openzfs/cmd/zed/agents/fmd_api.h @@ -72,10 +72,6 @@ typedef struct fmd_case { } fmd_case_t; -#define FMD_B_FALSE 0 /* false value for booleans as int */ -#define FMD_B_TRUE 1 /* true value for booleans as int */ - - #define FMD_CASE_UNSOLVED 0 /* case is not yet solved (waiting) */ #define FMD_CASE_SOLVED 1 /* case is solved (suspects added) */ #define FMD_CASE_CLOSE_WAIT 2 /* case is executing fmdo_close() */ @@ -176,8 +172,7 @@ extern int fmd_case_uuclosed(fmd_hdl_t *, const char *); extern int fmd_case_uuisresolved(fmd_hdl_t *, const char *); extern void fmd_case_uuresolved(fmd_hdl_t *, const char *); -extern int fmd_case_solved(fmd_hdl_t *, fmd_case_t *); -extern int fmd_case_closed(fmd_hdl_t *, fmd_case_t *); +extern boolean_t fmd_case_solved(fmd_hdl_t *, fmd_case_t *); extern void fmd_case_add_ereport(fmd_hdl_t *, fmd_case_t *, fmd_event_t *); extern void fmd_case_add_serd(fmd_hdl_t *, fmd_case_t *, const char *); diff --git a/sys/contrib/openzfs/cmd/zed/agents/fmd_serd.c b/sys/contrib/openzfs/cmd/zed/agents/fmd_serd.c index d4ec37fb769..98c752ae787 100644 --- a/sys/contrib/openzfs/cmd/zed/agents/fmd_serd.c +++ b/sys/contrib/openzfs/cmd/zed/agents/fmd_serd.c @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include #include @@ -74,7 +74,7 @@ fmd_serd_eng_alloc(const char *name, uint64_t n, hrtime_t t) fmd_serd_eng_t *sgp; sgp = malloc(sizeof (fmd_serd_eng_t)); - bzero(sgp, sizeof (fmd_serd_eng_t)); + memset(sgp, 0, sizeof (fmd_serd_eng_t)); sgp->sg_name = strdup(name); sgp->sg_flags = FMD_SERD_DIRTY; @@ -139,7 +139,7 @@ fmd_serd_hash_destroy(fmd_serd_hash_t *shp) } free(shp->sh_hash); - bzero(shp, sizeof (fmd_serd_hash_t)); + memset(shp, 0, sizeof (fmd_serd_hash_t)); } void @@ -234,7 +234,7 @@ fmd_serd_eng_record(fmd_serd_eng_t *sgp, hrtime_t hrt) if (sgp->sg_flags & FMD_SERD_FIRED) { serd_log_msg(" SERD Engine: record %s already fired!", sgp->sg_name); - return (FMD_B_FALSE); + return (B_FALSE); } while (sgp->sg_count >= sgp->sg_n) @@ -259,11 +259,11 @@ fmd_serd_eng_record(fmd_serd_eng_t *sgp, hrtime_t hrt) fmd_event_delta(oep->se_hrt, sep->se_hrt) <= sgp->sg_t) { sgp->sg_flags |= FMD_SERD_FIRED | FMD_SERD_DIRTY; serd_log_msg(" SERD Engine: fired %s", sgp->sg_name); - return (FMD_B_TRUE); + return (B_TRUE); } sgp->sg_flags |= FMD_SERD_DIRTY; - return (FMD_B_FALSE); + return (B_FALSE); } int diff --git a/sys/contrib/openzfs/cmd/zed/agents/zfs_diagnosis.c b/sys/contrib/openzfs/cmd/zed/agents/zfs_diagnosis.c index 3e45a957f70..4fe9ee2bc5b 100644 --- a/sys/contrib/openzfs/cmd/zed/agents/zfs_diagnosis.c +++ b/sys/contrib/openzfs/cmd/zed/agents/zfs_diagnosis.c @@ -27,7 +27,6 @@ #include #include -#include #include #include #include diff --git a/sys/contrib/openzfs/cmd/zfs/zfs_iter.c b/sys/contrib/openzfs/cmd/zfs/zfs_iter.c index 8b6a49a7929..d44bc2ad762 100644 --- a/sys/contrib/openzfs/cmd/zfs/zfs_iter.c +++ b/sys/contrib/openzfs/cmd/zfs/zfs_iter.c @@ -32,7 +32,6 @@ #include #include #include -#include #include diff --git a/sys/contrib/openzfs/cmd/zfs/zfs_main.c b/sys/contrib/openzfs/cmd/zfs/zfs_main.c index 42e4d6f7e19..b153d217df1 100644 --- a/sys/contrib/openzfs/cmd/zfs/zfs_main.c +++ b/sys/contrib/openzfs/cmd/zfs/zfs_main.c @@ -46,7 +46,7 @@ #include #include #include -#include +#include #include #include #include @@ -315,8 +315,9 @@ get_usage(zfs_help_t idx) case HELP_ROLLBACK: return (gettext("\trollback [-rRf] \n")); case HELP_SEND: - return (gettext("\tsend [-DnPpRvLecwhb] [-[i|I] snapshot] " - "\n" + return (gettext("\tsend [-DnPpRvLecwhb] " + "[-X dataset[,dataset]...] " + "[-[i|I] snapshot] \n" "\tsend [-DnvPLecw] [-i snapshot|bookmark] " "\n" "\tsend [-DnPpvLec] [-i bookmark|snapshot] " @@ -498,7 +499,7 @@ usage_prop_cb(int prop, void *cb) * that command. Otherwise, iterate over the entire command table and display * a complete usage message. */ -static void +static __attribute__((noreturn)) void usage(boolean_t requested) { int i; @@ -1997,7 +1998,7 @@ zfs_do_get(int argc, char **argv) zprop_get_cbdata_t cb = { 0 }; int i, c, flags = ZFS_ITER_ARGS_CAN_BE_PATHS; int types = ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK; - char *value, *fields; + char *fields; int ret = 0; int limit = 0; zprop_list_t fake_name = { 0 }; @@ -2037,12 +2038,18 @@ zfs_do_get(int argc, char **argv) * Process the set of columns to display. We zero out * the structure to give us a blank slate. */ - bzero(&cb.cb_columns, sizeof (cb.cb_columns)); + memset(&cb.cb_columns, 0, sizeof (cb.cb_columns)); + i = 0; - while (*optarg != '\0') { - static char *col_subopts[] = - { "name", "property", "value", "received", - "source", "all", NULL }; + for (char *tok; (tok = strsep(&optarg, ",")); ) { + static const char *const col_subopts[] = + { "name", "property", "value", + "received", "source", "all" }; + static const zfs_get_column_t col_subopt_col[] = + { GET_COL_NAME, GET_COL_PROPERTY, GET_COL_VALUE, + GET_COL_RECVD, GET_COL_SOURCE }; + static const int col_subopt_flags[] = + { 0, 0, 0, ZFS_ITER_RECVD_PROPS, 0 }; if (i == ZFS_GET_NCOLS) { (void) fprintf(stderr, gettext("too " @@ -2051,25 +2058,16 @@ zfs_do_get(int argc, char **argv) usage(B_FALSE); } - switch (getsubopt(&optarg, col_subopts, - &value)) { - case 0: - cb.cb_columns[i++] = GET_COL_NAME; - break; - case 1: - cb.cb_columns[i++] = GET_COL_PROPERTY; - break; - case 2: - cb.cb_columns[i++] = GET_COL_VALUE; - break; - case 3: - cb.cb_columns[i++] = GET_COL_RECVD; - flags |= ZFS_ITER_RECVD_PROPS; - break; - case 4: - cb.cb_columns[i++] = GET_COL_SOURCE; - break; - case 5: + for (c = 0; c < ARRAY_SIZE(col_subopts); ++c) + if (strcmp(tok, col_subopts[c]) == 0) + goto found; + + (void) fprintf(stderr, + gettext("invalid column name '%s'\n"), tok); + usage(B_FALSE); + +found: + if (c >= 5) { if (i > 0) { (void) fprintf(stderr, gettext("\"all\" conflicts " @@ -2077,94 +2075,70 @@ zfs_do_get(int argc, char **argv) "given to -o option\n")); usage(B_FALSE); } - cb.cb_columns[0] = GET_COL_NAME; - cb.cb_columns[1] = GET_COL_PROPERTY; - cb.cb_columns[2] = GET_COL_VALUE; - cb.cb_columns[3] = GET_COL_RECVD; - cb.cb_columns[4] = GET_COL_SOURCE; + + memcpy(cb.cb_columns, col_subopt_col, + sizeof (col_subopt_col)); flags |= ZFS_ITER_RECVD_PROPS; i = ZFS_GET_NCOLS; - break; - default: - (void) fprintf(stderr, - gettext("invalid column name " - "'%s'\n"), value); - usage(B_FALSE); + } else { + cb.cb_columns[i++] = col_subopt_col[c]; + flags |= col_subopt_flags[c]; } } break; case 's': cb.cb_sources = 0; - while (*optarg != '\0') { - static char *source_subopts[] = { - "local", "default", "inherited", - "received", "temporary", "none", - NULL }; - switch (getsubopt(&optarg, source_subopts, - &value)) { - case 0: - cb.cb_sources |= ZPROP_SRC_LOCAL; - break; - case 1: - cb.cb_sources |= ZPROP_SRC_DEFAULT; - break; - case 2: - cb.cb_sources |= ZPROP_SRC_INHERITED; - break; - case 3: - cb.cb_sources |= ZPROP_SRC_RECEIVED; - break; - case 4: - cb.cb_sources |= ZPROP_SRC_TEMPORARY; - break; - case 5: - cb.cb_sources |= ZPROP_SRC_NONE; - break; - default: - (void) fprintf(stderr, - gettext("invalid source " - "'%s'\n"), value); - usage(B_FALSE); - } + for (char *tok; (tok = strsep(&optarg, ",")); ) { + static const char *const source_opt[] = { + "local", "default", + "inherited", "received", + "temporary", "none" }; + static const int source_flg[] = { + ZPROP_SRC_LOCAL, ZPROP_SRC_DEFAULT, + ZPROP_SRC_INHERITED, ZPROP_SRC_RECEIVED, + ZPROP_SRC_TEMPORARY, ZPROP_SRC_NONE }; + + for (i = 0; i < ARRAY_SIZE(source_opt); ++i) + if (strcmp(tok, source_opt[i]) == 0) { + cb.cb_sources |= source_flg[i]; + goto found2; + } + + (void) fprintf(stderr, + gettext("invalid source '%s'\n"), tok); + usage(B_FALSE); +found2:; } break; case 't': types = 0; flags &= ~ZFS_ITER_PROP_LISTSNAPS; - while (*optarg != '\0') { - static char *type_subopts[] = { "filesystem", - "volume", "snapshot", "snap", "bookmark", - "all", NULL }; - switch (getsubopt(&optarg, type_subopts, - &value)) { - case 0: - types |= ZFS_TYPE_FILESYSTEM; - break; - case 1: - types |= ZFS_TYPE_VOLUME; - break; - case 2: - case 3: - types |= ZFS_TYPE_SNAPSHOT; - break; - case 4: - types |= ZFS_TYPE_BOOKMARK; - break; - case 5: - types = ZFS_TYPE_DATASET | - ZFS_TYPE_BOOKMARK; - break; + for (char *tok; (tok = strsep(&optarg, ",")); ) { + static const char *const type_opts[] = { + "filesystem", "volume", + "snapshot", "snap", + "bookmark", + "all" }; + static const int type_types[] = { + ZFS_TYPE_FILESYSTEM, ZFS_TYPE_VOLUME, + ZFS_TYPE_SNAPSHOT, ZFS_TYPE_SNAPSHOT, + ZFS_TYPE_BOOKMARK, + ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK }; - default: - (void) fprintf(stderr, - gettext("invalid type '%s'\n"), - value); - usage(B_FALSE); - } + for (i = 0; i < ARRAY_SIZE(type_opts); ++i) + if (strcmp(tok, type_opts[i]) == 0) { + types |= type_types[i]; + goto found3; + } + + (void) fprintf(stderr, + gettext("invalid type '%s'\n"), tok); + usage(B_FALSE); +found3:; } break; @@ -3578,13 +3552,12 @@ static int zfs_do_list(int argc, char **argv) { int c; - static char default_fields[] = + char default_fields[] = "name,used,available,referenced,mountpoint"; int types = ZFS_TYPE_DATASET; boolean_t types_specified = B_FALSE; - char *fields = NULL; + char *fields = default_fields; list_cbdata_t cb = { 0 }; - char *value; int limit = 0; int ret = 0; zfs_sort_column_t *sortcol = NULL; @@ -3629,36 +3602,29 @@ zfs_do_list(int argc, char **argv) types = 0; types_specified = B_TRUE; flags &= ~ZFS_ITER_PROP_LISTSNAPS; - while (*optarg != '\0') { - static char *type_subopts[] = { "filesystem", - "volume", "snapshot", "snap", "bookmark", - "all", NULL }; - switch (getsubopt(&optarg, type_subopts, - &value)) { - case 0: - types |= ZFS_TYPE_FILESYSTEM; - break; - case 1: - types |= ZFS_TYPE_VOLUME; - break; - case 2: - case 3: - types |= ZFS_TYPE_SNAPSHOT; - break; - case 4: - types |= ZFS_TYPE_BOOKMARK; - break; - case 5: - types = ZFS_TYPE_DATASET | - ZFS_TYPE_BOOKMARK; - break; - default: - (void) fprintf(stderr, - gettext("invalid type '%s'\n"), - value); - usage(B_FALSE); - } + for (char *tok; (tok = strsep(&optarg, ",")); ) { + static const char *const type_subopts[] = { + "filesystem", "volume", + "snapshot", "snap", + "bookmark", + "all" }; + static const int type_types[] = { + ZFS_TYPE_FILESYSTEM, ZFS_TYPE_VOLUME, + ZFS_TYPE_SNAPSHOT, ZFS_TYPE_SNAPSHOT, + ZFS_TYPE_BOOKMARK, + ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK }; + + for (c = 0; c < ARRAY_SIZE(type_subopts); ++c) + if (strcmp(tok, type_subopts[c]) == 0) { + types |= type_types[c]; + goto found3; + } + + (void) fprintf(stderr, + gettext("invalid type '%s'\n"), tok); + usage(B_FALSE); +found3:; } break; case ':': @@ -3676,9 +3642,6 @@ zfs_do_list(int argc, char **argv) argc -= optind; argv += optind; - if (fields == NULL) - fields = default_fields; - /* * If we are only going to list snapshot names and sort by name, * then we can use faster version. @@ -4355,6 +4318,77 @@ usage: return (-1); } +typedef struct zfs_send_exclude_arg { + size_t count; + char **list; +} zfs_send_exclude_arg_t; + +/* + * This function creates the zfs_send_exclude_arg_t + * object described above; it can be called multiple + * times, and the input can be comma-separated. + * This is NOT the most efficient data layout; however, + * I couldn't think of a non-pathological case where + * it should have more than a couple dozen instances + * of excludes. If that turns out to be used in + * practice, we might want to instead use a tree. + */ +static void +add_dataset_excludes(char *exclude, zfs_send_exclude_arg_t *context) +{ + char *tok; + while ((tok = strsep(&exclude, ",")) != NULL) { + if (!zfs_name_valid(tok, ZFS_TYPE_DATASET) || + strchr(tok, '/') == NULL) { + (void) fprintf(stderr, gettext("-X %s: " + "not a valid non-root dataset name.\n"), tok); + usage(B_FALSE); + } + context->list = safe_realloc(context->list, + (sizeof (char *)) * (context->count + 1)); + context->list[context->count++] = tok; + } +} + +static void +free_dataset_excludes(zfs_send_exclude_arg_t *exclude_list) +{ + free(exclude_list->list); +} + +/* + * This is the call back used by zfs_send to + * determine if a dataset should be skipped. + * As stated above, this is not the most efficient + * data structure to use, but as long as the + * number of excluded datasets is relatively + * small (a couple of dozen or so), it won't + * have a big impact on performance on modern + * processors. Since it's excluding hierarchies, + * we'd probably want to move to a more complex + * tree structure in that case. + */ +static boolean_t +zfs_do_send_exclude(zfs_handle_t *zhp, void *context) +{ + zfs_send_exclude_arg_t *exclude = context; + const char *name = zfs_get_name(zhp); + + for (size_t indx = 0; indx < exclude->count; indx++) { + char *exclude_name = exclude->list[indx]; + size_t len = strlen(exclude_name); + /* If it's shorter, it can't possibly match */ + if (strlen(name) < len) + continue; + if (strncmp(name, exclude_name, len) == 0 && + (name[len] == '/' || name[len] == '\0' || + name[len] == '@')) { + return (B_FALSE); + } + } + + return (B_TRUE); +} /* * Send a backup stream to stdout. @@ -4371,6 +4405,7 @@ zfs_do_send(int argc, char **argv) int c, err; nvlist_t *dbgnv = NULL; char *redactbook = NULL; + zfs_send_exclude_arg_t exclude_context = { 0 }; struct option long_options[] = { {"replicate", no_argument, NULL, 'R'}, @@ -4389,13 +4424,17 @@ zfs_do_send(int argc, char **argv) {"backup", no_argument, NULL, 'b'}, {"holds", no_argument, NULL, 'h'}, {"saved", no_argument, NULL, 'S'}, + {"exclude", required_argument, NULL, 'X'}, {0, 0, 0, 0} }; /* check options */ - while ((c = getopt_long(argc, argv, ":i:I:RsDpvnPLeht:cwbd:S", + while ((c = getopt_long(argc, argv, ":i:I:RsDpvnPLeht:cwbd:SX:", long_options, NULL)) != -1) { switch (c) { + case 'X': + add_dataset_excludes(optarg, &exclude_context); + break; case 'i': if (fromname) usage(B_FALSE); @@ -4505,6 +4544,13 @@ zfs_do_send(int argc, char **argv) if (flags.parsable && flags.verbosity == 0) flags.verbosity = 1; + if (exclude_context.count > 0 && !flags.replicate) { + (void) fprintf(stderr, gettext("Cannot specify " + "dataset exclusion (-X) on a non-recursive " + "send.\n")); + return (1); + } + argc -= optind; argv += optind; @@ -4686,8 +4732,11 @@ zfs_do_send(int argc, char **argv) if (flags.replicate && fromname == NULL) flags.doall = B_TRUE; - err = zfs_send(zhp, fromname, toname, &flags, STDOUT_FILENO, NULL, 0, - flags.verbosity >= 3 ? &dbgnv : NULL); + err = zfs_send(zhp, fromname, toname, &flags, STDOUT_FILENO, + exclude_context.count > 0 ? zfs_do_send_exclude : NULL, + &exclude_context, flags.verbosity >= 3 ? &dbgnv : NULL); + + free_dataset_excludes(&exclude_context); if (flags.verbosity >= 3 && dbgnv != NULL) { /* @@ -5104,7 +5153,7 @@ deleg_perm_compare(const void *larg, const void *rarg, void *unused) static inline void fs_perm_set_init(fs_perm_set_t *fspset) { - bzero(fspset, sizeof (fs_perm_set_t)); + memset(fspset, 0, sizeof (fs_perm_set_t)); if ((fspset->fsps_list_pool = uu_list_pool_create("fsps_list_pool", sizeof (fs_perm_node_t), offsetof(fs_perm_node_t, fspn_list_node), @@ -5171,7 +5220,7 @@ who_perm_init(who_perm_t *who_perm, fs_perm_t *fsperm, uu_avl_pool_t *pool; pool = fsperm->fsp_set->fsps_deleg_perm_avl_pool; - bzero(who_perm, sizeof (who_perm_t)); + memset(who_perm, 0, sizeof (who_perm_t)); if ((who_perm->who_deleg_perm_avl = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL) @@ -5205,7 +5254,7 @@ fs_perm_init(fs_perm_t *fsperm, fs_perm_set_t *fspset, const char *fsname) uu_avl_pool_t *nset_pool = fspset->fsps_named_set_avl_pool; uu_avl_pool_t *who_pool = fspset->fsps_who_perm_avl_pool; - bzero(fsperm, sizeof (fs_perm_t)); + memset(fsperm, 0, sizeof (fs_perm_t)); if ((fsperm->fsp_sc_avl = uu_avl_create(nset_pool, NULL, UU_DEFAULT)) == NULL) @@ -8503,27 +8552,25 @@ zfs_do_wait(int argc, char **argv) while ((c = getopt(argc, argv, "t:")) != -1) { switch (c) { case 't': - { - static char *col_subopts[] = { "deleteq", NULL }; - char *value; - /* Reset activities array */ - bzero(&enabled, sizeof (enabled)); - while (*optarg != '\0') { - int activity = getsubopt(&optarg, col_subopts, - &value); + memset(&enabled, 0, sizeof (enabled)); - if (activity < 0) { - (void) fprintf(stderr, - gettext("invalid activity '%s'\n"), - value); - usage(B_FALSE); - } + for (char *tok; (tok = strsep(&optarg, ",")); ) { + static const char *const col_subopts[ + ZFS_WAIT_NUM_ACTIVITIES] = { "deleteq" }; - enabled[activity] = B_TRUE; + for (i = 0; i < ARRAY_SIZE(col_subopts); ++i) + if (strcmp(tok, col_subopts[i]) == 0) { + enabled[i] = B_TRUE; + goto found; + } + + (void) fprintf(stderr, + gettext("invalid activity '%s'\n"), tok); + usage(B_FALSE); +found:; } break; - } case '?': (void) fprintf(stderr, gettext("invalid option '%c'\n"), optopt); diff --git a/sys/contrib/openzfs/cmd/zfs/zfs_project.c b/sys/contrib/openzfs/cmd/zfs/zfs_project.c index 341cc005de4..757d043582a 100644 --- a/sys/contrib/openzfs/cmd/zfs/zfs_project.c +++ b/sys/contrib/openzfs/cmd/zfs/zfs_project.c @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c b/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c index 6c8f7c6127a..853931c6ad6 100644 --- a/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c +++ b/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c @@ -36,7 +36,7 @@ #include #include -static _Noreturn void +static __attribute__((noreturn)) void usage(void) { (void) fprintf(stderr, diff --git a/sys/contrib/openzfs/cmd/zhack/zhack.c b/sys/contrib/openzfs/cmd/zhack/zhack.c index 92d20d753ae..71a2c5ae6c3 100644 --- a/sys/contrib/openzfs/cmd/zhack/zhack.c +++ b/sys/contrib/openzfs/cmd/zhack/zhack.c @@ -57,7 +57,7 @@ static importargs_t g_importargs; static char *g_pool; static boolean_t g_readonly; -static _Noreturn void +static __attribute__((noreturn)) void usage(void) { (void) fprintf(stderr, @@ -87,7 +87,7 @@ usage(void) } -static __attribute__((format(printf, 3, 4))) _Noreturn void +static __attribute__((format(printf, 3, 4))) __attribute__((noreturn)) void fatal(spa_t *spa, void *tag, const char *fmt, ...) { va_list ap; @@ -484,15 +484,12 @@ zhack_repair_label_cksum(int argc, char **argv) zio_checksum_info_t *ci = &zio_checksum_table[ZIO_CHECKSUM_LABEL]; const char *cfg_keys[] = { ZPOOL_CONFIG_VERSION, ZPOOL_CONFIG_POOL_STATE, ZPOOL_CONFIG_GUID }; - boolean_t labels_repaired[VDEV_LABELS]; + boolean_t labels_repaired[VDEV_LABELS] = {0}; boolean_t repaired = B_FALSE; - vdev_label_t labels[VDEV_LABELS]; + vdev_label_t labels[VDEV_LABELS] = {{{0}}}; struct stat st; int fd; - bzero(labels_repaired, sizeof (labels_repaired)); - bzero(labels, sizeof (labels)); - abd_init(); argc -= 1; diff --git a/sys/contrib/openzfs/cmd/zinject/translate.c b/sys/contrib/openzfs/cmd/zinject/translate.c index 4939c0b85b5..2b5f1fcd99b 100644 --- a/sys/contrib/openzfs/cmd/zinject/translate.c +++ b/sys/contrib/openzfs/cmd/zinject/translate.c @@ -31,7 +31,7 @@ #include #include #include -#include +#include #include #include #include @@ -186,6 +186,7 @@ initialize_range(err_type_t type, int level, char *range, switch (type) { default: break; + case TYPE_DATA: break; diff --git a/sys/contrib/openzfs/cmd/zinject/zinject.c b/sys/contrib/openzfs/cmd/zinject/zinject.c index 10d5dbe9004..74c54baebf6 100644 --- a/sys/contrib/openzfs/cmd/zinject/zinject.c +++ b/sys/contrib/openzfs/cmd/zinject/zinject.c @@ -144,6 +144,7 @@ #include #include #include +#include #include #include @@ -159,7 +160,7 @@ libzfs_handle_t *g_zfs; int zfs_fd; -static const char *errtable[TYPE_INVAL] = { +static const char *const errtable[TYPE_INVAL] = { "data", "dnode", "mos", diff --git a/sys/contrib/openzfs/cmd/zpool/os/linux/zpool_vdev_os.c b/sys/contrib/openzfs/cmd/zpool/os/linux/zpool_vdev_os.c index 9d2c21c2a87..ed157c627db 100644 --- a/sys/contrib/openzfs/cmd/zpool/os/linux/zpool_vdev_os.c +++ b/sys/contrib/openzfs/cmd/zpool/os/linux/zpool_vdev_os.c @@ -81,7 +81,6 @@ #include #include #include -#include #include #include #include diff --git a/sys/contrib/openzfs/cmd/zpool/zpool_iter.c b/sys/contrib/openzfs/cmd/zpool/zpool_iter.c index 65e53f8e0e2..ec3f768e316 100644 --- a/sys/contrib/openzfs/cmd/zpool/zpool_iter.c +++ b/sys/contrib/openzfs/cmd/zpool/zpool_iter.c @@ -32,7 +32,7 @@ #include #include #include -#include +#include #include #include diff --git a/sys/contrib/openzfs/cmd/zpool/zpool_main.c b/sys/contrib/openzfs/cmd/zpool/zpool_main.c index 717d8b806d7..5d1cae3e955 100644 --- a/sys/contrib/openzfs/cmd/zpool/zpool_main.c +++ b/sys/contrib/openzfs/cmd/zpool/zpool_main.c @@ -50,7 +50,6 @@ #include #include #include -#include #include #include #include @@ -519,7 +518,7 @@ print_vdev_prop_cb(int prop, void *cb) * that command. Otherwise, iterate over the entire command table and display * a complete usage message. */ -static void +static __attribute__((noreturn)) void usage(boolean_t requested) { FILE *fp = requested ? stdout : stderr; @@ -6067,6 +6066,7 @@ print_one_column(zpool_prop_t prop, uint64_t value, const char *str, size_t width = zprop_width(prop, &fixed, ZFS_TYPE_POOL); switch (prop) { + case ZPOOL_PROP_SIZE: case ZPOOL_PROP_EXPANDSZ: case ZPOOL_PROP_CHECKPOINT: case ZPOOL_PROP_DEDUPRATIO: @@ -6162,8 +6162,12 @@ print_list_stats(zpool_handle_t *zhp, const char *name, nvlist_t *nv, * 'toplevel' boolean value is passed to the print_one_column() * to indicate that the value is valid. */ - print_one_column(ZPOOL_PROP_SIZE, vs->vs_space, NULL, scripted, - toplevel, format); + if (vs->vs_pspace) + print_one_column(ZPOOL_PROP_SIZE, vs->vs_pspace, NULL, + scripted, B_TRUE, format); + else + print_one_column(ZPOOL_PROP_SIZE, vs->vs_space, NULL, + scripted, toplevel, format); print_one_column(ZPOOL_PROP_ALLOCATED, vs->vs_alloc, NULL, scripted, toplevel, format); print_one_column(ZPOOL_PROP_FREE, vs->vs_space - vs->vs_alloc, @@ -10065,7 +10069,6 @@ zpool_do_get(int argc, char **argv) zprop_list_t fake_name = { 0 }; int ret; int c, i; - char *value; char *propstr = NULL; cb.cb_first = B_TRUE; @@ -10092,35 +10095,34 @@ zpool_do_get(int argc, char **argv) cb.cb_scripted = B_TRUE; break; case 'o': - bzero(&cb.cb_columns, sizeof (cb.cb_columns)); + memset(&cb.cb_columns, 0, sizeof (cb.cb_columns)); i = 0; - while (*optarg != '\0') { - static char *col_subopts[] = - { "name", "property", "value", "source", - "all", NULL }; - if (i == ZFS_GET_NCOLS) { + for (char *tok; (tok = strsep(&optarg, ",")); ) { + static const char *const col_opts[] = + { "name", "property", "value", "source", + "all" }; + static const zfs_get_column_t col_cols[] = + { GET_COL_NAME, GET_COL_PROPERTY, GET_COL_VALUE, + GET_COL_SOURCE }; + + if (i == ZFS_GET_NCOLS - 1) { (void) fprintf(stderr, gettext("too " "many fields given to -o " "option\n")); usage(B_FALSE); } - switch (getsubopt(&optarg, col_subopts, - &value)) { - case 0: - cb.cb_columns[i++] = GET_COL_NAME; - break; - case 1: - cb.cb_columns[i++] = GET_COL_PROPERTY; - break; - case 2: - cb.cb_columns[i++] = GET_COL_VALUE; - break; - case 3: - cb.cb_columns[i++] = GET_COL_SOURCE; - break; - case 4: + for (c = 0; c < ARRAY_SIZE(col_opts); ++c) + if (strcmp(tok, col_opts[c]) == 0) + goto found; + + (void) fprintf(stderr, + gettext("invalid column name '%s'\n"), tok); + usage(B_FALSE); + +found: + if (c >= 4) { if (i > 0) { (void) fprintf(stderr, gettext("\"all\" conflicts " @@ -10128,18 +10130,12 @@ zpool_do_get(int argc, char **argv) "given to -o option\n")); usage(B_FALSE); } - cb.cb_columns[0] = GET_COL_NAME; - cb.cb_columns[1] = GET_COL_PROPERTY; - cb.cb_columns[2] = GET_COL_VALUE; - cb.cb_columns[3] = GET_COL_SOURCE; - i = ZFS_GET_NCOLS; - break; - default: - (void) fprintf(stderr, - gettext("invalid column name " - "'%s'\n"), value); - usage(B_FALSE); - } + + memcpy(cb.cb_columns, col_cols, + sizeof (col_cols)); + i = ZFS_GET_NCOLS - 1; + } else + cb.cb_columns[i++] = col_cols[c]; } break; case '?': @@ -10667,9 +10663,7 @@ int zpool_do_wait(int argc, char **argv) { boolean_t verbose = B_FALSE; - int c; - char *value; - int i; + int c, i; unsigned long count; pthread_t status_thr; int error = 0; @@ -10703,28 +10697,26 @@ zpool_do_wait(int argc, char **argv) get_timestamp_arg(*optarg); break; case 't': - { - static char *col_subopts[] = { "discard", "free", - "initialize", "replace", "remove", "resilver", - "scrub", "trim", NULL }; - /* Reset activities array */ - bzero(&wd.wd_enabled, sizeof (wd.wd_enabled)); - while (*optarg != '\0') { - int activity = getsubopt(&optarg, col_subopts, - &value); + memset(&wd.wd_enabled, 0, sizeof (wd.wd_enabled)); - if (activity < 0) { - (void) fprintf(stderr, - gettext("invalid activity '%s'\n"), - value); - usage(B_FALSE); - } + for (char *tok; (tok = strsep(&optarg, ",")); ) { + static const char *const col_opts[] = { + "discard", "free", "initialize", "replace", + "remove", "resilver", "scrub", "trim" }; - wd.wd_enabled[activity] = B_TRUE; + for (i = 0; i < ARRAY_SIZE(col_opts); ++i) + if (strcmp(tok, col_opts[i]) == 0) { + wd.wd_enabled[i] = B_TRUE; + goto found; + } + + (void) fprintf(stderr, + gettext("invalid activity '%s'\n"), tok); + usage(B_FALSE); +found:; } break; - } case '?': (void) fprintf(stderr, gettext("invalid option '%c'\n"), optopt); diff --git a/sys/contrib/openzfs/cmd/zpool/zpool_util.c b/sys/contrib/openzfs/cmd/zpool/zpool_util.c index 1c64c83d8ff..91dbb8ec4f7 100644 --- a/sys/contrib/openzfs/cmd/zpool/zpool_util.c +++ b/sys/contrib/openzfs/cmd/zpool/zpool_util.c @@ -28,7 +28,7 @@ #include #include #include -#include +#include #include #include "zpool_util.h" diff --git a/sys/contrib/openzfs/cmd/zstream/zstream.c b/sys/contrib/openzfs/cmd/zstream/zstream.c index 523ae068971..a228f45fad7 100644 --- a/sys/contrib/openzfs/cmd/zstream/zstream.c +++ b/sys/contrib/openzfs/cmd/zstream/zstream.c @@ -23,7 +23,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/sys/contrib/openzfs/cmd/zstream/zstream_dump.c b/sys/contrib/openzfs/cmd/zstream/zstream_dump.c index 04a4986b45d..977256cae40 100644 --- a/sys/contrib/openzfs/cmd/zstream/zstream_dump.c +++ b/sys/contrib/openzfs/cmd/zstream/zstream_dump.c @@ -34,7 +34,7 @@ #include #include #include -#include +#include #include #include diff --git a/sys/contrib/openzfs/cmd/zstream/zstream_redup.c b/sys/contrib/openzfs/cmd/zstream/zstream_redup.c index 474527e76ea..20aff17ae65 100644 --- a/sys/contrib/openzfs/cmd/zstream/zstream_redup.c +++ b/sys/contrib/openzfs/cmd/zstream/zstream_redup.c @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include #include #include @@ -229,7 +229,7 @@ zfs_redup_stream(int infd, int outfd, boolean_t verbose) * We need to regenerate the checksum. */ if (drr->drr_type != DRR_BEGIN) { - bzero(&drr->drr_u.drr_checksum.drr_checksum, + memset(&drr->drr_u.drr_checksum.drr_checksum, 0, sizeof (drr->drr_u.drr_checksum.drr_checksum)); } @@ -380,7 +380,7 @@ zfs_redup_stream(int infd, int outfd, boolean_t verbose) * a checksum. */ if (drr->drr_type != DRR_BEGIN) { - bzero(&drr->drr_u.drr_checksum.drr_checksum, + memset(&drr->drr_u.drr_checksum.drr_checksum, 0, sizeof (drr->drr_u.drr_checksum.drr_checksum)); } if (dump_record(drr, buf, payload_size, diff --git a/sys/contrib/openzfs/cmd/zstream/zstream_token.c b/sys/contrib/openzfs/cmd/zstream/zstream_token.c index 36a76a4bb85..bedb6893c50 100644 --- a/sys/contrib/openzfs/cmd/zstream/zstream_token.c +++ b/sys/contrib/openzfs/cmd/zstream/zstream_token.c @@ -34,7 +34,7 @@ #include #include #include -#include +#include #include #include diff --git a/sys/contrib/openzfs/cmd/ztest/ztest.c b/sys/contrib/openzfs/cmd/ztest/ztest.c index 292493584bf..d60422279ad 100644 --- a/sys/contrib/openzfs/cmd/ztest/ztest.c +++ b/sys/contrib/openzfs/cmd/ztest/ztest.c @@ -558,7 +558,7 @@ enum ztest_object { ZTEST_OBJECTS }; -static _Noreturn void usage(boolean_t); +static __attribute__((noreturn)) void usage(boolean_t requested); static int ztest_scrub_impl(spa_t *spa); /* @@ -622,7 +622,7 @@ static void sig_handler(int signo) char *fatal_msg; -static __attribute__((format(printf, 2, 3))) _Noreturn void +static __attribute__((format(printf, 2, 3))) __attribute__((noreturn)) void fatal(int do_perror, char *message, ...) { va_list args; @@ -831,7 +831,7 @@ fini_options(void) short_opts = NULL; } -static void +static __attribute__((noreturn)) void usage(boolean_t requested) { char option[80]; @@ -930,9 +930,9 @@ process_options(int argc, char **argv) int opt; uint64_t value; char altdir[MAXNAMELEN] = { 0 }; - char raid_kind[8] = { "random" }; + char raid_kind[8] = "random"; - bcopy(&ztest_opts_defaults, zo, sizeof (*zo)); + memcpy(zo, &ztest_opts_defaults, sizeof (*zo)); init_options(); @@ -1887,7 +1887,7 @@ ztest_log_create(ztest_ds_t *zd, dmu_tx_t *tx, lr_create_t *lr) return; itx = zil_itx_create(TX_CREATE, sizeof (*lr) + namesize); - bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, + memcpy(&itx->itx_lr + 1, &lr->lr_common + 1, sizeof (*lr) + namesize - sizeof (lr_t)); zil_itx_assign(zd->zd_zilog, itx, tx); @@ -1904,7 +1904,7 @@ ztest_log_remove(ztest_ds_t *zd, dmu_tx_t *tx, lr_remove_t *lr, uint64_t object) return; itx = zil_itx_create(TX_REMOVE, sizeof (*lr) + namesize); - bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, + memcpy(&itx->itx_lr + 1, &lr->lr_common + 1, sizeof (*lr) + namesize - sizeof (lr_t)); itx->itx_oid = object; @@ -1937,7 +1937,7 @@ ztest_log_write(ztest_ds_t *zd, dmu_tx_t *tx, lr_write_t *lr) itx->itx_wr_state = write_state; itx->itx_sync = (ztest_random(8) == 0); - bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, + memcpy(&itx->itx_lr + 1, &lr->lr_common + 1, sizeof (*lr) - sizeof (lr_t)); zil_itx_assign(zd->zd_zilog, itx, tx); @@ -1952,7 +1952,7 @@ ztest_log_truncate(ztest_ds_t *zd, dmu_tx_t *tx, lr_truncate_t *lr) return; itx = zil_itx_create(TX_TRUNCATE, sizeof (*lr)); - bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, + memcpy(&itx->itx_lr + 1, &lr->lr_common + 1, sizeof (*lr) - sizeof (lr_t)); itx->itx_sync = B_FALSE; @@ -1968,7 +1968,7 @@ ztest_log_setattr(ztest_ds_t *zd, dmu_tx_t *tx, lr_setattr_t *lr) return; itx = zil_itx_create(TX_SETATTR, sizeof (*lr)); - bcopy(&lr->lr_common + 1, &itx->itx_lr + 1, + memcpy(&itx->itx_lr + 1, &lr->lr_common + 1, sizeof (*lr) - sizeof (lr_t)); itx->itx_sync = B_FALSE; @@ -2233,7 +2233,7 @@ ztest_replay_write(void *arg1, void *arg2, boolean_t byteswap) if (abuf == NULL) { dmu_write(os, lr->lr_foid, offset, length, data, tx); } else { - bcopy(data, abuf->b_data, length); + memcpy(abuf->b_data, data, length); dmu_assign_arcbuf_by_dbuf(db, offset, abuf, tx); } @@ -2506,7 +2506,7 @@ ztest_lr_alloc(size_t lrsize, char *name) lr = umem_zalloc(lrsize + namesize, UMEM_NOFAIL); if (name) - bcopy(name, lr + lrsize, namesize); + memcpy(lr + lrsize, name, namesize); return (lr); } @@ -2663,7 +2663,7 @@ ztest_write(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size, lr->lr_blkoff = 0; BP_ZERO(&lr->lr_blkptr); - bcopy(data, lr + 1, size); + memcpy(lr + 1, data, size); error = ztest_replay_write(zd, lr, B_FALSE); @@ -2787,7 +2787,7 @@ ztest_io(ztest_ds_t *zd, uint64_t object, uint64_t offset) break; case ZTEST_IO_WRITE_ZEROES: - bzero(data, blocksize); + memset(data, 0, blocksize); (void) ztest_write(zd, object, offset, blocksize, data); break; @@ -4844,16 +4844,16 @@ ztest_dmu_read_write(ztest_ds_t *zd, uint64_t id) "got %"PRIx64", wanted %"PRIx64"+%"PRIx64"", pack->bw_index, n, i); - if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0) + if (memcmp(pack, bigH, sizeof (bufwad_t)) != 0) fatal(B_FALSE, "pack/bigH mismatch in %p/%p", pack, bigH); - if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0) + if (memcmp(pack, bigT, sizeof (bufwad_t)) != 0) fatal(B_FALSE, "pack/bigT mismatch in %p/%p", pack, bigT); if (freeit) { - bzero(pack, sizeof (bufwad_t)); + memset(pack, 0, sizeof (bufwad_t)); } else { pack->bw_index = n + i; pack->bw_txg = txg; @@ -4899,8 +4899,8 @@ ztest_dmu_read_write(ztest_ds_t *zd, uint64_t id) VERIFY0(dmu_read(os, bigobj, bigoff, bigsize, bigcheck, DMU_READ_PREFETCH)); - ASSERT0(bcmp(packbuf, packcheck, packsize)); - ASSERT0(bcmp(bigbuf, bigcheck, bigsize)); + ASSERT0(memcmp(packbuf, packcheck, packsize)); + ASSERT0(memcmp(bigbuf, bigcheck, bigsize)); umem_free(packcheck, packsize); umem_free(bigcheck, bigsize); @@ -4947,11 +4947,11 @@ compare_and_update_pbbufs(uint64_t s, bufwad_t *packbuf, bufwad_t *bigbuf, "got %"PRIx64", wanted %"PRIx64"+%"PRIx64"", pack->bw_index, n, i); - if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0) + if (memcmp(pack, bigH, sizeof (bufwad_t)) != 0) fatal(B_FALSE, "pack/bigH mismatch in %p/%p", pack, bigH); - if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0) + if (memcmp(pack, bigT, sizeof (bufwad_t)) != 0) fatal(B_FALSE, "pack/bigT mismatch in %p/%p", pack, bigT); @@ -5139,15 +5139,16 @@ ztest_dmu_read_write_zcopy(ztest_ds_t *zd, uint64_t id) for (off = bigoff, j = 0; j < s; j++, off += chunksize) { dmu_buf_t *dbt; if (i != 5 || chunksize < (SPA_MINBLOCKSIZE * 2)) { - bcopy((caddr_t)bigbuf + (off - bigoff), - bigbuf_arcbufs[j]->b_data, chunksize); + memcpy(bigbuf_arcbufs[j]->b_data, + (caddr_t)bigbuf + (off - bigoff), + chunksize); } else { - bcopy((caddr_t)bigbuf + (off - bigoff), - bigbuf_arcbufs[2 * j]->b_data, + memcpy(bigbuf_arcbufs[2 * j]->b_data, + (caddr_t)bigbuf + (off - bigoff), chunksize / 2); - bcopy((caddr_t)bigbuf + (off - bigoff) + + memcpy(bigbuf_arcbufs[2 * j + 1]->b_data, + (caddr_t)bigbuf + (off - bigoff) + chunksize / 2, - bigbuf_arcbufs[2 * j + 1]->b_data, chunksize / 2); } @@ -5183,8 +5184,8 @@ ztest_dmu_read_write_zcopy(ztest_ds_t *zd, uint64_t id) VERIFY0(dmu_read(os, bigobj, bigoff, bigsize, bigcheck, DMU_READ_PREFETCH)); - ASSERT0(bcmp(packbuf, packcheck, packsize)); - ASSERT0(bcmp(bigbuf, bigcheck, bigsize)); + ASSERT0(memcmp(packbuf, packcheck, packsize)); + ASSERT0(memcmp(bigbuf, bigcheck, bigsize)); umem_free(packcheck, packsize); umem_free(bigcheck, bigsize); @@ -5337,7 +5338,7 @@ ztest_zap(ztest_ds_t *zd, uint64_t id) prop = ztest_random(ZTEST_ZAP_MAX_PROPS); (void) sprintf(propname, "prop_%"PRIu64"", prop); (void) sprintf(txgname, "txg_%"PRIu64"", prop); - bzero(value, sizeof (value)); + memset(value, 0, sizeof (value)); last_txg = 0; /* @@ -5529,11 +5530,11 @@ ztest_zap_parallel(ztest_ds_t *zd, uint64_t id) umem_free(od, sizeof (ztest_od_t)); return; } - bcopy(name, string_value, namelen); + memcpy(string_value, name, namelen); } else { tx = NULL; txg = 0; - bzero(string_value, namelen); + memset(string_value, 0, namelen); } switch (i) { @@ -5552,7 +5553,7 @@ ztest_zap_parallel(ztest_ds_t *zd, uint64_t id) error = zap_lookup(os, object, name, wsize, wc, data); if (error == 0) { if (data == string_value && - bcmp(name, data, namelen) != 0) + memcmp(name, data, namelen) != 0) fatal(B_FALSE, "name '%s' != val '%s' len %d", name, (char *)data, namelen); } else { @@ -6436,8 +6437,8 @@ ztest_fletcher(ztest_ds_t *zd, uint64_t id) fletcher_4_byteswap(buf, size, NULL, &zc_byteswap); fletcher_4_native(buf, size, NULL, &zc); - VERIFY0(bcmp(&zc, &zc_ref, sizeof (zc))); - VERIFY0(bcmp(&zc_byteswap, &zc_ref_byteswap, + VERIFY0(memcmp(&zc, &zc_ref, sizeof (zc))); + VERIFY0(memcmp(&zc_byteswap, &zc_ref_byteswap, sizeof (zc_byteswap))); /* Test ABD - data */ @@ -6445,8 +6446,8 @@ ztest_fletcher(ztest_ds_t *zd, uint64_t id) &zc_byteswap); abd_fletcher_4_native(abd_data, size, NULL, &zc); - VERIFY0(bcmp(&zc, &zc_ref, sizeof (zc))); - VERIFY0(bcmp(&zc_byteswap, &zc_ref_byteswap, + VERIFY0(memcmp(&zc, &zc_ref, sizeof (zc))); + VERIFY0(memcmp(&zc_byteswap, &zc_ref_byteswap, sizeof (zc_byteswap))); /* Test ABD - metadata */ @@ -6454,8 +6455,8 @@ ztest_fletcher(ztest_ds_t *zd, uint64_t id) &zc_byteswap); abd_fletcher_4_native(abd_meta, size, NULL, &zc); - VERIFY0(bcmp(&zc, &zc_ref, sizeof (zc))); - VERIFY0(bcmp(&zc_byteswap, &zc_ref_byteswap, + VERIFY0(memcmp(&zc, &zc_ref, sizeof (zc))); + VERIFY0(memcmp(&zc_byteswap, &zc_ref_byteswap, sizeof (zc_byteswap))); } @@ -6993,7 +6994,7 @@ ztest_resume(spa_t *spa) (void) zio_resume(spa); } -static _Noreturn void +static __attribute__((noreturn)) void ztest_resume_thread(void *arg) { spa_t *spa = arg; @@ -7019,7 +7020,7 @@ ztest_resume_thread(void *arg) thread_exit(); } -static _Noreturn void +static __attribute__((noreturn)) void ztest_deadman_thread(void *arg) { ztest_shared_t *zs = arg; @@ -7097,7 +7098,7 @@ ztest_execute(int test, ztest_info_t *zi, uint64_t id) (double)functime / NANOSEC, zi->zi_funcname); } -static _Noreturn void +static __attribute__((noreturn)) void ztest_thread(void *arg) { int rand; @@ -7960,7 +7961,7 @@ ztest_run_init(void) * Create and initialize our storage pool. */ for (i = 1; i <= ztest_opts.zo_init; i++) { - bzero(zs, sizeof (ztest_shared_t)); + memset(zs, 0, sizeof (*zs)); if (ztest_opts.zo_verbose >= 3 && ztest_opts.zo_init != 1) { (void) printf("ztest_init(), pass %d\n", i); @@ -8041,12 +8042,12 @@ main(int argc, char **argv) setup_data_fd(); setup_hdr(); setup_data(); - bcopy(&ztest_opts, ztest_shared_opts, + memcpy(ztest_shared_opts, &ztest_opts, sizeof (*ztest_shared_opts)); } else { ztest_fd_data = atoi(fd_data_str); setup_data(); - bcopy(ztest_shared_opts, &ztest_opts, sizeof (ztest_opts)); + memcpy(&ztest_opts, ztest_shared_opts, sizeof (ztest_opts)); } ASSERT3U(ztest_opts.zo_datasets, ==, ztest_shared_hdr->zh_ds_count); diff --git a/sys/contrib/openzfs/config/Rules.am b/sys/contrib/openzfs/config/Rules.am index cbef12e2136..1540738482c 100644 --- a/sys/contrib/openzfs/config/Rules.am +++ b/sys/contrib/openzfs/config/Rules.am @@ -58,6 +58,9 @@ AM_CPPFLAGS += -D"strtok(...)=strtok(__VA_ARGS__) __attribute__((deprecated(\"Us AM_CPPFLAGS += -D"__xpg_basename(...)=__xpg_basename(__VA_ARGS__) __attribute__((deprecated(\"basename(3) is underspecified. Use zfs_basename() instead!\")))" AM_CPPFLAGS += -D"basename(...)=basename(__VA_ARGS__) __attribute__((deprecated(\"basename(3) is underspecified. Use zfs_basename() instead!\")))" AM_CPPFLAGS += -D"dirname(...)=dirname(__VA_ARGS__) __attribute__((deprecated(\"dirname(3) is underspecified. Use zfs_dirnamelen() instead!\")))" +AM_CPPFLAGS += -D"bcopy(...)=__attribute__((deprecated(\"bcopy(3) is deprecated. Use memcpy(3)/memmove(3) instead!\"))) bcopy(__VA_ARGS__)" +AM_CPPFLAGS += -D"bcmp(...)=__attribute__((deprecated(\"bcmp(3) is deprecated. Use memcmp(3) instead!\"))) bcmp(__VA_ARGS__)" +AM_CPPFLAGS += -D"bzero(...)=__attribute__((deprecated(\"bzero(3) is deprecated. Use memset(3) instead!\"))) bzero(__VA_ARGS__)" if ASAN_ENABLED AM_CPPFLAGS += -DZFS_ASAN_ENABLED diff --git a/sys/contrib/openzfs/config/always-arch.m4 b/sys/contrib/openzfs/config/always-arch.m4 index 25e8c963a4b..02c8e4775b9 100644 --- a/sys/contrib/openzfs/config/always-arch.m4 +++ b/sys/contrib/openzfs/config/always-arch.m4 @@ -2,10 +2,6 @@ dnl # dnl # Set the target cpu architecture. This allows the dnl # following syntax to be used in a Makefile.am. dnl # -dnl # ifeq ($(TARGET_CPU),x86_64) -dnl # ... -dnl # endif -dnl # dnl # if TARGET_CPU_POWERPC dnl # ... dnl # else @@ -29,13 +25,11 @@ AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_ARCH], [ sparc64) TARGET_CPU=sparc64 ;; + *) + TARGET_CPU=$target_cpu + ;; esac - AC_SUBST(TARGET_CPU) - - AM_CONDITIONAL([TARGET_CPU_I386], test $TARGET_CPU = i386) AM_CONDITIONAL([TARGET_CPU_X86_64], test $TARGET_CPU = x86_64) AM_CONDITIONAL([TARGET_CPU_POWERPC], test $TARGET_CPU = powerpc) - AM_CONDITIONAL([TARGET_CPU_AARCH64], test $TARGET_CPU = aarch64) - AM_CONDITIONAL([TARGET_CPU_SPARC64], test $TARGET_CPU = sparc64) ]) diff --git a/sys/contrib/openzfs/config/deb.am b/sys/contrib/openzfs/config/deb.am index cdbdbecb356..65aa70687ba 100644 --- a/sys/contrib/openzfs/config/deb.am +++ b/sys/contrib/openzfs/config/deb.am @@ -62,6 +62,7 @@ deb-utils: deb-local rpm-utils-initramfs pkg8=$${name}-dracut-$${version}.noarch.rpm; \ pkg9=$${name}-initramfs-$${version}.$${arch}.rpm; \ pkg10=`ls python*-pyzfs-$${version}* | tail -1`; \ + pkg11=pam_zfs_key-$${version}.$${arch}.rpm; \ ## Arguments need to be passed to dh_shlibdeps. Alien provides no mechanism ## to do this, so we install a shim onto the path which calls the real ## dh_shlibdeps with the required arguments. @@ -77,10 +78,10 @@ deb-utils: deb-local rpm-utils-initramfs env PATH=$${path_prepend}:$${PATH} \ fakeroot $(ALIEN) --bump=0 --scripts --to-deb --target=$$debarch \ $$pkg1 $$pkg2 $$pkg3 $$pkg4 $$pkg5 $$pkg6 $$pkg7 \ - $$pkg8 $$pkg9 $$pkg10 || exit 1; \ + $$pkg8 $$pkg9 $$pkg10 $$pkg11 || exit 1; \ $(RM) $${path_prepend}/dh_shlibdeps; \ rmdir $${path_prepend}; \ $(RM) $$pkg1 $$pkg2 $$pkg3 $$pkg4 $$pkg5 $$pkg6 $$pkg7 \ - $$pkg8 $$pkg9 $$pkg10; + $$pkg8 $$pkg9 $$pkg10 $$pkg11; deb: deb-kmod deb-dkms deb-utils diff --git a/sys/contrib/openzfs/config/kernel-add-disk.m4 b/sys/contrib/openzfs/config/kernel-add-disk.m4 index 5d1779eb432..44a8a5fd25b 100644 --- a/sys/contrib/openzfs/config/kernel-add-disk.m4 +++ b/sys/contrib/openzfs/config/kernel-add-disk.m4 @@ -3,16 +3,15 @@ dnl # 5.16 API change dnl # add_disk grew a must-check return code dnl # AC_DEFUN([ZFS_AC_KERNEL_SRC_ADD_DISK], [ - ZFS_LINUX_TEST_SRC([add_disk_ret], [ - #include + #include ], [ struct gendisk *disk = NULL; int err = add_disk(disk); err = err; ]) - ]) + AC_DEFUN([ZFS_AC_KERNEL_ADD_DISK], [ AC_MSG_CHECKING([whether add_disk() returns int]) ZFS_LINUX_TEST_RESULT([add_disk_ret], diff --git a/sys/contrib/openzfs/config/kernel-bio.m4 b/sys/contrib/openzfs/config/kernel-bio.m4 index d088d7023cb..b5d25448155 100644 --- a/sys/contrib/openzfs/config/kernel-bio.m4 +++ b/sys/contrib/openzfs/config/kernel-bio.m4 @@ -474,6 +474,41 @@ AC_DEFUN([ZFS_AC_KERNEL_BLK_CGROUP_HEADER], [ ]) ]) +dnl # +dnl # Linux 5.18 API +dnl # +dnl # In 07888c665b405b1cd3577ddebfeb74f4717a84c4 ("block: pass a block_device and opf to bio_alloc") +dnl # bio_alloc(gfp_t gfp_mask, unsigned short nr_iovecs) +dnl # became +dnl # bio_alloc(struct block_device *bdev, unsigned short nr_vecs, unsigned int opf, gfp_t gfp_mask) +dnl # however +dnl # > NULL/0 can be passed, both for the +dnl # > passthrough case on a raw request_queue and to temporarily avoid +dnl # > refactoring some nasty code. +dnl # +AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_ALLOC_4ARG], [ + ZFS_LINUX_TEST_SRC([bio_alloc_4arg], [ + #include + ],[ + gfp_t gfp_mask = 0; + unsigned short nr_iovecs = 0; + struct block_device *bdev = NULL; + unsigned int opf = 0; + + struct bio *__attribute__((unused)) allocated = bio_alloc(bdev, nr_iovecs, opf, gfp_mask); + ]) +]) + +AC_DEFUN([ZFS_AC_KERNEL_BIO_ALLOC_4ARG], [ + AC_MSG_CHECKING([for 4-argument bio_alloc()]) + ZFS_LINUX_TEST_RESULT([bio_alloc_4arg],[ + AC_MSG_RESULT(yes) + AC_DEFINE([HAVE_BIO_ALLOC_4ARG], 1, [bio_alloc() takes 4 arguments]) + ],[ + AC_MSG_RESULT(no) + ]) +]) + AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO], [ ZFS_AC_KERNEL_SRC_REQ ZFS_AC_KERNEL_SRC_BIO_OPS @@ -488,6 +523,7 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO], [ ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER + ZFS_AC_KERNEL_SRC_BIO_ALLOC_4ARG ]) AC_DEFUN([ZFS_AC_KERNEL_BIO], [ @@ -512,4 +548,5 @@ AC_DEFUN([ZFS_AC_KERNEL_BIO], [ ZFS_AC_KERNEL_BIO_BDEV_DISK ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID ZFS_AC_KERNEL_BLK_CGROUP_HEADER + ZFS_AC_KERNEL_BIO_ALLOC_4ARG ]) diff --git a/sys/contrib/openzfs/config/kernel-fpu.m4 b/sys/contrib/openzfs/config/kernel-fpu.m4 index 7f8b028d043..eb9520c60a7 100644 --- a/sys/contrib/openzfs/config/kernel-fpu.m4 +++ b/sys/contrib/openzfs/config/kernel-fpu.m4 @@ -2,12 +2,6 @@ dnl # dnl # Handle differences in kernel FPU code. dnl # dnl # Kernel -dnl # 5.16: XCR code put into asm/fpu/xcr.h -dnl # HAVE_KERNEL_FPU_XCR_HEADER -dnl # -dnl # XSTATE_XSAVE and XSTATE_XRESTORE aren't accessible any more -dnl # HAVE_KERNEL_FPU_XSAVE_INTERNAL -dnl # dnl # 5.11: kernel_fpu_begin() is an inlined function now, so don't check dnl # for it inside the kernel symbols. dnl # @@ -34,20 +28,8 @@ AC_DEFUN([ZFS_AC_KERNEL_FPU_HEADER], [ AC_DEFINE(HAVE_KERNEL_FPU_API_HEADER, 1, [kernel has asm/fpu/api.h]) AC_MSG_RESULT(asm/fpu/api.h) - AC_MSG_CHECKING([whether fpu/xcr header is available]) - ZFS_LINUX_TRY_COMPILE([ - #include - #include - ],[ - ],[ - AC_DEFINE(HAVE_KERNEL_FPU_XCR_HEADER, 1, - [kernel has asm/fpu/xcr.h]) - AC_MSG_RESULT(asm/fpu/xcr.h) - ],[ - AC_MSG_RESULT(no asm/fpu/xcr.h) - ]) ],[ - AC_MSG_RESULT(i387.h & xcr.h) + AC_MSG_RESULT(i387.h) ]) ]) @@ -56,9 +38,9 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_FPU], [ #include #ifdef HAVE_KERNEL_FPU_API_HEADER #include + #include #else #include - #include #endif ], [ kernel_fpu_begin(); @@ -69,80 +51,15 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_FPU], [ #include #ifdef HAVE_KERNEL_FPU_API_HEADER #include + #include #else #include - #include #endif ], [ __kernel_fpu_begin(); __kernel_fpu_end(); ], [], [ZFS_META_LICENSE]) - ZFS_LINUX_TEST_SRC([fpu_internal], [ - #if defined(__x86_64) || defined(__x86_64__) || \ - defined(__i386) || defined(__i386__) - #if !defined(__x86) - #define __x86 - #endif - #endif - - #if !defined(__x86) - #error Unsupported architecture - #endif - - #include - #ifdef HAVE_KERNEL_FPU_API_HEADER - #include - #include - #else - #include - #include - #endif - - #if !defined(XSTATE_XSAVE) - #error XSTATE_XSAVE not defined - #endif - - #if !defined(XSTATE_XRESTORE) - #error XSTATE_XRESTORE not defined - #endif - ],[ - struct fpu *fpu = ¤t->thread.fpu; - union fpregs_state *st = &fpu->state; - struct fregs_state *fr __attribute__ ((unused)) = &st->fsave; - struct fxregs_state *fxr __attribute__ ((unused)) = &st->fxsave; - struct xregs_state *xr __attribute__ ((unused)) = &st->xsave; - ]) - - ZFS_LINUX_TEST_SRC([fpu_xsave_internal], [ - #include - #if defined(__x86_64) || defined(__x86_64__) || \ - defined(__i386) || defined(__i386__) - #if !defined(__x86) - #define __x86 - #endif - #endif - - #if !defined(__x86) - #error Unsupported architecture - #endif - - #include - #ifdef HAVE_KERNEL_FPU_API_HEADER - #include - #include - #else - #include - #include - #endif - - ],[ - struct fpu *fpu = ¤t->thread.fpu; - union fpregs_state *st = &fpu->fpstate->regs; - struct fregs_state *fr __attribute__ ((unused)) = &st->fsave; - struct fxregs_state *fxr __attribute__ ((unused)) = &st->fxsave; - struct xregs_state *xr __attribute__ ((unused)) = &st->xsave; - ]) ]) AC_DEFUN([ZFS_AC_KERNEL_FPU], [ @@ -169,19 +86,9 @@ AC_DEFUN([ZFS_AC_KERNEL_FPU], [ AC_DEFINE(KERNEL_EXPORTS_X86_FPU, 1, [kernel exports FPU functions]) ],[ - ZFS_LINUX_TEST_RESULT([fpu_internal], [ - AC_MSG_RESULT(internal) - AC_DEFINE(HAVE_KERNEL_FPU_INTERNAL, 1, - [kernel fpu internal]) - ],[ - ZFS_LINUX_TEST_RESULT([fpu_xsave_internal], [ - AC_MSG_RESULT(internal with internal XSAVE) - AC_DEFINE(HAVE_KERNEL_FPU_XSAVE_INTERNAL, 1, - [kernel fpu and XSAVE internal]) - ],[ - AC_MSG_RESULT(unavailable) - ]) - ]) + AC_MSG_RESULT(internal) + AC_DEFINE(HAVE_KERNEL_FPU_INTERNAL, 1, + [kernel fpu internal]) ]) ]) ]) diff --git a/sys/contrib/openzfs/config/kernel-revalidate-disk-size.m4 b/sys/contrib/openzfs/config/kernel-revalidate-disk-size.m4 index a7d0cb3cdab..13cb92a174e 100644 --- a/sys/contrib/openzfs/config/kernel-revalidate-disk-size.m4 +++ b/sys/contrib/openzfs/config/kernel-revalidate-disk-size.m4 @@ -8,14 +8,14 @@ dnl # AC_DEFUN([ZFS_AC_KERNEL_SRC_REVALIDATE_DISK], [ ZFS_LINUX_TEST_SRC([revalidate_disk_size], [ - #include + #include ], [ struct gendisk *disk = NULL; (void) revalidate_disk_size(disk, false); ]) ZFS_LINUX_TEST_SRC([revalidate_disk], [ - #include + #include ], [ struct gendisk *disk = NULL; (void) revalidate_disk(disk); diff --git a/sys/contrib/openzfs/config/kernel-zero_page.m4 b/sys/contrib/openzfs/config/kernel-zero_page.m4 new file mode 100644 index 00000000000..1461781acb4 --- /dev/null +++ b/sys/contrib/openzfs/config/kernel-zero_page.m4 @@ -0,0 +1,27 @@ +dnl # +dnl # ZERO_PAGE() is an alias for emtpy_zero_page. On certain architectures +dnl # this is a GPL exported variable. +dnl # + +dnl # +dnl # Checking if ZERO_PAGE is exported GPL-only +dnl # +AC_DEFUN([ZFS_AC_KERNEL_SRC_ZERO_PAGE], [ + ZFS_LINUX_TEST_SRC([zero_page], [ + #include + ], [ + struct page *p __attribute__ ((unused)); + p = ZERO_PAGE(0); + ], [], [ZFS_META_LICENSE]) +]) + +AC_DEFUN([ZFS_AC_KERNEL_ZERO_PAGE], [ + AC_MSG_CHECKING([whether ZERO_PAGE() is GPL-only]) + ZFS_LINUX_TEST_RESULT([zero_page_license], [ + AC_MSG_RESULT(no) + ], [ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_ZERO_PAGE_GPL_ONLY, 1, + [ZERO_PAGE() is GPL-only]) + ]) +]) diff --git a/sys/contrib/openzfs/config/kernel.m4 b/sys/contrib/openzfs/config/kernel.m4 index 3122e9dbaa9..d1d3dede175 100644 --- a/sys/contrib/openzfs/config/kernel.m4 +++ b/sys/contrib/openzfs/config/kernel.m4 @@ -137,6 +137,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [ ZFS_AC_KERNEL_SRC_PAGEMAP_FOLIO_WAIT_BIT ZFS_AC_KERNEL_SRC_ADD_DISK ZFS_AC_KERNEL_SRC_KTHREAD + ZFS_AC_KERNEL_SRC_ZERO_PAGE AC_MSG_CHECKING([for available kernel interfaces]) ZFS_LINUX_TEST_COMPILE_ALL([kabi]) @@ -247,6 +248,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [ ZFS_AC_KERNEL_PAGEMAP_FOLIO_WAIT_BIT ZFS_AC_KERNEL_ADD_DISK ZFS_AC_KERNEL_KTHREAD + ZFS_AC_KERNEL_ZERO_PAGE ]) dnl # diff --git a/sys/contrib/openzfs/config/user-aio.h.m4 b/sys/contrib/openzfs/config/user-aio.h.m4 new file mode 100644 index 00000000000..152c0946722 --- /dev/null +++ b/sys/contrib/openzfs/config/user-aio.h.m4 @@ -0,0 +1,7 @@ +dnl # +dnl # POSIX specifies as part of realtime extensions, +dnl # and is missing from at least uClibc – force fallbacks there +dnl # +AC_DEFUN([ZFS_AC_CONFIG_USER_AIO_H], [ + ZFS_AC_FIND_SYSTEM_LIBRARY(AIO_H, [], [aio.h], [], [rt], [lio_listio]) +]) diff --git a/sys/contrib/openzfs/config/user-libaio.m4 b/sys/contrib/openzfs/config/user-libaio.m4 index 95c144d76b4..8009bd11b3e 100644 --- a/sys/contrib/openzfs/config/user-libaio.m4 +++ b/sys/contrib/openzfs/config/user-libaio.m4 @@ -1,5 +1,5 @@ dnl # -dnl # Check for libaio - only used for libaiot test cases. +dnl # Check for libaio - only used for mmap_libaio test cases. dnl # AC_DEFUN([ZFS_AC_CONFIG_USER_LIBAIO], [ ZFS_AC_FIND_SYSTEM_LIBRARY(LIBAIO, [], [libaio.h], [], [aio], [], [user_libaio=yes], [user_libaio=no]) diff --git a/sys/contrib/openzfs/config/user.m4 b/sys/contrib/openzfs/config/user.m4 index 670820b3771..f450af47e04 100644 --- a/sys/contrib/openzfs/config/user.m4 +++ b/sys/contrib/openzfs/config/user.m4 @@ -23,6 +23,7 @@ AC_DEFUN([ZFS_AC_CONFIG_USER], [ ZFS_AC_CONFIG_USER_LIBAIO ZFS_AC_CONFIG_USER_LIBATOMIC ZFS_AC_CONFIG_USER_LIBFETCH + ZFS_AC_CONFIG_USER_AIO_H ZFS_AC_CONFIG_USER_CLOCK_GETTIME ZFS_AC_CONFIG_USER_PAM ZFS_AC_CONFIG_USER_RUNSTATEDIR diff --git a/sys/contrib/openzfs/contrib/pam_zfs_key/pam_zfs_key.c b/sys/contrib/openzfs/contrib/pam_zfs_key/pam_zfs_key.c index f831f65af1d..6f95d468074 100644 --- a/sys/contrib/openzfs/contrib/pam_zfs_key/pam_zfs_key.c +++ b/sys/contrib/openzfs/contrib/pam_zfs_key/pam_zfs_key.c @@ -152,7 +152,7 @@ alloc_pw_string(const char *source) static void pw_free(pw_password_t *pw) { - bzero(pw->value, pw->len); + memset(pw->value, 0, pw->len); if (try_lock(munlock, pw->value, pw->len) == 0) { (void) munmap(pw->value, pw->len); } diff --git a/sys/contrib/openzfs/include/libuutil.h b/sys/contrib/openzfs/include/libuutil.h index 043152ac26b..05a7f503cca 100644 --- a/sys/contrib/openzfs/include/libuutil.h +++ b/sys/contrib/openzfs/include/libuutil.h @@ -85,13 +85,13 @@ extern void uu_warn(const char *, ...) __attribute__((format(printf, 1, 2))); extern void uu_vwarn(const char *, va_list) __attribute__((format(printf, 1, 0))); -extern _Noreturn void uu_die(const char *, ...) +extern __attribute__((noreturn)) void uu_die(const char *, ...) __attribute__((format(printf, 1, 2))); -extern _Noreturn void uu_vdie(const char *, va_list) +extern __attribute__((noreturn)) void uu_vdie(const char *, va_list) __attribute__((format(printf, 1, 0))); -extern _Noreturn void uu_xdie(int, const char *, ...) +extern __attribute__((noreturn)) void uu_xdie(int, const char *, ...) __attribute__((format(printf, 2, 3))); -extern _Noreturn void uu_vxdie(int, const char *, va_list) +extern __attribute__((noreturn)) void uu_vxdie(int, const char *, va_list) __attribute__((format(printf, 2, 0))); /* diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am b/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am index 232aaf569fa..7d5081a4c25 100644 --- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am +++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am @@ -22,7 +22,6 @@ KERNEL_H = \ inttypes.h \ isa_defs.h \ kmem_cache.h \ - kidmap.h \ kmem.h \ kstat.h \ list_impl.h \ @@ -48,7 +47,6 @@ KERNEL_H = \ simd.h \ spl_condvar.h \ string.h \ - strings.h \ sunddi.h \ sysmacros.h \ systeminfo.h \ diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/callb.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/callb.h index cc67b0263c5..d51132d4e61 100644 --- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/callb.h +++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/callb.h @@ -132,7 +132,7 @@ typedef struct callb_cpr { #define CALLB_CPR_INIT(cp, lockp, func, name) { \ strlcpy(curthread->td_name, (name), \ sizeof (curthread->td_name)); \ - bzero((caddr_t)(cp), sizeof (callb_cpr_t)); \ + memset(cp, 0, sizeof (callb_cpr_t)); \ (cp)->cc_lockp = lockp; \ (cp)->cc_id = callb_add(func, (void *)(cp), \ CB_CL_CPR_DAEMON, name); \ diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/cred.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/cred.h index 86f79011d6d..db986af57bf 100644 --- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/cred.h +++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/cred.h @@ -48,138 +48,20 @@ extern "C" { typedef struct ucred cred_t; #define CRED() curthread->td_ucred + +/* + * kcred is used when you need all privileges. + */ #define kcred (thread0.td_ucred) #define KUID_TO_SUID(x) (x) #define KGID_TO_SGID(x) (x) -#define crgetuid(cred) ((cred)->cr_uid) -#define crgetruid(cred) ((cred)->cr_ruid) -#define crgetgid(cred) ((cred)->cr_gid) -#define crgetgroups(cred) ((cred)->cr_groups) -#define crgetngroups(cred) ((cred)->cr_ngroups) -#define crgetsid(cred, i) (NULL) - -struct proc; /* cred.h is included in proc.h */ -struct prcred; -struct ksid; -struct ksidlist; -struct credklpd; -struct credgrp; - -struct auditinfo_addr; /* cred.h is included in audit.h */ - -extern int ngroups_max; -/* - * kcred is used when you need all privileges. - */ - -extern void cred_init(void); -extern void crfree(cred_t *); -extern cred_t *cralloc(void); /* all but ref uninitialized */ -extern cred_t *cralloc_ksid(void); /* cralloc() + ksid alloc'ed */ -extern cred_t *crget(void); /* initialized */ -extern void crcopy_to(cred_t *, cred_t *); -extern cred_t *crdup(cred_t *); -extern void crdup_to(cred_t *, cred_t *); -extern cred_t *crgetcred(void); -extern void crset(struct proc *, cred_t *); -extern void crset_zone_privall(cred_t *); -extern int supgroupmember(gid_t, const cred_t *); -extern int hasprocperm(const cred_t *, const cred_t *); -extern int prochasprocperm(struct proc *, struct proc *, const cred_t *); -extern int crcmp(const cred_t *, const cred_t *); -extern cred_t *zone_kcred(void); - -extern gid_t crgetrgid(const cred_t *); -extern gid_t crgetsgid(const cred_t *); - -#define crgetzoneid(cr) ((cr)->cr_prison->pr_id) -extern projid_t crgetprojid(const cred_t *); - -extern cred_t *crgetmapped(const cred_t *); - - -extern const struct auditinfo_addr *crgetauinfo(const cred_t *); -extern struct auditinfo_addr *crgetauinfo_modifiable(cred_t *); - -extern uint_t crgetref(const cred_t *); - -extern const gid_t *crgetggroups(const struct credgrp *); - - -/* - * Sets real, effective and/or saved uid/gid; - * -1 argument accepted as "no change". - */ -extern int crsetresuid(cred_t *, uid_t, uid_t, uid_t); -extern int crsetresgid(cred_t *, gid_t, gid_t, gid_t); - -/* - * Sets real, effective and saved uids/gids all to the same - * values. Both values must be non-negative and <= MAXUID - */ -extern int crsetugid(cred_t *, uid_t, gid_t); - -/* - * Functions to handle the supplemental group list. - */ -extern struct credgrp *crgrpcopyin(int, gid_t *); -extern void crgrprele(struct credgrp *); -extern void crsetcredgrp(cred_t *, struct credgrp *); - -/* - * Private interface for setting zone association of credential. - */ -struct zone; -extern void crsetzone(cred_t *, struct zone *); -extern struct zone *crgetzone(const cred_t *); - -/* - * Private interface for setting project id in credential. - */ -extern void crsetprojid(cred_t *, projid_t); - -/* - * Private interface for nfs. - */ -extern cred_t *crnetadjust(cred_t *); - -/* - * Private interface for procfs. - */ -extern void cred2prcred(const cred_t *, struct prcred *); - -/* - * Private interfaces for Rampart Trusted Solaris. - */ -struct ts_label_s; -extern struct ts_label_s *crgetlabel(const cred_t *); -extern boolean_t crisremote(const cred_t *); - -/* - * Private interfaces for ephemeral uids. - */ -#define VALID_UID(id, zn) \ - ((id) <= MAXUID || valid_ephemeral_uid((zn), (id))) - -#define VALID_GID(id, zn) \ - ((id) <= MAXUID || valid_ephemeral_gid((zn), (id))) - -extern boolean_t valid_ephemeral_uid(struct zone *, uid_t); -extern boolean_t valid_ephemeral_gid(struct zone *, gid_t); - -extern int eph_uid_alloc(struct zone *, int, uid_t *, int); -extern int eph_gid_alloc(struct zone *, int, gid_t *, int); - -extern void crsetsid(cred_t *, struct ksid *, int); -extern void crsetsidlist(cred_t *, struct ksidlist *); - -extern struct ksidlist *crgetsidlist(const cred_t *); - -extern int crsetpriv(cred_t *, ...); - -extern struct credklpd *crgetcrklpd(const cred_t *); -extern void crsetcrklpd(cred_t *, struct credklpd *); +#define crgetuid(cr) ((cr)->cr_uid) +#define crgetruid(cr) ((cr)->cr_ruid) +#define crgetgid(cr) ((cr)->cr_gid) +#define crgetgroups(cr) ((cr)->cr_groups) +#define crgetngroups(cr) ((cr)->cr_ngroups) +#define crgetzoneid(cr) ((cr)->cr_prison->pr_id) #ifdef __cplusplus } diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/kidmap.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/kidmap.h deleted file mode 100644 index dc0cf5988a4..00000000000 --- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/kidmap.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2007 Pawel Jakub Dawidek - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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. - * - * $FreeBSD$ - */ - -#ifndef _OPENSOLARIS_SYS_KIDMAP_H_ -#define _OPENSOLARIS_SYS_KIDMAP_H_ - -#include - -typedef int32_t idmap_stat; -typedef void idmap_get_handle_t; - -#define kidmap_get_create() (NULL) -#define kidmap_get_destroy(hdl) do { } while (0) -#define kidmap_get_mappings(hdl) (NULL) - -#endif /* _OPENSOLARIS_SYS_KIDMAP_H_ */ diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/sid.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/sid.h index d3fab8b2474..f249d05d55a 100644 --- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/sid.h +++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/sid.h @@ -29,7 +29,6 @@ #ifndef _OPENSOLARIS_SYS_SID_H_ #define _OPENSOLARIS_SYS_SID_H_ #include -#include typedef struct ksiddomain { char *kd_name; /* Domain part of SID */ @@ -59,28 +58,4 @@ ksiddomain_rele(ksiddomain_t *kd) kmem_free(kd, sizeof (*kd)); } -static __inline uint_t -ksid_getid(ksid_t *ks) -{ - - panic("%s has been unexpectedly called", __func__); -} - -static __inline const char * -ksid_getdomain(ksid_t *ks) -{ - - panic("%s has been unexpectedly called", __func__); -} - -static __inline uint_t -ksid_getrid(ksid_t *ks) -{ - - panic("%s has been unexpectedly called", __func__); -} - -#define kidmap_getsidbyuid(zone, uid, sid_prefix, rid) (1) -#define kidmap_getsidbygid(zone, gid, sid_prefix, rid) (1) - #endif /* _OPENSOLARIS_SYS_SID_H_ */ diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/strings.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/strings.h deleted file mode 100644 index 651685d3047..00000000000 --- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/strings.h +++ /dev/null @@ -1 +0,0 @@ -/* do not delete */ diff --git a/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h b/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h index 6d4c7a09fe8..0fc4168b74e 100644 --- a/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h +++ b/sys/contrib/openzfs/include/os/linux/kernel/linux/simd_x86.h @@ -85,23 +85,19 @@ #undef CONFIG_X86_DEBUG_FPU #endif -#if defined(HAVE_KERNEL_FPU_API_HEADER) -#include -#include -#if defined(HAVE_KERNEL_FPU_XCR_HEADER) -#include -#endif -#else -#include -#include -#endif - /* * The following cases are for kernels which export either the * kernel_fpu_* or __kernel_fpu_* functions. */ #if defined(KERNEL_EXPORTS_X86_FPU) +#if defined(HAVE_KERNEL_FPU_API_HEADER) +#include +#include +#else +#include +#endif + #define kfpu_allowed() 1 #define kfpu_init() 0 #define kfpu_fini() ((void) 0) @@ -136,29 +132,74 @@ * When the kernel_fpu_* symbols are unavailable then provide our own * versions which allow the FPU to be safely used. */ -#if defined(HAVE_KERNEL_FPU_INTERNAL) || defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) - -#if defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) -/* - * Some sanity checks. - * HAVE_KERNEL_FPU_INTERNAL and HAVE_KERNEL_FPU_XSAVE_INTERNAL are exclusive. - */ #if defined(HAVE_KERNEL_FPU_INTERNAL) -#error "HAVE_KERNEL_FPU_INTERNAL and HAVE_KERNEL_FPU_XSAVE_INTERNAL defined" -#endif + /* - * For kernels >= 5.16 we have to use inline assembly with the XSAVE{,OPT,S} - * instructions, so we need the toolchain to support at least XSAVE. + * For kernels not exporting *kfpu_{begin,end} we have to use inline assembly + * with the XSAVE{,OPT,S} instructions, so we need the toolchain to support at + * least XSAVE. */ #if !defined(HAVE_XSAVE) #error "Toolchain needs to support the XSAVE assembler instruction" #endif -#endif #include #include -extern union fpregs_state **zfs_kfpu_fpregs; +extern uint8_t **zfs_kfpu_fpregs; + +/* + * Return the size in bytes required by the XSAVE instruction for an + * XSAVE area containing all the user state components supported by this CPU. + * See: Intel 64 and IA-32 Architectures Software Developer’s Manual. + * Dec. 2021. Vol. 2A p. 3-222. + */ +static inline uint32_t +get_xsave_area_size(void) +{ + if (!boot_cpu_has(X86_FEATURE_OSXSAVE)) { + return (0); + } + /* + * Call CPUID with leaf 13 and subleaf 0. The size is in ecx. + * We don't need to check for cpuid_max here, since if this CPU has + * OSXSAVE set, it has leaf 13 (0x0D) as well. + */ + uint32_t eax, ebx, ecx, edx; + + eax = 13U; + ecx = 0U; + __asm__ __volatile__("cpuid" + : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) + : "a" (eax), "c" (ecx)); + + return (ecx); +} + +/* + * Return the allocation order of the maximum buffer size required to save the + * FPU state on this architecture. The value returned is the same as Linux' + * get_order() function would return (i.e. 2^order = nr. of pages required). + * Currently this will always return 0 since the save area is below 4k even for + * a full fledged AVX-512 implementation. + */ +static inline int +get_fpuregs_save_area_order(void) +{ + size_t area_size = (size_t)get_xsave_area_size(); + + /* + * If we are dealing with a CPU not supporting XSAVE, + * get_xsave_area_size() will return 0. Thus the maximum memory + * required is the FXSAVE area size which is 512 bytes. See: Intel 64 + * and IA-32 Architectures Software Developer’s Manual. Dec. 2021. + * Vol. 2A p. 3-451. + */ + if (area_size == 0) { + area_size = 512; + } + return (get_order(area_size)); +} /* * Initialize per-cpu variables to store FPU state. @@ -167,11 +208,11 @@ static inline void kfpu_fini(void) { int cpu; + int order = get_fpuregs_save_area_order(); for_each_possible_cpu(cpu) { if (zfs_kfpu_fpregs[cpu] != NULL) { - free_pages((unsigned long)zfs_kfpu_fpregs[cpu], - get_order(sizeof (union fpregs_state))); + free_pages((unsigned long)zfs_kfpu_fpregs[cpu], order); } } @@ -181,8 +222,9 @@ kfpu_fini(void) static inline int kfpu_init(void) { - zfs_kfpu_fpregs = kzalloc(num_possible_cpus() * - sizeof (union fpregs_state *), GFP_KERNEL); + zfs_kfpu_fpregs = kzalloc(num_possible_cpus() * sizeof (uint8_t *), + GFP_KERNEL); + if (zfs_kfpu_fpregs == NULL) return (-ENOMEM); @@ -191,8 +233,8 @@ kfpu_init(void) * the target memory. Since kmalloc() provides no alignment * guarantee instead use alloc_pages_node(). */ - unsigned int order = get_order(sizeof (union fpregs_state)); int cpu; + int order = get_fpuregs_save_area_order(); for_each_possible_cpu(cpu) { struct page *page = alloc_pages_node(cpu_to_node(cpu), @@ -209,9 +251,6 @@ kfpu_init(void) } #define kfpu_allowed() 1 -#if defined(HAVE_KERNEL_FPU_INTERNAL) -#define ex_handler_fprestore ex_handler_default -#endif /* * FPU save and restore instructions. @@ -226,21 +265,6 @@ kfpu_init(void) #define kfpu_fxsr_clean(rval) __asm("fnclex; emms; fildl %P[addr]" \ : : [addr] "m" (rval)); -#if defined(HAVE_KERNEL_FPU_INTERNAL) -static inline void -kfpu_save_xsave(struct xregs_state *addr, uint64_t mask) -{ - uint32_t low, hi; - int err; - - low = mask; - hi = mask >> 32; - XSTATE_XSAVE(addr, low, hi, err); - WARN_ON_ONCE(err); -} -#endif /* defined(HAVE_KERNEL_FPU_INTERNAL) */ - -#if defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) #define kfpu_do_xsave(instruction, addr, mask) \ { \ uint32_t low, hi; \ @@ -252,10 +276,9 @@ kfpu_save_xsave(struct xregs_state *addr, uint64_t mask) : [dst] "m" (*(addr)), "a" (low), "d" (hi) \ : "memory"); \ } -#endif /* defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) */ static inline void -kfpu_save_fxsr(struct fxregs_state *addr) +kfpu_save_fxsr(uint8_t *addr) { if (IS_ENABLED(CONFIG_X86_32)) kfpu_fxsave(addr); @@ -264,12 +287,11 @@ kfpu_save_fxsr(struct fxregs_state *addr) } static inline void -kfpu_save_fsave(struct fregs_state *addr) +kfpu_save_fsave(uint8_t *addr) { kfpu_fnsave(addr); } -#if defined(HAVE_KERNEL_FPU_INTERNAL) static inline void kfpu_begin(void) { @@ -286,70 +308,28 @@ kfpu_begin(void) * per-cpu variable, not in the task struct, this allows any user * FPU state to be correctly preserved and restored. */ - union fpregs_state *state = zfs_kfpu_fpregs[smp_processor_id()]; - if (static_cpu_has(X86_FEATURE_XSAVE)) { - kfpu_save_xsave(&state->xsave, ~0); - } else if (static_cpu_has(X86_FEATURE_FXSR)) { - kfpu_save_fxsr(&state->fxsave); - } else { - kfpu_save_fsave(&state->fsave); - } -} -#endif /* defined(HAVE_KERNEL_FPU_INTERNAL) */ - -#if defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) -static inline void -kfpu_begin(void) -{ - /* - * Preemption and interrupts must be disabled for the critical - * region where the FPU state is being modified. - */ - preempt_disable(); - local_irq_disable(); - - /* - * The current FPU registers need to be preserved by kfpu_begin() - * and restored by kfpu_end(). They are stored in a dedicated - * per-cpu variable, not in the task struct, this allows any user - * FPU state to be correctly preserved and restored. - */ - union fpregs_state *state = zfs_kfpu_fpregs[smp_processor_id()]; + uint8_t *state = zfs_kfpu_fpregs[smp_processor_id()]; #if defined(HAVE_XSAVES) if (static_cpu_has(X86_FEATURE_XSAVES)) { - kfpu_do_xsave("xsaves", &state->xsave, ~0); + kfpu_do_xsave("xsaves", state, ~0); return; } #endif #if defined(HAVE_XSAVEOPT) if (static_cpu_has(X86_FEATURE_XSAVEOPT)) { - kfpu_do_xsave("xsaveopt", &state->xsave, ~0); + kfpu_do_xsave("xsaveopt", state, ~0); return; } #endif if (static_cpu_has(X86_FEATURE_XSAVE)) { - kfpu_do_xsave("xsave", &state->xsave, ~0); + kfpu_do_xsave("xsave", state, ~0); } else if (static_cpu_has(X86_FEATURE_FXSR)) { - kfpu_save_fxsr(&state->fxsave); + kfpu_save_fxsr(state); } else { - kfpu_save_fsave(&state->fsave); + kfpu_save_fsave(state); } } -#endif /* defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) */ -#if defined(HAVE_KERNEL_FPU_INTERNAL) -static inline void -kfpu_restore_xsave(struct xregs_state *addr, uint64_t mask) -{ - uint32_t low, hi; - - low = mask; - hi = mask >> 32; - XSTATE_XRESTORE(addr, low, hi); -} -#endif /* defined(HAVE_KERNEL_FPU_INTERNAL) */ - -#if defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) #define kfpu_do_xrstor(instruction, addr, mask) \ { \ uint32_t low, hi; \ @@ -361,10 +341,9 @@ kfpu_restore_xsave(struct xregs_state *addr, uint64_t mask) : [src] "m" (*(addr)), "a" (low), "d" (hi) \ : "memory"); \ } -#endif /* defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) */ static inline void -kfpu_restore_fxsr(struct fxregs_state *addr) +kfpu_restore_fxsr(uint8_t *addr) { /* * On AuthenticAMD K7 and K8 processors the fxrstor instruction only @@ -382,67 +361,40 @@ kfpu_restore_fxsr(struct fxregs_state *addr) } static inline void -kfpu_restore_fsave(struct fregs_state *addr) +kfpu_restore_fsave(uint8_t *addr) { kfpu_frstor(addr); } -#if defined(HAVE_KERNEL_FPU_INTERNAL) static inline void kfpu_end(void) { - union fpregs_state *state = zfs_kfpu_fpregs[smp_processor_id()]; - - if (static_cpu_has(X86_FEATURE_XSAVE)) { - kfpu_restore_xsave(&state->xsave, ~0); - } else if (static_cpu_has(X86_FEATURE_FXSR)) { - kfpu_restore_fxsr(&state->fxsave); - } else { - kfpu_restore_fsave(&state->fsave); - } - - local_irq_enable(); - preempt_enable(); -} -#endif /* defined(HAVE_KERNEL_FPU_INTERNAL) */ - -#if defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) -static inline void -kfpu_end(void) -{ - union fpregs_state *state = zfs_kfpu_fpregs[smp_processor_id()]; + uint8_t *state = zfs_kfpu_fpregs[smp_processor_id()]; #if defined(HAVE_XSAVES) if (static_cpu_has(X86_FEATURE_XSAVES)) { - kfpu_do_xrstor("xrstors", &state->xsave, ~0); + kfpu_do_xrstor("xrstors", state, ~0); goto out; } #endif if (static_cpu_has(X86_FEATURE_XSAVE)) { - kfpu_do_xrstor("xrstor", &state->xsave, ~0); + kfpu_do_xrstor("xrstor", state, ~0); } else if (static_cpu_has(X86_FEATURE_FXSR)) { - kfpu_save_fxsr(&state->fxsave); + kfpu_restore_fxsr(state); } else { - kfpu_save_fsave(&state->fsave); + kfpu_restore_fsave(state); } out: local_irq_enable(); preempt_enable(); } -#endif /* defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) */ #else -/* - * FPU support is unavailable. - */ -#define kfpu_allowed() 0 -#define kfpu_begin() do {} while (0) -#define kfpu_end() do {} while (0) -#define kfpu_init() 0 -#define kfpu_fini() ((void) 0) +#error "Exactly one of KERNEL_EXPORTS_X86_FPU or HAVE_KERNEL_FPU_INTERNAL" \ + " must be defined" -#endif /* defined(HAVE_KERNEL_FPU_INTERNAL || HAVE_KERNEL_FPU_XSAVE_INTERNAL) */ +#endif /* defined(HAVE_KERNEL_FPU_INTERNAL */ #endif /* defined(KERNEL_EXPORTS_X86_FPU) */ /* @@ -452,6 +404,25 @@ out: /* * Detect register set support */ + +/* + * Check if OS supports AVX and AVX2 by checking XCR0 + * Only call this function if CPUID indicates that AVX feature is + * supported by the CPU, otherwise it might be an illegal instruction. + */ +static inline uint64_t +zfs_xgetbv(uint32_t index) +{ + uint32_t eax, edx; + /* xgetbv - instruction byte code */ + __asm__ __volatile__(".byte 0x0f; .byte 0x01; .byte 0xd0" + : "=a" (eax), "=d" (edx) + : "c" (index)); + + return ((((uint64_t)edx)<<32) | (uint64_t)eax); +} + + static inline boolean_t __simd_state_enabled(const uint64_t state) { @@ -466,7 +437,7 @@ __simd_state_enabled(const uint64_t state) if (!has_osxsave) return (B_FALSE); - xcr0 = xgetbv(0); + xcr0 = zfs_xgetbv(0); return ((xcr0 & state) == state); } diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am b/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am index 48c27f970fc..0dc9b90c109 100644 --- a/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am +++ b/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am @@ -33,7 +33,7 @@ KERNEL_H = \ signal.h \ simd.h \ stat.h \ - strings.h \ + string.h \ sunddi.h \ sysmacros.h \ systeminfo.h \ diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/cred.h b/sys/contrib/openzfs/include/os/linux/spl/sys/cred.h index 9cc85deb5c8..b7d3f38d70b 100644 --- a/sys/contrib/openzfs/include/os/linux/spl/sys/cred.h +++ b/sys/contrib/openzfs/include/os/linux/spl/sys/cred.h @@ -49,12 +49,7 @@ extern void crhold(cred_t *cr); extern void crfree(cred_t *cr); extern uid_t crgetuid(const cred_t *cr); extern uid_t crgetruid(const cred_t *cr); -extern uid_t crgetsuid(const cred_t *cr); -extern uid_t crgetfsuid(const cred_t *cr); extern gid_t crgetgid(const cred_t *cr); -extern gid_t crgetrgid(const cred_t *cr); -extern gid_t crgetsgid(const cred_t *cr); -extern gid_t crgetfsgid(const cred_t *cr); extern int crgetngroups(const cred_t *cr); extern gid_t *crgetgroups(const cred_t *cr); extern int groupmember(gid_t gid, const cred_t *cr); diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/string.h b/sys/contrib/openzfs/include/os/linux/spl/sys/string.h new file mode 100644 index 00000000000..38134dcf4c7 --- /dev/null +++ b/sys/contrib/openzfs/include/os/linux/spl/sys/string.h @@ -0,0 +1 @@ +#include diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/strings.h b/sys/contrib/openzfs/include/os/linux/spl/sys/strings.h deleted file mode 100644 index 48e417d1460..00000000000 --- a/sys/contrib/openzfs/include/os/linux/spl/sys/strings.h +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright (C) 2018 Lawrence Livermore National Security, LLC. - * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). - * UCRL-CODE-235197 - * - * This file is part of the SPL, Solaris Porting Layer. - * - * The SPL is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. - * - * The SPL is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * for more details. - * - * You should have received a copy of the GNU General Public License along - * with the SPL. If not, see . - */ -#ifndef _SPL_SYS_STRINGS_H -#define _SPL_SYS_STRINGS_H - -#include - -#define bzero(ptr, size) memset(ptr, 0, size) -#define bcopy(src, dest, size) memmove(dest, src, size) -#define bcmp(src, dest, size) memcmp((src), (dest), (size_t)(size)) - -#endif /* _SPL_SYS_STRINGS_H */ diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h b/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h index 7f9f486fcd4..bc88ff4efb6 100644 --- a/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h +++ b/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h @@ -53,7 +53,7 @@ typedef void (*thread_func_t)(void *); __thread_create(stk, stksize, (thread_func_t)func, #func, \ arg, len, pp, state, pri) -#define thread_exit() __thread_exit() +#define thread_exit() spl_thread_exit() #define thread_join(t) VERIFY(0) #define curthread current #define getcomm() current->comm @@ -62,10 +62,16 @@ typedef void (*thread_func_t)(void *); extern kthread_t *__thread_create(caddr_t stk, size_t stksize, thread_func_t func, const char *name, void *args, size_t len, proc_t *pp, int state, pri_t pri); -extern __attribute__((noreturn)) void __thread_exit(void); extern struct task_struct *spl_kthread_create(int (*func)(void *), void *data, const char namefmt[], ...); +static inline __attribute__((noreturn)) void +spl_thread_exit(void) +{ + tsd_exit(); + SPL_KTHREAD_COMPLETE_AND_EXIT(NULL, 0); +} + extern proc_t p0; #ifdef HAVE_SIGINFO diff --git a/sys/contrib/openzfs/include/sys/efi_partition.h b/sys/contrib/openzfs/include/sys/efi_partition.h index af3e98a0795..7d5e42e945a 100644 --- a/sys/contrib/openzfs/include/sys/efi_partition.h +++ b/sys/contrib/openzfs/include/sys/efi_partition.h @@ -73,18 +73,15 @@ typedef struct efi_gpe_Attrs { RequiredPartition :1; } efi_gpe_Attrs_t; +/* MBR partition identification tags */ +#define V_UNASSIGNED 0x00 /* unassigned partition */ +#define V_USR 0x04 /* Usr filesystem */ +#define V_RESERVED 0x0b /* SMI reserved data */ + /* * 6a96237f-1dd2-11b2-99a6-080020736631 V_UNASSIGNED (not used as such) - * 6a82cb45-1dd2-11b2-99a6-080020736631 V_BOOT - * 6a85cf4d-1dd2-11b2-99a6-080020736631 V_ROOT - * 6a87c46f-1dd2-11b2-99a6-080020736631 V_SWAP * 6a898cc3-1dd2-11b2-99a6-080020736631 V_USR - * 6a8b642b-1dd2-11b2-99a6-080020736631 V_BACKUP - * 6a8d2ac7-1dd2-11b2-99a6-080020736631 V_STAND (not used) - * 6a8ef2e9-1dd2-11b2-99a6-080020736631 V_VAR - * 6a90ba39-1dd2-11b2-99a6-080020736631 V_HOME - * 6a9283a5-1dd2-11b2-99a6-080020736631 V_ALTSCTR - * 6a945a3b-1dd2-11b2-99a6-080020736631 V_CACHE + * 6a945a3b-1dd2-11b2-99a6-080020736631 V_RESERVED */ #define EFI_UNUSED { 0x00000000, 0x0000, 0x0000, 0x00, 0x00, \ @@ -363,6 +360,11 @@ struct partition64 { #endif #ifndef _KERNEL +#define VT_ERROR (-2) /* errno supplies specific error */ +#define VT_EIO (-3) /* I/O error accessing vtoc */ +#define VT_EINVAL (-4) /* illegal value in vtoc or request */ +#define VT_ENOSPC (-6) /* requested space not found */ + _SYS_EFI_PARTITION_H int efi_debug; _SYS_EFI_PARTITION_H int efi_alloc_and_init(int, uint32_t, struct dk_gpt **); _SYS_EFI_PARTITION_H int efi_alloc_and_read(int, struct dk_gpt **); diff --git a/sys/contrib/openzfs/include/sys/fs/zfs.h b/sys/contrib/openzfs/include/sys/fs/zfs.h index ab29b4e2ef3..f9fd5cf676e 100644 --- a/sys/contrib/openzfs/include/sys/fs/zfs.h +++ b/sys/contrib/openzfs/include/sys/fs/zfs.h @@ -1185,6 +1185,7 @@ typedef struct vdev_stat { uint64_t vs_logical_ashift; /* vdev_logical_ashift */ uint64_t vs_physical_ashift; /* vdev_physical_ashift */ uint64_t vs_noalloc; /* allocations halted? */ + uint64_t vs_pspace; /* physical capacity */ } vdev_stat_t; #define VDEV_STAT_VALID(field, uint64_t_field_count) \ diff --git a/sys/contrib/openzfs/include/sys/xvattr.h b/sys/contrib/openzfs/include/sys/xvattr.h index 0463bdfbc9d..277c4694069 100644 --- a/sys/contrib/openzfs/include/sys/xvattr.h +++ b/sys/contrib/openzfs/include/sys/xvattr.h @@ -40,7 +40,7 @@ #define _SYS_XVATTR_H #include -#include +#include #define AV_SCANSTAMP_SZ 32 /* length of anti-virus scanstamp */ @@ -282,7 +282,7 @@ typedef struct xvattr { static inline void xva_init(xvattr_t *xvap) { - bzero(xvap, sizeof (xvattr_t)); + memset(xvap, 0, sizeof (xvattr_t)); xvap->xva_mapsize = XVA_MAPSIZE; xvap->xva_magic = XVA_MAGIC; xvap->xva_vattr.va_mask = ATTR_XVATTR; diff --git a/sys/contrib/openzfs/include/sys/zfs_context.h b/sys/contrib/openzfs/include/sys/zfs_context.h index a1114d746e3..944acdcfbe5 100644 --- a/sys/contrib/openzfs/include/sys/zfs_context.h +++ b/sys/contrib/openzfs/include/sys/zfs_context.h @@ -55,7 +55,7 @@ extern "C" { #include #include #include -#include +#include #include #include #include @@ -91,7 +91,6 @@ extern "C" { #include #include #include -#include #include #include #include @@ -153,13 +152,8 @@ extern void dprintf_setup(int *argc, char **argv); extern void cmn_err(int, const char *, ...); extern void vcmn_err(int, const char *, va_list); -#if defined(__cplusplus) && __cplusplus >= 201103L -extern void panic(const char *, ...) __attribute__((__noreturn__)); -extern void vpanic(const char *, va_list) __attribute__((__noreturn__)); -#else -extern _Noreturn void panic(const char *, ...); -extern _Noreturn void vpanic(const char *, va_list); -#endif +extern __attribute__((noreturn)) void panic(const char *, ...); +extern __attribute__((noreturn)) void vpanic(const char *, va_list); #define fm_panic panic diff --git a/sys/contrib/openzfs/lib/libefi/rdwr_efi.c b/sys/contrib/openzfs/lib/libefi/rdwr_efi.c index b4fec0c8600..30fddc3db8a 100644 --- a/sys/contrib/openzfs/lib/libefi/rdwr_efi.c +++ b/sys/contrib/openzfs/lib/libefi/rdwr_efi.c @@ -29,14 +29,12 @@ #include #include #include -#include #include #include #include #include #include #include -#include #include #include #include @@ -857,7 +855,6 @@ efi_read(int fd, struct dk_gpt *vtoc) } for (i = 0; i < vtoc->efi_nparts; i++) { - UUID_LE_CONVERT(vtoc->efi_parts[i].p_guid, efi_parts[i].efi_gpe_PartitionTypeGUID); @@ -865,7 +862,7 @@ efi_read(int fd, struct dk_gpt *vtoc) j < sizeof (conversion_array) / sizeof (struct uuid_to_ptag); j++) { - if (bcmp(&vtoc->efi_parts[i].p_guid, + if (memcmp(&vtoc->efi_parts[i].p_guid, &conversion_array[j].uuid, sizeof (struct uuid)) == 0) { vtoc->efi_parts[i].p_tag = j; @@ -920,18 +917,17 @@ write_pmbr(int fd, struct dk_gpt *vtoc) /* LINTED -- always longlong aligned */ dk_ioc.dki_data = (efi_gpt_t *)buf; if (efi_ioctl(fd, DKIOCGETEFI, &dk_ioc) == -1) { - (void) memcpy(&mb, buf, sizeof (mb)); - bzero(&mb, sizeof (mb)); + memset(&mb, 0, sizeof (mb)); mb.signature = LE_16(MBB_MAGIC); } else { (void) memcpy(&mb, buf, sizeof (mb)); if (mb.signature != LE_16(MBB_MAGIC)) { - bzero(&mb, sizeof (mb)); + memset(&mb, 0, sizeof (mb)); mb.signature = LE_16(MBB_MAGIC); } } - bzero(&mb.parts, sizeof (mb.parts)); + memset(&mb.parts, 0, sizeof (mb.parts)); cp = (uchar_t *)&mb.parts[0]; /* bootable or not */ *cp++ = 0; @@ -1455,8 +1451,8 @@ efi_write(int fd, struct dk_gpt *vtoc) (void) uuid_generate((uchar_t *) &vtoc->efi_parts[i].p_uguid); } - bcopy(&vtoc->efi_parts[i].p_uguid, - &efi_parts[i].efi_gpe_UniquePartitionGUID, + memcpy(&efi_parts[i].efi_gpe_UniquePartitionGUID, + &vtoc->efi_parts[i].p_uguid, sizeof (uuid_t)); } efi->efi_gpt_PartitionEntryArrayCRC32 = diff --git a/sys/contrib/openzfs/lib/libnvpair/libnvpair_json.c b/sys/contrib/openzfs/lib/libnvpair/libnvpair_json.c index 15b6f4afaf7..19acea8f509 100644 --- a/sys/contrib/openzfs/lib/libnvpair/libnvpair_json.c +++ b/sys/contrib/openzfs/lib/libnvpair/libnvpair_json.c @@ -15,7 +15,7 @@ #include #include -#include +#include #include #include @@ -46,12 +46,10 @@ static int nvlist_print_json_string(FILE *fp, const char *input) { - mbstate_t mbr; + mbstate_t mbr = {0}; wchar_t c; size_t sz; - bzero(&mbr, sizeof (mbr)); - FPRINTF(fp, "\""); while ((sz = mbrtowc(&c, input, MB_CUR_MAX, &mbr)) > 0) { if (sz == (size_t)-1 || sz == (size_t)-2) { diff --git a/sys/contrib/openzfs/lib/libshare/libshare.c b/sys/contrib/openzfs/lib/libshare/libshare.c index a228645fbf8..7bc31d7a682 100644 --- a/sys/contrib/openzfs/lib/libshare/libshare.c +++ b/sys/contrib/openzfs/lib/libshare/libshare.c @@ -27,8 +27,8 @@ #include #include +#include #include -#include #include #include #include diff --git a/sys/contrib/openzfs/lib/libshare/os/freebsd/smb.c b/sys/contrib/openzfs/lib/libshare/os/freebsd/smb.c index a25990d3bfb..445784b756b 100644 --- a/sys/contrib/openzfs/lib/libshare/os/freebsd/smb.c +++ b/sys/contrib/openzfs/lib/libshare/os/freebsd/smb.c @@ -27,7 +27,6 @@ #include #include #include -#include #include #include #include diff --git a/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c b/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c index 002c5e24ca6..5acfa3fb854 100644 --- a/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c +++ b/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c @@ -29,7 +29,6 @@ #include #include #include -#include #include #include #include diff --git a/sys/contrib/openzfs/lib/libshare/os/linux/smb.c b/sys/contrib/openzfs/lib/libshare/os/linux/smb.c index 312ffb97d12..bcb9b427031 100644 --- a/sys/contrib/openzfs/lib/libshare/os/linux/smb.c +++ b/sys/contrib/openzfs/lib/libshare/os/linux/smb.c @@ -50,7 +50,6 @@ #include #include #include -#include #include #include #include diff --git a/sys/contrib/openzfs/lib/libspl/include/sys/Makefile.am b/sys/contrib/openzfs/lib/libspl/include/sys/Makefile.am index 6816a012533..4315470b59b 100644 --- a/sys/contrib/openzfs/lib/libspl/include/sys/Makefile.am +++ b/sys/contrib/openzfs/lib/libspl/include/sys/Makefile.am @@ -29,7 +29,7 @@ libspl_HEADERS = \ simd.h \ stack.h \ stdtypes.h \ - strings.h \ + string.h \ stropts.h \ sunddi.h \ systeminfo.h \ @@ -43,6 +43,5 @@ libspl_HEADERS = \ va_list.h \ varargs.h \ vnode.h \ - vtoc.h \ wmsum.h \ zone.h diff --git a/sys/contrib/openzfs/lib/libspl/include/sys/kstat.h b/sys/contrib/openzfs/lib/libspl/include/sys/kstat.h index f73fb92eb79..7f9aa6d8dbd 100644 --- a/sys/contrib/openzfs/lib/libspl/include/sys/kstat.h +++ b/sys/contrib/openzfs/lib/libspl/include/sys/kstat.h @@ -383,9 +383,9 @@ typedef struct kstat32 { * * ksp->ks_snaptime = gethrtime(); * if (rw == KSTAT_WRITE) - * bcopy(buf, ksp->ks_data, ksp->ks_data_size); + * memcpy(ksp->ks_data, buf, ksp->ks_data_size); * else - * bcopy(ksp->ks_data, buf, ksp->ks_data_size); + * memcpy(buf, ksp->ks_data, ksp->ks_data_size); * return (0); * * A more illuminating example is taking a snapshot of a linked list: @@ -394,7 +394,7 @@ typedef struct kstat32 { * if (rw == KSTAT_WRITE) * return (EACCES); ... See below ... * for (foo = first_foo; foo; foo = foo->next) { - * bcopy((char *) foo, (char *) buf, sizeof (struct foo)); + * memcpy(buf, foo, sizeof (struct foo)); * buf = ((struct foo *) buf) + 1; * } * return (0); @@ -423,12 +423,12 @@ typedef struct kstat32 { * uint_t i; * * ... Do the regular copy ... - * bcopy(ksp->ks_data, buf, sizeof (kstat_named_t) * ksp->ks_ndata); + * memcpy(buf, ksp->ks_data, sizeof (kstat_named_t) * ksp->ks_ndata); * * for (i = 0; i < ksp->ks_ndata; i++, knp++) { * if (knp[i].data_type == KSTAT_DATA_STRING && * KSTAT_NAMED_STR_PTR(knp) != NULL) { - * bcopy(KSTAT_NAMED_STR_PTR(knp), end, + * memcpy(end, KSTAT_NAMED_STR_PTR(knp), * KSTAT_NAMED_STR_BUFLEN(knp)); * KSTAT_NAMED_STR_PTR(knp) = end; * end += KSTAT_NAMED_STR_BUFLEN(knp); diff --git a/sys/contrib/openzfs/lib/libspl/include/sys/string.h b/sys/contrib/openzfs/lib/libspl/include/sys/string.h new file mode 100644 index 00000000000..3b2f5900276 --- /dev/null +++ b/sys/contrib/openzfs/lib/libspl/include/sys/string.h @@ -0,0 +1 @@ +#include diff --git a/sys/contrib/openzfs/lib/libspl/include/sys/strings.h b/sys/contrib/openzfs/lib/libspl/include/sys/strings.h deleted file mode 100644 index c142047dcdb..00000000000 --- a/sys/contrib/openzfs/lib/libspl/include/sys/strings.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * CDDL HEADER START - * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License, Version 1.0 only - * (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 - */ -/* - * Copyright 2006 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - */ - -#ifndef _LIBSPL_SYS_STRINGS_H -#define _LIBSPL_SYS_STRINGS_H - -#include -#include - -#endif diff --git a/sys/contrib/openzfs/lib/libspl/include/sys/vtoc.h b/sys/contrib/openzfs/lib/libspl/include/sys/vtoc.h deleted file mode 100644 index 5d8448b628d..00000000000 --- a/sys/contrib/openzfs/lib/libspl/include/sys/vtoc.h +++ /dev/null @@ -1,350 +0,0 @@ -/* - * 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 - */ - -/* - * Copyright 2009 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - */ - - -/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ -/* All Rights Reserved */ - - -#ifndef _SYS_VTOC_H -#define _SYS_VTOC_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Note: the VTOC is not implemented fully, nor in the manner - * that AT&T implements it. AT&T puts the vtoc structure - * into a sector, usually the second sector (pdsector is first). - * - * Sun incorporates the tag, flag, version, and volume vtoc fields into - * its Disk Label, which already has some vtoc-equivalent fields. - * Upon reading the vtoc with read_vtoc(), the following exceptions - * occur: - * v_bootinfo [all] returned as zero - * v_sanity returned as VTOC_SANE - * if Disk Label was sane - * v_sectorsz returned as 512 - * v_reserved [all] returned as zero - * timestamp [all] returned as zero - * - * See dklabel.h, read_vtoc(), and write_vtoc(). - */ - -#define V_NUMPAR NDKMAP /* The number of partitions */ - /* (from dkio.h) */ - -#define VTOC_SANE 0x600DDEEE /* Indicates a sane VTOC */ -#define V_VERSION 0x01 /* layout version number */ -#define V_EXTVERSION V_VERSION /* extvtoc layout version number */ - -/* - * Partition identification tags - */ -#define V_UNASSIGNED 0x00 /* unassigned partition */ -#define V_BOOT 0x01 /* Boot partition */ -#define V_ROOT 0x02 /* Root filesystem */ -#define V_SWAP 0x03 /* Swap filesystem */ -#define V_USR 0x04 /* Usr filesystem */ -#define V_BACKUP 0x05 /* full disk */ -#define V_STAND 0x06 /* Stand partition */ -#define V_VAR 0x07 /* Var partition */ -#define V_HOME 0x08 /* Home partition */ -#define V_ALTSCTR 0x09 /* Alternate sector partition */ -#define V_CACHE 0x0a /* Cache (cachefs) partition */ -#define V_RESERVED 0x0b /* SMI reserved data */ - -/* - * Partition permission flags - */ -#define V_UNMNT 0x01 /* Unmountable partition */ -#define V_RONLY 0x10 /* Read only */ - -/* - * error codes for reading & writing vtoc - */ -#define VT_ERROR (-2) /* errno supplies specific error */ -#define VT_EIO (-3) /* I/O error accessing vtoc */ -#define VT_EINVAL (-4) /* illegal value in vtoc or request */ -#define VT_ENOTSUP (-5) /* VTOC op. not supported */ -#define VT_ENOSPC (-6) /* requested space not found */ -#define VT_EOVERFLOW (-7) /* VTOC op. data struct limited */ - -struct partition { - ushort_t p_tag; /* ID tag of partition */ - ushort_t p_flag; /* permission flags */ - uint64_t p_start; /* start sector no of partition */ - long p_size; /* # of blocks in partition */ -}; - -struct vtoc { - unsigned long v_bootinfo[3]; /* info needed by mboot (unsupported) */ - unsigned long v_sanity; /* to verify vtoc sanity */ - unsigned long v_version; /* layout version */ - char v_volume[LEN_DKL_VVOL]; /* volume name */ - ushort_t v_sectorsz; /* sector size in bytes */ - ushort_t v_nparts; /* number of partitions */ - unsigned long v_reserved[10]; /* free space */ - struct partition v_part[V_NUMPAR]; /* partition headers */ - time_t timestamp[V_NUMPAR]; /* partition timestamp (unsupported) */ - char v_asciilabel[LEN_DKL_ASCII]; /* for compatibility */ -}; - -struct extpartition { - ushort_t p_tag; /* ID tag of partition */ - ushort_t p_flag; /* permission flags */ - ushort_t p_pad[2]; - diskaddr_t p_start; /* start sector no of partition */ - diskaddr_t p_size; /* # of blocks in partition */ -}; - - -struct extvtoc { - uint64_t v_bootinfo[3]; /* info needed by mboot (unsupported) */ - uint64_t v_sanity; /* to verify vtoc sanity */ - uint64_t v_version; /* layout version */ - char v_volume[LEN_DKL_VVOL]; /* volume name */ - ushort_t v_sectorsz; /* sector size in bytes */ - ushort_t v_nparts; /* number of partitions */ - ushort_t pad[2]; - uint64_t v_reserved[10]; - struct extpartition v_part[V_NUMPAR]; /* partition headers */ - uint64_t timestamp[V_NUMPAR]; /* partition timestamp (unsupported) */ - char v_asciilabel[LEN_DKL_ASCII]; /* for compatibility */ -}; - -#ifdef _KERNEL -#define extvtoctovtoc(extv, v) \ - { \ - int i; \ - v.v_bootinfo[0] = (unsigned long)extv.v_bootinfo[0]; \ - v.v_bootinfo[1] = (unsigned long)extv.v_bootinfo[1]; \ - v.v_bootinfo[2] = (unsigned long)extv.v_bootinfo[2]; \ - v.v_sanity = (unsigned long)extv.v_sanity; \ - v.v_version = (unsigned long)extv.v_version; \ - bcopy(extv.v_volume, v.v_volume, LEN_DKL_VVOL); \ - v.v_sectorsz = extv.v_sectorsz; \ - v.v_nparts = extv.v_nparts; \ - for (i = 0; i < 10; i++) \ - v.v_reserved[i] = (unsigned long)extv.v_reserved[i]; \ - for (i = 0; i < V_NUMPAR; i++) { \ - v.v_part[i].p_tag = extv.v_part[i].p_tag; \ - v.v_part[i].p_flag = extv.v_part[i].p_flag; \ - v.v_part[i].p_start = (uint64_t)extv.v_part[i].p_start; \ - v.v_part[i].p_size = (long)extv.v_part[i].p_size; \ - v.timestamp[i] = (time_t)extv.timestamp[i]; \ - } \ - bcopy(extv.v_asciilabel, v.v_asciilabel, LEN_DKL_ASCII); \ - } - -#define vtoctoextvtoc(v, extv) \ - { \ - int i; \ - extv.v_bootinfo[0] = (uint64_t)v.v_bootinfo[0]; \ - extv.v_bootinfo[1] = (uint64_t)v.v_bootinfo[1]; \ - extv.v_bootinfo[2] = (uint64_t)v.v_bootinfo[2]; \ - extv.v_sanity = (uint64_t)v.v_sanity; \ - extv.v_version = (uint64_t)v.v_version; \ - bcopy(v.v_volume, extv.v_volume, LEN_DKL_VVOL); \ - extv.v_sectorsz = v.v_sectorsz; \ - extv.v_nparts = v.v_nparts; \ - for (i = 0; i < 10; i++) \ - extv.v_reserved[i] = (uint64_t)v.v_reserved[i]; \ - for (i = 0; i < V_NUMPAR; i++) { \ - extv.v_part[i].p_tag = v.v_part[i].p_tag; \ - extv.v_part[i].p_flag = v.v_part[i].p_flag; \ - extv.v_part[i].p_start = \ - (diskaddr_t)(unsigned long)v.v_part[i].p_start; \ - extv.v_part[i].p_size = \ - (diskaddr_t)(unsigned long)v.v_part[i].p_size; \ - extv.timestamp[i] = (uint64_t)v.timestamp[i]; \ - } \ - bcopy(v.v_asciilabel, extv.v_asciilabel, LEN_DKL_ASCII); \ - } -#endif /* _KERNEL */ - -#if defined(_SYSCALL32) -struct partition32 { - uint16_t p_tag; /* ID tag of partition */ - uint16_t p_flag; /* permission flags */ - daddr32_t p_start; /* start sector no of partition */ - int32_t p_size; /* # of blocks in partition */ -}; - -struct vtoc32 { - uint32_t v_bootinfo[3]; /* info needed by mboot (unsupported) */ - uint32_t v_sanity; /* to verify vtoc sanity */ - uint32_t v_version; /* layout version */ - char v_volume[LEN_DKL_VVOL]; /* volume name */ - uint16_t v_sectorsz; /* sector size in bytes */ - uint16_t v_nparts; /* number of partitions */ - uint32_t v_reserved[10]; /* free space */ - struct partition32 v_part[V_NUMPAR]; /* partition headers */ - time32_t timestamp[V_NUMPAR]; /* partition timestamp (unsupported) */ - char v_asciilabel[LEN_DKL_ASCII]; /* for compatibility */ -}; - -#define vtoc32tovtoc(v32, v) \ - { \ - int i; \ - v.v_bootinfo[0] = v32.v_bootinfo[0]; \ - v.v_bootinfo[1] = v32.v_bootinfo[1]; \ - v.v_bootinfo[2] = v32.v_bootinfo[2]; \ - v.v_sanity = v32.v_sanity; \ - v.v_version = v32.v_version; \ - bcopy(v32.v_volume, v.v_volume, LEN_DKL_VVOL); \ - v.v_sectorsz = v32.v_sectorsz; \ - v.v_nparts = v32.v_nparts; \ - v.v_version = v32.v_version; \ - for (i = 0; i < 10; i++) \ - v.v_reserved[i] = v32.v_reserved[i]; \ - for (i = 0; i < V_NUMPAR; i++) { \ - v.v_part[i].p_tag = (ushort_t)v32.v_part[i].p_tag; \ - v.v_part[i].p_flag = (ushort_t)v32.v_part[i].p_flag; \ - v.v_part[i].p_start = (unsigned)v32.v_part[i].p_start; \ - v.v_part[i].p_size = (unsigned)v32.v_part[i].p_size; \ - } \ - for (i = 0; i < V_NUMPAR; i++) \ - v.timestamp[i] = (time_t)v32.timestamp[i]; \ - bcopy(v32.v_asciilabel, v.v_asciilabel, LEN_DKL_ASCII); \ - } - -#define vtoc32toextvtoc(v32, extv) \ - { \ - int i; \ - extv.v_bootinfo[0] = v32.v_bootinfo[0]; \ - extv.v_bootinfo[1] = v32.v_bootinfo[1]; \ - extv.v_bootinfo[2] = v32.v_bootinfo[2]; \ - extv.v_sanity = v32.v_sanity; \ - extv.v_version = v32.v_version; \ - bcopy(v32.v_volume, extv.v_volume, LEN_DKL_VVOL); \ - extv.v_sectorsz = v32.v_sectorsz; \ - extv.v_nparts = v32.v_nparts; \ - extv.v_version = v32.v_version; \ - for (i = 0; i < 10; i++) \ - extv.v_reserved[i] = v32.v_reserved[i]; \ - for (i = 0; i < V_NUMPAR; i++) { \ - extv.v_part[i].p_tag = (ushort_t)v32.v_part[i].p_tag; \ - extv.v_part[i].p_flag = (ushort_t)v32.v_part[i].p_flag; \ - extv.v_part[i].p_start = (diskaddr_t)v32.v_part[i].p_start; \ - extv.v_part[i].p_size = (diskaddr_t)v32.v_part[i].p_size; \ - extv.timestamp[i] = (time_t)v32.timestamp[i]; \ - } \ - bcopy(v32.v_asciilabel, extv.v_asciilabel, LEN_DKL_ASCII); \ - } - - -#define vtoctovtoc32(v, v32) \ - { \ - int i; \ - v32.v_bootinfo[0] = v.v_bootinfo[0]; \ - v32.v_bootinfo[1] = v.v_bootinfo[1]; \ - v32.v_bootinfo[2] = v.v_bootinfo[2]; \ - v32.v_sanity = v.v_sanity; \ - v32.v_version = v.v_version; \ - bcopy(v.v_volume, v32.v_volume, LEN_DKL_VVOL); \ - v32.v_sectorsz = v.v_sectorsz; \ - v32.v_nparts = v.v_nparts; \ - v32.v_version = v.v_version; \ - for (i = 0; i < 10; i++) \ - v32.v_reserved[i] = v.v_reserved[i]; \ - for (i = 0; i < V_NUMPAR; i++) { \ - v32.v_part[i].p_tag = (ushort_t)v.v_part[i].p_tag; \ - v32.v_part[i].p_flag = (ushort_t)v.v_part[i].p_flag; \ - v32.v_part[i].p_start = (unsigned)v.v_part[i].p_start; \ - v32.v_part[i].p_size = (unsigned)v.v_part[i].p_size; \ - } \ - for (i = 0; i < V_NUMPAR; i++) { \ - if (v.timestamp[i] > TIME32_MAX) \ - v32.timestamp[i] = TIME32_MAX; \ - else \ - v32.timestamp[i] = (time32_t)v.timestamp[i]; \ - } \ - bcopy(v.v_asciilabel, v32.v_asciilabel, LEN_DKL_ASCII); \ - } - -#define extvtoctovtoc32(extv, v32) \ - { \ - int i; \ - v32.v_bootinfo[0] = extv.v_bootinfo[0]; \ - v32.v_bootinfo[1] = extv.v_bootinfo[1]; \ - v32.v_bootinfo[2] = extv.v_bootinfo[2]; \ - v32.v_sanity = extv.v_sanity; \ - v32.v_version = extv.v_version; \ - bcopy(extv.v_volume, v32.v_volume, LEN_DKL_VVOL); \ - v32.v_sectorsz = extv.v_sectorsz; \ - v32.v_nparts = extv.v_nparts; \ - v32.v_version = extv.v_version; \ - for (i = 0; i < 10; i++) \ - v32.v_reserved[i] = extv.v_reserved[i]; \ - for (i = 0; i < V_NUMPAR; i++) { \ - v32.v_part[i].p_tag = (ushort_t)extv.v_part[i].p_tag; \ - v32.v_part[i].p_flag = (ushort_t)extv.v_part[i].p_flag; \ - v32.v_part[i].p_start = (unsigned)extv.v_part[i].p_start; \ - v32.v_part[i].p_size = (unsigned)extv.v_part[i].p_size; \ - } \ - for (i = 0; i < V_NUMPAR; i++) { \ - if (extv.timestamp[i] > TIME32_MAX) \ - v32.timestamp[i] = TIME32_MAX; \ - else \ - v32.timestamp[i] = (time32_t)extv.timestamp[i]; \ - } \ - bcopy(extv.v_asciilabel, v32.v_asciilabel, LEN_DKL_ASCII); \ - } - - -#endif /* _SYSCALL32 */ - -/* - * These defines are the mode parameter for the checksum routines. - */ -#define CK_CHECKSUM 0 /* check checksum */ -#define CK_MAKESUM 1 /* generate checksum */ - -#if defined(__STDC__) - -extern int read_vtoc(int, struct vtoc *); -extern int write_vtoc(int, struct vtoc *); -extern int read_extvtoc(int, struct extvtoc *); -extern int write_extvtoc(int, struct extvtoc *); - -#else - -extern int read_vtoc(); -extern int write_vtoc(); -extern int read_extvtoc(); -extern int write_extvtoc(); - -#endif /* __STDC__ */ - -#ifdef __cplusplus -} -#endif - -#endif /* _SYS_VTOC_H */ diff --git a/sys/contrib/openzfs/lib/libuutil/uu_pname.c b/sys/contrib/openzfs/lib/libuutil/uu_pname.c index b6c9f2cc03e..610b8585dcb 100644 --- a/sys/contrib/openzfs/lib/libuutil/uu_pname.c +++ b/sys/contrib/openzfs/lib/libuutil/uu_pname.c @@ -40,7 +40,7 @@ static const char *pname; -static _Noreturn void +static __attribute__((noreturn)) void uu_die_internal(int status, const char *format, va_list alist); int uu_exit_ok_value = EXIT_SUCCESS; @@ -110,7 +110,7 @@ uu_warn(const char *format, ...) va_end(alist); } -static __attribute__((format(printf, 2, 0))) _Noreturn void +static __attribute__((format(printf, 2, 0))) __attribute__((noreturn)) void uu_die_internal(int status, const char *format, va_list alist) { uu_warn_internal(errno, format, alist); diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_config.c b/sys/contrib/openzfs/lib/libzfs/libzfs_config.c index dd590159660..97b10bb761b 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_config.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_config.c @@ -193,7 +193,7 @@ namespace_reload(libzfs_handle_t *hdl) return (-1); } - verify(nvpair_value_nvlist(elem, &child) == 0); + child = fnvpair_value_nvlist(elem); if (nvlist_dup(child, &cn->cn_config, 0) != 0) { free(cn->cn_name); free(cn); diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c b/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c index e7d3b09c67a..1428029a9d3 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c @@ -614,7 +614,6 @@ get_key_material_https(libzfs_handle_t *hdl, const char *uri, kfdok: if ((key = fdopen(kfd, "r+")) == NULL) { ret = errno; - free(path); (void) close(kfd); zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Couldn't reopen temporary file: %s"), strerror(ret)); @@ -789,7 +788,7 @@ derive_key(libzfs_handle_t *hdl, zfs_keyformat_t format, uint64_t iters, switch (format) { case ZFS_KEYFORMAT_RAW: - bcopy(key_material, key, WRAPPING_KEY_LEN); + memcpy(key, key_material, WRAPPING_KEY_LEN); break; case ZFS_KEYFORMAT_HEX: ret = hex_key_to_raw((char *)key_material, diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c b/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c index 0115a17e6fe..b973e09508f 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c @@ -234,7 +234,6 @@ process_user_props(zfs_handle_t *zhp, nvlist_t *props) { libzfs_handle_t *hdl = zhp->zfs_hdl; nvpair_t *elem; - nvlist_t *propval; nvlist_t *nvl; if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) { @@ -247,7 +246,7 @@ process_user_props(zfs_handle_t *zhp, nvlist_t *props) if (!zfs_prop_user(nvpair_name(elem))) continue; - verify(nvpair_value_nvlist(elem, &propval) == 0); + nvlist_t *propval = fnvpair_value_nvlist(elem); if (nvlist_add_nvlist(nvl, nvpair_name(elem), propval) != 0) { nvlist_free(nvl); (void) no_memory(hdl); @@ -1315,8 +1314,7 @@ zfs_valid_proplist(libzfs_handle_t *hdl, zfs_type_t type, nvlist_t *nvl, /* Replace the label string with the internal form. */ (void) nvlist_remove(ret, zfs_prop_to_name(prop), DATA_TYPE_STRING); - verify(nvlist_add_string(ret, zfs_prop_to_name(prop), - hex) == 0); + fnvlist_add_string(ret, zfs_prop_to_name(prop), hex); free(hex); break; @@ -2056,7 +2054,7 @@ getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source) *source = NULL; if (nvlist_lookup_nvlist(zhp->zfs_props, zfs_prop_to_name(prop), &nv) == 0) { - verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0); + value = fnvlist_lookup_uint64(nv, ZPROP_VALUE); (void) nvlist_lookup_string(nv, ZPROP_SOURCE, source); } else { verify(!zhp->zfs_props_table || @@ -2385,8 +2383,7 @@ zfs_prop_get_recvd(zfs_handle_t *zhp, const char *propname, char *propbuf, if (nvlist_lookup_nvlist(zhp->zfs_recvd_props, propname, &propval) != 0) return (-1); - verify(nvlist_lookup_string(propval, ZPROP_VALUE, - &recvdval) == 0); + recvdval = fnvlist_lookup_string(propval, ZPROP_VALUE); (void) strlcpy(propbuf, recvdval, proplen); } @@ -2500,13 +2497,11 @@ zfs_get_clones_nvl(zfs_handle_t *zhp) } nvlist_free(nv); nvlist_free(value); - verify(0 == nvlist_lookup_nvlist(zhp->zfs_props, - zfs_prop_to_name(ZFS_PROP_CLONES), &nv)); + nv = fnvlist_lookup_nvlist(zhp->zfs_props, + zfs_prop_to_name(ZFS_PROP_CLONES)); } - verify(nvlist_lookup_nvlist(nv, ZPROP_VALUE, &value) == 0); - - return (value); + return (fnvlist_lookup_nvlist(nv, ZPROP_VALUE)); } static int @@ -3863,7 +3858,7 @@ zfs_check_snap_cb(zfs_handle_t *zhp, void *arg) return (EINVAL); if (lzc_exists(name)) - verify(nvlist_add_boolean(dd->nvl, name) == 0); + fnvlist_add_boolean(dd->nvl, name); rv = zfs_iter_filesystems(zhp, zfs_check_snap_cb, dd); zfs_close(zhp); @@ -3880,7 +3875,7 @@ zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname, boolean_t defer) struct destroydata dd = { 0 }; dd.snapname = snapname; - verify(nvlist_alloc(&dd.nvl, NV_UNIQUE_NAME, 0) == 0); + dd.nvl = fnvlist_alloc(); (void) zfs_check_snap_cb(zfs_handle_dup(zhp), &dd); if (nvlist_empty(dd.nvl)) { @@ -3890,7 +3885,7 @@ zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname, boolean_t defer) } else { ret = zfs_destroy_snaps_nvl(zhp->zfs_hdl, dd.nvl, defer); } - nvlist_free(dd.nvl); + fnvlist_free(dd.nvl); return (ret); } @@ -4221,7 +4216,7 @@ zfs_snapshot(libzfs_handle_t *hdl, const char *path, boolean_t recursive, return (-1); } - verify(nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) == 0); + sd.sd_nvl = fnvlist_alloc(); if (recursive) { (void) zfs_snapshot_cb(zfs_handle_dup(zhp), &sd); } else { @@ -4229,7 +4224,7 @@ zfs_snapshot(libzfs_handle_t *hdl, const char *path, boolean_t recursive, } ret = zfs_snapshot_nvl(hdl, sd.sd_nvl, props); - nvlist_free(sd.sd_nvl); + fnvlist_free(sd.sd_nvl); zfs_close(zhp); return (ret); } @@ -4712,8 +4707,8 @@ zfs_expand_proplist(zfs_handle_t *zhp, zprop_list_t **plp, boolean_t received, } else { if (nvlist_lookup_nvlist(userprops, entry->pl_user_prop, &propval) == 0) { - verify(nvlist_lookup_string(propval, - ZPROP_VALUE, &strval) == 0); + strval = fnvlist_lookup_string(propval, + ZPROP_VALUE); if (strlen(strval) > entry->pl_width) entry->pl_width = strlen(strval); } diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_import.c b/sys/contrib/openzfs/lib/libzfs/libzfs_import.c index 0d375b35516..004a684d5be 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_import.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_import.c @@ -48,7 +48,6 @@ pool_active(libzfs_handle_t *hdl, const char *name, uint64_t guid, boolean_t *isactive) { zpool_handle_t *zhp; - uint64_t theguid; if (zpool_open_silent(hdl, name, &zhp) != 0) return (-1); @@ -58,8 +57,8 @@ pool_active(libzfs_handle_t *hdl, const char *name, uint64_t guid, return (0); } - verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_POOL_GUID, - &theguid) == 0); + uint64_t theguid = fnvlist_lookup_uint64(zhp->zpool_config, + ZPOOL_CONFIG_POOL_GUID); zpool_close(zhp); @@ -239,12 +238,10 @@ zpool_clear_label(int fd) static boolean_t find_guid(nvlist_t *nv, uint64_t guid) { - uint64_t tmp; nvlist_t **child; uint_t c, children; - verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &tmp) == 0); - if (tmp == guid) + if (fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID) == guid) return (B_TRUE); if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, @@ -268,18 +265,16 @@ find_aux(zpool_handle_t *zhp, void *data) { aux_cbdata_t *cbp = data; nvlist_t **list; - uint_t i, count; - uint64_t guid; - nvlist_t *nvroot; + uint_t count; - verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE, - &nvroot) == 0); + nvlist_t *nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, + ZPOOL_CONFIG_VDEV_TREE); if (nvlist_lookup_nvlist_array(nvroot, cbp->cb_type, &list, &count) == 0) { - for (i = 0; i < count; i++) { - verify(nvlist_lookup_uint64(list[i], - ZPOOL_CONFIG_GUID, &guid) == 0); + for (uint_t i = 0; i < count; i++) { + uint64_t guid = fnvlist_lookup_uint64(list[i], + ZPOOL_CONFIG_GUID); if (guid == cbp->cb_guid) { cbp->cb_zhp = zhp; return (1); @@ -301,9 +296,9 @@ zpool_in_use(libzfs_handle_t *hdl, int fd, pool_state_t *state, char **namestr, boolean_t *inuse) { nvlist_t *config; - char *name; + char *name = NULL; boolean_t ret; - uint64_t guid, vdev_guid; + uint64_t guid = 0, vdev_guid; zpool_handle_t *zhp; nvlist_t *pool_config; uint64_t stateval, isspare; @@ -320,16 +315,12 @@ zpool_in_use(libzfs_handle_t *hdl, int fd, pool_state_t *state, char **namestr, if (config == NULL) return (0); - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, - &stateval) == 0); - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, - &vdev_guid) == 0); + stateval = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE); + vdev_guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID); if (stateval != POOL_STATE_SPARE && stateval != POOL_STATE_L2CACHE) { - verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, - &name) == 0); - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, - &guid) == 0); + name = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME); + guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID); } switch (stateval) { @@ -378,10 +369,8 @@ zpool_in_use(libzfs_handle_t *hdl, int fd, pool_state_t *state, char **namestr, if ((zhp = zpool_open_canfail(hdl, name)) != NULL && (pool_config = zpool_get_config(zhp, NULL)) != NULL) { - nvlist_t *nvroot; - - verify(nvlist_lookup_nvlist(pool_config, - ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); + nvlist_t *nvroot = fnvlist_lookup_nvlist( + pool_config, ZPOOL_CONFIG_VDEV_TREE); ret = find_guid(nvroot, vdev_guid); } else { ret = B_FALSE; diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c b/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c index 3c537be7948..132454886cf 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c @@ -28,7 +28,7 @@ #include #include -#include +#include #include #include #include diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c b/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c index 62c46be9532..794fd2f2962 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c @@ -74,7 +74,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c index fe58221a026..a65a9b64502 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c @@ -123,15 +123,13 @@ zpool_get_prop_string(zpool_handle_t *zhp, zpool_prop_t prop, zprop_source_t *src) { nvlist_t *nv, *nvl; - uint64_t ival; char *value; zprop_source_t source; nvl = zhp->zpool_props; if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) { - verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &ival) == 0); - source = ival; - verify(nvlist_lookup_string(nv, ZPROP_VALUE, &value) == 0); + source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); + value = fnvlist_lookup_string(nv, ZPROP_VALUE); } else { source = ZPROP_SRC_DEFAULT; if ((value = (char *)zpool_prop_default_string(prop)) == NULL) @@ -169,9 +167,8 @@ zpool_get_prop_int(zpool_handle_t *zhp, zpool_prop_t prop, zprop_source_t *src) nvl = zhp->zpool_props; if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) { - verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &value) == 0); - source = value; - verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0); + source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); + value = fnvlist_lookup_uint64(nv, ZPROP_VALUE); } else { source = ZPROP_SRC_DEFAULT; value = zpool_prop_default_numeric(prop); @@ -255,9 +252,6 @@ zpool_get_state_str(zpool_handle_t *zhp) { zpool_errata_t errata; zpool_status_t status; - nvlist_t *nvroot; - vdev_stat_t *vs; - uint_t vsc; const char *str; status = zpool_get_status(zhp, NULL, &errata); @@ -268,11 +262,11 @@ zpool_get_state_str(zpool_handle_t *zhp) status == ZPOOL_STATUS_IO_FAILURE_MMP) { str = gettext("SUSPENDED"); } else { - verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL), - ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); - verify(nvlist_lookup_uint64_array(nvroot, - ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc) - == 0); + nvlist_t *nvroot = fnvlist_lookup_nvlist( + zpool_get_config(zhp, NULL), ZPOOL_CONFIG_VDEV_TREE); + uint_t vsc; + vdev_stat_t *vs = (vdev_stat_t *)fnvlist_lookup_uint64_array( + nvroot, ZPOOL_CONFIG_VDEV_STATS, &vsc); str = zpool_state_to_name(vs->vs_state, vs->vs_aux); } return (str); @@ -986,8 +980,7 @@ vdev_expand_proplist(zpool_handle_t *zhp, const char *vdevname, if (nvpair_value_nvlist(elem, &propval) != 0) continue; - verify(nvlist_lookup_string(propval, ZPROP_VALUE, - &strval) == 0); + strval = fnvlist_lookup_string(propval, ZPROP_VALUE); if ((entry = zfs_alloc(zhp->zpool_hdl, sizeof (zprop_list_t))) == NULL) @@ -1996,20 +1989,13 @@ void zpool_print_unsup_feat(nvlist_t *config) { nvlist_t *nvinfo, *unsup_feat; - nvpair_t *nvp; - verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == - 0); - verify(nvlist_lookup_nvlist(nvinfo, ZPOOL_CONFIG_UNSUP_FEAT, - &unsup_feat) == 0); - - for (nvp = nvlist_next_nvpair(unsup_feat, NULL); nvp != NULL; - nvp = nvlist_next_nvpair(unsup_feat, nvp)) { - char *desc; - - verify(nvpair_type(nvp) == DATA_TYPE_STRING); - verify(nvpair_value_string(nvp, &desc) == 0); + nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO); + unsup_feat = fnvlist_lookup_nvlist(nvinfo, ZPOOL_CONFIG_UNSUP_FEAT); + for (nvpair_t *nvp = nvlist_next_nvpair(unsup_feat, NULL); + nvp != NULL; nvp = nvlist_next_nvpair(unsup_feat, nvp)) { + char *desc = fnvpair_value_string(nvp); if (strlen(desc) > 0) (void) printf("\t%s (%s)\n", nvpair_name(nvp), desc); else @@ -2038,8 +2024,7 @@ zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname, int error = 0; char errbuf[1024]; - verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, - &origname) == 0); + origname = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME); (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, "cannot import pool '%s'"), origname); @@ -2058,8 +2043,7 @@ zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname, uint64_t version; prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE }; - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, - &version) == 0); + version = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION); if ((props = zpool_valid_proplist(hdl, origname, props, version, flags, errbuf)) == NULL) @@ -2073,8 +2057,7 @@ zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname, (void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name)); - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, - &zc.zc_guid) == 0); + zc.zc_guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID); if (zcmd_write_conf_nvlist(hdl, &zc, config) != 0) { zcmd_free_nvlists(&zc); @@ -2635,8 +2618,8 @@ zpool_scan(zpool_handle_t *zhp, pool_scan_func_t func, pool_scrub_cmd_t cmd) pool_scan_stat_t *ps = NULL; uint_t psc; - verify(nvlist_lookup_nvlist(zhp->zpool_config, - ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); + nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, + ZPOOL_CONFIG_VDEV_TREE); (void) nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &psc); if (ps && ps->pss_func == POOL_SCAN_SCRUB && @@ -2684,11 +2667,9 @@ vdev_to_nvlist_iter(nvlist_t *nv, nvlist_t *search, boolean_t *avail_spare, switch (nvpair_type(pair)) { case DATA_TYPE_UINT64: if (strcmp(srchkey, ZPOOL_CONFIG_GUID) == 0) { - uint64_t srchval, theguid; - - verify(nvpair_value_uint64(pair, &srchval) == 0); - verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, - &theguid) == 0); + uint64_t srchval = fnvpair_value_uint64(pair); + uint64_t theguid = fnvlist_lookup_uint64(nv, + ZPOOL_CONFIG_GUID); if (theguid == srchval) return (nv); } @@ -2697,7 +2678,7 @@ vdev_to_nvlist_iter(nvlist_t *nv, nvlist_t *search, boolean_t *avail_spare, case DATA_TYPE_STRING: { char *srchval, *val; - verify(nvpair_value_string(pair, &srchval) == 0); + srchval = fnvpair_value_string(pair); if (nvlist_lookup_string(nv, srchkey, &val) != 0) break; @@ -2749,9 +2730,8 @@ vdev_to_nvlist_iter(nvlist_t *nv, nvlist_t *search, boolean_t *avail_spare, } verify(zpool_vdev_is_interior(type)); - verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID, - &id) == 0); + id = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID); errno = 0; vdev_id = strtoull(idx, &end, 10); @@ -2777,8 +2757,8 @@ vdev_to_nvlist_iter(nvlist_t *nv, nvlist_t *search, boolean_t *avail_spare, free(type); return (NULL); } - verify(nvlist_lookup_uint64(nv, - ZPOOL_CONFIG_NPARITY, &vdev_parity) == 0); + vdev_parity = fnvlist_lookup_uint64(nv, + ZPOOL_CONFIG_NPARITY); if ((int)vdev_parity != parity) { free(type); break; @@ -2867,25 +2847,24 @@ zpool_find_vdev_by_physpath(zpool_handle_t *zhp, const char *ppath, uint64_t guid; char *end; - verify(nvlist_alloc(&search, NV_UNIQUE_NAME, KM_SLEEP) == 0); + search = fnvlist_alloc(); guid = strtoull(ppath, &end, 0); if (guid != 0 && *end == '\0') { - verify(nvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid) == 0); + fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid); } else { - verify(nvlist_add_string(search, ZPOOL_CONFIG_PHYS_PATH, - ppath) == 0); + fnvlist_add_string(search, ZPOOL_CONFIG_PHYS_PATH, ppath); } - verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE, - &nvroot) == 0); + nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, + ZPOOL_CONFIG_VDEV_TREE); *avail_spare = B_FALSE; *l2cache = B_FALSE; if (log != NULL) *log = B_FALSE; ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log); - nvlist_free(search); + fnvlist_free(search); return (ret); } @@ -2918,26 +2897,26 @@ zpool_find_vdev(zpool_handle_t *zhp, const char *path, boolean_t *avail_spare, nvlist_t *nvroot, *search, *ret; uint64_t guid; - verify(nvlist_alloc(&search, NV_UNIQUE_NAME, KM_SLEEP) == 0); + search = fnvlist_alloc(); guid = strtoull(path, &end, 0); if (guid != 0 && *end == '\0') { - verify(nvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid) == 0); + fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid); } else if (zpool_vdev_is_interior(path)) { - verify(nvlist_add_string(search, ZPOOL_CONFIG_TYPE, path) == 0); + fnvlist_add_string(search, ZPOOL_CONFIG_TYPE, path); } else { - verify(nvlist_add_string(search, ZPOOL_CONFIG_PATH, path) == 0); + fnvlist_add_string(search, ZPOOL_CONFIG_PATH, path); } - verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE, - &nvroot) == 0); + nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, + ZPOOL_CONFIG_VDEV_TREE); *avail_spare = B_FALSE; *l2cache = B_FALSE; if (log != NULL) *log = B_FALSE; ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log); - nvlist_free(search); + fnvlist_free(search); return (ret); } @@ -3101,7 +3080,6 @@ static uint64_t zpool_vdev_path_to_guid_impl(zpool_handle_t *zhp, const char *path, boolean_t *is_spare, boolean_t *is_l2cache, boolean_t *is_log) { - uint64_t guid; boolean_t spare = B_FALSE, l2cache = B_FALSE, log = B_FALSE; nvlist_t *tgt; @@ -3109,7 +3087,6 @@ zpool_vdev_path_to_guid_impl(zpool_handle_t *zhp, const char *path, &log)) == NULL) return (0); - verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &guid) == 0); if (is_spare != NULL) *is_spare = spare; if (is_l2cache != NULL) @@ -3117,7 +3094,7 @@ zpool_vdev_path_to_guid_impl(zpool_handle_t *zhp, const char *path, if (is_log != NULL) *is_log = log; - return (guid); + return (fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID)); } /* Convert a vdev path to a GUID. Returns GUID or 0 on error. */ @@ -3137,11 +3114,9 @@ zpool_vdev_online(zpool_handle_t *zhp, const char *path, int flags, { zfs_cmd_t zc = {"\0"}; char msg[1024]; - char *pathname; nvlist_t *tgt; boolean_t avail_spare, l2cache, islog; libzfs_handle_t *hdl = zhp->zpool_hdl; - int error; if (flags & ZFS_ONLINE_EXPAND) { (void) snprintf(msg, sizeof (msg), @@ -3156,11 +3131,13 @@ zpool_vdev_online(zpool_handle_t *zhp, const char *path, int flags, &islog)) == NULL) return (zfs_error(hdl, EZFS_NODEVICE, msg)); - verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0); + zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); if (avail_spare) return (zfs_error(hdl, EZFS_ISSPARE, msg)); +#ifndef __FreeBSD__ + char *pathname; if ((flags & ZFS_ONLINE_EXPAND || zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOEXPAND, NULL)) && nvlist_lookup_string(tgt, ZPOOL_CONFIG_PATH, &pathname) == 0) { @@ -3181,6 +3158,7 @@ zpool_vdev_online(zpool_handle_t *zhp, const char *path, int flags, if (wholedisk) { const char *fullpath = path; char buf[MAXPATHLEN]; + int error; if (path[0] != '/') { error = zfs_resolve_shortname(path, buf, @@ -3197,6 +3175,7 @@ zpool_vdev_online(zpool_handle_t *zhp, const char *path, int flags, return (error); } } +#endif zc.zc_cookie = VDEV_STATE_ONLINE; zc.zc_obj = flags; @@ -3235,7 +3214,7 @@ zpool_vdev_offline(zpool_handle_t *zhp, const char *path, boolean_t istmp) NULL)) == NULL) return (zfs_error(hdl, EZFS_NODEVICE, msg)); - verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0); + zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); if (avail_spare) return (zfs_error(hdl, EZFS_ISSPARE, msg)); @@ -3333,13 +3312,10 @@ is_replacing_spare(nvlist_t *search, nvlist_t *tgt, int which) { nvlist_t **child; uint_t c, children; - char *type; if (nvlist_lookup_nvlist_array(search, ZPOOL_CONFIG_CHILDREN, &child, &children) == 0) { - verify(nvlist_lookup_string(search, ZPOOL_CONFIG_TYPE, - &type) == 0); - + char *type = fnvlist_lookup_string(search, ZPOOL_CONFIG_TYPE); if ((strcmp(type, VDEV_TYPE_SPARE) == 0 || strcmp(type, VDEV_TYPE_DRAID_SPARE) == 0) && children == 2 && child[which] == tgt) @@ -3391,7 +3367,7 @@ zpool_vdev_attach(zpool_handle_t *zhp, const char *old_disk, if (l2cache) return (zfs_error(hdl, EZFS_ISL2CACHE, msg)); - verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0); + zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); zc.zc_cookie = replacing; zc.zc_simple = rebuild; @@ -3409,8 +3385,8 @@ zpool_vdev_attach(zpool_handle_t *zhp, const char *old_disk, return (zfs_error(hdl, EZFS_INVALCONFIG, msg)); } - verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL), - ZPOOL_CONFIG_VDEV_TREE, &config_root) == 0); + config_root = fnvlist_lookup_nvlist(zpool_get_config(zhp, NULL), + ZPOOL_CONFIG_VDEV_TREE); if ((newname = zpool_vdev_name(NULL, NULL, child[0], 0)) == NULL) return (-1); @@ -3564,7 +3540,7 @@ zpool_vdev_detach(zpool_handle_t *zhp, const char *path) if (l2cache) return (zfs_error(hdl, EZFS_ISL2CACHE, msg)); - verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0); + zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); if (zfs_ioctl(hdl, ZFS_IOC_VDEV_DETACH, &zc) == 0) return (0); @@ -3664,9 +3640,8 @@ zpool_vdev_split(zpool_handle_t *zhp, char *newname, nvlist_t **newroot, return (-1); } - verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &tree) - == 0); - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &vers) == 0); + tree = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); + vers = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION); if (props) { prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE }; @@ -3733,8 +3708,7 @@ zpool_vdev_split(zpool_handle_t *zhp, char *newname, nvlist_t **newroot, continue; } lastlog = 0; - verify(nvlist_lookup_string(child[c], ZPOOL_CONFIG_TYPE, &type) - == 0); + type = fnvlist_lookup_string(child[c], ZPOOL_CONFIG_TYPE); if (strcmp(type, VDEV_TYPE_INDIRECT) == 0) { vdev = child[c]; @@ -3957,14 +3931,13 @@ zpool_vdev_remove(zpool_handle_t *zhp, const char *path) int zpool_vdev_remove_cancel(zpool_handle_t *zhp) { - zfs_cmd_t zc; + zfs_cmd_t zc = {{0}}; char msg[1024]; libzfs_handle_t *hdl = zhp->zpool_hdl; (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN, "cannot cancel removal")); - bzero(&zc, sizeof (zc)); (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); zc.zc_cookie = 1; @@ -4041,8 +4014,7 @@ zpool_clear(zpool_handle_t *zhp, const char *path, nvlist_t *rewindnvl) if (avail_spare) return (zfs_error(hdl, EZFS_ISSPARE, msg)); - verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, - &zc.zc_guid) == 0); + zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); } zpool_get_load_policy(rewindnvl, &policy); @@ -4195,7 +4167,7 @@ zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv, * vdev_name will be "root"/"root-0" for the root vdev, but it is the * zpool name that will be displayed to the user. */ - verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); + type = fnvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE); if (zhp != NULL && strcmp(type, "root") == 0) return (zfs_strdup(hdl, zpool_get_name(zhp))); @@ -4252,8 +4224,7 @@ zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv, * If it's a raidz device, we need to stick in the parity level. */ if (strcmp(path, VDEV_TYPE_RAIDZ) == 0) { - verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, - &value) == 0); + value = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY); (void) snprintf(buf, sizeof (buf), "%s%llu", path, (u_longlong_t)value); path = buf; @@ -4269,12 +4240,12 @@ zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv, verify(nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child, &children) == 0); - verify(nvlist_lookup_uint64(nv, - ZPOOL_CONFIG_NPARITY, &nparity) == 0); - verify(nvlist_lookup_uint64(nv, - ZPOOL_CONFIG_DRAID_NDATA, &ndata) == 0); - verify(nvlist_lookup_uint64(nv, - ZPOOL_CONFIG_DRAID_NSPARES, &nspares) == 0); + nparity = fnvlist_lookup_uint64(nv, + ZPOOL_CONFIG_NPARITY); + ndata = fnvlist_lookup_uint64(nv, + ZPOOL_CONFIG_DRAID_NDATA); + nspares = fnvlist_lookup_uint64(nv, + ZPOOL_CONFIG_DRAID_NSPARES); path = zpool_draid_name(buf, sizeof (buf), ndata, nparity, nspares, children); @@ -4285,9 +4256,8 @@ zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv, * naming convention. */ if (name_flags & VDEV_NAME_TYPE_ID) { - uint64_t id; - verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID, - &id) == 0); + uint64_t id = fnvlist_lookup_uint64(nv, + ZPOOL_CONFIG_ID); (void) snprintf(tmpbuf, sizeof (tmpbuf), "%s-%llu", path, (u_longlong_t)id); path = tmpbuf; @@ -4321,8 +4291,7 @@ zpool_get_errlog(zpool_handle_t *zhp, nvlist_t **nverrlistp) * has increased, allocate more space and continue until we get the * entire list. */ - verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_ERRCOUNT, - &count) == 0); + count = fnvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_ERRCOUNT); if (count == 0) return (0); zc.zc_nvlist_dst = (uintptr_t)zfs_alloc(zhp->zpool_hdl, @@ -4551,9 +4520,9 @@ zpool_get_history(zpool_handle_t *zhp, nvlist_t **nvhisp, uint64_t *off, free(buf); if (!err) { - verify(nvlist_alloc(nvhisp, NV_UNIQUE_NAME, 0) == 0); - verify(nvlist_add_nvlist_array(*nvhisp, ZPOOL_HIST_RECORD, - (const nvlist_t **)records, numrecords) == 0); + *nvhisp = fnvlist_alloc(); + fnvlist_add_nvlist_array(*nvhisp, ZPOOL_HIST_RECORD, + (const nvlist_t **)records, numrecords); } for (i = 0; i < numrecords; i++) nvlist_free(records[i]); @@ -5090,7 +5059,7 @@ zpool_vdev_guid(zpool_handle_t *zhp, const char *vdevname, uint64_t *vdev_guid) return (zfs_error(zhp->zpool_hdl, EZFS_NODEVICE, errbuf)); } - verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, vdev_guid) == 0); + *vdev_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); return (0); } @@ -5103,19 +5072,16 @@ zpool_get_vdev_prop_value(nvlist_t *nvprop, vdev_prop_t prop, char *prop_name, char *buf, size_t len, zprop_source_t *srctype, boolean_t literal) { nvlist_t *nv; - uint64_t intval; char *strval; + uint64_t intval; zprop_source_t src = ZPROP_SRC_NONE; if (prop == VDEV_PROP_USER) { /* user property, prop_name must contain the property name */ assert(prop_name != NULL); if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { - verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, - &intval) == 0); - src = intval; - verify(nvlist_lookup_string(nv, ZPROP_VALUE, - &strval) == 0); + src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); + strval = fnvlist_lookup_string(nv, ZPROP_VALUE); } else { /* user prop not found */ return (-1); @@ -5132,11 +5098,8 @@ zpool_get_vdev_prop_value(nvlist_t *nvprop, vdev_prop_t prop, char *prop_name, switch (vdev_prop_get_type(prop)) { case PROP_TYPE_STRING: if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { - verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, - &intval) == 0); - src = intval; - verify(nvlist_lookup_string(nv, ZPROP_VALUE, - &strval) == 0); + src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); + strval = fnvlist_lookup_string(nv, ZPROP_VALUE); } else { src = ZPROP_SRC_DEFAULT; if ((strval = (char *)vdev_prop_default_string(prop)) @@ -5148,11 +5111,8 @@ zpool_get_vdev_prop_value(nvlist_t *nvprop, vdev_prop_t prop, char *prop_name, case PROP_TYPE_NUMBER: if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { - verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, - &intval) == 0); - src = intval; - verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, - &intval) == 0); + src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); + intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE); } else { src = ZPROP_SRC_DEFAULT; intval = vdev_prop_default_numeric(prop); @@ -5232,11 +5192,8 @@ zpool_get_vdev_prop_value(nvlist_t *nvprop, vdev_prop_t prop, char *prop_name, case PROP_TYPE_INDEX: if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { - verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, - &intval) == 0); - src = intval; - verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, - &intval) == 0); + src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); + intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE); } else { src = ZPROP_SRC_DEFAULT; intval = vdev_prop_default_numeric(prop); diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c b/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c index ba6eddd12ea..4e805c5750e 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c @@ -38,7 +38,7 @@ #include #include #include -#include +#include #include #include #include @@ -4285,9 +4285,9 @@ zfs_receive_one(libzfs_handle_t *hdl, int infd, const char *tosnap, boolean_t recursive; char *snapname = NULL; char destsnap[MAXPATHLEN * 2]; - char origin[MAXNAMELEN]; + char origin[MAXNAMELEN] = {0}; char name[MAXPATHLEN]; - char tmp_keylocation[MAXNAMELEN]; + char tmp_keylocation[MAXNAMELEN] = {0}; nvlist_t *rcvprops = NULL; /* props received from the send stream */ nvlist_t *oxprops = NULL; /* override (-o) and exclude (-x) props */ nvlist_t *origprops = NULL; /* original props (if destination exists) */ @@ -4303,8 +4303,6 @@ zfs_receive_one(libzfs_handle_t *hdl, int infd, const char *tosnap, #define CLOCK_MONOTONIC_RAW CLOCK_MONOTONIC #endif clock_gettime(CLOCK_MONOTONIC_RAW, &begin_time); - bzero(origin, MAXNAMELEN); - bzero(tmp_keylocation, MAXNAMELEN); (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, "cannot receive")); @@ -5228,7 +5226,7 @@ zfs_receive_impl(libzfs_handle_t *hdl, const char *tosnap, * We computed the checksum in the wrong byteorder in * recv_read() above; do it again correctly. */ - bzero(&zcksum, sizeof (zio_cksum_t)); + memset(&zcksum, 0, sizeof (zio_cksum_t)); fletcher_4_incremental_byteswap(&drr, sizeof (drr), &zcksum); flags->byteswap = B_TRUE; diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_status.c b/sys/contrib/openzfs/lib/libzfs/libzfs_status.c index b7713b2bfe0..348a0936144 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_status.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_status.c @@ -159,8 +159,7 @@ find_vdev_problem(nvlist_t *vdev, int (*func)(vdev_stat_t *, uint_t), boolean_t ignore_replacing) { nvlist_t **child; - vdev_stat_t *vs; - uint_t c, vsc, children; + uint_t c, children; /* * Ignore problems within a 'replacing' vdev, since we're presumably in @@ -169,10 +168,7 @@ find_vdev_problem(nvlist_t *vdev, int (*func)(vdev_stat_t *, uint_t), * later. */ if (ignore_replacing == B_TRUE) { - char *type; - - verify(nvlist_lookup_string(vdev, ZPOOL_CONFIG_TYPE, - &type) == 0); + char *type = fnvlist_lookup_string(vdev, ZPOOL_CONFIG_TYPE); if (strcmp(type, VDEV_TYPE_REPLACING) == 0) return (B_FALSE); } @@ -183,9 +179,9 @@ find_vdev_problem(nvlist_t *vdev, int (*func)(vdev_stat_t *, uint_t), if (find_vdev_problem(child[c], func, ignore_replacing)) return (B_TRUE); } else { - verify(nvlist_lookup_uint64_array(vdev, ZPOOL_CONFIG_VDEV_STATS, - (uint64_t **)&vs, &vsc) == 0); - + uint_t vsc; + vdev_stat_t *vs = (vdev_stat_t *)fnvlist_lookup_uint64_array( + vdev, ZPOOL_CONFIG_VDEV_STATS, &vsc); if (func(vs, vsc) != 0) return (B_TRUE); } @@ -224,26 +220,21 @@ static zpool_status_t check_status(nvlist_t *config, boolean_t isimport, zpool_errata_t *erratap, const char *compat) { - nvlist_t *nvroot; - vdev_stat_t *vs; pool_scan_stat_t *ps = NULL; uint_t vsc, psc; uint64_t nerr; - uint64_t version; - uint64_t stateval; uint64_t suspended; uint64_t hostid = 0; uint64_t errata = 0; unsigned long system_hostid = get_system_hostid(); - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, - &version) == 0); - verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, - &nvroot) == 0); - verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, - (uint64_t **)&vs, &vsc) == 0); - verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, - &stateval) == 0); + uint64_t version = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION); + nvlist_t *nvroot = fnvlist_lookup_nvlist(config, + ZPOOL_CONFIG_VDEV_TREE); + vdev_stat_t *vs = (vdev_stat_t *)fnvlist_lookup_uint64_array(nvroot, + ZPOOL_CONFIG_VDEV_STATS, &vsc); + uint64_t stateval = fnvlist_lookup_uint64(config, + ZPOOL_CONFIG_POOL_STATE); /* * Currently resilvering a vdev @@ -337,10 +328,8 @@ check_status(nvlist_t *config, boolean_t isimport, */ if (vs->vs_state == VDEV_STATE_CANT_OPEN && vs->vs_aux == VDEV_AUX_UNSUP_FEAT) { - nvlist_t *nvinfo; - - verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, - &nvinfo) == 0); + nvlist_t *nvinfo = fnvlist_lookup_nvlist(config, + ZPOOL_CONFIG_LOAD_INFO); if (nvlist_exists(nvinfo, ZPOOL_CONFIG_CAN_RDONLY)) return (ZPOOL_STATUS_UNSUP_FEAT_WRITE); return (ZPOOL_STATUS_UNSUP_FEAT_READ); diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_util.c b/sys/contrib/openzfs/lib/libzfs/libzfs_util.c index f38eeb5125e..71072b5a74e 100644 --- a/sys/contrib/openzfs/lib/libzfs/libzfs_util.c +++ b/sys/contrib/openzfs/lib/libzfs/libzfs_util.c @@ -807,7 +807,7 @@ zfs_realloc(libzfs_handle_t *hdl, void *ptr, size_t oldsize, size_t newsize) return (NULL); } - bzero((char *)ret + oldsize, (newsize - oldsize)); + memset((char *)ret + oldsize, 0, newsize - oldsize); return (ret); } @@ -1199,10 +1199,8 @@ zcmd_write_nvlist_com(libzfs_handle_t *hdl, uint64_t *outnv, uint64_t *outlen, nvlist_t *nvl) { char *packed; - size_t len; - - verify(nvlist_size(nvl, &len, NV_ENCODE_NATIVE) == 0); + size_t len = fnvlist_size(nvl); if ((packed = zfs_alloc(hdl, len)) == NULL) return (-1); @@ -1751,14 +1749,10 @@ error: } static int -addlist(libzfs_handle_t *hdl, char *propname, zprop_list_t **listp, +addlist(libzfs_handle_t *hdl, const char *propname, zprop_list_t **listp, zfs_type_t type) { - int prop; - zprop_list_t *entry; - - prop = zprop_name_to_prop(propname, type); - + int prop = zprop_name_to_prop(propname, type); if (prop != ZPROP_INVAL && !zprop_valid_for_type(prop, type, B_FALSE)) prop = ZPROP_INVAL; @@ -1778,7 +1772,8 @@ addlist(libzfs_handle_t *hdl, char *propname, zprop_list_t **listp, dgettext(TEXT_DOMAIN, "bad property list"))); } - entry = zfs_alloc(hdl, sizeof (zprop_list_t)); + zprop_list_t *entry = zfs_alloc(hdl, sizeof (*entry)); + entry->pl_prop = prop; if (prop == ZPROP_INVAL) { entry->pl_user_prop = zfs_strdup(hdl, propname); @@ -1821,62 +1816,25 @@ zprop_get_list(libzfs_handle_t *hdl, char *props, zprop_list_t **listp, "bad property list"))); } - /* - * It would be nice to use getsubopt() here, but the inclusion of column - * aliases makes this more effort than it's worth. - */ - while (*props != '\0') { - size_t len; - char *p; - char c; - - if ((p = strchr(props, ',')) == NULL) { - len = strlen(props); - p = props + len; - } else { - len = p - props; - } - - /* - * Check for empty options. - */ - if (len == 0) { - zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, - "empty property name")); - return (zfs_error(hdl, EZFS_BADPROP, - dgettext(TEXT_DOMAIN, "bad property list"))); - } - - /* - * Check all regular property names. - */ - c = props[len]; - props[len] = '\0'; - - if (strcmp(props, "space") == 0) { - static char *spaceprops[] = { + for (char *p; (p = strsep(&props, ",")); ) + if (strcmp(p, "space") == 0) { + static const char *const spaceprops[] = { "name", "avail", "used", "usedbysnapshots", "usedbydataset", "usedbyrefreservation", - "usedbychildren", NULL + "usedbychildren" }; - int i; - for (i = 0; spaceprops[i]; i++) { + for (int i = 0; i < ARRAY_SIZE(spaceprops); i++) { if (addlist(hdl, spaceprops[i], listp, type)) return (-1); listp = &(*listp)->pl_next; } } else { - if (addlist(hdl, props, listp, type)) + if (addlist(hdl, p, listp, type)) return (-1); listp = &(*listp)->pl_next; } - props = p; - if (c == ',') - props++; - } - return (0); } diff --git a/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_compat.c b/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_compat.c index f5be2b90bba..a4b30df85d2 100644 --- a/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_compat.c +++ b/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_compat.c @@ -103,9 +103,9 @@ execvPe(const char *name, const char *path, char * const *argv, 16); continue; } - bcopy(p, buf, lp); + memcpy(buf, p, lp); buf[lp] = '/'; - bcopy(name, buf + lp + 1, ln); + memcpy(buf + lp + 1, name, ln); buf[lp + ln + 1] = '\0'; retry: (void) execve(bp, argv, envp); @@ -135,7 +135,7 @@ retry: (void) execve(bp, argv, envp); if (cnt > 0) { memp[0] = argv[0]; memp[1] = bp; - bcopy(argv + 1, memp + 2, + memcpy(memp + 2, argv + 1, cnt * sizeof (char *)); } else { memp[0] = "sh"; diff --git a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_mount_os.c b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_mount_os.c index 1b01caeb707..eab068d59e2 100644 --- a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_mount_os.c +++ b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_mount_os.c @@ -37,7 +37,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c index 90eb8db5079..570615cfd48 100644 --- a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c +++ b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c @@ -34,14 +34,13 @@ #include #include #include -#include +#include #include #include #include #include #include #include -#include #include #include #include @@ -224,10 +223,8 @@ zpool_label_disk(libzfs_handle_t *hdl, zpool_handle_t *zhp, const char *name) dgettext(TEXT_DOMAIN, "cannot label '%s'"), name); if (zhp) { - nvlist_t *nvroot; - - verify(nvlist_lookup_nvlist(zhp->zpool_config, - ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); + nvlist_t *nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, + ZPOOL_CONFIG_VDEV_TREE); if (zhp->zpool_start_block == 0) start_block = find_start_block(nvroot); @@ -280,8 +277,9 @@ zpool_label_disk(libzfs_handle_t *hdl, zpool_handle_t *zhp, const char *name) * Why we use V_USR: V_BACKUP confuses users, and is considered * disposable by some EFI utilities (since EFI doesn't have a backup * slice). V_UNASSIGNED is supposed to be used only for zero size - * partitions, and efi_write() will fail if we use it. V_ROOT, V_BOOT, - * etc. were all pretty specific. V_USR is as close to reality as we + * partitions, and efi_write() will fail if we use it. + * Other available types were all pretty specific. + * V_USR is as close to reality as we * can get, in the absence of V_OTHER. */ vtoc->efi_parts[0].p_tag = V_USR; diff --git a/sys/contrib/openzfs/lib/libzpool/kernel.c b/sys/contrib/openzfs/lib/libzpool/kernel.c index 6b29d6d39e6..89151f70ecb 100644 --- a/sys/contrib/openzfs/lib/libzpool/kernel.c +++ b/sys/contrib/openzfs/lib/libzpool/kernel.c @@ -633,7 +633,7 @@ __dprintf(boolean_t dprint, const char *file, const char *func, static char ce_prefix[CE_IGNORE][10] = { "", "NOTICE: ", "WARNING: ", "" }; static char ce_suffix[CE_IGNORE][2] = { "", "\n", "\n", "" }; -void +__attribute__((noreturn)) void vpanic(const char *fmt, va_list adx) { (void) fprintf(stderr, "error: "); @@ -643,7 +643,7 @@ vpanic(const char *fmt, va_list adx) abort(); /* think of it as a "user-level crash dump" */ } -void +__attribute__((noreturn)) void panic(const char *fmt, ...) { va_list adx; diff --git a/sys/contrib/openzfs/lib/libzpool/taskq.c b/sys/contrib/openzfs/lib/libzpool/taskq.c index 146044bb8b0..2531b341f44 100644 --- a/sys/contrib/openzfs/lib/libzpool/taskq.c +++ b/sys/contrib/openzfs/lib/libzpool/taskq.c @@ -211,7 +211,7 @@ taskq_wait_outstanding(taskq_t *tq, taskqid_t id) taskq_wait(tq); } -static _Noreturn void +static __attribute__((noreturn)) void taskq_thread(void *arg) { taskq_t *tq = arg; diff --git a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c index c4a36549dff..f24696259f2 100644 --- a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c +++ b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c @@ -613,27 +613,24 @@ zfs_get_underlying_path(const char *dev_name) /* * A disk is considered a multipath whole disk when: * DEVNAME key value has "dm-" - * MPATH_DEVICE_READY is present - * DM_UUID key exists + * DM_UUID key exists and starts with 'mpath-' * ID_PART_TABLE_TYPE key does not exist or is not gpt * ID_FS_LABEL key does not exist (disk isn't labeled) */ static boolean_t is_mpath_udev_sane(struct udev_device *dev) { - const char *devname, *type, *uuid, *label, *mpath_ready; + const char *devname, *type, *uuid, *label; devname = udev_device_get_property_value(dev, "DEVNAME"); type = udev_device_get_property_value(dev, "ID_PART_TABLE_TYPE"); uuid = udev_device_get_property_value(dev, "DM_UUID"); label = udev_device_get_property_value(dev, "ID_FS_LABEL"); - mpath_ready = udev_device_get_property_value(dev, "MPATH_DEVICE_READY"); if ((devname != NULL && strncmp(devname, "/dev/dm-", 8) == 0) && ((type == NULL) || (strcmp(type, "gpt") != 0)) && - (uuid != NULL) && - (label == NULL) && - (mpath_ready != NULL && strncmp(mpath_ready, "1", 1) == 0)) { + ((uuid != NULL) && (strncmp(uuid, "mpath-", 6) == 0)) && + (label == NULL)) { return (B_TRUE); } diff --git a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c index 0493e897bbe..6b825fcd71f 100644 --- a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c +++ b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c @@ -264,36 +264,36 @@ zpool_default_search_paths(size_t *count) * index in the passed 'order' variable, otherwise return an error. */ static int -zfs_path_order(char *name, int *order) +zfs_path_order(const char *name, int *order) { - int i, error = ENOENT; - char *dir, *env, *envdup, *tmp = NULL; + const char *env = getenv("ZPOOL_IMPORT_PATH"); - env = getenv("ZPOOL_IMPORT_PATH"); if (env) { - envdup = strdup(env); - for (dir = strtok_r(envdup, ":", &tmp), i = 0; - dir != NULL; - dir = strtok_r(NULL, ":", &tmp), i++) { - if (strncmp(name, dir, strlen(dir)) == 0) { - *order = i; - error = 0; + for (int i = 0; ; ++i) { + env += strspn(env, ":"); + size_t dirlen = strcspn(env, ":"); + if (dirlen) { + if (strncmp(name, env, dirlen) == 0) { + *order = i; + return (0); + } + + env += dirlen; + } else break; - } } - free(envdup); } else { - for (i = 0; i < ARRAY_SIZE(zpool_default_import_path); i++) { + for (int i = 0; i < ARRAY_SIZE(zpool_default_import_path); + ++i) { if (strncmp(name, zpool_default_import_path[i], strlen(zpool_default_import_path[i])) == 0) { *order = i; - error = 0; - break; + return (0); } } } - return (error); + return (ENOENT); } /* diff --git a/sys/contrib/openzfs/lib/libzutil/zutil_device_path.c b/sys/contrib/openzfs/lib/libzutil/zutil_device_path.c index 435c444b246..6a8c8869edf 100644 --- a/sys/contrib/openzfs/lib/libzutil/zutil_device_path.c +++ b/sys/contrib/openzfs/lib/libzutil/zutil_device_path.c @@ -56,35 +56,36 @@ zfs_dirnamelen(const char *path) int zfs_resolve_shortname(const char *name, char *path, size_t len) { - int i, error = -1; - char *dir, *env, *envdup, *tmp = NULL; - - env = getenv("ZPOOL_IMPORT_PATH"); - errno = ENOENT; + const char *env = getenv("ZPOOL_IMPORT_PATH"); if (env) { - envdup = strdup(env); - for (dir = strtok_r(envdup, ":", &tmp); - dir != NULL && error != 0; - dir = strtok_r(NULL, ":", &tmp)) { - (void) snprintf(path, len, "%s/%s", dir, name); - error = access(path, F_OK); + for (;;) { + env += strspn(env, ":"); + size_t dirlen = strcspn(env, ":"); + if (dirlen) { + (void) snprintf(path, len, "%.*s/%s", + (int)dirlen, env, name); + if (access(path, F_OK) == 0) + return (0); + + env += dirlen; + } else + break; } - free(envdup); } else { - const char * const *zpool_default_import_path; size_t count; + const char *const *zpool_default_import_path = + zpool_default_search_paths(&count); - zpool_default_import_path = zpool_default_search_paths(&count); - - for (i = 0; i < count && error < 0; i++) { + for (size_t i = 0; i < count; ++i) { (void) snprintf(path, len, "%s/%s", zpool_default_import_path[i], name); - error = access(path, F_OK); + if (access(path, F_OK) == 0) + return (0); } } - return (error ? ENOENT : 0); + return (errno = ENOENT); } /* @@ -100,7 +101,7 @@ zfs_strcmp_shortname(const char *name, const char *cmp_name, int wholedisk) int path_len, cmp_len, i = 0, error = ENOENT; char *dir, *env, *envdup = NULL, *tmp = NULL; char path_name[MAXPATHLEN]; - const char * const *zpool_default_import_path = NULL; + const char *const *zpool_default_import_path = NULL; size_t count; cmp_len = strlen(cmp_name); diff --git a/sys/contrib/openzfs/lib/libzutil/zutil_import.c b/sys/contrib/openzfs/lib/libzutil/zutil_import.c index d7547c4249e..3744a1c3474 100644 --- a/sys/contrib/openzfs/lib/libzutil/zutil_import.c +++ b/sys/contrib/openzfs/lib/libzutil/zutil_import.c @@ -47,7 +47,9 @@ * using our derived config, and record the results. */ +#ifdef HAVE_AIO_H #include +#endif #include #include #include @@ -982,6 +984,9 @@ zpool_read_label_slow(int fd, nvlist_t **config, int *num_labels) int zpool_read_label(int fd, nvlist_t **config, int *num_labels) { +#ifndef HAVE_AIO_H + return (zpool_read_label_slow(fd, config, num_labels)); +#else struct stat64 statbuf; struct aiocb aiocbs[VDEV_LABELS]; struct aiocb *aiocbps[VDEV_LABELS]; @@ -1104,6 +1109,7 @@ zpool_read_label(int fd, nvlist_t **config, int *num_labels) *config = expected_config; return (0); +#endif } /* diff --git a/sys/contrib/openzfs/man/man7/zpoolconcepts.7 b/sys/contrib/openzfs/man/man7/zpoolconcepts.7 index 58132baf502..582aeae50e2 100644 --- a/sys/contrib/openzfs/man/man7/zpoolconcepts.7 +++ b/sys/contrib/openzfs/man/man7/zpoolconcepts.7 @@ -123,7 +123,7 @@ In regards to I/O, performance is similar to raidz since for any read all Delivered random IOPS can be reasonably approximated as .Sy floor((N-S)/(D+P))*single_drive_IOPS . .Pp -Like raidzm a dRAID can have single-, double-, or triple-parity. +Like raidz, a dRAID can have single-, double-, or triple-parity. The .Sy draid1 , .Sy draid2 , diff --git a/sys/contrib/openzfs/man/man8/zdb.8 b/sys/contrib/openzfs/man/man8/zdb.8 index 902f818cc48..31ee601538c 100644 --- a/sys/contrib/openzfs/man/man8/zdb.8 +++ b/sys/contrib/openzfs/man/man8/zdb.8 @@ -464,12 +464,7 @@ If no options are specified, all information about the named pool will be displayed at default verbosity. . .Sh EXAMPLES -.Bl -tag -width Ds -.It Xo -.Sy Example 1 : -Display the configuration of imported pool -.Ar rpool -.Xc +.Ss Example 1 : No Display the configuration of imported pool Ar rpool .Bd -literal .No # Nm zdb Fl C Ar rpool MOS Configuration: @@ -477,22 +472,16 @@ MOS Configuration: name: 'rpool' … .Ed -.It Xo -.Sy Example 2 : -Display basic dataset information about -.Ar rpool -.Xc +. +.Ss Example 2 : No Display basic dataset information about Ar rpool .Bd -literal .No # Nm zdb Fl d Ar rpool Dataset mos [META], ID 0, cr_txg 4, 26.9M, 1051 objects Dataset rpool/swap [ZVOL], ID 59, cr_txg 356, 486M, 2 objects … .Ed -.It Xo -.Sy Example 3 : -Display basic information about object 0 in -.Ar rpool/export/home -.Xc +. +.Ss Example 3 : No Display basic information about object 0 in Ar rpool/export/home .Bd -literal .No # Nm zdb Fl d Ar rpool/export/home 0 Dataset rpool/export/home [ZPL], ID 137, cr_txg 1546, 32K, 8 objects @@ -500,11 +489,8 @@ Dataset rpool/export/home [ZPL], ID 137, cr_txg 1546, 32K, 8 objects Object lvl iblk dblk dsize lsize %full type 0 7 16K 16K 15.0K 16K 25.00 DMU dnode .Ed -.It Xo -.Sy Example 4 : -Display the predicted effect of enabling deduplication on -.Ar rpool -.Xc +. +.Ss Example 4 : No Display the predicted effect of enabling deduplication on Ar rpool .Bd -literal .No # Nm zdb Fl S Ar rpool Simulated DDT histogram: @@ -518,7 +504,6 @@ refcnt blocks LSIZE PSIZE DSIZE blocks LSIZE PSIZE DSIZE … dedup = 1.11, compress = 1.80, copies = 1.00, dedup * compress / copies = 2.00 .Ed -.El . .Sh SEE ALSO .Xr zfs 8 , diff --git a/sys/contrib/openzfs/man/man8/zfs-allow.8 b/sys/contrib/openzfs/man/man8/zfs-allow.8 index bbd62edc289..f949a0a5eee 100644 --- a/sys/contrib/openzfs/man/man8/zfs-allow.8 +++ b/sys/contrib/openzfs/man/man8/zfs-allow.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZFS-ALLOW 8 .Os . @@ -384,3 +384,109 @@ Removes permissions from a permission set. If no permissions are specified, then all permissions are removed, thus removing the set entirely. .El +. +.Sh EXAMPLES +.\" These are, respectively, examples 17, 18, 19, 20 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Delegating ZFS Administration Permissions on a ZFS Dataset +The following example shows how to set permissions so that user +.Ar cindys +can create, destroy, mount, and take snapshots on +.Ar tank/cindys . +The permissions on +.Ar tank/cindys +are also displayed. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm allow Sy cindys create , Ns Sy destroy , Ns Sy mount , Ns Sy snapshot Ar tank/cindys +.No # Nm zfs Cm allow Ar tank/cindys +---- Permissions on tank/cindys -------------------------------------- +Local+Descendent permissions: + user cindys create,destroy,mount,snapshot +.Ed +.Pp +Because the +.Ar tank/cindys +mount point permission is set to 755 by default, user +.Ar cindys +will be unable to mount file systems under +.Ar tank/cindys . +Add an ACE similar to the following syntax to provide mount point access: +.Dl # Cm chmod No A+user: Ns Ar cindys Ns :add_subdirectory:allow Ar /tank/cindys +. +.Ss Example 2 : No Delegating Create Time Permissions on a ZFS Dataset +The following example shows how to grant anyone in the group +.Ar staff +to create file systems in +.Ar tank/users . +This syntax also allows staff members to destroy their own file systems, but not +destroy anyone else's file system. +The permissions on +.Ar tank/users +are also displayed. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm allow Ar staff Sy create , Ns Sy mount Ar tank/users +.No # Nm zfs Cm allow Fl c Sy destroy Ar tank/users +.No # Nm zfs Cm allow Ar tank/users +---- Permissions on tank/users --------------------------------------- +Permission sets: + destroy +Local+Descendent permissions: + group staff create,mount +.Ed +. +.Ss Example 3 : No Defining and Granting a Permission Set on a ZFS Dataset +The following example shows how to define and grant a permission set on the +.Ar tank/users +file system. +The permissions on +.Ar tank/users +are also displayed. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm allow Fl s No @ Ns Ar pset Sy create , Ns Sy destroy , Ns Sy snapshot , Ns Sy mount Ar tank/users +.No # Nm zfs Cm allow staff No @ Ns Ar pset tank/users +.No # Nm zfs Cm allow Ar tank/users +---- Permissions on tank/users --------------------------------------- +Permission sets: + @pset create,destroy,mount,snapshot +Local+Descendent permissions: + group staff @pset +.Ed +. +.Ss Example 4 : No Delegating Property Permissions on a ZFS Dataset +The following example shows to grant the ability to set quotas and reservations +on the +.Ar users/home +file system. +The permissions on +.Ar users/home +are also displayed. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm allow Ar cindys Sy quota , Ns Sy reservation Ar users/home +.No # Nm zfs Cm allow Ar users/home +---- Permissions on users/home --------------------------------------- +Local+Descendent permissions: + user cindys quota,reservation +cindys% zfs set quota=10G users/home/marks +cindys% zfs get quota users/home/marks +NAME PROPERTY VALUE SOURCE +users/home/marks quota 10G local +.Ed +. +.Ss Example 5 : No Removing ZFS Delegated Permissions on a ZFS Dataset +The following example shows how to remove the snapshot permission from the +.Ar staff +group on the +.Sy tank/users +file system. +The permissions on +.Sy tank/users +are also displayed. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm unallow Ar staff Sy snapshot Ar tank/users +.No # Nm zfs Cm allow Ar tank/users +---- Permissions on tank/users --------------------------------------- +Permission sets: + @pset create,destroy,mount,snapshot +Local+Descendent permissions: + group staff @pset +.Ed diff --git a/sys/contrib/openzfs/man/man8/zfs-bookmark.8 b/sys/contrib/openzfs/man/man8/zfs-bookmark.8 index 094a7b30902..88153b2ccfb 100644 --- a/sys/contrib/openzfs/man/man8/zfs-bookmark.8 +++ b/sys/contrib/openzfs/man/man8/zfs-bookmark.8 @@ -30,7 +30,7 @@ .\" Copyright 2019 Joyent, Inc. .\" Copyright (c) 2019, 2020 by Christian Schwarz. All Rights Reserved. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZFS-BOOKMARK 8 .Os . @@ -61,6 +61,14 @@ for details on ZFS feature flags and the .Sy bookmarks feature. . +.Sh EXAMPLES +.\" These are, respectively, examples 23 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Creating a bookmark +The following example create a bookmark to a snapshot. +This bookmark can then be used instead of snapshot in send streams. +.Dl # Nm zfs Cm bookmark Ar rpool Ns @ Ns Ar snapshot rpool Ns # Ns Ar bookmark +. .Sh SEE ALSO .Xr zfs-destroy 8 , .Xr zfs-send 8 , diff --git a/sys/contrib/openzfs/man/man8/zfs-clone.8 b/sys/contrib/openzfs/man/man8/zfs-clone.8 index 0640244f200..305748a8cd0 100644 --- a/sys/contrib/openzfs/man/man8/zfs-clone.8 +++ b/sys/contrib/openzfs/man/man8/zfs-clone.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZFS-CLONE 8 .Os . @@ -65,6 +65,32 @@ If the target filesystem or volume already exists, the operation completes successfully. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 9, 10 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Creating a ZFS Clone +The following command creates a writable file system whose initial contents are +the same as +.Ar pool/home/bob@yesterday . +.Dl # Nm zfs Cm clone Ar pool/home/bob@yesterday pool/clone +. +.Ss Example 2 : No Promoting a ZFS Clone +The following commands illustrate how to test out changes to a file system, and +then replace the original file system with the changed one, using clones, clone +promotion, and renaming: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm create Ar pool/project/production + populate /pool/project/production with data +.No # Nm zfs Cm snapshot Ar pool/project/production Ns @ Ns Ar today +.No # Nm zfs Cm clone Ar pool/project/production@today pool/project/beta + make changes to /pool/project/beta and test them +.No # Nm zfs Cm promote Ar pool/project/beta +.No # Nm zfs Cm rename Ar pool/project/production pool/project/legacy +.No # Nm zfs Cm rename Ar pool/project/beta pool/project/production + once the legacy version is no longer needed, it can be destroyed +.No # Nm zfs Cm destroy Ar pool/project/legacy +.Ed +. .Sh SEE ALSO .Xr zfs-promote 8 , .Xr zfs-snapshot 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-create.8 b/sys/contrib/openzfs/man/man8/zfs-create.8 index 55397fa661d..f302493e0ab 100644 --- a/sys/contrib/openzfs/man/man8/zfs-create.8 +++ b/sys/contrib/openzfs/man/man8/zfs-create.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd December 1, 2020 +.Dd March 16, 2022 .Dt ZFS-CREATE 8 .Os . @@ -243,6 +243,39 @@ enable the swap area using the command. Swapping to files on ZFS filesystems is not supported. . +.Sh EXAMPLES +.\" These are, respectively, examples 1, 10 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Creating a ZFS File System Hierarchy +The following commands create a file system named +.Ar pool/home +and a file system named +.Ar pool/home/bob . +The mount point +.Pa /export/home +is set for the parent file system, and is automatically inherited by the child +file system. +.Dl # Nm zfs Cm create Ar pool/home +.Dl # Nm zfs Cm set Sy mountpoint Ns = Ns Ar /export/home pool/home +.Dl # Nm zfs Cm create Ar pool/home/bob +. +.Ss Example 2 : No Promoting a ZFS Clone +The following commands illustrate how to test out changes to a file system, and +then replace the original file system with the changed one, using clones, clone +promotion, and renaming: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm create Ar pool/project/production + populate /pool/project/production with data +.No # Nm zfs Cm snapshot Ar pool/project/production Ns @ Ns Ar today +.No # Nm zfs Cm clone Ar pool/project/production@today pool/project/beta + make changes to /pool/project/beta and test them +.No # Nm zfs Cm promote Ar pool/project/beta +.No # Nm zfs Cm rename Ar pool/project/production pool/project/legacy +.No # Nm zfs Cm rename Ar pool/project/beta pool/project/production + once the legacy version is no longer needed, it can be destroyed +.No # Nm zfs Cm destroy Ar pool/project/legacy +.Ed +. .Sh SEE ALSO .Xr zfs-destroy 8 , .Xr zfs-list 8 , diff --git a/sys/contrib/openzfs/man/man8/zfs-destroy.8 b/sys/contrib/openzfs/man/man8/zfs-destroy.8 index 51d9b7ab8e7..26926d8dcbb 100644 --- a/sys/contrib/openzfs/man/man8/zfs-destroy.8 +++ b/sys/contrib/openzfs/man/man8/zfs-destroy.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd June 30, 2019 +.Dd March 16, 2022 .Dt ZFS-DESTROY 8 .Os . @@ -173,6 +173,54 @@ behavior for mounted file systems in use. The given bookmark is destroyed. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 3, 10, 15 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Creating and Destroying Multiple Snapshots +The following command creates snapshots named +.Ar yesterday No of Ar pool/home +and all of its descendent file systems. +Each snapshot is mounted on demand in the +.Pa .zfs/snapshot +directory at the root of its file system. +The second command destroys the newly created snapshots. +.Dl # Nm zfs Cm snapshot Fl r Ar pool/home Ns @ Ns Ar yesterday +.Dl # Nm zfs Cm destroy Fl r Ar pool/home Ns @ Ns Ar yesterday +. +.Ss Example 2 : No Promoting a ZFS Clone +The following commands illustrate how to test out changes to a file system, and +then replace the original file system with the changed one, using clones, clone +promotion, and renaming: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm create Ar pool/project/production + populate /pool/project/production with data +.No # Nm zfs Cm snapshot Ar pool/project/production Ns @ Ns Ar today +.No # Nm zfs Cm clone Ar pool/project/production@today pool/project/beta + make changes to /pool/project/beta and test them +.No # Nm zfs Cm promote Ar pool/project/beta +.No # Nm zfs Cm rename Ar pool/project/production pool/project/legacy +.No # Nm zfs Cm rename Ar pool/project/beta pool/project/production + once the legacy version is no longer needed, it can be destroyed +.No # Nm zfs Cm destroy Ar pool/project/legacy +.Ed +. +.Ss Example 3 : No Performing a Rolling Snapshot +The following example shows how to maintain a history of snapshots with a +consistent naming scheme. +To keep a week's worth of snapshots, the user destroys the oldest snapshot, +renames the remaining snapshots, and then creates a new snapshot, as follows: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm destroy Fl r Ar pool/users@7daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@6daysago No @ Ns Ar 7daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@5daysago No @ Ns Ar 6daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@4daysago No @ Ns Ar 5daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@3daysago No @ Ns Ar 4daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@2daysago No @ Ns Ar 3daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@yesterday No @ Ns Ar 2daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@today No @ Ns Ar yesterday +.No # Nm zfs Cm snapshot Fl r Ar pool/users Ns @ Ns Ar today +.Ed +. .Sh SEE ALSO .Xr zfs-create 8 , .Xr zfs-hold 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-diff.8 b/sys/contrib/openzfs/man/man8/zfs-diff.8 index a347f325203..f82735b38e4 100644 --- a/sys/contrib/openzfs/man/man8/zfs-diff.8 +++ b/sys/contrib/openzfs/man/man8/zfs-diff.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd May 29, 2021 +.Dd March 16, 2022 .Dt ZFS-DIFF 8 .Os . @@ -98,5 +98,24 @@ Do not non-ASCII paths. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 22 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Showing the differences between a snapshot and a ZFS Dataset +The following example shows how to see what has changed between a prior +snapshot of a ZFS dataset and its current state. +The +.Fl F +option is used to indicate type information for the files affected. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm diff Fl F Ar tank/test@before tank/test +M / /tank/test/ +M F /tank/test/linked (+1) +R F /tank/test/oldname -> /tank/test/newname +- F /tank/test/deleted ++ F /tank/test/created +M F /tank/test/modified +.Ed +. .Sh SEE ALSO .Xr zfs-snapshot 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-list.8 b/sys/contrib/openzfs/man/man8/zfs-list.8 index 5200483868f..2b4c13d0e3a 100644 --- a/sys/contrib/openzfs/man/man8/zfs-list.8 +++ b/sys/contrib/openzfs/man/man8/zfs-list.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZFS-LIST 8 .Os . @@ -70,10 +70,6 @@ The following fields are displayed: Used for scripting mode. Do not print headers and separate fields by a single tab instead of arbitrary white space. -.It Fl S Ar property -Same as the -.Fl s -option, but sorts by property in descending order. .It Fl d Ar depth Recursively display any children of the dataset, limiting the recursion to .Ar depth . @@ -142,6 +138,10 @@ the specified ordering. If no sorting options are specified the existing behavior of .Nm zfs Cm list is preserved. +.It Fl S Ar property +Same as +.Fl s , +but sorts by property in descending order. .It Fl t Ar type A comma-separated list of types to display, where .Ar type @@ -157,6 +157,27 @@ For example, specifying displays only snapshots. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 5 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Listing ZFS Datasets +The following command lists all active file systems and volumes in the system. +Snapshots are displayed if +.Sy listsnaps Ns = Ns Sy on . +The default is +.Sy off . +See +.Xr zpoolprops 7 +for more information on pool properties. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm list +NAME USED AVAIL REFER MOUNTPOINT +pool 450K 457G 18K /pool +pool/home 315K 457G 21K /export/home +pool/home/anne 18K 457G 18K /export/home/anne +pool/home/bob 276K 457G 276K /export/home/bob +.Ed +. .Sh SEE ALSO .Xr zfsprops 7 , .Xr zfs-get 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-promote.8 b/sys/contrib/openzfs/man/man8/zfs-promote.8 index ba8cd5f6da8..3cb89688733 100644 --- a/sys/contrib/openzfs/man/man8/zfs-promote.8 +++ b/sys/contrib/openzfs/man/man8/zfs-promote.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd June 30, 2019 +.Dd March 16, 2022 .Dt ZFS-PROMOTE 8 .Os . @@ -59,6 +59,26 @@ The .Nm zfs Cm rename subcommand can be used to rename any conflicting snapshots. . +.Sh EXAMPLES +.\" These are, respectively, examples 10 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Promoting a ZFS Clone +The following commands illustrate how to test out changes to a file system, and +then replace the original file system with the changed one, using clones, clone +promotion, and renaming: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm create Ar pool/project/production + populate /pool/project/production with data +.No # Nm zfs Cm snapshot Ar pool/project/production Ns @ Ns Ar today +.No # Nm zfs Cm clone Ar pool/project/production@today pool/project/beta + make changes to /pool/project/beta and test them +.No # Nm zfs Cm promote Ar pool/project/beta +.No # Nm zfs Cm rename Ar pool/project/production pool/project/legacy +.No # Nm zfs Cm rename Ar pool/project/beta pool/project/production + once the legacy version is no longer needed, it can be destroyed +.No # Nm zfs Cm destroy Ar pool/project/legacy +.Ed +. .Sh SEE ALSO .Xr zfs-clone 8 , .Xr zfs-rename 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-receive.8 b/sys/contrib/openzfs/man/man8/zfs-receive.8 index fc1e943bd61..8d99c7ee58d 100644 --- a/sys/contrib/openzfs/man/man8/zfs-receive.8 +++ b/sys/contrib/openzfs/man/man8/zfs-receive.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd February 16, 2020 +.Dd March 16, 2022 .Dt ZFS-RECEIVE 8 .Os . @@ -395,6 +395,48 @@ Abort an interrupted deleting its saved partially received state. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 12, 13 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Remotely Replicating ZFS Data +The following commands send a full stream and then an incremental stream to a +remote machine, restoring them into +.Em poolB/received/fs@a +and +.Em poolB/received/fs@b , +respectively. +.Em poolB +must contain the file system +.Em poolB/received , +and must not initially contain +.Em poolB/received/fs . +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm send Ar pool/fs@a | +.No " " Nm ssh Ar host Nm zfs Cm receive Ar poolB/received/fs Ns @ Ns Ar a +.No # Nm zfs Cm send Fl i Ar a pool/fs@b | +.No " " Nm ssh Ar host Nm zfs Cm receive Ar poolB/received/fs +.Ed +. +.Ss Example 2 : No Using the Nm zfs Cm receive Fl d No Option +The following command sends a full stream of +.Ar poolA/fsA/fsB@snap +to a remote machine, receiving it into +.Ar poolB/received/fsA/fsB@snap . +The +.Ar fsA/fsB@snap +portion of the received snapshot's name is determined from the name of the sent +snapshot. +.Ar poolB +must contain the file system +.Ar poolB/received . +If +.Ar poolB/received/fsA +does not exist, it is created as an empty file system. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm send Ar poolA/fsA/fsB@snap | +.No " " Nm ssh Ar host Nm zfs Cm receive Fl d Ar poolB/received +.Ed +. .Sh SEE ALSO .Xr zfs-send 8 , .Xr zstream 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-rename.8 b/sys/contrib/openzfs/man/man8/zfs-rename.8 index 6caee50657e..01c58087371 100644 --- a/sys/contrib/openzfs/man/man8/zfs-rename.8 +++ b/sys/contrib/openzfs/man/man8/zfs-rename.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd September 1, 2020 +.Dd March 16, 2022 .Dt ZFS-RENAME 8 .Os . @@ -121,3 +121,40 @@ the file system is not unmounted even if this option is not given. Recursively rename the snapshots of all descendent datasets. Snapshots are the only dataset that can be renamed recursively. .El +. +.Sh EXAMPLES +.\" These are, respectively, examples 10, 15 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Promoting a ZFS Clone +The following commands illustrate how to test out changes to a file system, and +then replace the original file system with the changed one, using clones, clone +promotion, and renaming: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm create Ar pool/project/production + populate /pool/project/production with data +.No # Nm zfs Cm snapshot Ar pool/project/production Ns @ Ns Ar today +.No # Nm zfs Cm clone Ar pool/project/production@today pool/project/beta + make changes to /pool/project/beta and test them +.No # Nm zfs Cm promote Ar pool/project/beta +.No # Nm zfs Cm rename Ar pool/project/production pool/project/legacy +.No # Nm zfs Cm rename Ar pool/project/beta pool/project/production + once the legacy version is no longer needed, it can be destroyed +.No # Nm zfs Cm destroy Ar pool/project/legacy +.Ed +. +.Ss Example 2 : No Performing a Rolling Snapshot +The following example shows how to maintain a history of snapshots with a +consistent naming scheme. +To keep a week's worth of snapshots, the user destroys the oldest snapshot, +renames the remaining snapshots, and then creates a new snapshot, as follows: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm destroy Fl r Ar pool/users@7daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@6daysago No @ Ns Ar 7daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@5daysago No @ Ns Ar 6daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@4daysago No @ Ns Ar 5daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@3daysago No @ Ns Ar 4daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@2daysago No @ Ns Ar 3daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@yesterday No @ Ns Ar 2daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@today No @ Ns Ar yesterday +.No # Nm zfs Cm snapshot Fl r Ar pool/users Ns @ Ns Ar today +.Ed diff --git a/sys/contrib/openzfs/man/man8/zfs-rollback.8 b/sys/contrib/openzfs/man/man8/zfs-rollback.8 index 08e914b4765..0ec61288858 100644 --- a/sys/contrib/openzfs/man/man8/zfs-rollback.8 +++ b/sys/contrib/openzfs/man/man8/zfs-rollback.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZFS-ROLLBACK 8 .Os . @@ -71,5 +71,16 @@ option to force an unmount of any clone file systems that are to be destroyed. Destroy any snapshots and bookmarks more recent than the one specified. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 8 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 8 : No Rolling Back a ZFS File System +The following command reverts the contents of +.Ar pool/home/anne +to the snapshot named +.Ar yesterday , +deleting all intermediate snapshots: +.Dl # Nm zfs Cm rollback Fl r Ar pool/home/anne Ns @ Ns Ar yesterday +. .Sh SEE ALSO .Xr zfs-snapshot 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-send.8 b/sys/contrib/openzfs/man/man8/zfs-send.8 index e83a92e4b34..67e94ca85bc 100644 --- a/sys/contrib/openzfs/man/man8/zfs-send.8 +++ b/sys/contrib/openzfs/man/man8/zfs-send.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd April 15, 2021 +.Dd March 16, 2022 .Dt ZFS-SEND 8 .Os . @@ -40,6 +40,7 @@ .Nm zfs .Cm send .Op Fl DLPRbcehnpsvw +.Op Fl X Ar dataset Ns Oo , Ns Ar dataset Oc Ns ... .Op Oo Fl I Ns | Ns Fl i Oc Ar snapshot .Ar snapshot .Nm zfs @@ -73,6 +74,7 @@ .Nm zfs .Cm send .Op Fl DLPRbcehnpvw +.Op Fl X Ar dataset Ns Oo , Ns Ar dataset Oc Ns ... .Op Oo Fl I Ns | Ns Fl i Oc Ar snapshot .Ar snapshot .Xc @@ -140,6 +142,23 @@ If the flag is used to send encrypted datasets, then .Fl w must also be specified. +.It Fl X , -exclude Ar dataset Ns Oo , Ns Ar dataset Oc Ns ... +When the +.Fl R +flag is given, +.Fl X +can be used to specify a list of datasets to be excluded from the +data stream. +The +.Fl X +option can be used multiple times, or the list of datasets can be +specified as a comma-separated list, or both. +.Ar dataset +must not be the pool's root dataset, and all descendant datasets of +.Ar dataset +will be excluded from the send stream. +Requires +.Fl R . .It Fl e , -embed Generate a more compact stream by using .Sy WRITE_EMBEDDED @@ -648,6 +667,48 @@ ones on the source, and are ready to be used, while the parent snapshot on the target contains none of the username and password data present on the source, because it was removed by the redacted send operation. . +.Sh EXAMPLES +.\" These are, respectively, examples 12, 13 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Remotely Replicating ZFS Data +The following commands send a full stream and then an incremental stream to a +remote machine, restoring them into +.Em poolB/received/fs@a +and +.Em poolB/received/fs@b , +respectively. +.Em poolB +must contain the file system +.Em poolB/received , +and must not initially contain +.Em poolB/received/fs . +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm send Ar pool/fs@a | +.No " " Nm ssh Ar host Nm zfs Cm receive Ar poolB/received/fs Ns @ Ns Ar a +.No # Nm zfs Cm send Fl i Ar a pool/fs@b | +.No " " Nm ssh Ar host Nm zfs Cm receive Ar poolB/received/fs +.Ed +. +.Ss Example 2 : No Using the Nm zfs Cm receive Fl d No Option +The following command sends a full stream of +.Ar poolA/fsA/fsB@snap +to a remote machine, receiving it into +.Ar poolB/received/fsA/fsB@snap . +The +.Ar fsA/fsB@snap +portion of the received snapshot's name is determined from the name of the sent +snapshot. +.Ar poolB +must contain the file system +.Ar poolB/received . +If +.Ar poolB/received/fsA +does not exist, it is created as an empty file system. +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm send Ar poolA/fsA/fsB@snap | +.No " " Nm ssh Ar host Nm zfs Cm receive Fl d Ar poolB/received +.Ed +. .Sh SEE ALSO .Xr zfs-bookmark 8 , .Xr zfs-receive 8 , diff --git a/sys/contrib/openzfs/man/man8/zfs-set.8 b/sys/contrib/openzfs/man/man8/zfs-set.8 index a3588cc2663..6092e49dfbc 100644 --- a/sys/contrib/openzfs/man/man8/zfs-set.8 +++ b/sys/contrib/openzfs/man/man8/zfs-set.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd June 2, 2021 +.Dd March 16, 2022 .Dt ZFS-SET 8 .Os . @@ -177,6 +177,132 @@ option was not specified. .El .El . +.Sh EXAMPLES +.\" These are, respectively, examples 1, 4, 6, 7, 11, 14, 16 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Creating a ZFS File System Hierarchy +The following commands create a file system named +.Ar pool/home +and a file system named +.Ar pool/home/bob . +The mount point +.Pa /export/home +is set for the parent file system, and is automatically inherited by the child +file system. +.Dl # Nm zfs Cm create Ar pool/home +.Dl # Nm zfs Cm set Sy mountpoint Ns = Ns Ar /export/home pool/home +.Dl # Nm zfs Cm create Ar pool/home/bob +. +.Ss Example 2 : No Disabling and Enabling File System Compression +The following command disables the +.Sy compression +property for all file systems under +.Ar pool/home . +The next command explicitly enables +.Sy compression +for +.Ar pool/home/anne . +.Dl # Nm zfs Cm set Sy compression Ns = Ns Sy off Ar pool/home +.Dl # Nm zfs Cm set Sy compression Ns = Ns Sy on Ar pool/home/anne +. +.Ss Example 3 : No Setting a Quota on a ZFS File System +The following command sets a quota of 50 Gbytes for +.Ar pool/home/bob : +.Dl # Nm zfs Cm set Sy quota Ns = Ns Ar 50G pool/home/bob +. +.Ss Example 4 : No Listing ZFS Properties +The following command lists all properties for +.Ar pool/home/bob : +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm get Sy all Ar pool/home/bob +NAME PROPERTY VALUE SOURCE +pool/home/bob type filesystem - +pool/home/bob creation Tue Jul 21 15:53 2009 - +pool/home/bob used 21K - +pool/home/bob available 20.0G - +pool/home/bob referenced 21K - +pool/home/bob compressratio 1.00x - +pool/home/bob mounted yes - +pool/home/bob quota 20G local +pool/home/bob reservation none default +pool/home/bob recordsize 128K default +pool/home/bob mountpoint /pool/home/bob default +pool/home/bob sharenfs off default +pool/home/bob checksum on default +pool/home/bob compression on local +pool/home/bob atime on default +pool/home/bob devices on default +pool/home/bob exec on default +pool/home/bob setuid on default +pool/home/bob readonly off default +pool/home/bob zoned off default +pool/home/bob snapdir hidden default +pool/home/bob acltype off default +pool/home/bob aclmode discard default +pool/home/bob aclinherit restricted default +pool/home/bob canmount on default +pool/home/bob xattr on default +pool/home/bob copies 1 default +pool/home/bob version 4 - +pool/home/bob utf8only off - +pool/home/bob normalization none - +pool/home/bob casesensitivity sensitive - +pool/home/bob vscan off default +pool/home/bob nbmand off default +pool/home/bob sharesmb off default +pool/home/bob refquota none default +pool/home/bob refreservation none default +pool/home/bob primarycache all default +pool/home/bob secondarycache all default +pool/home/bob usedbysnapshots 0 - +pool/home/bob usedbydataset 21K - +pool/home/bob usedbychildren 0 - +pool/home/bob usedbyrefreservation 0 - +.Ed +.Pp +The following command gets a single property value: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm get Fl H o Sy value compression Ar pool/home/bob +on +.Ed +.Pp +The following command lists all properties with local settings for +.Ar pool/home/bob : +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm get Fl r s Sy local Fl o Sy name , Ns Sy property , Ns Sy value all Ar pool/home/bob +NAME PROPERTY VALUE +pool/home/bob quota 20G +pool/home/bob compression on +.Ed +. +.Ss Example 5 : No Inheriting ZFS Properties +The following command causes +.Ar pool/home/bob No and Ar pool/home/anne +to inherit the +.Sy checksum +property from their parent. +.Dl # Nm zfs Cm inherit Sy checksum Ar pool/home/bob pool/home/anne +. +.Ss Example 6 : No Setting User Properties +The following example sets the user-defined +.Ar com.example : Ns Ar department +property for a dataset: +.Dl # Nm zfs Cm set Ar com.example : Ns Ar department Ns = Ns Ar 12345 tank/accounting +. +.Ss Example 7 : No Setting sharenfs Property Options on a ZFS File System +The following commands show how to set +.Sy sharenfs +property options to enable read-write +access for a set of IP addresses and to enable root access for system +.Qq neo +on the +.Ar tank/home +file system: +.Dl # Nm zfs Cm set Sy sharenfs Ns = Ns ' Ns Ar rw Ns =@123.123.0.0/16:[::1],root= Ns Ar neo Ns ' tank/home +.Pp +If you are using DNS for host name resolution, +specify the fully-qualified hostname. +. .Sh SEE ALSO .Xr zfsprops 7 , .Xr zfs-list 8 diff --git a/sys/contrib/openzfs/man/man8/zfs-snapshot.8 b/sys/contrib/openzfs/man/man8/zfs-snapshot.8 index 225123f44b2..771b52099ec 100644 --- a/sys/contrib/openzfs/man/man8/zfs-snapshot.8 +++ b/sys/contrib/openzfs/man/man8/zfs-snapshot.8 @@ -29,7 +29,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZFS-SNAPSHOT 8 .Os . @@ -65,6 +65,64 @@ for details. Recursively create snapshots of all descendent datasets .El . +.Sh EXAMPLES +.\" These are, respectively, examples 2, 3, 10, 15 from zfs.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Creating a ZFS Snapshot +The following command creates a snapshot named +.Ar yesterday . +This snapshot is mounted on demand in the +.Pa .zfs/snapshot +directory at the root of the +.Ar pool/home/bob +file system. +.Dl # Nm zfs Cm snapshot Ar pool/home/bob Ns @ Ns Ar yesterday +. +.Ss Example 2 : No Creating and Destroying Multiple Snapshots +The following command creates snapshots named +.Ar yesterday No of Ar pool/home +and all of its descendent file systems. +Each snapshot is mounted on demand in the +.Pa .zfs/snapshot +directory at the root of its file system. +The second command destroys the newly created snapshots. +.Dl # Nm zfs Cm snapshot Fl r Ar pool/home Ns @ Ns Ar yesterday +.Dl # Nm zfs Cm destroy Fl r Ar pool/home Ns @ Ns Ar yesterday +. +.Ss Example 3 : No Promoting a ZFS Clone +The following commands illustrate how to test out changes to a file system, and +then replace the original file system with the changed one, using clones, clone +promotion, and renaming: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm create Ar pool/project/production + populate /pool/project/production with data +.No # Nm zfs Cm snapshot Ar pool/project/production Ns @ Ns Ar today +.No # Nm zfs Cm clone Ar pool/project/production@today pool/project/beta + make changes to /pool/project/beta and test them +.No # Nm zfs Cm promote Ar pool/project/beta +.No # Nm zfs Cm rename Ar pool/project/production pool/project/legacy +.No # Nm zfs Cm rename Ar pool/project/beta pool/project/production + once the legacy version is no longer needed, it can be destroyed +.No # Nm zfs Cm destroy Ar pool/project/legacy +.Ed +. +.Ss Example 4 : No Performing a Rolling Snapshot +The following example shows how to maintain a history of snapshots with a +consistent naming scheme. +To keep a week's worth of snapshots, the user destroys the oldest snapshot, +renames the remaining snapshots, and then creates a new snapshot, as follows: +.Bd -literal -compact -offset Ds +.No # Nm zfs Cm destroy Fl r Ar pool/users@7daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@6daysago No @ Ns Ar 7daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@5daysago No @ Ns Ar 6daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@4daysago No @ Ns Ar 5daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@3daysago No @ Ns Ar 4daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@2daysago No @ Ns Ar 3daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@yesterday No @ Ns Ar 2daysago +.No # Nm zfs Cm rename Fl r Ar pool/users@today No @ Ns Ar yesterday +.No # Nm zfs Cm snapshot Fl r Ar pool/users Ns @ Ns Ar today +.Ed +. .Sh SEE ALSO .Xr zfs-bookmark 8 , .Xr zfs-clone 8 , diff --git a/sys/contrib/openzfs/man/man8/zfs.8 b/sys/contrib/openzfs/man/man8/zfs.8 index 48453ef46c0..dd901e1e6e8 100644 --- a/sys/contrib/openzfs/man/man8/zfs.8 +++ b/sys/contrib/openzfs/man/man8/zfs.8 @@ -36,7 +36,7 @@ .\" Copyright 2018 Nexenta Systems, Inc. .\" Copyright 2019 Joyent, Inc. .\" -.Dd June 30, 2019 +.Dd March 16, 2022 .Dt ZFS 8 .Os . @@ -299,9 +299,22 @@ if an error occurs, and if invalid command line options were specified. . .Sh EXAMPLES -.Bl -tag -width "" -. -.It Sy Example 1 : No Creating a ZFS File System Hierarchy +.\" Examples 1, 4, 6, 7, 11, 14, 16 are shared with zfs-set.8. +.\" Examples 1, 10 are shared with zfs-create.8. +.\" Examples 2, 3, 10, 15 are also shared with zfs-snapshot.8. +.\" Examples 3, 10, 15 are shared with zfs-destroy.8. +.\" Examples 5 are shared with zfs-list.8. +.\" Examples 8 are shared with zfs-rollback.8. +.\" Examples 9, 10 are shared with zfs-clone.8. +.\" Examples 10 are also shared with zfs-promote.8. +.\" Examples 10, 15 also are shared with zfs-rename.8. +.\" Examples 12, 13 are shared with zfs-send.8. +.\" Examples 12, 13 are also shared with zfs-receive.8. +.\" Examples 17, 18, 19, 20, 21 are shared with zfs-allow.8. +.\" Examples 22 are shared with zfs-diff.8. +.\" Examples 23 are shared with zfs-bookmark.8. +.\" Make sure to update them omnidirectionally +.Ss Example 1 : No Creating a ZFS File System Hierarchy The following commands create a file system named .Ar pool/home and a file system named @@ -314,7 +327,7 @@ file system. .Dl # Nm zfs Cm set Sy mountpoint Ns = Ns Ar /export/home pool/home .Dl # Nm zfs Cm create Ar pool/home/bob . -.It Sy Example 2 : No Creating a ZFS Snapshot +.Ss Example 2 : No Creating a ZFS Snapshot The following command creates a snapshot named .Ar yesterday . This snapshot is mounted on demand in the @@ -324,7 +337,7 @@ directory at the root of the file system. .Dl # Nm zfs Cm snapshot Ar pool/home/bob Ns @ Ns Ar yesterday . -.It Sy Example 3 : No Creating and Destroying Multiple Snapshots +.Ss Example 3 : No Creating and Destroying Multiple Snapshots The following command creates snapshots named .Ar yesterday No of Ar pool/home and all of its descendent file systems. @@ -335,7 +348,7 @@ The second command destroys the newly created snapshots. .Dl # Nm zfs Cm snapshot Fl r Ar pool/home Ns @ Ns Ar yesterday .Dl # Nm zfs Cm destroy Fl r Ar pool/home Ns @ Ns Ar yesterday . -.It Sy Example 4 : No Disabling and Enabling File System Compression +.Ss Example 4 : No Disabling and Enabling File System Compression The following command disables the .Sy compression property for all file systems under @@ -347,7 +360,7 @@ for .Dl # Nm zfs Cm set Sy compression Ns = Ns Sy off Ar pool/home .Dl # Nm zfs Cm set Sy compression Ns = Ns Sy on Ar pool/home/anne . -.It Sy Example 5 : No Listing ZFS Datasets +.Ss Example 5 : No Listing ZFS Datasets The following command lists all active file systems and volumes in the system. Snapshots are displayed if .Sy listsnaps Ns = Ns Sy on . @@ -365,12 +378,12 @@ pool/home/anne 18K 457G 18K /export/home/anne pool/home/bob 276K 457G 276K /export/home/bob .Ed . -.It Sy Example 6 : No Setting a Quota on a ZFS File System +.Ss Example 6 : No Setting a Quota on a ZFS File System The following command sets a quota of 50 Gbytes for .Ar pool/home/bob : .Dl # Nm zfs Cm set Sy quota Ns = Ns Ar 50G pool/home/bob . -.It Sy Example 7 : No Listing ZFS Properties +.Ss Example 7 : No Listing ZFS Properties The following command lists all properties for .Ar pool/home/bob : .Bd -literal -compact -offset Ds @@ -435,7 +448,7 @@ pool/home/bob quota 20G pool/home/bob compression on .Ed . -.It Sy Example 8 : No Rolling Back a ZFS File System +.Ss Example 8 : No Rolling Back a ZFS File System The following command reverts the contents of .Ar pool/home/anne to the snapshot named @@ -443,13 +456,13 @@ to the snapshot named deleting all intermediate snapshots: .Dl # Nm zfs Cm rollback Fl r Ar pool/home/anne Ns @ Ns Ar yesterday . -.It Sy Example 9 : No Creating a ZFS Clone +.Ss Example 9 : No Creating a ZFS Clone The following command creates a writable file system whose initial contents are the same as .Ar pool/home/bob@yesterday . .Dl # Nm zfs Cm clone Ar pool/home/bob@yesterday pool/clone . -.It Sy Example 10 : No Promoting a ZFS Clone +.Ss Example 10 : No Promoting a ZFS Clone The following commands illustrate how to test out changes to a file system, and then replace the original file system with the changed one, using clones, clone promotion, and renaming: @@ -466,7 +479,7 @@ promotion, and renaming: .No # Nm zfs Cm destroy Ar pool/project/legacy .Ed . -.It Sy Example 11 : No Inheriting ZFS Properties +.Ss Example 11 : No Inheriting ZFS Properties The following command causes .Ar pool/home/bob No and Ar pool/home/anne to inherit the @@ -474,7 +487,7 @@ to inherit the property from their parent. .Dl # Nm zfs Cm inherit Sy checksum Ar pool/home/bob pool/home/anne . -.It Sy Example 12 : No Remotely Replicating ZFS Data +.Ss Example 12 : No Remotely Replicating ZFS Data The following commands send a full stream and then an incremental stream to a remote machine, restoring them into .Em poolB/received/fs@a @@ -493,7 +506,7 @@ and must not initially contain .No " " Nm ssh Ar host Nm zfs Cm receive Ar poolB/received/fs .Ed . -.It Sy Example 13 : No Using the Nm zfs Cm receive Fl d No Option +.Ss Example 13 : No Using the Nm zfs Cm receive Fl d No Option The following command sends a full stream of .Ar poolA/fsA/fsB@snap to a remote machine, receiving it into @@ -513,13 +526,13 @@ does not exist, it is created as an empty file system. .No " " Nm ssh Ar host Nm zfs Cm receive Fl d Ar poolB/received .Ed . -.It Sy Example 14 : No Setting User Properties +.Ss Example 14 : No Setting User Properties The following example sets the user-defined .Ar com.example : Ns Ar department property for a dataset: .Dl # Nm zfs Cm set Ar com.example : Ns Ar department Ns = Ns Ar 12345 tank/accounting . -.It Sy Example 15 : No Performing a Rolling Snapshot +.Ss Example 15 : No Performing a Rolling Snapshot The following example shows how to maintain a history of snapshots with a consistent naming scheme. To keep a week's worth of snapshots, the user destroys the oldest snapshot, @@ -536,7 +549,7 @@ renames the remaining snapshots, and then creates a new snapshot, as follows: .No # Nm zfs Cm snapshot Fl r Ar pool/users Ns @ Ns Ar today .Ed . -.It Sy Example 16 : No Setting sharenfs Property Options on a ZFS File System +.Ss Example 16 : No Setting sharenfs Property Options on a ZFS File System The following commands show how to set .Sy sharenfs property options to enable read-write @@ -550,7 +563,7 @@ file system: If you are using DNS for host name resolution, specify the fully-qualified hostname. . -.It Sy Example 17 : No Delegating ZFS Administration Permissions on a ZFS Dataset +.Ss Example 17 : No Delegating ZFS Administration Permissions on a ZFS Dataset The following example shows how to set permissions so that user .Ar cindys can create, destroy, mount, and take snapshots on @@ -575,7 +588,7 @@ will be unable to mount file systems under Add an ACE similar to the following syntax to provide mount point access: .Dl # Cm chmod No A+user: Ns Ar cindys Ns :add_subdirectory:allow Ar /tank/cindys . -.It Sy Example 18 : No Delegating Create Time Permissions on a ZFS Dataset +.Ss Example 18 : No Delegating Create Time Permissions on a ZFS Dataset The following example shows how to grant anyone in the group .Ar staff to create file systems in @@ -596,7 +609,7 @@ Local+Descendent permissions: group staff create,mount .Ed . -.It Sy Example 19 : No Defining and Granting a Permission Set on a ZFS Dataset +.Ss Example 19 : No Defining and Granting a Permission Set on a ZFS Dataset The following example shows how to define and grant a permission set on the .Ar tank/users file system. @@ -614,7 +627,7 @@ Local+Descendent permissions: group staff @pset .Ed . -.It Sy Example 20 : No Delegating Property Permissions on a ZFS Dataset +.Ss Example 20 : No Delegating Property Permissions on a ZFS Dataset The following example shows to grant the ability to set quotas and reservations on the .Ar users/home @@ -634,7 +647,7 @@ NAME PROPERTY VALUE SOURCE users/home/marks quota 10G local .Ed . -.It Sy Example 21 : No Removing ZFS Delegated Permissions on a ZFS Dataset +.Ss Example 21 : No Removing ZFS Delegated Permissions on a ZFS Dataset The following example shows how to remove the snapshot permission from the .Ar staff group on the @@ -653,7 +666,7 @@ Local+Descendent permissions: group staff @pset .Ed . -.It Sy Example 22 : No Showing the differences between a snapshot and a ZFS Dataset +.Ss Example 22 : No Showing the differences between a snapshot and a ZFS Dataset The following example shows how to see what has changed between a prior snapshot of a ZFS dataset and its current state. The @@ -669,12 +682,12 @@ R F /tank/test/oldname -> /tank/test/newname M F /tank/test/modified .Ed . -.It Sy Example 23 : No Creating a bookmark +.Ss Example 23 : No Creating a bookmark The following example create a bookmark to a snapshot. This bookmark can then be used instead of snapshot in send streams. .Dl # Nm zfs Cm bookmark Ar rpool Ns @ Ns Ar snapshot rpool Ns # Ns Ar bookmark . -.It Sy Example 24 : No Setting Sy sharesmb No Property Options on a ZFS File System +.Ss Example 24 : No Setting Sy sharesmb No Property Options on a ZFS File System The following example show how to share SMB filesystem through ZFS. Note that a user and their password must be given. .Dl # Nm smbmount Ar //127.0.0.1/share_tmp /mnt/tmp Fl o No user=workgroup/turbo,password=obrut,uid=1000 @@ -701,7 +714,6 @@ in case you need to modify any options of the share afterwards. Do note that any changes done with the .Xr net 8 command will be undone if the share is ever unshared (like via a reboot). -.El . .Sh ENVIRONMENT VARIABLES .Bl -tag -width "ZFS_MOUNT_HELPER" diff --git a/sys/contrib/openzfs/man/man8/zpool-add.8 b/sys/contrib/openzfs/man/man8/zpool-add.8 index 26cf33c5538..04171ae0264 100644 --- a/sys/contrib/openzfs/man/man8/zpool-add.8 +++ b/sys/contrib/openzfs/man/man8/zpool-add.8 @@ -25,7 +25,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZPOOL-ADD 8 .Os . @@ -93,6 +93,29 @@ The only property supported at the moment is .Sy ashift . .El . +.Sh EXAMPLES +.\" These are, respectively, examples 5, 13 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Adding a Mirror to a ZFS Storage Pool +The following command adds two mirrored disks to the pool +.Ar tank , +assuming the pool is already made up of two-way mirrors. +The additional space is immediately available to any datasets within the pool. +.Dl # Nm zpool Cm add Ar tank Sy mirror Pa sda sdb +. +.Ss Example 2 : No Adding Cache Devices to a ZFS Pool +The following command adds two disks for use as cache devices to a ZFS storage +pool: +.Dl # Nm zpool Cm add Ar pool Sy cache Pa sdc sdd +.Pp +Once added, the cache devices gradually fill with content from main memory. +Depending on the size of your cache devices, it could take over an hour for +them to fill. +Capacity and reads can be monitored using the +.Cm iostat +subcommand as follows: +.Dl # Nm zpool Cm iostat Fl v Ar pool 5 +. .Sh SEE ALSO .Xr zpool-attach 8 , .Xr zpool-import 8 , diff --git a/sys/contrib/openzfs/man/man8/zpool-create.8 b/sys/contrib/openzfs/man/man8/zpool-create.8 index e902c770076..c1d1c7d564c 100644 --- a/sys/contrib/openzfs/man/man8/zpool-create.8 +++ b/sys/contrib/openzfs/man/man8/zpool-create.8 @@ -27,7 +27,7 @@ .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" Copyright (c) 2021, Colm Buckley .\" -.Dd June 2, 2021 +.Dd March 16, 2022 .Dt ZPOOL-CREATE 8 .Os . @@ -205,6 +205,38 @@ such as virtual machines or physical machines whose pools live on network block devices. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 1, 2, 3, 4, 11, 12 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Creating a RAID-Z Storage Pool +The following command creates a pool with a single raidz root vdev that +consists of six disks: +.Dl # Nm zpool Cm create Ar tank Sy raidz Pa sda sdb sdc sdd sde sdf +. +.Ss Example 2 : No Creating a Mirrored Storage Pool +The following command creates a pool with two mirrors, where each mirror +contains two disks: +.Dl # Nm zpool Cm create Ar tank Sy mirror Pa sda sdb Sy mirror Pa sdc sdd +. +.Ss Example 3 : No Creating a ZFS Storage Pool by Using Partitions +The following command creates a non-redundant pool using two disk partitions: +.Dl # Nm zpool Cm create Ar tank Pa sda1 sdb2 +. +.Ss Example 4 : No Creating a ZFS Storage Pool by Using Files +The following command creates a non-redundant pool using files. +While not recommended, a pool based on files can be useful for experimental +purposes. +.Dl # Nm zpool Cm create Ar tank Pa /path/to/file/a /path/to/file/b +. +.Ss Example 5 : No Managing Hot Spares +The following command creates a new pool with an available hot spare: +.Dl # Nm zpool Cm create Ar tank Sy mirror Pa sda sdb Sy spare Pa sdc +. +.Ss Example 6 : No Creating a ZFS Pool with Mirrored Separate Intent Logs +The following command creates a ZFS storage pool consisting of two, two-way +mirrors and mirrored log devices: +.Dl # Nm zpool Cm create Ar pool Sy mirror Pa sda sdb Sy mirror Pa sdc sdd Sy log mirror Pa sde sdf +. .Sh SEE ALSO .Xr zpool-destroy 8 , .Xr zpool-export 8 , diff --git a/sys/contrib/openzfs/man/man8/zpool-destroy.8 b/sys/contrib/openzfs/man/man8/zpool-destroy.8 index a2f6729c8a7..a98acf46f85 100644 --- a/sys/contrib/openzfs/man/man8/zpool-destroy.8 +++ b/sys/contrib/openzfs/man/man8/zpool-destroy.8 @@ -26,7 +26,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd May 31, 2021 +.Dd March 16, 2022 .Dt ZPOOL-DESTROY 8 .Os . @@ -46,3 +46,12 @@ This command tries to unmount any active datasets before destroying the pool. .It Fl f Forcefully unmount all active datasets. .El +. +.Sh EXAMPLES +.\" These are, respectively, examples 7 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Destroying a ZFS Storage Pool +The following command destroys the pool +.Ar tank +and any datasets contained within: +.Dl # Nm zpool Cm destroy Fl f Ar tank diff --git a/sys/contrib/openzfs/man/man8/zpool-export.8 b/sys/contrib/openzfs/man/man8/zpool-export.8 index a15291a1f59..14d737fa544 100644 --- a/sys/contrib/openzfs/man/man8/zpool-export.8 +++ b/sys/contrib/openzfs/man/man8/zpool-export.8 @@ -26,7 +26,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd February 16, 2020 +.Dd March 16, 2022 .Dt ZPOOL-EXPORT 8 .Os . @@ -68,5 +68,14 @@ is currently being used. This may lead to potential data corruption. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 8 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Exporting a ZFS Storage Pool +The following command exports the devices in pool +.Ar tank +so that they can be relocated or later imported: +.Dl # Nm zpool Cm export Ar tank +. .Sh SEE ALSO .Xr zpool-import 8 diff --git a/sys/contrib/openzfs/man/man8/zpool-import.8 b/sys/contrib/openzfs/man/man8/zpool-import.8 index 39b0e17ef58..20ce41e6459 100644 --- a/sys/contrib/openzfs/man/man8/zpool-import.8 +++ b/sys/contrib/openzfs/man/man8/zpool-import.8 @@ -26,7 +26,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd August 9, 2019 +.Dd March 16, 2022 .Dt ZPOOL-IMPORT 8 .Os . @@ -404,6 +404,30 @@ when not explicitly specified. .El .El . +.Sh EXAMPLES +.\" These are, respectively, examples 9 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 9 : No Importing a ZFS Storage Pool +The following command displays available pools, and then imports the pool +.Ar tank +for use on the system. +The results from this command are similar to the following: +.Bd -literal -compact -offset Ds +.No # Nm zpool Cm import + pool: tank + id: 15451357997522795478 + state: ONLINE +action: The pool can be imported using its name or numeric identifier. +config: + + tank ONLINE + mirror ONLINE + sda ONLINE + sdb ONLINE + +.No # Nm zpool Cm import Ar tank +.Ed +. .Sh SEE ALSO .Xr zpool-export 8 , .Xr zpool-list 8 , diff --git a/sys/contrib/openzfs/man/man8/zpool-iostat.8 b/sys/contrib/openzfs/man/man8/zpool-iostat.8 index 969c74cf398..b0c0565c4ef 100644 --- a/sys/contrib/openzfs/man/man8/zpool-iostat.8 +++ b/sys/contrib/openzfs/man/man8/zpool-iostat.8 @@ -26,7 +26,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd May 27, 2021 +.Dd March 16, 2022 .Dt ZPOOL-IOSTAT 8 .Os . @@ -258,6 +258,46 @@ If you specify an interval, the measurements will be sampled from the end of the interval. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 13, 16 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 13 : No Adding Cache Devices to a ZFS Pool +The following command adds two disks for use as cache devices to a ZFS storage +pool: +.Dl # Nm zpool Cm add Ar pool Sy cache Pa sdc sdd +.Pp +Once added, the cache devices gradually fill with content from main memory. +Depending on the size of your cache devices, it could take over an hour for +them to fill. +Capacity and reads can be monitored using the +.Cm iostat +subcommand as follows: +.Dl # Nm zpool Cm iostat Fl v Ar pool 5 +. +.Ss Example 16 : No Adding output columns +Additional columns can be added to the +.Nm zpool Cm status No and Nm zpool Cm iostat No output with Fl c . +.Bd -literal -compact -offset Ds +.No # Nm zpool Cm status Fl c Pa vendor , Ns Pa model , Ns Pa size + NAME STATE READ WRITE CKSUM vendor model size + tank ONLINE 0 0 0 + mirror-0 ONLINE 0 0 0 + U1 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U10 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U11 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U12 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U13 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U14 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + +.No # Nm zpool Cm iostat Fl vc Pa size + capacity operations bandwidth +pool alloc free read write read write size +---------- ----- ----- ----- ----- ----- ----- ---- +rpool 14.6G 54.9G 4 55 250K 2.69M + sda1 14.6G 54.9G 4 55 250K 2.69M 70G +---------- ----- ----- ----- ----- ----- ----- ---- +.Ed +. .Sh SEE ALSO .Xr iostat 1 , .Xr smartctl 8 , diff --git a/sys/contrib/openzfs/man/man8/zpool-list.8 b/sys/contrib/openzfs/man/man8/zpool-list.8 index dd4e13c1604..ce8e34b61de 100644 --- a/sys/contrib/openzfs/man/man8/zpool-list.8 +++ b/sys/contrib/openzfs/man/man8/zpool-list.8 @@ -26,7 +26,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd August 9, 2019 +.Dd March 16, 2022 .Dt ZPOOL-LIST 8 .Os . @@ -107,6 +107,40 @@ Reports usage statistics for individual vdevs within the pool, in addition to the pool-wide statistics. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 6, 15 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Listing Available ZFS Storage Pools +The following command lists all available pools on the system. +In this case, the pool +.Ar zion +is faulted due to a missing device. +The results from this command are similar to the following: +.Bd -literal -compact -offset Ds +.No # Nm zpool Cm list +NAME SIZE ALLOC FREE EXPANDSZ FRAG CAP DEDUP HEALTH ALTROOT +rpool 19.9G 8.43G 11.4G - 33% 42% 1.00x ONLINE - +tank 61.5G 20.0G 41.5G - 48% 32% 1.00x ONLINE - +zion - - - - - - - FAULTED - +.Ed +. +.Ss Example 2 : No Displaying expanded space on a device +The following command displays the detailed information for the pool +.Ar data . +This pool is comprised of a single raidz vdev where one of its devices +increased its capacity by 10GB. +In this example, the pool will not be able to utilize this extra capacity until +all the devices under the raidz vdev have been expanded. +.Bd -literal -compact -offset Ds +.No # Nm zpool Cm list Fl v Ar data +NAME SIZE ALLOC FREE EXPANDSZ FRAG CAP DEDUP HEALTH ALTROOT +data 23.9G 14.6G 9.30G - 48% 61% 1.00x ONLINE - + raidz1 23.9G 14.6G 9.30G - 48% + sda - - - - - + sdb - - - 10G - + sdc - - - - - +.Ed +. .Sh SEE ALSO .Xr zpool-import 8 , .Xr zpool-status 8 diff --git a/sys/contrib/openzfs/man/man8/zpool-remove.8 b/sys/contrib/openzfs/man/man8/zpool-remove.8 index 2e1bfec3fa6..ec476ec8857 100644 --- a/sys/contrib/openzfs/man/man8/zpool-remove.8 +++ b/sys/contrib/openzfs/man/man8/zpool-remove.8 @@ -26,12 +26,14 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd August 9, 2019 +.Dd March 16, 2022 .Dt ZPOOL-REMOVE 8 .Os +. .Sh NAME .Nm zpool-remove .Nd remove devices from ZFS storage pool +. .Sh SYNOPSIS .Nm zpool .Cm remove @@ -41,6 +43,7 @@ .Cm remove .Fl s .Ar pool +. .Sh DESCRIPTION .Bl -tag -width Ds .It Xo @@ -102,6 +105,45 @@ Waits until the removal has completed before returning. .Xc Stops and cancels an in-progress removal of a top-level vdev. .El +. +.Sh EXAMPLES +.\" These are, respectively, examples 14 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Removing a Mirrored top-level (Log or Data) Device +The following commands remove the mirrored log device +.Sy mirror-2 +and mirrored top-level data device +.Sy mirror-1 . +.Pp +Given this configuration: +.Bd -literal -compact -offset Ds + pool: tank + state: ONLINE + scrub: none requested +config: + + NAME STATE READ WRITE CKSUM + tank ONLINE 0 0 0 + mirror-0 ONLINE 0 0 0 + sda ONLINE 0 0 0 + sdb ONLINE 0 0 0 + mirror-1 ONLINE 0 0 0 + sdc ONLINE 0 0 0 + sdd ONLINE 0 0 0 + logs + mirror-2 ONLINE 0 0 0 + sde ONLINE 0 0 0 + sdf ONLINE 0 0 0 +.Ed +.Pp +The command to remove the mirrored log +.Ar mirror-2 No is: +.Dl # Nm zpool Cm remove Ar tank mirror-2 +.Pp +The command to remove the mirrored data +.Ar mirror-1 No is: +.Dl # Nm zpool Cm remove Ar tank mirror-1 +. .Sh SEE ALSO .Xr zpool-add 8 , .Xr zpool-detach 8 , diff --git a/sys/contrib/openzfs/man/man8/zpool-scrub.8 b/sys/contrib/openzfs/man/man8/zpool-scrub.8 index 69ae825b615..1c13d9b9b2a 100644 --- a/sys/contrib/openzfs/man/man8/zpool-scrub.8 +++ b/sys/contrib/openzfs/man/man8/zpool-scrub.8 @@ -97,10 +97,8 @@ again. Wait until scrub has completed before returning. .El .Sh EXAMPLES -.Bl -tag -width "Exam" -.It Sy Example 1 : Status of pool with ongoing scrub: -Output: -.Bd -literal -compact -offset Ds +.Ss Example 1 : No Status of pool with ongoing scrub: +.Bd -literal -compact .No # Nm zpool Cm status ... scan: scrub in progress since Sun Jul 25 16:07:49 2021 @@ -108,14 +106,10 @@ Output: 0B repaired, 16.91% done, 00:00:04 to go ... .Ed -Where: -.Bl -dash -offset indent -.It -Metadata which references 403M of file data has been +.Pp +Where metadata which references 403M of file data has been scanned at 100M/s, and 68.4M of that file data has been scrubbed sequentially at 10.0M/s. -.El -.El .Sh PERIODIC SCRUB On machines using systemd, scrub timers can be enabled on per-pool basis. .Nm weekly diff --git a/sys/contrib/openzfs/man/man8/zpool-status.8 b/sys/contrib/openzfs/man/man8/zpool-status.8 index 1b7c3515bd0..8617ab64047 100644 --- a/sys/contrib/openzfs/man/man8/zpool-status.8 +++ b/sys/contrib/openzfs/man/man8/zpool-status.8 @@ -26,7 +26,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd June 2, 2021 +.Dd March 16, 2022 .Dt ZPOOL-STATUS 8 .Os . @@ -124,6 +124,33 @@ unavailable. Warnings about pools not using the latest on-disk format will not be included. .El . +.Sh EXAMPLES +.\" These are, respectively, examples 16 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Adding output columns +Additional columns can be added to the +.Nm zpool Cm status No and Nm zpool Cm iostat No output with Fl c . +.Bd -literal -compact -offset Ds +.No # Nm zpool Cm status Fl c Pa vendor , Ns Pa model , Ns Pa size + NAME STATE READ WRITE CKSUM vendor model size + tank ONLINE 0 0 0 + mirror-0 ONLINE 0 0 0 + U1 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U10 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U11 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U12 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U13 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + U14 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T + +.No # Nm zpool Cm iostat Fl vc Pa size + capacity operations bandwidth +pool alloc free read write read write size +---------- ----- ----- ----- ----- ----- ----- ---- +rpool 14.6G 54.9G 4 55 250K 2.69M + sda1 14.6G 54.9G 4 55 250K 2.69M 70G +---------- ----- ----- ----- ----- ----- ----- ---- +.Ed +. .Sh SEE ALSO .Xr zpool-events 8 , .Xr zpool-history 8 , diff --git a/sys/contrib/openzfs/man/man8/zpool-upgrade.8 b/sys/contrib/openzfs/man/man8/zpool-upgrade.8 index 1b13bad898b..e66e96cfb31 100644 --- a/sys/contrib/openzfs/man/man8/zpool-upgrade.8 +++ b/sys/contrib/openzfs/man/man8/zpool-upgrade.8 @@ -27,7 +27,7 @@ .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" Copyright (c) 2021, Colm Buckley .\" -.Dd August 9, 2019 +.Dd March 16, 2022 .Dt ZPOOL-UPGRADE 8 .Os . @@ -102,6 +102,17 @@ supported legacy version number. .El .El . +.Sh EXAMPLES +.\" These are, respectively, examples 10 from zpool.8 +.\" Make sure to update them bidirectionally +.Ss Example 1 : No Upgrading All ZFS Storage Pools to the Current Version +The following command upgrades all ZFS Storage pools to the current version of +the software: +.Bd -literal -compact -offset Ds +.No # Nm zpool Cm upgrade Fl a +This system is currently running ZFS version 2. +.Ed +. .Sh SEE ALSO .Xr zpool-features 7 , .Xr zpoolconcepts 7 , diff --git a/sys/contrib/openzfs/man/man8/zpool.8 b/sys/contrib/openzfs/man/man8/zpool.8 index 3e71e65ab7d..e99eaf536f2 100644 --- a/sys/contrib/openzfs/man/man8/zpool.8 +++ b/sys/contrib/openzfs/man/man8/zpool.8 @@ -26,7 +26,7 @@ .\" Copyright 2017 Nexenta Systems, Inc. .\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved. .\" -.Dd June 2, 2021 +.Dd March 16, 2022 .Dt ZPOOL 8 .Os . @@ -230,35 +230,45 @@ Invalid command line options were specified. .El . .Sh EXAMPLES -.Bl -tag -width "Exam" -.It Sy Example 1 : No Creating a RAID-Z Storage Pool +.\" Examples 1, 2, 3, 4, 11, 12 are shared with zpool-create.8. +.\" Examples 5, 13 are shared with zpool-add.8. +.\" Examples 6, 15 are shared with zpool-list.8. +.\" Examples 7 are shared with zpool-destroy.8. +.\" Examples 8 are shared with zpool-export.8. +.\" Examples 9 are shared with zpool-import.8. +.\" Examples 10 are shared with zpool-upgrade.8. +.\" Examples 14 are shared with zpool-remove.8. +.\" Examples 16 are shared with zpool-status.8. +.\" Examples 13, 16 are also shared with zpool-iostat.8. +.\" Make sure to update them omnidirectionally +.Ss Example 1 : No Creating a RAID-Z Storage Pool The following command creates a pool with a single raidz root vdev that consists of six disks: -.Dl # Nm zpool Cm create Ar tank Sy raidz Ar sda sdb sdc sdd sde sdf +.Dl # Nm zpool Cm create Ar tank Sy raidz Pa sda sdb sdc sdd sde sdf . -.It Sy Example 2 : No Creating a Mirrored Storage Pool +.Ss Example 2 : No Creating a Mirrored Storage Pool The following command creates a pool with two mirrors, where each mirror contains two disks: -.Dl # Nm zpool Cm create Ar tank Sy mirror Ar sda sdb Sy mirror Ar sdc sdd +.Dl # Nm zpool Cm create Ar tank Sy mirror Pa sda sdb Sy mirror Pa sdc sdd . -.It Sy Example 3 : No Creating a ZFS Storage Pool by Using Partitions -The following command creates an unmirrored pool using two disk partitions: -.Dl # Nm zpool Cm create Ar tank sda1 sdb2 +.Ss Example 3 : No Creating a ZFS Storage Pool by Using Partitions +The following command creates a non-redundant pool using two disk partitions: +.Dl # Nm zpool Cm create Ar tank Pa sda1 sdb2 . -.It Sy Example 4 : No Creating a ZFS Storage Pool by Using Files -The following command creates an unmirrored pool using files. +.Ss Example 4 : No Creating a ZFS Storage Pool by Using Files +The following command creates a non-redundant pool using files. While not recommended, a pool based on files can be useful for experimental purposes. -.Dl # Nm zpool Cm create Ar tank /path/to/file/a /path/to/file/b +.Dl # Nm zpool Cm create Ar tank Pa /path/to/file/a /path/to/file/b . -.It Sy Example 5 : No Adding a Mirror to a ZFS Storage Pool +.Ss Example 5 : No Adding a Mirror to a ZFS Storage Pool The following command adds two mirrored disks to the pool .Ar tank , assuming the pool is already made up of two-way mirrors. The additional space is immediately available to any datasets within the pool. -.Dl # Nm zpool Cm add Ar tank Sy mirror Ar sda sdb +.Dl # Nm zpool Cm add Ar tank Sy mirror Pa sda sdb . -.It Sy Example 6 : No Listing Available ZFS Storage Pools +.Ss Example 6 : No Listing Available ZFS Storage Pools The following command lists all available pools on the system. In this case, the pool .Ar zion @@ -272,19 +282,19 @@ tank 61.5G 20.0G 41.5G - 48% 32% 1.00x ONLINE - zion - - - - - - - FAULTED - .Ed . -.It Sy Example 7 : No Destroying a ZFS Storage Pool +.Ss Example 7 : No Destroying a ZFS Storage Pool The following command destroys the pool .Ar tank and any datasets contained within: .Dl # Nm zpool Cm destroy Fl f Ar tank . -.It Sy Example 8 : No Exporting a ZFS Storage Pool +.Ss Example 8 : No Exporting a ZFS Storage Pool The following command exports the devices in pool .Ar tank so that they can be relocated or later imported: .Dl # Nm zpool Cm export Ar tank . -.It Sy Example 9 : No Importing a ZFS Storage Pool +.Ss Example 9 : No Importing a ZFS Storage Pool The following command displays available pools, and then imports the pool .Ar tank for use on the system. @@ -305,7 +315,7 @@ config: .No # Nm zpool Cm import Ar tank .Ed . -.It Sy Example 10 : No Upgrading All ZFS Storage Pools to the Current Version +.Ss Example 10 : No Upgrading All ZFS Storage Pools to the Current Version The following command upgrades all ZFS Storage pools to the current version of the software: .Bd -literal -compact -offset Ds @@ -313,30 +323,30 @@ the software: This system is currently running ZFS version 2. .Ed . -.It Sy Example 11 : No Managing Hot Spares +.Ss Example 11 : No Managing Hot Spares The following command creates a new pool with an available hot spare: -.Dl # Nm zpool Cm create Ar tank Sy mirror Ar sda sdb Sy spare Ar sdc +.Dl # Nm zpool Cm create Ar tank Sy mirror Pa sda sdb Sy spare Pa sdc .Pp If one of the disks were to fail, the pool would be reduced to the degraded state. The failed device can be replaced using the following command: -.Dl # Nm zpool Cm replace Ar tank sda sdd +.Dl # Nm zpool Cm replace Ar tank Pa sda sdd .Pp Once the data has been resilvered, the spare is automatically removed and is made available for use should another device fail. The hot spare can be permanently removed from the pool using the following command: -.Dl # Nm zpool Cm remove Ar tank sdc +.Dl # Nm zpool Cm remove Ar tank Pa sdc . -.It Sy Example 12 : No Creating a ZFS Pool with Mirrored Separate Intent Logs +.Ss Example 12 : No Creating a ZFS Pool with Mirrored Separate Intent Logs The following command creates a ZFS storage pool consisting of two, two-way mirrors and mirrored log devices: -.Dl # Nm zpool Cm create Ar pool Sy mirror Ar sda sdb Sy mirror Ar sdc sdd Sy log mirror Ar sde sdf +.Dl # Nm zpool Cm create Ar pool Sy mirror Pa sda sdb Sy mirror Pa sdc sdd Sy log mirror Pa sde sdf . -.It Sy Example 13 : No Adding Cache Devices to a ZFS Pool +.Ss Example 13 : No Adding Cache Devices to a ZFS Pool The following command adds two disks for use as cache devices to a ZFS storage pool: -.Dl # Nm zpool Cm add Ar pool Sy cache Ar sdc sdd +.Dl # Nm zpool Cm add Ar pool Sy cache Pa sdc sdd .Pp Once added, the cache devices gradually fill with content from main memory. Depending on the size of your cache devices, it could take over an hour for @@ -346,7 +356,7 @@ Capacity and reads can be monitored using the subcommand as follows: .Dl # Nm zpool Cm iostat Fl v Ar pool 5 . -.It Sy Example 14 : No Removing a Mirrored top-level (Log or Data) Device +.Ss Example 14 : No Removing a Mirrored top-level (Log or Data) Device The following commands remove the mirrored log device .Sy mirror-2 and mirrored top-level data device @@ -381,7 +391,7 @@ The command to remove the mirrored data .Ar mirror-1 No is: .Dl # Nm zpool Cm remove Ar tank mirror-1 . -.It Sy Example 15 : No Displaying expanded space on a device +.Ss Example 15 : No Displaying expanded space on a device The following command displays the detailed information for the pool .Ar data . This pool is comprised of a single raidz vdev where one of its devices @@ -398,11 +408,11 @@ data 23.9G 14.6G 9.30G - 48% 61% 1.00x ONLINE - sdc - - - - - .Ed . -.It Sy Example 16 : No Adding output columns +.Ss Example 16 : No Adding output columns Additional columns can be added to the .Nm zpool Cm status No and Nm zpool Cm iostat No output with Fl c . .Bd -literal -compact -offset Ds -.No # Nm zpool Cm status Fl c Ar vendor , Ns Ar model , Ns Ar size +.No # Nm zpool Cm status Fl c Pa vendor , Ns Pa model , Ns Pa size NAME STATE READ WRITE CKSUM vendor model size tank ONLINE 0 0 0 mirror-0 ONLINE 0 0 0 @@ -413,7 +423,7 @@ Additional columns can be added to the U13 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T U14 ONLINE 0 0 0 SEAGATE ST8000NM0075 7.3T -.No # Nm zpool Cm iostat Fl vc Ar size +.No # Nm zpool Cm iostat Fl vc Pa size capacity operations bandwidth pool alloc free read write read write size ---------- ----- ----- ----- ----- ----- ----- ---- @@ -421,7 +431,6 @@ rpool 14.6G 54.9G 4 55 250K 2.69M sda1 14.6G 54.9G 4 55 250K 2.69M 70G ---------- ----- ----- ----- ----- ----- ----- ---- .Ed -.El . .Sh ENVIRONMENT VARIABLES .Bl -tag -compact -width "ZPOOL_IMPORT_UDEV_TIMEOUT_MS" @@ -432,7 +441,7 @@ to dump core on exit for the purposes of running .Sy ::findleaks . .It Sy ZFS_COLOR Use ANSI color in -.Nm zpool status +.Nm zpool Cm status output. .It Sy ZPOOL_IMPORT_PATH The search path for devices or files to use with the pool. @@ -449,7 +458,7 @@ The maximum time in milliseconds that will wait for an expected device to be available. .It Sy ZPOOL_STATUS_NON_NATIVE_ASHIFT_IGNORE If set, suppress warning about non-native vdev ashift in -.Nm zpool status . +.Nm zpool Cm status . The value is not used, only the presence or absence of the variable matters. .It Sy ZPOOL_VDEV_NAME_GUID Cause @@ -481,7 +490,7 @@ NVP value is present in the pool's config. For example, a pool that originated on illumos platform would have a .Sy devid value in the config and -.Nm zpool status +.Nm zpool Cm status would fail when listing the config. This would also be true for future Linux-based pools. .Pp @@ -497,12 +506,12 @@ by setting .Pp .It Sy ZPOOL_SCRIPTS_AS_ROOT Allow a privileged user to run -.Nm zpool status/iostat Fl c . +.Nm zpool Cm status Ns / Ns Cm iostat Fl c . Normally, only unprivileged users are allowed to run .Fl c . .It Sy ZPOOL_SCRIPTS_PATH The search path for scripts when running -.Nm zpool status/iostat Fl c . +.Nm zpool Cm status Ns / Ns Cm iostat Fl c . This is a colon-separated list of directories and overrides the default .Pa ~/.zpool.d and @@ -510,7 +519,7 @@ and search paths. .It Sy ZPOOL_SCRIPTS_ENABLED Allow a user to run -.Nm zpool status/iostat Fl c . +.Nm zpool Cm status Ns / Ns Cm iostat Fl c . If .Sy ZPOOL_SCRIPTS_ENABLED is not set, it is assumed that the user is allowed to run diff --git a/sys/contrib/openzfs/module/Makefile.bsd b/sys/contrib/openzfs/module/Makefile.bsd index 695b6630ae2..61f02152d33 100644 --- a/sys/contrib/openzfs/module/Makefile.bsd +++ b/sys/contrib/openzfs/module/Makefile.bsd @@ -35,7 +35,7 @@ CFLAGS+= -include ${INCDIR}/os/freebsd/spl/sys/ccompile.h CFLAGS+= -D__KERNEL__ -DFREEBSD_NAMECACHE -DBUILDING_ZFS -D__BSD_VISIBLE=1 \ -DHAVE_UIO_ZEROCOPY -DWITHOUT_NETDUMP -D__KERNEL -D_SYS_CONDVAR_H_ \ - -D_SYS_VMEM_H_ -DKDTRACE_HOOKS -DSMP -DHAVE_KSID -DCOMPAT_FREEBSD11 + -D_SYS_VMEM_H_ -DKDTRACE_HOOKS -DSMP -DCOMPAT_FREEBSD11 .if ${MACHINE_ARCH} == "amd64" CFLAGS+= -DHAVE_AVX2 -DHAVE_AVX -D__x86_64 -DHAVE_SSE2 -DHAVE_AVX512F -DHAVE_SSSE3 diff --git a/sys/contrib/openzfs/module/icp/algs/aes/aes_impl.c b/sys/contrib/openzfs/module/icp/algs/aes/aes_impl.c index c238bee2170..f518a54a618 100644 --- a/sys/contrib/openzfs/module/icp/algs/aes/aes_impl.c +++ b/sys/contrib/openzfs/module/icp/algs/aes/aes_impl.c @@ -47,7 +47,7 @@ aes_init_keysched(const uint8_t *cipherKey, uint_t keyBits, void *keysched) union { uint64_t ka64[4]; uint32_t ka32[8]; - } keyarr; + } keyarr; switch (keyBits) { case 128: @@ -81,7 +81,7 @@ aes_init_keysched(const uint8_t *cipherKey, uint_t keyBits, void *keysched) keyarr.ka64[i] = *((uint64_t *)&cipherKey[j]); } } else { - bcopy(cipherKey, keyarr.ka32, keysize); + memcpy(keyarr.ka32, cipherKey, keysize); } } else { /* byte swap */ @@ -132,7 +132,7 @@ aes_encrypt_block(const void *ks, const uint8_t *pt, uint8_t *ct) buffer[2] = htonl(*(uint32_t *)(void *)&pt[8]); buffer[3] = htonl(*(uint32_t *)(void *)&pt[12]); } else - bcopy(pt, &buffer, AES_BLOCK_LEN); + memcpy(&buffer, pt, AES_BLOCK_LEN); ops->encrypt(&ksch->encr_ks.ks32[0], ksch->nr, buffer, buffer); @@ -143,7 +143,7 @@ aes_encrypt_block(const void *ks, const uint8_t *pt, uint8_t *ct) *(uint32_t *)(void *)&ct[8] = htonl(buffer[2]); *(uint32_t *)(void *)&ct[12] = htonl(buffer[3]); } else - bcopy(&buffer, ct, AES_BLOCK_LEN); + memcpy(ct, &buffer, AES_BLOCK_LEN); } return (CRYPTO_SUCCESS); } @@ -179,7 +179,7 @@ aes_decrypt_block(const void *ks, const uint8_t *ct, uint8_t *pt) buffer[2] = htonl(*(uint32_t *)(void *)&ct[8]); buffer[3] = htonl(*(uint32_t *)(void *)&ct[12]); } else - bcopy(ct, &buffer, AES_BLOCK_LEN); + memcpy(&buffer, ct, AES_BLOCK_LEN); ops->decrypt(&ksch->decr_ks.ks32[0], ksch->nr, buffer, buffer); @@ -190,7 +190,7 @@ aes_decrypt_block(const void *ks, const uint8_t *ct, uint8_t *pt) *(uint32_t *)(void *)&pt[8] = htonl(buffer[2]); *(uint32_t *)(void *)&pt[12] = htonl(buffer[3]); } else - bcopy(&buffer, pt, AES_BLOCK_LEN); + memcpy(pt, &buffer, AES_BLOCK_LEN); } return (CRYPTO_SUCCESS); } diff --git a/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c b/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c index 20418eaa73c..6f3a43e263b 100644 --- a/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c +++ b/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c @@ -35,7 +35,7 @@ * cryptographic use. Users of Edon-R must interface directly to this module. */ -#include +#include #include #include @@ -470,32 +470,32 @@ EdonRInit(EdonRState *state, size_t hashbitlen) state->hashbitlen = 224; state->bits_processed = 0; state->unprocessed_bits = 0; - bcopy(i224p2, hashState224(state)->DoublePipe, - 16 * sizeof (uint32_t)); + memcpy(hashState224(state)->DoublePipe, i224p2, + sizeof (i224p2)); break; case 256: state->hashbitlen = 256; state->bits_processed = 0; state->unprocessed_bits = 0; - bcopy(i256p2, hashState256(state)->DoublePipe, - 16 * sizeof (uint32_t)); + memcpy(hashState256(state)->DoublePipe, i256p2, + sizeof (i256p2)); break; case 384: state->hashbitlen = 384; state->bits_processed = 0; state->unprocessed_bits = 0; - bcopy(i384p2, hashState384(state)->DoublePipe, - 16 * sizeof (uint64_t)); + memcpy(hashState384(state)->DoublePipe, i384p2, + sizeof (i384p2)); break; case 512: state->hashbitlen = 512; state->bits_processed = 0; state->unprocessed_bits = 0; - bcopy(i512p2, hashState224(state)->DoublePipe, - 16 * sizeof (uint64_t)); + memcpy(hashState224(state)->DoublePipe, i512p2, + sizeof (i512p2)); break; } } @@ -520,8 +520,9 @@ EdonRUpdate(EdonRState *state, const uint8_t *data, size_t databitlen) ASSERT(state->unprocessed_bits + databitlen <= EdonR256_BLOCK_SIZE * 8); - bcopy(data, hashState256(state)->LastPart - + (state->unprocessed_bits >> 3), LastBytes); + memcpy(hashState256(state)->LastPart + + (state->unprocessed_bits >> 3), + data, LastBytes); state->unprocessed_bits += (int)databitlen; databitlen = state->unprocessed_bits; /* LINTED E_BAD_PTR_CAST_ALIGN */ @@ -542,7 +543,8 @@ EdonRUpdate(EdonRState *state, const uint8_t *data, size_t databitlen) 1) & 0x01ff; data32 += bits_processed >> 5; /* byte size update */ - bcopy(data32, hashState256(state)->LastPart, LastBytes); + memmove(hashState256(state)->LastPart, + data32, LastBytes); } break; @@ -555,8 +557,9 @@ EdonRUpdate(EdonRState *state, const uint8_t *data, size_t databitlen) ASSERT(state->unprocessed_bits + databitlen <= EdonR512_BLOCK_SIZE * 8); - bcopy(data, hashState512(state)->LastPart - + (state->unprocessed_bits >> 3), LastBytes); + memcpy(hashState512(state)->LastPart + + (state->unprocessed_bits >> 3), + data, LastBytes); state->unprocessed_bits += (int)databitlen; databitlen = state->unprocessed_bits; /* LINTED E_BAD_PTR_CAST_ALIGN */ @@ -577,7 +580,8 @@ EdonRUpdate(EdonRState *state, const uint8_t *data, size_t databitlen) 1) & 0x03ff; data64 += bits_processed >> 6; /* byte size update */ - bcopy(data64, hashState512(state)->LastPart, LastBytes); + memmove(hashState512(state)->LastPart, + data64, LastBytes); } break; } @@ -682,7 +686,7 @@ EdonRFinal(EdonRState *state, uint8_t *hashval) for (j = 0; j < EdonR224_DIGEST_SIZE >> 2; j++) st_swap32(s32[j], d32 + j); #else - bcopy(hashState256(state)->DoublePipe + 9, hashval, + memcpy(hashval, hashState256(state)->DoublePipe + 9, EdonR224_DIGEST_SIZE); #endif break; @@ -696,7 +700,7 @@ EdonRFinal(EdonRState *state, uint8_t *hashval) for (j = 0; j < EdonR256_DIGEST_SIZE >> 2; j++) st_swap32(s32[j], d32 + j); #else - bcopy(hashState256(state)->DoublePipe + 8, hashval, + memcpy(hashval, hashState256(state)->DoublePipe + 8, EdonR256_DIGEST_SIZE); #endif break; @@ -710,7 +714,7 @@ EdonRFinal(EdonRState *state, uint8_t *hashval) for (j = 0; j < EdonR384_DIGEST_SIZE >> 3; j++) st_swap64(s64[j], d64 + j); #else - bcopy(hashState384(state)->DoublePipe + 10, hashval, + memcpy(hashval, hashState384(state)->DoublePipe + 10, EdonR384_DIGEST_SIZE); #endif break; @@ -724,7 +728,7 @@ EdonRFinal(EdonRState *state, uint8_t *hashval) for (j = 0; j < EdonR512_DIGEST_SIZE >> 3; j++) st_swap64(s64[j], d64 + j); #else - bcopy(hashState512(state)->DoublePipe + 8, hashval, + memcpy(hashval, hashState512(state)->DoublePipe + 8, EdonR512_DIGEST_SIZE); #endif break; diff --git a/sys/contrib/openzfs/module/icp/algs/modes/cbc.c b/sys/contrib/openzfs/module/icp/algs/modes/cbc.c index 73605f04d85..da3ff4e3595 100644 --- a/sys/contrib/openzfs/module/icp/algs/modes/cbc.c +++ b/sys/contrib/openzfs/module/icp/algs/modes/cbc.c @@ -51,8 +51,8 @@ cbc_encrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, if (length + ctx->cbc_remainder_len < block_size) { /* accumulate bytes here and return */ - bcopy(datap, - (uint8_t *)ctx->cbc_remainder + ctx->cbc_remainder_len, + memcpy((uint8_t *)ctx->cbc_remainder + ctx->cbc_remainder_len, + datap, length); ctx->cbc_remainder_len += length; ctx->cbc_copy_to = datap; @@ -70,8 +70,8 @@ cbc_encrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, if (need > remainder) return (CRYPTO_DATA_LEN_RANGE); - bcopy(datap, &((uint8_t *)ctx->cbc_remainder) - [ctx->cbc_remainder_len], need); + memcpy(&((uint8_t *)ctx->cbc_remainder) + [ctx->cbc_remainder_len], datap, need); blockp = (uint8_t *)ctx->cbc_remainder; } else { @@ -91,10 +91,10 @@ cbc_encrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, if (out_data_1_len == block_size) { copy_block(lastp, out_data_1); } else { - bcopy(lastp, out_data_1, out_data_1_len); + memcpy(out_data_1, lastp, out_data_1_len); if (out_data_2 != NULL) { - bcopy(lastp + out_data_1_len, - out_data_2, + memcpy(out_data_2, + lastp + out_data_1_len, block_size - out_data_1_len); } } @@ -113,7 +113,7 @@ cbc_encrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, /* Incomplete last block. */ if (remainder > 0 && remainder < block_size) { - bcopy(datap, ctx->cbc_remainder, remainder); + memcpy(ctx->cbc_remainder, datap, remainder); ctx->cbc_remainder_len = remainder; ctx->cbc_copy_to = datap; goto out; @@ -157,8 +157,8 @@ cbc_decrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, if (length + ctx->cbc_remainder_len < block_size) { /* accumulate bytes here and return */ - bcopy(datap, - (uint8_t *)ctx->cbc_remainder + ctx->cbc_remainder_len, + memcpy((uint8_t *)ctx->cbc_remainder + ctx->cbc_remainder_len, + datap, length); ctx->cbc_remainder_len += length; ctx->cbc_copy_to = datap; @@ -176,8 +176,8 @@ cbc_decrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, if (need > remainder) return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE); - bcopy(datap, &((uint8_t *)ctx->cbc_remainder) - [ctx->cbc_remainder_len], need); + memcpy(&((uint8_t *)ctx->cbc_remainder) + [ctx->cbc_remainder_len], datap, need); blockp = (uint8_t *)ctx->cbc_remainder; } else { @@ -203,9 +203,9 @@ cbc_decrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, crypto_get_ptrs(out, &iov_or_mp, &offset, &out_data_1, &out_data_1_len, &out_data_2, block_size); - bcopy(blockp, out_data_1, out_data_1_len); + memcpy(out_data_1, blockp, out_data_1_len); if (out_data_2 != NULL) { - bcopy(blockp + out_data_1_len, out_data_2, + memcpy(out_data_2, blockp + out_data_1_len, block_size - out_data_1_len); } @@ -224,7 +224,7 @@ cbc_decrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length, /* Incomplete last block. */ if (remainder > 0 && remainder < block_size) { - bcopy(datap, ctx->cbc_remainder, remainder); + memcpy(ctx->cbc_remainder, datap, remainder); ctx->cbc_remainder_len = remainder; ctx->cbc_lastp = lastp; ctx->cbc_copy_to = datap; diff --git a/sys/contrib/openzfs/module/icp/algs/modes/ccm.c b/sys/contrib/openzfs/module/icp/algs/modes/ccm.c index a41cbc395fd..9fde2684a7c 100644 --- a/sys/contrib/openzfs/module/icp/algs/modes/ccm.c +++ b/sys/contrib/openzfs/module/icp/algs/modes/ccm.c @@ -59,8 +59,8 @@ ccm_mode_encrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, if (length + ctx->ccm_remainder_len < block_size) { /* accumulate bytes here and return */ - bcopy(datap, - (uint8_t *)ctx->ccm_remainder + ctx->ccm_remainder_len, + memcpy((uint8_t *)ctx->ccm_remainder + ctx->ccm_remainder_len, + datap, length); ctx->ccm_remainder_len += length; ctx->ccm_copy_to = datap; @@ -80,8 +80,8 @@ ccm_mode_encrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, if (need > remainder) return (CRYPTO_DATA_LEN_RANGE); - bcopy(datap, &((uint8_t *)ctx->ccm_remainder) - [ctx->ccm_remainder_len], need); + memcpy(&((uint8_t *)ctx->ccm_remainder) + [ctx->ccm_remainder_len], datap, need); blockp = (uint8_t *)ctx->ccm_remainder; } else { @@ -132,10 +132,10 @@ ccm_mode_encrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, if (out_data_1_len == block_size) { copy_block(lastp, out_data_1); } else { - bcopy(lastp, out_data_1, out_data_1_len); + memcpy(out_data_1, lastp, out_data_1_len); if (out_data_2 != NULL) { - bcopy(lastp + out_data_1_len, - out_data_2, + memcpy(out_data_2, + lastp + out_data_1_len, block_size - out_data_1_len); } } @@ -154,7 +154,7 @@ ccm_mode_encrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, /* Incomplete last block. */ if (remainder > 0 && remainder < block_size) { - bcopy(datap, ctx->ccm_remainder, remainder); + memcpy(ctx->ccm_remainder, datap, remainder); ctx->ccm_remainder_len = remainder; ctx->ccm_copy_to = datap; goto out; @@ -224,10 +224,10 @@ ccm_encrypt_final(ccm_ctx_t *ctx, crypto_data_t *out, size_t block_size, /* ccm_mac_input_buf is not used for encryption */ macp = (uint8_t *)ctx->ccm_mac_input_buf; - bzero(macp, block_size); + memset(macp, 0, block_size); /* copy remainder to temporary buffer */ - bcopy(ctx->ccm_remainder, macp, ctx->ccm_remainder_len); + memcpy(macp, ctx->ccm_remainder, ctx->ccm_remainder_len); /* calculate the CBC MAC */ xor_block(macp, mac_buf); @@ -254,33 +254,32 @@ ccm_encrypt_final(ccm_ctx_t *ctx, crypto_data_t *out, size_t block_size, ctx->ccm_remainder_len + ctx->ccm_mac_len); if (ctx->ccm_remainder_len > 0) { - /* copy temporary block to where it belongs */ if (out_data_2 == NULL) { /* everything will fit in out_data_1 */ - bcopy(macp, out_data_1, ctx->ccm_remainder_len); - bcopy(ccm_mac_p, out_data_1 + ctx->ccm_remainder_len, + memcpy(out_data_1, macp, ctx->ccm_remainder_len); + memcpy(out_data_1 + ctx->ccm_remainder_len, ccm_mac_p, ctx->ccm_mac_len); } else { - if (out_data_1_len < ctx->ccm_remainder_len) { - size_t data_2_len_used; - bcopy(macp, out_data_1, out_data_1_len); + memcpy(out_data_1, macp, out_data_1_len); data_2_len_used = ctx->ccm_remainder_len - out_data_1_len; - bcopy((uint8_t *)macp + out_data_1_len, - out_data_2, data_2_len_used); - bcopy(ccm_mac_p, out_data_2 + data_2_len_used, + memcpy(out_data_2, + (uint8_t *)macp + out_data_1_len, + data_2_len_used); + memcpy(out_data_2 + data_2_len_used, + ccm_mac_p, ctx->ccm_mac_len); } else { - bcopy(macp, out_data_1, out_data_1_len); + memcpy(out_data_1, macp, out_data_1_len); if (out_data_1_len == ctx->ccm_remainder_len) { /* mac will be in out_data_2 */ - bcopy(ccm_mac_p, out_data_2, + memcpy(out_data_2, ccm_mac_p, ctx->ccm_mac_len); } else { size_t len_not_used = out_data_1_len - @@ -290,11 +289,11 @@ ccm_encrypt_final(ccm_ctx_t *ctx, crypto_data_t *out, size_t block_size, * out_data_1, part of the mac will be * in out_data_2 */ - bcopy(ccm_mac_p, - out_data_1 + ctx->ccm_remainder_len, - len_not_used); - bcopy(ccm_mac_p + len_not_used, - out_data_2, + memcpy(out_data_1 + + ctx->ccm_remainder_len, + ccm_mac_p, len_not_used); + memcpy(out_data_2, + ccm_mac_p + len_not_used, ctx->ccm_mac_len - len_not_used); } @@ -302,9 +301,9 @@ ccm_encrypt_final(ccm_ctx_t *ctx, crypto_data_t *out, size_t block_size, } } else { /* copy block to where it belongs */ - bcopy(ccm_mac_p, out_data_1, out_data_1_len); + memcpy(out_data_1, ccm_mac_p, out_data_1_len); if (out_data_2 != NULL) { - bcopy(ccm_mac_p + out_data_1_len, out_data_2, + memcpy(out_data_2, ccm_mac_p + out_data_1_len, block_size - out_data_1_len); } } @@ -372,7 +371,7 @@ ccm_mode_decrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, } tmp = (uint8_t *)ctx->ccm_mac_input_buf; - bcopy(datap, tmp + pm_len, length); + memcpy(tmp + pm_len, datap, length); ctx->ccm_processed_mac_len += length; return (CRYPTO_SUCCESS); @@ -405,15 +404,15 @@ ccm_mode_decrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, mac_len = length - pt_part; ctx->ccm_processed_mac_len = mac_len; - bcopy(data + pt_part, ctx->ccm_mac_input_buf, mac_len); + memcpy(ctx->ccm_mac_input_buf, data + pt_part, mac_len); if (pt_part + ctx->ccm_remainder_len < block_size) { /* * since this is last of the ciphertext, will * just decrypt with it here */ - bcopy(datap, &((uint8_t *)ctx->ccm_remainder) - [ctx->ccm_remainder_len], pt_part); + memcpy(&((uint8_t *)ctx->ccm_remainder) + [ctx->ccm_remainder_len], datap, pt_part); ctx->ccm_remainder_len += pt_part; ccm_decrypt_incomplete_block(ctx, encrypt_block); ctx->ccm_processed_data_len += ctx->ccm_remainder_len; @@ -424,9 +423,9 @@ ccm_mode_decrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, length = pt_part; } } else if (length + ctx->ccm_remainder_len < block_size) { - /* accumulate bytes here and return */ - bcopy(datap, - (uint8_t *)ctx->ccm_remainder + ctx->ccm_remainder_len, + /* accumulate bytes here and return */ + memcpy((uint8_t *)ctx->ccm_remainder + ctx->ccm_remainder_len, + datap, length); ctx->ccm_remainder_len += length; ctx->ccm_copy_to = datap; @@ -441,8 +440,8 @@ ccm_mode_decrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, if (need > remainder) return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE); - bcopy(datap, &((uint8_t *)ctx->ccm_remainder) - [ctx->ccm_remainder_len], need); + memcpy(&((uint8_t *)ctx->ccm_remainder) + [ctx->ccm_remainder_len], datap, need); blockp = (uint8_t *)ctx->ccm_remainder; } else { @@ -492,7 +491,7 @@ ccm_mode_decrypt_contiguous_blocks(ccm_ctx_t *ctx, char *data, size_t length, /* Incomplete last block */ if (remainder > 0 && remainder < block_size) { - bcopy(datap, ctx->ccm_remainder, remainder); + memcpy(ctx->ccm_remainder, datap, remainder); ctx->ccm_remainder_len = remainder; ctx->ccm_copy_to = datap; if (ctx->ccm_processed_mac_len > 0) { @@ -539,10 +538,9 @@ ccm_decrypt_final(ccm_ctx_t *ctx, crypto_data_t *out, size_t block_size, macp = (uint8_t *)ctx->ccm_tmp; while (mac_remain > 0) { - if (mac_remain < block_size) { - bzero(macp, block_size); - bcopy(pt, macp, mac_remain); + memset(macp, 0, block_size); + memcpy(macp, pt, mac_remain); mac_remain = 0; } else { copy_block(pt, macp); @@ -560,7 +558,7 @@ ccm_decrypt_final(ccm_ctx_t *ctx, crypto_data_t *out, size_t block_size, calculate_ccm_mac((ccm_ctx_t *)ctx, ccm_mac_p, encrypt_block); /* compare the input CCM MAC value with what we calculated */ - if (bcmp(ctx->ccm_mac_input_buf, ccm_mac_p, ctx->ccm_mac_len)) { + if (memcmp(ctx->ccm_mac_input_buf, ccm_mac_p, ctx->ccm_mac_len)) { /* They don't match */ return (CRYPTO_INVALID_MAC); } else { @@ -654,10 +652,10 @@ ccm_format_initial_blocks(uchar_t *nonce, ulong_t nonceSize, b0[0] = (have_adata << 6) | (((t - 2) / 2) << 3) | (q - 1); /* copy the nonce value into b0 */ - bcopy(nonce, &(b0[1]), nonceSize); + memcpy(&(b0[1]), nonce, nonceSize); /* store the length of the payload into b0 */ - bzero(&(b0[1+nonceSize]), q); + memset(&(b0[1+nonceSize]), 0, q); payloadSize = aes_ctx->ccm_data_len; limit = 8 < q ? 8 : q; @@ -673,9 +671,9 @@ ccm_format_initial_blocks(uchar_t *nonce, ulong_t nonceSize, cb[0] = 0x07 & (q-1); /* first byte */ /* copy the nonce value into the counter block */ - bcopy(nonce, &(cb[1]), nonceSize); + memcpy(&(cb[1]), nonce, nonceSize); - bzero(&(cb[1+nonceSize]), q); + memset(&(cb[1+nonceSize]), 0, q); /* Create the mask for the counter field based on the size of nonce */ q <<= 3; @@ -782,7 +780,7 @@ ccm_init(ccm_ctx_t *ctx, unsigned char *nonce, size_t nonce_len, /* The IV for CBC MAC for AES CCM mode is always zero */ ivp = (uint8_t *)ctx->ccm_tmp; - bzero(ivp, block_size); + memset(ivp, 0, block_size); xor_block(ivp, mac_buf); @@ -800,14 +798,14 @@ ccm_init(ccm_ctx_t *ctx, unsigned char *nonce, size_t nonce_len, /* 1st block: it contains encoded associated data, and some data */ authp = (uint8_t *)ctx->ccm_tmp; - bzero(authp, block_size); - bcopy(encoded_a, authp, encoded_a_len); + memset(authp, 0, block_size); + memcpy(authp, encoded_a, encoded_a_len); processed = block_size - encoded_a_len; if (processed > auth_data_len) { /* in case auth_data is very small */ processed = auth_data_len; } - bcopy(auth_data, authp+encoded_a_len, processed); + memcpy(authp+encoded_a_len, auth_data, processed); /* xor with previous buffer */ xor_block(authp, mac_buf); encrypt_block(ctx->ccm_keysched, mac_buf, mac_buf); @@ -823,8 +821,8 @@ ccm_init(ccm_ctx_t *ctx, unsigned char *nonce, size_t nonce_len, * There's not a block full of data, pad rest of * buffer with zero */ - bzero(authp, block_size); - bcopy(&(auth_data[processed]), authp, remainder); + memset(authp, 0, block_size); + memcpy(authp, &(auth_data[processed]), remainder); datap = (uint8_t *)authp; remainder = 0; } else { diff --git a/sys/contrib/openzfs/module/icp/algs/modes/ctr.c b/sys/contrib/openzfs/module/icp/algs/modes/ctr.c index 82295cda877..c31c6251624 100644 --- a/sys/contrib/openzfs/module/icp/algs/modes/ctr.c +++ b/sys/contrib/openzfs/module/icp/algs/modes/ctr.c @@ -52,8 +52,8 @@ ctr_mode_contiguous_blocks(ctr_ctx_t *ctx, char *data, size_t length, if (length + ctx->ctr_remainder_len < block_size) { /* accumulate bytes here and return */ - bcopy(datap, - (uint8_t *)ctx->ctr_remainder + ctx->ctr_remainder_len, + memcpy((uint8_t *)ctx->ctr_remainder + ctx->ctr_remainder_len, + datap, length); ctx->ctr_remainder_len += length; ctx->ctr_copy_to = datap; @@ -71,8 +71,8 @@ ctr_mode_contiguous_blocks(ctr_ctx_t *ctx, char *data, size_t length, if (need > remainder) return (CRYPTO_DATA_LEN_RANGE); - bcopy(datap, &((uint8_t *)ctx->ctr_remainder) - [ctx->ctr_remainder_len], need); + memcpy(&((uint8_t *)ctx->ctr_remainder) + [ctx->ctr_remainder_len], datap, need); blockp = (uint8_t *)ctx->ctr_remainder; } else { @@ -114,9 +114,9 @@ ctr_mode_contiguous_blocks(ctr_ctx_t *ctx, char *data, size_t length, &out_data_1_len, &out_data_2, block_size); /* copy block to where it belongs */ - bcopy(lastp, out_data_1, out_data_1_len); + memcpy(out_data_1, lastp, out_data_1_len); if (out_data_2 != NULL) { - bcopy(lastp + out_data_1_len, out_data_2, + memcpy(out_data_2, lastp + out_data_1_len, block_size - out_data_1_len); } /* update offset */ @@ -134,7 +134,7 @@ ctr_mode_contiguous_blocks(ctr_ctx_t *ctx, char *data, size_t length, /* Incomplete last block. */ if (remainder > 0 && remainder < block_size) { - bcopy(datap, ctx->ctr_remainder, remainder); + memcpy(ctx->ctr_remainder, datap, remainder); ctx->ctr_remainder_len = remainder; ctx->ctr_copy_to = datap; goto out; @@ -176,10 +176,11 @@ ctr_mode_final(ctr_ctx_t *ctx, crypto_data_t *out, crypto_get_ptrs(out, &iov_or_mp, &offset, &out_data_1, &out_data_1_len, &out_data_2, ctx->ctr_remainder_len); - bcopy(p, out_data_1, out_data_1_len); + memcpy(out_data_1, p, out_data_1_len); if (out_data_2 != NULL) { - bcopy((uint8_t *)p + out_data_1_len, - out_data_2, ctx->ctr_remainder_len - out_data_1_len); + memcpy(out_data_2, + (uint8_t *)p + out_data_1_len, + ctx->ctr_remainder_len - out_data_1_len); } out->cd_offset += ctx->ctr_remainder_len; ctx->ctr_remainder_len = 0; diff --git a/sys/contrib/openzfs/module/icp/algs/modes/ecb.c b/sys/contrib/openzfs/module/icp/algs/modes/ecb.c index ffbdb9d57d0..e0b8ab15cdc 100644 --- a/sys/contrib/openzfs/module/icp/algs/modes/ecb.c +++ b/sys/contrib/openzfs/module/icp/algs/modes/ecb.c @@ -49,8 +49,8 @@ ecb_cipher_contiguous_blocks(ecb_ctx_t *ctx, char *data, size_t length, if (length + ctx->ecb_remainder_len < block_size) { /* accumulate bytes here and return */ - bcopy(datap, - (uint8_t *)ctx->ecb_remainder + ctx->ecb_remainder_len, + memcpy((uint8_t *)ctx->ecb_remainder + ctx->ecb_remainder_len, + datap, length); ctx->ecb_remainder_len += length; ctx->ecb_copy_to = datap; @@ -68,8 +68,8 @@ ecb_cipher_contiguous_blocks(ecb_ctx_t *ctx, char *data, size_t length, if (need > remainder) return (CRYPTO_DATA_LEN_RANGE); - bcopy(datap, &((uint8_t *)ctx->ecb_remainder) - [ctx->ecb_remainder_len], need); + memcpy(&((uint8_t *)ctx->ecb_remainder) + [ctx->ecb_remainder_len], datap, need); blockp = (uint8_t *)ctx->ecb_remainder; } else { @@ -81,9 +81,9 @@ ecb_cipher_contiguous_blocks(ecb_ctx_t *ctx, char *data, size_t length, &out_data_1_len, &out_data_2, block_size); /* copy block to where it belongs */ - bcopy(lastp, out_data_1, out_data_1_len); + memcpy(out_data_1, lastp, out_data_1_len); if (out_data_2 != NULL) { - bcopy(lastp + out_data_1_len, out_data_2, + memcpy(out_data_2, lastp + out_data_1_len, block_size - out_data_1_len); } /* update offset */ @@ -101,7 +101,7 @@ ecb_cipher_contiguous_blocks(ecb_ctx_t *ctx, char *data, size_t length, /* Incomplete last block. */ if (remainder > 0 && remainder < block_size) { - bcopy(datap, ctx->ecb_remainder, remainder); + memcpy(ctx->ecb_remainder, datap, remainder); ctx->ecb_remainder_len = remainder; ctx->ecb_copy_to = datap; goto out; diff --git a/sys/contrib/openzfs/module/icp/algs/modes/gcm.c b/sys/contrib/openzfs/module/icp/algs/modes/gcm.c index 7d34c2b040f..e666b45b5f4 100644 --- a/sys/contrib/openzfs/module/icp/algs/modes/gcm.c +++ b/sys/contrib/openzfs/module/icp/algs/modes/gcm.c @@ -108,8 +108,8 @@ gcm_mode_encrypt_contiguous_blocks(gcm_ctx_t *ctx, char *data, size_t length, if (length + ctx->gcm_remainder_len < block_size) { /* accumulate bytes here and return */ - bcopy(datap, - (uint8_t *)ctx->gcm_remainder + ctx->gcm_remainder_len, + memcpy((uint8_t *)ctx->gcm_remainder + ctx->gcm_remainder_len, + datap, length); ctx->gcm_remainder_len += length; if (ctx->gcm_copy_to == NULL) { @@ -130,8 +130,8 @@ gcm_mode_encrypt_contiguous_blocks(gcm_ctx_t *ctx, char *data, size_t length, if (need > remainder) return (CRYPTO_DATA_LEN_RANGE); - bcopy(datap, &((uint8_t *)ctx->gcm_remainder) - [ctx->gcm_remainder_len], need); + memcpy(&((uint8_t *)ctx->gcm_remainder) + [ctx->gcm_remainder_len], datap, need); blockp = (uint8_t *)ctx->gcm_remainder; } else { @@ -162,10 +162,10 @@ gcm_mode_encrypt_contiguous_blocks(gcm_ctx_t *ctx, char *data, size_t length, if (out_data_1_len == block_size) { copy_block(lastp, out_data_1); } else { - bcopy(lastp, out_data_1, out_data_1_len); + memcpy(out_data_1, lastp, out_data_1_len); if (out_data_2 != NULL) { - bcopy(lastp + out_data_1_len, - out_data_2, + memcpy(out_data_2, + lastp + out_data_1_len, block_size - out_data_1_len); } } @@ -187,7 +187,7 @@ gcm_mode_encrypt_contiguous_blocks(gcm_ctx_t *ctx, char *data, size_t length, /* Incomplete last block. */ if (remainder > 0 && remainder < block_size) { - bcopy(datap, ctx->gcm_remainder, remainder); + memcpy(ctx->gcm_remainder, datap, remainder); ctx->gcm_remainder_len = remainder; ctx->gcm_copy_to = datap; goto out; @@ -245,7 +245,7 @@ gcm_encrypt_final(gcm_ctx_t *ctx, crypto_data_t *out, size_t block_size, (uint8_t *)ctx->gcm_tmp); macp = (uint8_t *)ctx->gcm_remainder; - bzero(macp + ctx->gcm_remainder_len, + memset(macp + ctx->gcm_remainder_len, 0, block_size - ctx->gcm_remainder_len); /* XOR with counter block */ @@ -309,8 +309,8 @@ gcm_decrypt_incomplete_block(gcm_ctx_t *ctx, size_t block_size, size_t index, counterp = (uint8_t *)ctx->gcm_tmp; /* authentication tag */ - bzero((uint8_t *)ctx->gcm_tmp, block_size); - bcopy(datap, (uint8_t *)ctx->gcm_tmp, ctx->gcm_remainder_len); + memset((uint8_t *)ctx->gcm_tmp, 0, block_size); + memcpy((uint8_t *)ctx->gcm_tmp, datap, ctx->gcm_remainder_len); /* add ciphertext to the hash */ GHASH(ctx, ctx->gcm_tmp, ctx->gcm_ghash, gcm_impl_get_ops()); @@ -350,7 +350,7 @@ gcm_mode_decrypt_contiguous_blocks(gcm_ctx_t *ctx, char *data, size_t length, } if (ctx->gcm_pt_buf != NULL) { - bcopy(ctx->gcm_pt_buf, new, ctx->gcm_pt_buf_len); + memcpy(new, ctx->gcm_pt_buf, ctx->gcm_pt_buf_len); vmem_free(ctx->gcm_pt_buf, ctx->gcm_pt_buf_len); } else { ASSERT0(ctx->gcm_pt_buf_len); @@ -358,7 +358,7 @@ gcm_mode_decrypt_contiguous_blocks(gcm_ctx_t *ctx, char *data, size_t length, ctx->gcm_pt_buf = new; ctx->gcm_pt_buf_len = new_len; - bcopy(data, &ctx->gcm_pt_buf[ctx->gcm_processed_data_len], + memcpy(&ctx->gcm_pt_buf[ctx->gcm_processed_data_len], data, length); ctx->gcm_processed_data_len += length; } @@ -397,7 +397,7 @@ gcm_decrypt_final(gcm_ctx_t *ctx, crypto_data_t *out, size_t block_size, while (remainder > 0) { /* Incomplete last block */ if (remainder < block_size) { - bcopy(blockp, ctx->gcm_remainder, remainder); + memcpy(ctx->gcm_remainder, blockp, remainder); ctx->gcm_remainder_len = remainder; /* * not expecting anymore ciphertext, just @@ -438,7 +438,7 @@ out: xor_block((uint8_t *)ctx->gcm_J0, ghash); /* compare the input authentication tag with what we calculated */ - if (bcmp(&ctx->gcm_pt_buf[pt_len], ghash, ctx->gcm_tag_len)) { + if (memcmp(&ctx->gcm_pt_buf[pt_len], ghash, ctx->gcm_tag_len)) { /* They don't match */ return (CRYPTO_INVALID_MAC); } else { @@ -495,7 +495,7 @@ gcm_format_initial_blocks(uchar_t *iv, ulong_t iv_len, ghash = (uint8_t *)ctx->gcm_ghash; cb = (uint8_t *)ctx->gcm_cb; if (iv_len == 12) { - bcopy(iv, cb, 12); + memcpy(cb, iv, 12); cb[12] = 0; cb[13] = 0; cb[14] = 0; @@ -506,8 +506,8 @@ gcm_format_initial_blocks(uchar_t *iv, ulong_t iv_len, /* GHASH the IV */ do { if (remainder < block_size) { - bzero(cb, block_size); - bcopy(&(iv[processed]), cb, remainder); + memset(cb, 0, block_size); + memcpy(cb, &(iv[processed]), remainder); datap = (uint8_t *)cb; remainder = 0; } else { @@ -539,7 +539,7 @@ gcm_init(gcm_ctx_t *ctx, unsigned char *iv, size_t iv_len, size_t remainder, processed; /* encrypt zero block to get subkey H */ - bzero(ctx->gcm_H, sizeof (ctx->gcm_H)); + memset(ctx->gcm_H, 0, sizeof (ctx->gcm_H)); encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_H, (uint8_t *)ctx->gcm_H); @@ -549,8 +549,8 @@ gcm_init(gcm_ctx_t *ctx, unsigned char *iv, size_t iv_len, gops = gcm_impl_get_ops(); authp = (uint8_t *)ctx->gcm_tmp; ghash = (uint8_t *)ctx->gcm_ghash; - bzero(authp, block_size); - bzero(ghash, block_size); + memset(authp, 0, block_size); + memset(ghash, 0, block_size); processed = 0; remainder = auth_data_len; @@ -562,9 +562,9 @@ gcm_init(gcm_ctx_t *ctx, unsigned char *iv, size_t iv_len, */ if (auth_data != NULL) { - bzero(authp, block_size); - bcopy(&(auth_data[processed]), - authp, remainder); + memset(authp, 0, block_size); + memcpy(authp, &(auth_data[processed]), + remainder); } else { ASSERT0(remainder); } @@ -1139,10 +1139,10 @@ gcm_simd_get_htab_size(boolean_t simd_mode) static inline void gcm_clear_ctx(gcm_ctx_t *ctx) { - bzero(ctx->gcm_remainder, sizeof (ctx->gcm_remainder)); - bzero(ctx->gcm_H, sizeof (ctx->gcm_H)); - bzero(ctx->gcm_J0, sizeof (ctx->gcm_J0)); - bzero(ctx->gcm_tmp, sizeof (ctx->gcm_tmp)); + memset(ctx->gcm_remainder, 0, sizeof (ctx->gcm_remainder)); + memset(ctx->gcm_H, 0, sizeof (ctx->gcm_H)); + memset(ctx->gcm_J0, 0, sizeof (ctx->gcm_J0)); + memset(ctx->gcm_tmp, 0, sizeof (ctx->gcm_tmp)); } /* Increment the GCM counter block by n. */ @@ -1187,8 +1187,8 @@ gcm_mode_encrypt_contiguous_blocks_avx(gcm_ctx_t *ctx, char *data, need = block_size - ctx->gcm_remainder_len; if (length < need) { /* Accumulate bytes here and return. */ - bcopy(datap, (uint8_t *)ctx->gcm_remainder + - ctx->gcm_remainder_len, length); + memcpy((uint8_t *)ctx->gcm_remainder + + ctx->gcm_remainder_len, datap, length); ctx->gcm_remainder_len += length; if (ctx->gcm_copy_to == NULL) { @@ -1197,8 +1197,8 @@ gcm_mode_encrypt_contiguous_blocks_avx(gcm_ctx_t *ctx, char *data, return (CRYPTO_SUCCESS); } else { /* Complete incomplete block. */ - bcopy(datap, (uint8_t *)ctx->gcm_remainder + - ctx->gcm_remainder_len, need); + memcpy((uint8_t *)ctx->gcm_remainder + + ctx->gcm_remainder_len, datap, need); ctx->gcm_copy_to = NULL; } @@ -1276,7 +1276,7 @@ gcm_mode_encrypt_contiguous_blocks_avx(gcm_ctx_t *ctx, char *data, /* Less than GCM_AVX_MIN_ENCRYPT_BYTES remain, operate on blocks. */ while (bleft > 0) { if (bleft < block_size) { - bcopy(datap, ctx->gcm_remainder, bleft); + memcpy(ctx->gcm_remainder, datap, bleft); ctx->gcm_remainder_len = bleft; ctx->gcm_copy_to = datap; goto out; @@ -1335,7 +1335,7 @@ gcm_encrypt_final_avx(gcm_ctx_t *ctx, crypto_data_t *out, size_t block_size) const uint32_t *cb = (uint32_t *)ctx->gcm_cb; aes_encrypt_intel(keysched, aes_rounds, cb, (uint32_t *)tmp); - bzero(remainder + rem_len, block_size - rem_len); + memset(remainder + rem_len, 0, block_size - rem_len); for (int i = 0; i < rem_len; i++) { remainder[i] ^= tmp[i]; } @@ -1431,8 +1431,8 @@ gcm_decrypt_final_avx(gcm_ctx_t *ctx, crypto_data_t *out, size_t block_size) if (bleft < block_size) { uint8_t *lastb = (uint8_t *)ctx->gcm_remainder; - bzero(lastb, block_size); - bcopy(datap, lastb, bleft); + memset(lastb, 0, block_size); + memcpy(lastb, datap, bleft); /* The GCM processing. */ GHASH_AVX(ctx, lastb, block_size); aes_encrypt_intel(key->encr_ks.ks32, key->nr, cb, tmp); @@ -1468,7 +1468,7 @@ gcm_decrypt_final_avx(gcm_ctx_t *ctx, crypto_data_t *out, size_t block_size) kfpu_end(); /* Compare the input authentication tag with what we calculated. */ - if (bcmp(&ctx->gcm_pt_buf[pt_len], ghash, ctx->gcm_tag_len)) { + if (memcmp(&ctx->gcm_pt_buf[pt_len], ghash, ctx->gcm_tag_len)) { /* They don't match. */ return (CRYPTO_INVALID_MAC); } @@ -1500,8 +1500,8 @@ gcm_init_avx(gcm_ctx_t *ctx, unsigned char *iv, size_t iv_len, ASSERT(block_size == GCM_BLOCK_LEN); /* Init H (encrypt zero block) and create the initial counter block. */ - bzero(ctx->gcm_ghash, sizeof (ctx->gcm_ghash)); - bzero(H, sizeof (ctx->gcm_H)); + memset(ctx->gcm_ghash, 0, sizeof (ctx->gcm_ghash)); + memset(H, 0, sizeof (ctx->gcm_H)); kfpu_begin(); aes_encrypt_intel(keysched, aes_rounds, (const uint32_t *)H, (uint32_t *)H); @@ -1509,13 +1509,13 @@ gcm_init_avx(gcm_ctx_t *ctx, unsigned char *iv, size_t iv_len, gcm_init_htab_avx(ctx->gcm_Htable, H); if (iv_len == 12) { - bcopy(iv, cb, 12); + memcpy(cb, iv, 12); cb[12] = 0; cb[13] = 0; cb[14] = 0; cb[15] = 1; /* We need the ICB later. */ - bcopy(cb, ctx->gcm_J0, sizeof (ctx->gcm_J0)); + memcpy(ctx->gcm_J0, cb, sizeof (ctx->gcm_J0)); } else { /* * Most consumers use 12 byte IVs, so it's OK to use the @@ -1553,8 +1553,8 @@ gcm_init_avx(gcm_ctx_t *ctx, unsigned char *iv, size_t iv_len, /* Zero pad and hash incomplete last block. */ uint8_t *authp = (uint8_t *)ctx->gcm_tmp; - bzero(authp, block_size); - bcopy(datap, authp, incomp); + memset(authp, 0, block_size); + memcpy(authp, datap, incomp); GHASH_AVX(ctx, authp, block_size); } } diff --git a/sys/contrib/openzfs/module/icp/algs/modes/modes.c b/sys/contrib/openzfs/module/icp/algs/modes/modes.c index 59743c7d682..d505de40ee2 100644 --- a/sys/contrib/openzfs/module/icp/algs/modes/modes.c +++ b/sys/contrib/openzfs/module/icp/algs/modes/modes.c @@ -155,7 +155,7 @@ crypto_free_mode_ctx(void *ctx) #ifdef CAN_USE_GCM_ASM if (((gcm_ctx_t *)ctx)->gcm_Htable != NULL) { gcm_ctx_t *gcm_ctx = (gcm_ctx_t *)ctx; - bzero(gcm_ctx->gcm_Htable, gcm_ctx->gcm_htab_len); + memset(gcm_ctx->gcm_Htable, 0, gcm_ctx->gcm_htab_len); kmem_free(gcm_ctx->gcm_Htable, gcm_ctx->gcm_htab_len); } #endif diff --git a/sys/contrib/openzfs/module/icp/algs/sha2/sha2.c b/sys/contrib/openzfs/module/icp/algs/sha2/sha2.c index 6f1e9b7193d..151432f1a5d 100644 --- a/sys/contrib/openzfs/module/icp/algs/sha2/sha2.c +++ b/sys/contrib/openzfs/module/icp/algs/sha2/sha2.c @@ -190,7 +190,7 @@ SHA256Transform(SHA2_CTX *ctx, const uint8_t *blk) #endif /* __sparc */ if ((uintptr_t)blk & 0x3) { /* not 4-byte aligned? */ - bcopy(blk, ctx->buf_un.buf32, sizeof (ctx->buf_un.buf32)); + memcpy(ctx->buf_un.buf32, blk, sizeof (ctx->buf_un.buf32)); blk = (uint8_t *)ctx->buf_un.buf32; } @@ -406,7 +406,7 @@ SHA512Transform(SHA2_CTX *ctx, const uint8_t *blk) if ((uintptr_t)blk & 0x7) { /* not 8-byte aligned? */ - bcopy(blk, ctx->buf_un.buf64, sizeof (ctx->buf_un.buf64)); + memcpy(ctx->buf_un.buf64, blk, sizeof (ctx->buf_un.buf64)); blk = (uint8_t *)ctx->buf_un.buf64; } @@ -823,14 +823,14 @@ SHA2Update(SHA2_CTX *ctx, const void *inptr, size_t input_len) /* * general optimization: * - * only do initial bcopy() and SHA2Transform() if + * only do initial memcpy() and SHA2Transform() if * buf_index != 0. if buf_index == 0, we're just - * wasting our time doing the bcopy() since there + * wasting our time doing the memcpy() since there * wasn't any data left over from a previous call to * SHA2Update(). */ if (buf_index) { - bcopy(input, &ctx->buf_un.buf8[buf_index], buf_len); + memcpy(&ctx->buf_un.buf8[buf_index], input, buf_len); if (algotype <= SHA256_HMAC_GEN_MECH_INFO_TYPE) SHA256Transform(ctx, ctx->buf_un.buf8); else @@ -873,7 +873,7 @@ SHA2Update(SHA2_CTX *ctx, const void *inptr, size_t input_len) * general optimization: * * if i and input_len are the same, return now instead - * of calling bcopy(), since the bcopy() in this case + * of calling memcpy(), since the memcpy() in this case * will be an expensive noop. */ @@ -884,7 +884,7 @@ SHA2Update(SHA2_CTX *ctx, const void *inptr, size_t input_len) } /* buffer remaining input */ - bcopy(&input[i], &ctx->buf_un.buf8[buf_index], input_len - i); + memcpy(&ctx->buf_un.buf8[buf_index], &input[i], input_len - i); } @@ -936,7 +936,7 @@ SHA2Final(void *digest, SHA2_CTX *ctx) */ Encode64(digest, ctx->state.s64, sizeof (uint64_t) * 3); Encode64(last, &ctx->state.s64[3], sizeof (uint64_t)); - bcopy(last, (uint8_t *)digest + 24, 4); + memcpy((uint8_t *)digest + 24, last, 4); } else if (algotype == SHA512_256_MECH_INFO_TYPE) { Encode64(digest, ctx->state.s64, sizeof (uint64_t) * 4); } else { @@ -946,7 +946,7 @@ SHA2Final(void *digest, SHA2_CTX *ctx) } /* zeroize sensitive information */ - bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); } #ifdef _KERNEL diff --git a/sys/contrib/openzfs/module/icp/algs/skein/skein.c b/sys/contrib/openzfs/module/icp/algs/skein/skein.c index 83fe8426030..41ed2dd44e9 100644 --- a/sys/contrib/openzfs/module/icp/algs/skein/skein.c +++ b/sys/contrib/openzfs/module/icp/algs/skein/skein.c @@ -26,16 +26,16 @@ Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 256: - bcopy(SKEIN_256_IV_256, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_256_IV_256, sizeof (ctx->X)); break; case 224: - bcopy(SKEIN_256_IV_224, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_256_IV_224, sizeof (ctx->X)); break; case 160: - bcopy(SKEIN_256_IV_160, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_256_IV_160, sizeof (ctx->X)); break; case 128: - bcopy(SKEIN_256_IV_128, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_256_IV_128, sizeof (ctx->X)); break; #endif default: @@ -53,11 +53,11 @@ Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) cfg.w[1] = Skein_Swap64(hashBitLen); cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* zero pad config block */ - bzero(&cfg.w[3], sizeof (cfg) - 3 * sizeof (cfg.w[0])); + memset(&cfg.w[3], 0, sizeof (cfg) - 3 * sizeof (cfg.w[0])); /* compute the initial chaining values from config block */ /* zero the chaining variables */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); Skein_256_Process_Block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN); break; } @@ -91,7 +91,7 @@ Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) { /* is there a key? */ /* no key: use all zeroes as key for config block */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); } else { /* here to pre-process a key */ Skein_assert(sizeof (cfg.b) >= sizeof (ctx->X)); @@ -101,13 +101,13 @@ Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, /* set tweaks: T0 = 0; T1 = KEY type */ Skein_Start_New_Type(ctx, KEY); /* zero the initial chaining variables */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); /* hash the key */ (void) Skein_256_Update(ctx, key, keyBytes); /* put result into cfg.b[] */ (void) Skein_256_Final_Pad(ctx, cfg.b); /* copy over into ctx->X[] */ - bcopy(cfg.b, ctx->X, sizeof (cfg.b)); + memcpy(ctx->X, cfg.b, sizeof (cfg.b)); #if SKEIN_NEED_SWAP { uint_t i; @@ -124,7 +124,7 @@ Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx, CFG_FINAL); - bzero(&cfg.w, sizeof (cfg.w)); /* pre-pad cfg.w[] with zeroes */ + memset(&cfg.w, 0, sizeof (cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ @@ -161,7 +161,7 @@ Skein_256_Update(Skein_256_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt) if (n) { /* check on our logic here */ Skein_assert(n < msgByteCnt); - bcopy(msg, &ctx->b[ctx->h.bCnt], n); + memcpy(&ctx->b[ctx->h.bCnt], msg, n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; @@ -189,7 +189,7 @@ Skein_256_Update(Skein_256_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt) /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES); - bcopy(msg, &ctx->b[ctx->h.bCnt], msgByteCnt); + memcpy(&ctx->b[ctx->h.bCnt], msg, msgByteCnt); ctx->h.bCnt += msgByteCnt; } @@ -209,7 +209,7 @@ Skein_256_Final(Skein_256_Ctxt_t *ctx, uint8_t *hashVal) ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ /* zero pad b[] if necessary */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) - bzero(&ctx->b[ctx->h.bCnt], + memset(&ctx->b[ctx->h.bCnt], 0, SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); /* process the final block */ @@ -221,13 +221,12 @@ Skein_256_Final(Skein_256_Ctxt_t *ctx, uint8_t *hashVal) /* run Threefish in "counter mode" to generate output */ /* zero out b[], so it can hold the counter */ - bzero(ctx->b, sizeof (ctx->b)); + memset(ctx->b, 0, sizeof (ctx->b)); /* keep a local copy of counter mode "key" */ - bcopy(ctx->X, X, sizeof (X)); + memcpy(X, ctx->X, sizeof (X)); for (i = 0; i * SKEIN_256_BLOCK_BYTES < byteCnt; i++) { /* build the counter block */ - uint64_t tmp = Skein_Swap64((uint64_t)i); - bcopy(&tmp, ctx->b, sizeof (tmp)); + *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i); Skein_Start_New_Type(ctx, OUT_FINAL); /* run "counter mode" */ Skein_256_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t)); @@ -240,7 +239,7 @@ Skein_256_Final(Skein_256_Ctxt_t *ctx, uint8_t *hashVal) Skein_Show_Final(256, &ctx->h, n, hashVal + i * SKEIN_256_BLOCK_BYTES); /* restore the counter mode key for next time */ - bcopy(X, ctx->X, sizeof (X)); + memcpy(ctx->X, X, sizeof (X)); } return (SKEIN_SUCCESS); } @@ -262,16 +261,16 @@ Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 512: - bcopy(SKEIN_512_IV_512, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_512_IV_512, sizeof (ctx->X)); break; case 384: - bcopy(SKEIN_512_IV_384, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_512_IV_384, sizeof (ctx->X)); break; case 256: - bcopy(SKEIN_512_IV_256, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_512_IV_256, sizeof (ctx->X)); break; case 224: - bcopy(SKEIN_512_IV_224, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN_512_IV_224, sizeof (ctx->X)); break; #endif default: @@ -289,11 +288,11 @@ Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) cfg.w[1] = Skein_Swap64(hashBitLen); cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* zero pad config block */ - bzero(&cfg.w[3], sizeof (cfg) - 3 * sizeof (cfg.w[0])); + memset(&cfg.w[3], 0, sizeof (cfg) - 3 * sizeof (cfg.w[0])); /* compute the initial chaining values from config block */ /* zero the chaining variables */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); Skein_512_Process_Block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN); break; } @@ -328,7 +327,7 @@ Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) { /* is there a key? */ /* no key: use all zeroes as key for config block */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); } else { /* here to pre-process a key */ Skein_assert(sizeof (cfg.b) >= sizeof (ctx->X)); @@ -338,12 +337,12 @@ Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, /* set tweaks: T0 = 0; T1 = KEY type */ Skein_Start_New_Type(ctx, KEY); /* zero the initial chaining variables */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); (void) Skein_512_Update(ctx, key, keyBytes); /* hash the key */ /* put result into cfg.b[] */ (void) Skein_512_Final_Pad(ctx, cfg.b); /* copy over into ctx->X[] */ - bcopy(cfg.b, ctx->X, sizeof (cfg.b)); + memcpy(ctx->X, cfg.b, sizeof (cfg.b)); #if SKEIN_NEED_SWAP { uint_t i; @@ -360,7 +359,7 @@ Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx, CFG_FINAL); - bzero(&cfg.w, sizeof (cfg.w)); /* pre-pad cfg.w[] with zeroes */ + memset(&cfg.w, 0, sizeof (cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ @@ -397,7 +396,7 @@ Skein_512_Update(Skein_512_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt) if (n) { /* check on our logic here */ Skein_assert(n < msgByteCnt); - bcopy(msg, &ctx->b[ctx->h.bCnt], n); + memcpy(&ctx->b[ctx->h.bCnt], msg, n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; @@ -425,7 +424,7 @@ Skein_512_Update(Skein_512_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt) /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES); - bcopy(msg, &ctx->b[ctx->h.bCnt], msgByteCnt); + memcpy(&ctx->b[ctx->h.bCnt], msg, msgByteCnt); ctx->h.bCnt += msgByteCnt; } @@ -445,7 +444,7 @@ Skein_512_Final(Skein_512_Ctxt_t *ctx, uint8_t *hashVal) ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ /* zero pad b[] if necessary */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) - bzero(&ctx->b[ctx->h.bCnt], + memset(&ctx->b[ctx->h.bCnt], 0, SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); /* process the final block */ @@ -457,13 +456,12 @@ Skein_512_Final(Skein_512_Ctxt_t *ctx, uint8_t *hashVal) /* run Threefish in "counter mode" to generate output */ /* zero out b[], so it can hold the counter */ - bzero(ctx->b, sizeof (ctx->b)); + memset(ctx->b, 0, sizeof (ctx->b)); /* keep a local copy of counter mode "key" */ - bcopy(ctx->X, X, sizeof (X)); + memcpy(X, ctx->X, sizeof (X)); for (i = 0; i * SKEIN_512_BLOCK_BYTES < byteCnt; i++) { /* build the counter block */ - uint64_t tmp = Skein_Swap64((uint64_t)i); - bcopy(&tmp, ctx->b, sizeof (tmp)); + *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i); Skein_Start_New_Type(ctx, OUT_FINAL); /* run "counter mode" */ Skein_512_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t)); @@ -476,7 +474,7 @@ Skein_512_Final(Skein_512_Ctxt_t *ctx, uint8_t *hashVal) Skein_Show_Final(512, &ctx->h, n, hashVal + i * SKEIN_512_BLOCK_BYTES); /* restore the counter mode key for next time */ - bcopy(X, ctx->X, sizeof (X)); + memcpy(ctx->X, X, sizeof (X)); } return (SKEIN_SUCCESS); } @@ -498,13 +496,13 @@ Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 512: - bcopy(SKEIN1024_IV_512, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN1024_IV_512, sizeof (ctx->X)); break; case 384: - bcopy(SKEIN1024_IV_384, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN1024_IV_384, sizeof (ctx->X)); break; case 1024: - bcopy(SKEIN1024_IV_1024, ctx->X, sizeof (ctx->X)); + memcpy(ctx->X, SKEIN1024_IV_1024, sizeof (ctx->X)); break; #endif default: @@ -522,11 +520,11 @@ Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) cfg.w[1] = Skein_Swap64(hashBitLen); cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* zero pad config block */ - bzero(&cfg.w[3], sizeof (cfg) - 3 * sizeof (cfg.w[0])); + memset(&cfg.w[3], 0, sizeof (cfg) - 3 * sizeof (cfg.w[0])); /* compute the initial chaining values from config block */ /* zero the chaining variables */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); Skein1024_Process_Block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN); break; } @@ -561,7 +559,7 @@ Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) { /* is there a key? */ /* no key: use all zeroes as key for config block */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); } else { /* here to pre-process a key */ Skein_assert(sizeof (cfg.b) >= sizeof (ctx->X)); /* do a mini-Init right here */ @@ -570,12 +568,12 @@ Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, /* set tweaks: T0 = 0; T1 = KEY type */ Skein_Start_New_Type(ctx, KEY); /* zero the initial chaining variables */ - bzero(ctx->X, sizeof (ctx->X)); + memset(ctx->X, 0, sizeof (ctx->X)); (void) Skein1024_Update(ctx, key, keyBytes); /* hash the key */ /* put result into cfg.b[] */ (void) Skein1024_Final_Pad(ctx, cfg.b); /* copy over into ctx->X[] */ - bcopy(cfg.b, ctx->X, sizeof (cfg.b)); + memcpy(ctx->X, cfg.b, sizeof (cfg.b)); #if SKEIN_NEED_SWAP { uint_t i; @@ -592,7 +590,7 @@ Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo, ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx, CFG_FINAL); - bzero(&cfg.w, sizeof (cfg.w)); /* pre-pad cfg.w[] with zeroes */ + memset(&cfg.w, 0, sizeof (cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* hash result length in bits */ cfg.w[1] = Skein_Swap64(hashBitLen); @@ -630,7 +628,7 @@ Skein1024_Update(Skein1024_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt) if (n) { /* check on our logic here */ Skein_assert(n < msgByteCnt); - bcopy(msg, &ctx->b[ctx->h.bCnt], n); + memcpy(&ctx->b[ctx->h.bCnt], msg, n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; @@ -658,7 +656,7 @@ Skein1024_Update(Skein1024_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt) /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES); - bcopy(msg, &ctx->b[ctx->h.bCnt], msgByteCnt); + memcpy(&ctx->b[ctx->h.bCnt], msg, msgByteCnt); ctx->h.bCnt += msgByteCnt; } @@ -678,7 +676,7 @@ Skein1024_Final(Skein1024_Ctxt_t *ctx, uint8_t *hashVal) ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ /* zero pad b[] if necessary */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) - bzero(&ctx->b[ctx->h.bCnt], + memset(&ctx->b[ctx->h.bCnt], 0, SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); /* process the final block */ @@ -690,13 +688,12 @@ Skein1024_Final(Skein1024_Ctxt_t *ctx, uint8_t *hashVal) /* run Threefish in "counter mode" to generate output */ /* zero out b[], so it can hold the counter */ - bzero(ctx->b, sizeof (ctx->b)); + memset(ctx->b, 0, sizeof (ctx->b)); /* keep a local copy of counter mode "key" */ - bcopy(ctx->X, X, sizeof (X)); + memcpy(X, ctx->X, sizeof (X)); for (i = 0; i * SKEIN1024_BLOCK_BYTES < byteCnt; i++) { /* build the counter block */ - uint64_t tmp = Skein_Swap64((uint64_t)i); - bcopy(&tmp, ctx->b, sizeof (tmp)); + *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i); Skein_Start_New_Type(ctx, OUT_FINAL); /* run "counter mode" */ Skein1024_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t)); @@ -709,7 +706,7 @@ Skein1024_Final(Skein1024_Ctxt_t *ctx, uint8_t *hashVal) Skein_Show_Final(1024, &ctx->h, n, hashVal + i * SKEIN1024_BLOCK_BYTES); /* restore the counter mode key for next time */ - bcopy(X, ctx->X, sizeof (X)); + memcpy(ctx->X, X, sizeof (X)); } return (SKEIN_SUCCESS); } @@ -727,7 +724,7 @@ Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, uint8_t *hashVal) ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ /* zero pad b[] if necessary */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) - bzero(&ctx->b[ctx->h.bCnt], + memset(&ctx->b[ctx->h.bCnt], 0, SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); /* process the final block */ Skein_256_Process_Block(ctx, ctx->b, 1, ctx->h.bCnt); @@ -748,7 +745,7 @@ Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, uint8_t *hashVal) ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ /* zero pad b[] if necessary */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) - bzero(&ctx->b[ctx->h.bCnt], + memset(&ctx->b[ctx->h.bCnt], 0, SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); /* process the final block */ Skein_512_Process_Block(ctx, ctx->b, 1, ctx->h.bCnt); @@ -770,7 +767,7 @@ Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, uint8_t *hashVal) ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* zero pad b[] if necessary */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) - bzero(&ctx->b[ctx->h.bCnt], + memset(&ctx->b[ctx->h.bCnt], 0, SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); /* process the final block */ Skein1024_Process_Block(ctx, ctx->b, 1, ctx->h.bCnt); @@ -798,13 +795,12 @@ Skein_256_Output(Skein_256_Ctxt_t *ctx, uint8_t *hashVal) /* run Threefish in "counter mode" to generate output */ /* zero out b[], so it can hold the counter */ - bzero(ctx->b, sizeof (ctx->b)); + memset(ctx->b, 0, sizeof (ctx->b)); /* keep a local copy of counter mode "key" */ - bcopy(ctx->X, X, sizeof (X)); + memcpy(X, ctx->X, sizeof (X)); for (i = 0; i * SKEIN_256_BLOCK_BYTES < byteCnt; i++) { /* build the counter block */ - uint64_t tmp = Skein_Swap64((uint64_t)i); - bcopy(&tmp, ctx->b, sizeof (tmp)); + *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i); Skein_Start_New_Type(ctx, OUT_FINAL); /* run "counter mode" */ Skein_256_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t)); @@ -817,7 +813,7 @@ Skein_256_Output(Skein_256_Ctxt_t *ctx, uint8_t *hashVal) Skein_Show_Final(256, &ctx->h, n, hashVal + i * SKEIN_256_BLOCK_BYTES); /* restore the counter mode key for next time */ - bcopy(X, ctx->X, sizeof (X)); + memcpy(ctx->X, X, sizeof (X)); } return (SKEIN_SUCCESS); } @@ -838,13 +834,12 @@ Skein_512_Output(Skein_512_Ctxt_t *ctx, uint8_t *hashVal) /* run Threefish in "counter mode" to generate output */ /* zero out b[], so it can hold the counter */ - bzero(ctx->b, sizeof (ctx->b)); + memset(ctx->b, 0, sizeof (ctx->b)); /* keep a local copy of counter mode "key" */ - bcopy(ctx->X, X, sizeof (X)); + memcpy(X, ctx->X, sizeof (X)); for (i = 0; i * SKEIN_512_BLOCK_BYTES < byteCnt; i++) { /* build the counter block */ - uint64_t tmp = Skein_Swap64((uint64_t)i); - bcopy(&tmp, ctx->b, sizeof (tmp)); + *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i); Skein_Start_New_Type(ctx, OUT_FINAL); /* run "counter mode" */ Skein_512_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t)); @@ -857,7 +852,7 @@ Skein_512_Output(Skein_512_Ctxt_t *ctx, uint8_t *hashVal) Skein_Show_Final(256, &ctx->h, n, hashVal + i * SKEIN_512_BLOCK_BYTES); /* restore the counter mode key for next time */ - bcopy(X, ctx->X, sizeof (X)); + memcpy(ctx->X, X, sizeof (X)); } return (SKEIN_SUCCESS); } @@ -878,13 +873,12 @@ Skein1024_Output(Skein1024_Ctxt_t *ctx, uint8_t *hashVal) /* run Threefish in "counter mode" to generate output */ /* zero out b[], so it can hold the counter */ - bzero(ctx->b, sizeof (ctx->b)); + memset(ctx->b, 0, sizeof (ctx->b)); /* keep a local copy of counter mode "key" */ - bcopy(ctx->X, X, sizeof (X)); + memcpy(X, ctx->X, sizeof (X)); for (i = 0; i * SKEIN1024_BLOCK_BYTES < byteCnt; i++) { /* build the counter block */ - uint64_t tmp = Skein_Swap64((uint64_t)i); - bcopy(&tmp, ctx->b, sizeof (tmp)); + *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i); Skein_Start_New_Type(ctx, OUT_FINAL); /* run "counter mode" */ Skein1024_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t)); @@ -897,7 +891,7 @@ Skein1024_Output(Skein1024_Ctxt_t *ctx, uint8_t *hashVal) Skein_Show_Final(256, &ctx->h, n, hashVal + i * SKEIN1024_BLOCK_BYTES); /* restore the counter mode key for next time */ - bcopy(X, ctx->X, sizeof (X)); + memcpy(ctx->X, X, sizeof (X)); } return (SKEIN_SUCCESS); } diff --git a/sys/contrib/openzfs/module/icp/algs/skein/skein_impl.h b/sys/contrib/openzfs/module/icp/algs/skein/skein_impl.h index 1fa249e95e4..eff19ce83f8 100644 --- a/sys/contrib/openzfs/module/icp/algs/skein/skein_impl.h +++ b/sys/contrib/openzfs/module/icp/algs/skein/skein_impl.h @@ -25,7 +25,7 @@ #define _SKEIN_IMPL_H_ #include -#include +#include #include "skein_impl.h" #include "skein_port.h" diff --git a/sys/contrib/openzfs/module/icp/algs/skein/skein_port.h b/sys/contrib/openzfs/module/icp/algs/skein/skein_port.h index ce435308255..96d1266d019 100644 --- a/sys/contrib/openzfs/module/icp/algs/skein/skein_port.h +++ b/sys/contrib/openzfs/module/icp/algs/skein/skein_port.h @@ -50,9 +50,9 @@ #else /* here for x86 and x86-64 CPUs (and other detected little-endian CPUs) */ #define SKEIN_NEED_SWAP (0) -#define Skein_Put64_LSB_First(dst08, src64, bCnt) bcopy(src64, dst08, bCnt) +#define Skein_Put64_LSB_First(dst08, src64, bCnt) memcpy(dst08, src64, bCnt) #define Skein_Get64_LSB_First(dst64, src08, wCnt) \ - bcopy(src08, dst64, 8 * (wCnt)) + memcpy(dst64, src08, 8 * (wCnt)) #endif #endif /* ifndef SKEIN_NEED_SWAP */ diff --git a/sys/contrib/openzfs/module/icp/api/kcf_ctxops.c b/sys/contrib/openzfs/module/icp/api/kcf_ctxops.c index 67bf76a8f1f..25ed94fe8bd 100644 --- a/sys/contrib/openzfs/module/icp/api/kcf_ctxops.c +++ b/sys/contrib/openzfs/module/icp/api/kcf_ctxops.c @@ -138,7 +138,7 @@ crypto_destroy_ctx_template(crypto_ctx_template_t tmpl) ASSERT(ctx_tmpl->ct_prov_tmpl != NULL); - bzero(ctx_tmpl->ct_prov_tmpl, ctx_tmpl->ct_size); + memset(ctx_tmpl->ct_prov_tmpl, 0, ctx_tmpl->ct_size); kmem_free(ctx_tmpl->ct_prov_tmpl, ctx_tmpl->ct_size); kmem_free(ctx_tmpl, sizeof (kcf_ctx_template_t)); } diff --git a/sys/contrib/openzfs/module/icp/core/kcf_mech_tabs.c b/sys/contrib/openzfs/module/icp/core/kcf_mech_tabs.c index 347190aa7f8..ec43d53dc3f 100644 --- a/sys/contrib/openzfs/module/icp/core/kcf_mech_tabs.c +++ b/sys/contrib/openzfs/module/icp/core/kcf_mech_tabs.c @@ -250,7 +250,8 @@ kcf_add_mech_provider(short mech_indx, /* allocate and initialize new kcf_prov_mech_desc */ prov_mech = kmem_zalloc(sizeof (kcf_prov_mech_desc_t), KM_SLEEP); - bcopy(mech_info, &prov_mech->pm_mech_info, sizeof (crypto_mech_info_t)); + memcpy(&prov_mech->pm_mech_info, mech_info, + sizeof (crypto_mech_info_t)); prov_mech->pm_prov_desc = prov_desc; prov_desc->pd_mech_indx[KCF_MECH2CLASS(kcf_mech_type)] [KCF_MECH2INDEX(kcf_mech_type)] = mech_indx; diff --git a/sys/contrib/openzfs/module/icp/core/kcf_prov_lib.c b/sys/contrib/openzfs/module/icp/core/kcf_prov_lib.c index 505dbec313d..4bc99a8eb84 100644 --- a/sys/contrib/openzfs/module/icp/core/kcf_prov_lib.c +++ b/sys/contrib/openzfs/module/icp/core/kcf_prov_lib.c @@ -70,7 +70,7 @@ crypto_uio_copy_to_data(crypto_data_t *data, uchar_t *buf, int len) offset, length); datap = (uchar_t *)(zfs_uio_iovbase(uiop, vec_idx) + offset); - bcopy(buf, datap, cur_len); + memcpy(datap, buf, cur_len); buf += cur_len; length -= cur_len; @@ -99,8 +99,8 @@ crypto_put_output_data(uchar_t *buf, crypto_data_t *output, int len) output->cd_length = len; return (CRYPTO_BUFFER_TOO_SMALL); } - bcopy(buf, (uchar_t *)(output->cd_raw.iov_base + - output->cd_offset), len); + memcpy((uchar_t *)(output->cd_raw.iov_base + + output->cd_offset), buf, len); break; case CRYPTO_DATA_UIO: diff --git a/sys/contrib/openzfs/module/icp/io/aes.c b/sys/contrib/openzfs/module/icp/io/aes.c index b0f51262dd0..945d560ebe5 100644 --- a/sys/contrib/openzfs/module/icp/io/aes.c +++ b/sys/contrib/openzfs/module/icp/io/aes.c @@ -832,7 +832,7 @@ aes_encrypt_atomic(crypto_mechanism_t *mechanism, crypto_key_t *key, crypto_data_t *plaintext, crypto_data_t *ciphertext, crypto_spi_ctx_template_t template) { - aes_ctx_t aes_ctx; /* on the stack */ + aes_ctx_t aes_ctx = {{{{0}}}}; off_t saved_offset; size_t saved_length; size_t length_needed; @@ -858,8 +858,6 @@ aes_encrypt_atomic(crypto_mechanism_t *mechanism, if ((ret = aes_check_mech_param(mechanism, NULL)) != CRYPTO_SUCCESS) return (ret); - bzero(&aes_ctx, sizeof (aes_ctx_t)); - ret = aes_common_init_ctx(&aes_ctx, template, mechanism, key, KM_SLEEP, B_TRUE); if (ret != CRYPTO_SUCCESS) @@ -944,7 +942,7 @@ aes_encrypt_atomic(crypto_mechanism_t *mechanism, out: if (aes_ctx.ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) { - bzero(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len); + memset(aes_ctx.ac_keysched, 0, aes_ctx.ac_keysched_len); kmem_free(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len); } #ifdef CAN_USE_GCM_ASM @@ -953,7 +951,7 @@ out: gcm_ctx_t *ctx = (gcm_ctx_t *)&aes_ctx; - bzero(ctx->gcm_Htable, ctx->gcm_htab_len); + memset(ctx->gcm_Htable, 0, ctx->gcm_htab_len); kmem_free(ctx->gcm_Htable, ctx->gcm_htab_len); } #endif @@ -966,7 +964,7 @@ aes_decrypt_atomic(crypto_mechanism_t *mechanism, crypto_key_t *key, crypto_data_t *ciphertext, crypto_data_t *plaintext, crypto_spi_ctx_template_t template) { - aes_ctx_t aes_ctx; /* on the stack */ + aes_ctx_t aes_ctx = {{{{0}}}}; off_t saved_offset; size_t saved_length; size_t length_needed; @@ -992,8 +990,6 @@ aes_decrypt_atomic(crypto_mechanism_t *mechanism, if ((ret = aes_check_mech_param(mechanism, NULL)) != CRYPTO_SUCCESS) return (ret); - bzero(&aes_ctx, sizeof (aes_ctx_t)); - ret = aes_common_init_ctx(&aes_ctx, template, mechanism, key, KM_SLEEP, B_FALSE); if (ret != CRYPTO_SUCCESS) @@ -1096,7 +1092,7 @@ aes_decrypt_atomic(crypto_mechanism_t *mechanism, out: if (aes_ctx.ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) { - bzero(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len); + memset(aes_ctx.ac_keysched, 0, aes_ctx.ac_keysched_len); kmem_free(aes_ctx.ac_keysched, aes_ctx.ac_keysched_len); } @@ -1113,7 +1109,7 @@ out: if (((gcm_ctx_t *)&aes_ctx)->gcm_Htable != NULL) { gcm_ctx_t *ctx = (gcm_ctx_t *)&aes_ctx; - bzero(ctx->gcm_Htable, ctx->gcm_htab_len); + memset(ctx->gcm_Htable, 0, ctx->gcm_htab_len); kmem_free(ctx->gcm_Htable, ctx->gcm_htab_len); } #endif @@ -1150,7 +1146,7 @@ aes_create_ctx_template(crypto_mechanism_t *mechanism, crypto_key_t *key, * in the key. */ if ((rv = init_keysched(key, keysched)) != CRYPTO_SUCCESS) { - bzero(keysched, size); + memset(keysched, 0, size); kmem_free(keysched, size); return (rv); } @@ -1170,7 +1166,8 @@ aes_free_context(crypto_ctx_t *ctx) if (aes_ctx != NULL) { if (aes_ctx->ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) { ASSERT(aes_ctx->ac_keysched_len != 0); - bzero(aes_ctx->ac_keysched, aes_ctx->ac_keysched_len); + memset(aes_ctx->ac_keysched, 0, + aes_ctx->ac_keysched_len); kmem_free(aes_ctx->ac_keysched, aes_ctx->ac_keysched_len); } @@ -1260,7 +1257,7 @@ aes_common_init_ctx(aes_ctx_t *aes_ctx, crypto_spi_ctx_template_t *template, if (rv != CRYPTO_SUCCESS) { if (aes_ctx->ac_flags & PROVIDER_OWNS_KEY_SCHEDULE) { - bzero(keysched, size); + memset(keysched, 0, size); kmem_free(keysched, size); } } diff --git a/sys/contrib/openzfs/module/icp/io/sha2_mod.c b/sys/contrib/openzfs/module/icp/io/sha2_mod.c index c586c327264..4a218b50032 100644 --- a/sys/contrib/openzfs/module/icp/io/sha2_mod.c +++ b/sys/contrib/openzfs/module/icp/io/sha2_mod.c @@ -46,7 +46,7 @@ (len) = (uint32_t)*((ulong_t *)(m)->cm_param); \ else { \ ulong_t tmp_ulong; \ - bcopy((m)->cm_param, &tmp_ulong, sizeof (ulong_t)); \ + memcpy(&tmp_ulong, (m)->cm_param, sizeof (ulong_t)); \ (len) = (uint32_t)tmp_ulong; \ } \ } @@ -309,9 +309,9 @@ sha2_digest_final_uio(SHA2_CTX *sha2_ctx, crypto_data_t *digest, */ SHA2Final(digest_scratch, sha2_ctx); - bcopy(digest_scratch, (uchar_t *) + memcpy((uchar_t *) zfs_uio_iovbase(digest->cd_uio, vec_idx) + offset, - digest_len); + digest_scratch, digest_len); } else { SHA2Final((uchar_t *)zfs_uio_iovbase(digest-> cd_uio, vec_idx) + offset, @@ -336,8 +336,9 @@ sha2_digest_final_uio(SHA2_CTX *sha2_ctx, crypto_data_t *digest, cur_len = MIN(zfs_uio_iovlen(digest->cd_uio, vec_idx) - offset, length); - bcopy(digest_tmp + scratch_offset, + memcpy( zfs_uio_iovbase(digest->cd_uio, vec_idx) + offset, + digest_tmp + scratch_offset, cur_len); length -= cur_len; @@ -630,8 +631,8 @@ sha2_digest_atomic(crypto_mechanism_t *mechanism, crypto_data_t *data, static void sha2_mac_init_ctx(sha2_hmac_ctx_t *ctx, void *keyval, uint_t length_in_bytes) { - uint64_t ipad[SHA512_HMAC_BLOCK_SIZE / sizeof (uint64_t)]; - uint64_t opad[SHA512_HMAC_BLOCK_SIZE / sizeof (uint64_t)]; + uint64_t ipad[SHA512_HMAC_BLOCK_SIZE / sizeof (uint64_t)] = {0}; + uint64_t opad[SHA512_HMAC_BLOCK_SIZE / sizeof (uint64_t)] = {0}; int i, block_size, blocks_per_int64; /* Determine the block size */ @@ -643,12 +644,12 @@ sha2_mac_init_ctx(sha2_hmac_ctx_t *ctx, void *keyval, uint_t length_in_bytes) blocks_per_int64 = SHA512_HMAC_BLOCK_SIZE / sizeof (uint64_t); } - (void) bzero(ipad, block_size); - (void) bzero(opad, block_size); + (void) memset(ipad, 0, block_size); + (void) memset(opad, 0, block_size); if (keyval != NULL) { - (void) bcopy(keyval, ipad, length_in_bytes); - (void) bcopy(keyval, opad, length_in_bytes); + (void) memcpy(ipad, keyval, length_in_bytes); + (void) memcpy(opad, keyval, length_in_bytes); } else { ASSERT0(length_in_bytes); } @@ -666,7 +667,6 @@ sha2_mac_init_ctx(sha2_hmac_ctx_t *ctx, void *keyval, uint_t length_in_bytes) /* perform SHA2 on opad */ SHA2Init(ctx->hc_mech_type, &ctx->hc_ocontext); SHA2Update(&ctx->hc_ocontext, (uint8_t *)opad, block_size); - } /* @@ -708,7 +708,7 @@ sha2_mac_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism, PROV_SHA2_HMAC_CTX(ctx)->hc_mech_type = mechanism->cm_type; if (ctx_template != NULL) { /* reuse context template */ - bcopy(ctx_template, PROV_SHA2_HMAC_CTX(ctx), + memcpy(PROV_SHA2_HMAC_CTX(ctx), ctx_template, sizeof (sha2_hmac_ctx_t)); } else { /* no context template, compute context */ @@ -746,7 +746,7 @@ sha2_mac_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism, } if (ret != CRYPTO_SUCCESS) { - bzero(ctx->cc_provider_private, sizeof (sha2_hmac_ctx_t)); + memset(ctx->cc_provider_private, 0, sizeof (sha2_hmac_ctx_t)); kmem_free(ctx->cc_provider_private, sizeof (sha2_hmac_ctx_t)); ctx->cc_provider_private = NULL; } @@ -850,8 +850,8 @@ sha2_mac_final(crypto_ctx_t *ctx, crypto_data_t *mac) */ SHA2Final(digest, &PROV_SHA2_HMAC_CTX(ctx)->hc_ocontext); - bcopy(digest, (unsigned char *)mac->cd_raw.iov_base + - mac->cd_offset, digest_len); + memcpy((unsigned char *)mac->cd_raw.iov_base + + mac->cd_offset, digest, digest_len); } else { SHA2Final((unsigned char *)mac->cd_raw.iov_base + mac->cd_offset, @@ -872,7 +872,7 @@ sha2_mac_final(crypto_ctx_t *ctx, crypto_data_t *mac) else mac->cd_length = 0; - bzero(ctx->cc_provider_private, sizeof (sha2_hmac_ctx_t)); + memset(ctx->cc_provider_private, 0, sizeof (sha2_hmac_ctx_t)); kmem_free(ctx->cc_provider_private, sizeof (sha2_hmac_ctx_t)); ctx->cc_provider_private = NULL; @@ -928,7 +928,7 @@ sha2_mac_atomic(crypto_mechanism_t *mechanism, if (ctx_template != NULL) { /* reuse context template */ - bcopy(ctx_template, &sha2_hmac_ctx, sizeof (sha2_hmac_ctx_t)); + memcpy(&sha2_hmac_ctx, ctx_template, sizeof (sha2_hmac_ctx_t)); } else { sha2_hmac_ctx.hc_mech_type = mechanism->cm_type; /* no context template, initialize context */ @@ -1001,8 +1001,8 @@ sha2_mac_atomic(crypto_mechanism_t *mechanism, * the user only what was requested. */ SHA2Final(digest, &sha2_hmac_ctx.hc_ocontext); - bcopy(digest, (unsigned char *)mac->cd_raw.iov_base + - mac->cd_offset, digest_len); + memcpy((unsigned char *)mac->cd_raw.iov_base + + mac->cd_offset, digest, digest_len); } else { SHA2Final((unsigned char *)mac->cd_raw.iov_base + mac->cd_offset, &sha2_hmac_ctx.hc_ocontext); @@ -1021,7 +1021,7 @@ sha2_mac_atomic(crypto_mechanism_t *mechanism, return (CRYPTO_SUCCESS); } bail: - bzero(&sha2_hmac_ctx, sizeof (sha2_hmac_ctx_t)); + memset(&sha2_hmac_ctx, 0, sizeof (sha2_hmac_ctx_t)); mac->cd_length = 0; return (ret); } @@ -1060,7 +1060,7 @@ sha2_mac_verify_atomic(crypto_mechanism_t *mechanism, if (ctx_template != NULL) { /* reuse context template */ - bcopy(ctx_template, &sha2_hmac_ctx, sizeof (sha2_hmac_ctx_t)); + memcpy(&sha2_hmac_ctx, ctx_template, sizeof (sha2_hmac_ctx_t)); } else { sha2_hmac_ctx.hc_mech_type = mechanism->cm_type; /* no context template, initialize context */ @@ -1137,7 +1137,7 @@ sha2_mac_verify_atomic(crypto_mechanism_t *mechanism, switch (mac->cd_format) { case CRYPTO_DATA_RAW: - if (bcmp(digest, (unsigned char *)mac->cd_raw.iov_base + + if (memcmp(digest, (unsigned char *)mac->cd_raw.iov_base + mac->cd_offset, digest_len) != 0) ret = CRYPTO_INVALID_MAC; break; @@ -1170,7 +1170,7 @@ sha2_mac_verify_atomic(crypto_mechanism_t *mechanism, cur_len = MIN(zfs_uio_iovlen(mac->cd_uio, vec_idx) - offset, length); - if (bcmp(digest + scratch_offset, + if (memcmp(digest + scratch_offset, zfs_uio_iovbase(mac->cd_uio, vec_idx) + offset, cur_len) != 0) { ret = CRYPTO_INVALID_MAC; @@ -1191,7 +1191,7 @@ sha2_mac_verify_atomic(crypto_mechanism_t *mechanism, return (ret); bail: - bzero(&sha2_hmac_ctx, sizeof (sha2_hmac_ctx_t)); + memset(&sha2_hmac_ctx, 0, sizeof (sha2_hmac_ctx_t)); mac->cd_length = 0; return (ret); } @@ -1282,7 +1282,7 @@ sha2_free_context(crypto_ctx_t *ctx) else ctx_len = sizeof (sha2_hmac_ctx_t); - bzero(ctx->cc_provider_private, ctx_len); + memset(ctx->cc_provider_private, 0, ctx_len); kmem_free(ctx->cc_provider_private, ctx_len); ctx->cc_provider_private = NULL; diff --git a/sys/contrib/openzfs/module/icp/io/skein_mod.c b/sys/contrib/openzfs/module/icp/io/skein_mod.c index 1d6969e6886..a2ed6cedd8c 100644 --- a/sys/contrib/openzfs/module/icp/io/skein_mod.c +++ b/sys/contrib/openzfs/module/icp/io/skein_mod.c @@ -292,8 +292,8 @@ skein_digest_final_uio(skein_ctx_t *ctx, crypto_data_t *digest) while (vec_idx < zfs_uio_iovcnt(uio) && length > 0) { cur_len = MIN(zfs_uio_iovlen(uio, vec_idx) - offset, length); - bcopy(digest_tmp + scratch_offset, - zfs_uio_iovbase(uio, vec_idx) + offset, cur_len); + memcpy(zfs_uio_iovbase(uio, vec_idx) + offset, + digest_tmp + scratch_offset, cur_len); length -= cur_len; vec_idx++; @@ -349,7 +349,7 @@ skein_digest_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism) return (CRYPTO_SUCCESS); errout: - bzero(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); + memset(SKEIN_CTX(ctx), 0, sizeof (*SKEIN_CTX(ctx))); kmem_free(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); SKEIN_CTX_LVALUE(ctx) = NULL; return (error); @@ -376,7 +376,7 @@ skein_digest(crypto_ctx_t *ctx, crypto_data_t *data, crypto_data_t *digest) error = skein_update(ctx, data); if (error != CRYPTO_SUCCESS) { - bzero(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); + memset(SKEIN_CTX(ctx), 0, sizeof (*SKEIN_CTX(ctx))); kmem_free(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); SKEIN_CTX_LVALUE(ctx) = NULL; digest->cd_length = 0; @@ -452,7 +452,7 @@ skein_final(crypto_ctx_t *ctx, crypto_data_t *digest) else digest->cd_length = 0; - bzero(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); + memset(SKEIN_CTX(ctx), 0, sizeof (*SKEIN_CTX(ctx))); kmem_free(SKEIN_CTX(ctx), sizeof (*(SKEIN_CTX(ctx)))); SKEIN_CTX_LVALUE(ctx) = NULL; @@ -494,7 +494,7 @@ out: CRYPTO_BITS2BYTES(skein_ctx.sc_digest_bitlen); else digest->cd_length = 0; - bzero(&skein_ctx, sizeof (skein_ctx)); + memset(&skein_ctx, 0, sizeof (skein_ctx)); return (error); } @@ -543,7 +543,7 @@ skein_mac_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism, return (CRYPTO_HOST_MEMORY); if (ctx_template != NULL) { - bcopy(ctx_template, SKEIN_CTX(ctx), + memcpy(SKEIN_CTX(ctx), ctx_template, sizeof (*SKEIN_CTX(ctx))); } else { error = skein_mac_ctx_build(SKEIN_CTX(ctx), mechanism, key); @@ -553,7 +553,7 @@ skein_mac_init(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism, return (CRYPTO_SUCCESS); errout: - bzero(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); + memset(SKEIN_CTX(ctx), 0, sizeof (*SKEIN_CTX(ctx))); kmem_free(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); return (error); } @@ -573,13 +573,13 @@ skein_mac_atomic(crypto_mechanism_t *mechanism, crypto_spi_ctx_template_t ctx_template) { /* faux crypto context just for skein_digest_{update,final} */ - int error; + int error; crypto_ctx_t ctx; skein_ctx_t skein_ctx; SKEIN_CTX_LVALUE(&ctx) = &skein_ctx; if (ctx_template != NULL) { - bcopy(ctx_template, &skein_ctx, sizeof (skein_ctx)); + memcpy(&skein_ctx, ctx_template, sizeof (skein_ctx)); } else { error = skein_mac_ctx_build(&skein_ctx, mechanism, key); if (error != CRYPTO_SUCCESS) @@ -593,7 +593,7 @@ skein_mac_atomic(crypto_mechanism_t *mechanism, return (CRYPTO_SUCCESS); errout: - bzero(&skein_ctx, sizeof (skein_ctx)); + memset(&skein_ctx, 0, sizeof (skein_ctx)); return (error); } @@ -624,7 +624,7 @@ skein_create_ctx_template(crypto_mechanism_t *mechanism, crypto_key_t *key, return (CRYPTO_SUCCESS); errout: - bzero(ctx_tmpl, sizeof (*ctx_tmpl)); + memset(ctx_tmpl, 0, sizeof (*ctx_tmpl)); kmem_free(ctx_tmpl, sizeof (*ctx_tmpl)); return (error); } @@ -636,7 +636,7 @@ static int skein_free_context(crypto_ctx_t *ctx) { if (SKEIN_CTX(ctx) != NULL) { - bzero(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); + memset(SKEIN_CTX(ctx), 0, sizeof (*SKEIN_CTX(ctx))); kmem_free(SKEIN_CTX(ctx), sizeof (*SKEIN_CTX(ctx))); SKEIN_CTX_LVALUE(ctx) = NULL; } diff --git a/sys/contrib/openzfs/module/lua/ldo.c b/sys/contrib/openzfs/module/lua/ldo.c index 2ee9f665d77..727757f7d72 100644 --- a/sys/contrib/openzfs/module/lua/ldo.c +++ b/sys/contrib/openzfs/module/lua/ldo.c @@ -91,7 +91,7 @@ static intptr_t stack_remaining(void) { typedef struct _label_t { long long unsigned val[JMP_BUF_CNT]; } label_t; int setjmp(label_t *) __attribute__ ((__nothrow__)); -extern _Noreturn void longjmp(label_t *); +extern __attribute__((noreturn)) void longjmp(label_t *); #define LUAI_THROW(L,c) longjmp(&(c)->b) #define LUAI_TRY(L,c,a) if (setjmp(&(c)->b) == 0) { a } diff --git a/sys/contrib/openzfs/module/nvpair/nvpair.c b/sys/contrib/openzfs/module/nvpair/nvpair.c index b4463dd7308..a5222dac784 100644 --- a/sys/contrib/openzfs/module/nvpair/nvpair.c +++ b/sys/contrib/openzfs/module/nvpair/nvpair.c @@ -40,7 +40,7 @@ #include #include #include -#include +#include #include #include @@ -53,7 +53,7 @@ #include #endif -#define skip_whitespace(p) while ((*(p) == ' ') || (*(p) == '\t')) p++ +#define skip_whitespace(p) while ((*(p) == ' ') || (*(p) == '\t')) (p)++ /* * nvpair.c - Provides kernel & userland interfaces for manipulating @@ -203,7 +203,7 @@ nv_mem_zalloc(nvpriv_t *nvp, size_t size) void *buf; if ((buf = nva->nva_ops->nv_ao_alloc(nva, size)) != NULL) - bzero(buf, size); + memset(buf, 0, size); return (buf); } @@ -219,7 +219,7 @@ nv_mem_free(nvpriv_t *nvp, void *buf, size_t size) static void nv_priv_init(nvpriv_t *priv, nv_alloc_t *nva, uint32_t stat) { - bzero(priv, sizeof (nvpriv_t)); + memset(priv, 0, sizeof (nvpriv_t)); priv->nvp_nva = nva; priv->nvp_stat = stat; @@ -1203,7 +1203,7 @@ nvlist_add_common(nvlist_t *nvl, const char *name, nvp->nvp_name_sz = name_sz; nvp->nvp_value_elem = nelem; nvp->nvp_type = type; - bcopy(name, NVP_NAME(nvp), name_sz); + memcpy(NVP_NAME(nvp), name, name_sz); switch (type) { case DATA_TYPE_BOOLEAN: @@ -1217,7 +1217,7 @@ nvlist_add_common(nvlist_t *nvl, const char *name, buf += nelem * sizeof (uint64_t); for (i = 0; i < nelem; i++) { int slen = strlen(strs[i]) + 1; - bcopy(strs[i], buf, slen); + memcpy(buf, strs[i], slen); cstrs[i] = buf; buf += slen; } @@ -1255,7 +1255,7 @@ nvlist_add_common(nvlist_t *nvl, const char *name, break; } default: - bcopy(data, NVP_VALUE(nvp), value_sz); + memcpy(NVP_VALUE(nvp), data, value_sz); } /* if unique name, remove before add */ @@ -1588,7 +1588,7 @@ nvpair_value_common(const nvpair_t *nvp, data_type_t type, uint_t *nelem, return (EINVAL); if ((value_sz = i_get_value_size(type, NULL, 1)) < 0) return (EINVAL); - bcopy(NVP_VALUE(nvp), data, (size_t)value_sz); + memcpy(data, NVP_VALUE(nvp), (size_t)value_sz); if (nelem != NULL) *nelem = 1; break; @@ -2540,7 +2540,7 @@ nvs_embedded_nvl_array(nvstream_t *nvs, nvpair_t *nvp, size_t *size) size_t len = nelem * sizeof (uint64_t); nvlist_t *embedded = (nvlist_t *)((uintptr_t)nvlp + len); - bzero(nvlp, len); /* don't trust packed data */ + memset(nvlp, 0, len); /* don't trust packed data */ for (i = 0; i < nelem; i++) { if (nvs_embedded(nvs, embedded) != 0) { nvpair_free(nvp); @@ -2820,15 +2820,15 @@ native_cp(nvstream_t *nvs, void *buf, size_t size) return (EFAULT); /* - * The bcopy() below eliminates alignment requirement + * The memcpy() below eliminates alignment requirement * on the buffer (stream) and is preferred over direct access. */ switch (nvs->nvs_op) { case NVS_OP_ENCODE: - bcopy(buf, native->n_curr, size); + memcpy(native->n_curr, buf, size); break; case NVS_OP_DECODE: - bcopy(native->n_curr, buf, size); + memcpy(buf, native->n_curr, size); break; default: return (EINVAL); @@ -2895,7 +2895,7 @@ nvs_native_nvl_fini(nvstream_t *nvs) if (native->n_curr + sizeof (int) > native->n_end) return (EFAULT); - bzero(native->n_curr, sizeof (int)); + memset(native->n_curr, 0, sizeof (int)); native->n_curr += sizeof (int); } @@ -2912,10 +2912,10 @@ nvpair_native_embedded(nvstream_t *nvs, nvpair_t *nvp) /* * Null out the pointer that is meaningless in the packed * structure. The address may not be aligned, so we have - * to use bzero. + * to use memset. */ - bzero((char *)packed + offsetof(nvlist_t, nvl_priv), - sizeof (uint64_t)); + memset((char *)packed + offsetof(nvlist_t, nvl_priv), + 0, sizeof (uint64_t)); } return (nvs_embedded(nvs, EMBEDDED_NVL(nvp))); @@ -2933,18 +2933,18 @@ nvpair_native_embedded_array(nvstream_t *nvs, nvpair_t *nvp) /* * Null out pointers that are meaningless in the packed * structure. The addresses may not be aligned, so we have - * to use bzero. + * to use memset. */ - bzero(value, len); + memset(value, 0, len); for (i = 0; i < NVP_NELEM(nvp); i++, packed++) /* * Null out the pointer that is meaningless in the * packed structure. The address may not be aligned, - * so we have to use bzero. + * so we have to use memset. */ - bzero((char *)packed + offsetof(nvlist_t, nvl_priv), - sizeof (uint64_t)); + memset((char *)packed + offsetof(nvlist_t, nvl_priv), + 0, sizeof (uint64_t)); } return (nvs_embedded_nvl_array(nvs, nvp, NULL)); @@ -2961,9 +2961,9 @@ nvpair_native_string_array(nvstream_t *nvs, nvpair_t *nvp) /* * Null out pointers that are meaningless in the packed * structure. The addresses may not be aligned, so we have - * to use bzero. + * to use memset. */ - bzero(strp, NVP_NELEM(nvp) * sizeof (uint64_t)); + memset(strp, 0, NVP_NELEM(nvp) * sizeof (uint64_t)); break; } case NVS_OP_DECODE: { @@ -2988,9 +2988,9 @@ nvs_native_nvp_op(nvstream_t *nvs, nvpair_t *nvp) int ret = 0; /* - * We do the initial bcopy of the data before we look at + * We do the initial memcpy of the data before we look at * the nvpair type, because when we're decoding, we won't - * have the correct values for the pair until we do the bcopy. + * have the correct values for the pair until we do the memcpy. */ switch (nvs->nvs_op) { case NVS_OP_ENCODE: @@ -3086,7 +3086,7 @@ nvs_native_nvpair(nvstream_t *nvs, nvpair_t *nvp, size_t *size) /* try to read the size value from the stream */ if (native->n_curr + sizeof (int32_t) > native->n_end) return (EFAULT); - bcopy(native->n_curr, &decode_len, sizeof (int32_t)); + memcpy(&decode_len, native->n_curr, sizeof (int32_t)); /* sanity check the size value */ if (decode_len < 0 || @@ -3451,7 +3451,7 @@ nvs_xdr_nvp_op(nvstream_t *nvs, nvpair_t *nvp) int i; if (nvs->nvs_op == NVS_OP_DECODE) - bzero(buf, len); /* don't trust packed data */ + memset(buf, 0, len); /* don't trust packed data */ for (i = 0; i < nelem; i++) { if (buflen <= len) diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/acl_common.c b/sys/contrib/openzfs/module/os/freebsd/spl/acl_common.c index 7fd0e36e1ba..334a8b46398 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/acl_common.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/acl_common.c @@ -37,7 +37,6 @@ #include #include #include -#include #include #include #include @@ -738,7 +737,7 @@ out: static void acevals_init(acevals_t *vals, uid_t key) { - bzero(vals, sizeof (*vals)); + memset(vals, 0, sizeof (*vals)); vals->allowed = ACE_MASK_UNDEFINED; vals->denied = ACE_MASK_UNDEFINED; vals->mask = ACE_MASK_UNDEFINED; diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/sha256c.c b/sys/contrib/openzfs/module/os/freebsd/spl/sha256c.c index 241cf8c9ae7..52cf0df6c99 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/sha256c.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/sha256c.c @@ -301,7 +301,7 @@ SHA256_Final(unsigned char digest[static SHA256_DIGEST_LENGTH], SHA256_CTX *ctx) be32enc_vect(digest, ctx->state, SHA256_DIGEST_LENGTH); /* Clear the context state */ - explicit_bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); } /* SHA-224: ******************************************************* */ @@ -351,7 +351,7 @@ SHA224_Final(unsigned char digest[static SHA224_DIGEST_LENGTH], SHA224_CTX *ctx) be32enc_vect(digest, ctx->state, SHA224_DIGEST_LENGTH); /* Clear the context state */ - explicit_bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); } #ifdef WEAK_REFS diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/sha512c.c b/sys/contrib/openzfs/module/os/freebsd/spl/sha512c.c index 146f338f0ed..254cc21565c 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/sha512c.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/sha512c.c @@ -333,7 +333,7 @@ SHA512_Final(unsigned char digest[static SHA512_DIGEST_LENGTH], SHA512_CTX *ctx) be64enc_vect(digest, ctx->state, SHA512_DIGEST_LENGTH); /* Clear the context state */ - explicit_bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); } /* SHA-512t: ******************************************************** */ @@ -377,7 +377,7 @@ SHA512_224_Final(unsigned char digest[static SHA512_224_DIGEST_LENGTH], be64enc_vect(digest, ctx->state, SHA512_224_DIGEST_LENGTH); /* Clear the context state */ - explicit_bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); } void @@ -417,7 +417,7 @@ SHA512_256_Final(unsigned char digest[static SHA512_256_DIGEST_LENGTH], be64enc_vect(digest, ctx->state, SHA512_256_DIGEST_LENGTH); /* Clear the context state */ - explicit_bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); } /* ** SHA-384: ******************************************************** */ @@ -467,7 +467,7 @@ SHA384_Final(unsigned char digest[static SHA384_DIGEST_LENGTH], SHA384_CTX *ctx) be64enc_vect(digest, ctx->state, SHA384_DIGEST_LENGTH); /* Clear the context state */ - explicit_bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); } #if 0 diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/spl_acl.c b/sys/contrib/openzfs/module/os/freebsd/spl/spl_acl.c index 74c26d03f87..4d67cbb183e 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/spl_acl.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/spl_acl.c @@ -40,7 +40,7 @@ struct zfs2bsd { int zb_bsd; }; -struct zfs2bsd perms[] = {{ACE_READ_DATA, ACL_READ_DATA}, +static const struct zfs2bsd perms[] = {{ACE_READ_DATA, ACL_READ_DATA}, {ACE_WRITE_DATA, ACL_WRITE_DATA}, {ACE_EXECUTE, ACL_EXECUTE}, {ACE_APPEND_DATA, ACL_APPEND_DATA}, @@ -56,7 +56,7 @@ struct zfs2bsd perms[] = {{ACE_READ_DATA, ACL_READ_DATA}, {ACE_SYNCHRONIZE, ACL_SYNCHRONIZE}, {0, 0}}; -struct zfs2bsd flags[] = {{ACE_FILE_INHERIT_ACE, +static const struct zfs2bsd flags[] = {{ACE_FILE_INHERIT_ACE, ACL_ENTRY_FILE_INHERIT}, {ACE_DIRECTORY_INHERIT_ACE, ACL_ENTRY_DIRECTORY_INHERIT}, @@ -122,7 +122,7 @@ acl_from_aces(struct acl *aclp, const ace_t *aces, int nentries) return (EINVAL); } - bzero(aclp, sizeof (*aclp)); + memset(aclp, 0, sizeof (*aclp)); aclp->acl_maxcnt = ACL_MAX_ENTRIES; aclp->acl_cnt = nentries; @@ -177,7 +177,7 @@ aces_from_acl(ace_t *aces, int *nentries, const struct acl *aclp) const struct acl_entry *entry; ace_t *ace; - bzero(aces, sizeof (*aces) * aclp->acl_cnt); + memset(aces, 0, sizeof (*aces) * aclp->acl_cnt); *nentries = aclp->acl_cnt; diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/spl_sysevent.c b/sys/contrib/openzfs/module/os/freebsd/spl/spl_sysevent.c index d5d50080faf..16188c71b53 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/spl_sysevent.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/spl_sysevent.c @@ -250,7 +250,17 @@ sysevent_worker(void *arg __unused) nvlist_free(event); } } - zfs_zevent_destroy(ze); + + /* + * We avoid zfs_zevent_destroy() here because we're otherwise racing + * against fm_fini() destroying the zevent_lock. zfs_zevent_destroy() + * will currently only clear `ze->ze_zevent` from an event list then + * free `ze`, so just inline the free() here -- events have already + * been drained. + */ + VERIFY3P(ze->ze_zevent, ==, NULL); + kmem_free(ze, sizeof (zfs_zevent_t)); + kthread_exit(); } diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c b/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c index 3f4feb140d5..ff11f5d7acb 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c @@ -85,7 +85,7 @@ vfs_setmntopt(vfs_t *vfsp, const char *name, const char *arg, } else { opt->len = strlen(arg) + 1; opt->value = malloc(opt->len, M_MOUNT, M_WAITOK); - bcopy(arg, opt->value, opt->len); + memcpy(opt->value, arg, opt->len); } MNT_ILOCK(vfsp); diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/spl_zlib.c b/sys/contrib/openzfs/module/os/freebsd/spl/spl_zlib.c index fa2b0a2b690..8bd3bdedf26 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/spl_zlib.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/spl_zlib.c @@ -141,10 +141,9 @@ int z_compress_level(void *dest, size_t *destLen, const void *source, size_t sourceLen, int level) { - z_stream stream; + z_stream stream = {0}; int err; - bzero(&stream, sizeof (stream)); stream.next_in = (Byte *)source; stream.avail_in = (uInt)sourceLen; stream.next_out = dest; @@ -196,11 +195,9 @@ z_compress_level(void *dest, size_t *destLen, const void *source, int z_uncompress(void *dest, size_t *destLen, const void *source, size_t sourceLen) { - z_stream stream; + z_stream stream = {0}; int err; - bzero(&stream, sizeof (stream)); - stream.next_in = (Byte *)source; stream.avail_in = (uInt)sourceLen; stream.next_out = dest; diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/spl_zone.c b/sys/contrib/openzfs/module/os/freebsd/spl/spl_zone.c index bd3f019b2fa..658ef0bf056 100644 --- a/sys/contrib/openzfs/module/os/freebsd/spl/spl_zone.c +++ b/sys/contrib/openzfs/module/os/freebsd/spl/spl_zone.c @@ -184,7 +184,7 @@ zone_dataset_visible(const char *dataset, int *write) LIST_FOREACH(zd, head, zd_next) { len = strlen(zd->zd_dataset); if (strlen(dataset) >= len && - bcmp(dataset, zd->zd_dataset, len) == 0 && + memcmp(dataset, zd->zd_dataset, len) == 0 && (dataset[len] == '\0' || dataset[len] == '/' || dataset[len] == '@')) { if (write) @@ -206,7 +206,7 @@ zone_dataset_visible(const char *dataset, int *write) if (dataset[len - 1] == '/') len--; /* Ignore trailing slash */ if (len < strlen(zd->zd_dataset) && - bcmp(dataset, zd->zd_dataset, len) == 0 && + memcmp(dataset, zd->zd_dataset, len) == 0 && zd->zd_dataset[len] == '/') { if (write) *write = 0; diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c index 722a8898cde..5d2bae5cfeb 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c @@ -250,7 +250,7 @@ abd_alloc_zero_scatter(void) n = abd_chunkcnt_for_bytes(SPA_MAXBLOCKSIZE); abd_zero_buf = kmem_cache_alloc(abd_chunk_cache, KM_PUSHPAGE); - bzero(abd_zero_buf, PAGE_SIZE); + memset(abd_zero_buf, 0, PAGE_SIZE); abd_zero_scatter = abd_alloc_struct(SPA_MAXBLOCKSIZE); abd_zero_scatter->abd_flags |= ABD_FLAG_OWNER | ABD_FLAG_ZEROS; diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c index 73083f59f53..c4d5f8761f5 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c @@ -39,8 +39,6 @@ __FBSDID("$FreeBSD$"); #include #include #include -#else -#include #endif #include @@ -69,11 +67,11 @@ crypto_mac_init(struct hmac_ctx *ctx, const crypto_key_t *c_key) /* * This code is based on the similar code in geom/eli/g_eli_hmac.c */ - explicit_bzero(key, sizeof (key)); + memset(key, 0, sizeof (key)); if (c_key->ck_length == 0) /* do nothing */; else if (cl_bytes <= SHA512_HMAC_BLOCK_SIZE) - bcopy(c_key->ck_data, key, cl_bytes); + memcpy(key, c_key->ck_data, cl_bytes); else { /* * If key is longer than 128 bytes reset it to @@ -89,16 +87,16 @@ crypto_mac_init(struct hmac_ctx *ctx, const crypto_key_t *c_key) k_ipad[i] = key[i] ^ 0x36; k_opad[i] = key[i] ^ 0x5c; } - explicit_bzero(key, sizeof (key)); + memset(key, 0, sizeof (key)); /* Start inner SHA512. */ SHA512_Init(&ctx->innerctx); SHA512_Update(&ctx->innerctx, k_ipad, sizeof (k_ipad)); - explicit_bzero(k_ipad, sizeof (k_ipad)); + memset(k_ipad, 0, sizeof (k_ipad)); /* Start outer SHA512. */ SHA512_Init(&ctx->outerctx); SHA512_Update(&ctx->outerctx, k_opad, sizeof (k_opad)); - explicit_bzero(k_opad, sizeof (k_opad)); + memset(k_opad, 0, sizeof (k_opad)); } void @@ -119,12 +117,12 @@ crypto_mac_final(struct hmac_ctx *ctx, void *md, size_t mdsize) SHA512_Update(&ctx->outerctx, digest, sizeof (digest)); SHA512_Final(digest, &ctx->outerctx); - explicit_bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); /* mdsize == 0 means "Give me the whole hash!" */ if (mdsize == 0) mdsize = SHA512_DIGEST_LENGTH; - bcopy(digest, md, mdsize); - explicit_bzero(digest, sizeof (digest)); + memcpy(md, digest, mdsize); + memset(digest, 0, sizeof (digest)); } void @@ -156,7 +154,7 @@ freebsd_crypt_freesession(freebsd_crypt_session_t *sess) { mtx_destroy(&sess->fs_lock); crypto_freesession(sess->fs_sid); - explicit_bzero(sess, sizeof (*sess)); + memset(sess, 0, sizeof (*sess)); } static int @@ -243,7 +241,7 @@ int freebsd_crypt_newsession(freebsd_crypt_session_t *sessp, const struct zio_crypt_info *c_info, crypto_key_t *key) { - struct crypto_session_params csp; + struct crypto_session_params csp = {0}; int error = 0; #ifdef FCRYPTO_DEBUG @@ -259,7 +257,6 @@ freebsd_crypt_newsession(freebsd_crypt_session_t *sessp, } printf("}\n"); #endif - bzero(&csp, sizeof (csp)); csp.csp_mode = CSP_MODE_AEAD; csp.csp_cipher_key = key->ck_data; csp.csp_cipher_klen = key->ck_length / 8; @@ -364,7 +361,7 @@ freebsd_crypt_uio(boolean_t encrypt, crp->crp_payload_length = datalen; crp->crp_digest_start = auth_len + datalen; - bcopy(ivbuf, crp->crp_iv, ZIO_DATA_IV_LEN); + memcpy(crp->crp_iv, ivbuf, ZIO_DATA_IV_LEN); error = zfs_crypto_dispatch(session, crp); crypto_freereq(crp); out: @@ -384,7 +381,7 @@ int freebsd_crypt_newsession(freebsd_crypt_session_t *sessp, const struct zio_crypt_info *c_info, crypto_key_t *key) { - struct cryptoini cria, crie, *crip; + struct cryptoini cria = {0}, crie = {0}, *crip; struct enc_xform *xform; struct auth_hash *xauth; int error = 0; @@ -452,9 +449,6 @@ freebsd_crypt_newsession(freebsd_crypt_session_t *sessp, xauth->name, xauth->keysize); #endif - bzero(&crie, sizeof (crie)); - bzero(&cria, sizeof (cria)); - crie.cri_alg = xform->type; crie.cri_key = key->ck_data; crie.cri_klen = key->ck_length; @@ -466,7 +460,7 @@ freebsd_crypt_newsession(freebsd_crypt_session_t *sessp, cria.cri_next = &crie; crie.cri_next = NULL; crip = &cria; - // Everything else is bzero'd + // Everything else is zero-initialised error = crypto_newsession(&sid, crip, CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE); @@ -595,7 +589,7 @@ freebsd_crypt_uio(boolean_t encrypt, enc_desc->crd_inject = auth_len; enc_desc->crd_alg = xform->type; enc_desc->crd_flags = CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT; - bcopy(ivbuf, enc_desc->crd_iv, ZIO_DATA_IV_LEN); + memcpy(enc_desc->crd_iv, ivbuf, ZIO_DATA_IV_LEN); enc_desc->crd_next = NULL; #ifdef FCRYPTO_DEBUG diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/dmu_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/dmu_os.c index 38488dbda6f..a5f486b95db 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/dmu_os.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/dmu_os.c @@ -119,7 +119,7 @@ dmu_write_pages(objset_t *os, uint64_t object, uint64_t offset, uint64_t size, db->db_offset + bufoff); thiscpy = MIN(PAGESIZE, tocpy - copied); va = zfs_map_page(*ma, &sf); - bcopy(va, (char *)db->db_data + bufoff, thiscpy); + memcpy((char *)db->db_data + bufoff, va, thiscpy); zfs_unmap_page(sf); ma += 1; bufoff += PAGESIZE; @@ -189,7 +189,7 @@ dmu_read_pages(objset_t *os, uint64_t object, vm_page_t *ma, int count, ASSERT3U(db->db_size, >, PAGE_SIZE); bufoff = IDX_TO_OFF(m->pindex) % db->db_size; va = zfs_map_page(m, &sf); - bcopy((char *)db->db_data + bufoff, va, PAGESIZE); + memcpy(va, (char *)db->db_data + bufoff, PAGESIZE); zfs_unmap_page(sf); vm_page_valid(m); dmu_page_lock(m); @@ -231,7 +231,7 @@ dmu_read_pages(objset_t *os, uint64_t object, vm_page_t *ma, int count, tocpy = MIN(db->db_size - bufoff, PAGESIZE - pgoff); ASSERT3S(tocpy, >=, 0); if (m != bogus_page) - bcopy((char *)db->db_data + bufoff, va + pgoff, tocpy); + memcpy(va + pgoff, (char *)db->db_data + bufoff, tocpy); pgoff += tocpy; ASSERT3S(pgoff, >=, 0); @@ -287,7 +287,7 @@ dmu_read_pages(objset_t *os, uint64_t object, vm_page_t *ma, int count, #endif if (pgoff != 0) { ASSERT3P(m, !=, bogus_page); - bzero(va + pgoff, PAGESIZE - pgoff); + memset(va + pgoff, 0, PAGESIZE - pgoff); zfs_unmap_page(sf); vm_page_valid(m); } @@ -309,11 +309,11 @@ dmu_read_pages(objset_t *os, uint64_t object, vm_page_t *ma, int count, bufoff = IDX_TO_OFF(m->pindex) % db->db_size; tocpy = MIN(db->db_size - bufoff, PAGESIZE); va = zfs_map_page(m, &sf); - bcopy((char *)db->db_data + bufoff, va, tocpy); + memcpy(va, (char *)db->db_data + bufoff, tocpy); if (tocpy < PAGESIZE) { ASSERT3S(i, ==, *rahead - 1); ASSERT3U((db->db_size & PAGE_MASK), !=, 0); - bzero(va + tocpy, PAGESIZE - tocpy); + memset(va + tocpy, 0, PAGESIZE - tocpy); } zfs_unmap_page(sf); vm_page_valid(m); diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/hkdf.c b/sys/contrib/openzfs/module/os/freebsd/zfs/hkdf.c index ad5d67541ad..3a3c426fa48 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/hkdf.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/hkdf.c @@ -63,7 +63,7 @@ hkdf_sha512_expand(uint8_t *extract_key, uint8_t *info, uint_t info_len, crypto_mac_update(&ctx, info, info_len); crypto_mac_update(&ctx, &c, 1); crypto_mac_final(&ctx, T, SHA512_DIGEST_LENGTH); - bcopy(T, out_buf + pos, + memcpy(out_buf + pos, T, (i != N) ? SHA512_DIGEST_LENGTH : (out_len - pos)); pos += SHA512_DIGEST_LENGTH; } diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c index c0aa6732717..0900f686c06 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c @@ -689,10 +689,10 @@ zfs_copy_ace_2_fuid(zfsvfs_t *zfsvfs, vtype_t obj_type, zfs_acl_t *aclp, zobjacep = (zfs_object_ace_t *)aceptr; aceobjp = (ace_object_t *)acep; - bcopy(aceobjp->a_obj_type, zobjacep->z_object_type, + memcpy(zobjacep->z_object_type, aceobjp->a_obj_type, sizeof (aceobjp->a_obj_type)); - bcopy(aceobjp->a_inherit_obj_type, - zobjacep->z_inherit_type, + memcpy(zobjacep->z_inherit_type, + aceobjp->a_inherit_obj_type, sizeof (aceobjp->a_inherit_obj_type)); acep = (ace_t *)((caddr_t)acep + sizeof (ace_object_t)); break; @@ -739,11 +739,11 @@ zfs_copy_fuid_2_ace(zfsvfs_t *zfsvfs, zfs_acl_t *aclp, cred_t *cr, } zobjacep = (zfs_object_ace_t *)zacep; objacep = (ace_object_t *)acep; - bcopy(zobjacep->z_object_type, - objacep->a_obj_type, + memcpy(objacep->a_obj_type, + zobjacep->z_object_type, sizeof (zobjacep->z_object_type)); - bcopy(zobjacep->z_inherit_type, - objacep->a_inherit_obj_type, + memcpy(objacep->a_inherit_obj_type, + zobjacep->z_inherit_type, sizeof (zobjacep->z_inherit_type)); ace_size = sizeof (ace_object_t); break; @@ -1094,7 +1094,7 @@ zfs_acl_node_read(znode_t *zp, boolean_t have_lock, zfs_acl_t **aclpp, znode_acl.z_acl_extern_obj, 0, aclnode->z_size, aclnode->z_acldata, DMU_READ_PREFETCH); } else { - bcopy(znode_acl.z_ace_data, aclnode->z_acldata, + memcpy(aclnode->z_acldata, znode_acl.z_ace_data, aclnode->z_size); } } else { @@ -1282,7 +1282,7 @@ zfs_aclset_common(znode_t *zp, zfs_acl_t *aclp, cred_t *cr, dmu_tx_t *tx) aclnode = list_next(&aclp->z_acl, aclnode)) { if (aclnode->z_ace_count == 0) continue; - bcopy(aclnode->z_acldata, start, + memcpy(start, aclnode->z_acldata, aclnode->z_size); start = (caddr_t)start + aclnode->z_size; } @@ -1564,7 +1564,7 @@ zfs_acl_inherit(zfsvfs_t *zfsvfs, vtype_t vtype, zfs_acl_t *paclp, if ((data1sz = paclp->z_ops->ace_data(pacep, &data1)) != 0) { data2sz = aclp->z_ops->ace_data(acep, &data2); VERIFY3U(data2sz, ==, data1sz); - bcopy(data1, data2, data2sz); + memcpy(data2, data1, data2sz); } aclp->z_acl_count++; @@ -1633,7 +1633,7 @@ zfs_acl_ids_create(znode_t *dzp, int flag, vattr_t *vap, cred_t *cr, ASSERT_VOP_ELOCKED(ZTOV(dzp), __func__); } else ASSERT3P(dzp->z_vnode, ==, NULL); - bzero(acl_ids, sizeof (zfs_acl_ids_t)); + memset(acl_ids, 0, sizeof (zfs_acl_ids_t)); acl_ids->z_mode = MAKEIMODE(vap->va_type, vap->va_mode); if (vsecp) @@ -1653,8 +1653,10 @@ zfs_acl_ids_create(znode_t *dzp, int flag, vattr_t *vap, cred_t *cr, ZFS_GROUP, &acl_ids->z_fuidp); gid = vap->va_gid; } else { - acl_ids->z_fuid = zfs_fuid_create_cred(zfsvfs, ZFS_OWNER, - cr, &acl_ids->z_fuidp); + uid_t id = crgetuid(cr); + if (IS_EPHEMERAL(id)) + id = UID_NOBODY; + acl_ids->z_fuid = (uint64_t)id; acl_ids->z_fgid = 0; if (vap->va_mask & AT_GID) { acl_ids->z_fgid = zfs_fuid_create(zfsvfs, @@ -1847,7 +1849,7 @@ zfs_getacl(znode_t *zp, vsecattr_t *vsecp, boolean_t skipaclchk, cred_t *cr) for (aclnode = list_head(&aclp->z_acl); aclnode; aclnode = list_next(&aclp->z_acl, aclnode)) { - bcopy(aclnode->z_acldata, start, + memcpy(start, aclnode->z_acldata, aclnode->z_size); start = (caddr_t)start + aclnode->z_size; } diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c index 6692e7b317b..4db5cb58332 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_ctldir.c @@ -721,7 +721,7 @@ zfsctl_root_vptocnp(struct vop_vptocnp_args *ap) VOP_UNLOCK1(dvp); *ap->a_vpp = dvp; *ap->a_buflen -= sizeof (dotzfs_name); - bcopy(dotzfs_name, ap->a_buf + *ap->a_buflen, sizeof (dotzfs_name)); + memcpy(ap->a_buf + *ap->a_buflen, dotzfs_name, sizeof (dotzfs_name)); return (0); } @@ -1214,7 +1214,7 @@ zfsctl_snapshot_vptocnp(struct vop_vptocnp_args *ap) VOP_UNLOCK1(dvp); *ap->a_vpp = dvp; *ap->a_buflen -= len; - bcopy(node->sn_name, ap->a_buf + *ap->a_buflen, len); + memcpy(ap->a_buf + *ap->a_buflen, node->sn_name, len); } vfs_unbusy(mp); #if __FreeBSD_version >= 1300045 diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c index bd92c4ae647..e33aaea481b 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c @@ -539,7 +539,7 @@ mappedread_sf(znode_t *zp, int nbytes, zfs_uio_t *uio) error = dmu_read(os, zp->z_id, start, bytes, va, DMU_READ_PREFETCH); if (bytes != PAGESIZE && error == 0) - bzero(va + bytes, PAGESIZE - bytes); + memset(va + bytes, 0, PAGESIZE - bytes); zfs_unmap_page(sf); zfs_vmobject_wlock_12(obj); #if __FreeBSD_version >= 1300081 @@ -1043,8 +1043,7 @@ zfs_create(znode_t *dzp, const char *name, vattr_t *vap, int excl, int mode, objset_t *os; dmu_tx_t *tx; int error; - ksid_t *ksid; - uid_t uid; + uid_t uid = crgetuid(cr); gid_t gid = crgetgid(cr); uint64_t projid = ZFS_DEFAULT_PROJID; zfs_acl_ids_t acl_ids; @@ -1058,13 +1057,6 @@ zfs_create(znode_t *dzp, const char *name, vattr_t *vap, int excl, int mode, * If we have an ephemeral id, ACL, or XVATTR then * make sure file system is at proper version */ - - ksid = crgetsid(cr, KSID_OWNER); - if (ksid) - uid = ksid_getid(ksid); - else - uid = crgetuid(cr); - if (zfsvfs->z_use_fuids == B_FALSE && (vsecp || (vap->va_mask & AT_XVATTR) || IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid))) @@ -1396,8 +1388,7 @@ zfs_mkdir(znode_t *dzp, const char *dirname, vattr_t *vap, znode_t **zpp, uint64_t txtype; dmu_tx_t *tx; int error; - ksid_t *ksid; - uid_t uid; + uid_t uid = crgetuid(cr); gid_t gid = crgetgid(cr); zfs_acl_ids_t acl_ids; boolean_t fuid_dirtied; @@ -1408,12 +1399,6 @@ zfs_mkdir(znode_t *dzp, const char *dirname, vattr_t *vap, znode_t **zpp, * If we have an ephemeral id, ACL, or XVATTR then * make sure file system is at proper version */ - - ksid = crgetsid(cr, KSID_OWNER); - if (ksid) - uid = ksid_getid(ksid); - else - uid = crgetuid(cr); if (zfsvfs->z_use_fuids == B_FALSE && ((vap->va_mask & AT_XVATTR) || IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid))) @@ -5273,7 +5258,7 @@ zfs_create_attrname(int attrnamespace, const char *name, char *attrname, { const char *namespace, *prefix, *suffix; - bzero(attrname, size); + memset(attrname, 0, size); switch (attrnamespace) { case EXTATTR_NAMESPACE_USER: @@ -6142,7 +6127,7 @@ zfs_vptocnp(struct vop_vptocnp_args *ap) } if (error == 0) { *ap->a_buflen -= len; - bcopy(name, ap->a_buf + *ap->a_buflen, len); + memcpy(ap->a_buf + *ap->a_buflen, name, len); *ap->a_vpp = ZTOV(dzp); } ZFS_EXIT(zfsvfs); diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c index 51545df8fe4..2496d6897d9 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c @@ -1982,7 +1982,7 @@ zfs_obj_to_path_impl(objset_t *osp, uint64_t obj, sa_handle_t *hdl, complen = strlen(component); path -= complen; ASSERT3P(path, >=, buf); - bcopy(component, path, complen); + memcpy(path, component, complen); obj = pobj; if (sa_hdl != hdl) { diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c index a50b8058a94..0410ddd65a5 100644 --- a/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c +++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c @@ -211,10 +211,10 @@ zio_crypt_key_destroy_early(zio_crypt_key_t *key) rw_destroy(&key->zk_salt_lock); /* free crypto templates */ - bzero(&key->zk_session, sizeof (key->zk_session)); + memset(&key->zk_session, 0, sizeof (key->zk_session)); /* zero out sensitive data */ - bzero(key, sizeof (zio_crypt_key_t)); + memset(key, 0, sizeof (zio_crypt_key_t)); } void @@ -242,7 +242,7 @@ zio_crypt_key_init(uint64_t crypt, zio_crypt_key_t *key) return (ENOTSUP); keydata_len = zio_crypt_table[crypt].ci_keylen; - bzero(key, sizeof (zio_crypt_key_t)); + memset(key, 0, sizeof (zio_crypt_key_t)); rw_init(&key->zk_salt_lock, NULL, RW_DEFAULT, NULL); /* fill keydata buffers and salt with random data */ @@ -324,7 +324,7 @@ zio_crypt_key_change_salt(zio_crypt_key_t *key) goto out_unlock; /* assign the salt and reset the usage count */ - bcopy(salt, key->zk_salt, ZIO_DATA_SALT_LEN); + memcpy(key->zk_salt, salt, ZIO_DATA_SALT_LEN); key->zk_salt_count = 0; freebsd_crypt_freesession(&key->zk_session); @@ -352,7 +352,7 @@ zio_crypt_key_get_salt(zio_crypt_key_t *key, uint8_t *salt) rw_enter(&key->zk_salt_lock, RW_READER); - bcopy(key->zk_salt, salt, ZIO_DATA_SALT_LEN); + memcpy(salt, key->zk_salt, ZIO_DATA_SALT_LEN); salt_change = (atomic_inc_64_nv(&key->zk_salt_count) >= ZFS_CURRENT_MAX_SALT_USES); @@ -450,9 +450,8 @@ zio_crypt_key_wrap(crypto_key_t *cwkey, zio_crypt_key_t *key, uint8_t *iv, * the plain text (source) to the cipher buffer (dest). * We set iovecs[0] -- the authentication data -- below. */ - bcopy((void*)key->zk_master_keydata, keydata_out, keydata_len); - bcopy((void*)key->zk_hmac_keydata, hmac_keydata_out, - SHA512_HMAC_KEYLEN); + memcpy(keydata_out, key->zk_master_keydata, keydata_len); + memcpy(hmac_keydata_out, key->zk_hmac_keydata, SHA512_HMAC_KEYLEN); iovecs[1].iov_base = keydata_out; iovecs[1].iov_len = keydata_len; iovecs[2].iov_base = hmac_keydata_out; @@ -529,12 +528,11 @@ zio_crypt_key_unwrap(crypto_key_t *cwkey, uint64_t crypt, uint64_t version, */ dst = key->zk_master_keydata; src = keydata; - - bcopy(src, dst, keydata_len); + memcpy(dst, src, keydata_len); dst = key->zk_hmac_keydata; src = hmac_keydata; - bcopy(src, dst, SHA512_HMAC_KEYLEN); + memcpy(dst, src, SHA512_HMAC_KEYLEN); iovecs[1].iov_base = key->zk_master_keydata; iovecs[1].iov_len = keydata_len; @@ -618,7 +616,7 @@ zio_crypt_generate_iv(uint8_t *ivbuf) return (0); error: - bzero(ivbuf, ZIO_DATA_IV_LEN); + memset(ivbuf, 0, ZIO_DATA_IV_LEN); return (ret); } @@ -633,7 +631,7 @@ zio_crypt_do_hmac(zio_crypt_key_t *key, uint8_t *data, uint_t datalen, crypto_mac(&key->zk_hmac_key, data, datalen, raw_digestbuf, SHA512_DIGEST_LENGTH); - bcopy(raw_digestbuf, digestbuf, digestlen); + memcpy(digestbuf, raw_digestbuf, digestlen); return (0); } @@ -650,8 +648,8 @@ zio_crypt_generate_iv_salt_dedup(zio_crypt_key_t *key, uint8_t *data, if (ret != 0) return (ret); - bcopy(digestbuf, salt, ZIO_DATA_SALT_LEN); - bcopy(digestbuf + ZIO_DATA_SALT_LEN, ivbuf, ZIO_DATA_IV_LEN); + memcpy(salt, digestbuf, ZIO_DATA_SALT_LEN); + memcpy(ivbuf, digestbuf + ZIO_DATA_SALT_LEN, ZIO_DATA_IV_LEN); return (0); } @@ -674,18 +672,18 @@ zio_crypt_encode_params_bp(blkptr_t *bp, uint8_t *salt, uint8_t *iv) ASSERT(BP_IS_ENCRYPTED(bp)); if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(salt, &bp->blk_dva[2].dva_word[0], sizeof (uint64_t)); - bcopy(iv, &bp->blk_dva[2].dva_word[1], sizeof (uint64_t)); - bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); + memcpy(&bp->blk_dva[2].dva_word[0], salt, sizeof (uint64_t)); + memcpy(&bp->blk_dva[2].dva_word[1], iv, sizeof (uint64_t)); + memcpy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); BP_SET_IV2(bp, val32); } else { - bcopy(salt, &val64, sizeof (uint64_t)); + memcpy(&val64, salt, sizeof (uint64_t)); bp->blk_dva[2].dva_word[0] = BSWAP_64(val64); - bcopy(iv, &val64, sizeof (uint64_t)); + memcpy(&val64, iv, sizeof (uint64_t)); bp->blk_dva[2].dva_word[1] = BSWAP_64(val64); - bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); + memcpy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); BP_SET_IV2(bp, BSWAP_32(val32)); } } @@ -700,26 +698,26 @@ zio_crypt_decode_params_bp(const blkptr_t *bp, uint8_t *salt, uint8_t *iv) /* for convenience, so callers don't need to check */ if (BP_IS_AUTHENTICATED(bp)) { - bzero(salt, ZIO_DATA_SALT_LEN); - bzero(iv, ZIO_DATA_IV_LEN); + memset(salt, 0, ZIO_DATA_SALT_LEN); + memset(iv, 0, ZIO_DATA_IV_LEN); return; } if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(&bp->blk_dva[2].dva_word[0], salt, sizeof (uint64_t)); - bcopy(&bp->blk_dva[2].dva_word[1], iv, sizeof (uint64_t)); + memcpy(salt, &bp->blk_dva[2].dva_word[0], sizeof (uint64_t)); + memcpy(iv, &bp->blk_dva[2].dva_word[1], sizeof (uint64_t)); val32 = (uint32_t)BP_GET_IV2(bp); - bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); + memcpy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); } else { val64 = BSWAP_64(bp->blk_dva[2].dva_word[0]); - bcopy(&val64, salt, sizeof (uint64_t)); + memcpy(salt, &val64, sizeof (uint64_t)); val64 = BSWAP_64(bp->blk_dva[2].dva_word[1]); - bcopy(&val64, iv, sizeof (uint64_t)); + memcpy(iv, &val64, sizeof (uint64_t)); val32 = BSWAP_32((uint32_t)BP_GET_IV2(bp)); - bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); + memcpy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); } } @@ -732,14 +730,14 @@ zio_crypt_encode_mac_bp(blkptr_t *bp, uint8_t *mac) ASSERT3U(BP_GET_TYPE(bp), !=, DMU_OT_OBJSET); if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(mac, &bp->blk_cksum.zc_word[2], sizeof (uint64_t)); - bcopy(mac + sizeof (uint64_t), &bp->blk_cksum.zc_word[3], + memcpy(&bp->blk_cksum.zc_word[2], mac, sizeof (uint64_t)); + memcpy(&bp->blk_cksum.zc_word[3], mac + sizeof (uint64_t), sizeof (uint64_t)); } else { - bcopy(mac, &val64, sizeof (uint64_t)); + memcpy(&val64, mac, sizeof (uint64_t)); bp->blk_cksum.zc_word[2] = BSWAP_64(val64); - bcopy(mac + sizeof (uint64_t), &val64, sizeof (uint64_t)); + memcpy(&val64, mac + sizeof (uint64_t), sizeof (uint64_t)); bp->blk_cksum.zc_word[3] = BSWAP_64(val64); } } @@ -753,20 +751,20 @@ zio_crypt_decode_mac_bp(const blkptr_t *bp, uint8_t *mac) /* for convenience, so callers don't need to check */ if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) { - bzero(mac, ZIO_DATA_MAC_LEN); + memset(mac, 0, ZIO_DATA_MAC_LEN); return; } if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(&bp->blk_cksum.zc_word[2], mac, sizeof (uint64_t)); - bcopy(&bp->blk_cksum.zc_word[3], mac + sizeof (uint64_t), + memcpy(mac, &bp->blk_cksum.zc_word[2], sizeof (uint64_t)); + memcpy(mac + sizeof (uint64_t), &bp->blk_cksum.zc_word[3], sizeof (uint64_t)); } else { val64 = BSWAP_64(bp->blk_cksum.zc_word[2]); - bcopy(&val64, mac, sizeof (uint64_t)); + memcpy(mac, &val64, sizeof (uint64_t)); val64 = BSWAP_64(bp->blk_cksum.zc_word[3]); - bcopy(&val64, mac + sizeof (uint64_t), sizeof (uint64_t)); + memcpy(mac + sizeof (uint64_t), &val64, sizeof (uint64_t)); } } @@ -775,8 +773,8 @@ zio_crypt_encode_mac_zil(void *data, uint8_t *mac) { zil_chain_t *zilc = data; - bcopy(mac, &zilc->zc_eck.zec_cksum.zc_word[2], sizeof (uint64_t)); - bcopy(mac + sizeof (uint64_t), &zilc->zc_eck.zec_cksum.zc_word[3], + memcpy(&zilc->zc_eck.zec_cksum.zc_word[2], mac, sizeof (uint64_t)); + memcpy(&zilc->zc_eck.zec_cksum.zc_word[3], mac + sizeof (uint64_t), sizeof (uint64_t)); } @@ -790,8 +788,8 @@ zio_crypt_decode_mac_zil(const void *data, uint8_t *mac) */ const zil_chain_t *zilc = data; - bcopy(&zilc->zc_eck.zec_cksum.zc_word[2], mac, sizeof (uint64_t)); - bcopy(&zilc->zc_eck.zec_cksum.zc_word[3], mac + sizeof (uint64_t), + memcpy(mac, &zilc->zc_eck.zec_cksum.zc_word[2], sizeof (uint64_t)); + memcpy(mac + sizeof (uint64_t), &zilc->zc_eck.zec_cksum.zc_word[3], sizeof (uint64_t)); } @@ -818,7 +816,7 @@ zio_crypt_copy_dnode_bonus(abd_t *src_abd, uint8_t *dst, uint_t datalen) if (dnp->dn_type != DMU_OT_NONE && DMU_OT_IS_ENCRYPTED(dnp->dn_bonustype) && dnp->dn_bonuslen != 0) { - bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]), + memcpy(DN_BONUS(&ddnp[i]), DN_BONUS(dnp), DN_MAX_BONUS_LEN(dnp)); } } @@ -946,7 +944,7 @@ zio_crypt_bp_do_aad_updates(uint8_t **aadp, uint_t *aad_len, uint64_t version, blkptr_auth_buf_t bab; zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len); - bcopy(&bab, *aadp, bab_len); + memcpy(*aadp, &bab, bab_len); *aadp += bab_len; *aad_len += bab_len; } @@ -961,7 +959,7 @@ zio_crypt_do_dnode_hmac_updates(crypto_context_t ctx, uint64_t version, uint8_t tmp_dncore[offsetof(dnode_phys_t, dn_blkptr)]; /* authenticate the core dnode (masking out non-portable bits) */ - bcopy(dnp, tmp_dncore, sizeof (tmp_dncore)); + memcpy(tmp_dncore, dnp, sizeof (tmp_dncore)); adnp = (dnode_phys_t *)tmp_dncore; if (le_bswap) { adnp->dn_datablkszsec = BSWAP_16(adnp->dn_datablkszsec); @@ -1057,7 +1055,7 @@ zio_crypt_do_objset_hmacs(zio_crypt_key_t *key, void *data, uint_t datalen, crypto_mac_final(ctx, raw_portable_mac, SHA512_DIGEST_LENGTH); - bcopy(raw_portable_mac, portable_mac, ZIO_OBJSET_MAC_LEN); + memcpy(portable_mac, raw_portable_mac, ZIO_OBJSET_MAC_LEN); /* * This is necessary here as we check next whether @@ -1086,7 +1084,7 @@ zio_crypt_do_objset_hmacs(zio_crypt_key_t *key, void *data, uint_t datalen, osp->os_userused_dnode.dn_type == DMU_OT_NONE && osp->os_groupused_dnode.dn_type == DMU_OT_NONE) || (datalen <= OBJSET_PHYS_SIZE_V1)) { - bzero(local_mac, ZIO_OBJSET_MAC_LEN); + memset(local_mac, 0, ZIO_OBJSET_MAC_LEN); return (0); } @@ -1129,13 +1127,13 @@ zio_crypt_do_objset_hmacs(zio_crypt_key_t *key, void *data, uint_t datalen, crypto_mac_final(ctx, raw_local_mac, SHA512_DIGEST_LENGTH); - bcopy(raw_local_mac, local_mac, ZIO_OBJSET_MAC_LEN); + memcpy(local_mac, raw_local_mac, ZIO_OBJSET_MAC_LEN); return (0); error: - bzero(portable_mac, ZIO_OBJSET_MAC_LEN); - bzero(local_mac, ZIO_OBJSET_MAC_LEN); + memset(portable_mac, 0, ZIO_OBJSET_MAC_LEN); + memset(local_mac, 0, ZIO_OBJSET_MAC_LEN); return (ret); } @@ -1172,11 +1170,11 @@ zio_crypt_do_indirect_mac_checksum_impl(boolean_t generate, void *buf, SHA2Final(digestbuf, &ctx); if (generate) { - bcopy(digestbuf, cksum, ZIO_DATA_MAC_LEN); + memcpy(cksum, digestbuf, ZIO_DATA_MAC_LEN); return (0); } - if (bcmp(digestbuf, cksum, ZIO_DATA_MAC_LEN) != 0) { + if (memcmp(digestbuf, cksum, ZIO_DATA_MAC_LEN) != 0) { #ifdef FCRYPTO_DEBUG printf("%s(%d): Setting ECKSUM\n", __FUNCTION__, __LINE__); #endif @@ -1264,7 +1262,7 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, src = cipherbuf; dst = plainbuf; } - bcopy(src, dst, datalen); + memcpy(dst, src, datalen); /* Find the start and end record of the log block. */ zilc = (zil_chain_t *)src; @@ -1303,7 +1301,7 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, * the embedded checksum will not have been calculated yet, so we don't * authenticate that. */ - bcopy(src, aadp, sizeof (zil_chain_t) - sizeof (zio_eck_t)); + memcpy(aadp, src, sizeof (zil_chain_t) - sizeof (zio_eck_t)); aadp += sizeof (zil_chain_t) - sizeof (zio_eck_t); aad_len += sizeof (zil_chain_t) - sizeof (zio_eck_t); @@ -1329,8 +1327,8 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, } /* copy the common lr_t */ - bcopy(slrp, dlrp, sizeof (lr_t)); - bcopy(slrp, aadp, sizeof (lr_t)); + memcpy(dlrp, slrp, sizeof (lr_t)); + memcpy(aadp, slrp, sizeof (lr_t)); aadp += sizeof (lr_t); aad_len += sizeof (lr_t); @@ -1347,11 +1345,12 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, dst_iovecs[vec].iov_len = crypt_len; /* copy the bp now since it will not be encrypted */ - bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t), - dlrp + sizeof (lr_write_t) - sizeof (blkptr_t), + memcpy(dlrp + sizeof (lr_write_t) - sizeof (blkptr_t), + slrp + sizeof (lr_write_t) - sizeof (blkptr_t), + sizeof (blkptr_t)); + memcpy(aadp, + slrp + sizeof (lr_write_t) - sizeof (blkptr_t), sizeof (blkptr_t)); - bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t), - aadp, sizeof (blkptr_t)); aadp += sizeof (blkptr_t); aad_len += sizeof (blkptr_t); vec++; @@ -1419,7 +1418,7 @@ zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version, src = cipherbuf; dst = plainbuf; } - bcopy(src, dst, datalen); + memcpy(dst, src, datalen); sdnp = (dnode_phys_t *)src; ddnp = (dnode_phys_t *)dst; @@ -1462,10 +1461,11 @@ zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version, dnp = &sdnp[i]; /* copy over the core fields and blkptrs (kept as plaintext) */ - bcopy(dnp, &ddnp[i], (uint8_t *)DN_BONUS(dnp) - (uint8_t *)dnp); + memcpy(&ddnp[i], dnp, + (uint8_t *)DN_BONUS(dnp) - (uint8_t *)dnp); if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) { - bcopy(DN_SPILL_BLKPTR(dnp), DN_SPILL_BLKPTR(&ddnp[i]), + memcpy(DN_SPILL_BLKPTR(&ddnp[i]), DN_SPILL_BLKPTR(dnp), sizeof (blkptr_t)); } @@ -1480,7 +1480,7 @@ zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version, * authenticated data. */ crypt_len = offsetof(dnode_phys_t, dn_blkptr); - bcopy(dnp, aadp, crypt_len); + memcpy(aadp, dnp, crypt_len); adnp = (dnode_phys_t *)aadp; adnp->dn_flags &= DNODE_CRYPT_PORTABLE_FLAGS_MASK; adnp->dn_used = 0; @@ -1517,8 +1517,8 @@ zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version, vec++; total_len += crypt_len; } else { - bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]), crypt_len); - bcopy(DN_BONUS(dnp), aadp, crypt_len); + memcpy(DN_BONUS(&ddnp[i]), DN_BONUS(dnp), crypt_len); + memcpy(aadp, DN_BONUS(dnp), crypt_len); aadp += crypt_len; aad_len += crypt_len; } @@ -1561,7 +1561,7 @@ zio_crypt_init_uios_normal(boolean_t encrypt, uint8_t *plainbuf, ret = SET_ERROR(ENOMEM); goto error; } - bzero(cipher_iovecs, nr_cipher * sizeof (iovec_t)); + memset(cipher_iovecs, 0, nr_cipher * sizeof (iovec_t)); if (encrypt) { src = plainbuf; @@ -1570,7 +1570,7 @@ zio_crypt_init_uios_normal(boolean_t encrypt, uint8_t *plainbuf, src = cipherbuf; dst = plainbuf; } - bcopy(src, dst, datalen); + memcpy(dst, src, datalen); cipher_iovecs[0].iov_base = dst; cipher_iovecs[0].iov_len = datalen; @@ -1678,8 +1678,8 @@ zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key, zfs_uio_init(&puio, &puio_s); zfs_uio_init(&cuio, &cuio_s); - bzero(GET_UIO_STRUCT(&puio), sizeof (struct uio)); - bzero(GET_UIO_STRUCT(&cuio), sizeof (struct uio)); + memset(GET_UIO_STRUCT(&puio), 0, sizeof (struct uio)); + memset(GET_UIO_STRUCT(&cuio), 0, sizeof (struct uio)); #ifdef FCRYPTO_DEBUG printf("%s(%s, %p, %p, %d, %p, %p, %u, %s, %p, %p, %p)\n", @@ -1710,7 +1710,7 @@ zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key, rw_enter(&key->zk_salt_lock, RW_READER); locked = B_TRUE; - if (bcmp(salt, key->zk_salt, ZIO_DATA_SALT_LEN) == 0) { + if (memcmp(salt, key->zk_salt, ZIO_DATA_SALT_LEN) == 0) { ckey = &key->zk_current_key; tmpl = &key->zk_session; } else { @@ -1741,7 +1741,7 @@ zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key, if (authbuf != NULL) zio_buf_free(authbuf, datalen); if (ckey == &tmp_ckey) - bzero(enc_keydata, keydata_len); + memset(enc_keydata, 0, keydata_len); zio_crypt_destroy_uio(&puio); zio_crypt_destroy_uio(&cuio); @@ -1753,14 +1753,14 @@ error: kmem_free(failed_decrypt_buf, failed_decrypt_size); failed_decrypt_buf = kmem_alloc(datalen, KM_SLEEP); failed_decrypt_size = datalen; - bcopy(cipherbuf, failed_decrypt_buf, datalen); + memcpy(failed_decrypt_buf, cipherbuf, datalen); } if (locked) rw_exit(&key->zk_salt_lock); if (authbuf != NULL) zio_buf_free(authbuf, datalen); if (ckey == &tmp_ckey) - bzero(enc_keydata, keydata_len); + memset(enc_keydata, 0, keydata_len); zio_crypt_destroy_uio(&puio); zio_crypt_destroy_uio(&cuio); return (SET_ERROR(ret)); diff --git a/sys/contrib/openzfs/module/os/linux/spl/spl-cred.c b/sys/contrib/openzfs/module/os/linux/spl/spl-cred.c index 8fe1cc30ba9..f81b9540a63 100644 --- a/sys/contrib/openzfs/module/os/linux/spl/spl-cred.c +++ b/sys/contrib/openzfs/module/os/linux/spl/spl-cred.c @@ -128,7 +128,7 @@ groupmember(gid_t gid, const cred_t *cr) uid_t crgetuid(const cred_t *cr) { - return (KUID_TO_SUID(cr->euid)); + return (KUID_TO_SUID(cr->fsuid)); } /* Return the real user id */ @@ -138,44 +138,9 @@ crgetruid(const cred_t *cr) return (KUID_TO_SUID(cr->uid)); } -/* Return the saved user id */ -uid_t -crgetsuid(const cred_t *cr) -{ - return (KUID_TO_SUID(cr->suid)); -} - -/* Return the filesystem user id */ -uid_t -crgetfsuid(const cred_t *cr) -{ - return (KUID_TO_SUID(cr->fsuid)); -} - /* Return the effective group id */ gid_t crgetgid(const cred_t *cr) -{ - return (KGID_TO_SGID(cr->egid)); -} - -/* Return the real group id */ -gid_t -crgetrgid(const cred_t *cr) -{ - return (KGID_TO_SGID(cr->gid)); -} - -/* Return the saved group id */ -gid_t -crgetsgid(const cred_t *cr) -{ - return (KGID_TO_SGID(cr->sgid)); -} - -/* Return the filesystem group id */ -gid_t -crgetfsgid(const cred_t *cr) { return (KGID_TO_SGID(cr->fsgid)); } @@ -184,12 +149,7 @@ EXPORT_SYMBOL(crhold); EXPORT_SYMBOL(crfree); EXPORT_SYMBOL(crgetuid); EXPORT_SYMBOL(crgetruid); -EXPORT_SYMBOL(crgetsuid); -EXPORT_SYMBOL(crgetfsuid); EXPORT_SYMBOL(crgetgid); -EXPORT_SYMBOL(crgetrgid); -EXPORT_SYMBOL(crgetsgid); -EXPORT_SYMBOL(crgetfsgid); EXPORT_SYMBOL(crgetngroups); EXPORT_SYMBOL(crgetgroups); EXPORT_SYMBOL(groupmember); diff --git a/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c b/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c index 5bf2f691245..cc9a973fef6 100644 --- a/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c +++ b/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c @@ -42,7 +42,7 @@ #include #include #include -#include +#include #include #include #include @@ -771,7 +771,6 @@ spl_init(void) { int rc = 0; - bzero(&p0, sizeof (proc_t)); spl_random_init(); if ((rc = spl_kvmem_init())) diff --git a/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c b/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c index 16d2ca1b133..32a2d34b1d9 100644 --- a/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c +++ b/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c @@ -62,15 +62,6 @@ thread_generic_wrapper(void *arg) return (0); } -void -__thread_exit(void) -{ - tsd_exit(); - SPL_KTHREAD_COMPLETE_AND_EXIT(NULL, 0); - /* Unreachable */ -} -EXPORT_SYMBOL(__thread_exit); - /* * thread_create() may block forever if it cannot create a thread or * allocate memory. This is preferable to returning a NULL which Solaris diff --git a/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c b/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c index 113aee58599..688458621b9 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/abd_os.c @@ -182,8 +182,11 @@ abd_t *abd_zero_scatter = NULL; struct page; /* - * abd_zero_page we will be an allocated zero'd PAGESIZE buffer, which is - * assigned to set each of the pages of abd_zero_scatter. + * _KERNEL - Will point to ZERO_PAGE if it is available or it will be + * an allocated zero'd PAGESIZE buffer. + * Userspace - Will be an allocated zero'ed PAGESIZE buffer. + * + * abd_zero_page is assigned to each of the pages of abd_zero_scatter. */ static struct page *abd_zero_page = NULL; @@ -466,15 +469,19 @@ abd_alloc_zero_scatter(void) struct scatterlist *sg = NULL; struct sg_table table; gfp_t gfp = __GFP_NOWARN | GFP_NOIO; - gfp_t gfp_zero_page = gfp | __GFP_ZERO; int nr_pages = abd_chunkcnt_for_bytes(SPA_MAXBLOCKSIZE); int i = 0; +#if defined(HAVE_ZERO_PAGE_GPL_ONLY) + gfp_t gfp_zero_page = gfp | __GFP_ZERO; while ((abd_zero_page = __page_cache_alloc(gfp_zero_page)) == NULL) { ABDSTAT_BUMP(abdstat_scatter_page_alloc_retry); schedule_timeout_interruptible(1); } abd_mark_zfs_page(abd_zero_page); +#else + abd_zero_page = ZERO_PAGE(0); +#endif /* HAVE_ZERO_PAGE_GPL_ONLY */ while (sg_alloc_table(&table, nr_pages, gfp)) { ABDSTAT_BUMP(abdstat_scatter_sg_table_retry); @@ -695,8 +702,10 @@ abd_free_zero_scatter(void) abd_zero_scatter = NULL; ASSERT3P(abd_zero_page, !=, NULL); #if defined(_KERNEL) +#if defined(HAVE_ZERO_PAGE_GPL_ONLY) abd_unmark_zfs_page(abd_zero_page); __free_page(abd_zero_page); +#endif /* HAVE_ZERO_PAGE_GPL_ONLY */ #else umem_free(abd_zero_page, PAGESIZE); #endif /* _KERNEL */ diff --git a/sys/contrib/openzfs/module/os/linux/zfs/policy.c b/sys/contrib/openzfs/module/os/linux/zfs/policy.c index bbccb2e572d..5a52092bb90 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/policy.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/policy.c @@ -121,7 +121,7 @@ secpolicy_vnode_access2(const cred_t *cr, struct inode *ip, uid_t owner, int secpolicy_vnode_any_access(const cred_t *cr, struct inode *ip, uid_t owner) { - if (crgetfsuid(cr) == owner) + if (crgetuid(cr) == owner) return (0); if (zpl_inode_owner_or_capable(kcred->user_ns, ip)) @@ -147,7 +147,7 @@ secpolicy_vnode_any_access(const cred_t *cr, struct inode *ip, uid_t owner) int secpolicy_vnode_chown(const cred_t *cr, uid_t owner) { - if (crgetfsuid(cr) == owner) + if (crgetuid(cr) == owner) return (0); #if defined(CONFIG_USER_NS) @@ -184,7 +184,7 @@ secpolicy_vnode_remove(const cred_t *cr) int secpolicy_vnode_setdac(const cred_t *cr, uid_t owner) { - if (crgetfsuid(cr) == owner) + if (crgetuid(cr) == owner) return (0); #if defined(CONFIG_USER_NS) @@ -220,7 +220,7 @@ secpolicy_vnode_setids_setgids(const cred_t *cr, gid_t gid) if (!kgid_has_mapping(cr->user_ns, SGID_TO_KGID(gid))) return (EPERM); #endif - if (crgetfsgid(cr) != gid && !groupmember(gid, cr)) + if (crgetgid(cr) != gid && !groupmember(gid, cr)) return (priv_policy_user(cr, CAP_FSETID, EPERM)); return (0); @@ -286,7 +286,7 @@ secpolicy_setid_clear(vattr_t *vap, cred_t *cr) static int secpolicy_vnode_setid_modify(const cred_t *cr, uid_t owner) { - if (crgetfsuid(cr) == owner) + if (crgetuid(cr) == owner) return (0); #if defined(CONFIG_USER_NS) diff --git a/sys/contrib/openzfs/module/os/linux/zfs/qat_crypt.c b/sys/contrib/openzfs/module/os/linux/zfs/qat_crypt.c index 4771b2f3bec..18b6e38d1a6 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/qat_crypt.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/qat_crypt.c @@ -367,7 +367,7 @@ qat_crypt(qat_encrypt_dir_t dir, uint8_t *src_buf, uint8_t *dst_buf, aad_len); if (status != CPA_STATUS_SUCCESS) goto fail; - bcopy(aad_buf, op_data.pAdditionalAuthData, aad_len); + memcpy(op_data.pAdditionalAuthData, aad_buf, aad_len); } bytes_left = enc_len; @@ -413,10 +413,10 @@ qat_crypt(qat_encrypt_dir_t dir, uint8_t *src_buf, uint8_t *dst_buf, op_data.messageLenToHashInBytes = 0; op_data.messageLenToCipherInBytes = enc_len; op_data.ivLenInBytes = ZIO_DATA_IV_LEN; - bcopy(iv_buf, op_data.pIv, ZIO_DATA_IV_LEN); + memcpy(op_data.pIv, iv_buf, ZIO_DATA_IV_LEN); /* if dir is QAT_DECRYPT, copy digest_buf to pDigestResult */ if (dir == QAT_DECRYPT) - bcopy(digest_buf, op_data.pDigestResult, ZIO_DATA_MAC_LEN); + memcpy(op_data.pDigestResult, digest_buf, ZIO_DATA_MAC_LEN); cb.verify_result = CPA_FALSE; init_completion(&cb.complete); @@ -435,7 +435,7 @@ qat_crypt(qat_encrypt_dir_t dir, uint8_t *src_buf, uint8_t *dst_buf, if (dir == QAT_ENCRYPT) { /* if dir is QAT_ENCRYPT, save pDigestResult to digest_buf */ - bcopy(op_data.pDigestResult, digest_buf, ZIO_DATA_MAC_LEN); + memcpy(digest_buf, op_data.pDigestResult, ZIO_DATA_MAC_LEN); QAT_STAT_INCR(encrypt_total_out_bytes, enc_len); } else { QAT_STAT_INCR(decrypt_total_out_bytes, enc_len); @@ -557,7 +557,7 @@ qat_checksum(uint64_t cksum, uint8_t *buf, uint64_t size, zio_cksum_t *zcp) goto fail; } - bcopy(digest_buffer, zcp, sizeof (zio_cksum_t)); + memcpy(zcp, digest_buffer, sizeof (zio_cksum_t)); fail: if (status != CPA_STATUS_SUCCESS) diff --git a/sys/contrib/openzfs/module/os/linux/zfs/vdev_disk.c b/sys/contrib/openzfs/module/os/linux/zfs/vdev_disk.c index 61518bad0b1..6cec5be4401 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/vdev_disk.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/vdev_disk.c @@ -563,6 +563,10 @@ vdev_submit_bio(struct bio *bio) current->bio_list = bio_list; } +#ifdef HAVE_BIO_ALLOC_4ARG +#define bio_alloc(gfp_mask, nr_iovecs) bio_alloc(NULL, nr_iovecs, 0, gfp_mask) +#endif + static int __vdev_disk_physio(struct block_device *bdev, zio_t *zio, size_t io_size, uint64_t io_offset, int rw, int flags) diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c index 1859ecd9913..351e4dad799 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c @@ -687,10 +687,10 @@ zfs_copy_ace_2_fuid(zfsvfs_t *zfsvfs, umode_t obj_mode, zfs_acl_t *aclp, zobjacep = (zfs_object_ace_t *)aceptr; aceobjp = (ace_object_t *)acep; - bcopy(aceobjp->a_obj_type, zobjacep->z_object_type, + memcpy(zobjacep->z_object_type, aceobjp->a_obj_type, sizeof (aceobjp->a_obj_type)); - bcopy(aceobjp->a_inherit_obj_type, - zobjacep->z_inherit_type, + memcpy(zobjacep->z_inherit_type, + aceobjp->a_inherit_obj_type, sizeof (aceobjp->a_inherit_obj_type)); acep = (ace_t *)((caddr_t)acep + sizeof (ace_object_t)); break; @@ -737,11 +737,11 @@ zfs_copy_fuid_2_ace(zfsvfs_t *zfsvfs, zfs_acl_t *aclp, cred_t *cr, } zobjacep = (zfs_object_ace_t *)zacep; objacep = (ace_object_t *)acep; - bcopy(zobjacep->z_object_type, - objacep->a_obj_type, + memcpy(objacep->a_obj_type, + zobjacep->z_object_type, sizeof (zobjacep->z_object_type)); - bcopy(zobjacep->z_inherit_type, - objacep->a_inherit_obj_type, + memcpy(objacep->a_inherit_obj_type, + zobjacep->z_inherit_type, sizeof (zobjacep->z_inherit_type)); ace_size = sizeof (ace_object_t); break; @@ -1102,7 +1102,7 @@ zfs_acl_node_read(struct znode *zp, boolean_t have_lock, zfs_acl_t **aclpp, znode_acl.z_acl_extern_obj, 0, aclnode->z_size, aclnode->z_acldata, DMU_READ_PREFETCH); } else { - bcopy(znode_acl.z_ace_data, aclnode->z_acldata, + memcpy(aclnode->z_acldata, znode_acl.z_ace_data, aclnode->z_size); } } else { @@ -1447,7 +1447,7 @@ zfs_aclset_common(znode_t *zp, zfs_acl_t *aclp, cred_t *cr, dmu_tx_t *tx) aclnode = list_next(&aclp->z_acl, aclnode)) { if (aclnode->z_ace_count == 0) continue; - bcopy(aclnode->z_acldata, start, + memcpy(start, aclnode->z_acldata, aclnode->z_size); start = (caddr_t)start + aclnode->z_size; } @@ -1727,7 +1727,7 @@ zfs_acl_inherit(zfsvfs_t *zfsvfs, umode_t va_mode, zfs_acl_t *paclp, if ((data1sz = paclp->z_ops->ace_data(pacep, &data1)) != 0) { VERIFY((data2sz = aclp->z_ops->ace_data(acep, &data2)) == data1sz); - bcopy(data1, data2, data2sz); + memcpy(data2, data1, data2sz); } aclp->z_acl_count++; @@ -1791,7 +1791,7 @@ zfs_acl_ids_create(znode_t *dzp, int flag, vattr_t *vap, cred_t *cr, boolean_t trim = B_FALSE; boolean_t inherited = B_FALSE; - bzero(acl_ids, sizeof (zfs_acl_ids_t)); + memset(acl_ids, 0, sizeof (zfs_acl_ids_t)); acl_ids->z_mode = vap->va_mode; if (vsecp) @@ -2016,7 +2016,7 @@ zfs_getacl(znode_t *zp, vsecattr_t *vsecp, boolean_t skipaclchk, cred_t *cr) for (aclnode = list_head(&aclp->z_acl); aclnode; aclnode = list_next(&aclp->z_acl, aclnode)) { - bcopy(aclnode->z_acldata, start, + memcpy(start, aclnode->z_acldata, aclnode->z_size); start = (caddr_t)start + aclnode->z_size; } diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c index 82b32d1cc3f..c5b3b5ce7fc 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c @@ -297,7 +297,7 @@ zfs_dirent_lock(zfs_dirlock_t **dlpp, znode_t *dzp, char *name, */ dl->dl_namesize = strlen(dl->dl_name) + 1; name = kmem_alloc(dl->dl_namesize, KM_SLEEP); - bcopy(dl->dl_name, name, dl->dl_namesize); + memcpy(name, dl->dl_name, dl->dl_namesize); dl->dl_name = name; } @@ -625,7 +625,7 @@ zfs_purgedir(znode_t *dzp) skipped += 1; continue; } - bzero(&dl, sizeof (dl)); + memset(&dl, 0, sizeof (dl)); dl.dl_dzp = dzp; dl.dl_name = zap.za_name; diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_uio.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_uio.c index a3d5d5f83b6..ce47b3e6087 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_uio.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_uio.c @@ -44,7 +44,7 @@ #include #include #include -#include +#include #include #include @@ -103,9 +103,9 @@ zfs_uiomove_iov(void *p, size_t n, zfs_uio_rw_t rw, zfs_uio_t *uio) break; case UIO_SYSSPACE: if (rw == UIO_READ) - bcopy(p, iov->iov_base + skip, cnt); + memcpy(iov->iov_base + skip, p, cnt); else - bcopy(iov->iov_base + skip, p, cnt); + memcpy(p, iov->iov_base + skip, cnt); break; default: ASSERT(0); @@ -138,9 +138,9 @@ zfs_uiomove_bvec(void *p, size_t n, zfs_uio_rw_t rw, zfs_uio_t *uio) paddr = zfs_kmap_atomic(bv->bv_page); if (rw == UIO_READ) - bcopy(p, paddr + bv->bv_offset + skip, cnt); + memcpy(paddr + bv->bv_offset + skip, p, cnt); else - bcopy(paddr + bv->bv_offset + skip, p, cnt); + memcpy(p, paddr + bv->bv_offset + skip, cnt); zfs_kunmap_atomic(paddr); skip += cnt; @@ -275,7 +275,7 @@ zfs_uiocopy(void *p, size_t n, zfs_uio_rw_t rw, zfs_uio_t *uio, size_t *cbytes) zfs_uio_t uio_copy; int ret; - bcopy(uio, &uio_copy, sizeof (zfs_uio_t)); + memcpy(&uio_copy, uio, sizeof (zfs_uio_t)); if (uio->uio_segflg == UIO_BVEC) ret = zfs_uiomove_bvec(p, n, rw, &uio_copy); diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c index 412af0e8893..81a059651e8 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_vfsops.c @@ -1137,7 +1137,7 @@ zfs_statvfs(struct inode *ip, struct kstatfs *statp) * We have all of 40 characters to stuff a string here. * Is there anything useful we could/should provide? */ - bzero(statp->f_spare, sizeof (statp->f_spare)); + memset(statp->f_spare, 0, sizeof (statp->f_spare)); if (dmu_objset_projectquota_enabled(zfsvfs->z_os) && dmu_objset_projectquota_present(zfsvfs->z_os)) { diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c index d65d7531282..b76e65d1682 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c @@ -1581,7 +1581,7 @@ zfs_zero_partial_page(znode_t *zp, uint64_t start, uint64_t len) flush_dcache_page(pp); pb = kmap(pp); - bzero(pb + off, len); + memset(pb + off, 0, len); kunmap(pp); if (mapping_writably_mapped(mp)) @@ -2153,7 +2153,7 @@ zfs_obj_to_path_impl(objset_t *osp, uint64_t obj, sa_handle_t *hdl, component[0] = '/'; if (is_xattrdir) { - (void) sprintf(component + 1, ""); + strcpy(component + 1, ""); } else { error = zap_value_search(osp, pobj, obj, ZFS_DIRENT_OBJ(-1ULL), component + 1); @@ -2164,7 +2164,7 @@ zfs_obj_to_path_impl(objset_t *osp, uint64_t obj, sa_handle_t *hdl, complen = strlen(component); path -= complen; ASSERT(path >= buf); - bcopy(component, path, complen); + memcpy(path, component, complen); obj = pobj; if (sa_hdl != hdl) { diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c b/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c index 099d23484d3..dcab02b0789 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c @@ -216,7 +216,7 @@ zio_crypt_key_destroy(zio_crypt_key_t *key) crypto_destroy_ctx_template(key->zk_hmac_tmpl); /* zero out sensitive data */ - bzero(key, sizeof (zio_crypt_key_t)); + memset(key, 0, sizeof (zio_crypt_key_t)); } int @@ -230,7 +230,7 @@ zio_crypt_key_init(uint64_t crypt, zio_crypt_key_t *key) ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS); keydata_len = zio_crypt_table[crypt].ci_keylen; - bzero(key, sizeof (zio_crypt_key_t)); + memset(key, 0, sizeof (zio_crypt_key_t)); /* fill keydata buffers and salt with random data */ ret = random_get_bytes((uint8_t *)&key->zk_guid, sizeof (uint64_t)); @@ -317,7 +317,7 @@ zio_crypt_key_change_salt(zio_crypt_key_t *key) goto out_unlock; /* assign the salt and reset the usage count */ - bcopy(salt, key->zk_salt, ZIO_DATA_SALT_LEN); + memcpy(key->zk_salt, salt, ZIO_DATA_SALT_LEN); key->zk_salt_count = 0; /* destroy the old context template and create the new one */ @@ -346,7 +346,7 @@ zio_crypt_key_get_salt(zio_crypt_key_t *key, uint8_t *salt) rw_enter(&key->zk_salt_lock, RW_READER); - bcopy(key->zk_salt, salt, ZIO_DATA_SALT_LEN); + memcpy(salt, key->zk_salt, ZIO_DATA_SALT_LEN); salt_change = (atomic_inc_64_nv(&key->zk_salt_count) >= ZFS_CURRENT_MAX_SALT_USES); @@ -652,7 +652,7 @@ zio_crypt_generate_iv(uint8_t *ivbuf) return (0); error: - bzero(ivbuf, ZIO_DATA_IV_LEN); + memset(ivbuf, 0, ZIO_DATA_IV_LEN); return (ret); } @@ -693,12 +693,12 @@ zio_crypt_do_hmac(zio_crypt_key_t *key, uint8_t *data, uint_t datalen, goto error; } - bcopy(raw_digestbuf, digestbuf, digestlen); + memcpy(digestbuf, raw_digestbuf, digestlen); return (0); error: - bzero(digestbuf, digestlen); + memset(digestbuf, 0, digestlen); return (ret); } @@ -714,8 +714,8 @@ zio_crypt_generate_iv_salt_dedup(zio_crypt_key_t *key, uint8_t *data, if (ret != 0) return (ret); - bcopy(digestbuf, salt, ZIO_DATA_SALT_LEN); - bcopy(digestbuf + ZIO_DATA_SALT_LEN, ivbuf, ZIO_DATA_IV_LEN); + memcpy(salt, digestbuf, ZIO_DATA_SALT_LEN); + memcpy(ivbuf, digestbuf + ZIO_DATA_SALT_LEN, ZIO_DATA_IV_LEN); return (0); } @@ -738,18 +738,18 @@ zio_crypt_encode_params_bp(blkptr_t *bp, uint8_t *salt, uint8_t *iv) ASSERT(BP_IS_ENCRYPTED(bp)); if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(salt, &bp->blk_dva[2].dva_word[0], sizeof (uint64_t)); - bcopy(iv, &bp->blk_dva[2].dva_word[1], sizeof (uint64_t)); - bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); + memcpy(&bp->blk_dva[2].dva_word[0], salt, sizeof (uint64_t)); + memcpy(&bp->blk_dva[2].dva_word[1], iv, sizeof (uint64_t)); + memcpy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); BP_SET_IV2(bp, val32); } else { - bcopy(salt, &val64, sizeof (uint64_t)); + memcpy(&val64, salt, sizeof (uint64_t)); bp->blk_dva[2].dva_word[0] = BSWAP_64(val64); - bcopy(iv, &val64, sizeof (uint64_t)); + memcpy(&val64, iv, sizeof (uint64_t)); bp->blk_dva[2].dva_word[1] = BSWAP_64(val64); - bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); + memcpy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); BP_SET_IV2(bp, BSWAP_32(val32)); } } @@ -764,26 +764,26 @@ zio_crypt_decode_params_bp(const blkptr_t *bp, uint8_t *salt, uint8_t *iv) /* for convenience, so callers don't need to check */ if (BP_IS_AUTHENTICATED(bp)) { - bzero(salt, ZIO_DATA_SALT_LEN); - bzero(iv, ZIO_DATA_IV_LEN); + memset(salt, 0, ZIO_DATA_SALT_LEN); + memset(iv, 0, ZIO_DATA_IV_LEN); return; } if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(&bp->blk_dva[2].dva_word[0], salt, sizeof (uint64_t)); - bcopy(&bp->blk_dva[2].dva_word[1], iv, sizeof (uint64_t)); + memcpy(salt, &bp->blk_dva[2].dva_word[0], sizeof (uint64_t)); + memcpy(iv, &bp->blk_dva[2].dva_word[1], sizeof (uint64_t)); val32 = (uint32_t)BP_GET_IV2(bp); - bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); + memcpy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); } else { val64 = BSWAP_64(bp->blk_dva[2].dva_word[0]); - bcopy(&val64, salt, sizeof (uint64_t)); + memcpy(salt, &val64, sizeof (uint64_t)); val64 = BSWAP_64(bp->blk_dva[2].dva_word[1]); - bcopy(&val64, iv, sizeof (uint64_t)); + memcpy(iv, &val64, sizeof (uint64_t)); val32 = BSWAP_32((uint32_t)BP_GET_IV2(bp)); - bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t)); + memcpy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t)); } } @@ -796,14 +796,14 @@ zio_crypt_encode_mac_bp(blkptr_t *bp, uint8_t *mac) ASSERT3U(BP_GET_TYPE(bp), !=, DMU_OT_OBJSET); if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(mac, &bp->blk_cksum.zc_word[2], sizeof (uint64_t)); - bcopy(mac + sizeof (uint64_t), &bp->blk_cksum.zc_word[3], + memcpy(&bp->blk_cksum.zc_word[2], mac, sizeof (uint64_t)); + memcpy(&bp->blk_cksum.zc_word[3], mac + sizeof (uint64_t), sizeof (uint64_t)); } else { - bcopy(mac, &val64, sizeof (uint64_t)); + memcpy(&val64, mac, sizeof (uint64_t)); bp->blk_cksum.zc_word[2] = BSWAP_64(val64); - bcopy(mac + sizeof (uint64_t), &val64, sizeof (uint64_t)); + memcpy(&val64, mac + sizeof (uint64_t), sizeof (uint64_t)); bp->blk_cksum.zc_word[3] = BSWAP_64(val64); } } @@ -817,20 +817,20 @@ zio_crypt_decode_mac_bp(const blkptr_t *bp, uint8_t *mac) /* for convenience, so callers don't need to check */ if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) { - bzero(mac, ZIO_DATA_MAC_LEN); + memset(mac, 0, ZIO_DATA_MAC_LEN); return; } if (!BP_SHOULD_BYTESWAP(bp)) { - bcopy(&bp->blk_cksum.zc_word[2], mac, sizeof (uint64_t)); - bcopy(&bp->blk_cksum.zc_word[3], mac + sizeof (uint64_t), + memcpy(mac, &bp->blk_cksum.zc_word[2], sizeof (uint64_t)); + memcpy(mac + sizeof (uint64_t), &bp->blk_cksum.zc_word[3], sizeof (uint64_t)); } else { val64 = BSWAP_64(bp->blk_cksum.zc_word[2]); - bcopy(&val64, mac, sizeof (uint64_t)); + memcpy(mac, &val64, sizeof (uint64_t)); val64 = BSWAP_64(bp->blk_cksum.zc_word[3]); - bcopy(&val64, mac + sizeof (uint64_t), sizeof (uint64_t)); + memcpy(mac + sizeof (uint64_t), &val64, sizeof (uint64_t)); } } @@ -839,8 +839,8 @@ zio_crypt_encode_mac_zil(void *data, uint8_t *mac) { zil_chain_t *zilc = data; - bcopy(mac, &zilc->zc_eck.zec_cksum.zc_word[2], sizeof (uint64_t)); - bcopy(mac + sizeof (uint64_t), &zilc->zc_eck.zec_cksum.zc_word[3], + memcpy(&zilc->zc_eck.zec_cksum.zc_word[2], mac, sizeof (uint64_t)); + memcpy(&zilc->zc_eck.zec_cksum.zc_word[3], mac + sizeof (uint64_t), sizeof (uint64_t)); } @@ -854,8 +854,8 @@ zio_crypt_decode_mac_zil(const void *data, uint8_t *mac) */ const zil_chain_t *zilc = data; - bcopy(&zilc->zc_eck.zec_cksum.zc_word[2], mac, sizeof (uint64_t)); - bcopy(&zilc->zc_eck.zec_cksum.zc_word[3], mac + sizeof (uint64_t), + memcpy(mac, &zilc->zc_eck.zec_cksum.zc_word[2], sizeof (uint64_t)); + memcpy(mac + sizeof (uint64_t), &zilc->zc_eck.zec_cksum.zc_word[3], sizeof (uint64_t)); } @@ -882,7 +882,7 @@ zio_crypt_copy_dnode_bonus(abd_t *src_abd, uint8_t *dst, uint_t datalen) if (dnp->dn_type != DMU_OT_NONE && DMU_OT_IS_ENCRYPTED(dnp->dn_bonustype) && dnp->dn_bonuslen != 0) { - bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]), + memcpy(DN_BONUS(&ddnp[i]), DN_BONUS(dnp), DN_MAX_BONUS_LEN(dnp)); } } @@ -1024,7 +1024,7 @@ zio_crypt_bp_do_aad_updates(uint8_t **aadp, uint_t *aad_len, uint64_t version, blkptr_auth_buf_t bab; zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len); - bcopy(&bab, *aadp, bab_len); + memcpy(*aadp, &bab, bab_len); *aadp += bab_len; *aad_len += bab_len; } @@ -1048,7 +1048,7 @@ zio_crypt_do_dnode_hmac_updates(crypto_context_t ctx, uint64_t version, * of copying 512-64 unneeded bytes. The compiler seems to be fine * with that. */ - bcopy(dnp, &tmp_dncore, dn_core_size); + memcpy(&tmp_dncore, dnp, dn_core_size); adnp = &tmp_dncore; if (le_bswap) { @@ -1190,7 +1190,7 @@ zio_crypt_do_objset_hmacs(zio_crypt_key_t *key, void *data, uint_t datalen, goto error; } - bcopy(raw_portable_mac, portable_mac, ZIO_OBJSET_MAC_LEN); + memcpy(portable_mac, raw_portable_mac, ZIO_OBJSET_MAC_LEN); /* * This is necessary here as we check next whether @@ -1219,7 +1219,7 @@ zio_crypt_do_objset_hmacs(zio_crypt_key_t *key, void *data, uint_t datalen, osp->os_userused_dnode.dn_type == DMU_OT_NONE && osp->os_groupused_dnode.dn_type == DMU_OT_NONE) || (datalen <= OBJSET_PHYS_SIZE_V1)) { - bzero(local_mac, ZIO_OBJSET_MAC_LEN); + memset(local_mac, 0, ZIO_OBJSET_MAC_LEN); return (0); } @@ -1282,13 +1282,13 @@ zio_crypt_do_objset_hmacs(zio_crypt_key_t *key, void *data, uint_t datalen, goto error; } - bcopy(raw_local_mac, local_mac, ZIO_OBJSET_MAC_LEN); + memcpy(local_mac, raw_local_mac, ZIO_OBJSET_MAC_LEN); return (0); error: - bzero(portable_mac, ZIO_OBJSET_MAC_LEN); - bzero(local_mac, ZIO_OBJSET_MAC_LEN); + memset(portable_mac, 0, ZIO_OBJSET_MAC_LEN); + memset(local_mac, 0, ZIO_OBJSET_MAC_LEN); return (ret); } @@ -1324,11 +1324,11 @@ zio_crypt_do_indirect_mac_checksum_impl(boolean_t generate, void *buf, SHA2Final(digestbuf, &ctx); if (generate) { - bcopy(digestbuf, cksum, ZIO_DATA_MAC_LEN); + memcpy(cksum, digestbuf, ZIO_DATA_MAC_LEN); return (0); } - if (bcmp(digestbuf, cksum, ZIO_DATA_MAC_LEN) != 0) + if (memcmp(digestbuf, cksum, ZIO_DATA_MAC_LEN) != 0) return (SET_ERROR(ECKSUM)); return (0); @@ -1409,7 +1409,7 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, nr_src = 1; nr_dst = 0; } - bzero(dst, datalen); + memset(dst, 0, datalen); /* find the start and end record of the log block */ zilc = (zil_chain_t *)src; @@ -1460,8 +1460,8 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, * the embedded checksum will not have been calculated yet, so we don't * authenticate that. */ - bcopy(src, dst, sizeof (zil_chain_t)); - bcopy(src, aadp, sizeof (zil_chain_t) - sizeof (zio_eck_t)); + memcpy(dst, src, sizeof (zil_chain_t)); + memcpy(aadp, src, sizeof (zil_chain_t) - sizeof (zio_eck_t)); aadp += sizeof (zil_chain_t) - sizeof (zio_eck_t); aad_len += sizeof (zil_chain_t) - sizeof (zio_eck_t); @@ -1482,8 +1482,8 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, } /* copy the common lr_t */ - bcopy(slrp, dlrp, sizeof (lr_t)); - bcopy(slrp, aadp, sizeof (lr_t)); + memcpy(dlrp, slrp, sizeof (lr_t)); + memcpy(aadp, slrp, sizeof (lr_t)); aadp += sizeof (lr_t); aad_len += sizeof (lr_t); @@ -1504,11 +1504,12 @@ zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf, dst_iovecs[nr_iovecs].iov_len = crypt_len; /* copy the bp now since it will not be encrypted */ - bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t), - dlrp + sizeof (lr_write_t) - sizeof (blkptr_t), + memcpy(dlrp + sizeof (lr_write_t) - sizeof (blkptr_t), + slrp + sizeof (lr_write_t) - sizeof (blkptr_t), + sizeof (blkptr_t)); + memcpy(aadp, + slrp + sizeof (lr_write_t) - sizeof (blkptr_t), sizeof (blkptr_t)); - bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t), - aadp, sizeof (blkptr_t)); aadp += sizeof (blkptr_t); aad_len += sizeof (blkptr_t); nr_iovecs++; @@ -1655,10 +1656,11 @@ zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version, dnp = &sdnp[i]; /* copy over the core fields and blkptrs (kept as plaintext) */ - bcopy(dnp, &ddnp[i], (uint8_t *)DN_BONUS(dnp) - (uint8_t *)dnp); + memcpy(&ddnp[i], dnp, + (uint8_t *)DN_BONUS(dnp) - (uint8_t *)dnp); if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) { - bcopy(DN_SPILL_BLKPTR(dnp), DN_SPILL_BLKPTR(&ddnp[i]), + memcpy(DN_SPILL_BLKPTR(&ddnp[i]), DN_SPILL_BLKPTR(dnp), sizeof (blkptr_t)); } @@ -1673,7 +1675,7 @@ zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version, * authenticated data. */ crypt_len = offsetof(dnode_phys_t, dn_blkptr); - bcopy(dnp, aadp, crypt_len); + memcpy(aadp, dnp, crypt_len); adnp = (dnode_phys_t *)aadp; adnp->dn_flags &= DNODE_CRYPT_PORTABLE_FLAGS_MASK; adnp->dn_used = 0; @@ -1716,8 +1718,8 @@ zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version, nr_iovecs++; total_len += crypt_len; } else { - bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]), crypt_len); - bcopy(DN_BONUS(dnp), aadp, crypt_len); + memcpy(DN_BONUS(&ddnp[i]), DN_BONUS(dnp), crypt_len); + memcpy(aadp, DN_BONUS(dnp), crypt_len); aadp += crypt_len; aad_len += crypt_len; } @@ -1898,7 +1900,7 @@ zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key, rw_enter(&key->zk_salt_lock, RW_READER); locked = B_TRUE; - if (bcmp(salt, key->zk_salt, ZIO_DATA_SALT_LEN) == 0) { + if (memcmp(salt, key->zk_salt, ZIO_DATA_SALT_LEN) == 0) { ckey = &key->zk_current_key; tmpl = key->zk_current_tmpl; } else { @@ -1948,8 +1950,8 @@ zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key, /* If the hardware implementation fails fall back to software */ } - bzero(&puio, sizeof (zfs_uio_t)); - bzero(&cuio, sizeof (zfs_uio_t)); + memset(&puio, 0, sizeof (puio)); + memset(&cuio, 0, sizeof (cuio)); /* create uios for encryption */ ret = zio_crypt_init_uios(encrypt, key->zk_version, ot, plainbuf, @@ -1972,7 +1974,7 @@ zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key, if (authbuf != NULL) zio_buf_free(authbuf, datalen); if (ckey == &tmp_ckey) - bzero(enc_keydata, keydata_len); + memset(enc_keydata, 0, keydata_len); zio_crypt_destroy_uio(&puio); zio_crypt_destroy_uio(&cuio); @@ -1984,7 +1986,7 @@ error: if (authbuf != NULL) zio_buf_free(authbuf, datalen); if (ckey == &tmp_ckey) - bzero(enc_keydata, keydata_len); + memset(enc_keydata, 0, keydata_len); zio_crypt_destroy_uio(&puio); zio_crypt_destroy_uio(&cuio); diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c b/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c index 24a8b036bf0..4f79265a085 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c @@ -116,14 +116,14 @@ zpl_vap_init(vattr_t *vap, struct inode *dir, umode_t mode, cred_t *cr) { vap->va_mask = ATTR_MODE; vap->va_mode = mode; - vap->va_uid = crgetfsuid(cr); + vap->va_uid = crgetuid(cr); if (dir && dir->i_mode & S_ISGID) { vap->va_gid = KGID_TO_SGID(dir->i_gid); if (S_ISDIR(mode)) vap->va_mode |= S_ISGID; } else { - vap->va_gid = crgetfsgid(cr); + vap->va_gid = crgetgid(cr); } } diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c b/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c index 3b8ac517ada..c53bf3c2ab2 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c @@ -492,8 +492,8 @@ zpl_xattr_set_dir(struct inode *ip, const char *name, const void *value, vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP); vap->va_mode = xattr_mode; vap->va_mask = ATTR_MODE; - vap->va_uid = crgetfsuid(cr); - vap->va_gid = crgetfsgid(cr); + vap->va_uid = crgetuid(cr); + vap->va_gid = crgetgid(cr); error = -zfs_create(dxzp, (char *)name, vap, 0, 0644, &xzp, cr, 0, NULL); diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c b/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c index f772f416043..c964cce0de9 100644 --- a/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c +++ b/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c @@ -906,7 +906,7 @@ zvol_alloc(dev_t dev, const char *name) if (volmode == ZFS_VOLMODE_DEV) { /* * ZFS_VOLMODE_DEV disable partitioning on ZVOL devices: set - * gendisk->minors = 1 as noted in include/linux/genhd.h. + * gendisk->minors = 1 as noted in include/linux/blkdev.h. * Also disable extended partition numbers (GENHD_FL_EXT_DEVT) * and suppresses partition scanning (GENHD_FL_NO_PART_SCAN) * setting gendisk->flags accordingly. diff --git a/sys/contrib/openzfs/module/unicode/u8_textprep.c b/sys/contrib/openzfs/module/unicode/u8_textprep.c index 863f69f7ba8..b6b07b2453a 100644 --- a/sys/contrib/openzfs/module/unicode/u8_textprep.c +++ b/sys/contrib/openzfs/module/unicode/u8_textprep.c @@ -36,7 +36,7 @@ */ #include -#include +#include #include #include #include diff --git a/sys/contrib/openzfs/module/zcommon/zfs_deleg.c b/sys/contrib/openzfs/module/zcommon/zfs_deleg.c index 8a4a6ca86e1..acd2feca38e 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_deleg.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_deleg.c @@ -36,7 +36,7 @@ #include #include #endif -#include +#include #include #include "zfs_prop.h" #include "zfs_deleg.h" diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher.c index 16773d4de07..4606b5491da 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher.c @@ -126,8 +126,8 @@ * which has been filled either by: * * 1. a compression step, which will be mostly cached, or - * 2. a bcopy() or copyin(), which will be uncached (because the - * copy is cache-bypassing). + * 2. a memcpy() or copyin(), which will be uncached + * (because the copy is cache-bypassing). * * For both cached and uncached data, both fletcher checksums are much faster * than sha-256, and slower than 'off', which doesn't touch the data at all. diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_aarch64_neon.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_aarch64_neon.c index e84d69eb341..3e14875d6c8 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_aarch64_neon.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_aarch64_neon.c @@ -45,14 +45,14 @@ #include #include -#include +#include #include ZFS_NO_SANITIZE_UNDEFINED static void fletcher_4_aarch64_neon_init(fletcher_4_ctx_t *ctx) { - bzero(ctx->aarch64_neon, 4 * sizeof (zfs_fletcher_aarch64_neon_t)); + memset(ctx->aarch64_neon, 0, 4 * sizeof (zfs_fletcher_aarch64_neon_t)); } ZFS_NO_SANITIZE_UNDEFINED diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c index 8ee438ab932..713806d2825 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include #include @@ -39,7 +39,7 @@ ZFS_NO_SANITIZE_UNDEFINED static void fletcher_4_avx512f_init(fletcher_4_ctx_t *ctx) { - bzero(ctx->avx512, 4 * sizeof (zfs_fletcher_avx512_t)); + memset(ctx->avx512, 0, 4 * sizeof (zfs_fletcher_avx512_t)); } ZFS_NO_SANITIZE_UNDEFINED diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_intel.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_intel.c index 16e61a96f8b..42b6309d360 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_intel.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_intel.c @@ -43,15 +43,15 @@ #if defined(HAVE_AVX) && defined(HAVE_AVX2) #include +#include #include -#include #include ZFS_NO_SANITIZE_UNDEFINED static void fletcher_4_avx2_init(fletcher_4_ctx_t *ctx) { - bzero(ctx->avx, 4 * sizeof (zfs_fletcher_avx_t)); + memset(ctx->avx, 0, 4 * sizeof (zfs_fletcher_avx_t)); } ZFS_NO_SANITIZE_UNDEFINED diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_sse.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_sse.c index fc5938488e6..791bbd49f68 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_sse.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_sse.c @@ -45,15 +45,15 @@ #include #include +#include #include -#include #include ZFS_NO_SANITIZE_UNDEFINED static void fletcher_4_sse2_init(fletcher_4_ctx_t *ctx) { - bzero(ctx->sse, 4 * sizeof (zfs_fletcher_sse_t)); + memset(ctx->sse, 0, 4 * sizeof (zfs_fletcher_sse_t)); } ZFS_NO_SANITIZE_UNDEFINED diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar.c index 73a74b9ae0a..ba3fb54cbcf 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar.c @@ -44,14 +44,14 @@ #include #include #include -#include +#include #include ZFS_NO_SANITIZE_UNDEFINED static void fletcher_4_superscalar_init(fletcher_4_ctx_t *ctx) { - bzero(ctx->superscalar, 4 * sizeof (zfs_fletcher_superscalar_t)); + memset(ctx->superscalar, 0, 4 * sizeof (zfs_fletcher_superscalar_t)); } ZFS_NO_SANITIZE_UNDEFINED diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar4.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar4.c index 2dbf8bbb814..e3eda029590 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar4.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_superscalar4.c @@ -44,14 +44,14 @@ #include #include #include -#include +#include #include ZFS_NO_SANITIZE_UNDEFINED static void fletcher_4_superscalar4_init(fletcher_4_ctx_t *ctx) { - bzero(ctx->superscalar, 4 * sizeof (zfs_fletcher_superscalar_t)); + memset(ctx->superscalar, 0, 4 * sizeof (zfs_fletcher_superscalar_t)); } ZFS_NO_SANITIZE_UNDEFINED diff --git a/sys/contrib/openzfs/module/zcommon/zfs_prop.c b/sys/contrib/openzfs/module/zcommon/zfs_prop.c index 0d573506681..8b3e774d99e 100644 --- a/sys/contrib/openzfs/module/zcommon/zfs_prop.c +++ b/sys/contrib/openzfs/module/zcommon/zfs_prop.c @@ -1001,10 +1001,10 @@ zfs_prop_align_right(zfs_prop_t prop) #include -#if defined(HAVE_KERNEL_FPU_INTERNAL) || defined(HAVE_KERNEL_FPU_XSAVE_INTERNAL) -union fpregs_state **zfs_kfpu_fpregs; +#if defined(HAVE_KERNEL_FPU_INTERNAL) +uint8_t **zfs_kfpu_fpregs; EXPORT_SYMBOL(zfs_kfpu_fpregs); -#endif /* HAVE_KERNEL_FPU_INTERNAL || HAVE_KERNEL_FPU_XSAVE_INTERNAL */ +#endif /* defined(HAVE_KERNEL_FPU_INTERNAL) */ static int __init zcommon_init(void) diff --git a/sys/contrib/openzfs/module/zfs/aggsum.c b/sys/contrib/openzfs/module/zfs/aggsum.c index c4ea4f86fc5..488c6ef3b6f 100644 --- a/sys/contrib/openzfs/module/zfs/aggsum.c +++ b/sys/contrib/openzfs/module/zfs/aggsum.c @@ -87,7 +87,7 @@ static uint_t aggsum_borrow_shift = 4; void aggsum_init(aggsum_t *as, uint64_t value) { - bzero(as, sizeof (*as)); + memset(as, 0, sizeof (*as)); as->as_lower_bound = as->as_upper_bound = value; mutex_init(&as->as_lock, NULL, MUTEX_DEFAULT, NULL); /* diff --git a/sys/contrib/openzfs/module/zfs/arc.c b/sys/contrib/openzfs/module/zfs/arc.c index 744df24235e..79e754c4abc 100644 --- a/sys/contrib/openzfs/module/zfs/arc.c +++ b/sys/contrib/openzfs/module/zfs/arc.c @@ -250,7 +250,7 @@ * since the physical block is about to be rewritten. The new data contents * will be contained in the arc_buf_t. As the I/O pipeline performs the write, * it may compress the data before writing it to disk. The ARC will be called - * with the transformed data and will bcopy the transformed on-disk block into + * with the transformed data and will memcpy the transformed on-disk block into * a newly allocated b_pabd. Writes are always done into buffers which have * either been loaned (and hence are new and don't have other readers) or * buffers which have been released (and hence have their own hdr, if there @@ -928,7 +928,7 @@ static unsigned long l2arc_rebuild_blocks_min_l2size = 1024 * 1024 * 1024; /* L2ARC persistence rebuild control routines. */ void l2arc_rebuild_vdev(vdev_t *vd, boolean_t reopen); -static _Noreturn void l2arc_dev_rebuild_thread(void *arg); +static __attribute__((noreturn)) void l2arc_dev_rebuild_thread(void *arg); static int l2arc_rebuild(l2arc_dev_t *dev); /* L2ARC persistence read I/O routines. */ @@ -1132,7 +1132,7 @@ hdr_full_cons(void *vbuf, void *unused, int kmflag) (void) unused, (void) kmflag; arc_buf_hdr_t *hdr = vbuf; - bzero(hdr, HDR_FULL_SIZE); + memset(hdr, 0, HDR_FULL_SIZE); hdr->b_l1hdr.b_byteswap = DMU_BSWAP_NUMFUNCS; cv_init(&hdr->b_l1hdr.b_cv, NULL, CV_DEFAULT, NULL); zfs_refcount_create(&hdr->b_l1hdr.b_refcnt); @@ -1152,7 +1152,7 @@ hdr_full_crypt_cons(void *vbuf, void *unused, int kmflag) arc_buf_hdr_t *hdr = vbuf; hdr_full_cons(vbuf, unused, kmflag); - bzero(&hdr->b_crypt_hdr, sizeof (hdr->b_crypt_hdr)); + memset(&hdr->b_crypt_hdr, 0, sizeof (hdr->b_crypt_hdr)); arc_space_consume(sizeof (hdr->b_crypt_hdr), ARC_SPACE_HDRS); return (0); @@ -1164,7 +1164,7 @@ hdr_l2only_cons(void *vbuf, void *unused, int kmflag) (void) unused, (void) kmflag; arc_buf_hdr_t *hdr = vbuf; - bzero(hdr, HDR_L2ONLY_SIZE); + memset(hdr, 0, HDR_L2ONLY_SIZE); arc_space_consume(HDR_L2ONLY_SIZE, ARC_SPACE_L2HDRS); return (0); @@ -1176,7 +1176,7 @@ buf_cons(void *vbuf, void *unused, int kmflag) (void) unused, (void) kmflag; arc_buf_t *buf = vbuf; - bzero(buf, sizeof (arc_buf_t)); + memset(buf, 0, sizeof (arc_buf_t)); mutex_init(&buf->b_evict_lock, NULL, MUTEX_DEFAULT, NULL); arc_space_consume(sizeof (arc_buf_t), ARC_SPACE_HDRS); @@ -1204,11 +1204,11 @@ hdr_full_dest(void *vbuf, void *unused) static void hdr_full_crypt_dest(void *vbuf, void *unused) { - (void) unused; - arc_buf_hdr_t *hdr = vbuf; + (void) vbuf, (void) unused; hdr_full_dest(vbuf, unused); - arc_space_return(sizeof (hdr->b_crypt_hdr), ARC_SPACE_HDRS); + arc_space_return(sizeof (((arc_buf_hdr_t *)NULL)->b_crypt_hdr), + ARC_SPACE_HDRS); } static void @@ -1332,9 +1332,9 @@ arc_get_raw_params(arc_buf_t *buf, boolean_t *byteorder, uint8_t *salt, ASSERT(HDR_PROTECTED(hdr)); - bcopy(hdr->b_crypt_hdr.b_salt, salt, ZIO_DATA_SALT_LEN); - bcopy(hdr->b_crypt_hdr.b_iv, iv, ZIO_DATA_IV_LEN); - bcopy(hdr->b_crypt_hdr.b_mac, mac, ZIO_DATA_MAC_LEN); + memcpy(salt, hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN); + memcpy(iv, hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN); + memcpy(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN); *byteorder = (hdr->b_l1hdr.b_byteswap == DMU_BSWAP_NUMFUNCS) ? ZFS_HOST_BYTEORDER : !ZFS_HOST_BYTEORDER; } @@ -1692,7 +1692,7 @@ arc_buf_try_copy_decompressed_data(arc_buf_t *buf) } if (!ARC_BUF_COMPRESSED(from)) { - bcopy(from->b_data, buf->b_data, arc_buf_size(buf)); + memcpy(buf->b_data, from->b_data, arc_buf_size(buf)); copied = B_TRUE; break; } @@ -3349,7 +3349,7 @@ arc_hdr_realloc(arc_buf_hdr_t *hdr, kmem_cache_t *old, kmem_cache_t *new) ASSERT(MUTEX_HELD(HDR_LOCK(hdr))); buf_hash_remove(hdr); - bcopy(hdr, nhdr, HDR_L2ONLY_SIZE); + memcpy(nhdr, hdr, HDR_L2ONLY_SIZE); if (new == hdr_full_cache || new == hdr_full_crypt_cache) { arc_hdr_set_flags(nhdr, ARC_FLAG_HAS_L1HDR); @@ -3512,7 +3512,7 @@ arc_hdr_realloc_crypt(arc_buf_hdr_t *hdr, boolean_t need_crypt) } /* unset all members of the original hdr */ - bzero(&hdr->b_dva, sizeof (dva_t)); + memset(&hdr->b_dva, 0, sizeof (dva_t)); hdr->b_birth = 0; hdr->b_type = ARC_BUFC_INVALID; hdr->b_flags = 0; @@ -3537,9 +3537,9 @@ arc_hdr_realloc_crypt(arc_buf_hdr_t *hdr, boolean_t need_crypt) hdr->b_crypt_hdr.b_ot = DMU_OT_NONE; hdr->b_crypt_hdr.b_ebufcnt = 0; hdr->b_crypt_hdr.b_dsobj = 0; - bzero(hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN); - bzero(hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN); - bzero(hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN); + memset(hdr->b_crypt_hdr.b_salt, 0, ZIO_DATA_SALT_LEN); + memset(hdr->b_crypt_hdr.b_iv, 0, ZIO_DATA_IV_LEN); + memset(hdr->b_crypt_hdr.b_mac, 0, ZIO_DATA_MAC_LEN); } buf_discard_identity(hdr); @@ -3577,11 +3577,11 @@ arc_convert_to_raw(arc_buf_t *buf, uint64_t dsobj, boolean_t byteorder, arc_cksum_free(hdr); if (salt != NULL) - bcopy(salt, hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN); + memcpy(hdr->b_crypt_hdr.b_salt, salt, ZIO_DATA_SALT_LEN); if (iv != NULL) - bcopy(iv, hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN); + memcpy(hdr->b_crypt_hdr.b_iv, iv, ZIO_DATA_IV_LEN); if (mac != NULL) - bcopy(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN); + memcpy(hdr->b_crypt_hdr.b_mac, mac, ZIO_DATA_MAC_LEN); } /* @@ -3657,9 +3657,9 @@ arc_alloc_raw_buf(spa_t *spa, void *tag, uint64_t dsobj, boolean_t byteorder, hdr->b_crypt_hdr.b_ot = ot; hdr->b_l1hdr.b_byteswap = (byteorder == ZFS_HOST_BYTEORDER) ? DMU_BSWAP_NUMFUNCS : DMU_OT_BYTESWAP(ot); - bcopy(salt, hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN); - bcopy(iv, hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN); - bcopy(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN); + memcpy(hdr->b_crypt_hdr.b_salt, salt, ZIO_DATA_SALT_LEN); + memcpy(hdr->b_crypt_hdr.b_iv, iv, ZIO_DATA_IV_LEN); + memcpy(hdr->b_crypt_hdr.b_mac, mac, ZIO_DATA_MAC_LEN); /* * This buffer will be considered encrypted even if the ot is not an @@ -5643,7 +5643,7 @@ arc_bcopy_func(zio_t *zio, const zbookmark_phys_t *zb, const blkptr_t *bp, if (buf == NULL) return; - bcopy(buf->b_data, arg, arc_buf_size(buf)); + memcpy(arg, buf->b_data, arc_buf_size(buf)); arc_buf_destroy(buf, arg); } @@ -7106,11 +7106,11 @@ arc_write(zio_t *pio, spa_t *spa, uint64_t txg, localprop.zp_byteorder = (hdr->b_l1hdr.b_byteswap == DMU_BSWAP_NUMFUNCS) ? ZFS_HOST_BYTEORDER : !ZFS_HOST_BYTEORDER; - bcopy(hdr->b_crypt_hdr.b_salt, localprop.zp_salt, + memcpy(localprop.zp_salt, hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN); - bcopy(hdr->b_crypt_hdr.b_iv, localprop.zp_iv, + memcpy(localprop.zp_iv, hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN); - bcopy(hdr->b_crypt_hdr.b_mac, localprop.zp_mac, + memcpy(localprop.zp_mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN); if (DMU_OT_IS_ENCRYPTED(localprop.zp_type)) { localprop.zp_nopwrite = B_FALSE; @@ -8722,14 +8722,15 @@ top: * block pointer in the header. */ if (i == 0) { - bzero(l2dhdr, dev->l2ad_dev_hdr_asize); + memset(l2dhdr, 0, + dev->l2ad_dev_hdr_asize); } else { - bzero(&l2dhdr->dh_start_lbps[i], + memset(&l2dhdr->dh_start_lbps[i], 0, sizeof (l2arc_log_blkptr_t)); } break; } - bcopy(lb_ptr_buf->lb_ptr, &l2dhdr->dh_start_lbps[i], + memcpy(&l2dhdr->dh_start_lbps[i], lb_ptr_buf->lb_ptr, sizeof (l2arc_log_blkptr_t)); lb_ptr_buf = list_next(&dev->l2ad_lbptr_list, lb_ptr_buf); @@ -9353,7 +9354,7 @@ l2arc_apply_transforms(spa_t *spa, arc_buf_hdr_t *hdr, uint64_t asize, } ASSERT3U(psize, <=, HDR_GET_PSIZE(hdr)); if (psize < asize) - bzero((char *)tmp + psize, asize - psize); + memset((char *)tmp + psize, 0, asize - psize); psize = HDR_GET_PSIZE(hdr); abd_return_buf_copy(cabd, tmp, asize); to_write = cabd; @@ -9388,7 +9389,7 @@ encrypt: abd_zero_off(eabd, psize, asize - psize); /* assert that the MAC we got here matches the one we saved */ - ASSERT0(bcmp(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN)); + ASSERT0(memcmp(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN)); spa_keystore_dsl_key_rele(spa, dck, FTAG); if (to_write == cabd) @@ -9706,7 +9707,7 @@ l2arc_hdr_limit_reached(void) * This thread feeds the L2ARC at regular intervals. This is the beating * heart of the L2ARC. */ -static _Noreturn void +static __attribute__((noreturn)) void l2arc_feed_thread(void *unused) { (void) unused; @@ -9897,7 +9898,7 @@ l2arc_rebuild_dev(l2arc_dev_t *dev, boolean_t reopen) if (l2arc_trim_ahead > 0) { dev->l2ad_trim_all = B_TRUE; } else { - bzero(l2dhdr, l2dhdr_asize); + memset(l2dhdr, 0, l2dhdr_asize); l2arc_dev_hdr_update(dev); } } @@ -10145,7 +10146,7 @@ l2arc_spa_rebuild_start(spa_t *spa) /* * Main entry point for L2ARC rebuilding. */ -static _Noreturn void +static __attribute__((noreturn)) void l2arc_dev_rebuild_thread(void *arg) { l2arc_dev_t *dev = arg; @@ -10218,7 +10219,7 @@ l2arc_rebuild(l2arc_dev_t *dev) goto out; /* Prepare the rebuild process */ - bcopy(l2dhdr->dh_start_lbps, lbps, sizeof (lbps)); + memcpy(lbps, l2dhdr->dh_start_lbps, sizeof (lbps)); /* Start the rebuild process */ for (;;) { @@ -10264,7 +10265,7 @@ l2arc_rebuild(l2arc_dev_t *dev) lb_ptr_buf = kmem_zalloc(sizeof (l2arc_lb_ptr_buf_t), KM_SLEEP); lb_ptr_buf->lb_ptr = kmem_zalloc(sizeof (l2arc_log_blkptr_t), KM_SLEEP); - bcopy(&lbps[0], lb_ptr_buf->lb_ptr, + memcpy(lb_ptr_buf->lb_ptr, &lbps[0], sizeof (l2arc_log_blkptr_t)); mutex_enter(&dev->l2ad_mtx); list_insert_tail(&dev->l2ad_lbptr_list, lb_ptr_buf); @@ -10362,7 +10363,7 @@ out: */ spa_history_log_internal(spa, "L2ARC rebuild", NULL, "no valid log blocks"); - bzero(l2dhdr, dev->l2ad_dev_hdr_asize); + memset(l2dhdr, 0, dev->l2ad_dev_hdr_asize); l2arc_dev_hdr_update(dev); } else if (err == ECANCELED) { /* @@ -10853,13 +10854,13 @@ l2arc_log_blk_commit(l2arc_dev_t *dev, zio_t *pio, l2arc_write_callback_t *cb) ZIO_CHECKSUM_FLETCHER_4); if (asize < sizeof (*lb)) { /* compression succeeded */ - bzero(tmpbuf + psize, asize - psize); + memset(tmpbuf + psize, 0, asize - psize); L2BLK_SET_COMPRESS( (&l2dhdr->dh_start_lbps[0])->lbp_prop, ZIO_COMPRESS_LZ4); } else { /* compression failed */ - bcopy(lb, tmpbuf, sizeof (*lb)); + memcpy(tmpbuf, lb, sizeof (*lb)); L2BLK_SET_COMPRESS( (&l2dhdr->dh_start_lbps[0])->lbp_prop, ZIO_COMPRESS_OFF); @@ -10885,7 +10886,7 @@ l2arc_log_blk_commit(l2arc_dev_t *dev, zio_t *pio, l2arc_write_callback_t *cb) * Include the committed log block's pointer in the list of pointers * to log blocks present in the L2ARC device. */ - bcopy(&l2dhdr->dh_start_lbps[0], lb_ptr_buf->lb_ptr, + memcpy(lb_ptr_buf->lb_ptr, &l2dhdr->dh_start_lbps[0], sizeof (l2arc_log_blkptr_t)); mutex_enter(&dev->l2ad_mtx); list_insert_head(&dev->l2ad_lbptr_list, lb_ptr_buf); @@ -10974,7 +10975,7 @@ l2arc_log_blk_insert(l2arc_dev_t *dev, const arc_buf_hdr_t *hdr) ASSERT(HDR_HAS_L2HDR(hdr)); le = &lb->lb_entries[index]; - bzero(le, sizeof (*le)); + memset(le, 0, sizeof (*le)); le->le_dva = hdr->b_dva; le->le_birth = hdr->b_birth; le->le_daddr = hdr->b_l2hdr.b_daddr; diff --git a/sys/contrib/openzfs/module/zfs/blkptr.c b/sys/contrib/openzfs/module/zfs/blkptr.c index aa09ded8dba..d85f0737f6f 100644 --- a/sys/contrib/openzfs/module/zfs/blkptr.c +++ b/sys/contrib/openzfs/module/zfs/blkptr.c @@ -58,7 +58,7 @@ encode_embedded_bp_compressed(blkptr_t *bp, void *data, ASSERT3U(comp, >=, ZIO_COMPRESS_OFF); ASSERT3U(comp, <, ZIO_COMPRESS_FUNCTIONS); - bzero(bp, sizeof (*bp)); + memset(bp, 0, sizeof (*bp)); BP_SET_EMBEDDED(bp, B_TRUE); BP_SET_COMPRESS(bp, comp); BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER); diff --git a/sys/contrib/openzfs/module/zfs/bpobj.c b/sys/contrib/openzfs/module/zfs/bpobj.c index 68f534c6b19..fb29ccfe31e 100644 --- a/sys/contrib/openzfs/module/zfs/bpobj.c +++ b/sys/contrib/openzfs/module/zfs/bpobj.c @@ -156,7 +156,7 @@ bpobj_open(bpobj_t *bpo, objset_t *os, uint64_t object) if (err) return (err); - bzero(bpo, sizeof (*bpo)); + memset(bpo, 0, sizeof (*bpo)); mutex_init(&bpo->bpo_lock, NULL, MUTEX_DEFAULT, NULL); ASSERT(bpo->bpo_dbuf == NULL); @@ -805,12 +805,12 @@ bpobj_enqueue(bpobj_t *bpo, const blkptr_t *bp, boolean_t bp_freed, * set of BP's stored, and bpobj_iterate() wouldn't visit * all the space accounted for in the bpobj. */ - bzero(&stored_bp, sizeof (stored_bp)); + memset(&stored_bp, 0, sizeof (stored_bp)); stored_bp.blk_prop = bp->blk_prop; stored_bp.blk_birth = bp->blk_birth; } else if (!BP_GET_DEDUP(bp)) { /* The bpobj will compress better without the checksum */ - bzero(&stored_bp.blk_cksum, sizeof (stored_bp.blk_cksum)); + memset(&stored_bp.blk_cksum, 0, sizeof (stored_bp.blk_cksum)); } stored_bp.blk_fill = 0; diff --git a/sys/contrib/openzfs/module/zfs/btree.c b/sys/contrib/openzfs/module/zfs/btree.c index 5bcf621d599..a079929b5bc 100644 --- a/sys/contrib/openzfs/module/zfs/btree.c +++ b/sys/contrib/openzfs/module/zfs/btree.c @@ -159,7 +159,7 @@ zfs_btree_create(zfs_btree_t *tree, int (*compar) (const void *, const void *), */ ASSERT3U(size, <=, (BTREE_LEAF_SIZE - sizeof (zfs_btree_hdr_t)) / 4); - bzero(tree, sizeof (*tree)); + memset(tree, 0, sizeof (*tree)); tree->bt_compar = compar; tree->bt_elem_size = size; tree->bt_height = -1; diff --git a/sys/contrib/openzfs/module/zfs/dataset_kstats.c b/sys/contrib/openzfs/module/zfs/dataset_kstats.c index 3fbb24ddef5..6b4b31e8c9c 100644 --- a/sys/contrib/openzfs/module/zfs/dataset_kstats.c +++ b/sys/contrib/openzfs/module/zfs/dataset_kstats.c @@ -123,7 +123,7 @@ dataset_kstats_create(dataset_kstats_t *dk, objset_t *objset) dataset_kstat_values_t *dk_kstats = kmem_alloc(sizeof (empty_dataset_kstats), KM_SLEEP); - bcopy(&empty_dataset_kstats, dk_kstats, + memcpy(dk_kstats, &empty_dataset_kstats, sizeof (empty_dataset_kstats)); char *ds_name = kmem_zalloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); diff --git a/sys/contrib/openzfs/module/zfs/dbuf.c b/sys/contrib/openzfs/module/zfs/dbuf.c index cb2b7e5a1de..ee2470b3860 100644 --- a/sys/contrib/openzfs/module/zfs/dbuf.c +++ b/sys/contrib/openzfs/module/zfs/dbuf.c @@ -280,7 +280,7 @@ dbuf_cons(void *vdb, void *unused, int kmflag) { (void) unused, (void) kmflag; dmu_buf_impl_t *db = vdb; - bzero(db, sizeof (dmu_buf_impl_t)); + memset(db, 0, sizeof (dmu_buf_impl_t)); mutex_init(&db->db_mtx, NULL, MUTEX_DEFAULT, NULL); rw_init(&db->db_rwlock, NULL, RW_DEFAULT, NULL); @@ -778,7 +778,7 @@ dbuf_evict_one(void) * of the dbuf cache is at or below the maximum size. Once the dbuf is aged * out of the cache it is destroyed and becomes eligible for arc eviction. */ -static _Noreturn void +static __attribute__((noreturn)) void dbuf_evict_thread(void *unused) { (void) unused; @@ -1235,7 +1235,7 @@ dbuf_loan_arcbuf(dmu_buf_impl_t *db) mutex_exit(&db->db_mtx); abuf = arc_loan_buf(spa, B_FALSE, blksz); - bcopy(db->db.db_data, abuf->b_data, blksz); + memcpy(abuf->b_data, db->db.db_data, blksz); } else { abuf = db->db_buf; arc_loan_inuse_buf(abuf, db); @@ -1356,7 +1356,7 @@ dbuf_read_done(zio_t *zio, const zbookmark_phys_t *zb, const blkptr_t *bp, /* freed in flight */ ASSERT(zio == NULL || zio->io_error == 0); arc_release(buf, db); - bzero(buf->b_data, db->db.db_size); + memset(buf->b_data, 0, db->db.db_size); arc_buf_freeze(buf); db->db_freed_in_flight = FALSE; dbuf_set_data(db, buf); @@ -1395,9 +1395,9 @@ dbuf_read_bonus(dmu_buf_impl_t *db, dnode_t *dn, uint32_t flags) db->db.db_data = kmem_alloc(max_bonuslen, KM_SLEEP); arc_space_consume(max_bonuslen, ARC_SPACE_BONUS); if (bonuslen < max_bonuslen) - bzero(db->db.db_data, max_bonuslen); + memset(db->db.db_data, 0, max_bonuslen); if (bonuslen) - bcopy(DN_BONUS(dn->dn_phys), db->db.db_data, bonuslen); + memcpy(db->db.db_data, DN_BONUS(dn->dn_phys), bonuslen); db->db_state = DB_CACHED; DTRACE_SET_STATE(db, "bonus buffer filled"); return (0); @@ -1446,7 +1446,7 @@ dbuf_read_hole(dmu_buf_impl_t *db, dnode_t *dn) if (is_hole) { dbuf_set_data(db, dbuf_alloc_arcbuf(db)); - bzero(db->db.db_data, db->db.db_size); + memset(db->db.db_data, 0, db->db.db_size); if (db->db_blkptr != NULL && db->db_level > 0 && BP_IS_HOLE(db->db_blkptr) && @@ -1657,7 +1657,7 @@ dbuf_fix_old_data(dmu_buf_impl_t *db, uint64_t txg) int bonuslen = DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots); dr->dt.dl.dr_data = kmem_alloc(bonuslen, KM_SLEEP); arc_space_consume(bonuslen, ARC_SPACE_BONUS); - bcopy(db->db.db_data, dr->dt.dl.dr_data, bonuslen); + memcpy(dr->dt.dl.dr_data, db->db.db_data, bonuslen); } else if (zfs_refcount_count(&db->db_holds) > db->db_dirtycnt) { dnode_t *dn = DB_DNODE(db); int size = arc_buf_size(db->db_buf); @@ -1687,7 +1687,7 @@ dbuf_fix_old_data(dmu_buf_impl_t *db, uint64_t txg) } else { dr->dt.dl.dr_data = arc_alloc_buf(spa, db, type, size); } - bcopy(db->db.db_data, dr->dt.dl.dr_data->b_data, size); + memcpy(dr->dt.dl.dr_data->b_data, db->db.db_data, size); } else { db->db_buf = NULL; dbuf_clear_data(db); @@ -1985,7 +1985,7 @@ dbuf_free_range(dnode_t *dn, uint64_t start_blkid, uint64_t end_blkid, ASSERT(db->db.db_data != NULL); arc_release(db->db_buf, db); rw_enter(&db->db_rwlock, RW_WRITER); - bzero(db->db.db_data, db->db.db_size); + memset(db->db.db_data, 0, db->db.db_size); rw_exit(&db->db_rwlock); arc_buf_freeze(db->db_buf); } @@ -2022,10 +2022,10 @@ dbuf_new_size(dmu_buf_impl_t *db, int size, dmu_tx_t *tx) /* copy old block data to the new block */ old_buf = db->db_buf; - bcopy(old_buf->b_data, buf->b_data, MIN(osize, size)); + memcpy(buf->b_data, old_buf->b_data, MIN(osize, size)); /* zero the remainder */ if (size > osize) - bzero((uint8_t *)buf->b_data + osize, size - osize); + memset((uint8_t *)buf->b_data + osize, 0, size - osize); mutex_enter(&db->db_mtx); dbuf_set_data(db, buf); @@ -2655,9 +2655,9 @@ dmu_buf_set_crypt_params(dmu_buf_t *db_fake, boolean_t byteorder, dr->dt.dl.dr_has_raw_params = B_TRUE; dr->dt.dl.dr_byteorder = byteorder; - bcopy(salt, dr->dt.dl.dr_salt, ZIO_DATA_SALT_LEN); - bcopy(iv, dr->dt.dl.dr_iv, ZIO_DATA_IV_LEN); - bcopy(mac, dr->dt.dl.dr_mac, ZIO_DATA_MAC_LEN); + memcpy(dr->dt.dl.dr_salt, salt, ZIO_DATA_SALT_LEN); + memcpy(dr->dt.dl.dr_iv, iv, ZIO_DATA_IV_LEN); + memcpy(dr->dt.dl.dr_mac, mac, ZIO_DATA_MAC_LEN); } static void @@ -2690,7 +2690,7 @@ dmu_buf_fill_done(dmu_buf_t *dbuf, dmu_tx_t *tx) ASSERT(db->db_blkid != DMU_BONUS_BLKID); /* we were freed while filling */ /* XXX dbuf_undirty? */ - bzero(db->db.db_data, db->db.db_size); + memset(db->db.db_data, 0, db->db.db_size); db->db_freed_in_flight = FALSE; DTRACE_SET_STATE(db, "fill done handling freed in flight"); @@ -2802,7 +2802,7 @@ dbuf_assign_arcbuf(dmu_buf_impl_t *db, arc_buf_t *buf, dmu_tx_t *tx) ASSERT(!arc_is_encrypted(buf)); mutex_exit(&db->db_mtx); (void) dbuf_dirty(db, tx); - bcopy(buf->b_data, db->db.db_data, db->db.db_size); + memcpy(db->db.db_data, buf->b_data, db->db.db_size); arc_buf_destroy(buf, db); return; } @@ -3516,7 +3516,7 @@ dbuf_hold_copy(dnode_t *dn, dmu_buf_impl_t *db) } rw_enter(&db->db_rwlock, RW_WRITER); - bcopy(data->b_data, db->db.db_data, arc_buf_size(data)); + memcpy(db->db.db_data, data->b_data, arc_buf_size(data)); rw_exit(&db->db_rwlock); } @@ -4040,7 +4040,7 @@ dbuf_sync_bonus(dbuf_dirty_record_t *dr, dmu_tx_t *tx) dnode_t *dn = dr->dr_dnode; ASSERT3U(DN_MAX_BONUS_LEN(dn->dn_phys), <=, DN_SLOTS_TO_BONUSLEN(dn->dn_phys->dn_extra_slots + 1)); - bcopy(data, DN_BONUS(dn->dn_phys), DN_MAX_BONUS_LEN(dn->dn_phys)); + memcpy(DN_BONUS(dn->dn_phys), data, DN_MAX_BONUS_LEN(dn->dn_phys)); dbuf_sync_leaf_verify_bonus_dnode(dr); @@ -4460,7 +4460,7 @@ dbuf_sync_leaf(dbuf_dirty_record_t *dr, dmu_tx_t *tx) } else { *datap = arc_alloc_buf(os->os_spa, db, type, psize); } - bcopy(db->db.db_data, (*datap)->b_data, psize); + memcpy((*datap)->b_data, db->db.db_data, psize); } db->db_data_pending = dr; @@ -4640,7 +4640,7 @@ dbuf_write_children_ready(zio_t *zio, arc_buf_t *buf, void *vdb) * zero out. */ rw_enter(&db->db_rwlock, RW_WRITER); - bzero(db->db.db_data, db->db.db_size); + memset(db->db.db_data, 0, db->db.db_size); rw_exit(&db->db_rwlock); } DB_DNODE_EXIT(db); diff --git a/sys/contrib/openzfs/module/zfs/ddt.c b/sys/contrib/openzfs/module/zfs/ddt.c index f1415353f4b..61a9c8f0eae 100644 --- a/sys/contrib/openzfs/module/zfs/ddt.c +++ b/sys/contrib/openzfs/module/zfs/ddt.c @@ -46,11 +46,11 @@ static kmem_cache_t *ddt_entry_cache; */ int zfs_dedup_prefetch = 0; -static const ddt_ops_t *ddt_ops[DDT_TYPES] = { +static const ddt_ops_t *const ddt_ops[DDT_TYPES] = { &ddt_zap_ops, }; -static const char *ddt_class_name[DDT_CLASSES] = { +static const char *const ddt_class_name[DDT_CLASSES] = { "ditto", "duplicate", "unique", @@ -99,7 +99,7 @@ ddt_object_destroy(ddt_t *ddt, enum ddt_type type, enum ddt_class class, VERIFY(zap_remove(os, DMU_POOL_DIRECTORY_OBJECT, name, tx) == 0); VERIFY(zap_remove(os, spa->spa_ddt_stat_object, name, tx) == 0); VERIFY(ddt_ops[type]->ddt_op_destroy(os, *objectp, tx) == 0); - bzero(&ddt->ddt_object_stats[type][class], sizeof (ddt_object_t)); + memset(&ddt->ddt_object_stats[type][class], 0, sizeof (ddt_object_t)); *objectp = 0; } @@ -322,7 +322,7 @@ ddt_phys_fill(ddt_phys_t *ddp, const blkptr_t *bp) void ddt_phys_clear(ddt_phys_t *ddp) { - bzero(ddp, sizeof (*ddp)); + memset(ddp, 0, sizeof (*ddp)); } void @@ -390,7 +390,7 @@ ddt_stat_generate(ddt_t *ddt, ddt_entry_t *dde, ddt_stat_t *dds) uint64_t lsize = DDK_GET_LSIZE(ddk); uint64_t psize = DDK_GET_PSIZE(ddk); - bzero(dds, sizeof (*dds)); + memset(dds, 0, sizeof (*dds)); for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) { uint64_t dsize = 0; @@ -454,7 +454,7 @@ ddt_histogram_add(ddt_histogram_t *dst, const ddt_histogram_t *src) void ddt_histogram_stat(ddt_stat_t *dds, const ddt_histogram_t *ddh) { - bzero(dds, sizeof (*dds)); + memset(dds, 0, sizeof (*dds)); for (int h = 0; h < 64; h++) ddt_stat_add(dds, &ddh->ddh_stat[h], 0); @@ -532,7 +532,7 @@ ddt_get_dedup_dspace(spa_t *spa) if (spa->spa_dedup_dspace != ~0ULL) return (spa->spa_dedup_dspace); - bzero(&dds_total, sizeof (ddt_stat_t)); + memset(&dds_total, 0, sizeof (ddt_stat_t)); /* Calculate and cache the stats */ ddt_get_dedup_stats(spa, &dds_total); @@ -566,7 +566,7 @@ ddt_compress(void *src, uchar_t *dst, size_t s_len, size_t d_len) if (c_len == s_len) { cpfunc = ZIO_COMPRESS_OFF; - bcopy(src, dst, s_len); + memcpy(dst, src, s_len); } *version = cpfunc; @@ -586,7 +586,7 @@ ddt_decompress(uchar_t *src, void *dst, size_t s_len, size_t d_len) if (ci->ci_decompress != NULL) (void) ci->ci_decompress(src, dst, s_len, d_len, ci->ci_level); else - bcopy(src, dst, d_len); + memcpy(dst, src, d_len); if (((version & DDT_COMPRESS_BYTEORDER_MASK) != 0) != (ZFS_HOST_BYTEORDER != 0)) @@ -633,7 +633,7 @@ ddt_alloc(const ddt_key_t *ddk) ddt_entry_t *dde; dde = kmem_cache_alloc(ddt_entry_cache, KM_SLEEP); - bzero(dde, sizeof (ddt_entry_t)); + memset(dde, 0, sizeof (ddt_entry_t)); cv_init(&dde->dde_cv, NULL, CV_DEFAULT, NULL); dde->dde_key = *ddk; @@ -785,7 +785,7 @@ ddt_table_alloc(spa_t *spa, enum zio_checksum c) ddt_t *ddt; ddt = kmem_cache_alloc(ddt_cache, KM_SLEEP); - bzero(ddt, sizeof (ddt_t)); + memset(ddt, 0, sizeof (ddt_t)); mutex_init(&ddt->ddt_lock, NULL, MUTEX_DEFAULT, NULL); avl_create(&ddt->ddt_tree, ddt_entry_compare, @@ -847,7 +847,7 @@ ddt_load(spa_t *spa) /* * Seed the cached histograms. */ - bcopy(ddt->ddt_histogram, &ddt->ddt_histogram_cache, + memcpy(&ddt->ddt_histogram_cache, ddt->ddt_histogram, sizeof (ddt->ddt_histogram)); spa->spa_dedup_dspace = ~0ULL; } @@ -919,7 +919,7 @@ ddt_repair_start(ddt_t *ddt, const blkptr_t *bp) } } - bzero(dde->dde_phys, sizeof (dde->dde_phys)); + memset(dde->dde_phys, 0, sizeof (dde->dde_phys)); return (dde); } @@ -964,7 +964,7 @@ ddt_repair_entry(ddt_t *ddt, ddt_entry_t *dde, ddt_entry_t *rdde, zio_t *rio) for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++, rddp++) { if (ddp->ddp_phys_birth == 0 || ddp->ddp_phys_birth != rddp->ddp_phys_birth || - bcmp(ddp->ddp_dva, rddp->ddp_dva, sizeof (ddp->ddp_dva))) + memcmp(ddp->ddp_dva, rddp->ddp_dva, sizeof (ddp->ddp_dva))) continue; ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk); zio_nowait(zio_rewrite(zio, zio->io_spa, 0, &blk, @@ -1108,7 +1108,7 @@ ddt_sync_table(ddt_t *ddt, dmu_tx_t *tx, uint64_t txg) } } - bcopy(ddt->ddt_histogram, &ddt->ddt_histogram_cache, + memcpy(&ddt->ddt_histogram_cache, ddt->ddt_histogram, sizeof (ddt->ddt_histogram)); spa->spa_dedup_dspace = ~0ULL; } diff --git a/sys/contrib/openzfs/module/zfs/dmu.c b/sys/contrib/openzfs/module/zfs/dmu.c index 874ddc80087..461feeffb6a 100644 --- a/sys/contrib/openzfs/module/zfs/dmu.c +++ b/sys/contrib/openzfs/module/zfs/dmu.c @@ -1012,7 +1012,7 @@ dmu_read_impl(dnode_t *dn, uint64_t offset, uint64_t size, if (dn->dn_maxblkid == 0) { uint64_t newsz = offset > dn->dn_datablksz ? 0 : MIN(size, dn->dn_datablksz - offset); - bzero((char *)buf + newsz, size - newsz); + memset((char *)buf + newsz, 0, size - newsz); size = newsz; } @@ -2077,9 +2077,9 @@ dmu_write_policy(objset_t *os, dnode_t *dn, int level, int wp, zio_prop_t *zp) zp->zp_nopwrite = nopwrite; zp->zp_encrypt = encrypt; zp->zp_byteorder = ZFS_HOST_BYTEORDER; - bzero(zp->zp_salt, ZIO_DATA_SALT_LEN); - bzero(zp->zp_iv, ZIO_DATA_IV_LEN); - bzero(zp->zp_mac, ZIO_DATA_MAC_LEN); + memset(zp->zp_salt, 0, ZIO_DATA_SALT_LEN); + memset(zp->zp_iv, 0, ZIO_DATA_IV_LEN); + memset(zp->zp_mac, 0, ZIO_DATA_MAC_LEN); zp->zp_zpl_smallblk = DMU_OT_IS_FILE(zp->zp_type) ? os->os_zpl_special_smallblock : 0; diff --git a/sys/contrib/openzfs/module/zfs/dmu_objset.c b/sys/contrib/openzfs/module/zfs/dmu_objset.c index 9a74fa9ce36..8c2e75fc930 100644 --- a/sys/contrib/openzfs/module/zfs/dmu_objset.c +++ b/sys/contrib/openzfs/module/zfs/dmu_objset.c @@ -516,8 +516,8 @@ dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, if (arc_buf_size(os->os_phys_buf) < size) { arc_buf_t *buf = arc_alloc_buf(spa, &os->os_phys_buf, ARC_BUFC_METADATA, size); - bzero(buf->b_data, size); - bcopy(os->os_phys_buf->b_data, buf->b_data, + memset(buf->b_data, 0, size); + memcpy(buf->b_data, os->os_phys_buf->b_data, arc_buf_size(os->os_phys_buf)); arc_buf_destroy(os->os_phys_buf, &os->os_phys_buf); os->os_phys_buf = buf; @@ -531,7 +531,7 @@ dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp, os->os_phys_buf = arc_alloc_buf(spa, &os->os_phys_buf, ARC_BUFC_METADATA, size); os->os_phys = os->os_phys_buf->b_data; - bzero(os->os_phys, size); + memset(os->os_phys, 0, size); } /* * These properties will be filled in by the logic in zfs_get_zplprop() diff --git a/sys/contrib/openzfs/module/zfs/dmu_recv.c b/sys/contrib/openzfs/module/zfs/dmu_recv.c index b34c1bc6934..c90df1eb404 100644 --- a/sys/contrib/openzfs/module/zfs/dmu_recv.c +++ b/sys/contrib/openzfs/module/zfs/dmu_recv.c @@ -1148,7 +1148,7 @@ dmu_recv_begin(char *tofs, char *tosnap, dmu_replay_record_t *drr_begin, dmu_recv_begin_arg_t drba = { 0 }; int err; - bzero(drc, sizeof (dmu_recv_cookie_t)); + memset(drc, 0, sizeof (dmu_recv_cookie_t)); drc->drc_drr_begin = drr_begin; drc->drc_drrb = &drr_begin->drr_u.drr_begin; drc->drc_tosnap = tosnap; @@ -1211,7 +1211,6 @@ dmu_recv_begin(char *tofs, char *tosnap, dmu_replay_record_t *drr_begin, dmu_recv_resume_begin_check, dmu_recv_resume_begin_sync, &drba, 5, ZFS_SPACE_CHECK_NORMAL); } else { - /* * For non-raw, non-incremental, non-resuming receives the * user can specify encryption parameters on the command line @@ -1808,7 +1807,7 @@ receive_object(struct receive_writer_arg *rwa, struct drr_object *drro, dmu_buf_will_dirty(db, tx); ASSERT3U(db->db_size, >=, drro->drr_bonuslen); - bcopy(data, db->db_data, DRR_OBJECT_PAYLOAD_SIZE(drro)); + memcpy(db->db_data, data, DRR_OBJECT_PAYLOAD_SIZE(drro)); /* * Raw bonus buffers have their byteorder determined by the @@ -1949,11 +1948,11 @@ flush_write_batch_impl(struct receive_writer_arg *rwa) zp.zp_byteorder = ZFS_HOST_BYTEORDER ^ !!DRR_IS_RAW_BYTESWAPPED(drrw->drr_flags) ^ rwa->byteswap; - bcopy(drrw->drr_salt, zp.zp_salt, + memcpy(zp.zp_salt, drrw->drr_salt, ZIO_DATA_SALT_LEN); - bcopy(drrw->drr_iv, zp.zp_iv, + memcpy(zp.zp_iv, drrw->drr_iv, ZIO_DATA_IV_LEN); - bcopy(drrw->drr_mac, zp.zp_mac, + memcpy(zp.zp_mac, drrw->drr_mac, ZIO_DATA_MAC_LEN); if (DMU_OT_IS_ENCRYPTED(zp.zp_type)) { zp.zp_nopwrite = B_FALSE; @@ -2218,7 +2217,7 @@ receive_spill(struct receive_writer_arg *rwa, struct drr_spill *drrs, } } - bcopy(abd_to_buf(abd), abuf->b_data, DRR_SPILL_PAYLOAD_SIZE(drrs)); + memcpy(abuf->b_data, abd_to_buf(abd), DRR_SPILL_PAYLOAD_SIZE(drrs)); abd_free(abd); dbuf_assign_arcbuf((dmu_buf_impl_t *)db_spill, abuf, tx); @@ -2291,9 +2290,9 @@ receive_object_range(struct receive_writer_arg *rwa, rwa->or_crypt_params_present = B_TRUE; rwa->or_firstobj = drror->drr_firstobj; rwa->or_numslots = drror->drr_numslots; - bcopy(drror->drr_salt, rwa->or_salt, ZIO_DATA_SALT_LEN); - bcopy(drror->drr_iv, rwa->or_iv, ZIO_DATA_IV_LEN); - bcopy(drror->drr_mac, rwa->or_mac, ZIO_DATA_MAC_LEN); + memcpy(rwa->or_salt, drror->drr_salt, ZIO_DATA_SALT_LEN); + memcpy(rwa->or_iv, drror->drr_iv, ZIO_DATA_IV_LEN); + memcpy(rwa->or_mac, drror->drr_mac, ZIO_DATA_MAC_LEN); rwa->or_byteorder = byteorder; return (0); @@ -2802,7 +2801,7 @@ receive_process_record(struct receive_writer_arg *rwa, * dmu_recv_stream's worker thread; pull records off the queue, and then call * receive_process_record When we're done, signal the main thread and exit. */ -static _Noreturn void +static __attribute__((noreturn)) void receive_writer_thread(void *arg) { struct receive_writer_arg *rwa = arg; diff --git a/sys/contrib/openzfs/module/zfs/dmu_redact.c b/sys/contrib/openzfs/module/zfs/dmu_redact.c index ab2b5f23e3f..9b0fe8a747d 100644 --- a/sys/contrib/openzfs/module/zfs/dmu_redact.c +++ b/sys/contrib/openzfs/module/zfs/dmu_redact.c @@ -351,7 +351,7 @@ redact_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, return (0); } -static _Noreturn void +static __attribute__((noreturn)) void redact_traverse_thread(void *arg) { struct redact_thread_arg *rt_arg = arg; @@ -837,7 +837,7 @@ struct redact_merge_thread_arg { int error_code; }; -static _Noreturn void +static __attribute__((noreturn)) void redact_merge_thread(void *arg) { struct redact_merge_thread_arg *rmta = arg; diff --git a/sys/contrib/openzfs/module/zfs/dmu_send.c b/sys/contrib/openzfs/module/zfs/dmu_send.c index 021dffefa14..dd9e4f785cc 100644 --- a/sys/contrib/openzfs/module/zfs/dmu_send.c +++ b/sys/contrib/openzfs/module/zfs/dmu_send.c @@ -379,7 +379,7 @@ dump_free(dmu_send_cookie_t *dscp, uint64_t object, uint64_t offset, } } /* create a FREE record and make it pending */ - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_FREE; drrf->drr_object = object; drrf->drr_offset = offset; @@ -438,7 +438,7 @@ dump_redact(dmu_send_cookie_t *dscp, uint64_t object, uint64_t offset, } } /* create a REDACT record and make it pending */ - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_REDACT; drrr->drr_object = object; drrr->drr_offset = offset; @@ -480,7 +480,7 @@ dmu_dump_write(dmu_send_cookie_t *dscp, dmu_object_type_t type, uint64_t object, dscp->dsc_pending_op = PENDING_NONE; } /* write a WRITE record */ - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_WRITE; drrw->drr_object = object; drrw->drr_type = type; @@ -571,7 +571,7 @@ dump_write_embedded(dmu_send_cookie_t *dscp, uint64_t object, uint64_t offset, ASSERT(BP_IS_EMBEDDED(bp)); - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_WRITE_EMBEDDED; drrw->drr_object = object; drrw->drr_offset = offset; @@ -604,7 +604,7 @@ dump_spill(dmu_send_cookie_t *dscp, const blkptr_t *bp, uint64_t object, } /* write a SPILL record */ - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_SPILL; drrs->drr_object = object; drrs->drr_length = blksz; @@ -686,7 +686,7 @@ dump_freeobjects(dmu_send_cookie_t *dscp, uint64_t firstobj, uint64_t numobjs) } /* write a FREEOBJECTS record */ - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_FREEOBJECTS; drrfo->drr_firstobj = firstobj; drrfo->drr_numobjs = numobjs; @@ -727,7 +727,7 @@ dump_dnode(dmu_send_cookie_t *dscp, const blkptr_t *bp, uint64_t object, } /* write an OBJECT record */ - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_OBJECT; drro->drr_object = object; drro->drr_type = dnp->dn_type; @@ -801,7 +801,7 @@ dump_dnode(dmu_send_cookie_t *dscp, const blkptr_t *bp, uint64_t object, struct send_range record; blkptr_t *bp = DN_SPILL_BLKPTR(dnp); - bzero(&record, sizeof (struct send_range)); + memset(&record, 0, sizeof (struct send_range)); record.type = DATA; record.object = object; record.eos_marker = B_FALSE; @@ -841,7 +841,7 @@ dump_object_range(dmu_send_cookie_t *dscp, const blkptr_t *bp, dscp->dsc_pending_op = PENDING_NONE; } - bzero(dscp->dsc_drr, sizeof (dmu_replay_record_t)); + memset(dscp->dsc_drr, 0, sizeof (dmu_replay_record_t)); dscp->dsc_drr->drr_type = DRR_OBJECT_RANGE; drror->drr_firstobj = firstobj; drror->drr_numslots = numslots; @@ -1136,7 +1136,7 @@ send_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, record->sru.object.bp = *bp; size_t size = sizeof (*dnp) * (dnp->dn_extra_slots + 1); record->sru.object.dnp = kmem_alloc(size, KM_SLEEP); - bcopy(dnp, record->sru.object.dnp, size); + memcpy(record->sru.object.dnp, dnp, size); bqueue_enqueue(&sta->q, record, sizeof (*record)); return (0); } @@ -1234,7 +1234,7 @@ redact_list_cb(redact_block_phys_t *rb, void *arg) * error code of the thread in case something goes wrong, and pushes the End of * Stream record when the traverse_dataset call has finished. */ -static _Noreturn void +static __attribute__((noreturn)) void send_traverse_thread(void *arg) { struct send_thread_arg *st_arg = arg; @@ -1324,7 +1324,7 @@ get_next_range(bqueue_t *bq, struct send_range *prev) return (next); } -static _Noreturn void +static __attribute__((noreturn)) void redact_list_thread(void *arg) { struct redact_list_thread_arg *rlt_arg = arg; @@ -1519,7 +1519,7 @@ find_next_range(struct send_range **ranges, bqueue_t **qs, uint64_t *out_mask) * data from the redact_list_thread and use that to determine which blocks * should be redacted. */ -static _Noreturn void +static __attribute__((noreturn)) void send_merge_thread(void *arg) { struct send_merge_thread_arg *smt_arg = arg; @@ -1744,7 +1744,7 @@ enqueue_range(struct send_reader_thread_arg *srta, bqueue_t *q, dnode_t *dn, * some indirect blocks can be discarded because they're not holes. Second, * it issues prefetches for the data we need to send. */ -static _Noreturn void +static __attribute__((noreturn)) void send_reader_thread(void *arg) { struct send_reader_thread_arg *srta = arg; @@ -2597,7 +2597,7 @@ dmu_send_impl(struct dmu_send_params *dspp) * the receive side that the stream is incomplete. */ if (!dspp->savedok) { - bzero(drr, sizeof (dmu_replay_record_t)); + memset(drr, 0, sizeof (dmu_replay_record_t)); drr->drr_type = DRR_END; drr->drr_u.drr_end.drr_checksum = dsc.dsc_zc; drr->drr_u.drr_end.drr_toguid = dsc.dsc_toguid; @@ -2698,7 +2698,7 @@ dmu_send_obj(const char *pool, uint64_t tosnap, uint64_t fromsnap, uint64_t size = dspp.numfromredactsnaps * sizeof (uint64_t); dspp.fromredactsnaps = kmem_zalloc(size, KM_SLEEP); - bcopy(fromredact, dspp.fromredactsnaps, size); + memcpy(dspp.fromredactsnaps, fromredact, size); } boolean_t is_before = @@ -2883,7 +2883,7 @@ dmu_send(const char *tosnap, const char *fromsnap, boolean_t embedok, sizeof (uint64_t); dspp.fromredactsnaps = kmem_zalloc(size, KM_SLEEP); - bcopy(fromredact, dspp.fromredactsnaps, + memcpy(dspp.fromredactsnaps, fromredact, size); } if (!dsl_dataset_is_before(dspp.to_ds, fromds, diff --git a/sys/contrib/openzfs/module/zfs/dmu_traverse.c b/sys/contrib/openzfs/module/zfs/dmu_traverse.c index 8afcd776a9e..41baff73a17 100644 --- a/sys/contrib/openzfs/module/zfs/dmu_traverse.c +++ b/sys/contrib/openzfs/module/zfs/dmu_traverse.c @@ -168,8 +168,8 @@ resume_skip_check(traverse_data_t *td, const dnode_phys_t *dnp, * If we found the block we're trying to resume from, zero * the bookmark out to indicate that we have resumed. */ - if (bcmp(zb, td->td_resume, sizeof (*zb)) == 0) { - bzero(td->td_resume, sizeof (*zb)); + if (memcmp(zb, td->td_resume, sizeof (*zb)) == 0) { + memset(td->td_resume, 0, sizeof (*zb)); if (td->td_flags & TRAVERSE_POST) return (RESUME_SKIP_CHILDREN); } diff --git a/sys/contrib/openzfs/module/zfs/dnode.c b/sys/contrib/openzfs/module/zfs/dnode.c index 7b53b7cd053..af0ee1b0f8b 100644 --- a/sys/contrib/openzfs/module/zfs/dnode.c +++ b/sys/contrib/openzfs/module/zfs/dnode.c @@ -128,15 +128,15 @@ dnode_cons(void *arg, void *unused, int kmflag) zfs_refcount_create(&dn->dn_tx_holds); list_link_init(&dn->dn_link); - bzero(&dn->dn_next_type[0], sizeof (dn->dn_next_type)); - bzero(&dn->dn_next_nblkptr[0], sizeof (dn->dn_next_nblkptr)); - bzero(&dn->dn_next_nlevels[0], sizeof (dn->dn_next_nlevels)); - bzero(&dn->dn_next_indblkshift[0], sizeof (dn->dn_next_indblkshift)); - bzero(&dn->dn_next_bonustype[0], sizeof (dn->dn_next_bonustype)); - bzero(&dn->dn_rm_spillblk[0], sizeof (dn->dn_rm_spillblk)); - bzero(&dn->dn_next_bonuslen[0], sizeof (dn->dn_next_bonuslen)); - bzero(&dn->dn_next_blksz[0], sizeof (dn->dn_next_blksz)); - bzero(&dn->dn_next_maxblkid[0], sizeof (dn->dn_next_maxblkid)); + memset(dn->dn_next_type, 0, sizeof (dn->dn_next_type)); + memset(dn->dn_next_nblkptr, 0, sizeof (dn->dn_next_nblkptr)); + memset(dn->dn_next_nlevels, 0, sizeof (dn->dn_next_nlevels)); + memset(dn->dn_next_indblkshift, 0, sizeof (dn->dn_next_indblkshift)); + memset(dn->dn_next_bonustype, 0, sizeof (dn->dn_next_bonustype)); + memset(dn->dn_rm_spillblk, 0, sizeof (dn->dn_rm_spillblk)); + memset(dn->dn_next_bonuslen, 0, sizeof (dn->dn_next_bonuslen)); + memset(dn->dn_next_blksz, 0, sizeof (dn->dn_next_blksz)); + memset(dn->dn_next_maxblkid, 0, sizeof (dn->dn_next_maxblkid)); for (int i = 0; i < TXG_SIZE; i++) { multilist_link_init(&dn->dn_dirty_link[i]); @@ -317,7 +317,7 @@ dnode_byteswap(dnode_phys_t *dnp) int i; if (dnp->dn_type == DMU_OT_NONE) { - bzero(dnp, sizeof (dnode_phys_t)); + memset(dnp, 0, sizeof (dnode_phys_t)); return; } @@ -395,7 +395,7 @@ dnode_setbonuslen(dnode_t *dn, int newsize, dmu_tx_t *tx) /* clear any data after the end of the new size */ size_t diff = dn->dn_bonuslen - newsize; char *data_end = ((char *)dn->dn_bonus->db.db_data) + newsize; - bzero(data_end, diff); + memset(data_end, 0, diff); } dn->dn_bonuslen = newsize; @@ -596,7 +596,7 @@ dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs, DNODE_STAT_BUMP(dnode_allocate); ASSERT(dn->dn_type == DMU_OT_NONE); - ASSERT(bcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t)) == 0); + ASSERT0(memcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t))); ASSERT(dn->dn_phys->dn_type == DMU_OT_NONE); ASSERT(ot != DMU_OT_NONE); ASSERT(DMU_OT_IS_VALID(ot)); @@ -749,8 +749,6 @@ dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, static void dnode_move_impl(dnode_t *odn, dnode_t *ndn) { - int i; - ASSERT(!RW_LOCK_HELD(&odn->dn_struct_rwlock)); ASSERT(MUTEX_NOT_HELD(&odn->dn_mtx)); ASSERT(MUTEX_NOT_HELD(&odn->dn_dbufs_mtx)); @@ -774,29 +772,29 @@ dnode_move_impl(dnode_t *odn, dnode_t *ndn) ndn->dn_datablksz = odn->dn_datablksz; ndn->dn_maxblkid = odn->dn_maxblkid; ndn->dn_num_slots = odn->dn_num_slots; - bcopy(&odn->dn_next_type[0], &ndn->dn_next_type[0], + memcpy(ndn->dn_next_type, odn->dn_next_type, sizeof (odn->dn_next_type)); - bcopy(&odn->dn_next_nblkptr[0], &ndn->dn_next_nblkptr[0], + memcpy(ndn->dn_next_nblkptr, odn->dn_next_nblkptr, sizeof (odn->dn_next_nblkptr)); - bcopy(&odn->dn_next_nlevels[0], &ndn->dn_next_nlevels[0], + memcpy(ndn->dn_next_nlevels, odn->dn_next_nlevels, sizeof (odn->dn_next_nlevels)); - bcopy(&odn->dn_next_indblkshift[0], &ndn->dn_next_indblkshift[0], + memcpy(ndn->dn_next_indblkshift, odn->dn_next_indblkshift, sizeof (odn->dn_next_indblkshift)); - bcopy(&odn->dn_next_bonustype[0], &ndn->dn_next_bonustype[0], + memcpy(ndn->dn_next_bonustype, odn->dn_next_bonustype, sizeof (odn->dn_next_bonustype)); - bcopy(&odn->dn_rm_spillblk[0], &ndn->dn_rm_spillblk[0], + memcpy(ndn->dn_rm_spillblk, odn->dn_rm_spillblk, sizeof (odn->dn_rm_spillblk)); - bcopy(&odn->dn_next_bonuslen[0], &ndn->dn_next_bonuslen[0], + memcpy(ndn->dn_next_bonuslen, odn->dn_next_bonuslen, sizeof (odn->dn_next_bonuslen)); - bcopy(&odn->dn_next_blksz[0], &ndn->dn_next_blksz[0], + memcpy(ndn->dn_next_blksz, odn->dn_next_blksz, sizeof (odn->dn_next_blksz)); - bcopy(&odn->dn_next_maxblkid[0], &ndn->dn_next_maxblkid[0], + memcpy(ndn->dn_next_maxblkid, odn->dn_next_maxblkid, sizeof (odn->dn_next_maxblkid)); - for (i = 0; i < TXG_SIZE; i++) { + for (int i = 0; i < TXG_SIZE; i++) { list_move_tail(&ndn->dn_dirty_records[i], &odn->dn_dirty_records[i]); } - bcopy(&odn->dn_free_ranges[0], &ndn->dn_free_ranges[0], + memcpy(ndn->dn_free_ranges, odn->dn_free_ranges, sizeof (odn->dn_free_ranges)); ndn->dn_allocated_txg = odn->dn_allocated_txg; ndn->dn_free_txg = odn->dn_free_txg; @@ -850,7 +848,7 @@ dnode_move_impl(dnode_t *odn, dnode_t *ndn) /* * Satisfy the destructor. */ - for (i = 0; i < TXG_SIZE; i++) { + for (int i = 0; i < TXG_SIZE; i++) { list_create(&odn->dn_dirty_records[i], sizeof (dbuf_dirty_record_t), offsetof(dbuf_dirty_record_t, dr_dirty_node)); @@ -2081,7 +2079,7 @@ dnode_partial_zero(dnode_t *dn, uint64_t off, uint64_t blkoff, uint64_t len, dmu_buf_will_dirty(&db->db, tx); data = db->db.db_data; - bzero(data + blkoff, len); + memset(data + blkoff, 0, len); } dbuf_rele(db, FTAG); } diff --git a/sys/contrib/openzfs/module/zfs/dnode_sync.c b/sys/contrib/openzfs/module/zfs/dnode_sync.c index 12ab4bea145..973f93c4ec0 100644 --- a/sys/contrib/openzfs/module/zfs/dnode_sync.c +++ b/sys/contrib/openzfs/module/zfs/dnode_sync.c @@ -82,7 +82,7 @@ dnode_increase_indirection(dnode_t *dn, dmu_tx_t *tx) ASSERT(db->db.db_data); ASSERT(arc_released(db->db_buf)); ASSERT3U(sizeof (blkptr_t) * nblkptr, <=, db->db.db_size); - bcopy(dn->dn_phys->dn_blkptr, db->db.db_data, + memcpy(db->db.db_data, dn->dn_phys->dn_blkptr, sizeof (blkptr_t) * nblkptr); arc_buf_freeze(db->db_buf); @@ -119,7 +119,7 @@ dnode_increase_indirection(dnode_t *dn, dmu_tx_t *tx) mutex_exit(&child->db_mtx); } - bzero(dn->dn_phys->dn_blkptr, sizeof (blkptr_t) * nblkptr); + memset(dn->dn_phys->dn_blkptr, 0, sizeof (blkptr_t) * nblkptr); rw_exit(&db->db_rwlock); if (dn->dn_dbuf != NULL) @@ -158,7 +158,7 @@ free_blocks(dnode_t *dn, blkptr_t *bp, int num, dmu_tx_t *tx) dmu_object_type_t type = BP_GET_TYPE(bp); uint64_t lvl = BP_GET_LEVEL(bp); - bzero(bp, sizeof (blkptr_t)); + memset(bp, 0, sizeof (blkptr_t)); if (spa_feature_is_active(dn->dn_objset->os_spa, SPA_FEATURE_HOLE_BIRTH)) { @@ -347,7 +347,7 @@ free_children(dmu_buf_impl_t *db, uint64_t blkid, uint64_t nblks, rw_enter(&db->db_rwlock, RW_WRITER); for (i = 0, bp = db->db.db_data; i < 1 << epbs; i++, bp++) ASSERT(BP_IS_HOLE(bp)); - bzero(db->db.db_data, db->db.db_size); + memset(db->db.db_data, 0, db->db.db_size); free_blocks(dn, db->db_blkptr, 1, tx); rw_exit(&db->db_rwlock); } @@ -597,7 +597,7 @@ dnode_sync_free(dnode_t *dn, dmu_tx_t *tx) ASSERT(dn->dn_free_txg > 0); if (dn->dn_allocated_txg != dn->dn_free_txg) dmu_buf_will_dirty(&dn->dn_dbuf->db, tx); - bzero(dn->dn_phys, sizeof (dnode_phys_t) * dn->dn_num_slots); + memset(dn->dn_phys, 0, sizeof (dnode_phys_t) * dn->dn_num_slots); dnode_free_interior_slots(dn); mutex_enter(&dn->dn_mtx); @@ -634,7 +634,7 @@ dnode_sync(dnode_t *dn, dmu_tx_t *tx) ASSERT(dmu_tx_is_syncing(tx)); ASSERT(dnp->dn_type != DMU_OT_NONE || dn->dn_allocated_txg); ASSERT(dnp->dn_type != DMU_OT_NONE || - bcmp(dnp, &zerodn, DNODE_MIN_SIZE) == 0); + memcmp(dnp, &zerodn, DNODE_MIN_SIZE) == 0); DNODE_VERIFY(dn); ASSERT(dn->dn_dbuf == NULL || arc_released(dn->dn_dbuf->db_buf)); @@ -827,7 +827,7 @@ dnode_sync(dnode_t *dn, dmu_tx_t *tx) ASSERT(dn->dn_allocated_txg == tx->tx_txg); if (dn->dn_next_nblkptr[txgoff] > dnp->dn_nblkptr) { /* zero the new blkptrs we are gaining */ - bzero(dnp->dn_blkptr + dnp->dn_nblkptr, + memset(dnp->dn_blkptr + dnp->dn_nblkptr, 0, sizeof (blkptr_t) * (dn->dn_next_nblkptr[txgoff] - dnp->dn_nblkptr)); #ifdef ZFS_DEBUG diff --git a/sys/contrib/openzfs/module/zfs/dsl_bookmark.c b/sys/contrib/openzfs/module/zfs/dsl_bookmark.c index b8e3523ffc2..44fc399a6b6 100644 --- a/sys/contrib/openzfs/module/zfs/dsl_bookmark.c +++ b/sys/contrib/openzfs/module/zfs/dsl_bookmark.c @@ -82,7 +82,7 @@ dsl_bookmark_lookup_impl(dsl_dataset_t *ds, const char *shortname, * Zero out the bookmark in case the one stored on disk * is in an older, shorter format. */ - bzero(bmark_phys, sizeof (*bmark_phys)); + memset(bmark_phys, 0, sizeof (*bmark_phys)); err = zap_lookup_norm(mos, bmark_zapobj, shortname, sizeof (uint64_t), sizeof (*bmark_phys) / sizeof (uint64_t), bmark_phys, mt, NULL, 0, @@ -160,10 +160,9 @@ dsl_bookmark_create_nvl_validate_pair(const char *bmark, const char *source) int dsl_bookmark_create_nvl_validate(nvlist_t *bmarks) { - char *first; - size_t first_len; + char *first = NULL; + size_t first_len = 0; - first = NULL; for (nvpair_t *pair = nvlist_next_nvpair(bmarks, NULL); pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) { @@ -381,7 +380,7 @@ dsl_bookmark_set_phys(zfs_bookmark_phys_t *zbm, dsl_dataset_t *snap) &zbm->zbm_uncompressed_freed_before_next_snap); dsl_dataset_rele(nextds, FTAG); } else { - bzero(&zbm->zbm_flags, + memset(&zbm->zbm_flags, 0, sizeof (zfs_bookmark_phys_t) - offsetof(zfs_bookmark_phys_t, zbm_flags)); } @@ -426,8 +425,8 @@ dsl_bookmark_node_add(dsl_dataset_t *hds, dsl_bookmark_node_t *dbn, spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2, tx); } - __attribute__((unused)) zfs_bookmark_phys_t zero_phys = { 0 }; - ASSERT0(bcmp(((char *)&dbn->dbn_phys) + bookmark_phys_size, + zfs_bookmark_phys_t zero_phys = { 0 }; + ASSERT0(memcmp(((char *)&dbn->dbn_phys) + bookmark_phys_size, &zero_phys, sizeof (zfs_bookmark_phys_t) - bookmark_phys_size)); VERIFY0(zap_add(mos, hds->ds_bookmarks_obj, dbn->dbn_name, @@ -482,7 +481,7 @@ dsl_bookmark_create_sync_impl_snap(const char *bookmark, const char *snapshot, sizeof (redaction_list_phys_t) + num_redact_snaps * sizeof (uint64_t)); dmu_buf_will_dirty(local_rl->rl_dbuf, tx); - bcopy(redact_snaps, local_rl->rl_phys->rlp_snaps, + memcpy(local_rl->rl_phys->rlp_snaps, redact_snaps, sizeof (uint64_t) * num_redact_snaps); local_rl->rl_phys->rlp_num_snaps = num_redact_snaps; if (bookmark_redacted) { diff --git a/sys/contrib/openzfs/module/zfs/dsl_crypt.c b/sys/contrib/openzfs/module/zfs/dsl_crypt.c index 6330a44b4c3..d802eb6b68c 100644 --- a/sys/contrib/openzfs/module/zfs/dsl_crypt.c +++ b/sys/contrib/openzfs/module/zfs/dsl_crypt.c @@ -97,7 +97,7 @@ dsl_wrapping_key_free(dsl_wrapping_key_t *wkey) ASSERT0(zfs_refcount_count(&wkey->wk_refcnt)); if (wkey->wk_key.ck_data) { - bzero(wkey->wk_key.ck_data, + memset(wkey->wk_key.ck_data, 0, CRYPTO_BITS2BYTES(wkey->wk_key.ck_length)); kmem_free(wkey->wk_key.ck_data, CRYPTO_BITS2BYTES(wkey->wk_key.ck_length)); @@ -120,7 +120,7 @@ dsl_wrapping_key_create(uint8_t *wkeydata, zfs_keyformat_t keyformat, wkey->wk_key.ck_data = kmem_alloc(WRAPPING_KEY_LEN, KM_SLEEP); wkey->wk_key.ck_length = CRYPTO_BYTES2BITS(WRAPPING_KEY_LEN); - bcopy(wkeydata, wkey->wk_key.ck_data, WRAPPING_KEY_LEN); + memcpy(wkey->wk_key.ck_data, wkeydata, WRAPPING_KEY_LEN); /* initialize the rest of the struct */ zfs_refcount_create(&wkey->wk_refcnt); @@ -591,7 +591,7 @@ dsl_crypto_key_open(objset_t *mos, dsl_wrapping_key_t *wkey, error: if (dck != NULL) { - bzero(dck, sizeof (dsl_crypto_key_t)); + memset(dck, 0, sizeof (dsl_crypto_key_t)); kmem_free(dck, sizeof (dsl_crypto_key_t)); } @@ -2095,8 +2095,8 @@ dsl_crypto_recv_raw_objset_sync(dsl_dataset_t *ds, dmu_objset_type_t ostype, * written out raw next time. */ arc_release(os->os_phys_buf, &os->os_phys_buf); - bcopy(portable_mac, os->os_phys->os_portable_mac, ZIO_OBJSET_MAC_LEN); - bzero(os->os_phys->os_local_mac, ZIO_OBJSET_MAC_LEN); + memcpy(os->os_phys->os_portable_mac, portable_mac, ZIO_OBJSET_MAC_LEN); + memset(os->os_phys->os_local_mac, 0, ZIO_OBJSET_MAC_LEN); os->os_flags &= ~OBJSET_FLAG_USERACCOUNTING_COMPLETE; os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_TRUE; @@ -2547,7 +2547,7 @@ dsl_crypto_key_create_sync(uint64_t crypt, dsl_wrapping_key_t *wkey, DSL_CRYPTO_KEY_VERSION, sizeof (uint64_t), 1, &version, tx)); zio_crypt_key_destroy(&dck.dck_key); - bzero(&dck.dck_key, sizeof (zio_crypt_key_t)); + memset(&dck.dck_key, 0, sizeof (zio_crypt_key_t)); return (dck.dck_obj); } @@ -2687,14 +2687,15 @@ spa_do_crypt_objset_mac_abd(boolean_t generate, spa_t *spa, uint64_t dsobj, /* if we are generating encode the HMACs in the objset_phys_t */ if (generate) { - bcopy(portable_mac, osp->os_portable_mac, ZIO_OBJSET_MAC_LEN); - bcopy(local_mac, osp->os_local_mac, ZIO_OBJSET_MAC_LEN); + memcpy(osp->os_portable_mac, portable_mac, ZIO_OBJSET_MAC_LEN); + memcpy(osp->os_local_mac, local_mac, ZIO_OBJSET_MAC_LEN); abd_return_buf_copy(abd, buf, datalen); return (0); } - if (bcmp(portable_mac, osp->os_portable_mac, ZIO_OBJSET_MAC_LEN) != 0 || - bcmp(local_mac, osp->os_local_mac, ZIO_OBJSET_MAC_LEN) != 0) { + if (memcmp(portable_mac, osp->os_portable_mac, + ZIO_OBJSET_MAC_LEN) != 0 || + memcmp(local_mac, osp->os_local_mac, ZIO_OBJSET_MAC_LEN) != 0) { abd_return_buf(abd, buf, datalen); return (SET_ERROR(ECKSUM)); } @@ -2738,11 +2739,11 @@ spa_do_crypt_mac_abd(boolean_t generate, spa_t *spa, uint64_t dsobj, abd_t *abd, * Otherwise verify that the MAC matched what we expected. */ if (generate) { - bcopy(digestbuf, mac, ZIO_DATA_MAC_LEN); + memcpy(mac, digestbuf, ZIO_DATA_MAC_LEN); return (0); } - if (bcmp(digestbuf, mac, ZIO_DATA_MAC_LEN) != 0) + if (memcmp(digestbuf, mac, ZIO_DATA_MAC_LEN) != 0) return (SET_ERROR(ECKSUM)); return (0); @@ -2841,9 +2842,9 @@ spa_do_crypt_abd(boolean_t encrypt, spa_t *spa, const zbookmark_phys_t *zb, error: if (encrypt) { /* zero out any state we might have changed while encrypting */ - bzero(salt, ZIO_DATA_SALT_LEN); - bzero(iv, ZIO_DATA_IV_LEN); - bzero(mac, ZIO_DATA_MAC_LEN); + memset(salt, 0, ZIO_DATA_SALT_LEN); + memset(iv, 0, ZIO_DATA_IV_LEN); + memset(mac, 0, ZIO_DATA_MAC_LEN); abd_return_buf(pabd, plainbuf, datalen); abd_return_buf_copy(cabd, cipherbuf, datalen); } else { diff --git a/sys/contrib/openzfs/module/zfs/dsl_dataset.c b/sys/contrib/openzfs/module/zfs/dsl_dataset.c index 85b48fd12b6..e836d681e92 100644 --- a/sys/contrib/openzfs/module/zfs/dsl_dataset.c +++ b/sys/contrib/openzfs/module/zfs/dsl_dataset.c @@ -1148,7 +1148,7 @@ dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin, VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf)); dmu_buf_will_dirty(dbuf, tx); dsphys = dbuf->db_data; - bzero(dsphys, sizeof (dsl_dataset_phys_t)); + memset(dsphys, 0, sizeof (dsl_dataset_phys_t)); dsphys->ds_dir_obj = dd->dd_object; dsphys->ds_flags = flags; dsphys->ds_fsid_guid = unique_create(); @@ -1248,11 +1248,11 @@ dsl_dataset_zero_zil(dsl_dataset_t *ds, dmu_tx_t *tx) objset_t *os; VERIFY0(dmu_objset_from_ds(ds, &os)); - if (bcmp(&os->os_zil_header, &zero_zil, sizeof (zero_zil)) != 0) { + if (memcmp(&os->os_zil_header, &zero_zil, sizeof (zero_zil)) != 0) { dsl_pool_t *dp = ds->ds_dir->dd_pool; zio_t *zio; - bzero(&os->os_zil_header, sizeof (os->os_zil_header)); + memset(&os->os_zil_header, 0, sizeof (os->os_zil_header)); if (os->os_encrypted) os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_TRUE; @@ -1696,7 +1696,7 @@ dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname, */ ASSERT(spa_version(dmu_tx_pool(tx)->dp_spa) >= SPA_VERSION_FAST_SNAP || dmu_objset_from_ds(ds, &os) != 0 || - bcmp(&os->os_phys->os_zil_header, &zero_zil, + memcmp(&os->os_phys->os_zil_header, &zero_zil, sizeof (zero_zil)) == 0); /* Should not snapshot a dirty dataset. */ @@ -1718,7 +1718,7 @@ dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname, VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf)); dmu_buf_will_dirty(dbuf, tx); dsphys = dbuf->db_data; - bzero(dsphys, sizeof (dsl_dataset_phys_t)); + memset(dsphys, 0, sizeof (dsl_dataset_phys_t)); dsphys->ds_dir_obj = ds->ds_dir->dd_object; dsphys->ds_fsid_guid = unique_create(); (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid, @@ -2895,7 +2895,7 @@ dsl_dataset_modified_since_snap(dsl_dataset_t *ds, dsl_dataset_t *snap) return (B_TRUE); if (dmu_objset_from_ds(snap, &os_snap) != 0) return (B_TRUE); - return (bcmp(&os->os_phys->os_meta_dnode, + return (memcmp(&os->os_phys->os_meta_dnode, &os_snap->os_phys->os_meta_dnode, sizeof (os->os_phys->os_meta_dnode)) != 0); } @@ -4916,7 +4916,7 @@ dsl_dataset_activate_redaction(dsl_dataset_t *ds, uint64_t *redact_snaps, if (num_redact_snaps > 0) { ftuaa->array = kmem_alloc(num_redact_snaps * sizeof (uint64_t), KM_SLEEP); - bcopy(redact_snaps, ftuaa->array, num_redact_snaps * + memcpy(ftuaa->array, redact_snaps, num_redact_snaps * sizeof (uint64_t)); } dsl_dataset_activate_feature(dsobj, SPA_FEATURE_REDACTED_DATASETS, diff --git a/sys/contrib/openzfs/module/zfs/dsl_deadlist.c b/sys/contrib/openzfs/module/zfs/dsl_deadlist.c index e620510be6b..f516b1c3111 100644 --- a/sys/contrib/openzfs/module/zfs/dsl_deadlist.c +++ b/sys/contrib/openzfs/module/zfs/dsl_deadlist.c @@ -855,7 +855,7 @@ dsl_deadlist_merge(dsl_deadlist_t *dl, uint64_t obj, dmu_tx_t *tx) VERIFY0(dmu_bonus_hold(dl->dl_os, obj, FTAG, &bonus)); dlp = bonus->db_data; dmu_buf_will_dirty(bonus, tx); - bzero(dlp, sizeof (*dlp)); + memset(dlp, 0, sizeof (*dlp)); dmu_buf_rele(bonus, FTAG); mutex_exit(&dl->dl_lock); } diff --git a/sys/contrib/openzfs/module/zfs/dsl_scan.c b/sys/contrib/openzfs/module/zfs/dsl_scan.c index c6a5807c92f..dedf9c8a669 100644 --- a/sys/contrib/openzfs/module/zfs/dsl_scan.c +++ b/sys/contrib/openzfs/module/zfs/dsl_scan.c @@ -393,7 +393,7 @@ dsl_scan_resilvering(dsl_pool_t *dp) static inline void sio2bp(const scan_io_t *sio, blkptr_t *bp) { - bzero(bp, sizeof (*bp)); + memset(bp, 0, sizeof (*bp)); bp->blk_prop = sio->sio_blk_prop; bp->blk_phys_birth = sio->sio_phys_birth; bp->blk_birth = sio->sio_birth; @@ -403,7 +403,7 @@ sio2bp(const scan_io_t *sio, blkptr_t *bp) ASSERT3U(sio->sio_nr_dvas, >, 0); ASSERT3U(sio->sio_nr_dvas, <=, SPA_DVAS_PER_BP); - bcopy(sio->sio_dva, bp->blk_dva, sio->sio_nr_dvas * sizeof (dva_t)); + memcpy(bp->blk_dva, sio->sio_dva, sio->sio_nr_dvas * sizeof (dva_t)); } static inline void @@ -508,7 +508,7 @@ dsl_scan_init(dsl_pool_t *dp, uint64_t txg) return (EOVERFLOW); } - bcopy(zaptmp, &scn->scn_phys, + memcpy(&scn->scn_phys, zaptmp, SCAN_PHYS_NUMINTS * sizeof (uint64_t)); scn->scn_phys.scn_flags = overflow; @@ -567,7 +567,7 @@ dsl_scan_init(dsl_pool_t *dp, uint64_t txg) } } - bcopy(&scn->scn_phys, &scn->scn_phys_cached, sizeof (scn->scn_phys)); + memcpy(&scn->scn_phys_cached, &scn->scn_phys, sizeof (scn->scn_phys)); /* reload the queue into the in-core state */ if (scn->scn_phys.scn_queue_obj != 0) { @@ -689,7 +689,7 @@ dsl_scan_sync_state(dsl_scan_t *scn, dmu_tx_t *tx, state_sync_type_t sync_type) DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS, &scn->scn_phys, tx)); - bcopy(&scn->scn_phys, &scn->scn_phys_cached, + memcpy(&scn->scn_phys_cached, &scn->scn_phys, sizeof (scn->scn_phys)); if (scn->scn_checkpointing) @@ -730,7 +730,7 @@ dsl_scan_setup_sync(void *arg, dmu_tx_t *tx) ASSERT(!dsl_scan_is_running(scn)); ASSERT(*funcp > POOL_SCAN_NONE && *funcp < POOL_SCAN_FUNCS); - bzero(&scn->scn_phys, sizeof (scn->scn_phys)); + memset(&scn->scn_phys, 0, sizeof (scn->scn_phys)); scn->scn_phys.scn_func = *funcp; scn->scn_phys.scn_state = DSS_SCANNING; scn->scn_phys.scn_min_txg = 0; @@ -798,7 +798,8 @@ dsl_scan_setup_sync(void *arg, dmu_tx_t *tx) mutex_init(&dp->dp_blkstats->zab_lock, NULL, MUTEX_DEFAULT, NULL); } - bzero(&dp->dp_blkstats->zab_type, sizeof (dp->dp_blkstats->zab_type)); + memset(&dp->dp_blkstats->zab_type, 0, + sizeof (dp->dp_blkstats->zab_type)); if (spa_version(spa) < SPA_VERSION_DSL_SCRUB) ot = DMU_OT_ZAP_OTHER; @@ -806,7 +807,7 @@ dsl_scan_setup_sync(void *arg, dmu_tx_t *tx) scn->scn_phys.scn_queue_obj = zap_create(dp->dp_meta_objset, ot ? ot : DMU_OT_SCAN_QUEUE, DMU_OT_NONE, 0, tx); - bcopy(&scn->scn_phys, &scn->scn_phys_cached, sizeof (scn->scn_phys)); + memcpy(&scn->scn_phys_cached, &scn->scn_phys, sizeof (scn->scn_phys)); dsl_scan_sync_state(scn, tx, SYNC_MANDATORY); @@ -1792,14 +1793,15 @@ dsl_scan_check_resume(dsl_scan_t *scn, const dnode_phys_t *dnp, * indicate that it's OK to start checking for suspending * again. */ - if (bcmp(zb, &scn->scn_phys.scn_bookmark, sizeof (*zb)) == 0 || + if (memcmp(zb, &scn->scn_phys.scn_bookmark, + sizeof (*zb)) == 0 || zb->zb_object > scn->scn_phys.scn_bookmark.zb_object) { dprintf("resuming at %llx/%llx/%llx/%llx\n", (longlong_t)zb->zb_objset, (longlong_t)zb->zb_object, (longlong_t)zb->zb_level, (longlong_t)zb->zb_blkid); - bzero(&scn->scn_phys.scn_bookmark, sizeof (*zb)); + memset(&scn->scn_phys.scn_bookmark, 0, sizeof (*zb)); } } return (B_FALSE); @@ -2651,12 +2653,10 @@ static void dsl_scan_ddt(dsl_scan_t *scn, dmu_tx_t *tx) { ddt_bookmark_t *ddb = &scn->scn_phys.scn_ddt_bookmark; - ddt_entry_t dde; + ddt_entry_t dde = {{{{0}}}}; int error; uint64_t n = 0; - bzero(&dde, sizeof (ddt_entry_t)); - while ((error = ddt_walk(scn->scn_dp->dp_spa, ddb, &dde)) == 0) { ddt_t *ddt; @@ -2749,7 +2749,7 @@ dsl_scan_visit(dsl_scan_t *scn, dmu_tx_t *tx) * In case we suspended right at the end of the ds, zero the * bookmark so we don't think that we're still trying to resume. */ - bzero(&scn->scn_phys.scn_bookmark, sizeof (zbookmark_phys_t)); + memset(&scn->scn_phys.scn_bookmark, 0, sizeof (zbookmark_phys_t)); /* * Keep pulling things out of the dataset avl queue. Updates to the diff --git a/sys/contrib/openzfs/module/zfs/edonr_zfs.c b/sys/contrib/openzfs/module/zfs/edonr_zfs.c index 7c62e0be07e..e56b4054c67 100644 --- a/sys/contrib/openzfs/module/zfs/edonr_zfs.c +++ b/sys/contrib/openzfs/module/zfs/edonr_zfs.c @@ -53,10 +53,10 @@ abd_checksum_edonr_native(abd_t *abd, uint64_t size, EdonRState ctx; ASSERT(ctx_template != NULL); - bcopy(ctx_template, &ctx, sizeof (ctx)); + memcpy(&ctx, ctx_template, sizeof (ctx)); (void) abd_iterate_func(abd, 0, size, edonr_incremental, &ctx); EdonRFinal(&ctx, digest); - bcopy(digest, zcp->zc_word, sizeof (zcp->zc_word)); + memcpy(zcp->zc_word, digest, sizeof (zcp->zc_word)); } /* @@ -108,8 +108,8 @@ abd_checksum_edonr_tmpl_init(const zio_cksum_salt_t *salt) void abd_checksum_edonr_tmpl_free(void *ctx_template) { - EdonRState *ctx = ctx_template; + EdonRState *ctx = ctx_template; - bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); kmem_free(ctx, sizeof (*ctx)); } diff --git a/sys/contrib/openzfs/module/zfs/gzip.c b/sys/contrib/openzfs/module/zfs/gzip.c index 48191241bd7..6282229c830 100644 --- a/sys/contrib/openzfs/module/zfs/gzip.c +++ b/sys/contrib/openzfs/module/zfs/gzip.c @@ -28,7 +28,6 @@ #include #include -#include #include #include @@ -66,7 +65,7 @@ gzip_compress(void *s_start, void *d_start, size_t s_len, size_t d_len, int n) if (d_len != s_len) return (s_len); - bcopy(s_start, d_start, s_len); + memcpy(d_start, s_start, s_len); return (s_len); } /* if hardware compression fails, do it again with software */ @@ -76,7 +75,7 @@ gzip_compress(void *s_start, void *d_start, size_t s_len, size_t d_len, int n) if (d_len != s_len) return (s_len); - bcopy(s_start, d_start, s_len); + memcpy(d_start, s_start, s_len); return (s_len); } diff --git a/sys/contrib/openzfs/module/zfs/hkdf.c b/sys/contrib/openzfs/module/zfs/hkdf.c index 2c91401d5b4..580544c8ac1 100644 --- a/sys/contrib/openzfs/module/zfs/hkdf.c +++ b/sys/contrib/openzfs/module/zfs/hkdf.c @@ -132,7 +132,7 @@ hkdf_sha512_expand(uint8_t *extract_key, uint8_t *info, uint_t info_len, if (ret != CRYPTO_SUCCESS) return (SET_ERROR(EIO)); - bcopy(T, out_buf + pos, + memcpy(out_buf + pos, T, (i != N) ? SHA512_DIGEST_LENGTH : (out_len - pos)); pos += SHA512_DIGEST_LENGTH; } diff --git a/sys/contrib/openzfs/module/zfs/metaslab.c b/sys/contrib/openzfs/module/zfs/metaslab.c index bd17c1fe862..7ed83b305db 100644 --- a/sys/contrib/openzfs/module/zfs/metaslab.c +++ b/sys/contrib/openzfs/module/zfs/metaslab.c @@ -1952,9 +1952,9 @@ metaslab_aux_histograms_clear(metaslab_t *msp) */ ASSERT(msp->ms_loaded); - bzero(msp->ms_synchist, sizeof (msp->ms_synchist)); + memset(msp->ms_synchist, 0, sizeof (msp->ms_synchist)); for (int t = 0; t < TXG_DEFER_SIZE; t++) - bzero(msp->ms_deferhist[t], sizeof (msp->ms_deferhist[t])); + memset(msp->ms_deferhist[t], 0, sizeof (msp->ms_deferhist[t])); } static void @@ -2044,13 +2044,13 @@ metaslab_aux_histograms_update_done(metaslab_t *msp, boolean_t defer_allowed) */ uint64_t hist_index = spa_syncing_txg(spa) % TXG_DEFER_SIZE; if (defer_allowed) { - bcopy(msp->ms_synchist, msp->ms_deferhist[hist_index], + memcpy(msp->ms_deferhist[hist_index], msp->ms_synchist, sizeof (msp->ms_synchist)); } else { - bzero(msp->ms_deferhist[hist_index], + memset(msp->ms_deferhist[hist_index], 0, sizeof (msp->ms_deferhist[hist_index])); } - bzero(msp->ms_synchist, sizeof (msp->ms_synchist)); + memset(msp->ms_synchist, 0, sizeof (msp->ms_synchist)); } /* @@ -5296,7 +5296,7 @@ next: goto top; } - bzero(&dva[d], sizeof (dva_t)); + memset(&dva[d], 0, sizeof (dva_t)); metaslab_trace_add(zal, rotor, NULL, psize, d, TRACE_ENOSPC, allocator); return (SET_ERROR(ENOSPC)); @@ -5809,7 +5809,7 @@ metaslab_alloc(spa_t *spa, metaslab_class_t *mc, uint64_t psize, blkptr_t *bp, metaslab_group_alloc_decrement(spa, DVA_GET_VDEV(&dva[d]), zio, flags, allocator, B_FALSE); - bzero(&dva[d], sizeof (dva_t)); + memset(&dva[d], 0, sizeof (dva_t)); } spa_config_exit(spa, SCL_ALLOC, FTAG); return (error); diff --git a/sys/contrib/openzfs/module/zfs/mmp.c b/sys/contrib/openzfs/module/zfs/mmp.c index f8ba2169591..b03b90fdc52 100644 --- a/sys/contrib/openzfs/module/zfs/mmp.c +++ b/sys/contrib/openzfs/module/zfs/mmp.c @@ -187,7 +187,7 @@ uint_t zfs_multihost_import_intervals = MMP_DEFAULT_IMPORT_INTERVALS; uint_t zfs_multihost_fail_intervals = MMP_DEFAULT_FAIL_INTERVALS; static void *const mmp_tag = "mmp_write_uberblock"; -static _Noreturn void mmp_thread(void *arg); +static __attribute__((noreturn)) void mmp_thread(void *arg); void mmp_init(spa_t *spa) @@ -217,14 +217,13 @@ mmp_thread_enter(mmp_thread_t *mmp, callb_cpr_t *cpr) mutex_enter(&mmp->mmp_thread_lock); } -static _Noreturn void +static void mmp_thread_exit(mmp_thread_t *mmp, kthread_t **mpp, callb_cpr_t *cpr) { ASSERT(*mpp != NULL); *mpp = NULL; cv_broadcast(&mmp->mmp_thread_cv); CALLB_CPR_EXIT(cpr); /* drops &mmp->mmp_thread_lock */ - thread_exit(); } void @@ -537,7 +536,7 @@ mmp_write_uberblock(spa_t *spa) zio_nowait(zio); } -static _Noreturn void +static __attribute__((noreturn)) void mmp_thread(void *arg) { spa_t *spa = (spa_t *)arg; @@ -698,6 +697,8 @@ mmp_thread(void *arg) mmp->mmp_zio_root = NULL; mmp_thread_exit(mmp, &mmp->mmp_thread, &cpr); + + thread_exit(); } /* diff --git a/sys/contrib/openzfs/module/zfs/range_tree.c b/sys/contrib/openzfs/module/zfs/range_tree.c index f9fb97476b6..fe4bf616c47 100644 --- a/sys/contrib/openzfs/module/zfs/range_tree.c +++ b/sys/contrib/openzfs/module/zfs/range_tree.c @@ -78,7 +78,7 @@ static inline void rs_copy(range_seg_t *src, range_seg_t *dest, range_tree_t *rt) { - ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES); + ASSERT3U(rt->rt_type, <, RANGE_SEG_NUM_TYPES); size_t size = 0; switch (rt->rt_type) { case RANGE_SEG32: @@ -91,9 +91,9 @@ rs_copy(range_seg_t *src, range_seg_t *dest, range_tree_t *rt) size = sizeof (range_seg_gap_t); break; default: - VERIFY(0); + __builtin_unreachable(); } - bcopy(src, dest, size); + memcpy(dest, src, size); } void @@ -701,7 +701,7 @@ range_tree_vacate(range_tree_t *rt, range_tree_func_t *func, void *arg) zfs_btree_clear(&rt->rt_root); } - bzero(rt->rt_histogram, sizeof (rt->rt_histogram)); + memset(rt->rt_histogram, 0, sizeof (rt->rt_histogram)); rt->rt_space = 0; } diff --git a/sys/contrib/openzfs/module/zfs/sa.c b/sys/contrib/openzfs/module/zfs/sa.c index a078af159c1..2b6776581a4 100644 --- a/sys/contrib/openzfs/module/zfs/sa.c +++ b/sys/contrib/openzfs/module/zfs/sa.c @@ -160,7 +160,7 @@ do { \ *(uint64_t *)((uintptr_t)t + 8) = \ *(uint64_t *)((uintptr_t)s + 8); \ } else { \ - bcopy(s, t, l); \ + memcpy(t, s, l); \ } \ } else { \ sa_copy_data(f, s, t, l); \ @@ -414,7 +414,7 @@ sa_add_layout_entry(objset_t *os, const sa_attr_type_t *attrs, int attr_count, tb->lot_attr_count = attr_count; tb->lot_attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count, KM_SLEEP); - bcopy(attrs, tb->lot_attrs, sizeof (sa_attr_type_t) * attr_count); + memcpy(tb->lot_attrs, attrs, sizeof (sa_attr_type_t) * attr_count); tb->lot_num = lot_num; tb->lot_hash = hash; tb->lot_instance = 0; @@ -511,7 +511,7 @@ static void sa_copy_data(sa_data_locator_t *func, void *datastart, void *target, int buflen) { if (func == NULL) { - bcopy(datastart, target, buflen); + memcpy(target, datastart, buflen); } else { boolean_t start; int bytes; @@ -523,7 +523,7 @@ sa_copy_data(sa_data_locator_t *func, void *datastart, void *target, int buflen) bytes = 0; while (bytes < buflen) { func(&dataptr, &length, buflen, start, datastart); - bcopy(dataptr, saptr, length); + memcpy(saptr, dataptr, length); saptr = (void *)((caddr_t)saptr + length); bytes += length; start = B_FALSE; @@ -1664,8 +1664,9 @@ sa_add_projid(sa_handle_t *hdl, dmu_tx_t *tx, uint64_t projid) &xattr, 8); if (zp->z_pflags & ZFS_BONUS_SCANSTAMP) { - bcopy((caddr_t)db->db_data + ZFS_OLD_ZNODE_PHYS_SIZE, - scanstamp, AV_SCANSTAMP_SZ); + memcpy(scanstamp, + (caddr_t)db->db_data + ZFS_OLD_ZNODE_PHYS_SIZE, + AV_SCANSTAMP_SZ); SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_SCANSTAMP(zfsvfs), NULL, scanstamp, AV_SCANSTAMP_SZ); zp->z_pflags &= ~ZFS_BONUS_SCANSTAMP; @@ -1873,7 +1874,7 @@ sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, if (dn->dn_bonuslen != 0) { bonus_data_size = hdl->sa_bonus->db_size; old_data[0] = kmem_alloc(bonus_data_size, KM_SLEEP); - bcopy(hdl->sa_bonus->db_data, old_data[0], + memcpy(old_data[0], hdl->sa_bonus->db_data, hdl->sa_bonus->db_size); bonus_attr_count = hdl->sa_bonus_tab->sa_layout->lot_attr_count; } else { @@ -1886,7 +1887,7 @@ sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, if ((error = sa_get_spill(hdl)) == 0) { spill_data_size = hdl->sa_spill->db_size; old_data[1] = vmem_alloc(spill_data_size, KM_SLEEP); - bcopy(hdl->sa_spill->db_data, old_data[1], + memcpy(old_data[1], hdl->sa_spill->db_data, hdl->sa_spill->db_size); spill_attr_count = hdl->sa_spill_tab->sa_layout->lot_attr_count; diff --git a/sys/contrib/openzfs/module/zfs/skein_zfs.c b/sys/contrib/openzfs/module/zfs/skein_zfs.c index 55c7ac2a50a..4b2aca888ee 100644 --- a/sys/contrib/openzfs/module/zfs/skein_zfs.c +++ b/sys/contrib/openzfs/module/zfs/skein_zfs.c @@ -45,13 +45,13 @@ void abd_checksum_skein_native(abd_t *abd, uint64_t size, const void *ctx_template, zio_cksum_t *zcp) { - Skein_512_Ctxt_t ctx; + Skein_512_Ctxt_t ctx; ASSERT(ctx_template != NULL); - bcopy(ctx_template, &ctx, sizeof (ctx)); + memcpy(&ctx, ctx_template, sizeof (ctx)); (void) abd_iterate_func(abd, 0, size, skein_incremental, &ctx); (void) Skein_512_Final(&ctx, (uint8_t *)zcp); - bzero(&ctx, sizeof (ctx)); + memset(&ctx, 0, sizeof (ctx)); } /* @@ -79,9 +79,8 @@ abd_checksum_skein_byteswap(abd_t *abd, uint64_t size, void * abd_checksum_skein_tmpl_init(const zio_cksum_salt_t *salt) { - Skein_512_Ctxt_t *ctx; + Skein_512_Ctxt_t *ctx = kmem_zalloc(sizeof (*ctx), KM_SLEEP); - ctx = kmem_zalloc(sizeof (*ctx), KM_SLEEP); (void) Skein_512_InitExt(ctx, sizeof (zio_cksum_t) * 8, 0, salt->zcs_bytes, sizeof (salt->zcs_bytes)); return (ctx); @@ -94,8 +93,8 @@ abd_checksum_skein_tmpl_init(const zio_cksum_salt_t *salt) void abd_checksum_skein_tmpl_free(void *ctx_template) { - Skein_512_Ctxt_t *ctx = ctx_template; + Skein_512_Ctxt_t *ctx = ctx_template; - bzero(ctx, sizeof (*ctx)); + memset(ctx, 0, sizeof (*ctx)); kmem_free(ctx, sizeof (*ctx)); } diff --git a/sys/contrib/openzfs/module/zfs/spa.c b/sys/contrib/openzfs/module/zfs/spa.c index 744bcb434f0..e69cb5527be 100644 --- a/sys/contrib/openzfs/module/zfs/spa.c +++ b/sys/contrib/openzfs/module/zfs/spa.c @@ -947,8 +947,8 @@ spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub) { ASSERT(MUTEX_HELD(&spa->spa_errlist_lock)); - bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t)); - bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t)); + memcpy(last, &spa->spa_errlist_last, sizeof (avl_tree_t)); + memcpy(scrub, &spa->spa_errlist_scrub, sizeof (avl_tree_t)); avl_create(&spa->spa_errlist_scrub, spa_error_entry_compare, sizeof (spa_error_entry_t), @@ -8139,7 +8139,7 @@ spa_async_autoexpand(spa_t *spa, vdev_t *vd) spa_event_notify(vd->vdev_spa, vd, NULL, ESC_ZFS_VDEV_AUTOEXPAND); } -static _Noreturn void +static __attribute__((noreturn)) void spa_async_thread(void *arg) { spa_t *spa = (spa_t *)arg; @@ -8495,7 +8495,7 @@ spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx) VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR, KM_SLEEP) == 0); - bzero(packed + nvsize, bufsize - nvsize); + memset(packed + nvsize, 0, bufsize - nvsize); dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx); diff --git a/sys/contrib/openzfs/module/zfs/spa_checkpoint.c b/sys/contrib/openzfs/module/zfs/spa_checkpoint.c index 68c3ae2e0c3..7c543caaa27 100644 --- a/sys/contrib/openzfs/module/zfs/spa_checkpoint.c +++ b/sys/contrib/openzfs/module/zfs/spa_checkpoint.c @@ -166,7 +166,7 @@ spa_checkpoint_get_stats(spa_t *spa, pool_checkpoint_stat_t *pcs) if (!spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) return (SET_ERROR(ZFS_ERR_NO_CHECKPOINT)); - bzero(pcs, sizeof (pool_checkpoint_stat_t)); + memset(pcs, 0, sizeof (pool_checkpoint_stat_t)); int error = zap_contains(spa_meta_objset(spa), DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ZPOOL_CHECKPOINT); diff --git a/sys/contrib/openzfs/module/zfs/spa_misc.c b/sys/contrib/openzfs/module/zfs/spa_misc.c index a04766e7e33..12aec4a568e 100644 --- a/sys/contrib/openzfs/module/zfs/spa_misc.c +++ b/sys/contrib/openzfs/module/zfs/spa_misc.c @@ -1477,8 +1477,7 @@ spa_strdup(const char *s) len = strlen(s); new = kmem_alloc(len + 1, KM_SLEEP); - bcopy(s, new, len); - new[len] = '\0'; + memcpy(new, s, len + 1); return (new); } @@ -2566,7 +2565,7 @@ spa_scan_get_stats(spa_t *spa, pool_scan_stat_t *ps) if (scn == NULL || scn->scn_phys.scn_func == POOL_SCAN_NONE) return (SET_ERROR(ENOENT)); - bzero(ps, sizeof (pool_scan_stat_t)); + memset(ps, 0, sizeof (pool_scan_stat_t)); /* data stored on disk */ ps->pss_func = scn->scn_phys.scn_func; diff --git a/sys/contrib/openzfs/module/zfs/space_map.c b/sys/contrib/openzfs/module/zfs/space_map.c index 11d4798925e..61282f693c2 100644 --- a/sys/contrib/openzfs/module/zfs/space_map.c +++ b/sys/contrib/openzfs/module/zfs/space_map.c @@ -455,7 +455,8 @@ space_map_histogram_clear(space_map_t *sm) if (sm->sm_dbuf->db_size != sizeof (space_map_phys_t)) return; - bzero(sm->sm_phys->smp_histogram, sizeof (sm->sm_phys->smp_histogram)); + memset(sm->sm_phys->smp_histogram, 0, + sizeof (sm->sm_phys->smp_histogram)); } boolean_t @@ -896,7 +897,7 @@ space_map_truncate(space_map_t *sm, int blocksize, dmu_tx_t *tx) * will be reset. Do the same in the common case so that * bugs related to the uncommon case do not go unnoticed. */ - bzero(sm->sm_phys->smp_histogram, + memset(sm->sm_phys->smp_histogram, 0, sizeof (sm->sm_phys->smp_histogram)); } diff --git a/sys/contrib/openzfs/module/zfs/txg.c b/sys/contrib/openzfs/module/zfs/txg.c index 7908183caee..6d512307670 100644 --- a/sys/contrib/openzfs/module/zfs/txg.c +++ b/sys/contrib/openzfs/module/zfs/txg.c @@ -108,8 +108,8 @@ * now transition to the syncing state. */ -static _Noreturn void txg_sync_thread(void *arg); -static _Noreturn void txg_quiesce_thread(void *arg); +static __attribute__((noreturn)) void txg_sync_thread(void *arg); +static __attribute__((noreturn)) void txg_quiesce_thread(void *arg); int zfs_txg_timeout = 5; /* max seconds worth of delta per txg */ @@ -121,7 +121,7 @@ txg_init(dsl_pool_t *dp, uint64_t txg) { tx_state_t *tx = &dp->dp_tx; int c; - bzero(tx, sizeof (tx_state_t)); + memset(tx, 0, sizeof (tx_state_t)); tx->tx_cpu = vmem_zalloc(max_ncpus * sizeof (tx_cpu_t), KM_SLEEP); @@ -186,7 +186,7 @@ txg_fini(dsl_pool_t *dp) vmem_free(tx->tx_cpu, max_ncpus * sizeof (tx_cpu_t)); - bzero(tx, sizeof (tx_state_t)); + memset(tx, 0, sizeof (tx_state_t)); } /* @@ -514,7 +514,7 @@ txg_has_quiesced_to_sync(dsl_pool_t *dp) return (tx->tx_quiesced_txg != 0); } -static _Noreturn void +static __attribute__((noreturn)) void txg_sync_thread(void *arg) { dsl_pool_t *dp = arg; @@ -605,7 +605,7 @@ txg_sync_thread(void *arg) } } -static _Noreturn void +static __attribute__((noreturn)) void txg_quiesce_thread(void *arg) { dsl_pool_t *dp = arg; diff --git a/sys/contrib/openzfs/module/zfs/vdev.c b/sys/contrib/openzfs/module/zfs/vdev.c index a844ee2a73c..db2d2c5e44f 100644 --- a/sys/contrib/openzfs/module/zfs/vdev.c +++ b/sys/contrib/openzfs/module/zfs/vdev.c @@ -475,7 +475,7 @@ vdev_add_child(vdev_t *pvd, vdev_t *cvd) newchild = kmem_alloc(newsize, KM_SLEEP); if (pvd->vdev_child != NULL) { - bcopy(pvd->vdev_child, newchild, oldsize); + memcpy(newchild, pvd->vdev_child, oldsize); kmem_free(pvd->vdev_child, oldsize); } @@ -1426,7 +1426,7 @@ vdev_metaslab_init(vdev_t *vd, uint64_t txg) mspp = vmem_zalloc(newc * sizeof (*mspp), KM_SLEEP); if (expanding) { - bcopy(vd->vdev_ms, mspp, oldc * sizeof (*mspp)); + memcpy(mspp, vd->vdev_ms, oldc * sizeof (*mspp)); vmem_free(vd->vdev_ms, oldc * sizeof (*mspp)); } @@ -4418,12 +4418,13 @@ vdev_get_stats_ex(vdev_t *vd, vdev_stat_t *vs, vdev_stat_ex_t *vsx) vdev_t *tvd = vd->vdev_top; mutex_enter(&vd->vdev_stat_lock); if (vs) { - bcopy(&vd->vdev_stat, vs, sizeof (*vs)); + memcpy(vs, &vd->vdev_stat, sizeof (*vs)); vs->vs_timestamp = gethrtime() - vs->vs_timestamp; vs->vs_state = vd->vdev_state; vs->vs_rsize = vdev_get_min_asize(vd); if (vd->vdev_ops->vdev_op_leaf) { + vs->vs_pspace = vd->vdev_psize; vs->vs_rsize += VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE; /* diff --git a/sys/contrib/openzfs/module/zfs/vdev_draid.c b/sys/contrib/openzfs/module/zfs/vdev_draid.c index 6c765d98458..fa8daf57b2e 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_draid.c +++ b/sys/contrib/openzfs/module/zfs/vdev_draid.c @@ -1725,7 +1725,7 @@ vdev_draid_spare_create(nvlist_t *nvroot, vdev_t *vd, uint64_t *ndraidp, uint64_t nparity = vdc->vdc_nparity; for (uint64_t spare_id = 0; spare_id < nspares; spare_id++) { - bzero(path, sizeof (path)); + memset(path, 0, sizeof (path)); (void) snprintf(path, sizeof (path) - 1, "%s%llu-%llu-%llu", VDEV_TYPE_DRAID, (u_longlong_t)nparity, diff --git a/sys/contrib/openzfs/module/zfs/vdev_indirect.c b/sys/contrib/openzfs/module/zfs/vdev_indirect.c index aeba1e99e6e..9189d3f3124 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_indirect.c +++ b/sys/contrib/openzfs/module/zfs/vdev_indirect.c @@ -48,8 +48,8 @@ * "vdev_remap" operation that executes a callback on each contiguous * segment of the new location. This function is used in multiple ways: * - * - i/os to this vdev use the callback to determine where the - * data is now located, and issue child i/os for each segment's new + * - I/Os to this vdev use the callback to determine where the + * data is now located, and issue child I/Os for each segment's new * location. * * - frees and claims to this vdev use the callback to free or claim @@ -1021,7 +1021,7 @@ vdev_indirect_mapping_duplicate_adjacent_entries(vdev_t *vd, uint64_t offset, size_t copy_length = entries * sizeof (*first_mapping); duplicate_mappings = kmem_alloc(copy_length, KM_SLEEP); - bcopy(first_mapping, duplicate_mappings, copy_length); + memcpy(duplicate_mappings, first_mapping, copy_length); *copied_entries = entries; return (duplicate_mappings); diff --git a/sys/contrib/openzfs/module/zfs/vdev_indirect_births.c b/sys/contrib/openzfs/module/zfs/vdev_indirect_births.c index e8f925628d0..65a57e73604 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_indirect_births.c +++ b/sys/contrib/openzfs/module/zfs/vdev_indirect_births.c @@ -152,7 +152,7 @@ vdev_indirect_births_add_entry(vdev_indirect_births_t *vib, new_entries = vmem_alloc(new_size, KM_SLEEP); if (old_size > 0) { - bcopy(vib->vib_entries, new_entries, old_size); + memcpy(new_entries, vib->vib_entries, old_size); vmem_free(vib->vib_entries, old_size); } new_entries[vib->vib_phys->vib_count - 1] = vibe; diff --git a/sys/contrib/openzfs/module/zfs/vdev_indirect_mapping.c b/sys/contrib/openzfs/module/zfs/vdev_indirect_mapping.c index 4ade56e062f..e92495f2dd3 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_indirect_mapping.c +++ b/sys/contrib/openzfs/module/zfs/vdev_indirect_mapping.c @@ -482,7 +482,7 @@ vdev_indirect_mapping_add_entries(vdev_indirect_mapping_t *vim, entries_written * sizeof (vdev_indirect_mapping_entry_phys_t)); vim->vim_entries = vmem_alloc(new_size, KM_SLEEP); if (old_size > 0) { - bcopy(old_entries, vim->vim_entries, old_size); + memcpy(vim->vim_entries, old_entries, old_size); vmem_free(old_entries, old_size); } VERIFY0(dmu_read(vim->vim_objset, vim->vim_object, old_size, @@ -584,7 +584,7 @@ vdev_indirect_mapping_load_obsolete_counts(vdev_indirect_mapping_t *vim) 0, counts_size, counts, DMU_READ_PREFETCH)); } else { - bzero(counts, counts_size); + memset(counts, 0, counts_size); } return (counts); } diff --git a/sys/contrib/openzfs/module/zfs/vdev_initialize.c b/sys/contrib/openzfs/module/zfs/vdev_initialize.c index 6c4528e93ad..8945705a0a2 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_initialize.c +++ b/sys/contrib/openzfs/module/zfs/vdev_initialize.c @@ -488,7 +488,7 @@ vdev_initialize_range_add(void *arg, uint64_t start, uint64_t size) vdev_xlate_walk(vd, &logical_rs, vdev_initialize_xlate_range_add, arg); } -static _Noreturn void +static __attribute__((noreturn)) void vdev_initialize_thread(void *arg) { vdev_t *vd = arg; diff --git a/sys/contrib/openzfs/module/zfs/vdev_label.c b/sys/contrib/openzfs/module/zfs/vdev_label.c index 29391af820e..865710337e6 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_label.c +++ b/sys/contrib/openzfs/module/zfs/vdev_label.c @@ -1565,7 +1565,7 @@ vdev_uberblock_load(vdev_t *rvd, uberblock_t *ub, nvlist_t **config) ASSERT(ub); ASSERT(config); - bzero(ub, sizeof (uberblock_t)); + memset(ub, 0, sizeof (uberblock_t)); *config = NULL; cb.ubl_ubbest = ub; diff --git a/sys/contrib/openzfs/module/zfs/vdev_raidz.c b/sys/contrib/openzfs/module/zfs/vdev_raidz.c index 1d691c81b5d..ae0777b3dcc 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_raidz.c +++ b/sys/contrib/openzfs/module/zfs/vdev_raidz.c @@ -1779,11 +1779,9 @@ vdev_raidz_checksum_error(zio_t *zio, raidz_col_t *rc, abd_t *bad_data) static int raidz_checksum_verify(zio_t *zio) { - zio_bad_cksum_t zbc; + zio_bad_cksum_t zbc = {{{0}}}; raidz_map_t *rm = zio->io_vsd; - bzero(&zbc, sizeof (zio_bad_cksum_t)); - int ret = zio_checksum_error(zio, &zbc); if (ret != 0 && zbc.zbc_injected != 0) rm->rm_ecksuminjected = 1; diff --git a/sys/contrib/openzfs/module/zfs/vdev_rebuild.c b/sys/contrib/openzfs/module/zfs/vdev_rebuild.c index 510463b1f97..a965912ac7a 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_rebuild.c +++ b/sys/contrib/openzfs/module/zfs/vdev_rebuild.c @@ -133,7 +133,7 @@ static int zfs_rebuild_scrub_enabled = 1; /* * For vdev_rebuild_initiate_sync() and vdev_rebuild_reset_sync(). */ -static _Noreturn void vdev_rebuild_thread(void *arg); +static __attribute__((noreturn)) void vdev_rebuild_thread(void *arg); /* * Clear the per-vdev rebuild bytes value for a vdev tree. @@ -227,7 +227,7 @@ vdev_rebuild_initiate_sync(void *arg, dmu_tx_t *tx) spa_feature_incr(vd->vdev_spa, SPA_FEATURE_DEVICE_REBUILD, tx); mutex_enter(&vd->vdev_rebuild_lock); - bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); + memset(vrp, 0, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); vrp->vrp_rebuild_state = VDEV_REBUILD_ACTIVE; vrp->vrp_min_txg = 0; vrp->vrp_max_txg = dmu_tx_get_txg(tx); @@ -448,7 +448,7 @@ vdev_rebuild_clear_sync(void *arg, dmu_tx_t *tx) } clear_rebuild_bytes(vd); - bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); + memset(vrp, 0, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); if (vd->vdev_top_zap != 0 && zap_contains(mos, vd->vdev_top_zap, VDEV_TOP_ZAP_VDEV_REBUILD_PHYS) == 0) { @@ -701,7 +701,7 @@ vdev_rebuild_load(vdev_t *vd) vd->vdev_rebuilding = B_FALSE; if (!spa_feature_is_enabled(spa, SPA_FEATURE_DEVICE_REBUILD)) { - bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); + memset(vrp, 0, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); mutex_exit(&vd->vdev_rebuild_lock); return (SET_ERROR(ENOTSUP)); } @@ -718,7 +718,7 @@ vdev_rebuild_load(vdev_t *vd) * status allowing a new resilver/rebuild to be started. */ if (err == ENOENT || err == EOVERFLOW || err == ECKSUM) { - bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); + memset(vrp, 0, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES); } else if (err) { mutex_exit(&vd->vdev_rebuild_lock); return (err); @@ -736,7 +736,7 @@ vdev_rebuild_load(vdev_t *vd) * Each scan thread is responsible for rebuilding a top-level vdev. The * rebuild progress in tracked on-disk in VDEV_TOP_ZAP_VDEV_REBUILD_PHYS. */ -static _Noreturn void +static __attribute__((noreturn)) void vdev_rebuild_thread(void *arg) { vdev_t *vd = arg; @@ -1111,7 +1111,7 @@ vdev_rebuild_get_stats(vdev_t *tvd, vdev_rebuild_stat_t *vrs) tvd->vdev_top_zap, VDEV_TOP_ZAP_VDEV_REBUILD_PHYS); if (error == ENOENT) { - bzero(vrs, sizeof (vdev_rebuild_stat_t)); + memset(vrs, 0, sizeof (vdev_rebuild_stat_t)); vrs->vrs_state = VDEV_REBUILD_NONE; error = 0; } else if (error == 0) { diff --git a/sys/contrib/openzfs/module/zfs/vdev_removal.c b/sys/contrib/openzfs/module/zfs/vdev_removal.c index 6887b2f5237..17f9d6c9080 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_removal.c +++ b/sys/contrib/openzfs/module/zfs/vdev_removal.c @@ -140,7 +140,7 @@ int zfs_removal_suspend_progress = 0; #define VDEV_REMOVAL_ZAP_OBJS "lzap" -static _Noreturn void spa_vdev_remove_thread(void *arg); +static __attribute__((noreturn)) void spa_vdev_remove_thread(void *arg); static int spa_vdev_remove_cancel_impl(spa_t *spa); static void @@ -1589,7 +1589,7 @@ spa_remove_max_segment(spa_t *spa) * TXG have completed (see spa_txg_zio) and writes the new mappings to disk * (see vdev_mapping_sync()). */ -static _Noreturn void +static __attribute__((noreturn)) void spa_vdev_remove_thread(void *arg) { spa_t *spa = arg; diff --git a/sys/contrib/openzfs/module/zfs/vdev_trim.c b/sys/contrib/openzfs/module/zfs/vdev_trim.c index 77f27406ea0..ed98df78291 100644 --- a/sys/contrib/openzfs/module/zfs/vdev_trim.c +++ b/sys/contrib/openzfs/module/zfs/vdev_trim.c @@ -834,7 +834,7 @@ vdev_trim_range_add(void *arg, uint64_t start, uint64_t size) * by its ms_allocatable. While a metaslab is undergoing trimming it is * not eligible for new allocations. */ -static _Noreturn void +static __attribute__((noreturn)) void vdev_trim_thread(void *arg) { vdev_t *vd = arg; @@ -1175,7 +1175,7 @@ vdev_trim_range_verify(void *arg, uint64_t start, uint64_t size) * N.B. This behavior is different from a manual TRIM where a thread * is created for each leaf vdev, instead of each top-level vdev. */ -static _Noreturn void +static __attribute__((noreturn)) void vdev_autotrim_thread(void *arg) { vdev_t *vd = arg; @@ -1514,13 +1514,13 @@ vdev_autotrim_restart(spa_t *spa) vdev_autotrim(spa); } -static _Noreturn void +static __attribute__((noreturn)) void vdev_trim_l2arc_thread(void *arg) { vdev_t *vd = arg; spa_t *spa = vd->vdev_spa; l2arc_dev_t *dev = l2arc_vdev_get(vd); - trim_args_t ta; + trim_args_t ta = {0}; range_seg64_t physical_rs; ASSERT(vdev_is_concrete(vd)); @@ -1531,7 +1531,6 @@ vdev_trim_l2arc_thread(void *arg) vd->vdev_trim_partial = 0; vd->vdev_trim_secure = 0; - bzero(&ta, sizeof (ta)); ta.trim_vdev = vd; ta.trim_tree = range_tree_create(NULL, RANGE_SEG64, NULL, 0, 0); ta.trim_type = TRIM_TYPE_MANUAL; @@ -1591,7 +1590,7 @@ vdev_trim_l2arc_thread(void *arg) */ spa_config_enter(vd->vdev_spa, SCL_L2ARC, vd, RW_READER); - bzero(dev->l2ad_dev_hdr, dev->l2ad_dev_hdr_asize); + memset(dev->l2ad_dev_hdr, 0, dev->l2ad_dev_hdr_asize); l2arc_dev_hdr_update(dev); spa_config_exit(vd->vdev_spa, SCL_L2ARC, vd); @@ -1655,9 +1654,9 @@ vdev_trim_l2arc(spa_t *spa) int vdev_trim_simple(vdev_t *vd, uint64_t start, uint64_t size) { - trim_args_t ta; - range_seg64_t physical_rs; - int error; + trim_args_t ta = {0}; + range_seg64_t physical_rs; + int error; physical_rs.rs_start = start; physical_rs.rs_end = start + size; @@ -1666,7 +1665,6 @@ vdev_trim_simple(vdev_t *vd, uint64_t start, uint64_t size) ASSERT(!vd->vdev_detached); ASSERT(!vd->vdev_top->vdev_removing); - bzero(&ta, sizeof (ta)); ta.trim_vdev = vd; ta.trim_tree = range_tree_create(NULL, RANGE_SEG64, NULL, 0, 0); ta.trim_type = TRIM_TYPE_SIMPLE; diff --git a/sys/contrib/openzfs/module/zfs/zap.c b/sys/contrib/openzfs/module/zfs/zap.c index d1d07f9fc80..b2b9dc27f1b 100644 --- a/sys/contrib/openzfs/module/zfs/zap.c +++ b/sys/contrib/openzfs/module/zfs/zap.c @@ -112,7 +112,7 @@ fzap_upgrade(zap_t *zap, dmu_tx_t *tx, zap_flags_t flags) * explicitly zero it since it might be coming from an * initialized microzap */ - bzero(zap->zap_dbuf->db_data, zap->zap_dbuf->db_size); + memset(zap->zap_dbuf->db_data, 0, zap->zap_dbuf->db_size); zp->zap_block_type = ZBT_HEADER; zp->zap_magic = ZAP_MAGIC; diff --git a/sys/contrib/openzfs/module/zfs/zap_leaf.c b/sys/contrib/openzfs/module/zfs/zap_leaf.c index aad923d512d..d161c19c9cb 100644 --- a/sys/contrib/openzfs/module/zfs/zap_leaf.c +++ b/sys/contrib/openzfs/module/zfs/zap_leaf.c @@ -207,7 +207,7 @@ zap_leaf_chunk_free(zap_leaf_t *l, uint16_t chunk) zlf->lf_type = ZAP_CHUNK_FREE; zlf->lf_next = zap_leaf_phys(l)->l_hdr.lh_freelist; - bzero(zlf->lf_pad, sizeof (zlf->lf_pad)); /* help it to compress */ + memset(zlf->lf_pad, 0, sizeof (zlf->lf_pad)); /* help it to compress */ zap_leaf_phys(l)->l_hdr.lh_freelist = chunk; zap_leaf_phys(l)->l_hdr.lh_nfree++; @@ -304,7 +304,7 @@ zap_leaf_array_read(zap_leaf_t *l, uint16_t chunk, while (chunk != CHAIN_END) { struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, chunk).l_array; - bcopy(la->la_array, p, ZAP_LEAF_ARRAY_BYTES); + memcpy(p, la->la_array, ZAP_LEAF_ARRAY_BYTES); p += ZAP_LEAF_ARRAY_BYTES; chunk = la->la_next; } @@ -344,7 +344,7 @@ zap_leaf_array_match(zap_leaf_t *l, zap_name_t *zn, zap_leaf_array_read(l, chunk, sizeof (*thiskey), array_numints, sizeof (*thiskey), array_numints, thiskey); - boolean_t match = bcmp(thiskey, zn->zn_key_orig, + boolean_t match = memcmp(thiskey, zn->zn_key_orig, array_numints * sizeof (*thiskey)) == 0; kmem_free(thiskey, array_numints * sizeof (*thiskey)); return (match); @@ -372,7 +372,8 @@ zap_leaf_array_match(zap_leaf_t *l, zap_name_t *zn, struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, chunk).l_array; int toread = MIN(array_numints - bseen, ZAP_LEAF_ARRAY_BYTES); ASSERT3U(chunk, <, ZAP_LEAF_NUMCHUNKS(l)); - if (bcmp(la->la_array, (char *)zn->zn_key_orig + bseen, toread)) + if (memcmp(la->la_array, (char *)zn->zn_key_orig + bseen, + toread)) break; chunk = la->la_next; bseen += toread; diff --git a/sys/contrib/openzfs/module/zfs/zap_micro.c b/sys/contrib/openzfs/module/zfs/zap_micro.c index 1f32e445052..85134e999be 100644 --- a/sys/contrib/openzfs/module/zfs/zap_micro.c +++ b/sys/contrib/openzfs/module/zfs/zap_micro.c @@ -641,7 +641,7 @@ mzap_upgrade(zap_t **zapp, void *tag, dmu_tx_t *tx, zap_flags_t flags) int sz = zap->zap_dbuf->db_size; mzap_phys_t *mzp = vmem_alloc(sz, KM_SLEEP); - bcopy(zap->zap_dbuf->db_data, mzp, sz); + memcpy(mzp, zap->zap_dbuf->db_data, sz); int nchunks = zap->zap_m.zap_num_chunks; if (!flags) { @@ -1407,7 +1407,7 @@ zap_remove_impl(zap_t *zap, const char *name, err = SET_ERROR(ENOENT); } else { zap->zap_m.zap_num_entries--; - bzero(&zap_m_phys(zap)->mz_chunk[mze->mze_chunkid], + memset(&zap_m_phys(zap)->mz_chunk[mze->mze_chunkid], 0, sizeof (mzap_ent_phys_t)); mze_remove(zap, mze); } @@ -1632,7 +1632,7 @@ zap_get_stats(objset_t *os, uint64_t zapobj, zap_stats_t *zs) if (err != 0) return (err); - bzero(zs, sizeof (zap_stats_t)); + memset(zs, 0, sizeof (zap_stats_t)); if (zap->zap_ismicro) { zs->zs_blocksize = zap->zap_dbuf->db_size; diff --git a/sys/contrib/openzfs/module/zfs/zfs_fm.c b/sys/contrib/openzfs/module/zfs/zfs_fm.c index 828385b430b..adc9f4bc5ec 100644 --- a/sys/contrib/openzfs/module/zfs/zfs_fm.c +++ b/sys/contrib/openzfs/module/zfs/zfs_fm.c @@ -1150,7 +1150,7 @@ zfs_ereport_start_checksum(spa_t *spa, vdev_t *vd, const zbookmark_phys_t *zb, /* copy the checksum failure information if it was provided */ if (info != NULL) { report->zcr_ckinfo = kmem_zalloc(sizeof (*info), KM_SLEEP); - bcopy(info, report->zcr_ckinfo, sizeof (*info)); + memcpy(report->zcr_ckinfo, info, sizeof (*info)); } report->zcr_sector = 1ULL << vd->vdev_top->vdev_ashift; diff --git a/sys/contrib/openzfs/module/zfs/zfs_log.c b/sys/contrib/openzfs/module/zfs/zfs_log.c index 9df801870a4..1d4f5aa79a8 100644 --- a/sys/contrib/openzfs/module/zfs/zfs_log.c +++ b/sys/contrib/openzfs/module/zfs/zfs_log.c @@ -127,9 +127,9 @@ zfs_log_xvattr(lr_attr_t *lrattr, xvattr_t *xvap) attrs = (uint64_t *)bitmap; *attrs = 0; crtime = attrs + 1; - bzero(crtime, 2 * sizeof (uint64_t)); + memset(crtime, 0, 2 * sizeof (uint64_t)); scanstamp = (caddr_t)(crtime + 2); - bzero(scanstamp, AV_SCANSTAMP_SZ); + memset(scanstamp, 0, AV_SCANSTAMP_SZ); if (XVA_ISSET_REQ(xvap, XAT_READONLY)) *attrs |= (xoap->xoa_readonly == 0) ? 0 : XAT0_READONLY; @@ -168,13 +168,13 @@ zfs_log_xvattr(lr_attr_t *lrattr, xvattr_t *xvap) if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) { ASSERT(!XVA_ISSET_REQ(xvap, XAT_PROJID)); - bcopy(xoap->xoa_av_scanstamp, scanstamp, AV_SCANSTAMP_SZ); + memcpy(scanstamp, xoap->xoa_av_scanstamp, AV_SCANSTAMP_SZ); } else if (XVA_ISSET_REQ(xvap, XAT_PROJID)) { /* * XAT_PROJID and XAT_AV_SCANSTAMP will never be valid * at the same time, so we can share the same space. */ - bcopy(&xoap->xoa_projid, scanstamp, sizeof (uint64_t)); + memcpy(scanstamp, &xoap->xoa_projid, sizeof (uint64_t)); } if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) *attrs |= (xoap->xoa_reparse == 0) ? 0 : @@ -214,7 +214,7 @@ zfs_log_fuid_domains(zfs_fuid_info_t *fuidp, void *start) if (fuidp->z_domain_str_sz != 0) { for (zdomain = list_head(&fuidp->z_domains); zdomain; zdomain = list_next(&fuidp->z_domains, zdomain)) { - bcopy((void *)zdomain->z_domain, start, + memcpy(start, zdomain->z_domain, strlen(zdomain->z_domain) + 1); start = (caddr_t)start + strlen(zdomain->z_domain) + 1; @@ -392,7 +392,7 @@ zfs_log_create(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype, else lracl->lr_acl_flags = 0; - bcopy(vsecp->vsa_aclentp, end, aclsize); + memcpy(end, vsecp->vsa_aclentp, aclsize); end = (caddr_t)end + ZIL_ACE_LENGTH(aclsize); } @@ -404,7 +404,7 @@ zfs_log_create(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype, /* * Now place file name in log record */ - bcopy(name, end, namesize); + memcpy(end, name, namesize); zil_itx_assign(zilog, itx, tx); } @@ -426,7 +426,7 @@ zfs_log_remove(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype, itx = zil_itx_create(txtype, sizeof (*lr) + namesize); lr = (lr_remove_t *)&itx->itx_lr; lr->lr_doid = dzp->z_id; - bcopy(name, (char *)(lr + 1), namesize); + memcpy(lr + 1, name, namesize); itx->itx_oid = foid; @@ -462,7 +462,7 @@ zfs_log_link(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype, lr = (lr_link_t *)&itx->itx_lr; lr->lr_doid = dzp->z_id; lr->lr_link_obj = zp->z_id; - bcopy(name, (char *)(lr + 1), namesize); + memcpy(lr + 1, name, namesize); zil_itx_assign(zilog, itx, tx); } @@ -493,8 +493,8 @@ zfs_log_symlink(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype, sizeof (uint64_t)); (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_CRTIME(ZTOZSB(zp)), lr->lr_crtime, sizeof (uint64_t) * 2); - bcopy(name, (char *)(lr + 1), namesize); - bcopy(link, (char *)(lr + 1) + namesize, linksize); + memcpy((char *)(lr + 1), name, namesize); + memcpy((char *)(lr + 1) + namesize, link, linksize); zil_itx_assign(zilog, itx, tx); } @@ -518,8 +518,8 @@ zfs_log_rename(zilog_t *zilog, dmu_tx_t *tx, uint64_t txtype, znode_t *sdzp, lr = (lr_rename_t *)&itx->itx_lr; lr->lr_sdoid = sdzp->z_id; lr->lr_tdoid = tdzp->z_id; - bcopy(sname, (char *)(lr + 1), snamesize); - bcopy(dname, (char *)(lr + 1) + snamesize, dnamesize); + memcpy((char *)(lr + 1), sname, snamesize); + memcpy((char *)(lr + 1) + snamesize, dname, dnamesize); itx->itx_oid = szp->z_id; zil_itx_assign(zilog, itx, tx); @@ -742,9 +742,9 @@ zfs_log_setsaxattr(zilog_t *zilog, dmu_tx_t *tx, int txtype, lr = (lr_setsaxattr_t *)&itx->itx_lr; lr->lr_foid = zp->z_id; xattrstart = (char *)(lr + 1); - bcopy(name, xattrstart, namelen); + memcpy(xattrstart, name, namelen); if (value != NULL) { - bcopy(value, (char *)xattrstart + namelen, size); + memcpy((char *)xattrstart + namelen, value, size); lr->lr_size = size; } else { lr->lr_size = 0; @@ -802,11 +802,11 @@ zfs_log_acl(zilog_t *zilog, dmu_tx_t *tx, znode_t *zp, if (txtype == TX_ACL_V0) { lrv0 = (lr_acl_v0_t *)lr; - bcopy(vsecp->vsa_aclentp, (ace_t *)(lrv0 + 1), aclbytes); + memcpy(lrv0 + 1, vsecp->vsa_aclentp, aclbytes); } else { void *start = (ace_t *)(lr + 1); - bcopy(vsecp->vsa_aclentp, start, aclbytes); + memcpy(start, vsecp->vsa_aclentp, aclbytes); start = (caddr_t)start + ZIL_ACE_LENGTH(aclbytes); diff --git a/sys/contrib/openzfs/module/zfs/zfs_replay.c b/sys/contrib/openzfs/module/zfs/zfs_replay.c index 3ccd96dc256..e9c5eeb55b0 100644 --- a/sys/contrib/openzfs/module/zfs/zfs_replay.c +++ b/sys/contrib/openzfs/module/zfs/zfs_replay.c @@ -70,7 +70,7 @@ static void zfs_init_vattr(vattr_t *vap, uint64_t mask, uint64_t mode, uint64_t uid, uint64_t gid, uint64_t rdev, uint64_t nodeid) { - bzero(vap, sizeof (*vap)); + memset(vap, 0, sizeof (*vap)); vap->va_mask = (uint_t)mask; vap->va_mode = mode; #if defined(__FreeBSD__) || defined(__APPLE__) @@ -143,13 +143,13 @@ zfs_replay_xvattr(lr_attr_t *lrattr, xvattr_t *xvap) if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) { ASSERT(!XVA_ISSET_REQ(xvap, XAT_PROJID)); - bcopy(scanstamp, xoap->xoa_av_scanstamp, AV_SCANSTAMP_SZ); + memcpy(xoap->xoa_av_scanstamp, scanstamp, AV_SCANSTAMP_SZ); } else if (XVA_ISSET_REQ(xvap, XAT_PROJID)) { /* * XAT_PROJID and XAT_AV_SCANSTAMP will never be valid * at the same time, so we can share the same space. */ - bcopy(scanstamp, &xoap->xoa_projid, sizeof (uint64_t)); + memcpy(&xoap->xoa_projid, scanstamp, sizeof (uint64_t)); } if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) xoap->xoa_reparse = ((*attrs & XAT0_REPARSE) != 0); @@ -791,7 +791,7 @@ zfs_replay_truncate(void *arg1, void *arg2, boolean_t byteswap) zfsvfs_t *zfsvfs = arg1; lr_truncate_t *lr = arg2; znode_t *zp; - flock64_t fl; + flock64_t fl = {0}; int error; if (byteswap) @@ -800,7 +800,6 @@ zfs_replay_truncate(void *arg1, void *arg2, boolean_t byteswap) if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) return (error); - bzero(&fl, sizeof (fl)); fl.l_type = F_WRLCK; fl.l_whence = SEEK_SET; fl.l_start = lr->lr_offset; @@ -956,7 +955,7 @@ zfs_replay_acl_v0(void *arg1, void *arg2, boolean_t byteswap) zfsvfs_t *zfsvfs = arg1; lr_acl_v0_t *lr = arg2; ace_t *ace = (ace_t *)(lr + 1); /* ace array follows lr_acl_t */ - vsecattr_t vsa; + vsecattr_t vsa = {0}; znode_t *zp; int error; @@ -968,7 +967,6 @@ zfs_replay_acl_v0(void *arg1, void *arg2, boolean_t byteswap) if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) return (error); - bzero(&vsa, sizeof (vsa)); vsa.vsa_mask = VSA_ACE | VSA_ACECNT; vsa.vsa_aclcnt = lr->lr_aclcnt; vsa.vsa_aclentsz = sizeof (ace_t) * vsa.vsa_aclcnt; @@ -1002,7 +1000,7 @@ zfs_replay_acl(void *arg1, void *arg2, boolean_t byteswap) zfsvfs_t *zfsvfs = arg1; lr_acl_t *lr = arg2; ace_t *ace = (ace_t *)(lr + 1); - vsecattr_t vsa; + vsecattr_t vsa = {0}; znode_t *zp; int error; @@ -1019,7 +1017,6 @@ zfs_replay_acl(void *arg1, void *arg2, boolean_t byteswap) if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) return (error); - bzero(&vsa, sizeof (vsa)); vsa.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS; vsa.vsa_aclcnt = lr->lr_aclcnt; vsa.vsa_aclentp = ace; diff --git a/sys/contrib/openzfs/module/zfs/zfs_sa.c b/sys/contrib/openzfs/module/zfs/zfs_sa.c index 1f15cae00da..d0c7e169fde 100644 --- a/sys/contrib/openzfs/module/zfs/zfs_sa.c +++ b/sys/contrib/openzfs/module/zfs/zfs_sa.c @@ -107,8 +107,8 @@ zfs_sa_symlink(znode_t *zp, char *link, int len, dmu_tx_t *tx) if (ZFS_OLD_ZNODE_PHYS_SIZE + len <= dmu_bonus_max()) { VERIFY0(dmu_set_bonus(db, len + ZFS_OLD_ZNODE_PHYS_SIZE, tx)); if (len) { - bcopy(link, (caddr_t)db->db_data + - ZFS_OLD_ZNODE_PHYS_SIZE, len); + memcpy((caddr_t)db->db_data + + ZFS_OLD_ZNODE_PHYS_SIZE, link, len); } } else { dmu_buf_t *dbp; @@ -120,7 +120,7 @@ zfs_sa_symlink(znode_t *zp, char *link, int len, dmu_tx_t *tx) dmu_buf_will_dirty(dbp, tx); ASSERT3U(len, <=, dbp->db_size); - bcopy(link, dbp->db_data, len); + memcpy(dbp->db_data, link, len); dmu_buf_rele(dbp, FTAG); } } @@ -418,8 +418,9 @@ zfs_sa_upgrade(sa_handle_t *hdl, dmu_tx_t *tx) /* if scanstamp then add scanstamp */ if (zp->z_pflags & ZFS_BONUS_SCANSTAMP) { - bcopy((caddr_t)db->db_data + ZFS_OLD_ZNODE_PHYS_SIZE, - scanstamp, AV_SCANSTAMP_SZ); + memcpy(scanstamp, + (caddr_t)db->db_data + ZFS_OLD_ZNODE_PHYS_SIZE, + AV_SCANSTAMP_SZ); SA_ADD_BULK_ATTR(sa_attrs, count, SA_ZPL_SCANSTAMP(zfsvfs), NULL, scanstamp, AV_SCANSTAMP_SZ); zp->z_pflags &= ~ZFS_BONUS_SCANSTAMP; diff --git a/sys/contrib/openzfs/module/zfs/zfs_vnops.c b/sys/contrib/openzfs/module/zfs/zfs_vnops.c index 5d5b5f29a71..62806e9fe8b 100644 --- a/sys/contrib/openzfs/module/zfs/zfs_vnops.c +++ b/sys/contrib/openzfs/module/zfs/zfs_vnops.c @@ -355,9 +355,8 @@ zfs_clear_setid_bits_if_necessary(zfsvfs_t *zfsvfs, znode_t *zp, cred_t *cr, * than one TX_SETATTR per transaction group. */ if (*clear_setid_bits_txgp != dmu_tx_get_txg(tx)) { - vattr_t va; + vattr_t va = {0}; - bzero(&va, sizeof (va)); va.va_mask = AT_MODE; va.va_nodeid = zp->z_id; va.va_mode = newmode; diff --git a/sys/contrib/openzfs/module/zfs/zil.c b/sys/contrib/openzfs/module/zfs/zil.c index 10f89c91642..161ce3c97e7 100644 --- a/sys/contrib/openzfs/module/zfs/zil.c +++ b/sys/contrib/openzfs/module/zfs/zil.c @@ -259,12 +259,12 @@ zil_read_log_block(zilog_t *zilog, boolean_t decrypt, const blkptr_t *bp, char *lr = (char *)(zilc + 1); uint64_t len = zilc->zc_nused - sizeof (zil_chain_t); - if (bcmp(&cksum, &zilc->zc_next_blk.blk_cksum, + if (memcmp(&cksum, &zilc->zc_next_blk.blk_cksum, sizeof (cksum)) || BP_IS_HOLE(&zilc->zc_next_blk)) { error = SET_ERROR(ECKSUM); } else { ASSERT3U(len, <=, SPA_OLD_MAXBLOCKSIZE); - bcopy(lr, dst, len); + memcpy(dst, lr, len); *end = (char *)dst + len; *nbp = zilc->zc_next_blk; } @@ -273,14 +273,14 @@ zil_read_log_block(zilog_t *zilog, boolean_t decrypt, const blkptr_t *bp, uint64_t size = BP_GET_LSIZE(bp); zil_chain_t *zilc = (zil_chain_t *)(lr + size) - 1; - if (bcmp(&cksum, &zilc->zc_next_blk.blk_cksum, + if (memcmp(&cksum, &zilc->zc_next_blk.blk_cksum, sizeof (cksum)) || BP_IS_HOLE(&zilc->zc_next_blk) || (zilc->zc_nused > (size - sizeof (*zilc)))) { error = SET_ERROR(ECKSUM); } else { ASSERT3U(zilc->zc_nused, <=, SPA_OLD_MAXBLOCKSIZE); - bcopy(lr, dst, zilc->zc_nused); + memcpy(dst, lr, zilc->zc_nused); *end = (char *)dst + zilc->zc_nused; *nbp = zilc->zc_next_blk; } @@ -307,7 +307,7 @@ zil_read_log_data(zilog_t *zilog, const lr_write_t *lr, void *wbuf) if (BP_IS_HOLE(bp)) { if (wbuf != NULL) - bzero(wbuf, MAX(BP_GET_LSIZE(bp), lr->lr_length)); + memset(wbuf, 0, MAX(BP_GET_LSIZE(bp), lr->lr_length)); return (0); } @@ -330,7 +330,7 @@ zil_read_log_data(zilog_t *zilog, const lr_write_t *lr, void *wbuf) if (error == 0) { if (wbuf != NULL) - bcopy(abuf->b_data, wbuf, arc_buf_size(abuf)); + memcpy(wbuf, abuf->b_data, arc_buf_size(abuf)); arc_buf_destroy(abuf, &abuf); } @@ -353,12 +353,10 @@ zil_parse(zilog_t *zilog, zil_parse_blk_func_t *parse_blk_func, uint64_t max_lr_seq = 0; uint64_t blk_count = 0; uint64_t lr_count = 0; - blkptr_t blk, next_blk; + blkptr_t blk, next_blk = {{{{0}}}}; char *lrbuf, *lrp; int error = 0; - bzero(&next_blk, sizeof (blkptr_t)); - /* * Old logs didn't record the maximum zh_claim_lr_seq. */ @@ -786,7 +784,7 @@ zil_create(zilog_t *zilog) dmu_objset_type(zilog->zl_os) != DMU_OST_ZVOL, dsl_dataset_feature_is_active(ds, SPA_FEATURE_ZILSAXATTR)); - ASSERT(error != 0 || bcmp(&blk, &zh->zh_log, sizeof (blk)) == 0); + ASSERT(error != 0 || memcmp(&blk, &zh->zh_log, sizeof (blk)) == 0); IMPLY(error == 0, lwb != NULL); return (lwb); @@ -1648,7 +1646,7 @@ zil_lwb_write_issue(zilog_t *zilog, lwb_t *lwb) /* * clear unused data for security */ - bzero(lwb->lwb_buf + lwb->lwb_nused, wsz - lwb->lwb_nused); + memset(lwb->lwb_buf + lwb->lwb_nused, 0, wsz - lwb->lwb_nused); spa_config_enter(zilog->zl_spa, SCL_STATE, lwb, RW_READER); @@ -1782,7 +1780,7 @@ cont: dnow = MIN(dlen, lwb_sp - reclen); lr_buf = lwb->lwb_buf + lwb->lwb_nused; - bcopy(lrc, lr_buf, reclen); + memcpy(lr_buf, lrc, reclen); lrcb = (lr_t *)lr_buf; /* Like lrc, but inside lwb. */ lrwb = (lr_write_t *)lrcb; /* Like lrw, but inside lwb. */ @@ -1838,7 +1836,7 @@ cont: lwb->lwb_write_zio); if (dbuf != NULL && error == 0 && dnow == dlen) /* Zero any padding bytes in the last block. */ - bzero((char *)dbuf + lrwb->lr_length, dpad); + memset((char *)dbuf + lrwb->lr_length, 0, dpad); if (error == EIO) { txg_wait_synced(zilog->zl_dmu_pool, txg); @@ -1888,7 +1886,7 @@ zil_itx_create(uint64_t txtype, size_t olrsize) itx->itx_lr.lrc_txtype = txtype; itx->itx_lr.lrc_reclen = lrsize; itx->itx_lr.lrc_seq = 0; /* defensive */ - bzero((char *)&itx->itx_lr + olrsize, lrsize - olrsize); + memset((char *)&itx->itx_lr + olrsize, 0, lrsize - olrsize); itx->itx_sync = B_TRUE; /* default is synchronous */ itx->itx_callback = NULL; itx->itx_callback_data = NULL; @@ -3142,8 +3140,9 @@ zil_sync(zilog_t *zilog, dmu_tx_t *tx) ASSERT(list_head(&zilog->zl_lwb_list) == NULL); - bzero(zh, sizeof (zil_header_t)); - bzero(zilog->zl_replayed_seq, sizeof (zilog->zl_replayed_seq)); + memset(zh, 0, sizeof (zil_header_t)); + memset(zilog->zl_replayed_seq, 0, + sizeof (zilog->zl_replayed_seq)); if (zilog->zl_keep_first) { /* @@ -3645,7 +3644,7 @@ zil_replay_log_record(zilog_t *zilog, const lr_t *lr, void *zra, /* * Make a copy of the data so we can revise and extend it. */ - bcopy(lr, zr->zr_lr, reclen); + memcpy(zr->zr_lr, lr, reclen); /* * If this is a TX_WRITE with a blkptr, suck in the data. diff --git a/sys/contrib/openzfs/module/zfs/zio.c b/sys/contrib/openzfs/module/zfs/zio.c index 04a76c68204..f6adea57241 100644 --- a/sys/contrib/openzfs/module/zfs/zio.c +++ b/sys/contrib/openzfs/module/zfs/zio.c @@ -822,7 +822,7 @@ zio_create(zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp, IMPLY(lsize != psize, (flags & ZIO_FLAG_RAW_COMPRESS) != 0); zio = kmem_cache_alloc(zio_cache, KM_SLEEP); - bzero(zio, sizeof (zio_t)); + memset(zio, 0, sizeof (zio_t)); mutex_init(&zio->io_lock, NULL, MUTEX_NOLOCKDEP, NULL); cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL); @@ -2883,7 +2883,7 @@ zio_write_gang_block(zio_t *pio, metaslab_class_t *mc) gn = zio_gang_node_alloc(gnpp); gbh = gn->gn_gbh; - bzero(gbh, SPA_GANGBLOCKSIZE); + memset(gbh, 0, SPA_GANGBLOCKSIZE); gbh_abd = abd_get_from_buf(gbh, SPA_GANGBLOCKSIZE); /* @@ -2912,9 +2912,9 @@ zio_write_gang_block(zio_t *pio, metaslab_class_t *mc) zp.zp_nopwrite = B_FALSE; zp.zp_encrypt = gio->io_prop.zp_encrypt; zp.zp_byteorder = gio->io_prop.zp_byteorder; - bzero(zp.zp_salt, ZIO_DATA_SALT_LEN); - bzero(zp.zp_iv, ZIO_DATA_IV_LEN); - bzero(zp.zp_mac, ZIO_DATA_MAC_LEN); + memset(zp.zp_salt, 0, ZIO_DATA_SALT_LEN); + memset(zp.zp_iv, 0, ZIO_DATA_IV_LEN); + memset(zp.zp_mac, 0, ZIO_DATA_MAC_LEN); zio_t *cio = zio_write(zio, spa, txg, &gbh->zg_blkptr[g], has_data ? abd_get_offset(pio->io_abd, pio->io_size - @@ -3011,7 +3011,7 @@ zio_nop_write(zio_t *zio) ASSERT3U(BP_GET_PSIZE(bp), ==, BP_GET_PSIZE(bp_orig)); ASSERT3U(BP_GET_LSIZE(bp), ==, BP_GET_LSIZE(bp_orig)); ASSERT(zp->zp_compress != ZIO_COMPRESS_OFF); - ASSERT(bcmp(&bp->blk_prop, &bp_orig->blk_prop, + ASSERT(memcmp(&bp->blk_prop, &bp_orig->blk_prop, sizeof (uint64_t)) == 0); /* @@ -4561,7 +4561,7 @@ zio_done(zio_t *zio) if (zio->io_bp != NULL && !BP_IS_EMBEDDED(zio->io_bp)) { ASSERT(zio->io_bp->blk_pad[0] == 0); ASSERT(zio->io_bp->blk_pad[1] == 0); - ASSERT(bcmp(zio->io_bp, &zio->io_bp_copy, + ASSERT(memcmp(zio->io_bp, &zio->io_bp_copy, sizeof (blkptr_t)) == 0 || (zio->io_bp == zio_unique_parent(zio)->io_bp)); if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(zio->io_bp) && diff --git a/sys/contrib/openzfs/module/zfs/zio_checksum.c b/sys/contrib/openzfs/module/zfs/zio_checksum.c index 4dbab68dd7a..d89e5765326 100644 --- a/sys/contrib/openzfs/module/zfs/zio_checksum.c +++ b/sys/contrib/openzfs/module/zfs/zio_checksum.c @@ -351,7 +351,7 @@ zio_checksum_compute(zio_t *zio, enum zio_checksum checksum, zio_eck_t eck; size_t eck_offset; - bzero(&saved, sizeof (zio_cksum_t)); + memset(&saved, 0, sizeof (zio_cksum_t)); if (checksum == ZIO_CHECKSUM_ZILOG2) { zil_chain_t zilc; diff --git a/sys/contrib/openzfs/module/zfs/zio_inject.c b/sys/contrib/openzfs/module/zfs/zio_inject.c index cfc2e8f5b1d..9b629ca0f1f 100644 --- a/sys/contrib/openzfs/module/zfs/zio_inject.c +++ b/sys/contrib/openzfs/module/zfs/zio_inject.c @@ -148,7 +148,8 @@ zio_match_handler(const zbookmark_phys_t *zb, uint64_t type, int dva, zb->zb_level == record->zi_level && zb->zb_blkid >= record->zi_start && zb->zb_blkid <= record->zi_end && - (record->zi_dvas == 0 || (record->zi_dvas & (1ULL << dva))) && + (record->zi_dvas == 0 || + (dva != ZI_NO_DVA && (record->zi_dvas & (1ULL << dva)))) && error == record->zi_error) { return (freq_triggered(record->zi_freq)); } diff --git a/sys/contrib/openzfs/module/zfs/zthr.c b/sys/contrib/openzfs/module/zfs/zthr.c index 2cb600a7124..02b9f0805dd 100644 --- a/sys/contrib/openzfs/module/zfs/zthr.c +++ b/sys/contrib/openzfs/module/zfs/zthr.c @@ -231,7 +231,7 @@ struct zthr { const char *zthr_name; }; -static _Noreturn void +static __attribute__((noreturn)) void zthr_procedure(void *arg) { zthr_t *t = arg; diff --git a/sys/contrib/openzfs/module/zstd/Makefile.in b/sys/contrib/openzfs/module/zstd/Makefile.in index ec174e9b012..80096c3e379 100644 --- a/sys/contrib/openzfs/module/zstd/Makefile.in +++ b/sys/contrib/openzfs/module/zstd/Makefile.in @@ -62,3 +62,8 @@ $(MODULE)-objs += $(vanilla-objs) all: mkdir -p lib/common lib/compress lib/decompress +gensymbols: + for obj in $(vanilla-objs); do echo; echo "/* $$obj: */"; @OBJDUMP@ -t $$obj | awk '$$2 == "g" && !/ zfs_/ {print "#define\t" $$6 " zfs_" $$6}' | sort; done >> include/zstd_compat_wrapper.h + +checksymbols: + @OBJDUMP@ -t $(vanilla-objs) | awk '/file format/ {print} $$2 == "g" && !/ zfs_/ {++ret; print} END {exit ret}' diff --git a/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h b/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h index c39dfa2db93..de428175c7d 100644 --- a/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h +++ b/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h @@ -36,13 +36,9 @@ * This wrapper fixes a problem, in case the ZFS filesystem driver, is compiled * statically into the kernel. * This will cause a symbol collision with the older in-kernel zstd library. - * The following macros will simply rename all local zstd symbols and references * - * Note: if the zstd library for zfs is updated to a newer version, this macro - * list usually needs to be updated. - * this can be done with some hand crafting of the output of the following - * script - * nm zstd.o | awk '{print "#define "$3 " zfs_" $3}' > macrotable + * On update, truncate this file at the scissor line, rebuild the module, + * and make gensymbols. */ #define MEM_MODULE @@ -59,369 +55,240 @@ #endif -#define BIT_initDStream zfs_BIT_initDStream -#define BIT_mask zfs_BIT_mask -#define BIT_reloadDStream zfs_BIT_reloadDStream +/* -- >8 -- */ + +/* lib/common/entropy_common.o: */ +#define FSE_getErrorName zfs_FSE_getErrorName +#define FSE_isError zfs_FSE_isError +#define FSE_readNCount zfs_FSE_readNCount +#define FSE_versionNumber zfs_FSE_versionNumber +#define HUF_getErrorName zfs_HUF_getErrorName +#define HUF_isError zfs_HUF_isError +#define HUF_readStats zfs_HUF_readStats + +/* lib/common/error_private.o: */ #define ERR_getErrorString zfs_ERR_getErrorString -#define FSE_NCountWriteBound zfs_FSE_NCountWriteBound -#define FSE_buildCTable zfs_FSE_buildCTable + +/* lib/common/fse_decompress.o: */ +#define FSE_buildDTable_raw zfs_FSE_buildDTable_raw +#define FSE_buildDTable_rle zfs_FSE_buildDTable_rle +#define FSE_buildDTable zfs_FSE_buildDTable +#define FSE_createDTable zfs_FSE_createDTable +#define FSE_decompress_usingDTable zfs_FSE_decompress_usingDTable +#define FSE_decompress_wksp zfs_FSE_decompress_wksp +#define FSE_decompress zfs_FSE_decompress +#define FSE_freeDTable zfs_FSE_freeDTable + +/* lib/common/pool.o: */ +#define POOL_add zfs_POOL_add +#define POOL_create_advanced zfs_POOL_create_advanced +#define POOL_create zfs_POOL_create +#define POOL_free zfs_POOL_free +#define POOL_resize zfs_POOL_resize +#define POOL_sizeof zfs_POOL_sizeof +#define POOL_tryAdd zfs_POOL_tryAdd + +/* lib/common/zstd_common.o: */ +#define ZSTD_calloc zfs_ZSTD_calloc +#define ZSTD_free zfs_ZSTD_free +#define ZSTD_getErrorCode zfs_ZSTD_getErrorCode +#define ZSTD_getErrorName zfs_ZSTD_getErrorName +#define ZSTD_getErrorString zfs_ZSTD_getErrorString +#define ZSTD_isError zfs_ZSTD_isError +#define ZSTD_malloc zfs_ZSTD_malloc +#define ZSTD_versionNumber zfs_ZSTD_versionNumber +#define ZSTD_versionString zfs_ZSTD_versionString + +/* lib/compress/fse_compress.o: */ #define FSE_buildCTable_raw zfs_FSE_buildCTable_raw #define FSE_buildCTable_rle zfs_FSE_buildCTable_rle #define FSE_buildCTable_wksp zfs_FSE_buildCTable_wksp -#define FSE_buildDTable zfs_FSE_buildDTable -#define FSE_buildDTable_raw zfs_FSE_buildDTable_raw -#define FSE_buildDTable_rle zfs_FSE_buildDTable_rle -#define FSE_compress zfs_FSE_compress +#define FSE_buildCTable zfs_FSE_buildCTable #define FSE_compress2 zfs_FSE_compress2 #define FSE_compressBound zfs_FSE_compressBound #define FSE_compress_usingCTable zfs_FSE_compress_usingCTable -#define FSE_compress_usingCTable_generic zfs_FSE_compress_usingCTable_generic #define FSE_compress_wksp zfs_FSE_compress_wksp +#define FSE_compress zfs_FSE_compress #define FSE_createCTable zfs_FSE_createCTable -#define FSE_createDTable zfs_FSE_createDTable -#define FSE_decompress zfs_FSE_decompress -#define FSE_decompress_usingDTable zfs_FSE_decompress_usingDTable -#define FSE_decompress_wksp zfs_FSE_decompress_wksp #define FSE_freeCTable zfs_FSE_freeCTable -#define FSE_freeDTable zfs_FSE_freeDTable -#define FSE_getErrorName zfs_FSE_getErrorName +#define FSE_NCountWriteBound zfs_FSE_NCountWriteBound #define FSE_normalizeCount zfs_FSE_normalizeCount -#define FSE_optimalTableLog zfs_FSE_optimalTableLog #define FSE_optimalTableLog_internal zfs_FSE_optimalTableLog_internal -#define FSE_readNCount zfs_FSE_readNCount -#define FSE_versionNumber zfs_FSE_versionNumber +#define FSE_optimalTableLog zfs_FSE_optimalTableLog #define FSE_writeNCount zfs_FSE_writeNCount -#define HIST_count zfs_HIST_count -#define HIST_countFast zfs_HIST_countFast + +/* lib/compress/hist.o: */ #define HIST_countFast_wksp zfs_HIST_countFast_wksp -#define HIST_count_parallel_wksp zfs_HIST_count_parallel_wksp +#define HIST_countFast zfs_HIST_countFast #define HIST_count_simple zfs_HIST_count_simple #define HIST_count_wksp zfs_HIST_count_wksp -#define HUF_buildCTable zfs_HUF_buildCTable +#define HIST_count zfs_HIST_count +#define HIST_isError zfs_HIST_isError + +/* lib/compress/huf_compress.o: */ #define HUF_buildCTable_wksp zfs_HUF_buildCTable_wksp -#define HUF_compress zfs_HUF_compress -#define HUF_compress1X zfs_HUF_compress1X +#define HUF_buildCTable zfs_HUF_buildCTable #define HUF_compress1X_repeat zfs_HUF_compress1X_repeat #define HUF_compress1X_usingCTable zfs_HUF_compress1X_usingCTable #define HUF_compress1X_wksp zfs_HUF_compress1X_wksp +#define HUF_compress1X zfs_HUF_compress1X #define HUF_compress2 zfs_HUF_compress2 #define HUF_compress4X_repeat zfs_HUF_compress4X_repeat #define HUF_compress4X_usingCTable zfs_HUF_compress4X_usingCTable #define HUF_compress4X_wksp zfs_HUF_compress4X_wksp #define HUF_compressBound zfs_HUF_compressBound -#define HUF_compressWeights zfs_HUF_compressWeights -#define HUF_decompress zfs_HUF_decompress -#define HUF_decompress1X1 zfs_HUF_decompress1X1 -#define HUF_decompress1X1_DCtx zfs_HUF_decompress1X1_DCtx -#define HUF_decompress1X1_DCtx_wksp zfs_HUF_decompress1X1_DCtx_wksp -#define HUF_decompress1X1_DCtx_wksp_bmi2 zfs_HUF_decompress1X1_DCtx_wksp_bmi2 -#define HUF_decompress1X1_usingDTable zfs_HUF_decompress1X1_usingDTable -#define HUF_decompress1X2 zfs_HUF_decompress1X2 -#define HUF_decompress1X2_DCtx zfs_HUF_decompress1X2_DCtx -#define HUF_decompress1X2_DCtx_wksp zfs_HUF_decompress1X2_DCtx_wksp -#define HUF_decompress1X2_usingDTable zfs_HUF_decompress1X2_usingDTable -#define HUF_decompress1X_DCtx zfs_HUF_decompress1X_DCtx -#define HUF_decompress1X_DCtx_wksp zfs_HUF_decompress1X_DCtx_wksp -#define HUF_decompress1X_usingDTable zfs_HUF_decompress1X_usingDTable -#define HUF_decompress1X_usingDTable_bmi2 zfs_HUF_decompress1X_usingDTable_bmi2 -#define HUF_decompress4X1 zfs_HUF_decompress4X1 -#define HUF_decompress4X1_DCtx zfs_HUF_decompress4X1_DCtx -#define HUF_decompress4X1_DCtx_wksp zfs_HUF_decompress4X1_DCtx_wksp -#define HUF_decompress4X1_usingDTable zfs_HUF_decompress4X1_usingDTable -#define HUF_decompress4X2 zfs_HUF_decompress4X2 -#define HUF_decompress4X2_DCtx zfs_HUF_decompress4X2_DCtx -#define HUF_decompress4X2_DCtx_wksp zfs_HUF_decompress4X2_DCtx_wksp -#define HUF_decompress4X2_usingDTable zfs_HUF_decompress4X2_usingDTable -#define HUF_decompress4X_DCtx zfs_HUF_decompress4X_DCtx -#define HUF_decompress4X_hufOnly zfs_HUF_decompress4X_hufOnly -#define HUF_decompress4X_hufOnly_wksp zfs_HUF_decompress4X_hufOnly_wksp -#define HUF_decompress4X_hufOnly_wksp_bmi2 \ - zfs_HUF_decompress4X_hufOnly_wksp_bmi2 -#define HUF_decompress4X_usingDTable zfs_HUF_decompress4X_usingDTable -#define HUF_decompress4X_usingDTable_bmi2 zfs_HUF_decompress4X_usingDTable_bmi2 +#define HUF_compress zfs_HUF_compress #define HUF_estimateCompressedSize zfs_HUF_estimateCompressedSize -#define HUF_fillDTableX2Level2 zfs_HUF_fillDTableX2Level2 -#define HUF_getErrorName zfs_HUF_getErrorName #define HUF_getNbBits zfs_HUF_getNbBits #define HUF_optimalTableLog zfs_HUF_optimalTableLog #define HUF_readCTable zfs_HUF_readCTable -#define HUF_readDTableX1 zfs_HUF_readDTableX1 -#define HUF_readDTableX1_wksp zfs_HUF_readDTableX1_wksp -#define HUF_readDTableX2 zfs_HUF_readDTableX2 -#define HUF_readDTableX2_wksp zfs_HUF_readDTableX2_wksp -#define HUF_readStats zfs_HUF_readStats -#define HUF_selectDecoder zfs_HUF_selectDecoder -#define HUF_setMaxHeight zfs_HUF_setMaxHeight #define HUF_validateCTable zfs_HUF_validateCTable #define HUF_writeCTable zfs_HUF_writeCTable -#define LL_base zfs_LL_base -#define LL_bits zfs_LL_bits -#define LL_defaultDTable zfs_LL_defaultDTable -#define LL_defaultNorm zfs_LL_defaultNorm -#define ML_base zfs_ML_base -#define ML_bits zfs_ML_bits -#define ML_defaultDTable zfs_ML_defaultDTable -#define ML_defaultNorm zfs_ML_defaultNorm -#define OF_base zfs_OF_base -#define OF_bits zfs_OF_bits -#define OF_defaultDTable zfs_OF_defaultDTable -#define OF_defaultNorm zfs_OF_defaultNorm -#define POOL_add zfs_POOL_add -#define POOL_create zfs_POOL_create -#define POOL_create_advanced zfs_POOL_create_advanced -#define POOL_free zfs_POOL_free -#define POOL_resize zfs_POOL_resize -#define POOL_sizeof zfs_POOL_sizeof -#define POOL_tryAdd zfs_POOL_tryAdd + +/* lib/compress/zstd_compress_literals.o: */ +#define ZSTD_compressLiterals zfs_ZSTD_compressLiterals +#define ZSTD_compressRleLiteralsBlock zfs_ZSTD_compressRleLiteralsBlock +#define ZSTD_noCompressLiterals zfs_ZSTD_noCompressLiterals + +/* lib/compress/zstd_compress_sequences.o: */ +#define ZSTD_buildCTable zfs_ZSTD_buildCTable +#define ZSTD_crossEntropyCost zfs_ZSTD_crossEntropyCost +#define ZSTD_encodeSequences zfs_ZSTD_encodeSequences +#define ZSTD_fseBitCost zfs_ZSTD_fseBitCost +#define ZSTD_selectEncodingType zfs_ZSTD_selectEncodingType + +/* lib/compress/zstd_compress_superblock.o: */ +#define ZSTD_compressSuperBlock zfs_ZSTD_compressSuperBlock + +/* lib/compress/zstd_compress.o: */ +#define ZSTD_adjustCParams zfs_ZSTD_adjustCParams +#define ZSTD_CCtx_getParameter zfs_ZSTD_CCtx_getParameter +#define ZSTD_CCtx_loadDictionary_advanced zfs_ZSTD_CCtx_loadDictionary_advanced +#define ZSTD_CCtx_loadDictionary_byReference zfs_ZSTD_CCtx_loadDictionary_byReference +#define ZSTD_CCtx_loadDictionary zfs_ZSTD_CCtx_loadDictionary #define ZSTD_CCtxParams_getParameter zfs_ZSTD_CCtxParams_getParameter -#define ZSTD_CCtxParams_init zfs_ZSTD_CCtxParams_init #define ZSTD_CCtxParams_init_advanced zfs_ZSTD_CCtxParams_init_advanced +#define ZSTD_CCtxParams_init zfs_ZSTD_CCtxParams_init #define ZSTD_CCtxParams_reset zfs_ZSTD_CCtxParams_reset #define ZSTD_CCtxParams_setParameter zfs_ZSTD_CCtxParams_setParameter -#define ZSTD_CCtx_getParameter zfs_ZSTD_CCtx_getParameter -#define ZSTD_CCtx_loadDictionary zfs_ZSTD_CCtx_loadDictionary -#define ZSTD_CCtx_loadDictionary_advanced zfs_ZSTD_CCtx_loadDictionary_advanced -#define ZSTD_CCtx_loadDictionary_byReference \ - zfs_ZSTD_CCtx_loadDictionary_byReference #define ZSTD_CCtx_refCDict zfs_ZSTD_CCtx_refCDict -#define ZSTD_CCtx_refPrefix zfs_ZSTD_CCtx_refPrefix #define ZSTD_CCtx_refPrefix_advanced zfs_ZSTD_CCtx_refPrefix_advanced +#define ZSTD_CCtx_refPrefix zfs_ZSTD_CCtx_refPrefix #define ZSTD_CCtx_reset zfs_ZSTD_CCtx_reset +#define ZSTD_CCtx_setParametersUsingCCtxParams zfs_ZSTD_CCtx_setParametersUsingCCtxParams #define ZSTD_CCtx_setParameter zfs_ZSTD_CCtx_setParameter -#define ZSTD_CCtx_setParametersUsingCCtxParams \ - zfs_ZSTD_CCtx_setParametersUsingCCtxParams #define ZSTD_CCtx_setPledgedSrcSize zfs_ZSTD_CCtx_setPledgedSrcSize -#define ZSTD_CStreamInSize zfs_ZSTD_CStreamInSize -#define ZSTD_CStreamOutSize zfs_ZSTD_CStreamOutSize -#define ZSTD_DCtx_loadDictionary zfs_ZSTD_DCtx_loadDictionary -#define ZSTD_DCtx_loadDictionary_advanced zfs_ZSTD_DCtx_loadDictionary_advanced -#define ZSTD_DCtx_loadDictionary_byReference \ - zfs_ZSTD_DCtx_loadDictionary_byReference -#define ZSTD_DCtx_refDDict zfs_ZSTD_DCtx_refDDict -#define ZSTD_DCtx_refPrefix zfs_ZSTD_DCtx_refPrefix -#define ZSTD_DCtx_refPrefix_advanced zfs_ZSTD_DCtx_refPrefix_advanced -#define ZSTD_DCtx_reset zfs_ZSTD_DCtx_reset -#define ZSTD_DCtx_setFormat zfs_ZSTD_DCtx_setFormat -#define ZSTD_DCtx_setMaxWindowSize zfs_ZSTD_DCtx_setMaxWindowSize -#define ZSTD_DCtx_setParameter zfs_ZSTD_DCtx_setParameter -#define ZSTD_DDict_dictContent zfs_ZSTD_DDict_dictContent -#define ZSTD_DDict_dictSize zfs_ZSTD_DDict_dictSize -#define ZSTD_DStreamInSize zfs_ZSTD_DStreamInSize -#define ZSTD_DStreamOutSize zfs_ZSTD_DStreamOutSize -#define ZSTD_DUBT_findBestMatch zfs_ZSTD_DUBT_findBestMatch -#define ZSTD_NCountCost zfs_ZSTD_NCountCost -#define ZSTD_XXH64_digest zfs_ZSTD_XXH64_digest -#define ZSTD_adjustCParams zfs_ZSTD_adjustCParams -#define ZSTD_assignParamsToCCtxParams zfs_ZSTD_assignParamsToCCtxParams -#define ZSTD_buildCTable zfs_ZSTD_buildCTable -#define ZSTD_buildFSETable zfs_ZSTD_buildFSETable -#define ZSTD_buildSeqStore zfs_ZSTD_buildSeqStore -#define ZSTD_buildSeqTable zfs_ZSTD_buildSeqTable -#define ZSTD_cParam_getBounds zfs_ZSTD_cParam_getBounds -#define ZSTD_cParam_withinBounds zfs_ZSTD_cParam_withinBounds -#define ZSTD_calloc zfs_ZSTD_calloc #define ZSTD_checkCParams zfs_ZSTD_checkCParams -#define ZSTD_checkContinuity zfs_ZSTD_checkContinuity -#define ZSTD_compress zfs_ZSTD_compress #define ZSTD_compress2 zfs_ZSTD_compress2 -#define ZSTD_compressBegin zfs_ZSTD_compressBegin +#define ZSTD_compress_advanced_internal zfs_ZSTD_compress_advanced_internal +#define ZSTD_compress_advanced zfs_ZSTD_compress_advanced +#define ZSTD_compressBegin_advanced_internal zfs_ZSTD_compressBegin_advanced_internal #define ZSTD_compressBegin_advanced zfs_ZSTD_compressBegin_advanced -#define ZSTD_compressBegin_advanced_internal \ - zfs_ZSTD_compressBegin_advanced_internal +#define ZSTD_compressBegin_usingCDict_advanced zfs_ZSTD_compressBegin_usingCDict_advanced #define ZSTD_compressBegin_usingCDict zfs_ZSTD_compressBegin_usingCDict -#define ZSTD_compressBegin_usingCDict_advanced \ - zfs_ZSTD_compressBegin_usingCDict_advanced #define ZSTD_compressBegin_usingDict zfs_ZSTD_compressBegin_usingDict +#define ZSTD_compressBegin zfs_ZSTD_compressBegin #define ZSTD_compressBlock zfs_ZSTD_compressBlock -#define ZSTD_compressBlock_btlazy2 zfs_ZSTD_compressBlock_btlazy2 -#define ZSTD_compressBlock_btlazy2_dictMatchState \ - zfs_ZSTD_compressBlock_btlazy2_dictMatchState -#define ZSTD_compressBlock_btlazy2_extDict \ - zfs_ZSTD_compressBlock_btlazy2_extDict -#define ZSTD_compressBlock_btopt zfs_ZSTD_compressBlock_btopt -#define ZSTD_compressBlock_btopt_dictMatchState \ - zfs_ZSTD_compressBlock_btopt_dictMatchState -#define ZSTD_compressBlock_btopt_extDict zfs_ZSTD_compressBlock_btopt_extDict -#define ZSTD_compressBlock_btultra zfs_ZSTD_compressBlock_btultra -#define ZSTD_compressBlock_btultra2 zfs_ZSTD_compressBlock_btultra2 -#define ZSTD_compressBlock_btultra_dictMatchState \ - zfs_ZSTD_compressBlock_btultra_dictMatchState -#define ZSTD_compressBlock_btultra_extDict \ - zfs_ZSTD_compressBlock_btultra_extDict -#define ZSTD_compressBlock_doubleFast zfs_ZSTD_compressBlock_doubleFast -#define ZSTD_compressBlock_doubleFast_dictMatchState \ - zfs_ZSTD_compressBlock_doubleFast_dictMatchState -#define ZSTD_compressBlock_doubleFast_extDict \ - zfs_ZSTD_compressBlock_doubleFast_extDict -#define ZSTD_compressBlock_doubleFast_extDict_generic \ - zfs_ZSTD_compressBlock_doubleFast_extDict_generic -#define ZSTD_compressBlock_fast zfs_ZSTD_compressBlock_fast -#define ZSTD_compressBlock_fast_dictMatchState \ - zfs_ZSTD_compressBlock_fast_dictMatchState -#define ZSTD_compressBlock_fast_extDict zfs_ZSTD_compressBlock_fast_extDict -#define ZSTD_compressBlock_fast_extDict_generic \ - zfs_ZSTD_compressBlock_fast_extDict_generic -#define ZSTD_compressBlock_greedy zfs_ZSTD_compressBlock_greedy -#define ZSTD_compressBlock_greedy_dictMatchState \ - zfs_ZSTD_compressBlock_greedy_dictMatchState -#define ZSTD_compressBlock_greedy_extDict zfs_ZSTD_compressBlock_greedy_extDict -#define ZSTD_compressBlock_internal zfs_ZSTD_compressBlock_internal -#define ZSTD_compressBlock_lazy zfs_ZSTD_compressBlock_lazy -#define ZSTD_compressBlock_lazy2 zfs_ZSTD_compressBlock_lazy2 -#define ZSTD_compressBlock_lazy2_dictMatchState \ - zfs_ZSTD_compressBlock_lazy2_dictMatchState -#define ZSTD_compressBlock_lazy2_extDict zfs_ZSTD_compressBlock_lazy2_extDict -#define ZSTD_compressBlock_lazy_dictMatchState \ - zfs_ZSTD_compressBlock_lazy_dictMatchState -#define ZSTD_compressBlock_lazy_extDict zfs_ZSTD_compressBlock_lazy_extDict #define ZSTD_compressBound zfs_ZSTD_compressBound #define ZSTD_compressCCtx zfs_ZSTD_compressCCtx #define ZSTD_compressContinue zfs_ZSTD_compressContinue -#define ZSTD_compressContinue_internal zfs_ZSTD_compressContinue_internal #define ZSTD_compressEnd zfs_ZSTD_compressEnd -#define ZSTD_compressLiterals zfs_ZSTD_compressLiterals -#define ZSTD_compressRleLiteralsBlock zfs_ZSTD_compressRleLiteralsBlock -#define ZSTD_compressStream zfs_ZSTD_compressStream -#define ZSTD_compressStream2 zfs_ZSTD_compressStream2 #define ZSTD_compressStream2_simpleArgs zfs_ZSTD_compressStream2_simpleArgs -#define ZSTD_compressSuperBlock zfs_ZSTD_compressSuperBlock -#define ZSTD_compress_advanced zfs_ZSTD_compress_advanced -#define ZSTD_compress_advanced_internal zfs_ZSTD_compress_advanced_internal -#define ZSTD_compress_internal zfs_ZSTD_compress_internal -#define ZSTD_compress_usingCDict zfs_ZSTD_compress_usingCDict +#define ZSTD_compressStream2 zfs_ZSTD_compressStream2 +#define ZSTD_compressStream zfs_ZSTD_compressStream #define ZSTD_compress_usingCDict_advanced zfs_ZSTD_compress_usingCDict_advanced +#define ZSTD_compress_usingCDict zfs_ZSTD_compress_usingCDict #define ZSTD_compress_usingDict zfs_ZSTD_compress_usingDict +#define ZSTD_compress zfs_ZSTD_compress #define ZSTD_copyCCtx zfs_ZSTD_copyCCtx -#define ZSTD_copyDCtx zfs_ZSTD_copyDCtx -#define ZSTD_copyDDictParameters zfs_ZSTD_copyDDictParameters -#define ZSTD_count zfs_ZSTD_count -#define ZSTD_count_2segments zfs_ZSTD_count_2segments -#define ZSTD_createCCtx zfs_ZSTD_createCCtx -#define ZSTD_createCCtxParams zfs_ZSTD_createCCtxParams +#define ZSTD_cParam_getBounds zfs_ZSTD_cParam_getBounds #define ZSTD_createCCtx_advanced zfs_ZSTD_createCCtx_advanced -#define ZSTD_createCDict zfs_ZSTD_createCDict +#define ZSTD_createCCtxParams zfs_ZSTD_createCCtxParams +#define ZSTD_createCCtx zfs_ZSTD_createCCtx #define ZSTD_createCDict_advanced zfs_ZSTD_createCDict_advanced #define ZSTD_createCDict_byReference zfs_ZSTD_createCDict_byReference -#define ZSTD_createCStream zfs_ZSTD_createCStream +#define ZSTD_createCDict zfs_ZSTD_createCDict #define ZSTD_createCStream_advanced zfs_ZSTD_createCStream_advanced -#define ZSTD_createDCtx zfs_ZSTD_createDCtx -#define ZSTD_createDCtx_advanced zfs_ZSTD_createDCtx_advanced -#define ZSTD_createDDict zfs_ZSTD_createDDict -#define ZSTD_createDDict_advanced zfs_ZSTD_createDDict_advanced -#define ZSTD_createDDict_byReference zfs_ZSTD_createDDict_byReference -#define ZSTD_createDStream zfs_ZSTD_createDStream -#define ZSTD_createDStream_advanced zfs_ZSTD_createDStream_advanced -#define ZSTD_crossEntropyCost zfs_ZSTD_crossEntropyCost +#define ZSTD_createCStream zfs_ZSTD_createCStream +#define ZSTD_CStreamInSize zfs_ZSTD_CStreamInSize +#define ZSTD_CStreamOutSize zfs_ZSTD_CStreamOutSize #define ZSTD_cycleLog zfs_ZSTD_cycleLog -#define ZSTD_dParam_getBounds zfs_ZSTD_dParam_getBounds -#define ZSTD_decodeLiteralsBlock zfs_ZSTD_decodeLiteralsBlock -#define ZSTD_decodeSeqHeaders zfs_ZSTD_decodeSeqHeaders -#define ZSTD_decodingBufferSize_min zfs_ZSTD_decodingBufferSize_min -#define ZSTD_decompress zfs_ZSTD_decompress -#define ZSTD_decompressBegin zfs_ZSTD_decompressBegin -#define ZSTD_decompressBegin_usingDDict zfs_ZSTD_decompressBegin_usingDDict -#define ZSTD_decompressBegin_usingDict zfs_ZSTD_decompressBegin_usingDict -#define ZSTD_decompressBlock zfs_ZSTD_decompressBlock -#define ZSTD_decompressBlock_internal zfs_ZSTD_decompressBlock_internal -#define ZSTD_decompressBound zfs_ZSTD_decompressBound -#define ZSTD_decompressContinue zfs_ZSTD_decompressContinue -#define ZSTD_decompressContinueStream zfs_ZSTD_decompressContinueStream -#define ZSTD_decompressDCtx zfs_ZSTD_decompressDCtx -#define ZSTD_decompressMultiFrame zfs_ZSTD_decompressMultiFrame -#define ZSTD_decompressStream zfs_ZSTD_decompressStream -#define ZSTD_decompressStream_simpleArgs zfs_ZSTD_decompressStream_simpleArgs -#define ZSTD_decompress_usingDDict zfs_ZSTD_decompress_usingDDict -#define ZSTD_decompress_usingDict zfs_ZSTD_decompress_usingDict -#define ZSTD_defaultCParameters zfs_ZSTD_defaultCParameters -#define ZSTD_did_fieldSize zfs_ZSTD_did_fieldSize -#define ZSTD_encodeSequences zfs_ZSTD_encodeSequences -#define ZSTD_encodeSequences_default zfs_ZSTD_encodeSequences_default #define ZSTD_endStream zfs_ZSTD_endStream +#define ZSTD_estimateCCtxSize_usingCCtxParams zfs_ZSTD_estimateCCtxSize_usingCCtxParams +#define ZSTD_estimateCCtxSize_usingCParams zfs_ZSTD_estimateCCtxSize_usingCParams #define ZSTD_estimateCCtxSize zfs_ZSTD_estimateCCtxSize -#define ZSTD_estimateCCtxSize_usingCCtxParams \ - zfs_ZSTD_estimateCCtxSize_usingCCtxParams -#define ZSTD_estimateCCtxSize_usingCParams \ - zfs_ZSTD_estimateCCtxSize_usingCParams -#define ZSTD_estimateCDictSize zfs_ZSTD_estimateCDictSize #define ZSTD_estimateCDictSize_advanced zfs_ZSTD_estimateCDictSize_advanced +#define ZSTD_estimateCDictSize zfs_ZSTD_estimateCDictSize +#define ZSTD_estimateCStreamSize_usingCCtxParams zfs_ZSTD_estimateCStreamSize_usingCCtxParams +#define ZSTD_estimateCStreamSize_usingCParams zfs_ZSTD_estimateCStreamSize_usingCParams #define ZSTD_estimateCStreamSize zfs_ZSTD_estimateCStreamSize -#define ZSTD_estimateCStreamSize_usingCCtxParams \ - zfs_ZSTD_estimateCStreamSize_usingCCtxParams -#define ZSTD_estimateCStreamSize_usingCParams \ - zfs_ZSTD_estimateCStreamSize_usingCParams -#define ZSTD_estimateDCtxSize zfs_ZSTD_estimateDCtxSize -#define ZSTD_estimateDDictSize zfs_ZSTD_estimateDDictSize -#define ZSTD_estimateDStreamSize zfs_ZSTD_estimateDStreamSize -#define ZSTD_estimateDStreamSize_fromFrame \ - zfs_ZSTD_estimateDStreamSize_fromFrame -#define ZSTD_fcs_fieldSize zfs_ZSTD_fcs_fieldSize -#define ZSTD_fillDoubleHashTable zfs_ZSTD_fillDoubleHashTable -#define ZSTD_fillHashTable zfs_ZSTD_fillHashTable -#define ZSTD_findDecompressedSize zfs_ZSTD_findDecompressedSize -#define ZSTD_findFrameCompressedSize zfs_ZSTD_findFrameCompressedSize -#define ZSTD_findFrameSizeInfo zfs_ZSTD_findFrameSizeInfo #define ZSTD_flushStream zfs_ZSTD_flushStream -#define ZSTD_frameHeaderSize zfs_ZSTD_frameHeaderSize -#define ZSTD_free zfs_ZSTD_free -#define ZSTD_freeCCtx zfs_ZSTD_freeCCtx #define ZSTD_freeCCtxParams zfs_ZSTD_freeCCtxParams +#define ZSTD_freeCCtx zfs_ZSTD_freeCCtx #define ZSTD_freeCDict zfs_ZSTD_freeCDict #define ZSTD_freeCStream zfs_ZSTD_freeCStream -#define ZSTD_freeDCtx zfs_ZSTD_freeDCtx -#define ZSTD_freeDDict zfs_ZSTD_freeDDict -#define ZSTD_freeDStream zfs_ZSTD_freeDStream -#define ZSTD_fseBitCost zfs_ZSTD_fseBitCost #define ZSTD_getBlockSize zfs_ZSTD_getBlockSize -#define ZSTD_getCParams zfs_ZSTD_getCParams #define ZSTD_getCParamsFromCCtxParams zfs_ZSTD_getCParamsFromCCtxParams #define ZSTD_getCParamsFromCDict zfs_ZSTD_getCParamsFromCDict -#define ZSTD_getCParams_internal zfs_ZSTD_getCParams_internal -#define ZSTD_getDDict zfs_ZSTD_getDDict -#define ZSTD_getDecompressedSize zfs_ZSTD_getDecompressedSize -#define ZSTD_getDictID_fromDDict zfs_ZSTD_getDictID_fromDDict -#define ZSTD_getDictID_fromDict zfs_ZSTD_getDictID_fromDict -#define ZSTD_getDictID_fromFrame zfs_ZSTD_getDictID_fromFrame -#define ZSTD_getErrorCode zfs_ZSTD_getErrorCode -#define ZSTD_getErrorName zfs_ZSTD_getErrorName -#define ZSTD_getErrorString zfs_ZSTD_getErrorString -#define ZSTD_getFrameContentSize zfs_ZSTD_getFrameContentSize -#define ZSTD_getFrameHeader zfs_ZSTD_getFrameHeader -#define ZSTD_getFrameHeader_advanced zfs_ZSTD_getFrameHeader_advanced +#define ZSTD_getCParams zfs_ZSTD_getCParams #define ZSTD_getFrameProgression zfs_ZSTD_getFrameProgression #define ZSTD_getParams zfs_ZSTD_getParams #define ZSTD_getSeqStore zfs_ZSTD_getSeqStore #define ZSTD_getSequences zfs_ZSTD_getSequences -#define ZSTD_getcBlockSize zfs_ZSTD_getcBlockSize -#define ZSTD_hashPtr zfs_ZSTD_hashPtr -#define ZSTD_initCDict_internal zfs_ZSTD_initCDict_internal -#define ZSTD_initCStream zfs_ZSTD_initCStream #define ZSTD_initCStream_advanced zfs_ZSTD_initCStream_advanced #define ZSTD_initCStream_internal zfs_ZSTD_initCStream_internal #define ZSTD_initCStream_srcSize zfs_ZSTD_initCStream_srcSize +#define ZSTD_initCStream_usingCDict_advanced zfs_ZSTD_initCStream_usingCDict_advanced #define ZSTD_initCStream_usingCDict zfs_ZSTD_initCStream_usingCDict -#define ZSTD_initCStream_usingCDict_advanced \ - zfs_ZSTD_initCStream_usingCDict_advanced #define ZSTD_initCStream_usingDict zfs_ZSTD_initCStream_usingDict -#define ZSTD_initDDict_internal zfs_ZSTD_initDDict_internal -#define ZSTD_initDStream zfs_ZSTD_initDStream -#define ZSTD_initDStream_usingDDict zfs_ZSTD_initDStream_usingDDict -#define ZSTD_initDStream_usingDict zfs_ZSTD_initDStream_usingDict -#define ZSTD_initFseState zfs_ZSTD_initFseState +#define ZSTD_initCStream zfs_ZSTD_initCStream #define ZSTD_initStaticCCtx zfs_ZSTD_initStaticCCtx #define ZSTD_initStaticCDict zfs_ZSTD_initStaticCDict #define ZSTD_initStaticCStream zfs_ZSTD_initStaticCStream -#define ZSTD_initStaticDCtx zfs_ZSTD_initStaticDCtx -#define ZSTD_initStaticDDict zfs_ZSTD_initStaticDDict -#define ZSTD_initStaticDStream zfs_ZSTD_initStaticDStream -#define ZSTD_initStats_ultra zfs_ZSTD_initStats_ultra -#define ZSTD_insertAndFindFirstIndex zfs_ZSTD_insertAndFindFirstIndex -#define ZSTD_insertAndFindFirstIndexHash3 zfs_ZSTD_insertAndFindFirstIndexHash3 -#define ZSTD_insertAndFindFirstIndex_internal \ - zfs_ZSTD_insertAndFindFirstIndex_internal -#define ZSTD_insertBlock zfs_ZSTD_insertBlock #define ZSTD_invalidateRepCodes zfs_ZSTD_invalidateRepCodes -#define ZSTD_isError zfs_ZSTD_isError -#define ZSTD_isFrame zfs_ZSTD_isFrame +#define ZSTD_loadCEntropy zfs_ZSTD_loadCEntropy +#define ZSTD_maxCLevel zfs_ZSTD_maxCLevel +#define ZSTD_minCLevel zfs_ZSTD_minCLevel +#define ZSTD_referenceExternalSequences zfs_ZSTD_referenceExternalSequences +#define ZSTD_reset_compressedBlockState zfs_ZSTD_reset_compressedBlockState +#define ZSTD_resetCStream zfs_ZSTD_resetCStream +#define ZSTD_resetSeqStore zfs_ZSTD_resetSeqStore +#define ZSTD_selectBlockCompressor zfs_ZSTD_selectBlockCompressor +#define ZSTD_seqToCodes zfs_ZSTD_seqToCodes +#define ZSTD_sizeof_CCtx zfs_ZSTD_sizeof_CCtx +#define ZSTD_sizeof_CDict zfs_ZSTD_sizeof_CDict +#define ZSTD_sizeof_CStream zfs_ZSTD_sizeof_CStream +#define ZSTD_toFlushNow zfs_ZSTD_toFlushNow +#define ZSTD_writeLastEmptyBlock zfs_ZSTD_writeLastEmptyBlock + +/* lib/compress/zstd_double_fast.o: */ +#define ZSTD_compressBlock_doubleFast_dictMatchState zfs_ZSTD_compressBlock_doubleFast_dictMatchState +#define ZSTD_compressBlock_doubleFast_extDict zfs_ZSTD_compressBlock_doubleFast_extDict +#define ZSTD_compressBlock_doubleFast zfs_ZSTD_compressBlock_doubleFast +#define ZSTD_fillDoubleHashTable zfs_ZSTD_fillDoubleHashTable + +/* lib/compress/zstd_fast.o: */ +#define ZSTD_compressBlock_fast_dictMatchState zfs_ZSTD_compressBlock_fast_dictMatchState +#define ZSTD_compressBlock_fast_extDict zfs_ZSTD_compressBlock_fast_extDict +#define ZSTD_compressBlock_fast zfs_ZSTD_compressBlock_fast +#define ZSTD_fillHashTable zfs_ZSTD_fillHashTable + +/* lib/compress/zstd_lazy.o: */ +#define ZSTD_compressBlock_btlazy2_dictMatchState zfs_ZSTD_compressBlock_btlazy2_dictMatchState +#define ZSTD_compressBlock_btlazy2_extDict zfs_ZSTD_compressBlock_btlazy2_extDict +#define ZSTD_compressBlock_btlazy2 zfs_ZSTD_compressBlock_btlazy2 +#define ZSTD_compressBlock_greedy_dictMatchState zfs_ZSTD_compressBlock_greedy_dictMatchState +#define ZSTD_compressBlock_greedy_extDict zfs_ZSTD_compressBlock_greedy_extDict +#define ZSTD_compressBlock_greedy zfs_ZSTD_compressBlock_greedy +#define ZSTD_compressBlock_lazy2_dictMatchState zfs_ZSTD_compressBlock_lazy2_dictMatchState +#define ZSTD_compressBlock_lazy2_extDict zfs_ZSTD_compressBlock_lazy2_extDict +#define ZSTD_compressBlock_lazy2 zfs_ZSTD_compressBlock_lazy2 +#define ZSTD_compressBlock_lazy_dictMatchState zfs_ZSTD_compressBlock_lazy_dictMatchState +#define ZSTD_compressBlock_lazy_extDict zfs_ZSTD_compressBlock_lazy_extDict +#define ZSTD_compressBlock_lazy zfs_ZSTD_compressBlock_lazy +#define ZSTD_insertAndFindFirstIndex zfs_ZSTD_insertAndFindFirstIndex + +/* lib/compress/zstd_ldm.o: */ #define ZSTD_ldm_adjustParameters zfs_ZSTD_ldm_adjustParameters #define ZSTD_ldm_blockCompress zfs_ZSTD_ldm_blockCompress #define ZSTD_ldm_fillHashTable zfs_ZSTD_ldm_fillHashTable @@ -429,47 +296,129 @@ #define ZSTD_ldm_getMaxNbSeq zfs_ZSTD_ldm_getMaxNbSeq #define ZSTD_ldm_getTableSize zfs_ZSTD_ldm_getTableSize #define ZSTD_ldm_skipSequences zfs_ZSTD_ldm_skipSequences -#define ZSTD_loadCEntropy zfs_ZSTD_loadCEntropy + +/* lib/compress/zstd_opt.o: */ +#define ZSTD_compressBlock_btopt_dictMatchState zfs_ZSTD_compressBlock_btopt_dictMatchState +#define ZSTD_compressBlock_btopt_extDict zfs_ZSTD_compressBlock_btopt_extDict +#define ZSTD_compressBlock_btopt zfs_ZSTD_compressBlock_btopt +#define ZSTD_compressBlock_btultra2 zfs_ZSTD_compressBlock_btultra2 +#define ZSTD_compressBlock_btultra_dictMatchState zfs_ZSTD_compressBlock_btultra_dictMatchState +#define ZSTD_compressBlock_btultra_extDict zfs_ZSTD_compressBlock_btultra_extDict +#define ZSTD_compressBlock_btultra zfs_ZSTD_compressBlock_btultra +#define ZSTD_updateTree zfs_ZSTD_updateTree + +/* lib/decompress/huf_decompress.o: */ +#define HUF_decompress1X1_DCtx_wksp_bmi2 zfs_HUF_decompress1X1_DCtx_wksp_bmi2 +#define HUF_decompress1X1_DCtx_wksp zfs_HUF_decompress1X1_DCtx_wksp +#define HUF_decompress1X1_DCtx zfs_HUF_decompress1X1_DCtx +#define HUF_decompress1X1_usingDTable zfs_HUF_decompress1X1_usingDTable +#define HUF_decompress1X1 zfs_HUF_decompress1X1 +#define HUF_decompress1X2_DCtx_wksp zfs_HUF_decompress1X2_DCtx_wksp +#define HUF_decompress1X2_DCtx zfs_HUF_decompress1X2_DCtx +#define HUF_decompress1X2_usingDTable zfs_HUF_decompress1X2_usingDTable +#define HUF_decompress1X2 zfs_HUF_decompress1X2 +#define HUF_decompress1X_DCtx_wksp zfs_HUF_decompress1X_DCtx_wksp +#define HUF_decompress1X_DCtx zfs_HUF_decompress1X_DCtx +#define HUF_decompress1X_usingDTable_bmi2 zfs_HUF_decompress1X_usingDTable_bmi2 +#define HUF_decompress1X_usingDTable zfs_HUF_decompress1X_usingDTable +#define HUF_decompress4X1_DCtx_wksp zfs_HUF_decompress4X1_DCtx_wksp +#define HUF_decompress4X1_DCtx zfs_HUF_decompress4X1_DCtx +#define HUF_decompress4X1_usingDTable zfs_HUF_decompress4X1_usingDTable +#define HUF_decompress4X1 zfs_HUF_decompress4X1 +#define HUF_decompress4X2_DCtx_wksp zfs_HUF_decompress4X2_DCtx_wksp +#define HUF_decompress4X2_DCtx zfs_HUF_decompress4X2_DCtx +#define HUF_decompress4X2_usingDTable zfs_HUF_decompress4X2_usingDTable +#define HUF_decompress4X2 zfs_HUF_decompress4X2 +#define HUF_decompress4X_DCtx zfs_HUF_decompress4X_DCtx +#define HUF_decompress4X_hufOnly_wksp_bmi2 zfs_HUF_decompress4X_hufOnly_wksp_bmi2 +#define HUF_decompress4X_hufOnly_wksp zfs_HUF_decompress4X_hufOnly_wksp +#define HUF_decompress4X_hufOnly zfs_HUF_decompress4X_hufOnly +#define HUF_decompress4X_usingDTable_bmi2 zfs_HUF_decompress4X_usingDTable_bmi2 +#define HUF_decompress4X_usingDTable zfs_HUF_decompress4X_usingDTable +#define HUF_decompress zfs_HUF_decompress +#define HUF_readDTableX1_wksp zfs_HUF_readDTableX1_wksp +#define HUF_readDTableX1 zfs_HUF_readDTableX1 +#define HUF_readDTableX2_wksp zfs_HUF_readDTableX2_wksp +#define HUF_readDTableX2 zfs_HUF_readDTableX2 +#define HUF_selectDecoder zfs_HUF_selectDecoder + +/* lib/decompress/zstd_ddict.o: */ +#define ZSTD_copyDDictParameters zfs_ZSTD_copyDDictParameters +#define ZSTD_createDDict_advanced zfs_ZSTD_createDDict_advanced +#define ZSTD_createDDict_byReference zfs_ZSTD_createDDict_byReference +#define ZSTD_createDDict zfs_ZSTD_createDDict +#define ZSTD_DDict_dictContent zfs_ZSTD_DDict_dictContent +#define ZSTD_DDict_dictSize zfs_ZSTD_DDict_dictSize +#define ZSTD_estimateDDictSize zfs_ZSTD_estimateDDictSize +#define ZSTD_freeDDict zfs_ZSTD_freeDDict +#define ZSTD_getDictID_fromDDict zfs_ZSTD_getDictID_fromDDict +#define ZSTD_initStaticDDict zfs_ZSTD_initStaticDDict +#define ZSTD_sizeof_DDict zfs_ZSTD_sizeof_DDict + +/* lib/decompress/zstd_decompress.o: */ +#define ZSTD_copyDCtx zfs_ZSTD_copyDCtx +#define ZSTD_createDCtx_advanced zfs_ZSTD_createDCtx_advanced +#define ZSTD_createDCtx zfs_ZSTD_createDCtx +#define ZSTD_createDStream_advanced zfs_ZSTD_createDStream_advanced +#define ZSTD_createDStream zfs_ZSTD_createDStream +#define ZSTD_DCtx_loadDictionary_advanced zfs_ZSTD_DCtx_loadDictionary_advanced +#define ZSTD_DCtx_loadDictionary_byReference zfs_ZSTD_DCtx_loadDictionary_byReference +#define ZSTD_DCtx_loadDictionary zfs_ZSTD_DCtx_loadDictionary +#define ZSTD_DCtx_refDDict zfs_ZSTD_DCtx_refDDict +#define ZSTD_DCtx_refPrefix_advanced zfs_ZSTD_DCtx_refPrefix_advanced +#define ZSTD_DCtx_refPrefix zfs_ZSTD_DCtx_refPrefix +#define ZSTD_DCtx_reset zfs_ZSTD_DCtx_reset +#define ZSTD_DCtx_setFormat zfs_ZSTD_DCtx_setFormat +#define ZSTD_DCtx_setMaxWindowSize zfs_ZSTD_DCtx_setMaxWindowSize +#define ZSTD_DCtx_setParameter zfs_ZSTD_DCtx_setParameter +#define ZSTD_decodingBufferSize_min zfs_ZSTD_decodingBufferSize_min +#define ZSTD_decompressBegin_usingDDict zfs_ZSTD_decompressBegin_usingDDict +#define ZSTD_decompressBegin_usingDict zfs_ZSTD_decompressBegin_usingDict +#define ZSTD_decompressBegin zfs_ZSTD_decompressBegin +#define ZSTD_decompressBound zfs_ZSTD_decompressBound +#define ZSTD_decompressContinue zfs_ZSTD_decompressContinue +#define ZSTD_decompressDCtx zfs_ZSTD_decompressDCtx +#define ZSTD_decompressStream_simpleArgs zfs_ZSTD_decompressStream_simpleArgs +#define ZSTD_decompressStream zfs_ZSTD_decompressStream +#define ZSTD_decompress_usingDDict zfs_ZSTD_decompress_usingDDict +#define ZSTD_decompress_usingDict zfs_ZSTD_decompress_usingDict +#define ZSTD_decompress zfs_ZSTD_decompress +#define ZSTD_dParam_getBounds zfs_ZSTD_dParam_getBounds +#define ZSTD_DStreamInSize zfs_ZSTD_DStreamInSize +#define ZSTD_DStreamOutSize zfs_ZSTD_DStreamOutSize +#define ZSTD_estimateDCtxSize zfs_ZSTD_estimateDCtxSize +#define ZSTD_estimateDStreamSize_fromFrame zfs_ZSTD_estimateDStreamSize_fromFrame +#define ZSTD_estimateDStreamSize zfs_ZSTD_estimateDStreamSize +#define ZSTD_findDecompressedSize zfs_ZSTD_findDecompressedSize +#define ZSTD_findFrameCompressedSize zfs_ZSTD_findFrameCompressedSize +#define ZSTD_frameHeaderSize zfs_ZSTD_frameHeaderSize +#define ZSTD_freeDCtx zfs_ZSTD_freeDCtx +#define ZSTD_freeDStream zfs_ZSTD_freeDStream +#define ZSTD_getDecompressedSize zfs_ZSTD_getDecompressedSize +#define ZSTD_getDictID_fromDict zfs_ZSTD_getDictID_fromDict +#define ZSTD_getDictID_fromFrame zfs_ZSTD_getDictID_fromFrame +#define ZSTD_getFrameContentSize zfs_ZSTD_getFrameContentSize +#define ZSTD_getFrameHeader_advanced zfs_ZSTD_getFrameHeader_advanced +#define ZSTD_getFrameHeader zfs_ZSTD_getFrameHeader +#define ZSTD_initDStream_usingDDict zfs_ZSTD_initDStream_usingDDict +#define ZSTD_initDStream_usingDict zfs_ZSTD_initDStream_usingDict +#define ZSTD_initDStream zfs_ZSTD_initDStream +#define ZSTD_initStaticDCtx zfs_ZSTD_initStaticDCtx +#define ZSTD_initStaticDStream zfs_ZSTD_initStaticDStream +#define ZSTD_insertBlock zfs_ZSTD_insertBlock +#define ZSTD_isFrame zfs_ZSTD_isFrame #define ZSTD_loadDEntropy zfs_ZSTD_loadDEntropy -#define ZSTD_loadDictionaryContent zfs_ZSTD_loadDictionaryContent -#define ZSTD_makeCCtxParamsFromCParams zfs_ZSTD_makeCCtxParamsFromCParams -#define ZSTD_malloc zfs_ZSTD_malloc -#define ZSTD_maxCLevel zfs_ZSTD_maxCLevel -#define ZSTD_minCLevel zfs_ZSTD_minCLevel #define ZSTD_nextInputType zfs_ZSTD_nextInputType #define ZSTD_nextSrcSizeToDecompress zfs_ZSTD_nextSrcSizeToDecompress -#define ZSTD_noCompressLiterals zfs_ZSTD_noCompressLiterals -#define ZSTD_referenceExternalSequences zfs_ZSTD_referenceExternalSequences -#define ZSTD_rescaleFreqs zfs_ZSTD_rescaleFreqs -#define ZSTD_resetCCtx_internal zfs_ZSTD_resetCCtx_internal -#define ZSTD_resetCCtx_usingCDict zfs_ZSTD_resetCCtx_usingCDict -#define ZSTD_resetCStream zfs_ZSTD_resetCStream #define ZSTD_resetDStream zfs_ZSTD_resetDStream -#define ZSTD_resetSeqStore zfs_ZSTD_resetSeqStore -#define ZSTD_reset_compressedBlockState zfs_ZSTD_reset_compressedBlockState -#define ZSTD_safecopy zfs_ZSTD_safecopy -#define ZSTD_selectBlockCompressor zfs_ZSTD_selectBlockCompressor -#define ZSTD_selectEncodingType zfs_ZSTD_selectEncodingType -#define ZSTD_seqToCodes zfs_ZSTD_seqToCodes -#define ZSTD_sizeof_CCtx zfs_ZSTD_sizeof_CCtx -#define ZSTD_sizeof_CDict zfs_ZSTD_sizeof_CDict -#define ZSTD_sizeof_CStream zfs_ZSTD_sizeof_CStream #define ZSTD_sizeof_DCtx zfs_ZSTD_sizeof_DCtx -#define ZSTD_sizeof_DDict zfs_ZSTD_sizeof_DDict #define ZSTD_sizeof_DStream zfs_ZSTD_sizeof_DStream -#define ZSTD_toFlushNow zfs_ZSTD_toFlushNow -#define ZSTD_updateRep zfs_ZSTD_updateRep -#define ZSTD_updateStats zfs_ZSTD_updateStats -#define ZSTD_updateTree zfs_ZSTD_updateTree -#define ZSTD_versionNumber zfs_ZSTD_versionNumber -#define ZSTD_versionString zfs_ZSTD_versionString -#define ZSTD_writeFrameHeader zfs_ZSTD_writeFrameHeader -#define ZSTD_writeLastEmptyBlock zfs_ZSTD_writeLastEmptyBlock -#define algoTime zfs_algoTime -#define attachDictSizeCutoffs zfs_attachDictSizeCutoffs -#define g_ctx zfs_g_ctx -#define g_debuglevel zfs_g_debuglevel -#define kInverseProbabilityLog256 zfs_kInverseProbabilityLog256 -#define repStartValue zfs_repStartValue -#define FSE_isError zfs_FSE_isError -#define HUF_isError zfs_HUF_isError + +/* lib/decompress/zstd_decompress_block.o: */ +#define ZSTD_buildFSETable zfs_ZSTD_buildFSETable +#define ZSTD_checkContinuity zfs_ZSTD_checkContinuity +#define ZSTD_decodeLiteralsBlock zfs_ZSTD_decodeLiteralsBlock +#define ZSTD_decodeSeqHeaders zfs_ZSTD_decodeSeqHeaders +#define ZSTD_decompressBlock_internal zfs_ZSTD_decompressBlock_internal +#define ZSTD_decompressBlock zfs_ZSTD_decompressBlock +#define ZSTD_getcBlockSize zfs_ZSTD_getcBlockSize diff --git a/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in b/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in index 02be716aa96..cd0a3ded2a0 100644 --- a/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in +++ b/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in @@ -68,46 +68,9 @@ fi %defattr(-,root,root) /usr/src/%{module}-%{version} -%post -for POSTINST in /usr/lib/dkms/common.postinst; do - if [ -f $POSTINST ]; then - $POSTINST %{module} %{version} - exit $? - fi - echo "WARNING: $POSTINST does not exist." -done -echo -e "ERROR: DKMS version is too old and %{module} was not" -echo -e "built with legacy DKMS support." -echo -e "You must either rebuild %{module} with legacy postinst" -echo -e "support or upgrade DKMS to a more current version." -exit 1 - %preun -# Are we doing an upgrade? -if [ "$1" = "1" -o "$1" = "upgrade" ] ; then - # Yes we are. Are we upgrading to a new ZFS version? - NEWEST_VER=$(dkms status zfs | tr -d , | sort -r -V | awk '/installed/{print $2; exit}') - if [ "$NEWEST_VER" != "%{version}" ] ; then - # Yes, it's a new ZFS version. We'll uninstall the old module - # later on in this script. - true - else - # No, it's probably an upgrade of the same ZFS version - # to a new distro (zfs-dkms-0.7.12.fc28->zfs-dkms-0.7.12.fc29). - # Don't remove our modules, since the rebuild for the new - # distro will automatically delete the old modules. - exit 0 - fi -fi +dkms remove -m %{module} -v %{version} --all + +%posttrans +/usr/lib/dkms/common.postinst %{module} %{version} -# If we're here then we're doing an uninstall (not upgrade). -CONFIG_H="/var/lib/dkms/%{module}/%{version}/*/*/%{module}_config.h" -SPEC_META_ALIAS="@PACKAGE@-@VERSION@-@RELEASE@" -DKMS_META_ALIAS=`cat $CONFIG_H 2>/dev/null | - awk -F'"' '/META_ALIAS\s+"/ { print $2; exit 0 }'` -if [ "$SPEC_META_ALIAS" = "$DKMS_META_ALIAS" ]; then - echo -e - echo -e "Uninstall of %{module} module ($SPEC_META_ALIAS) beginning:" - dkms remove -m %{module} -v %{version} --all %{!?not_rpm:--rpm_safe_upgrade} -fi -exit 0 diff --git a/sys/contrib/openzfs/rpm/generic/zfs.spec.in b/sys/contrib/openzfs/rpm/generic/zfs.spec.in index bdd77b43da6..4b78a93085a 100644 --- a/sys/contrib/openzfs/rpm/generic/zfs.spec.in +++ b/sys/contrib/openzfs/rpm/generic/zfs.spec.in @@ -118,10 +118,6 @@ BuildRequires: ncompress BuildRequires: libtirpc-devel %endif -%if %{with pam} -BuildRequires: pam-devel -%endif - Requires: openssl %if 0%{?_systemd} BuildRequires: systemd @@ -326,6 +322,19 @@ This package contains a initramfs module used to construct an initramfs image which is ZFS aware. %endif +%if %{with pam} +%package -n pam_zfs_key +Summary: PAM module for encrypted ZFS datasets + +%if 0%{?rhel}%{?centos}%{?fedora}%{?suse_version} +BuildRequires: pam-devel +%endif + +%description -n pam_zfs_key +This package contains the pam_zfs_key PAM module, which provides +support for unlocking datasets on user login. +%endif + %prep %if %{with debug} %define debug --enable-debug @@ -508,10 +517,6 @@ systemctl --system daemon-reload >/dev/null || true %config(noreplace) %{_sysconfdir}/%{name}/zpool.d/* %config(noreplace) %{_sysconfdir}/%{name}/vdev_id.conf.*.example %attr(440, root, root) %config(noreplace) %{_sysconfdir}/sudoers.d/* -%if %{with pam} -%{_libdir}/security/* -%{_datadir}/pam-configs/* -%endif %files -n libzpool5 %{_libdir}/libzpool.so.* @@ -561,3 +566,9 @@ systemctl --system daemon-reload >/dev/null || true # ignore those files. %exclude /usr/share/initramfs-tools %endif + +%if %{with pam} +%files -n pam_zfs_key +%{_libdir}/security/* +%{_datadir}/pam-configs/* +%endif diff --git a/sys/contrib/openzfs/scripts/zfs-tests.sh b/sys/contrib/openzfs/scripts/zfs-tests.sh index 2477d0f9179..851ff8b74e5 100755 --- a/sys/contrib/openzfs/scripts/zfs-tests.sh +++ b/sys/contrib/openzfs/scripts/zfs-tests.sh @@ -39,6 +39,7 @@ VERBOSE="no" QUIET="" CLEANUP="yes" CLEANUPALL="no" +KMSG="" LOOPBACK="yes" STACK_TRACER="no" FILESIZE="4G" @@ -326,6 +327,7 @@ OPTIONS: -q Quiet test-runner output -x Remove all testpools, dm, lo, and files (unsafe) -k Disable cleanup after test failure + -K Log test names to /dev/kmsg -f Use files only, disables block device tests -S Enable stack tracer (negative performance impact) -c Only create and populate constrained path @@ -357,7 +359,7 @@ $0 -x EOF } -while getopts 'hvqxkfScRmn:d:s:r:?t:T:u:I:' OPTION; do +while getopts 'hvqxkKfScRmn:d:s:r:?t:T:u:I:' OPTION; do case $OPTION in h) usage @@ -375,6 +377,9 @@ while getopts 'hvqxkfScRmn:d:s:r:?t:T:u:I:' OPTION; do k) CLEANUP="no" ;; + K) + KMSG="yes" + ;; f) LOOPBACK="no" ;; @@ -705,6 +710,7 @@ REPORT_FILE=$(mktemp_file zts-report) msg "${TEST_RUNNER}" \ "${QUIET:+-q}" \ "${KMEMLEAK:+-m}" \ + "${KMSG:+-K}" \ "-c \"${RUNFILES}\"" \ "-T \"${TAGS}\"" \ "-i \"${STF_SUITE}\"" \ @@ -712,6 +718,7 @@ msg "${TEST_RUNNER}" \ { ${TEST_RUNNER} \ ${QUIET:+-q} \ ${KMEMLEAK:+-m} \ + ${KMSG:+-K} \ -c "${RUNFILES}" \ -T "${TAGS}" \ -i "${STF_SUITE}" \ diff --git a/sys/contrib/openzfs/tests/runfiles/common.run b/sys/contrib/openzfs/tests/runfiles/common.run index fdc2172b6a6..87b669db7dc 100644 --- a/sys/contrib/openzfs/tests/runfiles/common.run +++ b/sys/contrib/openzfs/tests/runfiles/common.run @@ -315,7 +315,7 @@ tests = ['zfs_upgrade_001_pos', 'zfs_upgrade_002_pos', 'zfs_upgrade_003_pos', tags = ['functional', 'cli_root', 'zfs_upgrade'] [tests/functional/cli_root/zfs_wait] -tests = ['zfs_wait_deleteq'] +tests = ['zfs_wait_deleteq', 'zfs_wait_getsubopt'] tags = ['functional', 'cli_root', 'zfs_wait'] [tests/functional/cli_root/zhack] @@ -551,7 +551,8 @@ tags = ['functional', 'cli_user', 'misc'] [tests/functional/cli_user/zfs_list] tests = ['zfs_list_001_pos', 'zfs_list_002_pos', 'zfs_list_003_pos', - 'zfs_list_004_neg', 'zfs_list_007_pos', 'zfs_list_008_neg'] + 'zfs_list_004_neg', 'zfs_list_005_neg', 'zfs_list_007_pos', + 'zfs_list_008_neg'] user = tags = ['functional', 'cli_user', 'zfs_list'] @@ -823,7 +824,8 @@ tests = ['recv_dedup', 'recv_dedup_encrypted_zvol', 'rsend_001_pos', 'rsend_006_pos', 'rsend_007_pos', 'rsend_008_pos', 'rsend_009_pos', 'rsend_010_pos', 'rsend_011_pos', 'rsend_012_pos', 'rsend_013_pos', 'rsend_014_pos', 'rsend_016_neg', 'rsend_019_pos', 'rsend_020_pos', - 'rsend_021_pos', 'rsend_022_pos', 'rsend_024_pos', + 'rsend_021_pos', 'rsend_022_pos', 'rsend_024_pos', 'rsend_025_pos', + 'rsend_026_neg', 'rsend_027_pos', 'rsend_028_neg', 'rsend_029_neg', 'send-c_verify_ratio', 'send-c_verify_contents', 'send-c_props', 'send-c_incremental', 'send-c_volume', 'send-c_zstreamdump', 'send-c_lz4_disabled', 'send-c_recv_lz4_disabled', diff --git a/sys/contrib/openzfs/tests/runfiles/sanity.run b/sys/contrib/openzfs/tests/runfiles/sanity.run index 383308bb59f..9faf0e4d991 100644 --- a/sys/contrib/openzfs/tests/runfiles/sanity.run +++ b/sys/contrib/openzfs/tests/runfiles/sanity.run @@ -236,7 +236,7 @@ tests = ['zfs_upgrade_001_pos', 'zfs_upgrade_002_pos', 'zfs_upgrade_006_neg', tags = ['functional', 'cli_root', 'zfs_upgrade'] [tests/functional/cli_root/zfs_wait] -tests = ['zfs_wait_deleteq'] +tests = ['zfs_wait_deleteq', 'zfs_wait_getsubopt'] tags = ['functional', 'cli_root', 'zfs_wait'] [tests/functional/cli_root/zpool] diff --git a/sys/contrib/openzfs/tests/test-runner/bin/test-runner.py.in b/sys/contrib/openzfs/tests/test-runner/bin/test-runner.py.in index c644745b439..5c868d945a8 100755 --- a/sys/contrib/openzfs/tests/test-runner/bin/test-runner.py.in +++ b/sys/contrib/openzfs/tests/test-runner/bin/test-runner.py.in @@ -34,6 +34,7 @@ from subprocess import Popen from subprocess import check_output from threading import Timer from time import time, CLOCK_MONOTONIC +from os.path import exists BASEDIR = '/var/tmp/test_results' TESTDIR = '/usr/share/zfs/' @@ -256,7 +257,7 @@ User: %s return out.lines, err.lines - def run(self, dryrun, kmemleak): + def run(self, dryrun, kmemleak, kmsg): """ This is the main function that runs each individual test. Determine whether or not the command requires sudo, and modify it @@ -275,6 +276,18 @@ User: %s except OSError as e: fail('%s' % e) + """ + Log each test we run to /dev/kmsg (on Linux), so if there's a kernel + warning we'll be able to match it up to a particular test. + """ + if kmsg is True and exists("/dev/kmsg"): + try: + kp = Popen([SUDO, "sh", "-c", + f"echo ZTS run {self.pathname} > /dev/kmsg"]) + kp.wait() + except Exception: + pass + self.result.starttime = monotonic_time() if kmemleak: @@ -459,14 +472,14 @@ Tags: %s cont = True if len(pretest.pathname): - pretest.run(options.dryrun, False) + pretest.run(options.dryrun, False, options.kmsg) cont = pretest.result.result == 'PASS' pretest.log(options) if cont: - test.run(options.dryrun, options.kmemleak) + test.run(options.dryrun, options.kmemleak, options.kmsg) if test.result.result == 'KILLED' and len(failsafe.pathname): - failsafe.run(options.dryrun, False) + failsafe.run(options.dryrun, False, options.kmsg) failsafe.log(options, suppress_console=True) else: test.skip() @@ -474,7 +487,7 @@ Tags: %s test.log(options) if len(posttest.pathname): - posttest.run(options.dryrun, False) + posttest.run(options.dryrun, False, options.kmsg) posttest.log(options) @@ -577,7 +590,7 @@ Tags: %s cont = True if len(pretest.pathname): - pretest.run(options.dryrun, False) + pretest.run(options.dryrun, False, options.kmsg) cont = pretest.result.result == 'PASS' pretest.log(options) @@ -590,9 +603,9 @@ Tags: %s failsafe = Cmd(self.failsafe, outputdir=odir, timeout=self.timeout, user=self.failsafe_user, identifier=self.identifier) if cont: - test.run(options.dryrun, options.kmemleak) + test.run(options.dryrun, options.kmemleak, options.kmsg) if test.result.result == 'KILLED' and len(failsafe.pathname): - failsafe.run(options.dryrun, False) + failsafe.run(options.dryrun, False, options.kmsg) failsafe.log(options, suppress_console=True) else: test.skip() @@ -600,7 +613,7 @@ Tags: %s test.log(options) if len(posttest.pathname): - posttest.run(options.dryrun, False) + posttest.run(options.dryrun, False, options.kmsg) posttest.log(options) @@ -1060,6 +1073,8 @@ def parse_args(): parser.add_option('-i', action='callback', callback=options_cb, default=TESTDIR, dest='testdir', type='string', metavar='testdir', help='Specify a test directory.') + parser.add_option('-K', action='store_true', default=False, dest='kmsg', + help='Log tests names to /dev/kmsg') parser.add_option('-m', action='callback', callback=kmemleak_cb, default=False, dest='kmemleak', help='Enable kmemleak reporting (Linux only)') diff --git a/sys/contrib/openzfs/tests/test-runner/include/logapi.shlib b/sys/contrib/openzfs/tests/test-runner/include/logapi.shlib index c9c01ab752e..33423a7e3c6 100644 --- a/sys/contrib/openzfs/tests/test-runner/include/logapi.shlib +++ b/sys/contrib/openzfs/tests/test-runner/include/logapi.shlib @@ -55,7 +55,6 @@ function log_note function log_neg { log_neg_expect "" "$@" - return $? } # Execute a positive test and exit $STF_FAIL is test fails @@ -64,8 +63,7 @@ function log_neg function log_must { - log_pos "$@" - (( $? != 0 )) && log_fail + log_pos "$@" || log_fail } # Execute a positive test (expecting no stderr) and exit $STF_FAIL @@ -74,8 +72,7 @@ function log_must function log_must_nostderr { - log_pos_nostderr "$@" - (( $? != 0 )) && log_fail + log_pos_nostderr "$@" || log_fail } # Execute a positive test but retry the command on failure if the output @@ -149,8 +146,7 @@ function log_must_retry # $@ - command to execute function log_must_busy { - log_must_retry "busy" 5 "$@" - (( $? != 0 )) && log_fail + log_must_retry "busy" 5 "$@" || log_fail } # Execute a negative test and exit $STF_FAIL if test passes @@ -159,8 +155,7 @@ function log_must_busy function log_mustnot { - log_neg "$@" - (( $? != 0 )) && log_fail + log_neg "$@" || log_fail } # Execute a negative test with keyword expected, and exit @@ -171,8 +166,7 @@ function log_mustnot function log_mustnot_expect { - log_neg_expect "$@" - (( $? != 0 )) && log_fail + log_neg_expect "$@" || log_fail } # Signal numbers are platform-dependent @@ -576,5 +570,5 @@ function _recursive_output #logfile fi rm -f $logfile logfile="$logfile.$$" - done + done } diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c index e12ab84fce5..6f4ecd5ef4c 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c @@ -766,7 +766,7 @@ eval_maps(uint64_t children, int passes, uint64_t *map_seed, static int draid_generate(int argc, char *argv[]) { - char filename[MAXPATHLEN]; + char filename[MAXPATHLEN] = {0}; uint64_t map_seed; int c, fd, error, verbose = 0, passes = 1, continuous = 0; int min_children = VDEV_DRAID_MIN_CHILDREN; @@ -824,10 +824,9 @@ draid_generate(int argc, char *argv[]) } } - if (argc > optind) { - bzero(filename, MAXPATHLEN); + if (argc > optind) strncpy(filename, argv[optind], MAXPATHLEN - 1); - } else { + else { (void) fprintf(stderr, "A FILE must be specified.\n"); return (1); } @@ -926,7 +925,7 @@ restart: static int draid_verify(int argc, char *argv[]) { - char filename[MAXPATHLEN]; + char filename[MAXPATHLEN] = {0}; int n = 0, c, error, verbose = 1; int check_ratios = 0; @@ -956,7 +955,6 @@ draid_verify(int argc, char *argv[]) if (abspath == NULL) return (ENOMEM); - bzero(filename, MAXPATHLEN); if (realpath(argv[optind], abspath) != NULL) strncpy(filename, abspath, MAXPATHLEN - 1); else @@ -980,9 +978,8 @@ draid_verify(int argc, char *argv[]) children <= VDEV_DRAID_MAX_CHILDREN; children++) { draid_map_t *map; - char key[8]; + char key[8] = {0}; - bzero(key, 8); snprintf(key, 8, "%llu", (u_longlong_t)children); error = alloc_fixed_map(children, &map); @@ -1126,7 +1123,7 @@ draid_verify(int argc, char *argv[]) static int draid_dump(int argc, char *argv[]) { - char filename[MAXPATHLEN]; + char filename[MAXPATHLEN] = {0}; int c, error, verbose = 1; int min_children = VDEV_DRAID_MIN_CHILDREN; int max_children = VDEV_DRAID_MAX_CHILDREN; @@ -1167,10 +1164,9 @@ draid_dump(int argc, char *argv[]) } } - if (argc > optind) { - bzero(filename, MAXPATHLEN); + if (argc > optind) strncpy(filename, argv[optind], MAXPATHLEN - 1); - } else { + else { (void) fprintf(stderr, "A FILE must be specified.\n"); return (1); } @@ -1202,13 +1198,12 @@ draid_dump(int argc, char *argv[]) static int draid_table(int argc, char *argv[]) { - char filename[MAXPATHLEN]; + char filename[MAXPATHLEN] = {0}; int error; - if (argc > optind) { - bzero(filename, MAXPATHLEN); + if (argc > optind) strncpy(filename, argv[optind], MAXPATHLEN - 1); - } else { + else { (void) fprintf(stderr, "A FILE must be specified.\n"); return (1); } @@ -1221,9 +1216,8 @@ draid_table(int argc, char *argv[]) children++) { uint64_t seed, checksum, nperms, avg_ratio; nvlist_t *cfg; - char key[8]; + char key[8] = {0}; - bzero(key, 8); snprintf(key, 8, "%llu", (u_longlong_t)children); error = read_map_key(filename, key, &cfg); @@ -1317,7 +1311,7 @@ draid_merge_impl(nvlist_t *allcfgs, const char *srcfilename, int *mergedp) static int draid_merge(int argc, char *argv[]) { - char filename[MAXPATHLEN]; + char filename[MAXPATHLEN] = {0}; int c, error, total_merged = 0, verbose = 0; nvlist_t *allcfgs; @@ -1345,7 +1339,6 @@ draid_merge(int argc, char *argv[]) return (1); } - bzero(filename, MAXPATHLEN); strncpy(filename, argv[optind], MAXPATHLEN - 1); optind++; @@ -1358,10 +1351,9 @@ draid_merge(int argc, char *argv[]) } while (optind < argc) { - char srcfilename[MAXPATHLEN]; + char srcfilename[MAXPATHLEN] = {0}; int merged = 0; - bzero(srcfilename, MAXPATHLEN); strncpy(srcfilename, argv[optind], MAXPATHLEN - 1); error = draid_merge_impl(allcfgs, srcfilename, &merged); diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/file_common.h b/sys/contrib/openzfs/tests/zfs-tests/cmd/file_common.h index 64b1777a9ae..f0c0e32b5f4 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/file_common.h +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/file_common.h @@ -52,7 +52,7 @@ extern "C" { #include #include #include -#include +#include #define BLOCKSZ 8192 #define DATA 0xa5 diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/libzfs_input_check/libzfs_input_check.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/libzfs_input_check/libzfs_input_check.c index fba18068cfc..bfa450be54d 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/libzfs_input_check/libzfs_input_check.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/libzfs_input_check/libzfs_input_check.c @@ -20,7 +20,6 @@ #include #include #include -#include #include #include @@ -33,19 +32,19 @@ * Test the nvpair inputs for the non-legacy zfs ioctl commands. */ -boolean_t unexpected_failures; -int zfs_fd; -const char *active_test; +static boolean_t unexpected_failures; +static int zfs_fd; +static const char *active_test; /* * Tracks which zfs_ioc_t commands were tested */ -boolean_t ioc_tested[ZFS_IOC_LAST - ZFS_IOC_FIRST]; +static boolean_t ioc_tested[ZFS_IOC_LAST - ZFS_IOC_FIRST]; /* * Legacy ioctls that are skipped (for now) */ -static unsigned ioc_skip[] = { +static const zfs_ioc_t ioc_skip[] = { ZFS_IOC_POOL_CREATE, ZFS_IOC_POOL_DESTROY, ZFS_IOC_POOL_IMPORT, diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/mkbusy/mkbusy.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/mkbusy/mkbusy.c index c32f1ecdc3b..75b5736e561 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/mkbusy/mkbusy.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/mkbusy/mkbusy.c @@ -24,21 +24,21 @@ #include #include #include -#include +#include #include #include #include #include -static _Noreturn void +static __attribute__((noreturn)) void usage(char *progname) { (void) fprintf(stderr, "Usage: %s \n", progname); exit(1); } -static _Noreturn void +static __attribute__((noreturn)) void fail(char *err) { perror(err); diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/mkfile/mkfile.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/mkfile/mkfile.c index f59a01efaca..ede05a1220a 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/mkfile/mkfile.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/mkfile/mkfile.c @@ -44,7 +44,13 @@ #define FILE_MODE (S_ISVTX + S_IRUSR + S_IWUSR) -static _Noreturn void usage(void); +static __attribute__((noreturn)) void +usage(void) +{ + (void) fprintf(stderr, gettext( + "Usage: mkfile [-nv] [g|k|b|m] [] ...\n")); + exit(1); +} int main(int argc, char **argv) @@ -272,10 +278,3 @@ main(int argc, char **argv) } return (errors); } - -static void usage() -{ - (void) fprintf(stderr, gettext( - "Usage: mkfile [-nv] [g|k|b|m] [] ...\n")); - exit(1); -} diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/nvlist_to_lua/nvlist_to_lua.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/nvlist_to_lua/nvlist_to_lua.c index 3072ca97939..4d2abfeb12a 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/nvlist_to_lua/nvlist_to_lua.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/nvlist_to_lua/nvlist_to_lua.c @@ -20,13 +20,12 @@ #include #include #include -#include #include #include -nvlist_t *nvl; -const char *pool; -boolean_t unexpected_failures; +static nvlist_t *nvl; +static const char *pool; +static boolean_t unexpected_failures; static boolean_t nvlist_equal(nvlist_t *nvla, nvlist_t *nvlb) diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/randwritecomp/randwritecomp.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/randwritecomp/randwritecomp.c index 708d5ee9051..3cff7fd0a01 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/randwritecomp/randwritecomp.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/randwritecomp/randwritecomp.c @@ -13,12 +13,6 @@ * Copyright (c) 2017 by Delphix. All rights reserved. */ -/* - * The following is defined so the source can use - * lrand48() and srand48(). - */ -#define __EXTENSIONS__ - #include #include #include "../file_common.h" @@ -27,7 +21,7 @@ * The following sample was derived from real-world data * of a production Oracle database. */ -static uint64_t size_distribution[] = { +static const uint64_t size_distribution[] = { 0, 1499018, 352084, @@ -87,11 +81,11 @@ fillbuf(char *buf) break; } - bcopy(randbuf, buf, BLOCKSZ); + memcpy(buf, randbuf, BLOCKSZ); if (i == 0) - bzero(buf, BLOCKSZ - 10); + memset(buf, 0, BLOCKSZ - 10); else if (i < 16) - bzero(buf, BLOCKSZ - i * 512 + 256); + memset(buf, 0, BLOCKSZ - i * 512 + 256); /*LINTED: E_BAD_PTR_CAST_ALIGN*/ ((uint32_t *)buf)[0] = lrand48(); } @@ -99,8 +93,7 @@ fillbuf(char *buf) static void exit_usage(void) { - (void) printf("usage: "); - (void) printf("randwritecomp [-s] [nwrites]\n"); + (void) puts("usage: randwritecomp [-s] file [nwrites]"); exit(EXIT_FAILURE); } diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/rename_dir/rename_dir.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/rename_dir/rename_dir.c index 897ec7b8414..3c3f45146e1 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/rename_dir/rename_dir.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/rename_dir/rename_dir.c @@ -46,7 +46,6 @@ #include #include #include -#include int main(void) @@ -58,6 +57,7 @@ main(void) perror("fork"); exit(1); break; + case 0: while (i > 0) { int c_count = 0; @@ -65,11 +65,11 @@ main(void) c_count++; if (rename("1/2/3/c", "a/b/c") == 0) c_count++; - if (c_count) { + if (c_count) (void) fprintf(stderr, "c_count: %d", c_count); - } } - break; + _exit(0); + default: while (i > 0) { int p_count = 0; @@ -77,12 +77,9 @@ main(void) p_count++; if (rename("a/b/c/d/e/1", "1") == 0) p_count++; - if (p_count) { + if (p_count) (void) fprintf(stderr, "p_count: %d", p_count); - } } - break; + return (0); } - - return (0); } diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/rm_lnkcnt_zero_file/rm_lnkcnt_zero_file.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/rm_lnkcnt_zero_file/rm_lnkcnt_zero_file.c index f8b6e3e808b..9aeabb08e02 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/cmd/rm_lnkcnt_zero_file/rm_lnkcnt_zero_file.c +++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/rm_lnkcnt_zero_file/rm_lnkcnt_zero_file.c @@ -45,7 +45,6 @@ #include #include #include -#include static char *filebase; diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/edonr_test.c b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/edonr_test.c index d8585ea4cf7..c6365a4147e 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/edonr_test.c +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/edonr_test.c @@ -160,7 +160,7 @@ main(int argc, char *argv[]) EdonRFinal(&ctx, digest); \ (void) printf("Edon-R-%-6sMessage: " #_m \ "\tResult: ", #mode); \ - if (bcmp(digest, testdigest, mode / 8) == 0) { \ + if (memcmp(digest, testdigest, mode / 8) == 0) { \ (void) printf("OK\n"); \ } else { \ (void) printf("FAILED!\n"); \ @@ -177,7 +177,7 @@ main(int argc, char *argv[]) double cpb = 0; \ int i; \ struct timeval start, end; \ - bzero(block, sizeof (block)); \ + memset(block, 0, sizeof (block)); \ (void) gettimeofday(&start, NULL); \ EdonRInit(&ctx, mode); \ for (i = 0; i < 8192; i++) \ diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/sha2_test.c b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/sha2_test.c index c7561b54f29..dc4173e1059 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/sha2_test.c +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/sha2_test.c @@ -189,7 +189,7 @@ main(int argc, char *argv[]) SHA2Final(digest, &ctx); \ (void) printf("SHA%-9sMessage: " #_m \ "\tResult: ", #mode); \ - if (bcmp(digest, testdigest, diglen / 8) == 0) { \ + if (memcmp(digest, testdigest, diglen / 8) == 0) { \ (void) printf("OK\n"); \ } else { \ (void) printf("FAILED!\n"); \ @@ -206,7 +206,7 @@ main(int argc, char *argv[]) double cpb = 0; \ int i; \ struct timeval start, end; \ - bzero(block, sizeof (block)); \ + memset(block, 0, sizeof (block)); \ (void) gettimeofday(&start, NULL); \ SHA2Init(SHA ## mode ## _MECH_INFO_TYPE, &ctx); \ for (i = 0; i < 8192; i++) \ diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/skein_test.c b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/skein_test.c index 484fad844b7..99b47b4532f 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/skein_test.c +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/checksum/skein_test.c @@ -34,7 +34,7 @@ #include #include -#include +#include #include #include #include @@ -278,7 +278,7 @@ main(int argc, char *argv[]) (void) Skein ## mode ## _Final(&ctx, digest); \ (void) printf("Skein" #mode "/" #diglen \ "\tMessage: " #_m "\tResult: "); \ - if (bcmp(digest, testdigest, diglen / 8) == 0) { \ + if (memcmp(digest, testdigest, diglen / 8) == 0) { \ (void) printf("OK\n"); \ } else { \ (void) printf("FAILED!\n"); \ @@ -295,7 +295,7 @@ main(int argc, char *argv[]) double cpb = 0; \ int i; \ struct timeval start, end; \ - bzero(block, sizeof (block)); \ + memset(block, 0, sizeof (block)); \ (void) gettimeofday(&start, NULL); \ (void) Skein ## mode ## _Init(&ctx, diglen); \ for (i = 0; i < 8192; i++) { \ diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh index 51a7ce1d96d..796b38928ec 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs/zfs_002_pos.ksh @@ -108,12 +108,8 @@ fi log_must export ZFS_ABORT=yes for subcmd in "${cmds[@]}" "${badparams[@]}"; do - zfs $subcmd >/dev/null 2>&1 && log_fail "$subcmd passed incorrectly." - if [[ ! -e $corefile ]]; then - log_fail "zfs $subcmd cannot generate core file with " \ - "ZFS_ABORT set." - fi - log_must rm -f $corefile + log_mustnot eval "zfs $subcmd >/dev/null 2>&1" + log_must rm $corefile done log_pass "With ZFS_ABORT set, zfs command can abort and generate core file " \ diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh index deb501698a9..807954a6069 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh @@ -154,12 +154,7 @@ typeset -i i=0 while ((i < ${#dataset[@]})); do for opt in "${options[@]}"; do for prop in ${all_props[@]}; do - eval "zfs get $opt $prop ${dataset[i]} > \ - $TESTDIR/$TESTFILE0" - ret=$? - if [[ $ret != 0 ]]; then - log_fail "zfs get returned: $ret" - fi + log_must eval "zfs get $opt $prop ${dataset[i]} > $TESTDIR/$TESTFILE0" check_return_value ${dataset[i]} "$prop" "$opt" done done @@ -170,12 +165,7 @@ i=0 while ((i < ${#bookmark[@]})); do for opt in "${options[@]}"; do for prop in ${bookmark_props[@]}; do - eval "zfs get $opt $prop ${bookmark[i]} > \ - $TESTDIR/$TESTFILE0" - ret=$? - if [[ $ret != 0 ]]; then - log_fail "zfs get returned: $ret" - fi + log_must eval "zfs get $opt $prop ${bookmark[i]} > $TESTDIR/$TESTFILE0" check_return_value ${bookmark[i]} "$prop" "$opt" done done diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_002_pos.ksh index c3746514eae..88822adfc76 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_002_pos.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_002_pos.ksh @@ -85,11 +85,7 @@ for dst in ${dataset[@]}; do for opt in "" $(gen_option_str "${options[*]}" "-" "" $opt_numb); do for prop in $(gen_option_str "${props[*]}" "" "," $prop_numb) do - zfs get $opt $prop $dst > /dev/null 2>&1 - ret=$? - if [[ $ret != 0 ]]; then - log_fail "zfs get $opt $prop $dst (Code: $ret)" - fi + log_must eval "zfs get $opt $prop $dst > /dev/null" done done done diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_005_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_005_neg.ksh index 510c54506d0..c527cef087a 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_005_neg.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_005_neg.ksh @@ -93,12 +93,7 @@ function test_options for dst in ${dataset[@]}; do for opt in $opts; do for prop in $props; do - zfs get $opt -- $prop $dst > /dev/null 2>&1 - ret=$? - if [[ $ret == 0 ]]; then - log_fail "zfs get $opt -- $prop " \ - "$dst unexpectedly succeeded." - fi + log_mustnot eval "zfs get $opt -- $prop $dst > /dev/null" done done done @@ -118,12 +113,7 @@ function test_options_bookmarks for dst in ${bookmark[@]}; do for opt in $opts; do for prop in $props; do - zfs get $opt -- $prop $dst > /dev/null 2>&1 - ret=$? - if [[ $ret == 0 ]]; then - log_fail "zfs get $opt -- $prop " \ - "$dst unexpectedly succeeded." - fi + log_mustnot eval "zfs get $opt -- $prop $dst > /dev/null" done done done diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_006_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_006_neg.ksh index a9168584906..e19936ef88d 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_006_neg.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_006_neg.ksh @@ -47,7 +47,8 @@ log_assert "Verify 'zfs get all' fails with invalid combination scenarios." set -f # Force ksh ignore '?' and '*' set -A bad_combine "ALL" "\-R all" "-P all" "-h all" "-rph all" "-RpH all" "-PrH all" \ - "-o all" "-s all" "-? all" "-* all" "-?* all" "all -r" "all -p" \ + "-o all" "-s all" "-s none=getsubopt" "-t filesystem=getsubopt" \ + "-? all" "-* all" "-?* all" "all -r" "all -p" \ "all -H" "all -rp" "all -rH" "all -ph" "all -rpH" "all -r $TESTPOOL" \ "all -H $TESTPOOL" "all -p $TESTPOOL" "all -r -p -H $TESTPOOL" \ "all -rph $TESTPOOL" "all,available,reservation $TESTPOOL" \ diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_007_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_007_neg.ksh index 9bb00807f1b..63dfb6a50b5 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_007_neg.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_007_neg.ksh @@ -51,7 +51,7 @@ set -A badargs "o name,property,value,resource" "o name" \ "-o" "-o ,,,,," "-o -o -o -o" "-o NAME,PROPERTY,VALUE,SOURCE" \ "-o name,properTy,value,source" "-o name, property, value,source" \ "-o name:property:value:source" "-o name,property:value,source" \ - "-o name;property;value;source" + "-o name;property;value;source" "-o name=getsubopt" typeset -i i=0 while (( i < ${#badargs[*]} )) diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib index 12082076322..7e34341d852 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib @@ -289,8 +289,8 @@ function check_prop_source if [[ "$chk_value" != "$value" || "$chk_source" != "$source" ]] then - log_note "expected (value '$value', source '$source'), got \ - (value '$chk_value', source '$chk_source')" + log_note "expected (value '$value', source '$source')," \ + "got (value '$chk_value', source '$chk_source')" return 1 else return 0 @@ -318,6 +318,8 @@ function check_prop_inherit if [[ "$value" != "$inherited_value" || \ "$source" != "inherited from $inherited_dtst" ]] then + log_note "expected (value '$inherited_value', source 'inherited from $inherited_dtst')," \ + "got (value '$value', source '$source')" return 1 else return 0 @@ -341,7 +343,7 @@ function check_prop_received received=$(zfs get -H -o received "$prop" "$dataset") if (($? != 0)); then - log_fail "Unable to get $prop received value for dataset " \ + log_fail "Unable to get $prop received value for dataset" \ "$dataset" fi if [[ "$received" == "$value" ]] diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_wait/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_wait/Makefile.am index d401fe68b1e..5d385d91572 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_wait/Makefile.am +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_wait/Makefile.am @@ -2,7 +2,8 @@ pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/cli_root/zfs_wait dist_pkgdata_SCRIPTS = \ setup.ksh \ cleanup.ksh \ - zfs_wait_deleteq.ksh + zfs_wait_deleteq.ksh \ + zfs_wait_getsubopt.ksh dist_pkgdata_DATA = \ zfs_wait.kshlib diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_wait/zfs_wait_getsubopt.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_wait/zfs_wait_getsubopt.ksh new file mode 100755 index 00000000000..d60aec96b7f --- /dev/null +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_wait/zfs_wait_getsubopt.ksh @@ -0,0 +1,14 @@ +#!/bin/ksh -p +# SPDX-License-Identifier: 0BSD + +. $STF_SUITE/include/libtest.shlib + +# +# DESCRIPTION: +# zfs wait -t used to accept getsubopt(3)-style deleteq=whatever; +# it doesn't anymore +# + +log_mustnot zfs wait -t deleteq=getsubopt $TESTPOOL + +log_pass "'zfs wait -t' doesn't accept =getsubopt suffixes." diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get_004_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get_004_neg.ksh index 1edd2ba79af..bbdd32933c8 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get_004_neg.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get_004_neg.ksh @@ -51,7 +51,8 @@ set -A arguments "$TESTPOOL $TESTPOOL" "$TESTPOOL rubbish" "-v $TESTPOOL" \ "nosuchproperty $TESTPOOL" "--$TESTPOOL" "all all" \ "type $TESTPOOL" "usage: $TESTPOOL" "bootfs $TESTPOOL@" \ "bootfs,bootfs $TESTPOOL" "name $TESTPOOL" "t%d%s" \ - "bootfs,delegation $TESTPOOL" "delegation $TESTPOOL@" + "bootfs,delegation $TESTPOOL" "delegation $TESTPOOL@" \ + "-o name=getsubopt allocated $TESTPOOL" for arg in $arguments do diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_wait/zpool_wait_usage.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_wait/zpool_wait_usage.ksh index 2d6f897092f..05cbfce5741 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_wait/zpool_wait_usage.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_wait/zpool_wait_usage.ksh @@ -43,5 +43,7 @@ zpool wait -t scrub fakepool 2>&1 | grep -i 'no such pool' || \ log_fail "Error message did not contain phrase 'no such pool'." zpool wait -t foo $TESTPOOL 2>&1 | grep -i 'invalid activity' || \ log_fail "Error message did not contain phrase 'invalid activity'." +zpool wait -t scrub=getsubopt $TESTPOOL 2>&1 | grep -i 'invalid activity' || \ + log_fail "getsubopt(3) error message did not contain phrase 'invalid activity'." log_pass "'zpool wait' behaves sensibly when invoked incorrectly." diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/Makefile.am index 8393072af22..81754f40159 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/Makefile.am +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/Makefile.am @@ -6,6 +6,7 @@ dist_pkgdata_SCRIPTS = \ zfs_list_002_pos.ksh \ zfs_list_003_pos.ksh \ zfs_list_004_neg.ksh \ + zfs_list_005_neg.ksh \ zfs_list_007_pos.ksh \ zfs_list_008_neg.ksh diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/zfs_list_005_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/zfs_list_005_neg.ksh new file mode 100755 index 00000000000..ae374a6f6c1 --- /dev/null +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/zfs_list_005_neg.ksh @@ -0,0 +1,14 @@ +#!/bin/ksh -p +# SPDX-License-Identifier: 0BSD + +. $STF_SUITE/include/libtest.shlib + +# +# DESCRIPTION: +# zfs list -t used to accept getsubopt(3)-style filesystem=whatever; +# it doesn't anymore +# + +log_mustnot zfs list -t filesystem=getsubopt + +log_pass "'zfs list -t' doesn't accept =getsubopt suffixes." diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/ctime/ctime.c b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/ctime/ctime.c index 41dcf6abc9c..cb2be72eedb 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/ctime/ctime.c +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/ctime/ctime.c @@ -38,7 +38,6 @@ #include #include #include -#include #include #include #include diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh index 591d5b85e88..f187b88f056 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/history/history_007_pos.ksh @@ -49,7 +49,7 @@ function cleanup poolexists $migratedpoolname && \ log_must zpool destroy -f $migratedpoolname - [[ -d $import_dir ]] && rm -rf $import_dir + rm -rf $import_dir } log_assert "Verify command history moves with migrated pool." @@ -80,10 +80,7 @@ for arch in "i386" "sparc"; do log_must zpool destroy -f $migratedpoolname log_must zpool import -d $import_dir $migratedpoolname - TZ=$TIMEZONE zpool history $migratedpoolname | grep -v "^$" \ - >$migrated_cmds_f - RET=$? - (( $RET != 0 )) && log_fail "zpool history $migratedpoolname fails." + log_must eval "TZ=$TIMEZONE zpool history $migratedpoolname | grep -v "^\$" >$migrated_cmds_f" # The migrated history file should differ with original history file on # two commands -- 'export' and 'import', which are included in migrated @@ -92,14 +89,13 @@ for arch in "i386" "sparc"; do # then compare this filtered file with the original history file. They # should be identical at this time. for subcmd in "export" "import"; do - grep "$subcmd" $migrated_cmds_f >/dev/null 2>&1 - RET=$? - (( $RET != 0 )) && log_fail "zpool $subcmd is not logged for" \ - "the imported pool $migratedpoolname." + grep -q "$subcmd" $migrated_cmds_f || \ + log_fail "zpool $subcmd is not logged for" \ + "the imported pool $migratedpoolname." done tmpfile=$import_dir/cmds_tmp.$$ - linenum=`cat $migrated_cmds_f | wc -l` + linenum=`wc -l < $migrated_cmds_f` (( linenum = linenum - 2 )) head -n $linenum $migrated_cmds_f > $tmpfile log_must diff $tmpfile $orig_cmds_f1 diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/hkdf/hkdf_test.c b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/hkdf/hkdf_test.c index 5fff3e09ed0..473a9ba9a0d 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/hkdf/hkdf_test.c +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/hkdf/hkdf_test.c @@ -18,13 +18,11 @@ */ #include -#include +#include #include #include #include -#define NELEMS(x) (sizeof (x) / sizeof ((x)[0])) - /* * Byte arrays are given as char pointers so that they * can be specified as strings. @@ -174,12 +172,9 @@ static hkdf_tv_t test_vectors[] = { static void hexdump(char *str, uint8_t *src, uint_t len) { - int i; - printf("\t%s\t", str); - for (i = 0; i < len; i++) { - printf("%02x", src[i] & 0xff); - } + for (int i = 0; i < len; i++) + printf("%02hhx", src[i]); printf("\n"); } @@ -187,21 +182,21 @@ static int run_test(int i, hkdf_tv_t *tv) { int ret; - uint8_t okey[SHA512_DIGEST_LENGTH]; + uint8_t good[SHA512_DIGEST_LENGTH]; printf("TEST %d:\t", i); ret = hkdf_sha512((uint8_t *)tv->ikm, tv->ikm_len, (uint8_t *)tv->salt, - tv->salt_len, (uint8_t *)tv->info, tv->info_len, okey, tv->okm_len); + tv->salt_len, (uint8_t *)tv->info, tv->info_len, good, tv->okm_len); if (ret != 0) { printf("HKDF failed with error code %d\n", ret); return (ret); } - if (bcmp(okey, tv->okm, tv->okm_len) != 0) { + if (memcmp(good, tv->okm, tv->okm_len) != 0) { printf("Output Mismatch\n"); hexdump("Expected:", (uint8_t *)tv->okm, tv->okm_len); - hexdump("Actual: ", okey, tv->okm_len); + hexdump("Actual: ", good, tv->okm_len); return (1); } @@ -217,7 +212,7 @@ main(void) icp_init(); - for (i = 0; i < NELEMS(test_vectors); i++) { + for (i = 0; i < ARRAY_SIZE(test_vectors); i++) { ret = run_test(i, &test_vectors[i]); if (ret != 0) break; diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh index 6b51598d7cc..6f6acdafafe 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/largest_pool/largest_pool_001_pos.ksh @@ -120,7 +120,7 @@ typeset str typeset -i ret for volsize in $VOLSIZES; do log_note "Create a pool which will contain a volume device" - create_pool $TESTPOOL2 "$DISKS" + log_must create_pool $TESTPOOL2 "$DISKS" log_note "Create a volume device of desired sizes: $volsize" str=$(zfs create -sV $volsize $TESTPOOL2/$TESTVOL 2>&1) @@ -140,7 +140,7 @@ for volsize in $VOLSIZES; do block_device_wait log_note "Create the largest pool allowed using the volume vdev" - create_pool $TESTPOOL "$VOL_PATH" + log_must create_pool $TESTPOOL "$VOL_PATH" log_note "Create a zfs file system in the largest pool" log_must zfs create $TESTPOOL/$TESTFS diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_lun_expsz.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_lun_expsz.ksh index 59f64081a97..a18e634cefa 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_lun_expsz.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_lun_expsz.ksh @@ -48,14 +48,18 @@ log_must zpool checkpoint $NESTEDPOOL log_must truncate -s $EXPSZ $FILEDISK1 log_must zpool online -e $NESTEDPOOL $FILEDISK1 NEWSZ=$(zpool list -v | grep "$FILEDISK1" | awk '{print $2}') +DEXPSZ=$(zpool list -v | grep "$FILEDISK1" | awk '{print $6}') nested_change_state_after_checkpoint log_mustnot [ "$INITSZ" = "$NEWSZ" ] +log_must [ "$DEXPSZ" = "-" ] log_must zpool export $NESTEDPOOL log_must zpool import -d $FILEDISKDIR --rewind-to-checkpoint $NESTEDPOOL nested_verify_pre_checkpoint_state FINSZ=$(zpool list -v | grep "$FILEDISK1" | awk '{print $2}') -log_must [ "$INITSZ" = "$FINSZ" ] +DEXPSZ=$(zpool list -v | grep "$FILEDISK1" | awk '{print $6}') +log_must [ "$EXPSZ" = "$FINSZ" ] +log_must [ "$DEXPSZ" != "-" ] log_pass "LUN expansion rewinded correctly." diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/Makefile.am index b8eb54f64c3..305fc0d517d 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/Makefile.am +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/Makefile.am @@ -24,6 +24,11 @@ dist_pkgdata_SCRIPTS = \ rsend_021_pos.ksh \ rsend_022_pos.ksh \ rsend_024_pos.ksh \ + rsend_025_pos.ksh \ + rsend_026_neg.ksh \ + rsend_027_pos.ksh \ + rsend_028_neg.ksh \ + rsend_029_neg.ksh \ send_encrypted_files.ksh \ send_encrypted_hierarchy.ksh \ send_encrypted_props.ksh \ diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend.kshlib index 2c8085f226b..8d704ee3687 100644 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend.kshlib +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend.kshlib @@ -583,24 +583,22 @@ function churn_files # function mess_send_file { + typeset -i minsize=2072 file=$1 filesize=$(stat_size $file) + if [ $filesize -lt $minsize ]; then + log_fail "Send file too small: $filesize < $minsize" + fi - offset=$(($RANDOM * $RANDOM % $filesize)) - - # The random offset might truncate the send stream to be - # smaller than the DRR_BEGIN record. If this happens, then - # the receiving system won't have enough info to create the - # partial dataset at all. We use zstream dump to check for - # this and retry in this case. + # Truncate the send stream at a random offset after the DRR_BEGIN + # record (beyond 2072 bytes), any smaller than this and the receiving + # system won't have enough info to create the partial dataset at all. + # We use zstream dump to verify there is an intact DRR_BEGIN record. + offset=$(((($RANDOM * $RANDOM) % ($filesize - $minsize)) + $minsize)) nr_begins=$(head -c $offset $file | zstream dump | \ grep DRR_BEGIN | awk '{ print $5 }') - while [ "$nr_begins" -eq 0 ]; do - offset=$(($RANDOM * $RANDOM % $filesize)) - nr_begins=$(head -c $offset $file | zstream dump | \ - grep DRR_BEGIN | awk '{ print $5 }') - done + log_must test "$nr_begins" -eq 1 if (($RANDOM % 7 <= 1)); then # diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_011_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_011_pos.ksh index 68f0e13927d..f2df0ed0346 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_011_pos.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_011_pos.ksh @@ -67,18 +67,12 @@ done # for ds in "$POOL/$FS/fs1" "$POOL/$FS/fs1/fs2" "$POOL/$FS/fs1/fclone" ; do for prop in $(fs_inherit_prop) ; do - zfs inherit $prop $ds - if (($? !=0 )); then - log_fail "zfs inherit $prop $ds" - fi + log_must zfs inherit $prop $ds done done if is_global_zone ; then for prop in $(vol_inherit_prop) ; do - zfs inherit $prop $POOL/$FS/vol - if (($? !=0 )); then - log_fail "zfs inherit $prop $POOL/$FS/vol" - fi + log_must zfs inherit $prop $POOL/$FS/vol done fi diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_012_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_012_pos.ksh index 594357dc4b7..694dd15b44f 100755 --- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_012_pos.ksh +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_012_pos.ksh @@ -52,18 +52,13 @@ function edited_prop "get") typeset props=$(zfs inherit 2>&1 | \ awk '$2=="YES" {print $1}' | \ - egrep -v "^vol|\.\.\.$") + grep -Ev "^vol|\.\.\.$") for item in $props ; do if [[ $item == "mlslabel" ]] && \ ! is_te_enabled ; then continue fi - zfs get -H -o property,value $item $ds >> \ - $backfile - if (($? != 0)); then - log_fail "zfs get -H -o property,value"\ - "$item $ds > $backfile" - fi + log_must eval "zfs get -H -o property,value $item $ds >> $backfile" done ;; "set") @@ -72,11 +67,8 @@ function edited_prop fi typeset prop value - while read prop value ; do - eval zfs set $prop='$value' $ds - if (($? != 0)); then - log_fail "zfs set $prop=$value $ds" - fi + while read -r prop value; do + log_must zfs set "$prop=$value" "$ds" done < $backfile ;; *) diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_025_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_025_pos.ksh new file mode 100755 index 00000000000..99254cccdbc --- /dev/null +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_025_pos.ksh @@ -0,0 +1,90 @@ +#!/bin/ksh -p +# +# 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 +# + +# +# Copyright 2009 Sun Microsystems, Inc. All rights reserved. +# Use is subject to license terms. +# + +# +# Copyright (c) 2013, 2016 by Delphix. All rights reserved. +# + +. $STF_SUITE/tests/functional/rsend/rsend.kshlib + +# DESCRIPTION: +# zfs send -exclude will exclude the given hierarchy +# and only that given hierarchy. +# +# STRATEGY: +# 1. Setup test model +# 2. Create several datasets on pool. +# 3. Send -R -X pool/dataset +# 4. Verify receive does not have the excluded dataset(s). + +verify_runnable "both" + +function cleanup +{ + cleanup_pool $POOL2 + cleanup_pool $POOL + log_must setup_test_model $POOL +} + +log_assert "zfs send -R -X will skip excluded dataset(s)" +log_onexit cleanup + +cleanup + +# +# Create some datasets +log_must zfs create -p $POOL/ds1/second/third +log_must zfs create -p $POOL/ds2/second + +log_must zfs snapshot -r $POOL@presend + +log_must eval "zfs send -R $POOL@presend > $BACKDIR/presend" +log_must eval "zfs receive -d -F $POOL2 < $BACKDIR/presend" + +for ds in ds1 ds1/second ds1/second/third \ + ds2 ds2/second +do + log_must datasetexists $POOL2/$ds +done + +log_must_busy zfs destroy -r $POOL2 + +log_must eval "zfs send -R -X $POOL/ds1/second $POOL@presend > $BACKDIR/presend" +log_must eval "zfs receive -d -F $POOL2 < $BACKDIR/presend" + +for ds in ds1 ds2 ds2/second +do + log_must datasetexists $POOL2/$ds +done + +for ds in ds1/second ds1/second/third +do + log_must datasetnonexists $POOL2/$ds +done + +log_pass "zfs send -X excluded datasets" + diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_026_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_026_neg.ksh new file mode 100755 index 00000000000..5248008a18c --- /dev/null +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_026_neg.ksh @@ -0,0 +1,58 @@ +#!/bin/ksh -p +# +# 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 +# + +# +# Copyright 2009 Sun Microsystems, Inc. All rights reserved. +# Use is subject to license terms. +# + +# +# Copyright (c) 2013, 2016 by Delphix. All rights reserved. +# + +. $STF_SUITE/include/libtest.shlib +. $STF_SUITE/tests/functional/rsend/rsend.kshlib + +# DESCRIPTION: +# zfs send -X without -R will fail. +# +# STRATEGY: +# 1. Setup test model +# 2. Run "zfs send -X random $POOL" and check for failure. + +verify_runnable "both" + +function cleanup +{ + cleanup_pool $POOL2 + cleanup_pool $POOL + log_must setup_test_model $POOL +} + +log_assert "zfs send -X without -R will fail" +log_onexit cleanup + +cleanup + +log_mustnot eval "zfs send -X $POOL/foobar $POOL@final" + +log_pass "Ensure that zfs send -X without -R will fail" diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_027_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_027_pos.ksh new file mode 100755 index 00000000000..645685e690b --- /dev/null +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_027_pos.ksh @@ -0,0 +1,92 @@ +#!/bin/ksh -p +# +# 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 +# + +# +# Copyright 2009 Sun Microsystems, Inc. All rights reserved. +# Use is subject to license terms. +# + +# +# Copyright (c) 2013, 2016 by Delphix. All rights reserved. +# + +. $STF_SUITE/tests/functional/rsend/rsend.kshlib + +# DESCRIPTION: +# zfs send with multiple -X/--exclude options will +# exclude all of them. +# +# STRATEGY: +# 1. Setup test model +# 2. Create several datasets on pool. +# 3. Send -R -X pool/dataset +# 4. Verify receive does not have the excluded dataset(s). + +verify_runnable "both" + +function cleanup +{ + cleanup_pool $POOL2 + cleanup_pool $POOL + log_must setup_test_model $POOL +} + +log_assert "zfs send with multiple -X options will skip excluded dataset" +log_onexit cleanup + +cleanup + +# +# Create some datasets +log_must zfs create -p $POOL/ds1/second/third +log_must zfs create -p $POOL/ds2/second +log_must zfs create -p $POOL/ds3/first/second/third + +log_must zfs snapshot -r $POOL@presend + +log_must eval "zfs send -R $POOL@presend > $BACKDIR/presend" +log_must eval "zfs receive -d -F $POOL2 < $BACKDIR/presend" + +for ds in ds1 ds1/second ds1/second/third \ + ds2 ds2/second \ + ds3 ds3/first ds3/first/second ds3/first/second/third +do + log_must datasetexists $POOL2/$ds +done + +log_must_busy zfs destroy -r $POOL2 + +log_must eval "zfs send -R -X $POOL/ds1/second --exclude $POOL/ds3/first/second $POOL@presend > $BACKDIR/presend" +log_must eval "zfs receive -d -F $POOL2 < $BACKDIR/presend" + +for ds in ds1 ds2 ds2/second ds3 ds3/first +do + log_must datasetexists $POOL2/$ds +done + +for ds in ds1/second ds1/second/third ds3/first/second ds3/first/second/third +do + log_must datasetnonexists $POOL2/$ds +done + +log_pass "zfs send with multiple -X options excluded datasets" + diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_028_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_028_neg.ksh new file mode 100755 index 00000000000..e9186d79344 --- /dev/null +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_028_neg.ksh @@ -0,0 +1,58 @@ +#!/bin/ksh -p +# +# 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 +# + +# +# Copyright 2009 Sun Microsystems, Inc. All rights reserved. +# Use is subject to license terms. +# + +# +# Copyright (c) 2013, 2016 by Delphix. All rights reserved. +# + +. $STF_SUITE/include/libtest.shlib +. $STF_SUITE/tests/functional/rsend/rsend.kshlib + +# DESCRIPTION: +# zfs send -X with invalid dataset name will fail. +# +# STRATEGY: +# 1. Setup test model +# 2. Run "zfs send -X $POOL $POOL" and check for failure. + +verify_runnable "both" + +function cleanup +{ + cleanup_pool $POOL2 + cleanup_pool $POOL + log_must setup_test_model $POOL +} + +log_assert "zfs send -X $POOL will fail" +log_onexit cleanup + +cleanup + +log_mustnot eval "zfs send -X $POOL $POOL@final" + +log_pass "Ensure that zfs send -X $POOL will fail" diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_029_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_029_neg.ksh new file mode 100755 index 00000000000..7c3a96b7128 --- /dev/null +++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/rsend_029_neg.ksh @@ -0,0 +1,58 @@ +#!/bin/ksh -p +# +# 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 +# + +# +# Copyright 2009 Sun Microsystems, Inc. All rights reserved. +# Use is subject to license terms. +# + +# +# Copyright (c) 2013, 2016 by Delphix. All rights reserved. +# + +. $STF_SUITE/include/libtest.shlib +. $STF_SUITE/tests/functional/rsend/rsend.kshlib + +# DESCRIPTION: +# zfs send -X with invalid dataset name will fail. +# +# STRATEGY: +# 1. Setup test model +# 2. Run "zfs send -X $POOL/da%set $POOL" and check for failure. + +verify_runnable "both" + +function cleanup +{ + cleanup_pool $POOL2 + cleanup_pool $POOL + log_must setup_test_model $POOL +} + +log_assert "zfs send -X $POOL/da%set will fail" +log_onexit cleanup + +cleanup + +log_mustnot eval "zfs send -X $POOL/da%set $POOL@final" + +log_pass "Ensure that zfs send -X with invalid dataset name will fail" diff --git a/sys/modules/zfs/Makefile b/sys/modules/zfs/Makefile index a6b7512dda2..c0e25869133 100644 --- a/sys/modules/zfs/Makefile +++ b/sys/modules/zfs/Makefile @@ -29,7 +29,7 @@ CFLAGS+= -I${.CURDIR} CFLAGS+= -D__KERNEL__ -DFREEBSD_NAMECACHE -DBUILDING_ZFS \ -DHAVE_UIO_ZEROCOPY -DWITHOUT_NETDUMP -D__KERNEL -D_SYS_CONDVAR_H_ \ - -D_SYS_VMEM_H_ -DIN_FREEBSD_BASE -DHAVE_KSID + -D_SYS_VMEM_H_ -DIN_FREEBSD_BASE .if ${MACHINE_ARCH} == "amd64" CFLAGS+= -DHAVE_AVX2 -DHAVE_AVX -D__x86_64 -DHAVE_SSE2 -DHAVE_AVX512F -DHAVE_AVX512BW -DHAVE_SSSE3