Print this page 
NEX-19394 backport 9337 zfs get all is slow due to uncached metadata
Reviewed by: Joyce McIntosh <joyce.mcintosh@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Prakash Surya <prakash.surya@delphix.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Thomas Caputi <tcaputi@datto.com>
Approved by: Richard Lowe <richlowe@richlowe.net>
 Conflicts:
  usr/src/uts/common/fs/zfs/dbuf.c
  usr/src/uts/common/fs/zfs/dmu.c
  usr/src/uts/common/fs/zfs/sys/dmu_objset.h
NEX-3214 remove cos object type from dmu.h
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Josef 'Jeff' Sipek <josef.sipek@nexenta.com>
NEX-5366 Race between unique_insert() and unique_remove() causes ZFS fsid change
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Dan Vatca <dan.vatca@gmail.com>
NEX-5795 Rename 'wrc' as 'wbc' in the source and in the tech docs
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
NEX-5064 On-demand trim should store operation start and stop time
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
NEX-4934 Add capability to remove special vdev
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
4185 add new cryptographic checksums to ZFS: SHA-512, Skein, Edon-R (fix studio build)
4185 add new cryptographic checksums to ZFS: SHA-512, Skein, Edon-R
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Prakash Surya <prakash.surya@delphix.com>
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Richard Lowe <richlowe@richlowe.net>
Approved by: Garrett D'Amore <garrett@damore.org>
5987 zfs prefetch code needs work
Reviewed by: Adam Leventhal <ahl@delphix.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Paul Dagnelie <pcd@delphix.com>
Approved by: Gordon Ross <gordon.ross@nexenta.com>
NEX-4582 update wrc test cases for allow to use write back cache per tree of datasets
Reviewed by: Steve Peng <steve.peng@nexenta.com>
Reviewed by: Alex Aizman <alex.aizman@nexenta.com>
5960 zfs recv should prefetch indirect blocks
5925 zfs receive -o origin=
Reviewed by: Prakash Surya <prakash.surya@delphix.com>
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
5269 zpool import slow
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: George Wilson <george@delphix.com>
Reviewed by: Dan McDonald <danmcd@omniti.com>
Approved by: Dan McDonald <danmcd@omniti.com>
5692 expose the number of hole blocks in a file
Reviewed by: Adam Leventhal <ahl@delphix.com>
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Boris Protopopov <bprotopopov@hotmail.com>
Approved by: Richard Lowe <richlowe@richlowe.net>
NEX-3669 Faults for fans that don't exist
Reviewed by: Jeffry Molanus <jeffry.molanus@nexenta.com>
NEX-3891 Hide the snapshots that belong to in-kernel autosnap-service
Reviewed by: Josef 'Jeff' Sipek <josef.sipek@nexenta.com>
Reviewed by: Alek Pinchuk <alek@nexenta.com>
NEX-3558 KRRP Integration
NEX-3212 remove vdev prop object type from dmu.h
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Josef Sipek <josef.sipek@nexenta.com>
4370 avoid transmitting holes during zfs send
4371 DMU code clean up
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
Reviewed by: Christopher Siden <christopher.siden@delphix.com>
Reviewed by: Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
Approved by: Garrett D'Amore <garrett@damore.org>
OS-80 support for vdev and CoS properties for the new I/O scheduler
OS-95 lint warning introduced by OS-61
Issue #40: ZDB shouldn't crash with new code
Support for secondarycache=data option
Align mutex tables in arc.c and dbuf.c to 64 bytes (cache line), place each kmutex_t on cache line by itself to avoid false sharing
Fixup merge results
re #12585 rb4049 ZFS++ work port - refactoring to improve separation of open/closed code, bug fixes, performance improvements - open code
Bug 11205: add missing libzfs_closed_stubs.c to fix opensource-only build.
ZFS plus work: special vdevs, cos, cos/vdev properties
Bug 10481 - Dry run option in 'zfs send' isn't the same as in NexentaStor 3.1
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/fs/zfs/sys/dmu.h
          +++ new/usr/src/uts/common/fs/zfs/sys/dmu.h
↓ open down ↓ 14 lines elided ↑ open up ↑ 
  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  /*
  23   23   * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24   24   * Copyright (c) 2011, 2017 by Delphix. All rights reserved.
  25      - * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
       25 + * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
  26   26   * Copyright (c) 2012, Joyent, Inc. All rights reserved.
  27   27   * Copyright 2013 DEY Storage Systems, Inc.
  28   28   * Copyright 2014 HybridCluster. All rights reserved.
  29   29   * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
  30   30   * Copyright 2013 Saso Kiselkov. All rights reserved.
  31   31   * Copyright (c) 2014 Integros [integros.com]
  32   32   */
  33   33  
  34   34  /* Portions Copyright 2010 Robert Milkowski */
  35   35
↓ open down ↓ 66 lines elided ↑ open up ↑ 
 102  102          DMU_BSWAP_NUMFUNCS
 103  103  } dmu_object_byteswap_t;
 104  104  
 105  105  #define DMU_OT_NEWTYPE 0x80
 106  106  #define DMU_OT_METADATA 0x40
 107  107  #define DMU_OT_BYTESWAP_MASK 0x3f
 108  108  
 109  109  /*
 110  110   * Defines a uint8_t object type. Object types specify if the data
 111  111   * in the object is metadata (boolean) and how to byteswap the data
 112      - * (dmu_object_byteswap_t).
      112 + * (dmu_object_byteswap_t). All of the types created by this method
      113 + * are cached in the dbuf metadata cache.
 113  114   */
 114  115  #define DMU_OT(byteswap, metadata) \
 115  116          (DMU_OT_NEWTYPE | \
 116  117          ((metadata) ? DMU_OT_METADATA : 0) | \
 117  118          ((byteswap) & DMU_OT_BYTESWAP_MASK))
 118  119  
 119  120  #define DMU_OT_IS_VALID(ot) (((ot) & DMU_OT_NEWTYPE) ? \
 120  121          ((ot) & DMU_OT_BYTESWAP_MASK) < DMU_BSWAP_NUMFUNCS : \
 121  122          (ot) < DMU_OT_NUMTYPES)
 122  123  
 123  124  #define DMU_OT_IS_METADATA(ot) (((ot) & DMU_OT_NEWTYPE) ? \
 124  125          ((ot) & DMU_OT_METADATA) : \
 125  126          dmu_ot[(ot)].ot_metadata)
 126  127  
      128 +#define DMU_OT_IS_METADATA_CACHED(ot) (((ot) & DMU_OT_NEWTYPE) ? \
      129 +        B_TRUE : dmu_ot[(ot)].ot_dbuf_metadata_cache)
      130 +
 127  131  /*
 128  132   * These object types use bp_fill != 1 for their L0 bp's. Therefore they can't
 129  133   * have their data embedded (i.e. use a BP_IS_EMBEDDED() bp), because bp_fill
 130  134   * is repurposed for embedded BPs.
 131  135   */
 132  136  #define DMU_OT_HAS_FILL(ot) \
 133  137          ((ot) == DMU_OT_DNODE || (ot) == DMU_OT_OBJSET)
 134  138  
 135  139  #define DMU_OT_BYTESWAP(ot) (((ot) & DMU_OT_NEWTYPE) ? \
 136  140          ((ot) & DMU_OT_BYTESWAP_MASK) : \
