Print this page
5056 ZFS deadlock on db_mtx and dn_holds
Reviewed by: Will Andrews <willa@spectralogic.com>
Reviewed by: Matt Ahrens <mahrens@delphix.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
Approved by: Dan McDonald <danmcd@omniti.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/zfs/dsl_userhold.c
+++ new/usr/src/uts/common/fs/zfs/dsl_userhold.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
24 24 * Copyright (c) 2013 Steven Hartland. All rights reserved.
25 25 */
26 26
27 27 #include <sys/zfs_context.h>
28 28 #include <sys/dsl_userhold.h>
29 29 #include <sys/dsl_dataset.h>
30 30 #include <sys/dsl_destroy.h>
31 31 #include <sys/dsl_synctask.h>
32 32 #include <sys/dmu_tx.h>
33 33 #include <sys/zfs_onexit.h>
34 34 #include <sys/dsl_pool.h>
35 35 #include <sys/dsl_dir.h>
36 36 #include <sys/zfs_ioctl.h>
37 37 #include <sys/zap.h>
38 38
39 39 typedef struct dsl_dataset_user_hold_arg {
40 40 nvlist_t *dduha_holds;
41 41 nvlist_t *dduha_chkholds;
42 42 nvlist_t *dduha_errlist;
43 43 minor_t dduha_minor;
44 44 } dsl_dataset_user_hold_arg_t;
45 45
46 46 /*
47 47 * If you add new checks here, you may need to add additional checks to the
48 48 * "temporary" case in snapshot_check() in dmu_objset.c.
49 49 */
50 50 int
51 51 dsl_dataset_user_hold_check_one(dsl_dataset_t *ds, const char *htag,
52 52 boolean_t temphold, dmu_tx_t *tx)
53 53 {
54 54 dsl_pool_t *dp = dmu_tx_pool(tx);
55 55 objset_t *mos = dp->dp_meta_objset;
56 56 int error = 0;
57 57
58 58 ASSERT(dsl_pool_config_held(dp));
59 59
60 60 if (strlen(htag) > MAXNAMELEN)
61 61 return (SET_ERROR(E2BIG));
62 62 /* Tempholds have a more restricted length */
63 63 if (temphold && strlen(htag) + MAX_TAG_PREFIX_LEN >= MAXNAMELEN)
64 64 return (SET_ERROR(E2BIG));
65 65
66 66 /* tags must be unique (if ds already exists) */
67 67 if (ds != NULL && dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
68 68 uint64_t value;
69 69
70 70 error = zap_lookup(mos, dsl_dataset_phys(ds)->ds_userrefs_obj,
71 71 htag, 8, 1, &value);
72 72 if (error == 0)
73 73 error = SET_ERROR(EEXIST);
74 74 else if (error == ENOENT)
75 75 error = 0;
76 76 }
77 77
78 78 return (error);
79 79 }
80 80
81 81 static int
82 82 dsl_dataset_user_hold_check(void *arg, dmu_tx_t *tx)
83 83 {
84 84 dsl_dataset_user_hold_arg_t *dduha = arg;
85 85 dsl_pool_t *dp = dmu_tx_pool(tx);
86 86
87 87 if (spa_version(dp->dp_spa) < SPA_VERSION_USERREFS)
88 88 return (SET_ERROR(ENOTSUP));
89 89
90 90 if (!dmu_tx_is_syncing(tx))
91 91 return (0);
92 92
93 93 for (nvpair_t *pair = nvlist_next_nvpair(dduha->dduha_holds, NULL);
94 94 pair != NULL; pair = nvlist_next_nvpair(dduha->dduha_holds, pair)) {
95 95 dsl_dataset_t *ds;
96 96 int error = 0;
97 97 char *htag, *name;
98 98
99 99 /* must be a snapshot */
100 100 name = nvpair_name(pair);
101 101 if (strchr(name, '@') == NULL)
102 102 error = SET_ERROR(EINVAL);
103 103
104 104 if (error == 0)
105 105 error = nvpair_value_string(pair, &htag);
106 106
107 107 if (error == 0)
108 108 error = dsl_dataset_hold(dp, name, FTAG, &ds);
109 109
110 110 if (error == 0) {
111 111 error = dsl_dataset_user_hold_check_one(ds, htag,
112 112 dduha->dduha_minor != 0, tx);
113 113 dsl_dataset_rele(ds, FTAG);
114 114 }
115 115
116 116 if (error == 0) {
117 117 fnvlist_add_string(dduha->dduha_chkholds, name, htag);
118 118 } else {
119 119 /*
120 120 * We register ENOENT errors so they can be correctly
121 121 * reported if needed, such as when all holds fail.
122 122 */
123 123 fnvlist_add_int32(dduha->dduha_errlist, name, error);
124 124 if (error != ENOENT)
125 125 return (error);
126 126 }
127 127 }
128 128
129 129 return (0);
130 130 }
131 131
132 132
133 133 static void
134 134 dsl_dataset_user_hold_sync_one_impl(nvlist_t *tmpholds, dsl_dataset_t *ds,
135 135 const char *htag, minor_t minor, uint64_t now, dmu_tx_t *tx)
136 136 {
137 137 dsl_pool_t *dp = ds->ds_dir->dd_pool;
138 138 objset_t *mos = dp->dp_meta_objset;
139 139 uint64_t zapobj;
140 140
141 141 ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
142 142
143 143 if (dsl_dataset_phys(ds)->ds_userrefs_obj == 0) {
144 144 /*
145 145 * This is the first user hold for this dataset. Create
146 146 * the userrefs zap object.
147 147 */
148 148 dmu_buf_will_dirty(ds->ds_dbuf, tx);
149 149 zapobj = dsl_dataset_phys(ds)->ds_userrefs_obj =
150 150 zap_create(mos, DMU_OT_USERREFS, DMU_OT_NONE, 0, tx);
151 151 } else {
152 152 zapobj = dsl_dataset_phys(ds)->ds_userrefs_obj;
153 153 }
154 154 ds->ds_userrefs++;
155 155
156 156 VERIFY0(zap_add(mos, zapobj, htag, 8, 1, &now, tx));
157 157
158 158 if (minor != 0) {
159 159 char name[MAXNAMELEN];
160 160 nvlist_t *tags;
161 161
162 162 VERIFY0(dsl_pool_user_hold(dp, ds->ds_object,
163 163 htag, now, tx));
164 164 (void) snprintf(name, sizeof (name), "%llx",
165 165 (u_longlong_t)ds->ds_object);
166 166
167 167 if (nvlist_lookup_nvlist(tmpholds, name, &tags) != 0) {
168 168 tags = fnvlist_alloc();
169 169 fnvlist_add_boolean(tags, htag);
170 170 fnvlist_add_nvlist(tmpholds, name, tags);
171 171 fnvlist_free(tags);
172 172 } else {
173 173 fnvlist_add_boolean(tags, htag);
174 174 }
175 175 }
176 176
177 177 spa_history_log_internal_ds(ds, "hold", tx,
178 178 "tag=%s temp=%d refs=%llu",
179 179 htag, minor != 0, ds->ds_userrefs);
180 180 }
181 181
182 182 typedef struct zfs_hold_cleanup_arg {
183 183 char zhca_spaname[MAXNAMELEN];
184 184 uint64_t zhca_spa_load_guid;
185 185 nvlist_t *zhca_holds;
186 186 } zfs_hold_cleanup_arg_t;
187 187
188 188 static void
189 189 dsl_dataset_user_release_onexit(void *arg)
190 190 {
191 191 zfs_hold_cleanup_arg_t *ca = arg;
192 192 spa_t *spa;
193 193 int error;
194 194
195 195 error = spa_open(ca->zhca_spaname, &spa, FTAG);
196 196 if (error != 0) {
197 197 zfs_dbgmsg("couldn't release holds on pool=%s "
198 198 "because pool is no longer loaded",
199 199 ca->zhca_spaname);
200 200 return;
201 201 }
202 202 if (spa_load_guid(spa) != ca->zhca_spa_load_guid) {
203 203 zfs_dbgmsg("couldn't release holds on pool=%s "
204 204 "because pool is no longer loaded (guid doesn't match)",
205 205 ca->zhca_spaname);
206 206 spa_close(spa, FTAG);
207 207 return;
208 208 }
209 209
210 210 (void) dsl_dataset_user_release_tmp(spa_get_dsl(spa), ca->zhca_holds);
211 211 fnvlist_free(ca->zhca_holds);
212 212 kmem_free(ca, sizeof (zfs_hold_cleanup_arg_t));
213 213 spa_close(spa, FTAG);
214 214 }
215 215
216 216 static void
217 217 dsl_onexit_hold_cleanup(spa_t *spa, nvlist_t *holds, minor_t minor)
218 218 {
219 219 zfs_hold_cleanup_arg_t *ca;
220 220
221 221 if (minor == 0 || nvlist_empty(holds)) {
222 222 fnvlist_free(holds);
223 223 return;
224 224 }
225 225
226 226 ASSERT(spa != NULL);
227 227 ca = kmem_alloc(sizeof (*ca), KM_SLEEP);
228 228
229 229 (void) strlcpy(ca->zhca_spaname, spa_name(spa),
230 230 sizeof (ca->zhca_spaname));
231 231 ca->zhca_spa_load_guid = spa_load_guid(spa);
232 232 ca->zhca_holds = holds;
233 233 VERIFY0(zfs_onexit_add_cb(minor,
234 234 dsl_dataset_user_release_onexit, ca, NULL));
235 235 }
236 236
237 237 void
238 238 dsl_dataset_user_hold_sync_one(dsl_dataset_t *ds, const char *htag,
239 239 minor_t minor, uint64_t now, dmu_tx_t *tx)
240 240 {
241 241 nvlist_t *tmpholds;
242 242
243 243 if (minor != 0)
244 244 tmpholds = fnvlist_alloc();
245 245 else
246 246 tmpholds = NULL;
247 247 dsl_dataset_user_hold_sync_one_impl(tmpholds, ds, htag, minor, now, tx);
248 248 dsl_onexit_hold_cleanup(dsl_dataset_get_spa(ds), tmpholds, minor);
249 249 }
250 250
251 251 static void
252 252 dsl_dataset_user_hold_sync(void *arg, dmu_tx_t *tx)
253 253 {
254 254 dsl_dataset_user_hold_arg_t *dduha = arg;
255 255 dsl_pool_t *dp = dmu_tx_pool(tx);
256 256 nvlist_t *tmpholds;
257 257 uint64_t now = gethrestime_sec();
258 258
259 259 if (dduha->dduha_minor != 0)
260 260 tmpholds = fnvlist_alloc();
261 261 else
262 262 tmpholds = NULL;
263 263 for (nvpair_t *pair = nvlist_next_nvpair(dduha->dduha_chkholds, NULL);
264 264 pair != NULL;
265 265 pair = nvlist_next_nvpair(dduha->dduha_chkholds, pair)) {
266 266 dsl_dataset_t *ds;
267 267
268 268 VERIFY0(dsl_dataset_hold(dp, nvpair_name(pair), FTAG, &ds));
269 269 dsl_dataset_user_hold_sync_one_impl(tmpholds, ds,
270 270 fnvpair_value_string(pair), dduha->dduha_minor, now, tx);
271 271 dsl_dataset_rele(ds, FTAG);
272 272 }
273 273 dsl_onexit_hold_cleanup(dp->dp_spa, tmpholds, dduha->dduha_minor);
274 274 }
275 275
276 276 /*
277 277 * The full semantics of this function are described in the comment above
278 278 * lzc_hold().
279 279 *
280 280 * To summarize:
281 281 * holds is nvl of snapname -> holdname
282 282 * errlist will be filled in with snapname -> error
283 283 *
284 284 * The snaphosts must all be in the same pool.
285 285 *
286 286 * Holds for snapshots that don't exist will be skipped.
287 287 *
288 288 * If none of the snapshots for requested holds exist then ENOENT will be
289 289 * returned.
290 290 *
291 291 * If cleanup_minor is not 0, the holds will be temporary, which will be cleaned
292 292 * up when the process exits.
293 293 *
294 294 * On success all the holds, for snapshots that existed, will be created and 0
295 295 * will be returned.
296 296 *
297 297 * On failure no holds will be created, the errlist will be filled in,
298 298 * and an errno will returned.
299 299 *
300 300 * In all cases the errlist will contain entries for holds where the snapshot
301 301 * didn't exist.
302 302 */
303 303 int
304 304 dsl_dataset_user_hold(nvlist_t *holds, minor_t cleanup_minor, nvlist_t *errlist)
305 305 {
306 306 dsl_dataset_user_hold_arg_t dduha;
307 307 nvpair_t *pair;
308 308 int ret;
309 309
310 310 pair = nvlist_next_nvpair(holds, NULL);
311 311 if (pair == NULL)
312 312 return (0);
313 313
314 314 dduha.dduha_holds = holds;
315 315 dduha.dduha_chkholds = fnvlist_alloc();
316 316 dduha.dduha_errlist = errlist;
317 317 dduha.dduha_minor = cleanup_minor;
318 318
319 319 ret = dsl_sync_task(nvpair_name(pair), dsl_dataset_user_hold_check,
320 320 dsl_dataset_user_hold_sync, &dduha,
321 321 fnvlist_num_pairs(holds), ZFS_SPACE_CHECK_RESERVED);
322 322 fnvlist_free(dduha.dduha_chkholds);
323 323
324 324 return (ret);
325 325 }
326 326
327 327 typedef int (dsl_holdfunc_t)(dsl_pool_t *dp, const char *name, void *tag,
328 328 dsl_dataset_t **dsp);
329 329
330 330 typedef struct dsl_dataset_user_release_arg {
331 331 dsl_holdfunc_t *ddura_holdfunc;
332 332 nvlist_t *ddura_holds;
333 333 nvlist_t *ddura_todelete;
334 334 nvlist_t *ddura_errlist;
335 335 nvlist_t *ddura_chkholds;
336 336 } dsl_dataset_user_release_arg_t;
337 337
338 338 /* Place a dataset hold on the snapshot identified by passed dsobj string */
339 339 static int
340 340 dsl_dataset_hold_obj_string(dsl_pool_t *dp, const char *dsobj, void *tag,
341 341 dsl_dataset_t **dsp)
342 342 {
343 343 return (dsl_dataset_hold_obj(dp, strtonum(dsobj, NULL), tag, dsp));
344 344 }
|
↓ open down ↓ |
344 lines elided |
↑ open up ↑ |
345 345
346 346 static int
347 347 dsl_dataset_user_release_check_one(dsl_dataset_user_release_arg_t *ddura,
348 348 dsl_dataset_t *ds, nvlist_t *holds, const char *snapname)
349 349 {
350 350 uint64_t zapobj;
351 351 nvlist_t *holds_found;
352 352 objset_t *mos;
353 353 int numholds;
354 354
355 - if (!dsl_dataset_is_snapshot(ds))
355 + if (!ds->ds_is_snapshot)
356 356 return (SET_ERROR(EINVAL));
357 357
358 358 if (nvlist_empty(holds))
359 359 return (0);
360 360
361 361 numholds = 0;
362 362 mos = ds->ds_dir->dd_pool->dp_meta_objset;
363 363 zapobj = dsl_dataset_phys(ds)->ds_userrefs_obj;
364 364 holds_found = fnvlist_alloc();
365 365
366 366 for (nvpair_t *pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
367 367 pair = nvlist_next_nvpair(holds, pair)) {
368 368 uint64_t tmp;
369 369 int error;
370 370 const char *holdname = nvpair_name(pair);
371 371
372 372 if (zapobj != 0)
373 373 error = zap_lookup(mos, zapobj, holdname, 8, 1, &tmp);
374 374 else
375 375 error = SET_ERROR(ENOENT);
376 376
377 377 /*
378 378 * Non-existent holds are put on the errlist, but don't
379 379 * cause an overall failure.
380 380 */
381 381 if (error == ENOENT) {
382 382 if (ddura->ddura_errlist != NULL) {
383 383 char *errtag = kmem_asprintf("%s#%s",
384 384 snapname, holdname);
385 385 fnvlist_add_int32(ddura->ddura_errlist, errtag,
386 386 ENOENT);
387 387 strfree(errtag);
388 388 }
389 389 continue;
390 390 }
391 391
392 392 if (error != 0) {
393 393 fnvlist_free(holds_found);
394 394 return (error);
395 395 }
396 396
397 397 fnvlist_add_boolean(holds_found, holdname);
398 398 numholds++;
399 399 }
400 400
401 401 if (DS_IS_DEFER_DESTROY(ds) &&
402 402 dsl_dataset_phys(ds)->ds_num_children == 1 &&
403 403 ds->ds_userrefs == numholds) {
404 404 /* we need to destroy the snapshot as well */
405 405 if (dsl_dataset_long_held(ds)) {
406 406 fnvlist_free(holds_found);
407 407 return (SET_ERROR(EBUSY));
408 408 }
409 409 fnvlist_add_boolean(ddura->ddura_todelete, snapname);
410 410 }
411 411
412 412 if (numholds != 0) {
413 413 fnvlist_add_nvlist(ddura->ddura_chkholds, snapname,
414 414 holds_found);
415 415 }
416 416 fnvlist_free(holds_found);
417 417
418 418 return (0);
419 419 }
420 420
421 421 static int
422 422 dsl_dataset_user_release_check(void *arg, dmu_tx_t *tx)
423 423 {
424 424 dsl_dataset_user_release_arg_t *ddura;
425 425 dsl_holdfunc_t *holdfunc;
426 426 dsl_pool_t *dp;
427 427
428 428 if (!dmu_tx_is_syncing(tx))
429 429 return (0);
430 430
431 431 dp = dmu_tx_pool(tx);
432 432
433 433 ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
434 434
435 435 ddura = arg;
436 436 holdfunc = ddura->ddura_holdfunc;
437 437
438 438 for (nvpair_t *pair = nvlist_next_nvpair(ddura->ddura_holds, NULL);
439 439 pair != NULL; pair = nvlist_next_nvpair(ddura->ddura_holds, pair)) {
440 440 int error;
441 441 dsl_dataset_t *ds;
442 442 nvlist_t *holds;
443 443 const char *snapname = nvpair_name(pair);
444 444
445 445 error = nvpair_value_nvlist(pair, &holds);
446 446 if (error != 0)
447 447 error = (SET_ERROR(EINVAL));
448 448 else
449 449 error = holdfunc(dp, snapname, FTAG, &ds);
450 450 if (error == 0) {
451 451 error = dsl_dataset_user_release_check_one(ddura, ds,
452 452 holds, snapname);
453 453 dsl_dataset_rele(ds, FTAG);
454 454 }
455 455 if (error != 0) {
456 456 if (ddura->ddura_errlist != NULL) {
457 457 fnvlist_add_int32(ddura->ddura_errlist,
458 458 snapname, error);
459 459 }
460 460 /*
461 461 * Non-existent snapshots are put on the errlist,
462 462 * but don't cause an overall failure.
463 463 */
464 464 if (error != ENOENT)
465 465 return (error);
466 466 }
467 467 }
468 468
469 469 return (0);
470 470 }
471 471
472 472 static void
473 473 dsl_dataset_user_release_sync_one(dsl_dataset_t *ds, nvlist_t *holds,
474 474 dmu_tx_t *tx)
475 475 {
476 476 dsl_pool_t *dp = ds->ds_dir->dd_pool;
477 477 objset_t *mos = dp->dp_meta_objset;
478 478
479 479 for (nvpair_t *pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
480 480 pair = nvlist_next_nvpair(holds, pair)) {
481 481 int error;
482 482 const char *holdname = nvpair_name(pair);
483 483
484 484 /* Remove temporary hold if one exists. */
485 485 error = dsl_pool_user_release(dp, ds->ds_object, holdname, tx);
486 486 VERIFY(error == 0 || error == ENOENT);
487 487
488 488 VERIFY0(zap_remove(mos, dsl_dataset_phys(ds)->ds_userrefs_obj,
489 489 holdname, tx));
490 490 ds->ds_userrefs--;
491 491
492 492 spa_history_log_internal_ds(ds, "release", tx,
493 493 "tag=%s refs=%lld", holdname, (longlong_t)ds->ds_userrefs);
494 494 }
495 495 }
496 496
497 497 static void
498 498 dsl_dataset_user_release_sync(void *arg, dmu_tx_t *tx)
499 499 {
500 500 dsl_dataset_user_release_arg_t *ddura = arg;
501 501 dsl_holdfunc_t *holdfunc = ddura->ddura_holdfunc;
502 502 dsl_pool_t *dp = dmu_tx_pool(tx);
503 503
504 504 ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
505 505
506 506 for (nvpair_t *pair = nvlist_next_nvpair(ddura->ddura_chkholds, NULL);
507 507 pair != NULL; pair = nvlist_next_nvpair(ddura->ddura_chkholds,
508 508 pair)) {
509 509 dsl_dataset_t *ds;
510 510 const char *name = nvpair_name(pair);
511 511
512 512 VERIFY0(holdfunc(dp, name, FTAG, &ds));
513 513
514 514 dsl_dataset_user_release_sync_one(ds,
515 515 fnvpair_value_nvlist(pair), tx);
516 516 if (nvlist_exists(ddura->ddura_todelete, name)) {
517 517 ASSERT(ds->ds_userrefs == 0 &&
518 518 dsl_dataset_phys(ds)->ds_num_children == 1 &&
519 519 DS_IS_DEFER_DESTROY(ds));
520 520 dsl_destroy_snapshot_sync_impl(ds, B_FALSE, tx);
521 521 }
522 522 dsl_dataset_rele(ds, FTAG);
523 523 }
524 524 }
525 525
526 526 /*
527 527 * The full semantics of this function are described in the comment above
528 528 * lzc_release().
529 529 *
530 530 * To summarize:
531 531 * Releases holds specified in the nvl holds.
532 532 *
533 533 * holds is nvl of snapname -> { holdname, ... }
534 534 * errlist will be filled in with snapname -> error
535 535 *
536 536 * If tmpdp is not NULL the names for holds should be the dsobj's of snapshots,
537 537 * otherwise they should be the names of shapshots.
538 538 *
539 539 * As a release may cause snapshots to be destroyed this trys to ensure they
540 540 * aren't mounted.
541 541 *
542 542 * The release of non-existent holds are skipped.
543 543 *
544 544 * At least one hold must have been released for the this function to succeed
545 545 * and return 0.
546 546 */
547 547 static int
548 548 dsl_dataset_user_release_impl(nvlist_t *holds, nvlist_t *errlist,
549 549 dsl_pool_t *tmpdp)
550 550 {
551 551 dsl_dataset_user_release_arg_t ddura;
552 552 nvpair_t *pair;
553 553 char *pool;
554 554 int error;
555 555
556 556 pair = nvlist_next_nvpair(holds, NULL);
557 557 if (pair == NULL)
558 558 return (0);
559 559
560 560 /*
561 561 * The release may cause snapshots to be destroyed; make sure they
562 562 * are not mounted.
563 563 */
564 564 if (tmpdp != NULL) {
565 565 /* Temporary holds are specified by dsobj string. */
566 566 ddura.ddura_holdfunc = dsl_dataset_hold_obj_string;
567 567 pool = spa_name(tmpdp->dp_spa);
568 568 #ifdef _KERNEL
569 569 for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
570 570 pair = nvlist_next_nvpair(holds, pair)) {
571 571 dsl_dataset_t *ds;
572 572
573 573 dsl_pool_config_enter(tmpdp, FTAG);
574 574 error = dsl_dataset_hold_obj_string(tmpdp,
575 575 nvpair_name(pair), FTAG, &ds);
576 576 if (error == 0) {
577 577 char name[MAXNAMELEN];
578 578 dsl_dataset_name(ds, name);
579 579 dsl_pool_config_exit(tmpdp, FTAG);
580 580 dsl_dataset_rele(ds, FTAG);
581 581 (void) zfs_unmount_snap(name);
582 582 } else {
583 583 dsl_pool_config_exit(tmpdp, FTAG);
584 584 }
585 585 }
586 586 #endif
587 587 } else {
588 588 /* Non-temporary holds are specified by name. */
589 589 ddura.ddura_holdfunc = dsl_dataset_hold;
590 590 pool = nvpair_name(pair);
591 591 #ifdef _KERNEL
592 592 for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
593 593 pair = nvlist_next_nvpair(holds, pair)) {
594 594 (void) zfs_unmount_snap(nvpair_name(pair));
595 595 }
596 596 #endif
597 597 }
598 598
599 599 ddura.ddura_holds = holds;
600 600 ddura.ddura_errlist = errlist;
601 601 ddura.ddura_todelete = fnvlist_alloc();
602 602 ddura.ddura_chkholds = fnvlist_alloc();
603 603
604 604 error = dsl_sync_task(pool, dsl_dataset_user_release_check,
605 605 dsl_dataset_user_release_sync, &ddura, 0, ZFS_SPACE_CHECK_NONE);
606 606 fnvlist_free(ddura.ddura_todelete);
607 607 fnvlist_free(ddura.ddura_chkholds);
608 608
609 609 return (error);
610 610 }
611 611
612 612 /*
613 613 * holds is nvl of snapname -> { holdname, ... }
614 614 * errlist will be filled in with snapname -> error
615 615 */
616 616 int
617 617 dsl_dataset_user_release(nvlist_t *holds, nvlist_t *errlist)
618 618 {
619 619 return (dsl_dataset_user_release_impl(holds, errlist, NULL));
620 620 }
621 621
622 622 /*
623 623 * holds is nvl of snapdsobj -> { holdname, ... }
624 624 */
625 625 void
626 626 dsl_dataset_user_release_tmp(struct dsl_pool *dp, nvlist_t *holds)
627 627 {
628 628 ASSERT(dp != NULL);
629 629 (void) dsl_dataset_user_release_impl(holds, NULL, dp);
630 630 }
631 631
632 632 int
633 633 dsl_dataset_get_holds(const char *dsname, nvlist_t *nvl)
634 634 {
635 635 dsl_pool_t *dp;
636 636 dsl_dataset_t *ds;
637 637 int err;
638 638
639 639 err = dsl_pool_hold(dsname, FTAG, &dp);
640 640 if (err != 0)
641 641 return (err);
642 642 err = dsl_dataset_hold(dp, dsname, FTAG, &ds);
643 643 if (err != 0) {
644 644 dsl_pool_rele(dp, FTAG);
645 645 return (err);
646 646 }
647 647
648 648 if (dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
649 649 zap_attribute_t *za;
650 650 zap_cursor_t zc;
651 651
652 652 za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);
653 653 for (zap_cursor_init(&zc, ds->ds_dir->dd_pool->dp_meta_objset,
654 654 dsl_dataset_phys(ds)->ds_userrefs_obj);
655 655 zap_cursor_retrieve(&zc, za) == 0;
656 656 zap_cursor_advance(&zc)) {
657 657 fnvlist_add_uint64(nvl, za->za_name,
658 658 za->za_first_integer);
659 659 }
660 660 zap_cursor_fini(&zc);
661 661 kmem_free(za, sizeof (zap_attribute_t));
662 662 }
663 663 dsl_dataset_rele(ds, FTAG);
664 664 dsl_pool_rele(dp, FTAG);
665 665 return (0);
666 666 }
|
↓ open down ↓ |
301 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX