Data Structures |
| struct | zio_eck |
| struct | zio_gbh |
| struct | zbookmark |
| | A bookmark is a four-tuple <objset, object, level, blkid> that uniquely identifies any block in the pool. More...
|
| struct | zio_prop |
| struct | zio_cksum_report |
| struct | zio_vsd_ops |
| struct | zio_gang_node |
| struct | zio_transform |
| struct | zio_link |
| struct | zio_trim_stats |
| struct | zio |
Defines |
| #define | ZEC_MAGIC 0x210da7ab10c7a11ULL |
| | Embedded checksum.
|
| #define | SPA_GANGBLOCKSIZE SPA_MINBLOCKSIZE |
| #define | SPA_GBH_NBLKPTRS |
| #define | SPA_GBH_FILLER |
| #define | ZIO_CHECKSUM_ON_VALUE ZIO_CHECKSUM_FLETCHER_4 |
| #define | ZIO_CHECKSUM_DEFAULT ZIO_CHECKSUM_ON |
| #define | ZIO_CHECKSUM_MASK 0xffULL |
| #define | ZIO_CHECKSUM_VERIFY (1 << 8) |
| #define | ZIO_DEDUPCHECKSUM ZIO_CHECKSUM_SHA256 |
| #define | ZIO_DEDUPDITTO_MIN 100 |
| #define | ZIO_COMPRESS_ON_VALUE ZIO_COMPRESS_LZJB |
| #define | ZIO_COMPRESS_DEFAULT ZIO_COMPRESS_OFF |
| #define | BOOTFS_COMPRESS_VALID(compress) |
| #define | ZIO_FAILURE_MODE_WAIT 0 |
| #define | ZIO_FAILURE_MODE_CONTINUE 1 |
| #define | ZIO_FAILURE_MODE_PANIC 2 |
| #define | ZIO_PRIORITY_NOW (zio_priority_table[0]) |
| #define | ZIO_PRIORITY_SYNC_READ (zio_priority_table[1]) |
| #define | ZIO_PRIORITY_SYNC_WRITE (zio_priority_table[2]) |
| #define | ZIO_PRIORITY_LOG_WRITE (zio_priority_table[3]) |
| #define | ZIO_PRIORITY_CACHE_FILL (zio_priority_table[4]) |
| #define | ZIO_PRIORITY_AGG (zio_priority_table[5]) |
| #define | ZIO_PRIORITY_FREE (zio_priority_table[6]) |
| #define | ZIO_PRIORITY_ASYNC_WRITE (zio_priority_table[7]) |
| #define | ZIO_PRIORITY_ASYNC_READ (zio_priority_table[8]) |
| #define | ZIO_PRIORITY_RESILVER (zio_priority_table[9]) |
| #define | ZIO_PRIORITY_SCRUB (zio_priority_table[10]) |
| #define | ZIO_PRIORITY_DDT_PREFETCH (zio_priority_table[11]) |
| #define | ZIO_PRIORITY_TRIM (zio_priority_table[12]) |
| #define | ZIO_PRIORITY_TABLE_SIZE 13 |
| #define | ZIO_PIPELINE_CONTINUE 0x100 |
| #define | ZIO_PIPELINE_STOP 0x101 |
| #define | ZIO_FLAG_AGG_INHERIT (ZIO_FLAG_CANFAIL - 1) |
| #define | ZIO_FLAG_DDT_INHERIT (ZIO_FLAG_IO_RETRY - 1) |
| #define | ZIO_FLAG_GANG_INHERIT (ZIO_FLAG_IO_RETRY - 1) |
| #define | ZIO_FLAG_VDEV_INHERIT (ZIO_FLAG_DONT_QUEUE - 1) |
| #define | ZIO_FLAG_MUSTSUCCEED 0 |
| #define | ZIO_DDT_CHILD_FLAGS(zio) |
| #define | ZIO_GANG_CHILD_FLAGS(zio) |
| #define | ZIO_VDEV_CHILD_FLAGS(zio) |
| #define | ECKSUM 122 |
| #define | EFRAGS 123 |
| #define | SET_BOOKMARK(zb, objset, object, level, blkid) |
| #define | ZB_DESTROYED_OBJSET (-1ULL) |
| #define | ZB_ROOT_OBJECT (0ULL) |
| #define | ZB_ROOT_LEVEL (-1LL) |
| #define | ZB_ROOT_BLKID (0ULL) |
| #define | ZB_ZIL_OBJECT (0ULL) |
| #define | ZB_ZIL_LEVEL (-2LL) |
| #define | ZB_IS_ZERO(zb) |
| #define | ZB_IS_ROOT(zb) |
| #define | ZIO_REEXECUTE_NOW 0x01 |
| | The io_reexecute flags are distinct from io_flags because the child must be able to propagate them to the parent.
|
| #define | ZIO_REEXECUTE_SUSPEND 0x02 |
| #define | ZIO_TRIM_STAT_INCR(stat, val) atomic_add_64(&zio_trim_stats.stat.value.ui64, (val)); |
| #define | ZIO_TRIM_STAT_BUMP(stat) ZIO_TRIM_STAT_INCR(stat, 1); |
Typedefs |
| typedef struct zio_eck | zio_eck_t |
| typedef struct zio_gbh | zio_gbh_phys_t |
| typedef void | zio_done_func_t (zio_t *zio) |
| typedef struct zbookmark | zbookmark_t |
| | A bookmark is a four-tuple <objset, object, level, blkid> that uniquely identifies any block in the pool.
|
| typedef struct zio_prop | zio_prop_t |
| typedef struct zio_cksum_report | zio_cksum_report_t |
| typedef void | zio_cksum_finish_f (zio_cksum_report_t *rep, const void *good_data) |
| typedef void | zio_cksum_free_f (void *cbdata, size_t size) |
| typedef void | zio_vsd_cksum_report_f (zio_t *zio, zio_cksum_report_t *zcr, void *arg) |
| typedef struct zio_vsd_ops | zio_vsd_ops_t |
| typedef struct zio_gang_node | zio_gang_node_t |
| typedef zio_t * | zio_gang_issue_func_t (zio_t *zio, blkptr_t *bp, zio_gang_node_t *gn, void *data) |
| typedef void | zio_transform_func_t (zio_t *zio, void *data, uint64_t size) |
| typedef struct zio_transform | zio_transform_t |
| typedef int | zio_pipe_stage_t (zio_t *zio) |
| typedef struct zio_link | zio_link_t |
| typedef struct zio_trim_stats | zio_trim_stats_t |
Enumerations |
| enum | zio_checksum {
ZIO_CHECKSUM_INHERIT = 0,
ZIO_CHECKSUM_ON,
ZIO_CHECKSUM_OFF,
ZIO_CHECKSUM_LABEL,
ZIO_CHECKSUM_GANG_HEADER,
ZIO_CHECKSUM_ZILOG,
ZIO_CHECKSUM_FLETCHER_2,
ZIO_CHECKSUM_FLETCHER_4,
ZIO_CHECKSUM_SHA256,
ZIO_CHECKSUM_ZILOG2,
ZIO_CHECKSUM_FUNCTIONS
} |
| enum | zio_compress {
ZIO_COMPRESS_INHERIT = 0,
ZIO_COMPRESS_ON,
ZIO_COMPRESS_OFF,
ZIO_COMPRESS_LZJB,
ZIO_COMPRESS_EMPTY,
ZIO_COMPRESS_GZIP_1,
ZIO_COMPRESS_GZIP_2,
ZIO_COMPRESS_GZIP_3,
ZIO_COMPRESS_GZIP_4,
ZIO_COMPRESS_GZIP_5,
ZIO_COMPRESS_GZIP_6,
ZIO_COMPRESS_GZIP_7,
ZIO_COMPRESS_GZIP_8,
ZIO_COMPRESS_GZIP_9,
ZIO_COMPRESS_ZLE,
ZIO_COMPRESS_FUNCTIONS
} |
| enum | zio_flag {
ZIO_FLAG_DONT_AGGREGATE = 1 << 0,
ZIO_FLAG_IO_REPAIR = 1 << 1,
ZIO_FLAG_SELF_HEAL = 1 << 2,
ZIO_FLAG_RESILVER = 1 << 3,
ZIO_FLAG_SCRUB = 1 << 4,
ZIO_FLAG_SCAN_THREAD = 1 << 5
} |
| enum | zio_child {
ZIO_CHILD_VDEV = 0,
ZIO_CHILD_GANG,
ZIO_CHILD_DDT,
ZIO_CHILD_LOGICAL,
ZIO_CHILD_TYPES
} |
| enum | zio_wait_type { ZIO_WAIT_READY = 0,
ZIO_WAIT_DONE,
ZIO_WAIT_TYPES
} |
Functions |
| zio_t * | zio_null (zio_t *pio, spa_t *spa, vdev_t *vd, zio_done_func_t *done, void *priv, enum zio_flag flags) |
| zio_t * | zio_root (spa_t *spa, zio_done_func_t *done, void *priv, enum zio_flag flags) |
| zio_t * | zio_read (zio_t *pio, spa_t *spa, const blkptr_t *bp, void *data, uint64_t size, zio_done_func_t *done, void *priv, int priority, enum zio_flag flags, const zbookmark_t *zb) |
| zio_t * | zio_write (zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, void *data, uint64_t size, const zio_prop_t *zp, zio_done_func_t *ready, zio_done_func_t *done, void *priv, int priority, enum zio_flag flags, const zbookmark_t *zb) |
| zio_t * | zio_rewrite (zio_t *pio, spa_t *spa, uint64_t txg, blkptr_t *bp, void *data, uint64_t size, zio_done_func_t *done, void *priv, int priority, enum zio_flag flags, zbookmark_t *zb) |
| void | zio_write_override (zio_t *zio, blkptr_t *bp, int copies) |
| void | zio_free (spa_t *spa, uint64_t txg, const blkptr_t *bp) |
| zio_t * | zio_claim (zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp, zio_done_func_t *done, void *priv, enum zio_flag flags) |
| zio_t * | zio_ioctl (zio_t *pio, spa_t *spa, vdev_t *vd, int cmd, uint64_t offset, uint64_t size, zio_done_func_t *done, void *priv, int priority, enum zio_flag flags) |
| zio_t * | zio_read_phys (zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size, void *data, int checksum, zio_done_func_t *done, void *priv, int priority, enum zio_flag flags, boolean_t labels) |
| zio_t * | zio_write_phys (zio_t *pio, vdev_t *vd, uint64_t offset, uint64_t size, void *data, int checksum, zio_done_func_t *done, void *priv, int priority, enum zio_flag flags, boolean_t labels) |
| zio_t * | zio_free_sync (zio_t *pio, spa_t *spa, uint64_t txg, const blkptr_t *bp, uint64_t size, enum zio_flag flags) |
| int | zio_alloc_zil (spa_t *spa, uint64_t txg, blkptr_t *new_bp, blkptr_t *old_bp, uint64_t size, boolean_t use_slog) |
| | Try to allocate an intent log block.
|
| void | zio_free_zil (spa_t *spa, uint64_t txg, blkptr_t *bp) |
| | Free an intent log block.
|
| void | zio_flush (zio_t *zio, vdev_t *vd) |
| zio_t * | zio_trim (zio_t *zio, spa_t *spa, vdev_t *vd, uint64_t offset, uint64_t size) |
| void | zio_shrink (zio_t *zio, uint64_t size) |
| int | zio_wait (zio_t *zio) |
| | Initiate I/O, either sync or async.
|
| void | zio_nowait (zio_t *zio) |
| void | zio_execute (zio_t *zio) |
| | Execute the I/O pipeline until one of the following occurs:
- the I/O completes
- the pipeline stalls waiting for dependent child I/Os
- the I/O issues, so we're waiting for an I/O completion interrupt
- the I/O is delegated by vdev-level caching or aggregation
- the I/O is deferred due to vdev-level queueing
- the I/O is handed off to another thread.
|
| void | zio_interrupt (zio_t *zio) |
| zio_t * | zio_walk_parents (zio_t *cio) |
| zio_t * | zio_walk_children (zio_t *pio) |
| zio_t * | zio_unique_parent (zio_t *cio) |
| void | zio_add_child (zio_t *pio, zio_t *cio) |
| void * | zio_buf_alloc (size_t size) |
| | Use zio_buf_alloc to allocate ZFS metadata.
|
| void | zio_buf_free (void *buf, size_t size) |
| void * | zio_data_buf_alloc (size_t size) |
| | Use zio_data_buf_alloc to allocate data.
|
| void | zio_data_buf_free (void *buf, size_t size) |
| void | zio_resubmit_stage_async (void *) |
| zio_t * | zio_vdev_child_io (zio_t *zio, blkptr_t *bp, vdev_t *vd, uint64_t offset, void *data, uint64_t size, int type, int priority, enum zio_flag flags, zio_done_func_t *done, void *priv) |
| | Create a child I/O to do some work for us.
|
| zio_t * | zio_vdev_delegated_io (vdev_t *vd, uint64_t offset, void *data, uint64_t size, int type, int priority, enum zio_flag flags, zio_done_func_t *done, void *priv) |
| void | zio_vdev_io_bypass (zio_t *zio) |
| void | zio_vdev_io_reissue (zio_t *zio) |
| void | zio_vdev_io_redone (zio_t *zio) |
| void | zio_checksum_verified (zio_t *zio) |
| | Called by RAID-Z to ensure we don't compute the checksum twice.
|
| int | zio_worst_error (int e1, int e2) |
| | Compare the severity of errors.
|
| enum zio_checksum | zio_checksum_select (enum zio_checksum child, enum zio_checksum parent) |
| enum zio_checksum | zio_checksum_dedup_select (spa_t *spa, enum zio_checksum child, enum zio_checksum parent) |
| enum zio_compress | zio_compress_select (enum zio_compress child, enum zio_compress parent) |
| void | zio_suspend (spa_t *spa, zio_t *zio) |
| int | zio_resume (spa_t *spa) |
| void | zio_resume_wait (spa_t *spa) |
| void | zio_init (void) |
| void | zio_fini (void) |
| int | zio_inject_fault (char *name, int flags, int *id, struct zinject_record *record) |
| | Create a new handler for the given record.
|
| int | zio_inject_list_next (int *id, char *name, size_t buflen, struct zinject_record *record) |
| | Returns the next record with an ID greater than that supplied to the function.
|
| int | zio_clear_fault (int id) |
| | Clear the fault handler with the given identifier, or return ENOENT if none exists.
|
| void | zio_handle_panic_injection (spa_t *spa, char *tag, uint64_t type) |
| | Panic the system when a config change happens in the function specified by tag.
|
| int | zio_handle_fault_injection (zio_t *zio, int error) |
| | Determine if the I/O in question should return failure.
|
| int | zio_handle_device_injection (vdev_t *vd, zio_t *zio, int error) |
| int | zio_handle_label_injection (zio_t *zio, int error) |
| | Determine if the zio is part of a label update and has an injection handler associated with that portion of the label.
|
| void | zio_handle_ignored_writes (zio_t *zio) |
| | Simulate hardware that ignores cache flushes.
|
| void | zfs_ereport_start_checksum (spa_t *spa, vdev_t *vd, struct zio *zio, uint64_t offset, uint64_t length, void *arg, struct zio_bad_cksum *info) |
| void | zfs_ereport_finish_checksum (zio_cksum_report_t *report, const void *good_data, const void *bad_data, boolean_t drop_if_identical) |
| void | zfs_ereport_send_interim_checksum (zio_cksum_report_t *report) |
| void | zfs_ereport_free_checksum (zio_cksum_report_t *report) |
| void | zfs_ereport_post_checksum (spa_t *spa, vdev_t *vd, struct zio *zio, uint64_t offset, uint64_t length, const void *good_data, const void *bad_data, struct zio_bad_cksum *info) |
| | If we have the good data in hand, this function can be used.
|
| void | spa_handle_ignored_writes (spa_t *spa) |
| | Called from spa_sync(), but primarily an injection handler.
|
| boolean_t | zbookmark_is_before (const struct dnode_phys *dnp, const zbookmark_t *zb1, const zbookmark_t *zb2) |
Variables |
| uint8_t | zio_priority_table [ZIO_PRIORITY_TABLE_SIZE] |
| | I/O priority table.
|
| char * | zio_type_name [ZIO_TYPES] |
| | I/O type descriptions.
|
| zio_vsd_cksum_report_f | zio_vsd_default_cksum_report |
| zio_trim_stats_t | zio_trim_stats |
| | See zio.h for more information about these fields.
|
| uint32_t | zio_injection_enabled |
1.7.3