↓ open down ↓ 87 lines elided ↑ open up ↑ 
 224  228          DMU_OTN_UINT16_DATA = DMU_OT(DMU_BSWAP_UINT16, B_FALSE),
 225  229          DMU_OTN_UINT16_METADATA = DMU_OT(DMU_BSWAP_UINT16, B_TRUE),
 226  230          DMU_OTN_UINT32_DATA = DMU_OT(DMU_BSWAP_UINT32, B_FALSE),
 227  231          DMU_OTN_UINT32_METADATA = DMU_OT(DMU_BSWAP_UINT32, B_TRUE),
 228  232          DMU_OTN_UINT64_DATA = DMU_OT(DMU_BSWAP_UINT64, B_FALSE),
 229  233          DMU_OTN_UINT64_METADATA = DMU_OT(DMU_BSWAP_UINT64, B_TRUE),
 230  234          DMU_OTN_ZAP_DATA = DMU_OT(DMU_BSWAP_ZAP, B_FALSE),
 231  235          DMU_OTN_ZAP_METADATA = DMU_OT(DMU_BSWAP_ZAP, B_TRUE),
 232  236  } dmu_object_type_t;
 233  237  
      238 +typedef enum txg_how {
      239 +        TXG_WAIT = 1,
      240 +        TXG_NOWAIT,
      241 +        TXG_WAITED,
      242 +} txg_how_t;
      243 +
 234  244  /*
 235      - * These flags are intended to be used to specify the "txg_how"
 236      - * parameter when calling the dmu_tx_assign() function. See the comment
 237      - * above dmu_tx_assign() for more details on the meaning of these flags.
      245 + * Selected classes of metadata
 238  246   */
 239      -#define TXG_NOWAIT      (0ULL)
 240      -#define TXG_WAIT        (1ULL<<0)
 241      -#define TXG_NOTHROTTLE  (1ULL<<1)
      247 +#define DMU_OT_IS_DDT_META(type)        \
      248 +        ((type == DMU_OT_DDT_ZAP) ||    \
      249 +        (type == DMU_OT_DDT_STATS))
 242  250  
      251 +#define DMU_OT_IS_ZPL_META(type)                \
      252 +        ((type == DMU_OT_ZNODE) ||              \
      253 +        (type == DMU_OT_OLDACL) ||              \
      254 +        (type == DMU_OT_DIRECTORY_CONTENTS) ||  \
      255 +        (type == DMU_OT_MASTER_NODE) ||         \
      256 +        (type == DMU_OT_UNLINKED_SET))
      257 +
 243  258  void byteswap_uint64_array(void *buf, size_t size);
 244  259  void byteswap_uint32_array(void *buf, size_t size);
 245  260  void byteswap_uint16_array(void *buf, size_t size);
 246  261  void byteswap_uint8_array(void *buf, size_t size);
 247  262  void zap_byteswap(void *buf, size_t size);
 248  263  void zfs_oldacl_byteswap(void *buf, size_t size);
 249  264  void zfs_acl_byteswap(void *buf, size_t size);
 250  265  void zfs_znode_byteswap(void *buf, size_t size);
 251  266  
 252  267  #define DS_FIND_SNAPSHOTS       (1<<0)
