initial commit
[freebsd-arm:freebsd-arm.git] / cddl / contrib / opensolaris / uts / common / fs / zfs / dsl_pool.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/dsl_pool.h>
27 #include <sys/dsl_dataset.h>
28 #include <sys/dsl_dir.h>
29 #include <sys/dsl_synctask.h>
30 #include <sys/dmu_tx.h>
31 #include <sys/dmu_objset.h>
32 #include <sys/arc.h>
33 #include <sys/zap.h>
34 #include <sys/zio.h>
35 #include <sys/zfs_context.h>
36 #include <sys/fs/zfs.h>
37 #include <sys/zfs_znode.h>
38 #include <sys/spa_impl.h>
39
40 int zfs_no_write_throttle = 0;
41 int zfs_write_limit_shift = 3;                  /* 1/8th of physical memory */
42 int zfs_txg_synctime = 5;                       /* target secs to sync a txg */
43
44 uint64_t zfs_write_limit_min = 32 << 20;        /* min write limit is 32MB */
45 uint64_t zfs_write_limit_max = 0;               /* max data payload per txg */
46 uint64_t zfs_write_limit_inflated = 0;
47 uint64_t zfs_write_limit_override = 0;
48 extern uint64_t zfs_write_limit_min;
49
50 kmutex_t zfs_write_limit_lock;
51
52 static pgcnt_t old_physmem = 0;
53
54 static int
55 dsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **ddp)
56 {
57         uint64_t obj;
58         int err;
59
60         err = zap_lookup(dp->dp_meta_objset,
61             dp->dp_root_dir->dd_phys->dd_child_dir_zapobj,
62             name, sizeof (obj), 1, &obj);
63         if (err)
64                 return (err);
65
66         return (dsl_dir_open_obj(dp, obj, name, dp, ddp));
67 }
68
69 static dsl_pool_t *
70 dsl_pool_open_impl(spa_t *spa, uint64_t txg)
71 {
72         dsl_pool_t *dp;
73         blkptr_t *bp = spa_get_rootblkptr(spa);
74
75         dp = kmem_zalloc(sizeof (dsl_pool_t), KM_SLEEP);
76         dp->dp_spa = spa;
77         dp->dp_meta_rootbp = *bp;
78         rw_init(&dp->dp_config_rwlock, NULL, RW_DEFAULT, NULL);
79         dp->dp_write_limit = zfs_write_limit_min;
80         txg_init(dp, txg);
81
82         txg_list_create(&dp->dp_dirty_datasets,
83             offsetof(dsl_dataset_t, ds_dirty_link));
84         txg_list_create(&dp->dp_dirty_dirs,
85             offsetof(dsl_dir_t, dd_dirty_link));
86         txg_list_create(&dp->dp_sync_tasks,
87             offsetof(dsl_sync_task_group_t, dstg_node));
88         list_create(&dp->dp_synced_datasets, sizeof (dsl_dataset_t),
89             offsetof(dsl_dataset_t, ds_synced_link));
90
91         mutex_init(&dp->dp_lock, NULL, MUTEX_DEFAULT, NULL);
92         mutex_init(&dp->dp_scrub_cancel_lock, NULL, MUTEX_DEFAULT, NULL);
93
94         dp->dp_vnrele_taskq = taskq_create("zfs_vn_rele_taskq", 1, minclsyspri,
95             1, 4, 0);
96
97         return (dp);
98 }
99
100 int
101 dsl_pool_open(spa_t *spa, uint64_t txg, dsl_pool_t **dpp)
102 {
103         int err;
104         dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
105         dsl_dir_t *dd;
106         dsl_dataset_t *ds;
107         objset_impl_t *osi;
108
109         rw_enter(&dp->dp_config_rwlock, RW_WRITER);
110         err = dmu_objset_open_impl(spa, NULL, &dp->dp_meta_rootbp, &osi);
111         if (err)
112                 goto out;
113         dp->dp_meta_objset = &osi->os;
114
115         err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
116             DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1,
117             &dp->dp_root_dir_obj);
118         if (err)
119                 goto out;
120
121         err = dsl_dir_open_obj(dp, dp->dp_root_dir_obj,
122             NULL, dp, &dp->dp_root_dir);
123         if (err)
124                 goto out;
125
126         err = dsl_pool_open_special_dir(dp, MOS_DIR_NAME, &dp->dp_mos_dir);
127         if (err)
128                 goto out;
129
130         if (spa_version(spa) >= SPA_VERSION_ORIGIN) {
131                 err = dsl_pool_open_special_dir(dp, ORIGIN_DIR_NAME, &dd);
132                 if (err)
133                         goto out;
134                 err = dsl_dataset_hold_obj(dp, dd->dd_phys->dd_head_dataset_obj,
135                     FTAG, &ds);
136                 if (err)
137                         goto out;
138                 err = dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj,
139                     dp, &dp->dp_origin_snap);
140                 if (err)
141                         goto out;
142                 dsl_dataset_rele(ds, FTAG);
143                 dsl_dir_close(dd, dp);
144         }
145
146         /* get scrub status */
147         err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
148             DMU_POOL_SCRUB_FUNC, sizeof (uint32_t), 1,
149             &dp->dp_scrub_func);
150         if (err == 0) {
151                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
152                     DMU_POOL_SCRUB_QUEUE, sizeof (uint64_t), 1,
153                     &dp->dp_scrub_queue_obj);
154                 if (err)
155                         goto out;
156                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
157                     DMU_POOL_SCRUB_MIN_TXG, sizeof (uint64_t), 1,
158                     &dp->dp_scrub_min_txg);
159                 if (err)
160                         goto out;
161                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
162                     DMU_POOL_SCRUB_MAX_TXG, sizeof (uint64_t), 1,
163                     &dp->dp_scrub_max_txg);
164                 if (err)
165                         goto out;
166                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
167                     DMU_POOL_SCRUB_BOOKMARK, sizeof (uint64_t), 4,
168                     &dp->dp_scrub_bookmark);
169                 if (err)
170                         goto out;
171                 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
172                     DMU_POOL_SCRUB_ERRORS, sizeof (uint64_t), 1,
173                     &spa->spa_scrub_errors);
174                 if (err)
175                         goto out;
176                 if (spa_version(spa) < SPA_VERSION_DSL_SCRUB) {
177                         /*
178                          * A new-type scrub was in progress on an old
179                          * pool.  Restart from the beginning, since the
180                          * old software may have changed the pool in the
181                          * meantime.
182                          */
183                         dsl_pool_scrub_restart(dp);
184                 }
185         } else {
186                 /*
187                  * It's OK if there is no scrub in progress (and if
188                  * there was an I/O error, ignore it).
189                  */
190                 err = 0;
191         }
192
193 out:
194         rw_exit(&dp->dp_config_rwlock);
195         if (err)
196                 dsl_pool_close(dp);
197         else
198                 *dpp = dp;
199
200         return (err);
201 }
202
203 void
204 dsl_pool_close(dsl_pool_t *dp)
205 {
206         /* drop our references from dsl_pool_open() */
207
208         /*
209          * Since we held the origin_snap from "syncing" context (which
210          * includes pool-opening context), it actually only got a "ref"
211          * and not a hold, so just drop that here.
212          */
213         if (dp->dp_origin_snap)
214                 dsl_dataset_drop_ref(dp->dp_origin_snap, dp);
215         if (dp->dp_mos_dir)
216                 dsl_dir_close(dp->dp_mos_dir, dp);
217         if (dp->dp_root_dir)
218                 dsl_dir_close(dp->dp_root_dir, dp);
219
220         /* undo the dmu_objset_open_impl(mos) from dsl_pool_open() */
221         if (dp->dp_meta_objset)
222                 dmu_objset_evict(NULL, dp->dp_meta_objset->os);
223
224         txg_list_destroy(&dp->dp_dirty_datasets);
225         txg_list_destroy(&dp->dp_dirty_dirs);
226         txg_list_destroy(&dp->dp_sync_tasks);
227         list_destroy(&dp->dp_synced_datasets);
228
229         arc_flush(dp->dp_spa);
230         txg_fini(dp);
231         rw_destroy(&dp->dp_config_rwlock);
232         mutex_destroy(&dp->dp_lock);
233         mutex_destroy(&dp->dp_scrub_cancel_lock);
234         taskq_destroy(dp->dp_vnrele_taskq);
235         kmem_free(dp, sizeof (dsl_pool_t));
236 }
237
238 dsl_pool_t *
239 dsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg)
240 {
241         int err;
242         dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
243         dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg);
244         objset_impl_t *osip;
245         dsl_dataset_t *ds;
246         uint64_t dsobj;
247
248         /* create and open the MOS (meta-objset) */
249         dp->dp_meta_objset = &dmu_objset_create_impl(spa,
250             NULL, &dp->dp_meta_rootbp, DMU_OST_META, tx)->os;
251
252         /* create the pool directory */
253         err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
254             DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx);
255         ASSERT3U(err, ==, 0);
256
257         /* create and open the root dir */
258         dp->dp_root_dir_obj = dsl_dir_create_sync(dp, NULL, NULL, tx);
259         VERIFY(0 == dsl_dir_open_obj(dp, dp->dp_root_dir_obj,
260             NULL, dp, &dp->dp_root_dir));
261
262         /* create and open the meta-objset dir */
263         (void) dsl_dir_create_sync(dp, dp->dp_root_dir, MOS_DIR_NAME, tx);
264         VERIFY(0 == dsl_pool_open_special_dir(dp,
265             MOS_DIR_NAME, &dp->dp_mos_dir));
266
267         if (spa_version(spa) >= SPA_VERSION_DSL_SCRUB)
268                 dsl_pool_create_origin(dp, tx);
269
270         /* create the root dataset */
271         dsobj = dsl_dataset_create_sync_dd(dp->dp_root_dir, NULL, 0, tx);
272
273         /* create the root objset */
274         VERIFY(0 == dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
275         osip = dmu_objset_create_impl(dp->dp_spa, ds,
276             dsl_dataset_get_blkptr(ds), DMU_OST_ZFS, tx);
277 #ifdef _KERNEL
278         zfs_create_fs(&osip->os, kcred, zplprops, tx);
279 #endif
280         dsl_dataset_rele(ds, FTAG);
281
282         dmu_tx_commit(tx);
283
284         return (dp);
285 }
286
287 void
288 dsl_pool_sync(dsl_pool_t *dp, uint64_t txg)
289 {
290         zio_t *zio;
291         dmu_tx_t *tx;
292         dsl_dir_t *dd;
293         dsl_dataset_t *ds;
294         dsl_sync_task_group_t *dstg;
295         objset_impl_t *mosi = dp->dp_meta_objset->os;
296         hrtime_t start, write_time;
297         uint64_t data_written;
298         int err;
299
300         tx = dmu_tx_create_assigned(dp, txg);
301
302         dp->dp_read_overhead = 0;
303         zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
304         while (ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) {
305                 if (!list_link_active(&ds->ds_synced_link))
306                         list_insert_tail(&dp->dp_synced_datasets, ds);
307                 else
308                         dmu_buf_rele(ds->ds_dbuf, ds);
309                 dsl_dataset_sync(ds, zio, tx);
310         }
311         DTRACE_PROBE(pool_sync__1setup);
312
313         start = gethrtime();
314         err = zio_wait(zio);
315         write_time = gethrtime() - start;
316         ASSERT(err == 0);
317         DTRACE_PROBE(pool_sync__2rootzio);
318
319         while (dstg = txg_list_remove(&dp->dp_sync_tasks, txg))
320                 dsl_sync_task_group_sync(dstg, tx);
321         DTRACE_PROBE(pool_sync__3task);
322
323         start = gethrtime();
324         while (dd = txg_list_remove(&dp->dp_dirty_dirs, txg))
325                 dsl_dir_sync(dd, tx);
326         write_time += gethrtime() - start;
327
328         if (spa_sync_pass(dp->dp_spa) == 1)
329                 dsl_pool_scrub_sync(dp, tx);
330
331         start = gethrtime();
332         if (list_head(&mosi->os_dirty_dnodes[txg & TXG_MASK]) != NULL ||
333             list_head(&mosi->os_free_dnodes[txg & TXG_MASK]) != NULL) {
334                 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
335                 dmu_objset_sync(mosi, zio, tx);
336                 err = zio_wait(zio);
337                 ASSERT(err == 0);
338                 dprintf_bp(&dp->dp_meta_rootbp, "meta objset rootbp is %s", "");
339                 spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp);
340         }
341         write_time += gethrtime() - start;
342         DTRACE_PROBE2(pool_sync__4io, hrtime_t, write_time,
343             hrtime_t, dp->dp_read_overhead);
344         write_time -= dp->dp_read_overhead;
345
346         dmu_tx_commit(tx);
347
348         data_written = dp->dp_space_towrite[txg & TXG_MASK];
349         dp->dp_space_towrite[txg & TXG_MASK] = 0;
350         ASSERT(dp->dp_tempreserved[txg & TXG_MASK] == 0);
351
352         /*
353          * If the write limit max has not been explicitly set, set it
354          * to a fraction of available physical memory (default 1/8th).
355          * Note that we must inflate the limit because the spa
356          * inflates write sizes to account for data replication.
357          * Check this each sync phase to catch changing memory size.
358          */
359         if (physmem != old_physmem && zfs_write_limit_shift) {
360                 mutex_enter(&zfs_write_limit_lock);
361                 old_physmem = physmem;
362                 zfs_write_limit_max = ptob(physmem) >> zfs_write_limit_shift;
363                 zfs_write_limit_inflated = MAX(zfs_write_limit_min,
364                     spa_get_asize(dp->dp_spa, zfs_write_limit_max));
365                 mutex_exit(&zfs_write_limit_lock);
366         }
367
368         /*
369          * Attempt to keep the sync time consistent by adjusting the
370          * amount of write traffic allowed into each transaction group.
371          * Weight the throughput calculation towards the current value:
372          *      thru = 3/4 old_thru + 1/4 new_thru
373          */
374         ASSERT(zfs_write_limit_min > 0);
375         if (data_written > zfs_write_limit_min / 8 && write_time > 0) {
376                 uint64_t throughput = (data_written * NANOSEC) / write_time;
377                 if (dp->dp_throughput)
378                         dp->dp_throughput = throughput / 4 +
379                             3 * dp->dp_throughput / 4;
380                 else
381                         dp->dp_throughput = throughput;
382                 dp->dp_write_limit = MIN(zfs_write_limit_inflated,
383                     MAX(zfs_write_limit_min,
384                     dp->dp_throughput * zfs_txg_synctime));
385         }
386 }
387
388 void
389 dsl_pool_zil_clean(dsl_pool_t *dp)
390 {
391         dsl_dataset_t *ds;
392
393         while (ds = list_head(&dp->dp_synced_datasets)) {
394                 list_remove(&dp->dp_synced_datasets, ds);
395                 ASSERT(ds->ds_user_ptr != NULL);
396                 zil_clean(((objset_impl_t *)ds->ds_user_ptr)->os_zil);
397                 dmu_buf_rele(ds->ds_dbuf, ds);
398         }
399 }
400
401 /*
402  * TRUE if the current thread is the tx_sync_thread or if we
403  * are being called from SPA context during pool initialization.
404  */
405 int
406 dsl_pool_sync_context(dsl_pool_t *dp)
407 {
408         return (curthread == dp->dp_tx.tx_sync_thread ||
409             spa_get_dsl(dp->dp_spa) == NULL);
410 }
411
412 uint64_t
413 dsl_pool_adjustedsize(dsl_pool_t *dp, boolean_t netfree)
414 {
415         uint64_t space, resv;
416
417         /*
418          * Reserve about 1.6% (1/64), or at least 32MB, for allocation
419          * efficiency.
420          * XXX The intent log is not accounted for, so it must fit
421          * within this slop.
422          *
423          * If we're trying to assess whether it's OK to do a free,
424          * cut the reservation in half to allow forward progress
425          * (e.g. make it possible to rm(1) files from a full pool).
426          */
427         space = spa_get_dspace(dp->dp_spa);
428         resv = MAX(space >> 6, SPA_MINDEVSIZE >> 1);
429         if (netfree)
430                 resv >>= 1;
431
432         return (space - resv);
433 }
434
435 int
436 dsl_pool_tempreserve_space(dsl_pool_t *dp, uint64_t space, dmu_tx_t *tx)
437 {
438         uint64_t reserved = 0;
439         uint64_t write_limit = (zfs_write_limit_override ?
440             zfs_write_limit_override : dp->dp_write_limit);
441
442         if (zfs_no_write_throttle) {
443                 atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK],
444                     space);
445                 return (0);
446         }
447
448         /*
449          * Check to see if we have exceeded the maximum allowed IO for
450          * this transaction group.  We can do this without locks since
451          * a little slop here is ok.  Note that we do the reserved check
452          * with only half the requested reserve: this is because the
453          * reserve requests are worst-case, and we really don't want to
454          * throttle based off of worst-case estimates.
455          */
456         if (write_limit > 0) {
457                 reserved = dp->dp_space_towrite[tx->tx_txg & TXG_MASK]
458                     + dp->dp_tempreserved[tx->tx_txg & TXG_MASK] / 2;
459
460                 if (reserved && reserved > write_limit)
461                         return (ERESTART);
462         }
463
464         atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], space);
465
466         /*
467          * If this transaction group is over 7/8ths capacity, delay
468          * the caller 1 clock tick.  This will slow down the "fill"
469          * rate until the sync process can catch up with us.
470          */
471         if (reserved && reserved > (write_limit - (write_limit >> 3)))
472                 txg_delay(dp, tx->tx_txg, 1);
473
474         return (0);
475 }
476
477 void
478 dsl_pool_tempreserve_clear(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx)
479 {
480         ASSERT(dp->dp_tempreserved[tx->tx_txg & TXG_MASK] >= space);
481         atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], -space);
482 }
483
484 void
485 dsl_pool_memory_pressure(dsl_pool_t *dp)
486 {
487         uint64_t space_inuse = 0;
488         int i;
489
490         if (dp->dp_write_limit == zfs_write_limit_min)
491                 return;
492
493         for (i = 0; i < TXG_SIZE; i++) {
494                 space_inuse += dp->dp_space_towrite[i];
495                 space_inuse += dp->dp_tempreserved[i];
496         }
497         dp->dp_write_limit = MAX(zfs_write_limit_min,
498             MIN(dp->dp_write_limit, space_inuse / 4));
499 }
500
501 void
502 dsl_pool_willuse_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx)
503 {
504         if (space > 0) {
505                 mutex_enter(&dp->dp_lock);
506                 dp->dp_space_towrite[tx->tx_txg & TXG_MASK] += space;
507                 mutex_exit(&dp->dp_lock);
508         }
509 }
510
511 /* ARGSUSED */
512 static int
513 upgrade_clones_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg)
514 {
515         dmu_tx_t *tx = arg;
516         dsl_dataset_t *ds, *prev = NULL;
517         int err;
518         dsl_pool_t *dp = spa_get_dsl(spa);
519
520         err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
521         if (err)
522                 return (err);
523
524         while (ds->ds_phys->ds_prev_snap_obj != 0) {
525                 err = dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj,
526                     FTAG, &prev);
527                 if (err) {
528                         dsl_dataset_rele(ds, FTAG);
529                         return (err);
530                 }
531
532                 if (prev->ds_phys->ds_next_snap_obj != ds->ds_object)
533                         break;
534                 dsl_dataset_rele(ds, FTAG);
535                 ds = prev;
536                 prev = NULL;
537         }
538
539         if (prev == NULL) {
540                 prev = dp->dp_origin_snap;
541
542                 /*
543                  * The $ORIGIN can't have any data, or the accounting
544                  * will be wrong.
545                  */
546                 ASSERT(prev->ds_phys->ds_bp.blk_birth == 0);
547
548                 /* The origin doesn't get attached to itself */
549                 if (ds->ds_object == prev->ds_object) {
550                         dsl_dataset_rele(ds, FTAG);
551                         return (0);
552                 }
553
554                 dmu_buf_will_dirty(ds->ds_dbuf, tx);
555                 ds->ds_phys->ds_prev_snap_obj = prev->ds_object;
556                 ds->ds_phys->ds_prev_snap_txg = prev->ds_phys->ds_creation_txg;
557
558                 dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx);
559                 ds->ds_dir->dd_phys->dd_origin_obj = prev->ds_object;
560
561                 dmu_buf_will_dirty(prev->ds_dbuf, tx);
562                 prev->ds_phys->ds_num_children++;
563
564                 if (ds->ds_phys->ds_next_snap_obj == 0) {
565                         ASSERT(ds->ds_prev == NULL);
566                         VERIFY(0 == dsl_dataset_hold_obj(dp,
567                             ds->ds_phys->ds_prev_snap_obj, ds, &ds->ds_prev));
568                 }
569         }
570
571         ASSERT(ds->ds_dir->dd_phys->dd_origin_obj == prev->ds_object);
572         ASSERT(ds->ds_phys->ds_prev_snap_obj == prev->ds_object);
573
574         if (prev->ds_phys->ds_next_clones_obj == 0) {
575                 prev->ds_phys->ds_next_clones_obj =
576                     zap_create(dp->dp_meta_objset,
577                     DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
578         }
579         VERIFY(0 == zap_add_int(dp->dp_meta_objset,
580             prev->ds_phys->ds_next_clones_obj, ds->ds_object, tx));
581
582         dsl_dataset_rele(ds, FTAG);
583         if (prev != dp->dp_origin_snap)
584                 dsl_dataset_rele(prev, FTAG);
585         return (0);
586 }
587
588 void
589 dsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx)
590 {
591         ASSERT(dmu_tx_is_syncing(tx));
592         ASSERT(dp->dp_origin_snap != NULL);
593
594         (void) dmu_objset_find_spa(dp->dp_spa, NULL, upgrade_clones_cb,
595             tx, DS_FIND_CHILDREN);
596 }
597
598 void
599 dsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx)
600 {
601         uint64_t dsobj;
602         dsl_dataset_t *ds;
603
604         ASSERT(dmu_tx_is_syncing(tx));
605         ASSERT(dp->dp_origin_snap == NULL);
606
607         /* create the origin dir, ds, & snap-ds */
608         rw_enter(&dp->dp_config_rwlock, RW_WRITER);
609         dsobj = dsl_dataset_create_sync(dp->dp_root_dir, ORIGIN_DIR_NAME,
610             NULL, 0, kcred, tx);
611         VERIFY(0 == dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
612         dsl_dataset_snapshot_sync(ds, ORIGIN_DIR_NAME, kcred, tx);
613         VERIFY(0 == dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj,
614             dp, &dp->dp_origin_snap));
615         dsl_dataset_rele(ds, FTAG);
616         rw_exit(&dp->dp_config_rwlock);
617 }
618
619 taskq_t *
620 dsl_pool_vnrele_taskq(dsl_pool_t *dp)
621 {
622         return (dp->dp_vnrele_taskq);
623 }