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