2619 asynchronous destruction of ZFS file systems
2747 SPA versioning with zfs feature flags
Reviewed by: Matt Ahrens <mahrens@delphix.com>
Reviewed by: George Wilson <gwilson@delphix.com>
Reviewed by: Richard Lowe <richlowe@richlowe.net>
Reviewed by: Dan Kruchinin <dan.kruchinin@gmail.com>
Approved by: Dan McDonald <danmcd@nexenta.com>

          --- old/usr/src/uts/common/fs/zfs/sys/dsl_pool.h
          +++ new/usr/src/uts/common/fs/zfs/sys/dsl_pool.h

   1    1  /*
   2    2   * CDDL HEADER START
   3    3   *
   4    4   * The contents of this file are subject to the terms of the
   5    5   * Common Development and Distribution License (the "License").
   6    6   * You may not use this file except in compliance with the License.
   7    7   *
   8    8   * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9    9   * or http://www.opensolaris.org/os/licensing.
  10   10   * See the License for the specific language governing permissions
  11   11   * and limitations under the License.
  12   12   *

  13   13   * When distributing Covered Code, include this CDDL HEADER in each
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*
  22   22   * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
       23 + * Copyright (c) 2012 by Delphix. All rights reserved.
  23   24   */
  24   25  
  25   26  #ifndef _SYS_DSL_POOL_H
  26   27  #define _SYS_DSL_POOL_H
  27   28  
  28   29  #include <sys/spa.h>
  29   30  #include <sys/txg.h>
  30   31  #include <sys/txg_impl.h>
  31   32  #include <sys/zfs_context.h>
  32   33  #include <sys/zio.h>
  33   34  #include <sys/dnode.h>
  34   35  #include <sys/ddt.h>
  35   36  #include <sys/arc.h>
  36   37  #include <sys/bpobj.h>
       38 +#include <sys/bptree.h>
  37   39  
  38   40  #ifdef  __cplusplus
  39   41  extern "C" {
  40   42  #endif
  41   43  
  42   44  struct objset;
  43   45  struct dsl_dir;
  44   46  struct dsl_dataset;
  45   47  struct dsl_pool;
  46   48  struct dmu_tx;
  47   49  struct dsl_scan;
  48   50  
  49   51  /* These macros are for indexing into the zfs_all_blkstats_t. */
  50   52  #define DMU_OT_DEFERRED DMU_OT_NONE
  51      -#define DMU_OT_TOTAL    DMU_OT_NUMTYPES
       53 +#define DMU_OT_OTHER    DMU_OT_NUMTYPES /* place holder for DMU_OT() types */
       54 +#define DMU_OT_TOTAL    (DMU_OT_NUMTYPES + 1)
  52   55  
  53   56  typedef struct zfs_blkstat {
  54   57          uint64_t        zb_count;
  55   58          uint64_t        zb_asize;
  56   59          uint64_t        zb_lsize;
  57   60          uint64_t        zb_psize;
  58   61          uint64_t        zb_gangs;
  59   62          uint64_t        zb_ditto_2_of_2_samevdev;
  60   63          uint64_t        zb_ditto_2_of_3_samevdev;
  61   64          uint64_t        zb_ditto_3_of_3_samevdev;

  62   65  } zfs_blkstat_t;
  63   66  
  64   67  typedef struct zfs_all_blkstats {
  65   68          zfs_blkstat_t   zab_type[DN_MAX_LEVELS + 1][DMU_OT_TOTAL + 1];
  66   69  } zfs_all_blkstats_t;
  67   70  
  68   71  
  69   72  typedef struct dsl_pool {
  70   73          /* Immutable */
  71   74          spa_t *dp_spa;
  72   75          struct objset *dp_meta_objset;
  73   76          struct dsl_dir *dp_root_dir;
  74   77          struct dsl_dir *dp_mos_dir;
  75   78          struct dsl_dir *dp_free_dir;
  76   79          struct dsl_dataset *dp_origin_snap;
  77   80          uint64_t dp_root_dir_obj;

  78   81          struct taskq *dp_vnrele_taskq;
  79   82  
  80   83          /* No lock needed - sync context only */
  81   84          blkptr_t dp_meta_rootbp;
  82   85          list_t dp_synced_datasets;
  83   86          hrtime_t dp_read_overhead;
  84   87          uint64_t dp_throughput; /* bytes per millisec */
  85   88          uint64_t dp_write_limit;
  86   89          uint64_t dp_tmp_userrefs_obj;
  87   90          bpobj_t dp_free_bpobj;
       91 +        uint64_t dp_bptree_obj;
  88   92  
  89   93          struct dsl_scan *dp_scan;
  90   94  
  91   95          /* Uses dp_lock */
  92   96          kmutex_t dp_lock;
  93   97          uint64_t dp_space_towrite[TXG_SIZE];
  94   98          uint64_t dp_tempreserved[TXG_SIZE];
  95   99  
  96  100          /* Has its own locking */
  97  101          tx_state_t dp_tx;

  98  102          txg_list_t dp_dirty_datasets;
  99  103          txg_list_t dp_dirty_dirs;
 100  104          txg_list_t dp_sync_tasks;
 101  105  
 102  106          /*

 103  107           * Protects administrative changes (properties, namespace)
 104  108           * It is only held for write in syncing context.  Therefore
 105  109           * syncing context does not need to ever have it for read, since
 106  110           * nobody else could possibly have it for write.
 107  111           */
 108  112          krwlock_t dp_config_rwlock;
 109  113  
 110  114          zfs_all_blkstats_t *dp_blkstats;
 111  115  } dsl_pool_t;
 112  116  
 113      -int dsl_pool_open(spa_t *spa, uint64_t txg, dsl_pool_t **dpp);
      117 +int dsl_pool_init(spa_t *spa, uint64_t txg, dsl_pool_t **dpp);
      118 +int dsl_pool_open(dsl_pool_t *dp);
 114  119  void dsl_pool_close(dsl_pool_t *dp);
 115  120  dsl_pool_t *dsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg);
 116  121  void dsl_pool_sync(dsl_pool_t *dp, uint64_t txg);
 117  122  void dsl_pool_sync_done(dsl_pool_t *dp, uint64_t txg);
 118  123  int dsl_pool_sync_context(dsl_pool_t *dp);
 119  124  uint64_t dsl_pool_adjustedsize(dsl_pool_t *dp, boolean_t netfree);
 120  125  uint64_t dsl_pool_adjustedfree(dsl_pool_t *dp, boolean_t netfree);
 121  126  int dsl_pool_tempreserve_space(dsl_pool_t *dp, uint64_t space, dmu_tx_t *tx);
 122  127  void dsl_pool_tempreserve_clear(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx);
 123  128  void dsl_pool_memory_pressure(dsl_pool_t *dp);

 124  129  void dsl_pool_willuse_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx);
 125  130  void dsl_free(dsl_pool_t *dp, uint64_t txg, const blkptr_t *bpp);
 126  131  void dsl_free_sync(zio_t *pio, dsl_pool_t *dp, uint64_t txg,
 127  132      const blkptr_t *bpp);
 128  133  int dsl_read(zio_t *pio, spa_t *spa, const blkptr_t *bpp, arc_buf_t *pbuf,
 129  134      arc_done_func_t *done, void *private, int priority, int zio_flags,
 130  135      uint32_t *arc_flags, const zbookmark_t *zb);
 131  136  int dsl_read_nolock(zio_t *pio, spa_t *spa, const blkptr_t *bpp,
 132  137      arc_done_func_t *done, void *private, int priority, int zio_flags,
 133  138      uint32_t *arc_flags, const zbookmark_t *zb);
 134  139  void dsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx);
 135  140  void dsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx);
 136  141  void dsl_pool_upgrade_dir_clones(dsl_pool_t *dp, dmu_tx_t *tx);
 137  142  
 138  143  taskq_t *dsl_pool_vnrele_taskq(dsl_pool_t *dp);
 139  144  
 140  145  extern int dsl_pool_user_hold(dsl_pool_t *dp, uint64_t dsobj,
 141  146      const char *tag, uint64_t *now, dmu_tx_t *tx);
 142  147  extern int dsl_pool_user_release(dsl_pool_t *dp, uint64_t dsobj,
 143  148      const char *tag, dmu_tx_t *tx);
 144  149  extern void dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp);
 145  150  int dsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **);
 146  151  
 147  152  #ifdef  __cplusplus
 148  153  }
 149  154  #endif
 150  155  
 151  156  #endif /* _SYS_DSL_POOL_H */

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX