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.
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.
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]
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2013, 2015 by Delphix. All rights reserved.
24 * Copyright 2014 HybridCluster. All rights reserved.
28 #include <sys/dmu_objset.h>
29 #include <sys/dmu_tx.h>
30 #include <sys/dnode.h>
32 #include <sys/zfeature.h>
33 #include <sys/dsl_dataset.h>
36 dmu_object_alloc(objset_t *os, dmu_object_type_t ot, int blocksize,
37 dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)
39 return dmu_object_alloc_dnsize(os, ot, blocksize, bonustype, bonuslen,
44 dmu_object_alloc_dnsize(objset_t *os, dmu_object_type_t ot, int blocksize,
45 dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx)
48 uint64_t L1_dnode_count = DNODES_PER_BLOCK <<
49 (DMU_META_DNODE(os)->dn_indblkshift - SPA_BLKPTRSHIFT);
51 int dn_slots = dnodesize >> DNODE_SHIFT;
52 boolean_t restarted = B_FALSE;
55 dn_slots = DNODE_MIN_SLOTS;
57 ASSERT3S(dn_slots, >=, DNODE_MIN_SLOTS);
58 ASSERT3S(dn_slots, <=, DNODE_MAX_SLOTS);
61 mutex_enter(&os->os_obj_lock);
63 object = os->os_obj_next;
65 * Each time we polish off a L1 bp worth of dnodes (2^12
66 * objects), move to another L1 bp that's still
67 * reasonably sparse (at most 1/4 full). Look from the
68 * beginning at most once per txg. If we still can't
69 * allocate from that L1 block, search for an empty L0
70 * block, which will quickly skip to the end of the
71 * metadnode if the no nearby L0 blocks are empty. This
72 * fallback avoids a pathology where full dnode blocks
73 * containing large dnodes appear sparse because they
74 * have a low blk_fill, leading to many failed
75 * allocation attempts. In the long term a better
76 * mechanism to search for sparse metadnode regions,
77 * such as spacemaps, could be implemented.
79 * os_scan_dnodes is set during txg sync if enough objects
80 * have been freed since the previous rescan to justify
83 * Note that dmu_traverse depends on the behavior that we use
84 * multiple blocks of the dnode object before going back to
85 * reuse objects. Any change to this algorithm should preserve
86 * that property or find another solution to the issues
87 * described in traverse_visitbp.
89 if (P2PHASE(object, L1_dnode_count) == 0) {
94 if (os->os_rescan_dnodes) {
96 os->os_rescan_dnodes = B_FALSE;
98 offset = object << DNODE_SHIFT;
100 blkfill = restarted ? 1 : DNODES_PER_BLOCK >> 2;
101 minlvl = restarted ? 1 : 2;
103 error = dnode_next_offset(DMU_META_DNODE(os),
104 DNODE_FIND_HOLE, &offset, minlvl, blkfill, 0);
106 object = offset >> DNODE_SHIFT;
108 os->os_obj_next = object + dn_slots;
111 * XXX We should check for an i/o error here and return
112 * up to our caller. Actually we should pre-read it in
113 * dmu_tx_assign(), but there is currently no mechanism
116 (void) dnode_hold_impl(os, object, DNODE_MUST_BE_FREE, dn_slots,
121 if (dmu_object_next(os, &object, B_TRUE, 0) == 0)
122 os->os_obj_next = object;
125 * Skip to next known valid starting point for a dnode.
127 os->os_obj_next = P2ROUNDUP(object + 1,
131 dnode_allocate(dn, ot, blocksize, 0, bonustype, bonuslen, dn_slots, tx);
132 mutex_exit(&os->os_obj_lock);
134 dmu_tx_add_new_object(tx, os, dn);
135 dnode_rele(dn, FTAG);
141 dmu_object_claim(objset_t *os, uint64_t object, dmu_object_type_t ot,
142 int blocksize, dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)
144 return (dmu_object_claim_dnsize(os, object, ot, blocksize, bonustype,
149 dmu_object_claim_dnsize(objset_t *os, uint64_t object, dmu_object_type_t ot,
150 int blocksize, dmu_object_type_t bonustype, int bonuslen,
151 int dnodesize, dmu_tx_t *tx)
154 int dn_slots = dnodesize >> DNODE_SHIFT;
158 dn_slots = DNODE_MIN_SLOTS;
159 ASSERT3S(dn_slots, >=, DNODE_MIN_SLOTS);
160 ASSERT3S(dn_slots, <=, DNODE_MAX_SLOTS);
162 if (object == DMU_META_DNODE_OBJECT && !dmu_tx_private_ok(tx))
163 return (SET_ERROR(EBADF));
165 err = dnode_hold_impl(os, object, DNODE_MUST_BE_FREE, dn_slots,
170 dnode_allocate(dn, ot, blocksize, 0, bonustype, bonuslen, dn_slots, tx);
171 dmu_tx_add_new_object(tx, os, dn);
173 dnode_rele(dn, FTAG);
179 dmu_object_reclaim(objset_t *os, uint64_t object, dmu_object_type_t ot,
180 int blocksize, dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)
182 return (dmu_object_reclaim_dnsize(os, object, ot, blocksize, bonustype,
187 dmu_object_reclaim_dnsize(objset_t *os, uint64_t object, dmu_object_type_t ot,
188 int blocksize, dmu_object_type_t bonustype, int bonuslen, int dnodesize,
192 int dn_slots = dnodesize >> DNODE_SHIFT;
195 if (object == DMU_META_DNODE_OBJECT)
196 return (SET_ERROR(EBADF));
198 err = dnode_hold_impl(os, object, DNODE_MUST_BE_ALLOCATED, 0,
203 dnode_reallocate(dn, ot, blocksize, bonustype, bonuslen, dn_slots, tx);
205 dnode_rele(dn, FTAG);
211 dmu_object_free(objset_t *os, uint64_t object, dmu_tx_t *tx)
216 ASSERT(object != DMU_META_DNODE_OBJECT || dmu_tx_private_ok(tx));
218 err = dnode_hold_impl(os, object, DNODE_MUST_BE_ALLOCATED, 0,
223 ASSERT(dn->dn_type != DMU_OT_NONE);
224 dnode_free_range(dn, 0, DMU_OBJECT_END, tx);
226 dnode_rele(dn, FTAG);
232 * Return (in *objectp) the next object which is allocated (or a hole)
233 * after *object, taking into account only objects that may have been modified
234 * after the specified txg.
237 dmu_object_next(objset_t *os, uint64_t *objectp, boolean_t hole, uint64_t txg)
240 dmu_object_info_t doi;
241 struct dsl_dataset *ds = os->os_dsl_dataset;
246 * Avoid expensive dnode hold if this dataset doesn't use large dnodes.
248 if (ds && ds->ds_feature_inuse[SPA_FEATURE_LARGE_DNODE]) {
249 error = dmu_object_info(os, *objectp, &doi);
250 if (error && !(error == EINVAL && *objectp == 0))
251 return (SET_ERROR(error));
253 dnodesize = doi.doi_dnodesize;
255 dnodesize = DNODE_MIN_SIZE;
259 offset = 1 << DNODE_SHIFT;
261 offset = (*objectp << DNODE_SHIFT) + dnodesize;
263 error = dnode_next_offset(DMU_META_DNODE(os),
264 (hole ? DNODE_FIND_HOLE : 0), &offset, 0, DNODES_PER_BLOCK, txg);
266 *objectp = offset >> DNODE_SHIFT;
272 * Turn this object from old_type into DMU_OTN_ZAP_METADATA, and bump the
273 * refcount on SPA_FEATURE_EXTENSIBLE_DATASET.
275 * Only for use from syncing context, on MOS objects.
278 dmu_object_zapify(objset_t *mos, uint64_t object, dmu_object_type_t old_type,
283 ASSERT(dmu_tx_is_syncing(tx));
285 VERIFY0(dnode_hold(mos, object, FTAG, &dn));
286 if (dn->dn_type == DMU_OTN_ZAP_METADATA) {
287 dnode_rele(dn, FTAG);
290 ASSERT3U(dn->dn_type, ==, old_type);
291 ASSERT0(dn->dn_maxblkid);
292 dn->dn_next_type[tx->tx_txg & TXG_MASK] = dn->dn_type =
293 DMU_OTN_ZAP_METADATA;
294 dnode_setdirty(dn, tx);
295 dnode_rele(dn, FTAG);
297 mzap_create_impl(mos, object, 0, 0, tx);
299 spa_feature_incr(dmu_objset_spa(mos),
300 SPA_FEATURE_EXTENSIBLE_DATASET, tx);
304 dmu_object_free_zapified(objset_t *mos, uint64_t object, dmu_tx_t *tx)
309 ASSERT(dmu_tx_is_syncing(tx));
311 VERIFY0(dnode_hold(mos, object, FTAG, &dn));
313 dnode_rele(dn, FTAG);
315 if (t == DMU_OTN_ZAP_METADATA) {
316 spa_feature_decr(dmu_objset_spa(mos),
317 SPA_FEATURE_EXTENSIBLE_DATASET, tx);
319 VERIFY0(dmu_object_free(mos, object, tx));
322 #if defined(_KERNEL) && defined(HAVE_SPL)
323 EXPORT_SYMBOL(dmu_object_alloc);
324 EXPORT_SYMBOL(dmu_object_alloc_dnsize);
325 EXPORT_SYMBOL(dmu_object_claim);
326 EXPORT_SYMBOL(dmu_object_claim_dnsize);
327 EXPORT_SYMBOL(dmu_object_reclaim);
328 EXPORT_SYMBOL(dmu_object_reclaim_dnsize);
329 EXPORT_SYMBOL(dmu_object_free);
330 EXPORT_SYMBOL(dmu_object_next);
331 EXPORT_SYMBOL(dmu_object_zapify);
332 EXPORT_SYMBOL(dmu_object_free_zapified);