Home | History | Annotate | Download | only in zfs
      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 (the "License").
      6  * You may not use this file except in compliance with the License.
      7  *
      8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
      9  * or http://www.opensolaris.org/os/licensing.
     10  * See the License for the specific language governing permissions
     11  * and limitations under the License.
     12  *
     13  * When distributing Covered Code, include this CDDL HEADER in each
     14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     15  * If applicable, add the following below this CDDL HEADER, with the
     16  * fields enclosed by brackets "[]" replaced with your own identifying
     17  * information: Portions Copyright [yyyy] [name of copyright owner]
     18  *
     19  * CDDL HEADER END
     20  */
     21 
     22 /*
     23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
     24  * Use is subject to license terms.
     25  */
     26 
     27 #include <sys/zfs_context.h>
     28 #include <sys/spa.h>
     29 #include <sys/zio.h>
     30 #include <sys/ddt.h>
     31 #include <sys/zap.h>
     32 #include <sys/dmu_tx.h>
     33 #include <util/sscanf.h>
     34 
     35 int ddt_zap_leaf_blockshift = 12;
     36 int ddt_zap_indirect_blockshift = 12;
     37 
     38 static int
     39 ddt_zap_create(objset_t *os, uint64_t *objectp, dmu_tx_t *tx, boolean_t prehash)
     40 {
     41 	zap_flags_t flags = ZAP_FLAG_HASH64 | ZAP_FLAG_UINT64_KEY;
     42 
     43 	if (prehash)
     44 		flags |= ZAP_FLAG_PRE_HASHED_KEY;
     45 
     46 	*objectp = zap_create_flags(os, 0, flags, DMU_OT_DDT_ZAP,
     47 	    ddt_zap_leaf_blockshift, ddt_zap_indirect_blockshift,
     48 	    DMU_OT_NONE, 0, tx);
     49 
     50 	return (*objectp == 0 ? ENOTSUP : 0);
     51 }
     52 
     53 static int
     54 ddt_zap_destroy(objset_t *os, uint64_t object, dmu_tx_t *tx)
     55 {
     56 	return (zap_destroy(os, object, tx));
     57 }
     58 
     59 static int
     60 ddt_zap_lookup(objset_t *os, uint64_t object, ddt_entry_t *dde)
     61 {
     62 	uchar_t cbuf[sizeof (dde->dde_phys) + 1];
     63 	uint64_t one, csize;
     64 	int error;
     65 
     66 	error = zap_length_uint64(os, object, (uint64_t *)&dde->dde_key,
     67 	    DDT_KEY_WORDS, &one, &csize);
     68 	if (error)
     69 		return (error);
     70 
     71 	ASSERT(one == 1);
     72 	ASSERT(csize <= sizeof (cbuf));
     73 
     74 	error = zap_lookup_uint64(os, object, (uint64_t *)&dde->dde_key,
     75 	    DDT_KEY_WORDS, 1, csize, cbuf);
     76 	if (error)
     77 		return (error);
     78 
     79 	ddt_decompress(cbuf, dde->dde_phys, csize, sizeof (dde->dde_phys));
     80 
     81 	return (0);
     82 }
     83 
     84 static int
     85 ddt_zap_update(objset_t *os, uint64_t object, ddt_entry_t *dde, dmu_tx_t *tx)
     86 {
     87 	uchar_t cbuf[sizeof (dde->dde_phys) + 1];
     88 	uint64_t csize;
     89 
     90 	csize = ddt_compress(dde->dde_phys, cbuf,
     91 	    sizeof (dde->dde_phys), sizeof (cbuf));
     92 
     93 	return (zap_update_uint64(os, object, (uint64_t *)&dde->dde_key,
     94 	    DDT_KEY_WORDS, 1, csize, cbuf, tx));
     95 }
     96 
     97 static int
     98 ddt_zap_remove(objset_t *os, uint64_t object, ddt_entry_t *dde, dmu_tx_t *tx)
     99 {
    100 	return (zap_remove_uint64(os, object, (uint64_t *)&dde->dde_key,
    101 	    DDT_KEY_WORDS, tx));
    102 }
    103 
    104 static int
    105 ddt_zap_walk(objset_t *os, uint64_t object, ddt_entry_t *dde, uint64_t *walk)
    106 {
    107 	zap_cursor_t zc;
    108 	zap_attribute_t za;
    109 	int error;
    110 
    111 	zap_cursor_init_serialized(&zc, os, object, *walk);
    112 	if ((error = zap_cursor_retrieve(&zc, &za)) == 0) {
    113 		uchar_t cbuf[sizeof (dde->dde_phys) + 1];
    114 		uint64_t csize = za.za_num_integers;
    115 		ASSERT(za.za_integer_length == 1);
    116 		error = zap_lookup_uint64(os, object, (uint64_t *)za.za_name,
    117 		    DDT_KEY_WORDS, 1, csize, cbuf);
    118 		ASSERT(error == 0);
    119 		if (error == 0) {
    120 			ddt_decompress(cbuf, dde->dde_phys, csize,
    121 			    sizeof (dde->dde_phys));
    122 			dde->dde_key = *(ddt_key_t *)za.za_name;
    123 		}
    124 		zap_cursor_advance(&zc);
    125 		*walk = zap_cursor_serialize(&zc);
    126 	}
    127 	zap_cursor_fini(&zc);
    128 	return (error);
    129 }
    130 
    131 static uint64_t
    132 ddt_zap_count(objset_t *os, uint64_t object)
    133 {
    134 	uint64_t count = 0;
    135 
    136 	VERIFY(zap_count(os, object, &count) == 0);
    137 
    138 	return (count);
    139 }
    140 
    141 const ddt_ops_t ddt_zap_ops = {
    142 	"zap",
    143 	ddt_zap_create,
    144 	ddt_zap_destroy,
    145 	ddt_zap_lookup,
    146 	ddt_zap_update,
    147 	ddt_zap_remove,
    148 	ddt_zap_walk,
    149 	ddt_zap_count,
    150 };
    151