c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2024-12-25 02:49:32 +03:00
Code Issues Packages Projects Releases Wiki Activity

OpenZFS 9235 - rename zpool_rewind_policy_t to zpool_load_policy_t

Browse Source 
We want to be able to pass various settings during import/open of a
pool, which are not only related to rewind. Instead of adding a new
policy and duplicate a bunch of code, we should just rename
rewind_policy to a more generic term like load_policy.

For instance, we'd like to set spa->spa_import_flags from the nvlist,
rather from a flags parameter passed to spa_import as in some cases we
want those flags not only for the import case, but also for the open
case. One such flag could be ZFS_IMPORT_MISSING_LOG (as used in zdb)
which would allow zfs to open a pool when logs are missing.

Authored by: Pavel Zakharov <pavel.zakharov@delphix.com>
Reviewed by: Matt Ahrens <matt@delphix.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
Approved by: Robert Mustacchi <rm@joyent.com>
Ported-by: Brian Behlendorf <behlendorf1@llnl.gov>

OpenZFS-issue: https://illumos.org/issues/9235
OpenZFS-commit: https://github.com/openzfs/openzfs/commit/d2b1e44
Closes #7532
This commit is contained in:
Pavel Zakharov 2017-02-10 17:51:09 -05:00 committed by Brian Behlendorf
parent 85912983a4
commit 8a393be353
9 changed files with 85 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/zdb/zdb.c
View File

@ -5074,8 +5074,8 @@ main(int argc, char **argv)
(dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0); (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 || if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, max_txg) != 0 || nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, max_txg) != 0 ||
nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind) != 0) nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY, rewind) != 0)
fatal("internal error: %s", strerror(ENOMEM)); fatal("internal error: %s", strerror(ENOMEM));
error = 0; error = 0;
@ -5108,7 +5108,7 @@ main(int argc, char **argv)
if (error == 0) { if (error == 0) {
if (nvlist_add_nvlist(cfg, if (nvlist_add_nvlist(cfg,
ZPOOL_REWIND_POLICY, policy) != 0) { ZPOOL_LOAD_POLICY, policy) != 0) {
fatal("can't open '%s': %s", fatal("can't open '%s': %s",
target, strerror(ENOMEM)); target, strerror(ENOMEM));
} }

11
cmd/zpool/zpool_main.c
View File

@ -2667,8 +2667,9 @@ zpool_do_import(int argc, char **argv)
/* In the future, we can capture further policy and include it here */ /* In the future, we can capture further policy and include it here */
if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 ||
nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, txg) != 0 || nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, txg) != 0 ||
nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY,
rewind_policy) != 0)
goto error; goto error;
/* check argument count */ /* check argument count */
@ -2819,7 +2820,7 @@ zpool_do_import(int argc, char **argv)
if (do_destroyed && pool_state != POOL_STATE_DESTROYED) if (do_destroyed && pool_state != POOL_STATE_DESTROYED)
continue; continue;
verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY, verify(nvlist_add_nvlist(config, ZPOOL_LOAD_POLICY,
policy) == 0); policy) == 0);
if (argc == 0) { if (argc == 0) {
@ -5878,8 +5879,10 @@ zpool_do_clear(int argc, char **argv)
/* In future, further rewind policy choices can be passed along here */ /* In future, further rewind policy choices can be passed along here */
if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 ||
nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY,
rewind_policy) != 0) {
return (1); return (1);
}
pool = argv[0]; pool = argv[0];
device = argc == 2 ? argv[1] : NULL; device = argc == 2 ? argv[1] : NULL;

2
include/libzfs.h
View File

@ -413,7 +413,7 @@ typedef struct importargs {
int unique : 1; /* does 'poolname' already exist? */ int unique : 1; /* does 'poolname' already exist? */
int exists : 1; /* set on return if pool already exists */ int exists : 1; /* set on return if pool already exists */
int scan : 1; /* prefer scanning to libblkid cache */ int scan : 1; /* prefer scanning to libblkid cache */
nvlist_t *policy; /* rewind policy (rewind txg, etc.) */ nvlist_t *policy; /* load policy (max txg, rewind, etc.) */
} importargs_t; } importargs_t;
extern nvlist_t *zpool_search_import(libzfs_handle_t *, importargs_t *); extern nvlist_t *zpool_search_import(libzfs_handle_t *, importargs_t *);

26
include/sys/fs/zfs.h
View File

