sys/spa_impl.h

Go to the documentation of this file.

/*
 * 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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2012 by Delphix. All rights reserved.
 * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
 */

#ifndef _SYS_SPA_IMPL_H
#define _SYS_SPA_IMPL_H

#include <sys/spa.h>
#include <sys/vdev.h>
#include <sys/metaslab.h>
#include <sys/dmu.h>
#include <sys/dsl_pool.h>
#include <sys/uberblock_impl.h>
#include <sys/zfs_context.h>
#include <sys/avl.h>
#include <sys/refcount.h>
#include <sys/bplist.h>
#include <sys/bpobj.h>

#ifdef  __cplusplus
extern "C" {
#endif

typedef struct spa_error_entry {
        zbookmark_t     se_bookmark;
        char            *se_name;
        avl_node_t      se_avl;
} spa_error_entry_t;

typedef struct spa_history_phys {
        uint64_t sh_pool_create_len;    
        uint64_t sh_phys_max_off;       
        uint64_t sh_bof;                
        uint64_t sh_eof;                
        uint64_t sh_records_lost;       
} spa_history_phys_t;

struct spa_aux_vdev {
        uint64_t        sav_object;             
        nvlist_t        *sav_config;            
        vdev_t          **sav_vdevs;            
        int             sav_count;              
        boolean_t       sav_sync;               
        nvlist_t        **sav_pending;          
        uint_t          sav_npending;           
};

typedef struct spa_config_lock {
        kmutex_t        scl_lock;
        kthread_t       *scl_writer;
        int             scl_write_wanted;
        kcondvar_t      scl_cv;
        refcount_t      scl_count;
} spa_config_lock_t;

typedef struct spa_config_dirent {
        list_node_t     scd_link;
        char            *scd_path;
} spa_config_dirent_t;

enum zio_taskq_type {
        ZIO_TASKQ_ISSUE = 0,
        ZIO_TASKQ_ISSUE_HIGH,
        ZIO_TASKQ_INTERRUPT,
        ZIO_TASKQ_INTERRUPT_HIGH,
        ZIO_TASKQ_TYPES
};

typedef enum spa_proc_state {
        SPA_PROC_NONE,          
        SPA_PROC_CREATED,       
        SPA_PROC_ACTIVE,        
        SPA_PROC_DEACTIVATE,    
        SPA_PROC_GONE           
} spa_proc_state_t;

struct spa {
        char            spa_name[MAXNAMELEN];   
        char            *spa_comment;           
        avl_node_t      spa_avl;                
        nvlist_t        *spa_config;            
        nvlist_t        *spa_config_syncing;    
        nvlist_t        *spa_config_splitting;  
        nvlist_t        *spa_load_info;         
        uint64_t        spa_config_txg;         
        int             spa_sync_pass;          
        pool_state_t    spa_state;              
        int             spa_inject_ref;         
        uint8_t         spa_sync_on;            
        spa_load_state_t spa_load_state;        
        uint64_t        spa_import_flags;       
        taskq_t         *spa_zio_taskq[ZIO_TYPES][ZIO_TASKQ_TYPES];
        dsl_pool_t      *spa_dsl_pool;
        boolean_t       spa_is_initializing;    
        metaslab_class_t *spa_normal_class;     
        metaslab_class_t *spa_log_class;        
        uint64_t        spa_first_txg;          
        uint64_t        spa_final_txg;          
        uint64_t        spa_freeze_txg;         
        uint64_t        spa_load_max_txg;       
        uint64_t        spa_claim_max_txg;      
        timespec_t      spa_loaded_ts;          
        objset_t        *spa_meta_objset;       
        txg_list_t      spa_vdev_txg_list;      
        vdev_t          *spa_root_vdev;         
        uint64_t        spa_config_guid;        
        uint64_t        spa_load_guid;          
        uint64_t        spa_last_synced_guid;   
        list_t          spa_config_dirty_list;  
        list_t          spa_state_dirty_list;   
        spa_aux_vdev_t  spa_spares;             
        spa_aux_vdev_t  spa_l2cache;            
        nvlist_t        *spa_label_features;    
        uint64_t        spa_config_object;      
        uint64_t        spa_config_generation;  
        uint64_t        spa_syncing_txg;        
        bpobj_t         spa_deferred_bpobj;     
        bplist_t        spa_free_bplist[TXG_SIZE]; 
        uberblock_t     spa_ubsync;             
        uberblock_t     spa_uberblock;          
        boolean_t       spa_extreme_rewind;     
        uint64_t        spa_last_io;            
        kmutex_t        spa_scrub_lock;         
        uint64_t        spa_scrub_inflight;     
        kcondvar_t      spa_scrub_io_cv;        
        uint8_t         spa_scrub_active;       
        uint8_t         spa_scrub_type;         
        uint8_t         spa_scrub_finished;     
        uint8_t         spa_scrub_started;      
        uint8_t         spa_scrub_reopen;       
        uint64_t        spa_scan_pass_start;    
        uint64_t        spa_scan_pass_exam;     
        kmutex_t        spa_async_lock;         
        kthread_t       *spa_async_thread;      
        int             spa_async_suspended;    
        kcondvar_t      spa_async_cv;           
        uint16_t        spa_async_tasks;        
        char            *spa_root;              
        uint64_t        spa_ena;                
        int             spa_last_open_failed;   
        uint64_t        spa_last_ubsync_txg;    
        uint64_t        spa_last_ubsync_txg_ts; 
        uint64_t        spa_load_txg;           
        uint64_t        spa_load_txg_ts;        
        uint64_t        spa_load_meta_errors;   
        uint64_t        spa_load_data_errors;   
        uint64_t        spa_verify_min_txg;     
        kmutex_t        spa_errlog_lock;        
        uint64_t        spa_errlog_last;        
        uint64_t        spa_errlog_scrub;       
        kmutex_t        spa_errlist_lock;       
        avl_tree_t      spa_errlist_last;       
        avl_tree_t      spa_errlist_scrub;      
        uint64_t        spa_deflate;            
        uint64_t        spa_history;            
        kmutex_t        spa_history_lock;       
        vdev_t          *spa_pending_vdev;      
        kmutex_t        spa_props_lock;         
        uint64_t        spa_pool_props_object;  
        uint64_t        spa_bootfs;             
        uint64_t        spa_failmode;           
        uint64_t        spa_delegation;         
        list_t          spa_config_list;        
        zio_t           *spa_async_zio_root;    
        zio_t           *spa_suspend_zio_root;  
        kmutex_t        spa_suspend_lock;       
        kcondvar_t      spa_suspend_cv;         
        uint8_t         spa_suspended;          
        uint8_t         spa_claiming;           
        boolean_t       spa_debug;              
        boolean_t       spa_is_root;            
        int             spa_minref;             
        int             spa_mode;               
        spa_log_state_t spa_log_state;          
        uint64_t        spa_autoexpand;         
        ddt_t           *spa_ddt[ZIO_CHECKSUM_FUNCTIONS]; 
        uint64_t        spa_ddt_stat_object;    
        uint64_t        spa_dedup_ditto;        
        uint64_t        spa_dedup_checksum;     
        uint64_t        spa_dspace;             
        kmutex_t        spa_vdev_top_lock;      
        kmutex_t        spa_proc_lock;          
        kcondvar_t      spa_proc_cv;            
        spa_proc_state_t spa_proc_state;        
        struct proc     *spa_proc;              
        uint64_t        spa_did;                
        kthread_t       *spa_trim_thread;       
        kmutex_t        spa_trim_lock;          
        kcondvar_t      spa_trim_cv;            
        boolean_t       spa_autoreplace;        
        int             spa_vdev_locks;         
        uint64_t        spa_creation_version;   
        uint64_t        spa_prev_software_version; 
        uint64_t        spa_feat_for_write_obj; 
        uint64_t        spa_feat_for_read_obj;  
        uint64_t        spa_feat_desc_obj;      
        int64_t         spa_ccw_fail_time;      
        /*
         * spa_refcount & spa_config_lock must be the last elements
         * because refcount_t changes size based on compilation options.
         * In order for the MDB module to function correctly, the other
         * fields must remain in the same location.
         */
        spa_config_lock_t spa_config_lock[SCL_LOCKS]; 
        refcount_t      spa_refcount;           
#ifndef sun
        boolean_t       spa_splitting_newspa;   
#endif

};

extern const char *spa_config_path;

#ifdef  __cplusplus
}
#endif

#endif  /* _SYS_SPA_IMPL_H */