sys/zfs_ioctl.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.
 */

#ifndef _SYS_ZFS_IOCTL_H
#define _SYS_ZFS_IOCTL_H

#include <sys/cred.h>
#include <sys/dmu.h>
#include <sys/zio.h>
#include <sys/dsl_deleg.h>
#include <sys/spa.h>
#include <sys/zfs_stat.h>

#ifdef _KERNEL
#include <sys/nvpair.h>
#endif  /* _KERNEL */

#ifdef  __cplusplus
extern "C" {
#endif

/*
 * Property values for snapdir
 */
#define ZFS_SNAPDIR_HIDDEN              0
#define ZFS_SNAPDIR_VISIBLE             1

/*
 * Field manipulation macros for the drr_versioninfo field of the
 * send stream header.
 */

typedef enum drr_headertype {
        DMU_SUBSTREAM = 0x1,
        DMU_COMPOUNDSTREAM = 0x2
} drr_headertype_t;

#define DMU_GET_STREAM_HDRTYPE(vi)      BF64_GET((vi), 0, 2)
#define DMU_SET_STREAM_HDRTYPE(vi, x)   BF64_SET((vi), 0, 2, x)

#define DMU_GET_FEATUREFLAGS(vi)        BF64_GET((vi), 2, 30)
#define DMU_SET_FEATUREFLAGS(vi, x)     BF64_SET((vi), 2, 30, x)

/*
 * Feature flags for zfs send streams (flags in drr_versioninfo)
 */

#define DMU_BACKUP_FEATURE_DEDUP        (0x1)
#define DMU_BACKUP_FEATURE_DEDUPPROPS   (0x2)
#define DMU_BACKUP_FEATURE_SA_SPILL     (0x4)

#define DMU_BACKUP_FEATURE_MASK (DMU_BACKUP_FEATURE_DEDUP | \
                DMU_BACKUP_FEATURE_DEDUPPROPS | DMU_BACKUP_FEATURE_SA_SPILL)

#define DMU_STREAM_SUPPORTED(x) (!((x) & ~DMU_BACKUP_FEATURE_MASK))

#define DMU_BACKUP_MAGIC 0x2F5bacbacULL

#define DRR_FLAG_CLONE          (1<<0)
#define DRR_FLAG_CI_DATA        (1<<1)

/*
 * flags in the drr_checksumflags field in the DRR_WRITE and
 * DRR_WRITE_BYREF blocks
 */
#define DRR_CHECKSUM_DEDUP      (1<<0)

#define DRR_IS_DEDUP_CAPABLE(flags)     ((flags) & DRR_CHECKSUM_DEDUP)

struct drr_begin {
        uint64_t drr_magic;
        uint64_t drr_versioninfo;
        uint64_t drr_creation_time;
        dmu_objset_type_t drr_type;
        uint32_t drr_flags;
        uint64_t drr_toguid;
        uint64_t drr_fromguid;
        char drr_toname[MAXNAMELEN];
};

struct drr_end {
        zio_cksum_t drr_checksum;
        uint64_t drr_toguid;
};

struct drr_object {
        uint64_t drr_object;
        dmu_object_type_t drr_type;
        dmu_object_type_t drr_bonustype;
        uint32_t drr_blksz;
        uint32_t drr_bonuslen;
        uint8_t drr_checksumtype;
        uint8_t drr_compress;
        uint8_t drr_pad[6];
        uint64_t drr_toguid;
};

struct drr_freeobjects {
        uint64_t drr_firstobj;
        uint64_t drr_numobjs;
        uint64_t drr_toguid;
};

struct drr_write {
        uint64_t drr_object;
        dmu_object_type_t drr_type;
        uint32_t drr_pad;
        uint64_t drr_offset;
        uint64_t drr_length;
        uint64_t drr_toguid;
        uint8_t drr_checksumtype;
        uint8_t drr_checksumflags;
        uint8_t drr_pad2[6];
        ddt_key_t drr_key; 
};

struct drr_free {
        uint64_t drr_object;
        uint64_t drr_offset;
        uint64_t drr_length;
        uint64_t drr_toguid;
};

struct drr_write_byref {
        uint64_t drr_object;
        uint64_t drr_offset;
        uint64_t drr_length;
        uint64_t drr_toguid;
        uint64_t drr_refguid;
        uint64_t drr_refobject;
        uint64_t drr_refoffset;
        uint8_t drr_checksumtype;
        uint8_t drr_checksumflags;
        uint8_t drr_pad2[6];
        ddt_key_t drr_key; 
};

struct drr_spill {
        uint64_t drr_object;
        uint64_t drr_length;
        uint64_t drr_toguid;
        uint64_t drr_pad[4]; 
};

typedef struct dmu_replay_record {
        enum {
                DRR_BEGIN, DRR_OBJECT, DRR_FREEOBJECTS,
                DRR_WRITE, DRR_FREE, DRR_END, DRR_WRITE_BYREF,
                DRR_SPILL, DRR_NUMTYPES
        } drr_type;
        uint32_t drr_payloadlen;
        union {
                struct drr_begin drr_begin;
                struct drr_end drr_end;
                struct drr_object drr_object;
                struct drr_freeobjects drr_freeobjects;
                struct drr_write drr_write;
                struct drr_free drr_free;
                struct drr_write_byref drr_write_byref;
                struct drr_spill drr_spill;
        } drr_u;
} dmu_replay_record_t;

typedef enum diff_type {
        DDR_NONE = 0x1,
        DDR_INUSE = 0x2,
        DDR_FREE = 0x4
} diff_type_t;

typedef struct dmu_diff_record {
        uint64_t ddr_type;
        uint64_t ddr_first;
        uint64_t ddr_last;
} dmu_diff_record_t;

typedef struct zinject_record {
        uint64_t        zi_objset;
        uint64_t        zi_object;
        uint64_t        zi_start;
        uint64_t        zi_end;
        uint64_t        zi_guid;
        uint32_t        zi_level;
        uint32_t        zi_error;
        uint64_t        zi_type;
        uint32_t        zi_freq;
        uint32_t        zi_failfast;
        char            zi_func[MAXNAMELEN];
        uint32_t        zi_iotype;
        int32_t         zi_duration;
        uint64_t        zi_timer;
} zinject_record_t;

#define ZINJECT_NULL            0x1
#define ZINJECT_FLUSH_ARC       0x2
#define ZINJECT_UNLOAD_SPA      0x4

typedef struct zfs_share {
        uint64_t        z_exportdata;
        uint64_t        z_sharedata;
        uint64_t        z_sharetype;    
        uint64_t        z_sharemax;  
} zfs_share_t;

typedef enum zfs_case {
        ZFS_CASE_SENSITIVE,
        ZFS_CASE_INSENSITIVE,
        ZFS_CASE_MIXED
} zfs_case_t;

typedef struct zfs_cmd {
        char            zc_name[MAXPATHLEN];
        char            zc_value[MAXPATHLEN * 2];
        char            zc_string[MAXNAMELEN];
        char            zc_top_ds[MAXPATHLEN];
        uint64_t        zc_guid;
        uint64_t        zc_nvlist_conf;         
        uint64_t        zc_nvlist_conf_size;
        uint64_t        zc_nvlist_src;          
        uint64_t        zc_nvlist_src_size;
        uint64_t        zc_nvlist_dst;          
        uint64_t        zc_nvlist_dst_size;
        uint64_t        zc_cookie;
        uint64_t        zc_objset_type;
        uint64_t        zc_perm_action;
        uint64_t        zc_history;             
        uint64_t        zc_history_len;
        uint64_t        zc_history_offset;
        uint64_t        zc_obj;
        uint64_t        zc_iflags;              
        zfs_share_t     zc_share;
        uint64_t        zc_jailid;
        dmu_objset_stats_t zc_objset_stats;
        struct drr_begin zc_begin_record;
        zinject_record_t zc_inject_record;
        boolean_t       zc_defer_destroy;
        boolean_t       zc_temphold;
        uint64_t        zc_action_handle;
        int             zc_cleanup_fd;
        uint8_t         zc_simple;
        uint8_t         zc_pad[3];              /* alignment */
        uint64_t        zc_sendobj;
        uint64_t        zc_fromobj;
        uint64_t        zc_createtxg;
        zfs_stat_t      zc_stat;
} zfs_cmd_t;

typedef struct zfs_useracct {
        char zu_domain[256];
        uid_t zu_rid;
        uint32_t zu_pad;
        uint64_t zu_space;
} zfs_useracct_t;

#define ZFSDEV_MAX_MINOR        (1 << 16)
#define ZFS_MIN_MINOR   (ZFSDEV_MAX_MINOR + 1)

#define ZPOOL_EXPORT_AFTER_SPLIT 0x1

#ifdef _KERNEL

typedef struct zfs_creat {
        nvlist_t        *zct_zplprops;
        nvlist_t        *zct_props;
} zfs_creat_t;

extern int zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr);
extern int zfs_secpolicy_rename_perms(const char *from,
    const char *to, cred_t *cr);
extern int zfs_secpolicy_destroy_perms(const char *name, cred_t *cr);
extern int zfs_busy(void);
extern int zfs_unmount_snap(const char *, void *);

enum zfs_soft_state_type {
        ZSST_ZVOL,
        ZSST_CTLDEV
};

typedef struct zfs_soft_state {
        enum zfs_soft_state_type zss_type;
        void *zss_data;
} zfs_soft_state_t;

extern void *zfsdev_get_soft_state(minor_t minor,
    enum zfs_soft_state_type which);
extern minor_t zfsdev_minor_alloc(void);

extern void *zfsdev_state;

#endif  /* _KERNEL */

#ifdef  __cplusplus
}
#endif

#endif  /* _SYS_ZFS_IOCTL_H */