↓ open down ↓ 31 lines elided ↑ open up ↑ 
 284  299  int dmu_objset_clone(const char *name, const char *origin);
 285  300  int dsl_destroy_snapshots_nvl(struct nvlist *snaps, boolean_t defer,
 286  301      struct nvlist *errlist);
 287  302  int dmu_objset_snapshot_one(const char *fsname, const char *snapname);
 288  303  int dmu_objset_snapshot_tmp(const char *, const char *, int);
 289  304  int dmu_objset_find(char *name, int func(const char *, void *), void *arg,
 290  305      int flags);
 291  306  void dmu_objset_byteswap(void *buf, size_t size);
 292  307  int dsl_dataset_rename_snapshot(const char *fsname,
 293  308      const char *oldsnapname, const char *newsnapname, boolean_t recursive);
 294      -int dmu_objset_remap_indirects(const char *fsname);
 295  309  
 296  310  typedef struct dmu_buf {
 297  311          uint64_t db_object;             /* object that this buffer is part of */
 298  312          uint64_t db_offset;             /* byte offset in this object */
 299  313          uint64_t db_size;               /* size of buffer in bytes */
 300  314          void *db_data;                  /* data in buffer */
 301  315  } dmu_buf_t;
 302  316  
 303  317  /*
 304  318   * The names of zap entries in the DIRECTORY_OBJECT of the MOS.
↓ open down ↓ 16 lines elided ↑ open up ↑ 
 321  335  #define DMU_POOL_TMP_USERREFS           "tmp_userrefs"
 322  336  #define DMU_POOL_DDT                    "DDT-%s-%s-%s"
 323  337  #define DMU_POOL_DDT_STATS              "DDT-statistics"
 324  338  #define DMU_POOL_CREATION_VERSION       "creation_version"
 325  339  #define DMU_POOL_SCAN                   "scan"
 326  340  #define DMU_POOL_FREE_BPOBJ             "free_bpobj"
 327  341  #define DMU_POOL_BPTREE_OBJ             "bptree_obj"
 328  342  #define DMU_POOL_EMPTY_BPOBJ            "empty_bpobj"
 329  343  #define DMU_POOL_CHECKSUM_SALT          "org.illumos:checksum_salt"
 330  344  #define DMU_POOL_VDEV_ZAP_MAP           "com.delphix:vdev_zap_map"
 331      -#define DMU_POOL_REMOVING               "com.delphix:removing"
 332      -#define DMU_POOL_OBSOLETE_BPOBJ         "com.delphix:obsolete_bpobj"
 333      -#define DMU_POOL_CONDENSING_INDIRECT    "com.delphix:condensing_indirect"
 334  345  
      346 +#define DMU_POOL_COS_PROPS              "cos_props"
      347 +#define DMU_POOL_VDEV_PROPS             "vdev_props"
      348 +#define DMU_POOL_TRIM_START_TIME        "trim_start_time"
      349 +#define DMU_POOL_TRIM_STOP_TIME         "trim_stop_time"
      350 +
 335  351  /*
 336  352   * Allocate an object from this objset.  The range of object numbers
 337  353   * available is (0, DN_MAX_OBJECT).  Object 0 is the meta-dnode.
 338  354   *
 339  355   * The transaction must be assigned to a txg.  The newly allocated
 340  356   * object will be "held" in the transaction (ie. you can modify the
 341  357   * newly allocated object in this transaction).
 342  358   *
 343  359   * dmu_object_alloc() chooses an object and returns it in *objectp.
 344  360   *
↓ open down ↓ 62 lines elided ↑ open up ↑ 
 407  423  void dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum,
 408  424      dmu_tx_t *tx);
 409  425  
 410  426  /*
 411  427   * Set the compress property on a dnode.  The new compression algorithm will
 412  428   * apply to all newly written blocks; existing blocks will not be affected.
 413  429   */
 414  430  void dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress,
 415  431      dmu_tx_t *tx);
 416  432  
 417      -int dmu_object_remap_indirects(objset_t *os, uint64_t object, uint64_t txg);
 418      -
 419  433  void
 420  434  dmu_write_embedded(objset_t *os, uint64_t object, uint64_t offset,
 421  435      void *data, uint8_t etype, uint8_t comp, int uncompressed_size,
 422  436      int compressed_size, int byteorder, dmu_tx_t *tx);
 423  437  
 424  438  /*
 425  439   * Decide how to write a block: checksum, compression, number of copies, etc.
 426  440   */
 427  441  #define WP_NOFILL       0x1
 428  442  #define WP_DMU_SYNC     0x2
 429  443  #define WP_SPILL        0x4
 430  444  
      445 +#define WP_SPECIALCLASS_SHIFT   (16)
      446 +#define WP_SPECIALCLASS_BITS    (1) /* 1 bits per storage class */
      447 +#define WP_SPECIALCLASS_MASK    (((1 << WP_SPECIALCLASS_BITS) - 1) \
      448 +        << WP_SPECIALCLASS_SHIFT)
      449 +
      450 +#define WP_SET_SPECIALCLASS(flags, sclass)      { \
      451 +        flags |= ((sclass << WP_SPECIALCLASS_SHIFT) & WP_SPECIALCLASS_MASK); \
      452 +}
      453 +
      454 +#define WP_GET_SPECIALCLASS(flags) \
      455 +        ((flags & WP_SPECIALCLASS_MASK) >> WP_SPECIALCLASS_SHIFT)
      456 +
 431  457  void dmu_write_policy(objset_t *os, dnode_t *dn, int level, int wp,
 432  458      struct zio_prop *zp);
 433  459  /*
 434  460   * The bonus data is accessed more or less like a regular buffer.
 435  461   * You must dmu_bonus_hold() to get the buffer, which will give you a
 436  462   * dmu_buf_t with db_offset==-1ULL, and db_size = the size of the bonus
 437      - * data.  As with any normal buffer, you must call dmu_buf_will_dirty()
 438      - * before modifying it, and the
      463 + * data.  As with any normal buffer, you must call dmu_buf_read() to
      464 + * read db_data, dmu_buf_will_dirty() before modifying it, and the
 439  465   * object must be held in an assigned transaction before calling
 440  466   * dmu_buf_will_dirty.  You may use dmu_buf_set_user() on the bonus
 441  467   * buffer as well.  You must release your hold with dmu_buf_rele().
 442  468   *
 443  469   * Returns ENOENT, EIO, or 0.
 444  470   */
 445  471  int dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **);
 446  472  int dmu_bonus_max(void);
 447  473  int dmu_set_bonus(dmu_buf_t *, int, dmu_tx_t *);
 448  474  int dmu_set_bonustype(dmu_buf_t *, dmu_object_type_t, dmu_tx_t *);