@ -570,7 +570,7 @@ typedef enum zfs_key_location {
#define ZPL_VERSION_USERSPACE ZPL_VERSION_4 #define ZPL_VERSION_USERSPACE ZPL_VERSION_4
#define ZPL_VERSION_SA ZPL_VERSION_5 #define ZPL_VERSION_SA ZPL_VERSION_5
/* Rewind request information */ /* Rewind policy information */
#define ZPOOL_NO_REWIND 1 /* No policy - default behavior */ #define ZPOOL_NO_REWIND 1 /* No policy - default behavior */
#define ZPOOL_NEVER_REWIND 2 /* Do not search for best txg or rewind */ #define ZPOOL_NEVER_REWIND 2 /* Do not search for best txg or rewind */
#define ZPOOL_TRY_REWIND 4 /* Search for best txg, but do not rewind */ #define ZPOOL_TRY_REWIND 4 /* Search for best txg, but do not rewind */
@ -579,12 +579,12 @@ typedef enum zfs_key_location {
#define ZPOOL_REWIND_MASK 28 /* All the possible rewind bits */ #define ZPOOL_REWIND_MASK 28 /* All the possible rewind bits */
#define ZPOOL_REWIND_POLICIES 31 /* All the possible policy bits */ #define ZPOOL_REWIND_POLICIES 31 /* All the possible policy bits */
typedef struct zpool_rewind_policy { typedef struct zpool_load_policy {
uint32_t zrp_request; /* rewind behavior requested */ uint32_t zlp_rewind; /* rewind policy requested */
uint64_t zrp_maxmeta; /* max acceptable meta-data errors */ uint64_t zlp_maxmeta; /* max acceptable meta-data errors */
uint64_t zrp_maxdata; /* max acceptable data errors */ uint64_t zlp_maxdata; /* max acceptable data errors */
uint64_t zrp_txg; /* specific txg to load */ uint64_t zlp_txg; /* specific txg to load */
} zpool_rewind_policy_t; } zpool_load_policy_t;
/* /*
* The following are configuration names used in the nvlist describing a pool's * The following are configuration names used in the nvlist describing a pool's
@ -722,12 +722,12 @@ typedef struct zpool_rewind_policy {
#define ZPOOL_CONFIG_FRU "fru" #define ZPOOL_CONFIG_FRU "fru"
#define ZPOOL_CONFIG_AUX_STATE "aux_state" #define ZPOOL_CONFIG_AUX_STATE "aux_state"
/* Rewind policy parameters */ /* Pool load policy parameters */
#define ZPOOL_REWIND_POLICY "rewind-policy" #define ZPOOL_LOAD_POLICY "load-policy"
#define ZPOOL_REWIND_REQUEST "rewind-request" #define ZPOOL_LOAD_REWIND_POLICY "load-rewind-policy"
#define ZPOOL_REWIND_REQUEST_TXG "rewind-request-txg" #define ZPOOL_LOAD_REQUEST_TXG "load-request-txg"
#define ZPOOL_REWIND_META_THRESH "rewind-meta-thresh" #define ZPOOL_LOAD_META_THRESH "load-meta-thresh"
#define ZPOOL_REWIND_DATA_THRESH "rewind-data-thresh" #define ZPOOL_LOAD_DATA_THRESH "load-data-thresh"
/* Rewind data discovered */ /* Rewind data discovered */
#define ZPOOL_CONFIG_LOAD_TIME "rewind_txg_ts" #define ZPOOL_CONFIG_LOAD_TIME "rewind_txg_ts"

4
include/zfs_comutil.h
View File

@ -20,7 +20,7 @@
*/ */
/* /*
* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012 by Delphix. All rights reserved. * Copyright (c) 2012, 2017 by Delphix. All rights reserved.
*/ */
#ifndef _ZFS_COMUTIL_H #ifndef _ZFS_COMUTIL_H
@ -34,7 +34,7 @@ extern "C" {
#endif #endif
extern boolean_t zfs_allocatable_devs(nvlist_t *); extern boolean_t zfs_allocatable_devs(nvlist_t *);
extern void zpool_get_rewind_policy(nvlist_t *, zpool_rewind_policy_t *); extern void zpool_get_load_policy(nvlist_t *, zpool_load_policy_t *);
extern int zfs_zpl_version_map(int spa_version); extern int zfs_zpl_version_map(int spa_version);
extern int zfs_spa_version_map(int zpl_version); extern int zfs_spa_version_map(int zpl_version);

2
lib/libzfs/libzfs_import.c
View File

@ -1232,7 +1232,7 @@ get_configs(libzfs_handle_t *hdl, pool_list_t *pl, boolean_t active_ok,
} }
if (policy != NULL) { if (policy != NULL) {
if (nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY, if (nvlist_add_nvlist(config, ZPOOL_LOAD_POLICY,
policy) != 0) policy) != 0)
goto nomem; goto nomem;
} }

22
lib/libzfs/libzfs_pool.c
View File

@ -1746,7 +1746,7 @@ zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
nvlist_t *props, int flags) nvlist_t *props, int flags)
{ {
zfs_cmd_t zc = {"\0"}; zfs_cmd_t zc = {"\0"};
zpool_rewind_policy_t policy; zpool_load_policy_t policy;
nvlist_t *nv = NULL; nvlist_t *nv = NULL;
nvlist_t *nvinfo = NULL; nvlist_t *nvinfo = NULL;
nvlist_t *missing = NULL; nvlist_t *missing = NULL;
@ -1818,7 +1818,7 @@ zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
zcmd_free_nvlists(&zc); zcmd_free_nvlists(&zc);
zpool_get_rewind_policy(config, &policy); zpool_get_load_policy(config, &policy);
if (error) { if (error) {
char desc[1024]; char desc[1024];
@ -1828,7 +1828,7 @@ zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
* Dry-run failed, but we print out what success * Dry-run failed, but we print out what success
* looks like if we found a best txg * looks like if we found a best txg
*/ */
if (policy.zrp_request & ZPOOL_TRY_REWIND) { if (policy.zlp_rewind & ZPOOL_TRY_REWIND) {
zpool_rewind_exclaim(hdl, newname ? origname : thename, zpool_rewind_exclaim(hdl, newname ? origname : thename,
B_TRUE, nv); B_TRUE, nv);
nvlist_free(nv); nvlist_free(nv);
@ -1968,10 +1968,10 @@ zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
ret = -1; ret = -1;
else if (zhp != NULL) else if (zhp != NULL)
zpool_close(zhp); zpool_close(zhp);
if (policy.zrp_request & if (policy.zlp_rewind &
(ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) { (ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) {
zpool_rewind_exclaim(hdl, newname ? origname : thename, zpool_rewind_exclaim(hdl, newname ? origname : thename,
((policy.zrp_request & ZPOOL_TRY_REWIND) != 0), nv); ((policy.zlp_rewind & ZPOOL_TRY_REWIND) != 0), nv);
} }
nvlist_free(nv); nvlist_free(nv);
return (0); return (0);
@ -3341,7 +3341,7 @@ zpool_clear(zpool_handle_t *zhp, const char *path, nvlist_t *rewindnvl)
zfs_cmd_t zc = {"\0"}; zfs_cmd_t zc = {"\0"};
char msg[1024]; char msg[1024];
nvlist_t *tgt; nvlist_t *tgt;
zpool_rewind_policy_t policy; zpool_load_policy_t policy;
boolean_t avail_spare, l2cache; boolean_t avail_spare, l2cache;
libzfs_handle_t *hdl = zhp->zpool_hdl; libzfs_handle_t *hdl = zhp->zpool_hdl;
nvlist_t *nvi = NULL; nvlist_t *nvi = NULL;
@ -3373,8 +3373,8 @@ zpool_clear(zpool_handle_t *zhp, const char *path, nvlist_t *rewindnvl)
&zc.zc_guid) == 0); &zc.zc_guid) == 0);
} }
zpool_get_rewind_policy(rewindnvl, &policy); zpool_get_load_policy(rewindnvl, &policy);
zc.zc_cookie = policy.zrp_request; zc.zc_cookie = policy.zlp_rewind;
if (zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size * 2) != 0) if (zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size * 2) != 0)
return (-1); return (-1);
@ -3390,13 +3390,13 @@ zpool_clear(zpool_handle_t *zhp, const char *path, nvlist_t *rewindnvl)
} }
} }
if (!error || ((policy.zrp_request & ZPOOL_TRY_REWIND) && if (!error || ((policy.zlp_rewind & ZPOOL_TRY_REWIND) &&
errno != EPERM && errno != EACCES)) { errno != EPERM && errno != EACCES)) {
if (policy.zrp_request & if (policy.zlp_rewind &
(ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) { (ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) {
(void) zcmd_read_dst_nvlist(hdl, &zc, &nvi); (void) zcmd_read_dst_nvlist(hdl, &zc, &nvi);
zpool_rewind_exclaim(hdl, zc.zc_name, zpool_rewind_exclaim(hdl, zc.zc_name,
((policy.zrp_request & ZPOOL_TRY_REWIND) != 0), ((policy.zlp_rewind & ZPOOL_TRY_REWIND) != 0),
nvi); nvi);
nvlist_free(nvi); nvlist_free(nvi);
} }

42
module/zcommon/zfs_comutil.c
View File

@ -20,7 +20,7 @@
*/ */
/* /*
* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012 by Delphix. All rights reserved. * Copyright (c) 2012, 2017 by Delphix. All rights reserved.
*/ */
/* /*
@ -65,17 +65,17 @@ zfs_allocatable_devs(nvlist_t *nv)
} }
void void
zpool_get_rewind_policy(nvlist_t *nvl, zpool_rewind_policy_t *zrpp) zpool_get_load_policy(nvlist_t *nvl, zpool_load_policy_t *zlpp)
{ {
nvlist_t *policy; nvlist_t *policy;
nvpair_t *elem; nvpair_t *elem;
char *nm; char *nm;
/* Defaults */ /* Defaults */
zrpp->zrp_request = ZPOOL_NO_REWIND; zlpp->zlp_rewind = ZPOOL_NO_REWIND;
zrpp->zrp_maxmeta = 0; zlpp->zlp_maxmeta = 0;
zrpp->zrp_maxdata = UINT64_MAX; zlpp->zlp_maxdata = UINT64_MAX;
zrpp->zrp_txg = UINT64_MAX; zlpp->zlp_txg = UINT64_MAX;
if (nvl == NULL) if (nvl == NULL)
return; return;
@ -83,24 +83,24 @@ zpool_get_rewind_policy(nvlist_t *nvl, zpool_rewind_policy_t *zrpp)
elem = NULL; elem = NULL;
while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) { while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
nm = nvpair_name(elem); nm = nvpair_name(elem);
if (strcmp(nm, ZPOOL_REWIND_POLICY) == 0) { if (strcmp(nm, ZPOOL_LOAD_POLICY) == 0) {
if (nvpair_value_nvlist(elem, &policy) == 0) if (nvpair_value_nvlist(elem, &policy) == 0)
zpool_get_rewind_policy(policy, zrpp); zpool_get_load_policy(policy, zlpp);
return; return;
} else if (strcmp(nm, ZPOOL_REWIND_REQUEST) == 0) { } else if (strcmp(nm, ZPOOL_LOAD_REWIND_POLICY) == 0) {
if (nvpair_value_uint32(elem, &zrpp->zrp_request) == 0) if (nvpair_value_uint32(elem, &zlpp->zlp_rewind) == 0)
if (zrpp->zrp_request & ~ZPOOL_REWIND_POLICIES) if (zlpp->zlp_rewind & ~ZPOOL_REWIND_POLICIES)
zrpp->zrp_request = ZPOOL_NO_REWIND; zlpp->zlp_rewind = ZPOOL_NO_REWIND;
} else if (strcmp(nm, ZPOOL_REWIND_REQUEST_TXG) == 0) { } else if (strcmp(nm, ZPOOL_LOAD_REQUEST_TXG) == 0) {
(void) nvpair_value_uint64(elem, &zrpp->zrp_txg); (void) nvpair_value_uint64(elem, &zlpp->zlp_txg);
} else if (strcmp(nm, ZPOOL_REWIND_META_THRESH) == 0) { } else if (strcmp(nm, ZPOOL_LOAD_META_THRESH) == 0) {
(void) nvpair_value_uint64(elem, &zrpp->zrp_maxmeta); (void) nvpair_value_uint64(elem, &zlpp->zlp_maxmeta);
} else if (strcmp(nm, ZPOOL_REWIND_DATA_THRESH) == 0) { } else if (strcmp(nm, ZPOOL_LOAD_DATA_THRESH) == 0) {
(void) nvpair_value_uint64(elem, &zrpp->zrp_maxdata); (void) nvpair_value_uint64(elem, &zlpp->zlp_maxdata);
} }
} }
if (zrpp->zrp_request == 0) if (zlpp->zlp_rewind == 0)
zrpp->zrp_request = ZPOOL_NO_REWIND; zlpp->zlp_rewind = ZPOOL_NO_REWIND;
} }
typedef struct zfs_version_spa_map { typedef struct zfs_version_spa_map {
@ -206,7 +206,7 @@ const char *zfs_history_event_names[ZFS_NUM_LEGACY_HISTORY_EVENTS] = {
#if defined(_KERNEL) #if defined(_KERNEL)
EXPORT_SYMBOL(zfs_allocatable_devs); EXPORT_SYMBOL(zfs_allocatable_devs);
EXPORT_SYMBOL(zpool_get_rewind_policy); EXPORT_SYMBOL(zpool_get_load_policy);
EXPORT_SYMBOL(zfs_zpl_version_map); EXPORT_SYMBOL(zfs_zpl_version_map);
EXPORT_SYMBOL(zfs_spa_version_map); EXPORT_SYMBOL(zfs_spa_version_map);
EXPORT_SYMBOL(zfs_history_event_names); EXPORT_SYMBOL(zfs_history_event_names);

54
module/zfs/spa.c
View File

@ -2093,13 +2093,13 @@ spa_load_verify(spa_t *spa)
{ {
zio_t *rio; zio_t *rio;
spa_load_error_t sle = { 0 }; spa_load_error_t sle = { 0 };
zpool_rewind_policy_t policy; zpool_load_policy_t policy;
boolean_t verify_ok = B_FALSE; boolean_t verify_ok = B_FALSE;
int error = 0; int error = 0;
zpool_get_rewind_policy(spa->spa_config, &policy); zpool_get_load_policy(spa->spa_config, &policy);
if (policy.zrp_request & ZPOOL_NEVER_REWIND) if (policy.zlp_rewind & ZPOOL_NEVER_REWIND)
return (0); return (0);
dsl_pool_config_enter(spa->spa_dsl_pool, FTAG); dsl_pool_config_enter(spa->spa_dsl_pool, FTAG);
@ -2138,8 +2138,8 @@ spa_load_verify(spa_t *spa)
} }
if (spa_load_verify_dryrun || if (spa_load_verify_dryrun ||
(!error && sle.sle_meta_count <= policy.zrp_maxmeta && (!error && sle.sle_meta_count <= policy.zlp_maxmeta &&
sle.sle_data_count <= policy.zrp_maxdata)) { sle.sle_data_count <= policy.zlp_maxdata)) {
int64_t loss = 0; int64_t loss = 0;
verify_ok = B_TRUE; verify_ok = B_TRUE;
@ -3020,17 +3020,17 @@ spa_ld_load_trusted_config(spa_t *spa, spa_import_type_t type,
/* /*
* We will use spa_config if we decide to reload the spa or if spa_load * We will use spa_config if we decide to reload the spa or if spa_load
* fails and we rewind. We must thus regenerate the config using the * fails and we rewind. We must thus regenerate the config using the
* MOS information with the updated paths. Rewind policy is an import * MOS information with the updated paths. ZPOOL_LOAD_POLICY is used to
* setting and is not in the MOS. We copy it over to our new, trusted * pass settings on how to load the pool and is not stored in the MOS.
* config. * We copy it over to our new, trusted config.
*/ */
mos_config_txg = fnvlist_lookup_uint64(mos_config, mos_config_txg = fnvlist_lookup_uint64(mos_config,
ZPOOL_CONFIG_POOL_TXG); ZPOOL_CONFIG_POOL_TXG);
nvlist_free(mos_config); nvlist_free(mos_config);
mos_config = spa_config_generate(spa, NULL, mos_config_txg, B_FALSE); mos_config = spa_config_generate(spa, NULL, mos_config_txg, B_FALSE);
if (nvlist_lookup_nvlist(spa->spa_config, ZPOOL_REWIND_POLICY, if (nvlist_lookup_nvlist(spa->spa_config, ZPOOL_LOAD_POLICY,
&policy) == 0) &policy) == 0)
fnvlist_add_nvlist(mos_config, ZPOOL_REWIND_POLICY, policy); fnvlist_add_nvlist(mos_config, ZPOOL_LOAD_POLICY, policy);
spa_config_set(spa, mos_config); spa_config_set(spa, mos_config);
spa->spa_config_source = SPA_CONFIG_SRC_MOS; spa->spa_config_source = SPA_CONFIG_SRC_MOS;
@ -4082,13 +4082,13 @@ spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t *nvpolicy,
} }
if (spa->spa_state == POOL_STATE_UNINITIALIZED) { if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
zpool_rewind_policy_t policy; zpool_load_policy_t policy;
firstopen = B_TRUE; firstopen = B_TRUE;
zpool_get_rewind_policy(nvpolicy ? nvpolicy : spa->spa_config, zpool_get_load_policy(nvpolicy ? nvpolicy : spa->spa_config,
&policy); &policy);
if (policy.zrp_request & ZPOOL_DO_REWIND) if (policy.zlp_rewind & ZPOOL_DO_REWIND)
state = SPA_LOAD_RECOVER; state = SPA_LOAD_RECOVER;
spa_activate(spa, spa_mode_global); spa_activate(spa, spa_mode_global);
@ -4098,8 +4098,8 @@ spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t *nvpolicy,
spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE; spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE;
zfs_dbgmsg("spa_open_common: opening %s", pool); zfs_dbgmsg("spa_open_common: opening %s", pool);
error = spa_load_best(spa, state, policy.zrp_txg, error = spa_load_best(spa, state, policy.zlp_txg,
policy.zrp_request); policy.zlp_rewind);
if (error == EBADF) { if (error == EBADF) {
/* /*
@ -4960,7 +4960,7 @@ spa_import(char *pool, nvlist_t *config, nvlist_t *props, uint64_t flags)
spa_t *spa; spa_t *spa;
char *altroot = NULL; char *altroot = NULL;
spa_load_state_t state = SPA_LOAD_IMPORT; spa_load_state_t state = SPA_LOAD_IMPORT;
zpool_rewind_policy_t policy; zpool_load_policy_t policy;
uint64_t mode = spa_mode_global; uint64_t mode = spa_mode_global;
uint64_t readonly = B_FALSE; uint64_t readonly = B_FALSE;
int error; int error;
@ -5011,8 +5011,8 @@ spa_import(char *pool, nvlist_t *config, nvlist_t *props, uint64_t flags)
*/ */
spa_async_suspend(spa); spa_async_suspend(spa);
zpool_get_rewind_policy(config, &policy); zpool_get_load_policy(config, &policy);
if (policy.zrp_request & ZPOOL_DO_REWIND) if (policy.zlp_rewind & ZPOOL_DO_REWIND)
state = SPA_LOAD_RECOVER; state = SPA_LOAD_RECOVER;
spa->spa_config_source = SPA_CONFIG_SRC_TRYIMPORT; spa->spa_config_source = SPA_CONFIG_SRC_TRYIMPORT;
@ -5022,9 +5022,9 @@ spa_import(char *pool, nvlist_t *config, nvlist_t *props, uint64_t flags)
zfs_dbgmsg("spa_import: importing %s", pool); zfs_dbgmsg("spa_import: importing %s", pool);
} else { } else {
zfs_dbgmsg("spa_import: importing %s, max_txg=%lld " zfs_dbgmsg("spa_import: importing %s, max_txg=%lld "
"(RECOVERY MODE)", pool, (longlong_t)policy.zrp_txg); "(RECOVERY MODE)", pool, (longlong_t)policy.zlp_txg);
} }
error = spa_load_best(spa, state, policy.zrp_txg, policy.zrp_request); error = spa_load_best(spa, state, policy.zlp_txg, policy.zlp_rewind);
/* /*
* Propagate anything learned while loading the pool and pass it * Propagate anything learned while loading the pool and pass it
@ -5142,7 +5142,7 @@ spa_tryimport(nvlist_t *tryconfig)
spa_t *spa; spa_t *spa;
uint64_t state; uint64_t state;
int error; int error;
zpool_rewind_policy_t policy; zpool_load_policy_t policy;
if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname)) if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname))
return (NULL); return (NULL);
@ -5158,16 +5158,14 @@ spa_tryimport(nvlist_t *tryconfig)
spa_activate(spa, FREAD); spa_activate(spa, FREAD);
/* /*
* Rewind pool if a max txg was provided. Note that even though we * Rewind pool if a max txg was provided.
* retrieve the complete rewind policy, only the rewind txg is relevant
* for tryimport.
*/ */
zpool_get_rewind_policy(spa->spa_config, &policy); zpool_get_load_policy(spa->spa_config, &policy);
if (policy.zrp_txg != UINT64_MAX) { if (policy.zlp_txg != UINT64_MAX) {
spa->spa_load_max_txg = policy.zrp_txg; spa->spa_load_max_txg = policy.zlp_txg;
spa->spa_extreme_rewind = B_TRUE; spa->spa_extreme_rewind = B_TRUE;
zfs_dbgmsg("spa_tryimport: importing %s, max_txg=%lld", zfs_dbgmsg("spa_tryimport: importing %s, max_txg=%lld",
poolname, (longlong_t)policy.zrp_txg); poolname, (longlong_t)policy.zlp_txg);
} else { } else {
zfs_dbgmsg("spa_tryimport: importing %s", poolname); zfs_dbgmsg("spa_tryimport: importing %s", poolname);
} }