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, 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 }