1 /* 2 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2013 by Delphix. All rights reserved. 4 */ 5 6 /* 7 * BSD 3 Clause License 8 * 9 * Copyright (c) 2007, The Storage Networking Industry Association. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * - Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 17 * - Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in 19 * the documentation and/or other materials provided with the 20 * distribution. 21 * 22 * - Neither the name of The Storage Networking Industry Association (SNIA) 23 * nor the names of its contributors may be used to endorse or promote 24 * products derived from this software without specific prior written 25 * permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 28 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 31 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 #include <stdio.h> 41 #include <string.h> 42 #include "ndmpd.h" 43 #include <libzfs.h> 44 45 typedef struct snap_param { 46 char *snp_name; 47 boolean_t snp_found; 48 } snap_param_t; 49 50 static int cleanup_fd = -1; 51 52 /* 53 * ndmp_has_backup 54 * 55 * Call backup function which looks for backup snapshot. 56 * This is a callback function used with zfs_iter_snapshots. 57 * 58 * Parameters: 59 * zhp (input) - ZFS handle pointer 60 * data (output) - 0 - no backup snapshot 61 * 1 - has backup snapshot 62 * 63 * Returns: 64 * 0: on success 65 * -1: otherwise 66 */ 67 static int 68 ndmp_has_backup(zfs_handle_t *zhp, void *data) 69 { 70 const char *name; 71 snap_param_t *chp = (snap_param_t *)data; 72 73 name = zfs_get_name(zhp); 74 if (name == NULL || 75 strstr(name, chp->snp_name) == NULL) { 76 zfs_close(zhp); 77 return (-1); 78 } 79 80 chp->snp_found = 1; 81 zfs_close(zhp); 82 83 return (0); 84 } 85 86 /* 87 * ndmp_has_backup_snapshot 88 * 89 * Returns TRUE if the volume has an active backup snapshot, otherwise, 90 * returns FALSE. 91 * 92 * Parameters: 93 * volname (input) - name of the volume 94 * 95 * Returns: 96 * 0: on success 97 * -1: otherwise 98 */ 99 static int 100 ndmp_has_backup_snapshot(char *volname, char *jobname) 101 { 102 zfs_handle_t *zhp; 103 snap_param_t snp; 104 char chname[ZFS_MAXNAMELEN]; 105 106 (void) mutex_lock(&zlib_mtx); 107 if ((zhp = zfs_open(zlibh, volname, ZFS_TYPE_DATASET)) == 0) { 108 NDMP_LOG(LOG_ERR, "Cannot open snapshot %s.", volname); 109 (void) mutex_unlock(&zlib_mtx); 110 return (-1); 111 } 112 113 snp.snp_found = 0; 114 (void) snprintf(chname, ZFS_MAXNAMELEN, "@%s", jobname); 115 snp.snp_name = chname; 116 117 (void) zfs_iter_snapshots(zhp, ndmp_has_backup, &snp); 118 zfs_close(zhp); 119 (void) mutex_unlock(&zlib_mtx); 120 121 return (snp.snp_found); 122 } 123 124 /* 125 * ndmp_create_snapshot 126 * 127 * This function will parse the path to get the real volume name. 128 * It will then create a snapshot based on volume and job name. 129 * This function should be called before the NDMP backup is started. 130 * 131 * Parameters: 132 * vol_name (input) - name of the volume 133 * 134 * Returns: 135 * 0: on success 136 * -1: otherwise 137 */ 138 int 139 ndmp_create_snapshot(char *vol_name, char *jname) 140 { 141 char vol[ZFS_MAXNAMELEN]; 142 143 if (vol_name == 0 || 144 get_zfsvolname(vol, sizeof (vol), vol_name) == -1) 145 return (0); 146 147 /* 148 * If there is an old snapshot left from the previous 149 * backup it could be stale one and it must be 150 * removed before using it. 151 */ 152 if (ndmp_has_backup_snapshot(vol, jname)) 153 (void) snapshot_destroy(vol, jname, B_FALSE, B_TRUE, NULL); 154 155 return (snapshot_create(vol, jname, B_FALSE, B_TRUE)); 156 } 157 158 /* 159 * ndmp_remove_snapshot 160 * 161 * This function will parse the path to get the real volume name. 162 * It will then remove the snapshot for that volume and job name. 163 * This function should be called after NDMP backup is finished. 164 * 165 * Parameters: 166 * vol_name (input) - name of the volume 167 * 168 * Returns: 169 * 0: on success 170 * -1: otherwise 171 */ 172 int 173 ndmp_remove_snapshot(char *vol_name, char *jname) 174 { 175 char vol[ZFS_MAXNAMELEN]; 176 177 if (vol_name == 0 || 178 get_zfsvolname(vol, sizeof (vol), vol_name) == -1) 179 return (0); 180 181 return (snapshot_destroy(vol, jname, B_FALSE, B_TRUE, NULL)); 182 } 183 184 /* 185 * Put a hold on snapshot 186 */ 187 int 188 snapshot_hold(char *volname, char *snapname, char *jname, boolean_t recursive) 189 { 190 zfs_handle_t *zhp; 191 char *p; 192 193 if ((zhp = zfs_open(zlibh, volname, ZFS_TYPE_DATASET)) == 0) { 194 NDMP_LOG(LOG_ERR, "Cannot open volume %s.", volname); 195 return (-1); 196 } 197 198 if (cleanup_fd == -1 && (cleanup_fd = open(ZFS_DEV, 199 O_RDWR|O_EXCL)) < 0) { 200 NDMP_LOG(LOG_ERR, "Cannot open dev %d", errno); 201 zfs_close(zhp); 202 return (-1); 203 } 204 205 p = strchr(snapname, '@') + 1; 206 if (zfs_hold(zhp, p, jname, recursive, B_FALSE, cleanup_fd) != 0) { 207 NDMP_LOG(LOG_ERR, "Cannot hold snapshot %s", p); 208 zfs_close(zhp); 209 return (-1); 210 } 211 zfs_close(zhp); 212 return (0); 213 } 214 215 int 216 snapshot_release(char *volname, char *snapname, char *jname, 217 boolean_t recursive) 218 { 219 zfs_handle_t *zhp; 220 char *p; 221 int rv = 0; 222 223 if ((zhp = zfs_open(zlibh, volname, ZFS_TYPE_DATASET)) == 0) { 224 NDMP_LOG(LOG_ERR, "Cannot open volume %s", volname); 225 return (-1); 226 } 227 228 p = strchr(snapname, '@') + 1; 229 if (zfs_release(zhp, p, jname, recursive) != 0) { 230 NDMP_LOG(LOG_DEBUG, "Cannot release snapshot %s", p); 231 rv = -1; 232 } 233 if (cleanup_fd != -1) { 234 (void) close(cleanup_fd); 235 cleanup_fd = -1; 236 } 237 zfs_close(zhp); 238 return (rv); 239 } 240 241 /* 242 * Create a snapshot on the volume 243 */ 244 int 245 snapshot_create(char *volname, char *jname, boolean_t recursive, 246 boolean_t hold) 247 { 248 char snapname[ZFS_MAXNAMELEN]; 249 int rv; 250 251 if (!volname || !*volname) 252 return (-1); 253 254 (void) snprintf(snapname, ZFS_MAXNAMELEN, "%s@%s", volname, jname); 255 256 (void) mutex_lock(&zlib_mtx); 257 if ((rv = zfs_snapshot(zlibh, snapname, recursive, NULL)) 258 == -1) { 259 if (errno == EEXIST) { 260 (void) mutex_unlock(&zlib_mtx); 261 return (0); 262 } 263 NDMP_LOG(LOG_DEBUG, 264 "snapshot_create: %s failed (err=%d): %s", 265 snapname, errno, libzfs_error_description(zlibh)); 266 (void) mutex_unlock(&zlib_mtx); 267 return (rv); 268 } 269 if (hold && snapshot_hold(volname, snapname, jname, recursive) != 0) { 270 NDMP_LOG(LOG_DEBUG, 271 "snapshot_create: %s hold failed (err=%d): %s", 272 snapname, errno, libzfs_error_description(zlibh)); 273 (void) mutex_unlock(&zlib_mtx); 274 return (-1); 275 } 276 277 (void) mutex_unlock(&zlib_mtx); 278 return (0); 279 } 280 281 /* 282 * Remove and release the backup snapshot 283 */ 284 int 285 snapshot_destroy(char *volname, char *jname, boolean_t recursive, 286 boolean_t hold, int *zfs_err) 287 { 288 char snapname[ZFS_MAXNAMELEN]; 289 zfs_handle_t *zhp; 290 zfs_type_t ztype; 291 char *namep; 292 int err; 293 294 if (zfs_err) 295 *zfs_err = 0; 296 297 if (!volname || !*volname) 298 return (-1); 299 300 if (recursive) { 301 ztype = ZFS_TYPE_VOLUME | ZFS_TYPE_FILESYSTEM; 302 namep = volname; 303 } else { 304 (void) snprintf(snapname, ZFS_MAXNAMELEN, "%s@%s", volname, 305 jname); 306 namep = snapname; 307 ztype = ZFS_TYPE_SNAPSHOT; 308 } 309 310 (void) mutex_lock(&zlib_mtx); 311 if (hold && 312 snapshot_release(volname, namep, jname, recursive) != 0) { 313 NDMP_LOG(LOG_DEBUG, 314 "snapshot_destroy: %s release failed (err=%d): %s", 315 namep, errno, libzfs_error_description(zlibh)); 316 (void) mutex_unlock(&zlib_mtx); 317 return (-1); 318 } 319 320 if ((zhp = zfs_open(zlibh, namep, ztype)) == NULL) { 321 NDMP_LOG(LOG_DEBUG, "snapshot_destroy: open %s failed", 322 namep); 323 (void) mutex_unlock(&zlib_mtx); 324 return (-1); 325 } 326 327 if (recursive) { 328 err = zfs_destroy_snaps(zhp, jname, B_TRUE); 329 } else { 330 err = zfs_destroy(zhp, B_TRUE); 331 } 332 333 if (err) { 334 NDMP_LOG(LOG_ERR, "%s (recursive destroy: %d): %d; %s; %s", 335 namep, 336 recursive, 337 libzfs_errno(zlibh), 338 libzfs_error_action(zlibh), 339 libzfs_error_description(zlibh)); 340 341 if (zfs_err) 342 *zfs_err = err; 343 } 344 345 zfs_close(zhp); 346 (void) mutex_unlock(&zlib_mtx); 347 348 return (0); 349 } 350