Home | History | Annotate | Download | only in sys
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License (the "License").
      6  * You may not use this file except in compliance with the License.
      7  *
      8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
      9  * or http://www.opensolaris.org/os/licensing.
     10  * See the License for the specific language governing permissions
     11  * and limitations under the License.
     12  *
     13  * When distributing Covered Code, include this CDDL HEADER in each
     14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     15  * If applicable, add the following below this CDDL HEADER, with the
     16  * fields enclosed by brackets "[]" replaced with your own identifying
     17  * information: Portions Copyright [yyyy] [name of copyright owner]
     18  *
     19  * CDDL HEADER END
     20  */
     21 /*
     22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
     23  * Use is subject to license terms.
     24  */
     25 
     26 #ifndef _SYS_SPA_IMPL_H
     27 #define	_SYS_SPA_IMPL_H
     28 
     29 #include <sys/spa.h>
     30 #include <sys/vdev.h>
     31 #include <sys/metaslab.h>
     32 #include <sys/dmu.h>
     33 #include <sys/dsl_pool.h>
     34 #include <sys/uberblock_impl.h>
     35 #include <sys/zfs_context.h>
     36 #include <sys/avl.h>
     37 #include <sys/refcount.h>
     38 #include <sys/bplist.h>
     39 
     40 #ifdef	__cplusplus
     41 extern "C" {
     42 #endif
     43 
     44 typedef struct spa_error_entry {
     45 	zbookmark_t	se_bookmark;
     46 	char		*se_name;
     47 	avl_node_t	se_avl;
     48 } spa_error_entry_t;
     49 
     50 typedef struct spa_history_phys {
     51 	uint64_t sh_pool_create_len;	/* ending offset of zpool create */
     52 	uint64_t sh_phys_max_off;	/* physical EOF */
     53 	uint64_t sh_bof;		/* logical BOF */
     54 	uint64_t sh_eof;		/* logical EOF */
     55 	uint64_t sh_records_lost;	/* num of records overwritten */
     56 } spa_history_phys_t;
     57 
     58 struct spa_aux_vdev {
     59 	uint64_t	sav_object;		/* MOS object for device list */
     60 	nvlist_t	*sav_config;		/* cached device config */
     61 	vdev_t		**sav_vdevs;		/* devices */
     62 	int		sav_count;		/* number devices */
     63 	boolean_t	sav_sync;		/* sync the device list */
     64 	nvlist_t	**sav_pending;		/* pending device additions */
     65 	uint_t		sav_npending;		/* # pending devices */
     66 };
     67 
     68 typedef struct spa_config_lock {
     69 	kmutex_t	scl_lock;
     70 	kthread_t	*scl_writer;
     71 	int		scl_write_wanted;
     72 	kcondvar_t	scl_cv;
     73 	refcount_t	scl_count;
     74 } spa_config_lock_t;
     75 
     76 typedef struct spa_config_dirent {
     77 	list_node_t	scd_link;
     78 	char		*scd_path;
     79 } spa_config_dirent_t;
     80 
     81 enum zio_taskq_type {
     82 	ZIO_TASKQ_ISSUE = 0,
     83 	ZIO_TASKQ_ISSUE_HIGH,
     84 	ZIO_TASKQ_INTERRUPT,
     85 	ZIO_TASKQ_INTERRUPT_HIGH,
     86 	ZIO_TASKQ_TYPES
     87 };
     88 
     89 /*
     90  * State machine for the zpool-pooname process.  The states transitions
     91  * are done as follows:
     92  *
     93  *	From		   To			Routine
     94  *	PROC_NONE	-> PROC_CREATED		spa_activate()
     95  *	PROC_CREATED	-> PROC_ACTIVE		spa_thread()
     96  *	PROC_ACTIVE	-> PROC_DEACTIVATE	spa_deactivate()
     97  *	PROC_DEACTIVATE	-> PROC_GONE		spa_thread()
     98  *	PROC_GONE	-> PROC_NONE		spa_deactivate()
     99  */
    100 typedef enum spa_proc_state {
    101 	SPA_PROC_NONE,		/* spa_proc = &p0, no process created */
    102 	SPA_PROC_CREATED,	/* spa_activate() has proc, is waiting */
    103 	SPA_PROC_ACTIVE,	/* taskqs created, spa_proc set */
    104 	SPA_PROC_DEACTIVATE,	/* spa_deactivate() requests process exit */
    105 	SPA_PROC_GONE		/* spa_thread() is exiting, spa_proc = &p0 */
    106 } spa_proc_state_t;
    107 
    108 struct spa {
    109 	/*
    110 	 * Fields protected by spa_namespace_lock.
    111 	 */
    112 	char		spa_name[MAXNAMELEN];	/* pool name */
    113 	avl_node_t	spa_avl;		/* node in spa_namespace_avl */
    114 	nvlist_t	*spa_config;		/* last synced config */
    115 	nvlist_t	*spa_config_syncing;	/* currently syncing config */
    116 	uint64_t	spa_config_txg;		/* txg of last config change */
    117 	int		spa_sync_pass;		/* iterate-to-convergence */
    118 	pool_state_t	spa_state;		/* pool state */
    119 	int		spa_inject_ref;		/* injection references */
    120 	uint8_t		spa_sync_on;		/* sync threads are running */
    121 	spa_load_state_t spa_load_state;	/* current load operation */
    122 	boolean_t	spa_load_verbatim;	/* load the given config? */
    123 	taskq_t		*spa_zio_taskq[ZIO_TYPES][ZIO_TASKQ_TYPES];
    124 	dsl_pool_t	*spa_dsl_pool;
    125 	metaslab_class_t *spa_normal_class;	/* normal data class */
    126 	metaslab_class_t *spa_log_class;	/* intent log data class */
    127 	uint64_t	spa_first_txg;		/* first txg after spa_open() */
    128 	uint64_t	spa_final_txg;		/* txg of export/destroy */
    129 	uint64_t	spa_freeze_txg;		/* freeze pool at this txg */
    130 	uint64_t	spa_load_max_txg;	/* best initial ub_txg */
    131 	uint64_t	spa_claim_max_txg;	/* highest claimed birth txg */
    132 	objset_t	*spa_meta_objset;	/* copy of dp->dp_meta_objset */
    133 	txg_list_t	spa_vdev_txg_list;	/* per-txg dirty vdev list */
    134 	vdev_t		*spa_root_vdev;		/* top-level vdev container */
    135 	uint64_t	spa_load_guid;		/* initial guid for spa_load */
    136 	list_t		spa_config_dirty_list;	/* vdevs with dirty config */
    137 	list_t		spa_state_dirty_list;	/* vdevs with dirty state */
    138 	spa_aux_vdev_t	spa_spares;		/* hot spares */
    139 	spa_aux_vdev_t	spa_l2cache;		/* L2ARC cache devices */
    140 	uint64_t	spa_config_object;	/* MOS object for pool config */
    141 	uint64_t	spa_config_generation;	/* config generation number */
    142 	uint64_t	spa_syncing_txg;	/* txg currently syncing */
    143 	uint64_t	spa_deferred_bplist_obj; /* object for deferred frees */
    144 	bplist_t	spa_deferred_bplist;	/* deferred-free bplist */
    145 	bplist_t	spa_free_bplist[TXG_SIZE]; /* bplist of stuff to free */
    146 	uberblock_t	spa_ubsync;		/* last synced uberblock */
    147 	uberblock_t	spa_uberblock;		/* current uberblock */
    148 	boolean_t	spa_extreme_rewind;	/* rewind past deferred frees */
    149 	kmutex_t	spa_scrub_lock;		/* resilver/scrub lock */
    150 	uint64_t	spa_scrub_inflight;	/* in-flight scrub I/Os */
    151 	uint64_t	spa_scrub_maxinflight;	/* max in-flight scrub I/Os */
    152 	uint64_t	spa_scrub_errors;	/* scrub I/O error count */
    153 	kcondvar_t	spa_scrub_io_cv;	/* scrub I/O completion */
    154 	uint8_t		spa_scrub_active;	/* active or suspended? */
    155 	uint8_t		spa_scrub_type;		/* type of scrub we're doing */
    156 	uint8_t		spa_scrub_finished;	/* indicator to rotate logs */
    157 	uint8_t		spa_scrub_started;	/* started since last boot */
    158 	uint8_t		spa_scrub_reopen;	/* scrub doing vdev_reopen */
    159 	kmutex_t	spa_async_lock;		/* protect async state */
    160 	kthread_t	*spa_async_thread;	/* thread doing async task */
    161 	int		spa_async_suspended;	/* async tasks suspended */
    162 	kcondvar_t	spa_async_cv;		/* wait for thread_exit() */
    163 	uint16_t	spa_async_tasks;	/* async task mask */
    164 	char		*spa_root;		/* alternate root directory */
    165 	uint64_t	spa_ena;		/* spa-wide ereport ENA */
    166 	int		spa_last_open_failed;	/* error if last open failed */
    167 	nvlist_t	*spa_failed_open_cfg;	/* cached config nvlist */
    168 	uint64_t	spa_last_ubsync_txg;	/* "best" uberblock txg */
    169 	uint64_t	spa_last_ubsync_txg_ts;	/* timestamp from that ub */
    170 	uint64_t	spa_load_txg;		/* ub txg that loaded */
    171 	uint64_t	spa_load_txg_ts;	/* timestamp from that ub */
    172 	uint64_t	spa_load_meta_errors;	/* verify metadata err count */
    173 	uint64_t	spa_load_data_errors;	/* verify data err count */
    174 	uint64_t	spa_verify_min_txg;	/* start txg of verify scrub */
    175 	kmutex_t	spa_errlog_lock;	/* error log lock */
    176 	uint64_t	spa_errlog_last;	/* last error log object */
    177 	uint64_t	spa_errlog_scrub;	/* scrub error log object */
    178 	kmutex_t	spa_errlist_lock;	/* error list/ereport lock */
    179 	avl_tree_t	spa_errlist_last;	/* last error list */
    180 	avl_tree_t	spa_errlist_scrub;	/* scrub error list */
    181 	uint64_t	spa_deflate;		/* should we deflate? */
    182 	uint64_t	spa_history;		/* history object */
    183 	kmutex_t	spa_history_lock;	/* history lock */
    184 	vdev_t		*spa_pending_vdev;	/* pending vdev additions */
    185 	kmutex_t	spa_props_lock;		/* property lock */
    186 	uint64_t	spa_pool_props_object;	/* object for properties */
    187 	uint64_t	spa_bootfs;		/* default boot filesystem */
    188 	uint64_t	spa_failmode;		/* failure mode for the pool */
    189 	uint64_t	spa_delegation;		/* delegation on/off */
    190 	list_t		spa_config_list;	/* previous cache file(s) */
    191 	zio_t		*spa_async_zio_root;	/* root of all async I/O */
    192 	zio_t		*spa_suspend_zio_root;	/* root of all suspended I/O */
    193 	kmutex_t	spa_suspend_lock;	/* protects suspend_zio_root */
    194 	kcondvar_t	spa_suspend_cv;		/* notification of resume */
    195 	uint8_t		spa_suspended;		/* pool is suspended */
    196 	uint8_t		spa_claiming;		/* pool is doing zil_claim() */
    197 	boolean_t	spa_is_root;		/* pool is root */
    198 	int		spa_minref;		/* num refs when first opened */
    199 	int		spa_mode;		/* FREAD | FWRITE */
    200 	spa_log_state_t spa_log_state;		/* log state */
    201 	uint64_t	spa_autoexpand;		/* lun expansion on/off */
    202 	ddt_t		*spa_ddt[ZIO_CHECKSUM_FUNCTIONS]; /* in-core DDTs */
    203 	uint64_t	spa_ddt_stat_object;	/* DDT statistics */
    204 	uint64_t	spa_dedup_ditto;	/* dedup ditto threshold */
    205 	uint64_t	spa_dedup_checksum;	/* default dedup checksum */
    206 	uint64_t	spa_dspace;		/* dspace in normal class */
    207 	kmutex_t	spa_vdev_top_lock;	/* dueling offline/remove */
    208 	kmutex_t	spa_proc_lock;		/* protects spa_proc* */
    209 	kcondvar_t	spa_proc_cv;		/* spa_proc_state transitions */
    210 	spa_proc_state_t spa_proc_state;	/* see definition */
    211 	struct proc	*spa_proc;		/* "zpool-poolname" process */
    212 	uint64_t	spa_did;		/* if procp != p0, did of t1 */
    213 	boolean_t	spa_autoreplace;	/* autoreplace set in open */
    214 	int		spa_vdev_locks;		/* locks grabbed */
    215 	/*
    216 	 * spa_refcnt & spa_config_lock must be the last elements
    217 	 * because refcount_t changes size based on compilation options.
    218 	 * In order for the MDB module to function correctly, the other
    219 	 * fields must remain in the same location.
    220 	 */
    221 	spa_config_lock_t spa_config_lock[SCL_LOCKS]; /* config changes */
    222 	refcount_t	spa_refcount;		/* number of opens */
    223 };
    224 
    225 extern const char *spa_config_path;
    226 
    227 #ifdef	__cplusplus
    228 }
    229 #endif
    230 
    231 #endif	/* _SYS_SPA_IMPL_H */
    232