↓ open down ↓ 196 lines elided ↑ open up ↑ 
 645  671  struct blkptr *dmu_buf_get_blkptr(dmu_buf_t *db);
 646  672  
 647  673  /*
 648  674   * Indicate that you are going to modify the buffer's data (db_data).
 649  675   *
 650  676   * The transaction (tx) must be assigned to a txg (ie. you've called
 651  677   * dmu_tx_assign()).  The buffer's object must be held in the tx
 652  678   * (ie. you've called dmu_tx_hold_object(tx, db->db_object)).
 653  679   */
 654  680  void dmu_buf_will_dirty(dmu_buf_t *db, dmu_tx_t *tx);
      681 +void dmu_buf_will_dirty_sc(dmu_buf_t *db, dmu_tx_t *tx, boolean_t sc);
 655  682  
 656  683  /*
 657  684   * You must create a transaction, then hold the objects which you will
 658  685   * (or might) modify as part of this transaction.  Then you must assign
 659  686   * the transaction to a transaction group.  Once the transaction has
 660  687   * been assigned, you can modify buffers which belong to held objects as
 661  688   * part of this transaction.  You can't modify buffers before the
 662  689   * transaction has been assigned; you can't modify buffers which don't
 663  690   * belong to objects which this transaction holds; you can't hold
 664  691   * objects once the transaction has been assigned.  You may hold an
↓ open down ↓ 10 lines elided ↑ open up ↑ 
 675  702  #define DMU_OBJECT_END  (-1ULL)
 676  703  
 677  704  dmu_tx_t *dmu_tx_create(objset_t *os);
 678  705  void dmu_tx_hold_write(dmu_tx_t *tx, uint64_t object, uint64_t off, int len);
 679  706  void dmu_tx_hold_write_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off,
 680  707      int len);
 681  708  void dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off,
 682  709      uint64_t len);
 683  710  void dmu_tx_hold_free_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off,
 684  711      uint64_t len);
 685      -void dmu_tx_hold_remap_l1indirect(dmu_tx_t *tx, uint64_t object);
 686  712  void dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name);
 687  713  void dmu_tx_hold_zap_by_dnode(dmu_tx_t *tx, dnode_t *dn, int add,
 688  714      const char *name);
 689  715  void dmu_tx_hold_bonus(dmu_tx_t *tx, uint64_t object);
 690  716  void dmu_tx_hold_bonus_by_dnode(dmu_tx_t *tx, dnode_t *dn);
 691  717  void dmu_tx_hold_spill(dmu_tx_t *tx, uint64_t object);
 692  718  void dmu_tx_hold_sa(dmu_tx_t *tx, struct sa_handle *hdl, boolean_t may_grow);
 693  719  void dmu_tx_hold_sa_create(dmu_tx_t *tx, int total_size);
 694  720  void dmu_tx_abort(dmu_tx_t *tx);
 695      -int dmu_tx_assign(dmu_tx_t *tx, uint64_t txg_how);
      721 +int dmu_tx_assign(dmu_tx_t *tx, enum txg_how txg_how);
 696  722  void dmu_tx_wait(dmu_tx_t *tx);
 697  723  void dmu_tx_commit(dmu_tx_t *tx);
 698  724  void dmu_tx_mark_netfree(dmu_tx_t *tx);
 699  725  
 700  726  /*
 701  727   * To register a commit callback, dmu_tx_callback_register() must be called.
 702  728   *
 703  729   * dcb_data is a pointer to caller private data that is passed on as a
 704  730   * callback parameter. The caller is responsible for properly allocating and
 705  731   * freeing it.
↓ open down ↓ 85 lines elided ↑ open up ↑ 
 791  817          uint64_t doi_physical_blocks_512;       /* data + metadata, 512b blks */
 792  818          uint64_t doi_max_offset;
 793  819          uint64_t doi_fill_count;                /* number of non-empty blocks */
 794  820  } dmu_object_info_t;
 795  821  
 796  822  typedef void arc_byteswap_func_t(void *buf, size_t size);
 797  823  
 798  824  typedef struct dmu_object_type_info {
 799  825          dmu_object_byteswap_t   ot_byteswap;
 800  826          boolean_t               ot_metadata;
      827 +        boolean_t               ot_dbuf_metadata_cache;
 801  828          char                    *ot_name;
 802  829  } dmu_object_type_info_t;
 803  830  
 804  831  typedef struct dmu_object_byteswap_info {
 805  832          arc_byteswap_func_t     *ob_func;
 806  833          char                    *ob_name;
 807  834  } dmu_object_byteswap_info_t;
 808  835  
 809  836  extern const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES];
 810  837  extern const dmu_object_byteswap_info_t dmu_ot_byteswap[DMU_BSWAP_NUMFUNCS];
