1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _SYS_FSSNAP_H 28 #define _SYS_FSSNAP_H 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 #include <sys/sysmacros.h> 33 #include <sys/devops.h> 34 35 #ifdef __cplusplus 36 extern "C" { 37 #endif 38 39 #include <sys/buf.h> 40 #include <sys/taskq.h> 41 #include <sys/fs/ufs_inode.h> 42 43 /* snapshot backend interfaces, macros, and data structures */ 44 45 #if defined(_KERNEL) 46 47 /* 48 * defines for the number of threads used to handle tasks, the maximum 49 * number of chunks in memory at a time, and the maximum number of tasks to 50 * allow before the taskqs start throttling. MAXTASKS should be greater than 51 * or equal to MAX_MEM_CHUNKS. 52 */ 53 #define FSSNAP_TASKQ_THREADS (2) 54 #define FSSNAP_MAX_MEM_CHUNKS (32) 55 #define FSSNAP_TASKQ_MAXTASKS (FSSNAP_MAX_MEM_CHUNKS) 56 57 /* 58 * It is assumed that a chunk is a multiple of a disk sector so that 59 * the chunk size can be reduced before using it as a conversion 60 * factor. Therefore the number of chunks on a file system will 61 * always be less than the number of blocks it occupies, and these 62 * conversions will not overflow. (do not convert to bytes first!) 63 */ 64 65 typedef unsigned long long chunknumber_t; 66 67 /* disk blocks to snapshot chunks */ 68 #define dbtocowchunk(cmap, dblkno) ((dblkno) / \ 69 ((cmap)->cmap_chunksz >> DEV_BSHIFT)) 70 71 /* snapshot chunks to disk blocks */ 72 #define cowchunktodb(cmap, cowchunk) ((cowchunk) * \ 73 ((cmap)->cmap_chunksz >> DEV_BSHIFT)) 74 75 /* 76 * A snapshot_id is the shared structure between the snapshot driver 77 * and the file system. 78 */ 79 typedef struct snapshot_id { 80 struct snapshot_id *sid_next; /* next snapshot in list */ 81 krwlock_t sid_rwlock; /* protects enable/disable */ 82 struct cow_info *sid_cowinfo; /* pointer to cow state */ 83 uint_t sid_snapnumber; /* snapshot number */ 84 uint_t sid_flags; /* general flags */ 85 struct vnode *sid_fvp; /* root vnode to snapshot */ 86 } snapshot_id_t; 87 88 /* snapshot_id flags */ 89 #define SID_DISABLED (0x01) /* this snapshot has been disabled */ 90 #define SID_DISABLING (0x02) /* this snapshot is being disabled */ 91 #define SID_BLOCK_BUSY (0x04) /* snapshot block driver is attached */ 92 #define SID_CHAR_BUSY (0x08) /* snapshot character driver is attached */ 93 #define SID_CREATING (0x10) /* snapshot is being created */ 94 #define SID_DELETE (0x20) /* error condition found, delete snapshot */ 95 96 /* true if snapshot device is open */ 97 #define SID_BUSY(sidp) (((sidp)->sid_flags & SID_BLOCK_BUSY) || \ 98 ((sidp)->sid_flags & SID_CHAR_BUSY)) 99 100 /* true if snapshot can not be used */ 101 #define SID_INACTIVE(sidp) (((sidp)->sid_flags & SID_DISABLED) || \ 102 ((sidp)->sid_flags & SID_DISABLING) || \ 103 ((sidp)->sid_flags & SID_CREATING) || \ 104 ((sidp)->sid_flags & SID_DELETE) || \ 105 ((sidp)->sid_cowinfo == NULL)) 106 107 /* true if snapshot can be reused now */ 108 #define SID_AVAILABLE(sidp) (!SID_BUSY(sidp) && \ 109 ((sidp)->sid_flags & SID_DISABLED)) 110 111 /* 112 * The cow_map keeps track of all translations, and two bitmaps to 113 * determine whether the chunk is eligible for translation, and if so 114 * whether or not it already has a translation. The candidate bitmap 115 * is read-only and does not require a lock, the hastrans bitmap and 116 * the translation table are protected by the cmap_rwlock. 117 */ 118 typedef struct cow_map { 119 krwlock_t cmap_rwlock; /* protects this structure */ 120 ksema_t cmap_throttle_sem; /* used to throttle writes */ 121 uint32_t cmap_waiters; /* semaphore waiters */ 122 uint_t cmap_chunksz; /* granularity of COW operations */ 123 chunknumber_t cmap_chunksperbf; /* chunks in max backing file */ 124 chunknumber_t cmap_nchunks; /* number of chunks in backing file */ 125 u_offset_t cmap_maxsize; /* max bytes allowed (0 is no limit) */ 126 size_t cmap_bmsize; /* size of bitmaps (in bytes) */ 127 caddr_t cmap_candidate; /* 1 = block is a candidate for COW */ 128 caddr_t cmap_hastrans; /* 1 = an entry exists in the table */ 129 struct cow_map_node *cmap_table; /* translation table */ 130 } cow_map_t; 131 132 /* 133 * The cow_map_node keeps track of chunks that are still in memory. 134 */ 135 136 typedef struct cow_map_node { 137 struct cow_map_node *cmn_next; 138 struct cow_map_node *cmn_prev; 139 struct snapshot_id *cmn_sid; /* backpointer to snapshot */ 140 chunknumber_t cmn_chunk; /* original chunk number */ 141 caddr_t cmn_buf; /* the data itself */ 142 int release_sem; /* flag to release */ 143 /* cmap_throttle_sem */ 144 } cow_map_node_t; 145 146 /* 147 * The cow_info structure holds basic snapshot state information. It is 148 * mostly read-only once the snapshot is created so no locking is required. 149 * The exception is cow_nextchunk, which is ever-increasing and updated with 150 * atomic_add(). This structure is allocated dynamically, and creation and 151 * deletion of the snapshot is protected by the snapshot_mutex variable. 152 */ 153 typedef struct cow_info { 154 int cow_backcount; /* number of backing files */ 155 vnode_t **cow_backfile_array; /* array of backing files */ 156 u_offset_t cow_backfile_sz; /* max size of a backfile */ 157 taskq_t *cow_taskq; /* task queue for async writes */ 158 struct kstat *cow_kstat_mntpt; /* kstat for mount point */ 159 struct kstat *cow_kstat_bfname; /* kstat for backing file */ 160 struct kstat *cow_kstat_num; /* named numeric kstats */ 161 struct cow_map cow_map; /* block translation table */ 162 } cow_info_t; 163 164 /* kstat information */ 165 struct cow_kstat_num { 166 kstat_named_t ckn_state; /* state of the snapshot device */ 167 kstat_named_t ckn_bfsize; /* sum of sizes of backing files */ 168 kstat_named_t ckn_maxsize; /* maximum backing file size */ 169 kstat_named_t ckn_createtime; /* snapshot creation time */ 170 kstat_named_t ckn_chunksize; /* chunk size */ 171 }; 172 173 /* ckn_state values */ 174 #define COWSTATE_CREATING (0) /* snapshot being created */ 175 #define COWSTATE_IDLE (1) /* snapshot exists, but not open */ 176 #define COWSTATE_ACTIVE (2) /* snapshot open */ 177 #define COWSTATE_DISABLED (3) /* snapshot deleted (pending close) */ 178 179 extern uint_t bypass_snapshot_throttle_key; 180 181 #endif /* _KERNEL */ 182 183 #ifdef __cplusplus 184 } 185 #endif 186 187 #endif /* _SYS_FSSNAP_H */ 188