sys/cddl/contrib/opensolaris/uts/common/fs/zfs/bplist.c

   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  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 #include <sys/bplist.h>
  29 #include <sys/zfs_context.h>
  30
  31 static int
  32 bplist_hold(bplist_t *bpl)
  33 {
  34         ASSERT(MUTEX_HELD(&bpl->bpl_lock));
  35         if (bpl->bpl_dbuf == NULL) {
  36                 int err = dmu_bonus_hold(bpl->bpl_mos,
  37                     bpl->bpl_object, bpl, &bpl->bpl_dbuf);
  38                 if (err)
  39                         return (err);
  40                 bpl->bpl_phys = bpl->bpl_dbuf->db_data;
  41         }
  42         return (0);
  43 }
  44
  45 uint64_t
  46 bplist_create(objset_t *mos, int blocksize, dmu_tx_t *tx)
  47 {
  48         int size;
  49
  50         size = spa_version(dmu_objset_spa(mos)) < ZFS_VERSION_BPLIST_ACCOUNT ?
  51             BPLIST_SIZE_V0 : sizeof (bplist_phys_t);
  52
  53         return (dmu_object_alloc(mos, DMU_OT_BPLIST, blocksize,
  54             DMU_OT_BPLIST_HDR, size, tx));
  55 }
  56
  57 void
  58 bplist_destroy(objset_t *mos, uint64_t object, dmu_tx_t *tx)
  59 {
  60         VERIFY(dmu_object_free(mos, object, tx) == 0);
  61 }
  62
  63 int
  64 bplist_open(bplist_t *bpl, objset_t *mos, uint64_t object)
  65 {
  66         dmu_object_info_t doi;
  67         int err;
  68
  69         err = dmu_object_info(mos, object, &doi);
  70         if (err)
  71                 return (err);
  72
  73         mutex_enter(&bpl->bpl_lock);
  74
  75         ASSERT(bpl->bpl_dbuf == NULL);
  76         ASSERT(bpl->bpl_phys == NULL);
  77         ASSERT(bpl->bpl_cached_dbuf == NULL);
  78         ASSERT(bpl->bpl_queue == NULL);
  79         ASSERT(object != 0);
  80         ASSERT3U(doi.doi_type, ==, DMU_OT_BPLIST);
  81         ASSERT3U(doi.doi_bonus_type, ==, DMU_OT_BPLIST_HDR);
  82
  83         bpl->bpl_mos = mos;
  84         bpl->bpl_object = object;
  85         bpl->bpl_blockshift = highbit(doi.doi_data_block_size - 1);
  86         bpl->bpl_bpshift = bpl->bpl_blockshift - SPA_BLKPTRSHIFT;
  87         bpl->bpl_havecomp = (doi.doi_bonus_size == sizeof (bplist_phys_t));
  88
  89         mutex_exit(&bpl->bpl_lock);
  90         return (0);
  91 }
  92
  93 void
  94 bplist_close(bplist_t *bpl)
  95 {
  96         mutex_enter(&bpl->bpl_lock);
  97
  98         ASSERT(bpl->bpl_queue == NULL);
  99
 100         if (bpl->bpl_cached_dbuf) {
 101                 dmu_buf_rele(bpl->bpl_cached_dbuf, bpl);
 102                 bpl->bpl_cached_dbuf = NULL;
 103         }
 104         if (bpl->bpl_dbuf) {
 105                 dmu_buf_rele(bpl->bpl_dbuf, bpl);
 106                 bpl->bpl_dbuf = NULL;
 107                 bpl->bpl_phys = NULL;
 108         }
 109
 110         mutex_exit(&bpl->bpl_lock);
 111 }
 112
 113 boolean_t
 114 bplist_empty(bplist_t *bpl)
 115 {
 116         boolean_t rv;
 117
 118         if (bpl->bpl_object == 0)
 119                 return (B_TRUE);
 120
 121         mutex_enter(&bpl->bpl_lock);
 122         VERIFY(0 == bplist_hold(bpl)); /* XXX */
 123         rv = (bpl->bpl_phys->bpl_entries == 0);
 124         mutex_exit(&bpl->bpl_lock);
 125
 126         return (rv);
 127 }
 128
 129 static int
 130 bplist_cache(bplist_t *bpl, uint64_t blkid)
 131 {
 132         int err = 0;
 133
 134         if (bpl->bpl_cached_dbuf == NULL ||
 135             bpl->bpl_cached_dbuf->db_offset != (blkid << bpl->bpl_blockshift)) {
 136                 if (bpl->bpl_cached_dbuf != NULL)
 137                         dmu_buf_rele(bpl->bpl_cached_dbuf, bpl);
 138                 err = dmu_buf_hold(bpl->bpl_mos,
 139                     bpl->bpl_object, blkid << bpl->bpl_blockshift,
 140                     bpl, &bpl->bpl_cached_dbuf);
 141                 ASSERT(err || bpl->bpl_cached_dbuf->db_size ==
 142                     1ULL << bpl->bpl_blockshift);
 143         }
 144         return (err);
 145 }
 146
 147 int
 148 bplist_iterate(bplist_t *bpl, uint64_t *itorp, blkptr_t *bp)
 149 {
 150         uint64_t blk, off;
 151         blkptr_t *bparray;
 152         int err;
 153
 154         mutex_enter(&bpl->bpl_lock);
 155
 156         err = bplist_hold(bpl);
 157         if (err) {
 158                 mutex_exit(&bpl->bpl_lock);
 159                 return (err);
 160         }
 161
 162         if (*itorp >= bpl->bpl_phys->bpl_entries) {
 163                 mutex_exit(&bpl->bpl_lock);
 164                 return (ENOENT);
 165         }
 166
 167         blk = *itorp >> bpl->bpl_bpshift;
 168         off = P2PHASE(*itorp, 1ULL << bpl->bpl_bpshift);
 169
 170         err = bplist_cache(bpl, blk);
 171         if (err) {
 172                 mutex_exit(&bpl->bpl_lock);
 173                 return (err);
 174         }
 175
 176         bparray = bpl->bpl_cached_dbuf->db_data;
 177         *bp = bparray[off];
 178         (*itorp)++;
 179         mutex_exit(&bpl->bpl_lock);
 180         return (0);
 181 }
 182
 183 int
 184 bplist_enqueue(bplist_t *bpl, blkptr_t *bp, dmu_tx_t *tx)
 185 {
 186         uint64_t blk, off;
 187         blkptr_t *bparray;
 188         int err;
 189
 190         ASSERT(!BP_IS_HOLE(bp));
 191         mutex_enter(&bpl->bpl_lock);
 192         err = bplist_hold(bpl);
 193         if (err)
 194                 return (err);
 195
 196         blk = bpl->bpl_phys->bpl_entries >> bpl->bpl_bpshift;
 197         off = P2PHASE(bpl->bpl_phys->bpl_entries, 1ULL << bpl->bpl_bpshift);
 198
 199         err = bplist_cache(bpl, blk);
 200         if (err) {
 201                 mutex_exit(&bpl->bpl_lock);
 202                 return (err);
 203         }
 204
 205         dmu_buf_will_dirty(bpl->bpl_cached_dbuf, tx);
 206         bparray = bpl->bpl_cached_dbuf->db_data;
 207         bparray[off] = *bp;
 208
 209         /* We never need the fill count. */
 210         bparray[off].blk_fill = 0;
 211
 212         /* The bplist will compress better if we can leave off the checksum */
 213         bzero(&bparray[off].blk_cksum, sizeof (bparray[off].blk_cksum));
 214
 215         dmu_buf_will_dirty(bpl->bpl_dbuf, tx);
 216         bpl->bpl_phys->bpl_entries++;
 217         bpl->bpl_phys->bpl_bytes +=
 218             bp_get_dasize(dmu_objset_spa(bpl->bpl_mos), bp);
 219         if (bpl->bpl_havecomp) {
 220                 bpl->bpl_phys->bpl_comp += BP_GET_PSIZE(bp);
 221                 bpl->bpl_phys->bpl_uncomp += BP_GET_UCSIZE(bp);
 222         }
 223         mutex_exit(&bpl->bpl_lock);
 224
 225         return (0);
 226 }
 227
 228 /*
 229  * Deferred entry; will be written later by bplist_sync().
 230  */
 231 void
 232 bplist_enqueue_deferred(bplist_t *bpl, blkptr_t *bp)
 233 {
 234         bplist_q_t *bpq = kmem_alloc(sizeof (*bpq), KM_SLEEP);
 235
 236         ASSERT(!BP_IS_HOLE(bp));
 237         mutex_enter(&bpl->bpl_lock);
 238         bpq->bpq_blk = *bp;
 239         bpq->bpq_next = bpl->bpl_queue;
 240         bpl->bpl_queue = bpq;
 241         mutex_exit(&bpl->bpl_lock);
 242 }
 243
 244 void
 245 bplist_sync(bplist_t *bpl, dmu_tx_t *tx)
 246 {
 247         bplist_q_t *bpq;
 248
 249         mutex_enter(&bpl->bpl_lock);
 250         while ((bpq = bpl->bpl_queue) != NULL) {
 251                 bpl->bpl_queue = bpq->bpq_next;
 252                 mutex_exit(&bpl->bpl_lock);
 253                 VERIFY(0 == bplist_enqueue(bpl, &bpq->bpq_blk, tx));
 254                 kmem_free(bpq, sizeof (*bpq));
 255                 mutex_enter(&bpl->bpl_lock);
 256         }
 257         mutex_exit(&bpl->bpl_lock);
 258 }
 259
 260 void
 261 bplist_vacate(bplist_t *bpl, dmu_tx_t *tx)
 262 {
 263         mutex_enter(&bpl->bpl_lock);
 264         ASSERT3P(bpl->bpl_queue, ==, NULL);
 265         VERIFY(0 == bplist_hold(bpl));
 266         dmu_buf_will_dirty(bpl->bpl_dbuf, tx);
 267         VERIFY(0 == dmu_free_range(bpl->bpl_mos,
 268             bpl->bpl_object, 0, -1ULL, tx));
 269         bpl->bpl_phys->bpl_entries = 0;
 270         bpl->bpl_phys->bpl_bytes = 0;
 271         if (bpl->bpl_havecomp) {
 272                 bpl->bpl_phys->bpl_comp = 0;
 273                 bpl->bpl_phys->bpl_uncomp = 0;
 274         }
 275         mutex_exit(&bpl->bpl_lock);
 276 }
 277
 278 int
 279 bplist_space(bplist_t *bpl, uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
 280 {
 281         uint64_t itor = 0, comp = 0, uncomp = 0;
 282         int err;
 283         blkptr_t bp;
 284
 285         mutex_enter(&bpl->bpl_lock);
 286
 287         err = bplist_hold(bpl);
 288         if (err) {
 289                 mutex_exit(&bpl->bpl_lock);
 290                 return (err);
 291         }
 292
 293         *usedp = bpl->bpl_phys->bpl_bytes;
 294         if (bpl->bpl_havecomp) {
 295                 *compp = bpl->bpl_phys->bpl_comp;
 296                 *uncompp = bpl->bpl_phys->bpl_uncomp;
 297         }
 298         mutex_exit(&bpl->bpl_lock);
 299
 300         if (!bpl->bpl_havecomp) {
 301                 while ((err = bplist_iterate(bpl, &itor, &bp)) == 0) {
 302                         comp += BP_GET_PSIZE(&bp);
 303                         uncomp += BP_GET_UCSIZE(&bp);
 304                 }
 305                 if (err == ENOENT)
 306                         err = 0;
 307                 *compp = comp;
 308                 *uncompp = uncomp;
 309         }
 310
 311         return (err);
 312 }