↓ open down ↓ 16 lines elided ↑ open up ↑ 
 827  854   */
 828  855  void dmu_object_size_from_db(dmu_buf_t *db, uint32_t *blksize,
 829  856      u_longlong_t *nblk512);
 830  857  
 831  858  typedef struct dmu_objset_stats {
 832  859          uint64_t dds_num_clones; /* number of clones of this */
 833  860          uint64_t dds_creation_txg;
 834  861          uint64_t dds_guid;
 835  862          dmu_objset_type_t dds_type;
 836  863          uint8_t dds_is_snapshot;
      864 +        uint8_t dds_is_autosnapshot;
 837  865          uint8_t dds_inconsistent;
 838  866          char dds_origin[ZFS_MAX_DATASET_NAME_LEN];
 839  867  } dmu_objset_stats_t;
 840  868  
 841  869  /*
 842  870   * Get stats on a dataset.
 843  871   */
 844  872  void dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat);
 845  873  
 846  874  /*
↓ open down ↓ 33 lines elided ↑ open up ↑ 
 880  908  
 881  909  extern struct spa *dmu_objset_spa(objset_t *os);
 882  910  extern struct zilog *dmu_objset_zil(objset_t *os);
 883  911  extern struct dsl_pool *dmu_objset_pool(objset_t *os);
 884  912  extern struct dsl_dataset *dmu_objset_ds(objset_t *os);
 885  913  extern void dmu_objset_name(objset_t *os, char *buf);
 886  914  extern dmu_objset_type_t dmu_objset_type(objset_t *os);
 887  915  extern uint64_t dmu_objset_id(objset_t *os);
 888  916  extern zfs_sync_type_t dmu_objset_syncprop(objset_t *os);
 889  917  extern zfs_logbias_op_t dmu_objset_logbias(objset_t *os);
      918 +int dmu_clone_list_next(objset_t *os, int len, char *name,
      919 +    uint64_t *idp, uint64_t *offp);
 890  920  extern int dmu_snapshot_list_next(objset_t *os, int namelen, char *name,
 891  921      uint64_t *id, uint64_t *offp, boolean_t *case_conflict);
 892  922  extern int dmu_snapshot_realname(objset_t *os, char *name, char *real,
 893  923      int maxlen, boolean_t *conflict);
 894  924  extern int dmu_dir_list_next(objset_t *os, int namelen, char *name,
 895  925      uint64_t *idp, uint64_t *offp);
 896  926  
 897  927  typedef int objset_used_cb_t(dmu_object_type_t bonustype,
 898  928      void *bonus, uint64_t *userp, uint64_t *groupp);
 899  929  extern void dmu_objset_register_type(dmu_objset_type_t ost,
↓ open down ↓ 75 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX