/* * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015 by Delphix. All rights reserved. */ /* * BSD 3 Clause License * * Copyright (c) 2007, The Storage Networking Industry Association. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * - Neither the name of The Storage Networking Industry Association (SNIA) * nor the names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #ifndef _TLM_H_ #define _TLM_H_ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define IS_SET(f, m) (((f) & (m)) != 0) #define TLM_MAX_BACKUP_JOB_NAME 32 /* max size of a job's name */ #define TLM_TAPE_BUFFERS 10 /* number of rotating tape buffers */ #define TLM_LINE_SIZE 128 /* size of text messages */ #define TLM_BACKUP_RUN 0x00000001 #define TLM_RESTORE_RUN 0x00000002 #define TLM_STOP 0x00000009 /* graceful stop */ #define TLM_ABORT 0x99999999 /* abandon the run */ #define TLM_EXTRA_SPACE 64 #define TLM_MAX_PATH_NAME (PATH_MAX + TLM_EXTRA_SPACE) #define ENTRYTYPELEN 14 #define PERMS 4 #define ID_STR_MAX 20 #define APPENDED_ID_MAX (ID_STR_MAX + 1) #define ACL_ENTRY_SIZE (ENTRYTYPELEN + ID_STR_MAX + PERMS + APPENDED_ID_MAX) #define TLM_MAX_ACL_TXT MAX_ACL_ENTRIES * ACL_ENTRY_SIZE /* operation flags */ #define TLM_OP_CHOOSE_ARCHIVE 0x00000001 /* look for archive bit */ /* * Synchronization flags used when launching the TLM threads. */ #define TLM_TAPE_READER 0x00000001 #define TLM_TAPE_WRITER 0x00000002 #define TLM_SOCK_READER 0x00000004 #define TLM_SOCK_WRITER 0x00000008 #define TLM_BUF_READER 0x00000010 #define TLM_BUF_WRITER 0x00000020 #define TLM_TAR_READER 0x00000040 #define TLM_TAR_WRITER 0x00000080 #define SCSI_SERIAL_PAGE 0x80 #define SCSI_DEVICE_IDENT_PAGE 0x83 #define SCMD_READ_ELEMENT_STATUS 0xB8 #define OCTAL7CHAR 07777777 #define SYSATTR_RDONLY "SUNWattr_ro" #define SYSATTR_RW "SUNWattr_rw" typedef int (*func_t)(); typedef struct scsi_serial { int sr_flags; char sr_num[16]; } scsi_serial_t; typedef struct fs_fhandle { int fh_fid; char *fh_fpath; } fs_fhandle_t; typedef struct scsi_link { struct scsi_link *sl_next; struct scsi_link *sl_prev; struct scsi_adapter *sl_sa; unsigned int sl_sid; unsigned int sl_lun; unsigned int sl_requested_max_active; unsigned int sl_granted_max_active; unsigned int sl_n_active; unsigned int sl_type; /* SCSI device type */ } scsi_link_t; typedef struct scsi_adapter { struct scsi_adapter *sa_next; char sa_name[16]; struct scsi_link sa_link_head; } scsi_adapter_t; typedef struct sasd_drive { char sd_name[256]; char sd_vendor[8 + 1]; char sd_id[16 + 1]; char sd_rev[4 + 1]; char sd_serial[16 + 1]; char sd_wwn[32 + 1]; } sasd_drive_t; typedef struct scsi_sasd_drive { sasd_drive_t ss_sd; scsi_link_t ss_slink; } scsi_sasd_drive_t; #define DEFAULT_SLINK_MAX_XFER (64*1024) typedef struct tlm_info { int ti_init_done; /* initialization done ? */ int ti_library_count; /* number of libraries */ struct tlm_library *ti_library; /* first in chain */ struct tlm_chain_link *ti_job_stats; /* chain of job statistics */ } tlm_info_t; typedef struct tlm_chain_link { struct tlm_chain_link *tc_next; /* next blob of statistics */ struct tlm_chain_link *tc_prev; /* previous blob in the chain */ int tc_ref_count; /* number of routines */ void *tc_data; /* the data blob */ } tlm_chain_link_t; typedef struct tlm_robot { struct tlm_robot *tr_next; struct tlm_library *tr_library; int tr_number; } tlm_robot_t; typedef struct tlm_drive { struct tlm_drive *td_next; struct tlm_library *td_library; char td_job_name[TLM_MAX_BACKUP_JOB_NAME]; int td_number; /* number of this tape drive */ int td_element; /* the library's number for the drive */ struct scsi_link *td_slink; /* because the drive may be connected */ /* to a different SCSI card than the */ /* library */ short td_scsi_id; short td_lun; short td_volume_number; /* for current job */ /* an index into the tape set */ int td_fd; /* I/O file descriptor */ int td_errno; /* system error number */ long td_exists : 1; } tlm_drive_t; typedef struct tlm_slot { struct tlm_slot *ts_next; struct tlm_library *ts_library; int ts_number; /* number of this slot */ int ts_element; short ts_use_count; /* number of times used since loaded */ long ts_status_full : 1; } tlm_slot_t; typedef struct tlm_library { struct tlm_library *tl_next; int tl_number; /* number of this tape library */ long tl_capability_robot : 1, tl_capability_door : 1, tl_capability_lock : 1, tl_capability_slots : 1, tl_capability_export : 1, tl_capability_drives : 1, tl_capability_barcodes : 1, tl_ghost_drives : 1; /* * "ghost_drives" is used to make sure that * all drives claimed by the library really * exist ... libraries have been known to lie. */ struct scsi_link *tl_slink; int tl_robot_count; tlm_robot_t *tl_robot; int tl_drive_count; tlm_drive_t *tl_drive; int tl_slot_count; tlm_slot_t *tl_slot; } tlm_library_t; typedef struct { #ifdef _BIG_ENDIAN uint8_t di_peripheral_qual : 3, di_peripheral_dev_type : 5; uint8_t di_page_code; uint16_t di_page_length; #else uint8_t di_peripheral_dev_type : 5, di_peripheral_qual : 3; uint8_t di_page_code; uint16_t di_page_length; #endif } device_ident_header_t; typedef struct { #ifdef _BIG_ENDIAN uint8_t ni_proto_ident : 4, ni_code_set : 4; uint8_t ni_PIV : 1, : 1, ni_asso : 2, ni_ident_type : 4; uint8_t ni_reserved; uint8_t ni_ident_length; #else uint8_t ni_code_set : 4, ni_proto_ident : 4; uint8_t ni_ident_type : 4, ni_asso : 2, : 1, ni_PIV : 1; uint8_t ni_reserved; uint8_t ni_ident_length; #endif } name_ident_t; #define TLM_NO_ERRORS 0x00000000 #define TLM_ERROR_BUSY 0x00000001 #define TLM_ERROR_INTERNAL 0x00000002 #define TLM_ERROR_NO_ROBOTS 0x00000003 #define TLM_TIMEOUT 0x00000004 #define TLM_ERROR_RANGE 0x00000005 #define TLM_EMPTY 0x00000006 #define TLM_DRIVE_NOT_ASSIGNED 0x00000007 #define TLM_NO_TAPE_NAME 0x00000008 #define TLM_NO_BACKUP_DIR 0x00000009 #define TLM_NO_BACKUP_HARDWARE 0x0000000a #define TLM_NO_SOURCE_FILE 0x0000000b #define TLM_NO_FREE_TAPES 0x0000000c #define TLM_EOT 0x0000000d #define TLM_SERIAL_NOT_FOUND 0x0000000e #define TLM_SMALL_READ 0x0000000f #define TLM_NO_RESTORE_FILE 0x00000010 #define TLM_EOF 0x00000011 #define TLM_NO_DIRECTORY 0x00000012 #define TLM_NO_MEMORY 0x00000013 #define TLM_WRITE_ERROR 0x00000014 #define TLM_NO_SCRATCH_SPACE 0x00000015 #define TLM_INVALID 0x00000016 #define TLM_MOVE 0x00000017 #define TLM_SKIP 0x00000018 #define TLM_OPEN_ERR 0x00000019 #define TLM_MAX_TAPE_DRIVES 16 #define TLM_NAME_SIZE 100 #define TLM_MAX_TAR_IMAGE 017777777770 #define TLM_VOLNAME_MAX_LENGTH 255 #define NAME_MAX 255 #define TLM_MAGIC "ustar " #define TLM_SNAPSHOT_PREFIX ".zfs" #define TLM_SNAPSHOT_DIR ".zfs/snapshot" #define RECORDSIZE 512 #define NAMSIZ 100 typedef struct tlm_tar_hdr { char th_name[TLM_NAME_SIZE]; char th_mode[8]; char th_uid[8]; char th_gid[8]; char th_size[12]; char th_mtime[12]; char th_chksum[8]; char th_linkflag; char th_linkname[TLM_NAME_SIZE]; char th_magic[8]; char th_uname[32]; char th_gname[32]; union { struct { char th_devmajor[8]; char th_devminor[8]; } th_dev; char th_hlink_ino[12]; } th_shared; } tlm_tar_hdr_t; /* * The linkflag defines the type of file */ #define LF_OLDNORMAL '\0' /* Normal disk file, Unix compat */ #define LF_NORMAL '0' /* Normal disk file */ #define LF_LINK '1' /* Link to previously dumped file */ #define LF_SYMLINK '2' /* Symbolic link */ #define LF_CHR '3' /* Character special file */ #define LF_BLK '4' /* Block special file */ #define LF_DIR '5' /* Directory */ #define LF_FIFO '6' /* FIFO special file */ #define LF_CONTIG '7' /* Contiguous file */ /* Further link types may be defined later. */ #define LF_DUMPDIR 'D' /* * This is a dir entry that contains * the names of files that were in * the dir at the time the dump * was made */ #define LF_HUMONGUS 'H' /* * Identifies the NEXT file on the tape * as a HUGE file */ #define LF_LONGLINK 'K' /* * Identifies the NEXT file on the tape * as having a long linkname */ #define LF_LONGNAME 'L' /* * Identifies the NEXT file on the tape * as having a long name. */ #define LF_MULTIVOL 'M' /* * This is the continuation * of a file that began on another * volume */ #define LF_VOLHDR 'V' /* This file is a tape/volume header */ /* Ignore it on extraction */ #define LF_ACL 'A' /* Access Control List */ #define LF_XATTR 'E' /* Extended attribute */ #define KILOBYTE 1024 /* * ACL support structure */ typedef struct sec_attr { char attr_type; char attr_len[7]; char attr_info[TLM_MAX_ACL_TXT]; } sec_attr_t; typedef struct tlm_acls { int acl_checkpointed : 1, /* are checkpoints active ? */ acl_clear_archive : 1, /* clear archive bit ? */ acl_overwrite : 1, /* always overwrite ? */ acl_update : 1, /* only update ? */ acl_non_trivial : 1; /* real ACLs? */ /* * The following fields are here to allow * the backup reader to open a file one time * and keep the information for ACL, ATTRs, * and reading the file. */ sec_attr_t acl_info; char acl_root_dir[TLM_VOLNAME_MAX_LENGTH]; /* name of root filesystem */ fs_fhandle_t acl_dir_fh; /* parent dir's info */ fs_fhandle_t acl_fil_fh; /* file's info */ struct stat64 acl_attr; /* file system attributes */ char uname[32]; char gname[32]; } tlm_acls_t; /* * Tape manager's data archiving ops vector * * This vector represents the granular operations for * performing backup/restore. Each backend should provide * such a vector interface in order to be invoked by NDMP * server. * The reserved callbacks are kept for different backup * types which are volume-based rather than file-based * e.g. zfs send. */ typedef struct tm_ops { char *tm_name; int (*tm_putfile)(); int (*tm_putdir)(); int (*tm_putvol)(); /* Reserved */ void * (*tm_getfile)(void *); int (*tm_getdir)(); int (*tm_getvol)(); /* Reserved */ } tm_ops_t; /* The checksum field is filled with this while the checksum is computed. */ #define CHKBLANKS " " /* 8 blanks, no null */ #define LONGNAME_PREFIX "././_LoNg_NaMe_" extern void ndmp_log(ulong_t, char *, char *, ...); extern char ndmp_log_info[256]; #define NDMP_LOG(p, ...) { \ (void) snprintf(ndmp_log_info, \ sizeof (ndmp_log_info), \ "[%d][%s:%d]", \ (int)pthread_self(), __func__, __LINE__); \ ndmp_log(p, ndmp_log_info, __VA_ARGS__); \ } extern void *ndmp_malloc(size_t size); /* * ZFS metadata plug-in module structures */ #define ZFS_MAX_PROPS 100 #define ZFS_META_MAGIC "ZFSMETA" #define ZFS_META_MAGIC_EXT "ZFSMETA2" /* Add new major/minor for header changes */ typedef enum { META_HDR_MAJOR_0, /* Original format */ META_HDR_MAJOR_1, /* Extended format */ } ndmp_metadata_header_major_t; #define META_HDR_MAJOR_VERSION META_HDR_MAJOR_1 typedef enum { META_HDR_MINOR_0, } ndmp_metadata_header_minor_t; #define META_HDR_MINOR_VERSION META_HDR_MINOR_0 /* To support older backups */ typedef struct ndmp_metadata_property { char mp_name[NAME_MAX]; char mp_value[NAME_MAX]; char mp_source[NAME_MAX]; } ndmp_metadata_property_t; typedef struct ndmp_metadata_property_ext { char mp_name[ZFS_MAX_DATASET_NAME_LEN]; char mp_value[ZFS_MAXPROPLEN]; char mp_source[ZFS_MAXPROPLEN]; } ndmp_metadata_property_ext_t; typedef struct ndmp_metadata_top_header { char th_plname[100]; uint_t th_plversion; char th_magic[10]; void *th_reserved_1; int th_count; } ndmp_metadata_top_header_t; /* Original metadata format */ typedef struct ndmp_metadata_header { ndmp_metadata_top_header_t nh_hdr; char nh_dataset[NAME_MAX]; ndmp_metadata_property_t nh_property[1]; } ndmp_metadata_header_t; /* Extended metadata format */ typedef struct ndmp_metadata_header_ext { ndmp_metadata_top_header_t nh_hdr; char nh_dataset[ZFS_MAX_DATASET_NAME_LEN]; int32_t nh_total_bytes; int32_t nh_major; int32_t nh_minor; ndmp_metadata_property_ext_t nh_property[1]; } ndmp_metadata_header_ext_t; #define nh_plname nh_hdr.th_plname #define nh_plversion nh_hdr.th_plversion #define nh_magic nh_hdr.th_magic #define nh_count nh_hdr.th_count typedef struct ndmp_metadata_handle { void *ml_handle; int32_t ml_quota_prop; union { ndmp_metadata_header_t *u_hdr; ndmp_metadata_header_ext_t *u_xhdr; } ml_hdr_u; } ndmp_metadata_handle_t; #define ml_hdr ml_hdr_u.u_hdr #define ml_xhdr ml_hdr_u.u_xhdr /* * Node in struct hardlink_q * * inode: the inode of the hardlink * path: the name of the hardlink, used during restore * offset: tape offset of the data records for the hardlink, used during backup * is_tmp: indicate whether the file was created temporarily for restoring * other links during a non-DAR partial restore */ struct hardlink_node { unsigned long inode; char *path; unsigned long long offset; int is_tmp; SLIST_ENTRY(hardlink_node) next_hardlink; }; /* * Hardlinks that have been backed up or restored. * * During backup, each node represents a file whose * (1) inode has multiple links * (2) data has been backed up * * When we run into a file with multiple links during backup, * we first check the list to see whether a file with the same inode * has been backed up. If yes, we backup an empty record, while * making the file history of this file contain the data offset * of the offset of the file that has been backed up. If no, * we backup this file, and add an entry to the list. * * During restore, each node represents an LF_LINK type record whose * data has been restored (v.s. a hard link has been created). * * During restore, when we run into a record of LF_LINK type, we * first check the queue to see whether a file with the same inode * has been restored. If yes, we create a hardlink to it. * If no, we restore the data, and add an entry to the list. */ struct hardlink_q { struct hardlink_node *slh_first; }; /* Utility functions from handling hardlink */ extern struct hardlink_q *hardlink_q_init(); extern void hardlink_q_cleanup(struct hardlink_q *qhead); extern int hardlink_q_get(struct hardlink_q *qhead, unsigned long inode, unsigned long long *offset, char **path); extern int hardlink_q_add(struct hardlink_q *qhead, unsigned long inode, unsigned long long offset, char *path, int is_tmp); #endif /* !_TLM_H_ */