sys/vfs/hammer/hammer_dedup.c

   1 /*
   2  * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Ilya Dryomov <idryomov@gmail.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "hammer.h"
  36
  37 static __inline int validate_zone(hammer_off_t data_offset);
  38
  39 int
  40 hammer_ioc_dedup(hammer_transaction_t trans, hammer_inode_t ip,
  41                  struct hammer_ioc_dedup *dedup)
  42 {
  43         struct hammer_cursor cursor1, cursor2;
  44         int error;
  45
  46         /*
  47          * Enforce hammer filesystem version requirements
  48          */
  49         if (trans->hmp->version < HAMMER_VOL_VERSION_FIVE) {
  50                 kprintf("hammer: Filesystem must be upgraded to v5 "
  51                         "before you can run dedup\n");
  52                 return (EOPNOTSUPP);
  53         }
  54
  55         /*
  56          * Cursor1, return an error -> candidate goes to pass2 list
  57          */
  58         error = hammer_init_cursor(trans, &cursor1, NULL, NULL);
  59         if (error)
  60                 goto done_cursor;
  61         cursor1.key_beg = dedup->elm1;
  62         cursor1.flags |= HAMMER_CURSOR_BACKEND;
  63
  64         error = hammer_btree_lookup(&cursor1);
  65         if (error)
  66                 goto done_cursor;
  67         error = hammer_btree_extract(&cursor1, HAMMER_CURSOR_GET_LEAF |
  68                                                 HAMMER_CURSOR_GET_DATA);
  69         if (error)
  70                 goto done_cursor;
  71
  72         /*
  73          * Cursor2, return an error -> candidate goes to pass2 list
  74          */
  75         error = hammer_init_cursor(trans, &cursor2, NULL, NULL);
  76         if (error)
  77                 goto done_cursors;
  78         cursor2.key_beg = dedup->elm2;
  79         cursor2.flags |= HAMMER_CURSOR_BACKEND;
  80
  81         error = hammer_btree_lookup(&cursor2);
  82         if (error)
  83                 goto done_cursors;
  84         error = hammer_btree_extract(&cursor2, HAMMER_CURSOR_GET_LEAF |
  85                                                 HAMMER_CURSOR_GET_DATA);
  86         if (error)
  87                 goto done_cursors;
  88
  89         /*
  90          * Zone validation. We can't de-dup any of the other zones
  91          * (BTREE or META) or bad things will happen.
  92          *
  93          * Return with error = 0, but set an INVALID_ZONE flag.
  94          */
  95         error = validate_zone(cursor1.leaf->data_offset) +
  96                             validate_zone(cursor2.leaf->data_offset);
  97         if (error) {
  98                 dedup->head.flags |= HAMMER_IOC_DEDUP_INVALID_ZONE;
  99                 error = 0;
 100                 goto done_cursors;
 101         }
 102
 103         /*
 104          * Comparison checks
 105          *
 106          * If zones don't match or data_len fields aren't the same
 107          * we consider it to be a comparison failure.
 108          *
 109          * Return with error = 0, but set a CMP_FAILURE flag.
 110          */
 111         if ((cursor1.leaf->data_offset & HAMMER_OFF_ZONE_MASK) !=
 112             (cursor2.leaf->data_offset & HAMMER_OFF_ZONE_MASK)) {
 113                 dedup->head.flags |= HAMMER_IOC_DEDUP_CMP_FAILURE;
 114                 goto done_cursors;
 115         }
 116         if (cursor1.leaf->data_len != cursor2.leaf->data_len) {
 117                 dedup->head.flags |= HAMMER_IOC_DEDUP_CMP_FAILURE;
 118                 goto done_cursors;
 119         }
 120
 121         /* byte-by-byte comparison to be sure */
 122         if (bcmp(cursor1.data, cursor2.data, cursor1.leaf->data_len)) {
 123                 dedup->head.flags |= HAMMER_IOC_DEDUP_CMP_FAILURE;
 124                 goto done_cursors;
 125         }
 126
 127         /*
 128          * Upgrade both cursors together to an exclusive lock
 129          *
 130          * Return an error -> candidate goes to pass2 list
 131          */
 132         hammer_sync_lock_sh(trans);
 133         error = hammer_cursor_upgrade2(&cursor1, &cursor2);
 134         if (error) {
 135                 hammer_sync_unlock(trans);
 136                 goto done_cursors;
 137         }
 138
 139         error = hammer_blockmap_dedup(cursor1.trans,
 140                         cursor1.leaf->data_offset, cursor1.leaf->data_len);
 141         if (error) {
 142                 if (error == ERANGE) {
 143                         /*
 144                          * Return with error = 0, but set an UNDERFLOW flag
 145                          */
 146                         dedup->head.flags |= HAMMER_IOC_DEDUP_UNDERFLOW;
 147                         error = 0;
 148                         goto downgrade_cursors;
 149                 } else {
 150                         /*
 151                          * Return an error -> block goes to pass2 list
 152                          */
 153                         goto downgrade_cursors;
 154                 }
 155         }
 156
 157         /*
 158          * The cursor2's cache must be invalidated before calling
 159          * hammer_blockmap_free(), otherwise it will not be able to
 160          * invalidate the underlying data buffer.
 161          */
 162         hammer_cursor_invalidate_cache(&cursor2);
 163         hammer_blockmap_free(cursor2.trans,
 164                         cursor2.leaf->data_offset, cursor2.leaf->data_len);
 165
 166         hammer_modify_node(cursor2.trans, cursor2.node,
 167                         &cursor2.leaf->data_offset, sizeof(hammer_off_t));
 168         cursor2.leaf->data_offset = cursor1.leaf->data_offset;
 169         hammer_modify_node_done(cursor2.node);
 170
 171 downgrade_cursors:
 172         hammer_cursor_downgrade2(&cursor1, &cursor2);
 173         hammer_sync_unlock(trans);
 174 done_cursors:
 175         hammer_done_cursor(&cursor2);
 176 done_cursor:
 177         hammer_done_cursor(&cursor1);
 178         return (error);
 179 }
 180
 181 static __inline int
 182 validate_zone(hammer_off_t data_offset)
 183 {
 184         switch(data_offset & HAMMER_OFF_ZONE_MASK) {
 185         case HAMMER_ZONE_LARGE_DATA:
 186         case HAMMER_ZONE_SMALL_DATA:
 187                 return (0);
 188         default:
 189                 return (1);
 190         }
 191 }