Print this page
4082 zfs receive gets EFBIG from dmu_tx_hold_free()
Reviewed by: Eric Schrock <eric.schrock@delphix.com>
Reviewed by: Christopher Siden <christopher.siden@delphix.com>
Reviewed by: George Wilson <george.wilson@delphix.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/zfs/dmu.c
+++ new/usr/src/uts/common/fs/zfs/dmu.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) 2013 by Delphix. All rights reserved.
24 24 */
25 25 /* Copyright (c) 2013 by Saso Kiselkov. All rights reserved. */
26 26 /* Copyright (c) 2013, Joyent, Inc. All rights reserved. */
27 27
28 28 #include <sys/dmu.h>
29 29 #include <sys/dmu_impl.h>
30 30 #include <sys/dmu_tx.h>
31 31 #include <sys/dbuf.h>
32 32 #include <sys/dnode.h>
33 33 #include <sys/zfs_context.h>
34 34 #include <sys/dmu_objset.h>
35 35 #include <sys/dmu_traverse.h>
36 36 #include <sys/dsl_dataset.h>
37 37 #include <sys/dsl_dir.h>
38 38 #include <sys/dsl_pool.h>
39 39 #include <sys/dsl_synctask.h>
40 40 #include <sys/dsl_prop.h>
41 41 #include <sys/dmu_zfetch.h>
42 42 #include <sys/zfs_ioctl.h>
43 43 #include <sys/zap.h>
44 44 #include <sys/zio_checksum.h>
45 45 #include <sys/zio_compress.h>
46 46 #include <sys/sa.h>
47 47 #ifdef _KERNEL
48 48 #include <sys/vmsystm.h>
49 49 #include <sys/zfs_znode.h>
50 50 #endif
51 51
52 52 /*
53 53 * Enable/disable nopwrite feature.
54 54 */
55 55 int zfs_nopwrite_enabled = 1;
56 56
57 57 const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES] = {
58 58 { DMU_BSWAP_UINT8, TRUE, "unallocated" },
59 59 { DMU_BSWAP_ZAP, TRUE, "object directory" },
60 60 { DMU_BSWAP_UINT64, TRUE, "object array" },
61 61 { DMU_BSWAP_UINT8, TRUE, "packed nvlist" },
62 62 { DMU_BSWAP_UINT64, TRUE, "packed nvlist size" },
63 63 { DMU_BSWAP_UINT64, TRUE, "bpobj" },
64 64 { DMU_BSWAP_UINT64, TRUE, "bpobj header" },
65 65 { DMU_BSWAP_UINT64, TRUE, "SPA space map header" },
66 66 { DMU_BSWAP_UINT64, TRUE, "SPA space map" },
67 67 { DMU_BSWAP_UINT64, TRUE, "ZIL intent log" },
68 68 { DMU_BSWAP_DNODE, TRUE, "DMU dnode" },
69 69 { DMU_BSWAP_OBJSET, TRUE, "DMU objset" },
70 70 { DMU_BSWAP_UINT64, TRUE, "DSL directory" },
71 71 { DMU_BSWAP_ZAP, TRUE, "DSL directory child map"},
72 72 { DMU_BSWAP_ZAP, TRUE, "DSL dataset snap map" },
73 73 { DMU_BSWAP_ZAP, TRUE, "DSL props" },
74 74 { DMU_BSWAP_UINT64, TRUE, "DSL dataset" },
75 75 { DMU_BSWAP_ZNODE, TRUE, "ZFS znode" },
76 76 { DMU_BSWAP_OLDACL, TRUE, "ZFS V0 ACL" },
77 77 { DMU_BSWAP_UINT8, FALSE, "ZFS plain file" },
78 78 { DMU_BSWAP_ZAP, TRUE, "ZFS directory" },
79 79 { DMU_BSWAP_ZAP, TRUE, "ZFS master node" },
80 80 { DMU_BSWAP_ZAP, TRUE, "ZFS delete queue" },
81 81 { DMU_BSWAP_UINT8, FALSE, "zvol object" },
82 82 { DMU_BSWAP_ZAP, TRUE, "zvol prop" },
83 83 { DMU_BSWAP_UINT8, FALSE, "other uint8[]" },
84 84 { DMU_BSWAP_UINT64, FALSE, "other uint64[]" },
85 85 { DMU_BSWAP_ZAP, TRUE, "other ZAP" },
86 86 { DMU_BSWAP_ZAP, TRUE, "persistent error log" },
87 87 { DMU_BSWAP_UINT8, TRUE, "SPA history" },
88 88 { DMU_BSWAP_UINT64, TRUE, "SPA history offsets" },
89 89 { DMU_BSWAP_ZAP, TRUE, "Pool properties" },
90 90 { DMU_BSWAP_ZAP, TRUE, "DSL permissions" },
91 91 { DMU_BSWAP_ACL, TRUE, "ZFS ACL" },
92 92 { DMU_BSWAP_UINT8, TRUE, "ZFS SYSACL" },
93 93 { DMU_BSWAP_UINT8, TRUE, "FUID table" },
94 94 { DMU_BSWAP_UINT64, TRUE, "FUID table size" },
95 95 { DMU_BSWAP_ZAP, TRUE, "DSL dataset next clones"},
96 96 { DMU_BSWAP_ZAP, TRUE, "scan work queue" },
97 97 { DMU_BSWAP_ZAP, TRUE, "ZFS user/group used" },
98 98 { DMU_BSWAP_ZAP, TRUE, "ZFS user/group quota" },
99 99 { DMU_BSWAP_ZAP, TRUE, "snapshot refcount tags"},
100 100 { DMU_BSWAP_ZAP, TRUE, "DDT ZAP algorithm" },
101 101 { DMU_BSWAP_ZAP, TRUE, "DDT statistics" },
102 102 { DMU_BSWAP_UINT8, TRUE, "System attributes" },
103 103 { DMU_BSWAP_ZAP, TRUE, "SA master node" },
104 104 { DMU_BSWAP_ZAP, TRUE, "SA attr registration" },
105 105 { DMU_BSWAP_ZAP, TRUE, "SA attr layouts" },
106 106 { DMU_BSWAP_ZAP, TRUE, "scan translations" },
107 107 { DMU_BSWAP_UINT8, FALSE, "deduplicated block" },
108 108 { DMU_BSWAP_ZAP, TRUE, "DSL deadlist map" },
109 109 { DMU_BSWAP_UINT64, TRUE, "DSL deadlist map hdr" },
110 110 { DMU_BSWAP_ZAP, TRUE, "DSL dir clones" },
111 111 { DMU_BSWAP_UINT64, TRUE, "bpobj subobj" }
112 112 };
113 113
114 114 const dmu_object_byteswap_info_t dmu_ot_byteswap[DMU_BSWAP_NUMFUNCS] = {
115 115 { byteswap_uint8_array, "uint8" },
116 116 { byteswap_uint16_array, "uint16" },
117 117 { byteswap_uint32_array, "uint32" },
118 118 { byteswap_uint64_array, "uint64" },
119 119 { zap_byteswap, "zap" },
120 120 { dnode_buf_byteswap, "dnode" },
121 121 { dmu_objset_byteswap, "objset" },
122 122 { zfs_znode_byteswap, "znode" },
123 123 { zfs_oldacl_byteswap, "oldacl" },
124 124 { zfs_acl_byteswap, "acl" }
125 125 };
126 126
127 127 int
128 128 dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset,
129 129 void *tag, dmu_buf_t **dbp, int flags)
130 130 {
131 131 dnode_t *dn;
132 132 uint64_t blkid;
133 133 dmu_buf_impl_t *db;
134 134 int err;
135 135 int db_flags = DB_RF_CANFAIL;
136 136
137 137 if (flags & DMU_READ_NO_PREFETCH)
138 138 db_flags |= DB_RF_NOPREFETCH;
139 139
140 140 err = dnode_hold(os, object, FTAG, &dn);
141 141 if (err)
142 142 return (err);
143 143 blkid = dbuf_whichblock(dn, offset);
144 144 rw_enter(&dn->dn_struct_rwlock, RW_READER);
145 145 db = dbuf_hold(dn, blkid, tag);
146 146 rw_exit(&dn->dn_struct_rwlock);
147 147 if (db == NULL) {
148 148 err = SET_ERROR(EIO);
149 149 } else {
150 150 err = dbuf_read(db, NULL, db_flags);
151 151 if (err) {
152 152 dbuf_rele(db, tag);
153 153 db = NULL;
154 154 }
155 155 }
156 156
157 157 dnode_rele(dn, FTAG);
158 158 *dbp = &db->db; /* NULL db plus first field offset is NULL */
159 159 return (err);
160 160 }
161 161
162 162 int
163 163 dmu_bonus_max(void)
164 164 {
165 165 return (DN_MAX_BONUSLEN);
166 166 }
167 167
168 168 int
169 169 dmu_set_bonus(dmu_buf_t *db_fake, int newsize, dmu_tx_t *tx)
170 170 {
171 171 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
172 172 dnode_t *dn;
173 173 int error;
174 174
175 175 DB_DNODE_ENTER(db);
176 176 dn = DB_DNODE(db);
177 177
178 178 if (dn->dn_bonus != db) {
179 179 error = SET_ERROR(EINVAL);
180 180 } else if (newsize < 0 || newsize > db_fake->db_size) {
181 181 error = SET_ERROR(EINVAL);
182 182 } else {
183 183 dnode_setbonuslen(dn, newsize, tx);
184 184 error = 0;
185 185 }
186 186
187 187 DB_DNODE_EXIT(db);
188 188 return (error);
189 189 }
190 190
191 191 int
192 192 dmu_set_bonustype(dmu_buf_t *db_fake, dmu_object_type_t type, dmu_tx_t *tx)
193 193 {
194 194 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
195 195 dnode_t *dn;
196 196 int error;
197 197
198 198 DB_DNODE_ENTER(db);
199 199 dn = DB_DNODE(db);
200 200
201 201 if (!DMU_OT_IS_VALID(type)) {
202 202 error = SET_ERROR(EINVAL);
203 203 } else if (dn->dn_bonus != db) {
204 204 error = SET_ERROR(EINVAL);
205 205 } else {
206 206 dnode_setbonus_type(dn, type, tx);
207 207 error = 0;
208 208 }
209 209
210 210 DB_DNODE_EXIT(db);
211 211 return (error);
212 212 }
213 213
214 214 dmu_object_type_t
215 215 dmu_get_bonustype(dmu_buf_t *db_fake)
216 216 {
217 217 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
218 218 dnode_t *dn;
219 219 dmu_object_type_t type;
220 220
221 221 DB_DNODE_ENTER(db);
222 222 dn = DB_DNODE(db);
223 223 type = dn->dn_bonustype;
224 224 DB_DNODE_EXIT(db);
225 225
226 226 return (type);
227 227 }
228 228
229 229 int
230 230 dmu_rm_spill(objset_t *os, uint64_t object, dmu_tx_t *tx)
231 231 {
232 232 dnode_t *dn;
233 233 int error;
234 234
235 235 error = dnode_hold(os, object, FTAG, &dn);
236 236 dbuf_rm_spill(dn, tx);
237 237 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
238 238 dnode_rm_spill(dn, tx);
239 239 rw_exit(&dn->dn_struct_rwlock);
240 240 dnode_rele(dn, FTAG);
241 241 return (error);
242 242 }
243 243
244 244 /*
245 245 * returns ENOENT, EIO, or 0.
246 246 */
247 247 int
248 248 dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **dbp)
249 249 {
250 250 dnode_t *dn;
251 251 dmu_buf_impl_t *db;
252 252 int error;
253 253
254 254 error = dnode_hold(os, object, FTAG, &dn);
255 255 if (error)
256 256 return (error);
257 257
258 258 rw_enter(&dn->dn_struct_rwlock, RW_READER);
259 259 if (dn->dn_bonus == NULL) {
260 260 rw_exit(&dn->dn_struct_rwlock);
261 261 rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
262 262 if (dn->dn_bonus == NULL)
263 263 dbuf_create_bonus(dn);
264 264 }
265 265 db = dn->dn_bonus;
266 266
267 267 /* as long as the bonus buf is held, the dnode will be held */
268 268 if (refcount_add(&db->db_holds, tag) == 1) {
269 269 VERIFY(dnode_add_ref(dn, db));
270 270 (void) atomic_inc_32_nv(&dn->dn_dbufs_count);
271 271 }
272 272
273 273 /*
274 274 * Wait to drop dn_struct_rwlock until after adding the bonus dbuf's
275 275 * hold and incrementing the dbuf count to ensure that dnode_move() sees
276 276 * a dnode hold for every dbuf.
277 277 */
278 278 rw_exit(&dn->dn_struct_rwlock);
279 279
280 280 dnode_rele(dn, FTAG);
281 281
282 282 VERIFY(0 == dbuf_read(db, NULL, DB_RF_MUST_SUCCEED | DB_RF_NOPREFETCH));
283 283
284 284 *dbp = &db->db;
285 285 return (0);
286 286 }
287 287
288 288 /*
289 289 * returns ENOENT, EIO, or 0.
290 290 *
291 291 * This interface will allocate a blank spill dbuf when a spill blk
292 292 * doesn't already exist on the dnode.
293 293 *
294 294 * if you only want to find an already existing spill db, then
295 295 * dmu_spill_hold_existing() should be used.
296 296 */
297 297 int
298 298 dmu_spill_hold_by_dnode(dnode_t *dn, uint32_t flags, void *tag, dmu_buf_t **dbp)
299 299 {
300 300 dmu_buf_impl_t *db = NULL;
301 301 int err;
302 302
303 303 if ((flags & DB_RF_HAVESTRUCT) == 0)
304 304 rw_enter(&dn->dn_struct_rwlock, RW_READER);
305 305
306 306 db = dbuf_hold(dn, DMU_SPILL_BLKID, tag);
307 307
308 308 if ((flags & DB_RF_HAVESTRUCT) == 0)
309 309 rw_exit(&dn->dn_struct_rwlock);
310 310
311 311 ASSERT(db != NULL);
312 312 err = dbuf_read(db, NULL, flags);
313 313 if (err == 0)
314 314 *dbp = &db->db;
315 315 else
316 316 dbuf_rele(db, tag);
317 317 return (err);
318 318 }
319 319
320 320 int
321 321 dmu_spill_hold_existing(dmu_buf_t *bonus, void *tag, dmu_buf_t **dbp)
322 322 {
323 323 dmu_buf_impl_t *db = (dmu_buf_impl_t *)bonus;
324 324 dnode_t *dn;
325 325 int err;
326 326
327 327 DB_DNODE_ENTER(db);
328 328 dn = DB_DNODE(db);
329 329
330 330 if (spa_version(dn->dn_objset->os_spa) < SPA_VERSION_SA) {
331 331 err = SET_ERROR(EINVAL);
332 332 } else {
333 333 rw_enter(&dn->dn_struct_rwlock, RW_READER);
334 334
335 335 if (!dn->dn_have_spill) {
336 336 err = SET_ERROR(ENOENT);
337 337 } else {
338 338 err = dmu_spill_hold_by_dnode(dn,
339 339 DB_RF_HAVESTRUCT | DB_RF_CANFAIL, tag, dbp);
340 340 }
341 341
342 342 rw_exit(&dn->dn_struct_rwlock);
343 343 }
344 344
345 345 DB_DNODE_EXIT(db);
346 346 return (err);
347 347 }
348 348
349 349 int
350 350 dmu_spill_hold_by_bonus(dmu_buf_t *bonus, void *tag, dmu_buf_t **dbp)
351 351 {
352 352 dmu_buf_impl_t *db = (dmu_buf_impl_t *)bonus;
353 353 dnode_t *dn;
354 354 int err;
355 355
356 356 DB_DNODE_ENTER(db);
357 357 dn = DB_DNODE(db);
358 358 err = dmu_spill_hold_by_dnode(dn, DB_RF_CANFAIL, tag, dbp);
359 359 DB_DNODE_EXIT(db);
360 360
361 361 return (err);
362 362 }
363 363
364 364 /*
365 365 * Note: longer-term, we should modify all of the dmu_buf_*() interfaces
366 366 * to take a held dnode rather than <os, object> -- the lookup is wasteful,
367 367 * and can induce severe lock contention when writing to several files
368 368 * whose dnodes are in the same block.
369 369 */
370 370 static int
371 371 dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
372 372 int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp, uint32_t flags)
373 373 {
374 374 dmu_buf_t **dbp;
375 375 uint64_t blkid, nblks, i;
376 376 uint32_t dbuf_flags;
377 377 int err;
378 378 zio_t *zio;
379 379
380 380 ASSERT(length <= DMU_MAX_ACCESS);
381 381
382 382 dbuf_flags = DB_RF_CANFAIL | DB_RF_NEVERWAIT | DB_RF_HAVESTRUCT;
383 383 if (flags & DMU_READ_NO_PREFETCH || length > zfetch_array_rd_sz)
384 384 dbuf_flags |= DB_RF_NOPREFETCH;
385 385
386 386 rw_enter(&dn->dn_struct_rwlock, RW_READER);
387 387 if (dn->dn_datablkshift) {
388 388 int blkshift = dn->dn_datablkshift;
389 389 nblks = (P2ROUNDUP(offset+length, 1ULL<<blkshift) -
390 390 P2ALIGN(offset, 1ULL<<blkshift)) >> blkshift;
391 391 } else {
392 392 if (offset + length > dn->dn_datablksz) {
393 393 zfs_panic_recover("zfs: accessing past end of object "
394 394 "%llx/%llx (size=%u access=%llu+%llu)",
395 395 (longlong_t)dn->dn_objset->
396 396 os_dsl_dataset->ds_object,
397 397 (longlong_t)dn->dn_object, dn->dn_datablksz,
398 398 (longlong_t)offset, (longlong_t)length);
399 399 rw_exit(&dn->dn_struct_rwlock);
400 400 return (SET_ERROR(EIO));
401 401 }
402 402 nblks = 1;
403 403 }
404 404 dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks, KM_SLEEP);
405 405
406 406 zio = zio_root(dn->dn_objset->os_spa, NULL, NULL, ZIO_FLAG_CANFAIL);
407 407 blkid = dbuf_whichblock(dn, offset);
408 408 for (i = 0; i < nblks; i++) {
409 409 dmu_buf_impl_t *db = dbuf_hold(dn, blkid+i, tag);
410 410 if (db == NULL) {
411 411 rw_exit(&dn->dn_struct_rwlock);
412 412 dmu_buf_rele_array(dbp, nblks, tag);
413 413 zio_nowait(zio);
414 414 return (SET_ERROR(EIO));
415 415 }
416 416 /* initiate async i/o */
417 417 if (read) {
418 418 (void) dbuf_read(db, zio, dbuf_flags);
419 419 }
420 420 dbp[i] = &db->db;
421 421 }
422 422 rw_exit(&dn->dn_struct_rwlock);
423 423
424 424 /* wait for async i/o */
425 425 err = zio_wait(zio);
426 426 if (err) {
427 427 dmu_buf_rele_array(dbp, nblks, tag);
428 428 return (err);
429 429 }
430 430
431 431 /* wait for other io to complete */
432 432 if (read) {
433 433 for (i = 0; i < nblks; i++) {
434 434 dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
435 435 mutex_enter(&db->db_mtx);
436 436 while (db->db_state == DB_READ ||
437 437 db->db_state == DB_FILL)
438 438 cv_wait(&db->db_changed, &db->db_mtx);
439 439 if (db->db_state == DB_UNCACHED)
440 440 err = SET_ERROR(EIO);
441 441 mutex_exit(&db->db_mtx);
442 442 if (err) {
443 443 dmu_buf_rele_array(dbp, nblks, tag);
444 444 return (err);
445 445 }
446 446 }
447 447 }
448 448
449 449 *numbufsp = nblks;
450 450 *dbpp = dbp;
451 451 return (0);
452 452 }
453 453
454 454 static int
455 455 dmu_buf_hold_array(objset_t *os, uint64_t object, uint64_t offset,
456 456 uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp)
457 457 {
458 458 dnode_t *dn;
459 459 int err;
460 460
461 461 err = dnode_hold(os, object, FTAG, &dn);
462 462 if (err)
463 463 return (err);
464 464
465 465 err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag,
466 466 numbufsp, dbpp, DMU_READ_PREFETCH);
467 467
468 468 dnode_rele(dn, FTAG);
469 469
470 470 return (err);
471 471 }
472 472
473 473 int
474 474 dmu_buf_hold_array_by_bonus(dmu_buf_t *db_fake, uint64_t offset,
475 475 uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp)
476 476 {
477 477 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
478 478 dnode_t *dn;
479 479 int err;
480 480
481 481 DB_DNODE_ENTER(db);
482 482 dn = DB_DNODE(db);
483 483 err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag,
484 484 numbufsp, dbpp, DMU_READ_PREFETCH);
485 485 DB_DNODE_EXIT(db);
486 486
487 487 return (err);
488 488 }
489 489
490 490 void
491 491 dmu_buf_rele_array(dmu_buf_t **dbp_fake, int numbufs, void *tag)
492 492 {
493 493 int i;
494 494 dmu_buf_impl_t **dbp = (dmu_buf_impl_t **)dbp_fake;
495 495
496 496 if (numbufs == 0)
497 497 return;
498 498
499 499 for (i = 0; i < numbufs; i++) {
500 500 if (dbp[i])
501 501 dbuf_rele(dbp[i], tag);
502 502 }
503 503
504 504 kmem_free(dbp, sizeof (dmu_buf_t *) * numbufs);
505 505 }
506 506
507 507 /*
508 508 * Issue prefetch i/os for the given blocks.
509 509 *
510 510 * Note: The assumption is that we *know* these blocks will be needed
511 511 * almost immediately. Therefore, the prefetch i/os will be issued at
512 512 * ZIO_PRIORITY_SYNC_READ
513 513 *
514 514 * Note: indirect blocks and other metadata will be read synchronously,
515 515 * causing this function to block if they are not already cached.
516 516 */
517 517 void
518 518 dmu_prefetch(objset_t *os, uint64_t object, uint64_t offset, uint64_t len)
519 519 {
520 520 dnode_t *dn;
521 521 uint64_t blkid;
522 522 int nblks, err;
523 523
524 524 if (zfs_prefetch_disable)
525 525 return;
526 526
527 527 if (len == 0) { /* they're interested in the bonus buffer */
528 528 dn = DMU_META_DNODE(os);
529 529
530 530 if (object == 0 || object >= DN_MAX_OBJECT)
531 531 return;
532 532
533 533 rw_enter(&dn->dn_struct_rwlock, RW_READER);
534 534 blkid = dbuf_whichblock(dn, object * sizeof (dnode_phys_t));
535 535 dbuf_prefetch(dn, blkid, ZIO_PRIORITY_SYNC_READ);
536 536 rw_exit(&dn->dn_struct_rwlock);
537 537 return;
538 538 }
539 539
540 540 /*
541 541 * XXX - Note, if the dnode for the requested object is not
542 542 * already cached, we will do a *synchronous* read in the
543 543 * dnode_hold() call. The same is true for any indirects.
544 544 */
545 545 err = dnode_hold(os, object, FTAG, &dn);
546 546 if (err != 0)
547 547 return;
548 548
549 549 rw_enter(&dn->dn_struct_rwlock, RW_READER);
550 550 if (dn->dn_datablkshift) {
551 551 int blkshift = dn->dn_datablkshift;
552 552 nblks = (P2ROUNDUP(offset + len, 1 << blkshift) -
553 553 P2ALIGN(offset, 1 << blkshift)) >> blkshift;
554 554 } else {
555 555 nblks = (offset < dn->dn_datablksz);
556 556 }
557 557
558 558 if (nblks != 0) {
559 559 blkid = dbuf_whichblock(dn, offset);
560 560 for (int i = 0; i < nblks; i++)
561 561 dbuf_prefetch(dn, blkid + i, ZIO_PRIORITY_SYNC_READ);
562 562 }
563 563
564 564 rw_exit(&dn->dn_struct_rwlock);
565 565
566 566 dnode_rele(dn, FTAG);
567 567 }
568 568
569 569 /*
570 570 * Get the next "chunk" of file data to free. We traverse the file from
571 571 * the end so that the file gets shorter over time (if we crashes in the
572 572 * middle, this will leave us in a better state). We find allocated file
573 573 * data by simply searching the allocated level 1 indirects.
574 574 *
575 575 * On input, *start should be the first offset that does not need to be
576 576 * freed (e.g. "offset + length"). On return, *start will be the first
577 577 * offset that should be freed.
578 578 */
579 579 static int
580 580 get_next_chunk(dnode_t *dn, uint64_t *start, uint64_t minimum)
581 581 {
582 582 uint64_t maxblks = DMU_MAX_ACCESS >> (dn->dn_indblkshift + 1);
583 583 /* bytes of data covered by a level-1 indirect block */
584 584 uint64_t iblkrange =
585 585 dn->dn_datablksz * EPB(dn->dn_indblkshift, SPA_BLKPTRSHIFT);
586 586
587 587 ASSERT3U(minimum, <=, *start);
588 588
589 589 if (*start - minimum <= iblkrange * maxblks) {
590 590 *start = minimum;
591 591 return (0);
592 592 }
593 593 ASSERT(ISP2(iblkrange));
594 594
595 595 for (uint64_t blks = 0; *start > minimum && blks < maxblks; blks++) {
596 596 int err;
597 597
598 598 /*
599 599 * dnode_next_offset(BACKWARDS) will find an allocated L1
600 600 * indirect block at or before the input offset. We must
601 601 * decrement *start so that it is at the end of the region
602 602 * to search.
603 603 */
604 604 (*start)--;
605 605 err = dnode_next_offset(dn,
606 606 DNODE_FIND_BACKWARDS, start, 2, 1, 0);
607 607
608 608 /* if there are no indirect blocks before start, we are done */
609 609 if (err == ESRCH) {
610 610 *start = minimum;
611 611 break;
612 612 } else if (err != 0) {
613 613 return (err);
614 614 }
615 615
616 616 /* set start to the beginning of this L1 indirect */
617 617 *start = P2ALIGN(*start, iblkrange);
618 618 }
619 619 if (*start < minimum)
620 620 *start = minimum;
621 621 return (0);
622 622 }
623 623
624 624 static int
625 625 dmu_free_long_range_impl(objset_t *os, dnode_t *dn, uint64_t offset,
626 626 uint64_t length)
627 627 {
628 628 uint64_t object_size = (dn->dn_maxblkid + 1) * dn->dn_datablksz;
629 629 int err;
630 630
631 631 if (offset >= object_size)
632 632 return (0);
633 633
634 634 if (length == DMU_OBJECT_END || offset + length > object_size)
635 635 length = object_size - offset;
636 636
637 637 while (length != 0) {
638 638 uint64_t chunk_end, chunk_begin;
639 639
640 640 chunk_end = chunk_begin = offset + length;
641 641
642 642 /* move chunk_begin backwards to the beginning of this chunk */
643 643 err = get_next_chunk(dn, &chunk_begin, offset);
644 644 if (err)
645 645 return (err);
646 646 ASSERT3U(chunk_begin, >=, offset);
647 647 ASSERT3U(chunk_begin, <=, chunk_end);
648 648
649 649 dmu_tx_t *tx = dmu_tx_create(os);
650 650 dmu_tx_hold_free(tx, dn->dn_object,
651 651 chunk_begin, chunk_end - chunk_begin);
652 652 err = dmu_tx_assign(tx, TXG_WAIT);
653 653 if (err) {
654 654 dmu_tx_abort(tx);
655 655 return (err);
656 656 }
657 657 dnode_free_range(dn, chunk_begin, chunk_end - chunk_begin, tx);
658 658 dmu_tx_commit(tx);
659 659
660 660 length -= chunk_end - chunk_begin;
661 661 }
662 662 return (0);
663 663 }
664 664
665 665 int
|
↓ open down ↓ |
665 lines elided |
↑ open up ↑ |
666 666 dmu_free_long_range(objset_t *os, uint64_t object,
667 667 uint64_t offset, uint64_t length)
668 668 {
669 669 dnode_t *dn;
670 670 int err;
671 671
672 672 err = dnode_hold(os, object, FTAG, &dn);
673 673 if (err != 0)
674 674 return (err);
675 675 err = dmu_free_long_range_impl(os, dn, offset, length);
676 +
677 + /*
678 + * It is important to zero out the maxblkid when freeing the entire
679 + * file, so that (a) subsequent calls to dmu_free_long_range_impl()
680 + * will take the fast path, and (b) dnode_reallocate() can verify
681 + * that the entire file has been freed.
682 + */
683 + if (offset == 0 && length == DMU_OBJECT_END)
684 + dn->dn_maxblkid = 0;
685 +
676 686 dnode_rele(dn, FTAG);
677 687 return (err);
678 688 }
679 689
680 690 int
681 691 dmu_free_long_object(objset_t *os, uint64_t object)
682 692 {
683 693 dmu_tx_t *tx;
684 694 int err;
685 695
686 696 err = dmu_free_long_range(os, object, 0, DMU_OBJECT_END);
687 697 if (err != 0)
688 698 return (err);
689 699
690 700 tx = dmu_tx_create(os);
691 701 dmu_tx_hold_bonus(tx, object);
692 702 dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);
693 703 err = dmu_tx_assign(tx, TXG_WAIT);
694 704 if (err == 0) {
695 705 err = dmu_object_free(os, object, tx);
696 706 dmu_tx_commit(tx);
697 707 } else {
698 708 dmu_tx_abort(tx);
699 709 }
700 710
701 711 return (err);
702 712 }
703 713
704 714 int
705 715 dmu_free_range(objset_t *os, uint64_t object, uint64_t offset,
706 716 uint64_t size, dmu_tx_t *tx)
707 717 {
708 718 dnode_t *dn;
709 719 int err = dnode_hold(os, object, FTAG, &dn);
710 720 if (err)
711 721 return (err);
712 722 ASSERT(offset < UINT64_MAX);
713 723 ASSERT(size == -1ULL || size <= UINT64_MAX - offset);
714 724 dnode_free_range(dn, offset, size, tx);
715 725 dnode_rele(dn, FTAG);
716 726 return (0);
717 727 }
718 728
719 729 int
720 730 dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
721 731 void *buf, uint32_t flags)
722 732 {
723 733 dnode_t *dn;
724 734 dmu_buf_t **dbp;
725 735 int numbufs, err;
726 736
727 737 err = dnode_hold(os, object, FTAG, &dn);
728 738 if (err)
729 739 return (err);
730 740
731 741 /*
732 742 * Deal with odd block sizes, where there can't be data past the first
733 743 * block. If we ever do the tail block optimization, we will need to
734 744 * handle that here as well.
735 745 */
736 746 if (dn->dn_maxblkid == 0) {
737 747 int newsz = offset > dn->dn_datablksz ? 0 :
738 748 MIN(size, dn->dn_datablksz - offset);
739 749 bzero((char *)buf + newsz, size - newsz);
740 750 size = newsz;
741 751 }
742 752
743 753 while (size > 0) {
744 754 uint64_t mylen = MIN(size, DMU_MAX_ACCESS / 2);
745 755 int i;
746 756
747 757 /*
748 758 * NB: we could do this block-at-a-time, but it's nice
749 759 * to be reading in parallel.
750 760 */
751 761 err = dmu_buf_hold_array_by_dnode(dn, offset, mylen,
752 762 TRUE, FTAG, &numbufs, &dbp, flags);
753 763 if (err)
754 764 break;
755 765
756 766 for (i = 0; i < numbufs; i++) {
757 767 int tocpy;
758 768 int bufoff;
759 769 dmu_buf_t *db = dbp[i];
760 770
761 771 ASSERT(size > 0);
762 772
763 773 bufoff = offset - db->db_offset;
764 774 tocpy = (int)MIN(db->db_size - bufoff, size);
765 775
766 776 bcopy((char *)db->db_data + bufoff, buf, tocpy);
767 777
768 778 offset += tocpy;
769 779 size -= tocpy;
770 780 buf = (char *)buf + tocpy;
771 781 }
772 782 dmu_buf_rele_array(dbp, numbufs, FTAG);
773 783 }
774 784 dnode_rele(dn, FTAG);
775 785 return (err);
776 786 }
777 787
778 788 void
779 789 dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
780 790 const void *buf, dmu_tx_t *tx)
781 791 {
782 792 dmu_buf_t **dbp;
783 793 int numbufs, i;
784 794
785 795 if (size == 0)
786 796 return;
787 797
788 798 VERIFY(0 == dmu_buf_hold_array(os, object, offset, size,
789 799 FALSE, FTAG, &numbufs, &dbp));
790 800
791 801 for (i = 0; i < numbufs; i++) {
792 802 int tocpy;
793 803 int bufoff;
794 804 dmu_buf_t *db = dbp[i];
795 805
796 806 ASSERT(size > 0);
797 807
798 808 bufoff = offset - db->db_offset;
799 809 tocpy = (int)MIN(db->db_size - bufoff, size);
800 810
801 811 ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size);
802 812
803 813 if (tocpy == db->db_size)
804 814 dmu_buf_will_fill(db, tx);
805 815 else
806 816 dmu_buf_will_dirty(db, tx);
807 817
808 818 bcopy(buf, (char *)db->db_data + bufoff, tocpy);
809 819
810 820 if (tocpy == db->db_size)
811 821 dmu_buf_fill_done(db, tx);
812 822
813 823 offset += tocpy;
814 824 size -= tocpy;
815 825 buf = (char *)buf + tocpy;
816 826 }
817 827 dmu_buf_rele_array(dbp, numbufs, FTAG);
818 828 }
819 829
820 830 void
821 831 dmu_prealloc(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
822 832 dmu_tx_t *tx)
823 833 {
824 834 dmu_buf_t **dbp;
825 835 int numbufs, i;
826 836
827 837 if (size == 0)
828 838 return;
829 839
830 840 VERIFY(0 == dmu_buf_hold_array(os, object, offset, size,
831 841 FALSE, FTAG, &numbufs, &dbp));
832 842
833 843 for (i = 0; i < numbufs; i++) {
834 844 dmu_buf_t *db = dbp[i];
835 845
836 846 dmu_buf_will_not_fill(db, tx);
837 847 }
838 848 dmu_buf_rele_array(dbp, numbufs, FTAG);
839 849 }
840 850
841 851 /*
842 852 * DMU support for xuio
843 853 */
844 854 kstat_t *xuio_ksp = NULL;
845 855
846 856 int
847 857 dmu_xuio_init(xuio_t *xuio, int nblk)
848 858 {
849 859 dmu_xuio_t *priv;
850 860 uio_t *uio = &xuio->xu_uio;
851 861
852 862 uio->uio_iovcnt = nblk;
853 863 uio->uio_iov = kmem_zalloc(nblk * sizeof (iovec_t), KM_SLEEP);
854 864
855 865 priv = kmem_zalloc(sizeof (dmu_xuio_t), KM_SLEEP);
856 866 priv->cnt = nblk;
857 867 priv->bufs = kmem_zalloc(nblk * sizeof (arc_buf_t *), KM_SLEEP);
858 868 priv->iovp = uio->uio_iov;
859 869 XUIO_XUZC_PRIV(xuio) = priv;
860 870
861 871 if (XUIO_XUZC_RW(xuio) == UIO_READ)
862 872 XUIOSTAT_INCR(xuiostat_onloan_rbuf, nblk);
863 873 else
864 874 XUIOSTAT_INCR(xuiostat_onloan_wbuf, nblk);
865 875
866 876 return (0);
867 877 }
868 878
869 879 void
870 880 dmu_xuio_fini(xuio_t *xuio)
871 881 {
872 882 dmu_xuio_t *priv = XUIO_XUZC_PRIV(xuio);
873 883 int nblk = priv->cnt;
874 884
875 885 kmem_free(priv->iovp, nblk * sizeof (iovec_t));
876 886 kmem_free(priv->bufs, nblk * sizeof (arc_buf_t *));
877 887 kmem_free(priv, sizeof (dmu_xuio_t));
878 888
879 889 if (XUIO_XUZC_RW(xuio) == UIO_READ)
880 890 XUIOSTAT_INCR(xuiostat_onloan_rbuf, -nblk);
881 891 else
882 892 XUIOSTAT_INCR(xuiostat_onloan_wbuf, -nblk);
883 893 }
884 894
885 895 /*
886 896 * Initialize iov[priv->next] and priv->bufs[priv->next] with { off, n, abuf }
887 897 * and increase priv->next by 1.
888 898 */
889 899 int
890 900 dmu_xuio_add(xuio_t *xuio, arc_buf_t *abuf, offset_t off, size_t n)
891 901 {
892 902 struct iovec *iov;
893 903 uio_t *uio = &xuio->xu_uio;
894 904 dmu_xuio_t *priv = XUIO_XUZC_PRIV(xuio);
895 905 int i = priv->next++;
896 906
897 907 ASSERT(i < priv->cnt);
898 908 ASSERT(off + n <= arc_buf_size(abuf));
899 909 iov = uio->uio_iov + i;
900 910 iov->iov_base = (char *)abuf->b_data + off;
901 911 iov->iov_len = n;
902 912 priv->bufs[i] = abuf;
903 913 return (0);
904 914 }
905 915
906 916 int
907 917 dmu_xuio_cnt(xuio_t *xuio)
908 918 {
909 919 dmu_xuio_t *priv = XUIO_XUZC_PRIV(xuio);
910 920 return (priv->cnt);
911 921 }
912 922
913 923 arc_buf_t *
914 924 dmu_xuio_arcbuf(xuio_t *xuio, int i)
915 925 {
916 926 dmu_xuio_t *priv = XUIO_XUZC_PRIV(xuio);
917 927
918 928 ASSERT(i < priv->cnt);
919 929 return (priv->bufs[i]);
920 930 }
921 931
922 932 void
923 933 dmu_xuio_clear(xuio_t *xuio, int i)
924 934 {
925 935 dmu_xuio_t *priv = XUIO_XUZC_PRIV(xuio);
926 936
927 937 ASSERT(i < priv->cnt);
928 938 priv->bufs[i] = NULL;
929 939 }
930 940
931 941 static void
932 942 xuio_stat_init(void)
933 943 {
934 944 xuio_ksp = kstat_create("zfs", 0, "xuio_stats", "misc",
935 945 KSTAT_TYPE_NAMED, sizeof (xuio_stats) / sizeof (kstat_named_t),
936 946 KSTAT_FLAG_VIRTUAL);
937 947 if (xuio_ksp != NULL) {
938 948 xuio_ksp->ks_data = &xuio_stats;
939 949 kstat_install(xuio_ksp);
940 950 }
941 951 }
942 952
943 953 static void
944 954 xuio_stat_fini(void)
945 955 {
946 956 if (xuio_ksp != NULL) {
947 957 kstat_delete(xuio_ksp);
948 958 xuio_ksp = NULL;
949 959 }
950 960 }
951 961
952 962 void
953 963 xuio_stat_wbuf_copied()
954 964 {
955 965 XUIOSTAT_BUMP(xuiostat_wbuf_copied);
956 966 }
957 967
958 968 void
959 969 xuio_stat_wbuf_nocopy()
960 970 {
961 971 XUIOSTAT_BUMP(xuiostat_wbuf_nocopy);
962 972 }
963 973
964 974 #ifdef _KERNEL
965 975 int
966 976 dmu_read_uio(objset_t *os, uint64_t object, uio_t *uio, uint64_t size)
967 977 {
968 978 dmu_buf_t **dbp;
969 979 int numbufs, i, err;
970 980 xuio_t *xuio = NULL;
971 981
972 982 /*
973 983 * NB: we could do this block-at-a-time, but it's nice
974 984 * to be reading in parallel.
975 985 */
976 986 err = dmu_buf_hold_array(os, object, uio->uio_loffset, size, TRUE, FTAG,
977 987 &numbufs, &dbp);
978 988 if (err)
979 989 return (err);
980 990
981 991 if (uio->uio_extflg == UIO_XUIO)
982 992 xuio = (xuio_t *)uio;
983 993
984 994 for (i = 0; i < numbufs; i++) {
985 995 int tocpy;
986 996 int bufoff;
987 997 dmu_buf_t *db = dbp[i];
988 998
989 999 ASSERT(size > 0);
990 1000
991 1001 bufoff = uio->uio_loffset - db->db_offset;
992 1002 tocpy = (int)MIN(db->db_size - bufoff, size);
993 1003
994 1004 if (xuio) {
995 1005 dmu_buf_impl_t *dbi = (dmu_buf_impl_t *)db;
996 1006 arc_buf_t *dbuf_abuf = dbi->db_buf;
997 1007 arc_buf_t *abuf = dbuf_loan_arcbuf(dbi);
998 1008 err = dmu_xuio_add(xuio, abuf, bufoff, tocpy);
999 1009 if (!err) {
1000 1010 uio->uio_resid -= tocpy;
1001 1011 uio->uio_loffset += tocpy;
1002 1012 }
1003 1013
1004 1014 if (abuf == dbuf_abuf)
1005 1015 XUIOSTAT_BUMP(xuiostat_rbuf_nocopy);
1006 1016 else
1007 1017 XUIOSTAT_BUMP(xuiostat_rbuf_copied);
1008 1018 } else {
1009 1019 err = uiomove((char *)db->db_data + bufoff, tocpy,
1010 1020 UIO_READ, uio);
1011 1021 }
1012 1022 if (err)
1013 1023 break;
1014 1024
1015 1025 size -= tocpy;
1016 1026 }
1017 1027 dmu_buf_rele_array(dbp, numbufs, FTAG);
1018 1028
1019 1029 return (err);
1020 1030 }
1021 1031
1022 1032 static int
1023 1033 dmu_write_uio_dnode(dnode_t *dn, uio_t *uio, uint64_t size, dmu_tx_t *tx)
1024 1034 {
1025 1035 dmu_buf_t **dbp;
1026 1036 int numbufs;
1027 1037 int err = 0;
1028 1038 int i;
1029 1039
1030 1040 err = dmu_buf_hold_array_by_dnode(dn, uio->uio_loffset, size,
1031 1041 FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH);
1032 1042 if (err)
1033 1043 return (err);
1034 1044
1035 1045 for (i = 0; i < numbufs; i++) {
1036 1046 int tocpy;
1037 1047 int bufoff;
1038 1048 dmu_buf_t *db = dbp[i];
1039 1049
1040 1050 ASSERT(size > 0);
1041 1051
1042 1052 bufoff = uio->uio_loffset - db->db_offset;
1043 1053 tocpy = (int)MIN(db->db_size - bufoff, size);
1044 1054
1045 1055 ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size);
1046 1056
1047 1057 if (tocpy == db->db_size)
1048 1058 dmu_buf_will_fill(db, tx);
1049 1059 else
1050 1060 dmu_buf_will_dirty(db, tx);
1051 1061
1052 1062 /*
1053 1063 * XXX uiomove could block forever (eg. nfs-backed
1054 1064 * pages). There needs to be a uiolockdown() function
1055 1065 * to lock the pages in memory, so that uiomove won't
1056 1066 * block.
1057 1067 */
1058 1068 err = uiomove((char *)db->db_data + bufoff, tocpy,
1059 1069 UIO_WRITE, uio);
1060 1070
1061 1071 if (tocpy == db->db_size)
1062 1072 dmu_buf_fill_done(db, tx);
1063 1073
1064 1074 if (err)
1065 1075 break;
1066 1076
1067 1077 size -= tocpy;
1068 1078 }
1069 1079
1070 1080 dmu_buf_rele_array(dbp, numbufs, FTAG);
1071 1081 return (err);
1072 1082 }
1073 1083
1074 1084 int
1075 1085 dmu_write_uio_dbuf(dmu_buf_t *zdb, uio_t *uio, uint64_t size,
1076 1086 dmu_tx_t *tx)
1077 1087 {
1078 1088 dmu_buf_impl_t *db = (dmu_buf_impl_t *)zdb;
1079 1089 dnode_t *dn;
1080 1090 int err;
1081 1091
1082 1092 if (size == 0)
1083 1093 return (0);
1084 1094
1085 1095 DB_DNODE_ENTER(db);
1086 1096 dn = DB_DNODE(db);
1087 1097 err = dmu_write_uio_dnode(dn, uio, size, tx);
1088 1098 DB_DNODE_EXIT(db);
1089 1099
1090 1100 return (err);
1091 1101 }
1092 1102
1093 1103 int
1094 1104 dmu_write_uio(objset_t *os, uint64_t object, uio_t *uio, uint64_t size,
1095 1105 dmu_tx_t *tx)
1096 1106 {
1097 1107 dnode_t *dn;
1098 1108 int err;
1099 1109
1100 1110 if (size == 0)
1101 1111 return (0);
1102 1112
1103 1113 err = dnode_hold(os, object, FTAG, &dn);
1104 1114 if (err)
1105 1115 return (err);
1106 1116
1107 1117 err = dmu_write_uio_dnode(dn, uio, size, tx);
1108 1118
1109 1119 dnode_rele(dn, FTAG);
1110 1120
1111 1121 return (err);
1112 1122 }
1113 1123
1114 1124 int
1115 1125 dmu_write_pages(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
1116 1126 page_t *pp, dmu_tx_t *tx)
1117 1127 {
1118 1128 dmu_buf_t **dbp;
1119 1129 int numbufs, i;
1120 1130 int err;
1121 1131
1122 1132 if (size == 0)
1123 1133 return (0);
1124 1134
1125 1135 err = dmu_buf_hold_array(os, object, offset, size,
1126 1136 FALSE, FTAG, &numbufs, &dbp);
1127 1137 if (err)
1128 1138 return (err);
1129 1139
1130 1140 for (i = 0; i < numbufs; i++) {
1131 1141 int tocpy, copied, thiscpy;
1132 1142 int bufoff;
1133 1143 dmu_buf_t *db = dbp[i];
1134 1144 caddr_t va;
1135 1145
1136 1146 ASSERT(size > 0);
1137 1147 ASSERT3U(db->db_size, >=, PAGESIZE);
1138 1148
1139 1149 bufoff = offset - db->db_offset;
1140 1150 tocpy = (int)MIN(db->db_size - bufoff, size);
1141 1151
1142 1152 ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size);
1143 1153
1144 1154 if (tocpy == db->db_size)
1145 1155 dmu_buf_will_fill(db, tx);
1146 1156 else
1147 1157 dmu_buf_will_dirty(db, tx);
1148 1158
1149 1159 for (copied = 0; copied < tocpy; copied += PAGESIZE) {
1150 1160 ASSERT3U(pp->p_offset, ==, db->db_offset + bufoff);
1151 1161 thiscpy = MIN(PAGESIZE, tocpy - copied);
1152 1162 va = zfs_map_page(pp, S_READ);
1153 1163 bcopy(va, (char *)db->db_data + bufoff, thiscpy);
1154 1164 zfs_unmap_page(pp, va);
1155 1165 pp = pp->p_next;
1156 1166 bufoff += PAGESIZE;
1157 1167 }
1158 1168
1159 1169 if (tocpy == db->db_size)
1160 1170 dmu_buf_fill_done(db, tx);
1161 1171
1162 1172 offset += tocpy;
1163 1173 size -= tocpy;
1164 1174 }
1165 1175 dmu_buf_rele_array(dbp, numbufs, FTAG);
1166 1176 return (err);
1167 1177 }
1168 1178 #endif
1169 1179
1170 1180 /*
1171 1181 * Allocate a loaned anonymous arc buffer.
1172 1182 */
1173 1183 arc_buf_t *
1174 1184 dmu_request_arcbuf(dmu_buf_t *handle, int size)
1175 1185 {
1176 1186 dmu_buf_impl_t *db = (dmu_buf_impl_t *)handle;
1177 1187 spa_t *spa;
1178 1188
1179 1189 DB_GET_SPA(&spa, db);
1180 1190 return (arc_loan_buf(spa, size));
1181 1191 }
1182 1192
1183 1193 /*
1184 1194 * Free a loaned arc buffer.
1185 1195 */
1186 1196 void
1187 1197 dmu_return_arcbuf(arc_buf_t *buf)
1188 1198 {
1189 1199 arc_return_buf(buf, FTAG);
1190 1200 VERIFY(arc_buf_remove_ref(buf, FTAG));
1191 1201 }
1192 1202
1193 1203 /*
1194 1204 * When possible directly assign passed loaned arc buffer to a dbuf.
1195 1205 * If this is not possible copy the contents of passed arc buf via
1196 1206 * dmu_write().
1197 1207 */
1198 1208 void
1199 1209 dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, arc_buf_t *buf,
1200 1210 dmu_tx_t *tx)
1201 1211 {
1202 1212 dmu_buf_impl_t *dbuf = (dmu_buf_impl_t *)handle;
1203 1213 dnode_t *dn;
1204 1214 dmu_buf_impl_t *db;
1205 1215 uint32_t blksz = (uint32_t)arc_buf_size(buf);
1206 1216 uint64_t blkid;
1207 1217
1208 1218 DB_DNODE_ENTER(dbuf);
1209 1219 dn = DB_DNODE(dbuf);
1210 1220 rw_enter(&dn->dn_struct_rwlock, RW_READER);
1211 1221 blkid = dbuf_whichblock(dn, offset);
1212 1222 VERIFY((db = dbuf_hold(dn, blkid, FTAG)) != NULL);
1213 1223 rw_exit(&dn->dn_struct_rwlock);
1214 1224 DB_DNODE_EXIT(dbuf);
1215 1225
1216 1226 if (offset == db->db.db_offset && blksz == db->db.db_size) {
1217 1227 dbuf_assign_arcbuf(db, buf, tx);
1218 1228 dbuf_rele(db, FTAG);
1219 1229 } else {
1220 1230 objset_t *os;
1221 1231 uint64_t object;
1222 1232
1223 1233 DB_DNODE_ENTER(dbuf);
1224 1234 dn = DB_DNODE(dbuf);
1225 1235 os = dn->dn_objset;
1226 1236 object = dn->dn_object;
1227 1237 DB_DNODE_EXIT(dbuf);
1228 1238
1229 1239 dbuf_rele(db, FTAG);
1230 1240 dmu_write(os, object, offset, blksz, buf->b_data, tx);
1231 1241 dmu_return_arcbuf(buf);
1232 1242 XUIOSTAT_BUMP(xuiostat_wbuf_copied);
1233 1243 }
1234 1244 }
1235 1245
1236 1246 typedef struct {
1237 1247 dbuf_dirty_record_t *dsa_dr;
1238 1248 dmu_sync_cb_t *dsa_done;
1239 1249 zgd_t *dsa_zgd;
1240 1250 dmu_tx_t *dsa_tx;
1241 1251 } dmu_sync_arg_t;
1242 1252
1243 1253 /* ARGSUSED */
1244 1254 static void
1245 1255 dmu_sync_ready(zio_t *zio, arc_buf_t *buf, void *varg)
1246 1256 {
1247 1257 dmu_sync_arg_t *dsa = varg;
1248 1258 dmu_buf_t *db = dsa->dsa_zgd->zgd_db;
1249 1259 blkptr_t *bp = zio->io_bp;
1250 1260
1251 1261 if (zio->io_error == 0) {
1252 1262 if (BP_IS_HOLE(bp)) {
1253 1263 /*
1254 1264 * A block of zeros may compress to a hole, but the
1255 1265 * block size still needs to be known for replay.
1256 1266 */
1257 1267 BP_SET_LSIZE(bp, db->db_size);
1258 1268 } else {
1259 1269 ASSERT(BP_GET_LEVEL(bp) == 0);
1260 1270 bp->blk_fill = 1;
1261 1271 }
1262 1272 }
1263 1273 }
1264 1274
1265 1275 static void
1266 1276 dmu_sync_late_arrival_ready(zio_t *zio)
1267 1277 {
1268 1278 dmu_sync_ready(zio, NULL, zio->io_private);
1269 1279 }
1270 1280
1271 1281 /* ARGSUSED */
1272 1282 static void
1273 1283 dmu_sync_done(zio_t *zio, arc_buf_t *buf, void *varg)
1274 1284 {
1275 1285 dmu_sync_arg_t *dsa = varg;
1276 1286 dbuf_dirty_record_t *dr = dsa->dsa_dr;
1277 1287 dmu_buf_impl_t *db = dr->dr_dbuf;
1278 1288
1279 1289 mutex_enter(&db->db_mtx);
1280 1290 ASSERT(dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC);
1281 1291 if (zio->io_error == 0) {
1282 1292 dr->dt.dl.dr_nopwrite = !!(zio->io_flags & ZIO_FLAG_NOPWRITE);
1283 1293 if (dr->dt.dl.dr_nopwrite) {
1284 1294 blkptr_t *bp = zio->io_bp;
1285 1295 blkptr_t *bp_orig = &zio->io_bp_orig;
1286 1296 uint8_t chksum = BP_GET_CHECKSUM(bp_orig);
1287 1297
1288 1298 ASSERT(BP_EQUAL(bp, bp_orig));
1289 1299 ASSERT(zio->io_prop.zp_compress != ZIO_COMPRESS_OFF);
1290 1300 ASSERT(zio_checksum_table[chksum].ci_dedup);
1291 1301 }
1292 1302 dr->dt.dl.dr_overridden_by = *zio->io_bp;
1293 1303 dr->dt.dl.dr_override_state = DR_OVERRIDDEN;
1294 1304 dr->dt.dl.dr_copies = zio->io_prop.zp_copies;
1295 1305 if (BP_IS_HOLE(&dr->dt.dl.dr_overridden_by))
1296 1306 BP_ZERO(&dr->dt.dl.dr_overridden_by);
1297 1307 } else {
1298 1308 dr->dt.dl.dr_override_state = DR_NOT_OVERRIDDEN;
1299 1309 }
1300 1310 cv_broadcast(&db->db_changed);
1301 1311 mutex_exit(&db->db_mtx);
1302 1312
1303 1313 dsa->dsa_done(dsa->dsa_zgd, zio->io_error);
1304 1314
1305 1315 kmem_free(dsa, sizeof (*dsa));
1306 1316 }
1307 1317
1308 1318 static void
1309 1319 dmu_sync_late_arrival_done(zio_t *zio)
1310 1320 {
1311 1321 blkptr_t *bp = zio->io_bp;
1312 1322 dmu_sync_arg_t *dsa = zio->io_private;
1313 1323 blkptr_t *bp_orig = &zio->io_bp_orig;
1314 1324
1315 1325 if (zio->io_error == 0 && !BP_IS_HOLE(bp)) {
1316 1326 /*
1317 1327 * If we didn't allocate a new block (i.e. ZIO_FLAG_NOPWRITE)
1318 1328 * then there is nothing to do here. Otherwise, free the
1319 1329 * newly allocated block in this txg.
1320 1330 */
1321 1331 if (zio->io_flags & ZIO_FLAG_NOPWRITE) {
1322 1332 ASSERT(BP_EQUAL(bp, bp_orig));
1323 1333 } else {
1324 1334 ASSERT(BP_IS_HOLE(bp_orig) || !BP_EQUAL(bp, bp_orig));
1325 1335 ASSERT(zio->io_bp->blk_birth == zio->io_txg);
1326 1336 ASSERT(zio->io_txg > spa_syncing_txg(zio->io_spa));
1327 1337 zio_free(zio->io_spa, zio->io_txg, zio->io_bp);
1328 1338 }
1329 1339 }
1330 1340
1331 1341 dmu_tx_commit(dsa->dsa_tx);
1332 1342
1333 1343 dsa->dsa_done(dsa->dsa_zgd, zio->io_error);
1334 1344
1335 1345 kmem_free(dsa, sizeof (*dsa));
1336 1346 }
1337 1347
1338 1348 static int
1339 1349 dmu_sync_late_arrival(zio_t *pio, objset_t *os, dmu_sync_cb_t *done, zgd_t *zgd,
1340 1350 zio_prop_t *zp, zbookmark_t *zb)
1341 1351 {
1342 1352 dmu_sync_arg_t *dsa;
1343 1353 dmu_tx_t *tx;
1344 1354
1345 1355 tx = dmu_tx_create(os);
1346 1356 dmu_tx_hold_space(tx, zgd->zgd_db->db_size);
1347 1357 if (dmu_tx_assign(tx, TXG_WAIT) != 0) {
1348 1358 dmu_tx_abort(tx);
1349 1359 /* Make zl_get_data do txg_waited_synced() */
1350 1360 return (SET_ERROR(EIO));
1351 1361 }
1352 1362
1353 1363 dsa = kmem_alloc(sizeof (dmu_sync_arg_t), KM_SLEEP);
1354 1364 dsa->dsa_dr = NULL;
1355 1365 dsa->dsa_done = done;
1356 1366 dsa->dsa_zgd = zgd;
1357 1367 dsa->dsa_tx = tx;
1358 1368
1359 1369 zio_nowait(zio_write(pio, os->os_spa, dmu_tx_get_txg(tx), zgd->zgd_bp,
1360 1370 zgd->zgd_db->db_data, zgd->zgd_db->db_size, zp,
1361 1371 dmu_sync_late_arrival_ready, NULL, dmu_sync_late_arrival_done, dsa,
1362 1372 ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, zb));
1363 1373
1364 1374 return (0);
1365 1375 }
1366 1376
1367 1377 /*
1368 1378 * Intent log support: sync the block associated with db to disk.
1369 1379 * N.B. and XXX: the caller is responsible for making sure that the
1370 1380 * data isn't changing while dmu_sync() is writing it.
1371 1381 *
1372 1382 * Return values:
1373 1383 *
1374 1384 * EEXIST: this txg has already been synced, so there's nothing to do.
1375 1385 * The caller should not log the write.
1376 1386 *
1377 1387 * ENOENT: the block was dbuf_free_range()'d, so there's nothing to do.
1378 1388 * The caller should not log the write.
1379 1389 *
1380 1390 * EALREADY: this block is already in the process of being synced.
1381 1391 * The caller should track its progress (somehow).
1382 1392 *
1383 1393 * EIO: could not do the I/O.
1384 1394 * The caller should do a txg_wait_synced().
1385 1395 *
1386 1396 * 0: the I/O has been initiated.
1387 1397 * The caller should log this blkptr in the done callback.
1388 1398 * It is possible that the I/O will fail, in which case
1389 1399 * the error will be reported to the done callback and
1390 1400 * propagated to pio from zio_done().
1391 1401 */
1392 1402 int
1393 1403 dmu_sync(zio_t *pio, uint64_t txg, dmu_sync_cb_t *done, zgd_t *zgd)
1394 1404 {
1395 1405 blkptr_t *bp = zgd->zgd_bp;
1396 1406 dmu_buf_impl_t *db = (dmu_buf_impl_t *)zgd->zgd_db;
1397 1407 objset_t *os = db->db_objset;
1398 1408 dsl_dataset_t *ds = os->os_dsl_dataset;
1399 1409 dbuf_dirty_record_t *dr;
1400 1410 dmu_sync_arg_t *dsa;
1401 1411 zbookmark_t zb;
1402 1412 zio_prop_t zp;
1403 1413 dnode_t *dn;
1404 1414
1405 1415 ASSERT(pio != NULL);
1406 1416 ASSERT(txg != 0);
1407 1417
1408 1418 SET_BOOKMARK(&zb, ds->ds_object,
1409 1419 db->db.db_object, db->db_level, db->db_blkid);
1410 1420
1411 1421 DB_DNODE_ENTER(db);
1412 1422 dn = DB_DNODE(db);
1413 1423 dmu_write_policy(os, dn, db->db_level, WP_DMU_SYNC, &zp);
1414 1424 DB_DNODE_EXIT(db);
1415 1425
1416 1426 /*
1417 1427 * If we're frozen (running ziltest), we always need to generate a bp.
1418 1428 */
1419 1429 if (txg > spa_freeze_txg(os->os_spa))
1420 1430 return (dmu_sync_late_arrival(pio, os, done, zgd, &zp, &zb));
1421 1431
1422 1432 /*
1423 1433 * Grabbing db_mtx now provides a barrier between dbuf_sync_leaf()
1424 1434 * and us. If we determine that this txg is not yet syncing,
1425 1435 * but it begins to sync a moment later, that's OK because the
1426 1436 * sync thread will block in dbuf_sync_leaf() until we drop db_mtx.
1427 1437 */
1428 1438 mutex_enter(&db->db_mtx);
1429 1439
1430 1440 if (txg <= spa_last_synced_txg(os->os_spa)) {
1431 1441 /*
1432 1442 * This txg has already synced. There's nothing to do.
1433 1443 */
1434 1444 mutex_exit(&db->db_mtx);
1435 1445 return (SET_ERROR(EEXIST));
1436 1446 }
1437 1447
1438 1448 if (txg <= spa_syncing_txg(os->os_spa)) {
1439 1449 /*
1440 1450 * This txg is currently syncing, so we can't mess with
1441 1451 * the dirty record anymore; just write a new log block.
1442 1452 */
1443 1453 mutex_exit(&db->db_mtx);
1444 1454 return (dmu_sync_late_arrival(pio, os, done, zgd, &zp, &zb));
1445 1455 }
1446 1456
1447 1457 dr = db->db_last_dirty;
1448 1458 while (dr && dr->dr_txg != txg)
1449 1459 dr = dr->dr_next;
1450 1460
1451 1461 if (dr == NULL) {
1452 1462 /*
1453 1463 * There's no dr for this dbuf, so it must have been freed.
1454 1464 * There's no need to log writes to freed blocks, so we're done.
1455 1465 */
1456 1466 mutex_exit(&db->db_mtx);
1457 1467 return (SET_ERROR(ENOENT));
1458 1468 }
1459 1469
1460 1470 ASSERT(dr->dr_next == NULL || dr->dr_next->dr_txg < txg);
1461 1471
1462 1472 /*
1463 1473 * Assume the on-disk data is X, the current syncing data is Y,
1464 1474 * and the current in-memory data is Z (currently in dmu_sync).
1465 1475 * X and Z are identical but Y is has been modified. Normally,
1466 1476 * when X and Z are the same we will perform a nopwrite but if Y
1467 1477 * is different we must disable nopwrite since the resulting write
1468 1478 * of Y to disk can free the block containing X. If we allowed a
1469 1479 * nopwrite to occur the block pointing to Z would reference a freed
1470 1480 * block. Since this is a rare case we simplify this by disabling
1471 1481 * nopwrite if the current dmu_sync-ing dbuf has been modified in
1472 1482 * a previous transaction.
1473 1483 */
1474 1484 if (dr->dr_next)
1475 1485 zp.zp_nopwrite = B_FALSE;
1476 1486
1477 1487 ASSERT(dr->dr_txg == txg);
1478 1488 if (dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC ||
1479 1489 dr->dt.dl.dr_override_state == DR_OVERRIDDEN) {
1480 1490 /*
1481 1491 * We have already issued a sync write for this buffer,
1482 1492 * or this buffer has already been synced. It could not
1483 1493 * have been dirtied since, or we would have cleared the state.
1484 1494 */
1485 1495 mutex_exit(&db->db_mtx);
1486 1496 return (SET_ERROR(EALREADY));
1487 1497 }
1488 1498
1489 1499 ASSERT(dr->dt.dl.dr_override_state == DR_NOT_OVERRIDDEN);
1490 1500 dr->dt.dl.dr_override_state = DR_IN_DMU_SYNC;
1491 1501 mutex_exit(&db->db_mtx);
1492 1502
1493 1503 dsa = kmem_alloc(sizeof (dmu_sync_arg_t), KM_SLEEP);
1494 1504 dsa->dsa_dr = dr;
1495 1505 dsa->dsa_done = done;
1496 1506 dsa->dsa_zgd = zgd;
1497 1507 dsa->dsa_tx = NULL;
1498 1508
1499 1509 zio_nowait(arc_write(pio, os->os_spa, txg,
1500 1510 bp, dr->dt.dl.dr_data, DBUF_IS_L2CACHEABLE(db),
1501 1511 DBUF_IS_L2COMPRESSIBLE(db), &zp, dmu_sync_ready,
1502 1512 NULL, dmu_sync_done, dsa, ZIO_PRIORITY_SYNC_WRITE,
1503 1513 ZIO_FLAG_CANFAIL, &zb));
1504 1514
1505 1515 return (0);
1506 1516 }
1507 1517
1508 1518 int
1509 1519 dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size, int ibs,
1510 1520 dmu_tx_t *tx)
1511 1521 {
1512 1522 dnode_t *dn;
1513 1523 int err;
1514 1524
1515 1525 err = dnode_hold(os, object, FTAG, &dn);
1516 1526 if (err)
1517 1527 return (err);
1518 1528 err = dnode_set_blksz(dn, size, ibs, tx);
1519 1529 dnode_rele(dn, FTAG);
1520 1530 return (err);
1521 1531 }
1522 1532
1523 1533 void
1524 1534 dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum,
1525 1535 dmu_tx_t *tx)
1526 1536 {
1527 1537 dnode_t *dn;
1528 1538
1529 1539 /* XXX assumes dnode_hold will not get an i/o error */
1530 1540 (void) dnode_hold(os, object, FTAG, &dn);
1531 1541 ASSERT(checksum < ZIO_CHECKSUM_FUNCTIONS);
1532 1542 dn->dn_checksum = checksum;
1533 1543 dnode_setdirty(dn, tx);
1534 1544 dnode_rele(dn, FTAG);
1535 1545 }
1536 1546
1537 1547 void
1538 1548 dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress,
1539 1549 dmu_tx_t *tx)
1540 1550 {
1541 1551 dnode_t *dn;
1542 1552
1543 1553 /* XXX assumes dnode_hold will not get an i/o error */
1544 1554 (void) dnode_hold(os, object, FTAG, &dn);
1545 1555 ASSERT(compress < ZIO_COMPRESS_FUNCTIONS);
1546 1556 dn->dn_compress = compress;
1547 1557 dnode_setdirty(dn, tx);
1548 1558 dnode_rele(dn, FTAG);
1549 1559 }
1550 1560
1551 1561 int zfs_mdcomp_disable = 0;
1552 1562
1553 1563 void
1554 1564 dmu_write_policy(objset_t *os, dnode_t *dn, int level, int wp, zio_prop_t *zp)
1555 1565 {
1556 1566 dmu_object_type_t type = dn ? dn->dn_type : DMU_OT_OBJSET;
1557 1567 boolean_t ismd = (level > 0 || DMU_OT_IS_METADATA(type) ||
1558 1568 (wp & WP_SPILL));
1559 1569 enum zio_checksum checksum = os->os_checksum;
1560 1570 enum zio_compress compress = os->os_compress;
1561 1571 enum zio_checksum dedup_checksum = os->os_dedup_checksum;
1562 1572 boolean_t dedup = B_FALSE;
1563 1573 boolean_t nopwrite = B_FALSE;
1564 1574 boolean_t dedup_verify = os->os_dedup_verify;
1565 1575 int copies = os->os_copies;
1566 1576
1567 1577 /*
1568 1578 * We maintain different write policies for each of the following
1569 1579 * types of data:
1570 1580 * 1. metadata
1571 1581 * 2. preallocated blocks (i.e. level-0 blocks of a dump device)
1572 1582 * 3. all other level 0 blocks
1573 1583 */
1574 1584 if (ismd) {
1575 1585 /*
1576 1586 * XXX -- we should design a compression algorithm
1577 1587 * that specializes in arrays of bps.
1578 1588 */
1579 1589 compress = zfs_mdcomp_disable ? ZIO_COMPRESS_EMPTY :
1580 1590 ZIO_COMPRESS_LZJB;
1581 1591
1582 1592 /*
1583 1593 * Metadata always gets checksummed. If the data
1584 1594 * checksum is multi-bit correctable, and it's not a
1585 1595 * ZBT-style checksum, then it's suitable for metadata
1586 1596 * as well. Otherwise, the metadata checksum defaults
1587 1597 * to fletcher4.
1588 1598 */
1589 1599 if (zio_checksum_table[checksum].ci_correctable < 1 ||
1590 1600 zio_checksum_table[checksum].ci_eck)
1591 1601 checksum = ZIO_CHECKSUM_FLETCHER_4;
1592 1602 } else if (wp & WP_NOFILL) {
1593 1603 ASSERT(level == 0);
1594 1604
1595 1605 /*
1596 1606 * If we're writing preallocated blocks, we aren't actually
1597 1607 * writing them so don't set any policy properties. These
1598 1608 * blocks are currently only used by an external subsystem
1599 1609 * outside of zfs (i.e. dump) and not written by the zio
1600 1610 * pipeline.
1601 1611 */
1602 1612 compress = ZIO_COMPRESS_OFF;
1603 1613 checksum = ZIO_CHECKSUM_NOPARITY;
1604 1614 } else {
1605 1615 compress = zio_compress_select(dn->dn_compress, compress);
1606 1616
1607 1617 checksum = (dedup_checksum == ZIO_CHECKSUM_OFF) ?
1608 1618 zio_checksum_select(dn->dn_checksum, checksum) :
1609 1619 dedup_checksum;
1610 1620
1611 1621 /*
1612 1622 * Determine dedup setting. If we are in dmu_sync(),
1613 1623 * we won't actually dedup now because that's all
1614 1624 * done in syncing context; but we do want to use the
1615 1625 * dedup checkum. If the checksum is not strong
1616 1626 * enough to ensure unique signatures, force
1617 1627 * dedup_verify.
1618 1628 */
1619 1629 if (dedup_checksum != ZIO_CHECKSUM_OFF) {
1620 1630 dedup = (wp & WP_DMU_SYNC) ? B_FALSE : B_TRUE;
1621 1631 if (!zio_checksum_table[checksum].ci_dedup)
1622 1632 dedup_verify = B_TRUE;
1623 1633 }
1624 1634
1625 1635 /*
1626 1636 * Enable nopwrite if we have a cryptographically secure
1627 1637 * checksum that has no known collisions (i.e. SHA-256)
1628 1638 * and compression is enabled. We don't enable nopwrite if
1629 1639 * dedup is enabled as the two features are mutually exclusive.
1630 1640 */
1631 1641 nopwrite = (!dedup && zio_checksum_table[checksum].ci_dedup &&
1632 1642 compress != ZIO_COMPRESS_OFF && zfs_nopwrite_enabled);
1633 1643 }
1634 1644
1635 1645 zp->zp_checksum = checksum;
1636 1646 zp->zp_compress = compress;
1637 1647 zp->zp_type = (wp & WP_SPILL) ? dn->dn_bonustype : type;
1638 1648 zp->zp_level = level;
1639 1649 zp->zp_copies = MIN(copies + ismd, spa_max_replication(os->os_spa));
1640 1650 zp->zp_dedup = dedup;
1641 1651 zp->zp_dedup_verify = dedup && dedup_verify;
1642 1652 zp->zp_nopwrite = nopwrite;
1643 1653 }
1644 1654
1645 1655 int
1646 1656 dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole, uint64_t *off)
1647 1657 {
1648 1658 dnode_t *dn;
1649 1659 int i, err;
1650 1660
1651 1661 err = dnode_hold(os, object, FTAG, &dn);
1652 1662 if (err)
1653 1663 return (err);
1654 1664 /*
1655 1665 * Sync any current changes before
1656 1666 * we go trundling through the block pointers.
1657 1667 */
1658 1668 for (i = 0; i < TXG_SIZE; i++) {
1659 1669 if (list_link_active(&dn->dn_dirty_link[i]))
1660 1670 break;
1661 1671 }
1662 1672 if (i != TXG_SIZE) {
1663 1673 dnode_rele(dn, FTAG);
1664 1674 txg_wait_synced(dmu_objset_pool(os), 0);
1665 1675 err = dnode_hold(os, object, FTAG, &dn);
1666 1676 if (err)
1667 1677 return (err);
1668 1678 }
1669 1679
1670 1680 err = dnode_next_offset(dn, (hole ? DNODE_FIND_HOLE : 0), off, 1, 1, 0);
1671 1681 dnode_rele(dn, FTAG);
1672 1682
1673 1683 return (err);
1674 1684 }
1675 1685
1676 1686 void
1677 1687 dmu_object_info_from_dnode(dnode_t *dn, dmu_object_info_t *doi)
1678 1688 {
1679 1689 dnode_phys_t *dnp;
1680 1690
1681 1691 rw_enter(&dn->dn_struct_rwlock, RW_READER);
1682 1692 mutex_enter(&dn->dn_mtx);
1683 1693
1684 1694 dnp = dn->dn_phys;
1685 1695
1686 1696 doi->doi_data_block_size = dn->dn_datablksz;
1687 1697 doi->doi_metadata_block_size = dn->dn_indblkshift ?
1688 1698 1ULL << dn->dn_indblkshift : 0;
1689 1699 doi->doi_type = dn->dn_type;
1690 1700 doi->doi_bonus_type = dn->dn_bonustype;
1691 1701 doi->doi_bonus_size = dn->dn_bonuslen;
1692 1702 doi->doi_indirection = dn->dn_nlevels;
1693 1703 doi->doi_checksum = dn->dn_checksum;
1694 1704 doi->doi_compress = dn->dn_compress;
1695 1705 doi->doi_physical_blocks_512 = (DN_USED_BYTES(dnp) + 256) >> 9;
1696 1706 doi->doi_max_offset = (dn->dn_maxblkid + 1) * dn->dn_datablksz;
1697 1707 doi->doi_fill_count = 0;
1698 1708 for (int i = 0; i < dnp->dn_nblkptr; i++)
1699 1709 doi->doi_fill_count += dnp->dn_blkptr[i].blk_fill;
1700 1710
1701 1711 mutex_exit(&dn->dn_mtx);
1702 1712 rw_exit(&dn->dn_struct_rwlock);
1703 1713 }
1704 1714
1705 1715 /*
1706 1716 * Get information on a DMU object.
1707 1717 * If doi is NULL, just indicates whether the object exists.
1708 1718 */
1709 1719 int
1710 1720 dmu_object_info(objset_t *os, uint64_t object, dmu_object_info_t *doi)
1711 1721 {
1712 1722 dnode_t *dn;
1713 1723 int err = dnode_hold(os, object, FTAG, &dn);
1714 1724
1715 1725 if (err)
1716 1726 return (err);
1717 1727
1718 1728 if (doi != NULL)
1719 1729 dmu_object_info_from_dnode(dn, doi);
1720 1730
1721 1731 dnode_rele(dn, FTAG);
1722 1732 return (0);
1723 1733 }
1724 1734
1725 1735 /*
1726 1736 * As above, but faster; can be used when you have a held dbuf in hand.
1727 1737 */
1728 1738 void
1729 1739 dmu_object_info_from_db(dmu_buf_t *db_fake, dmu_object_info_t *doi)
1730 1740 {
1731 1741 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
1732 1742
1733 1743 DB_DNODE_ENTER(db);
1734 1744 dmu_object_info_from_dnode(DB_DNODE(db), doi);
1735 1745 DB_DNODE_EXIT(db);
1736 1746 }
1737 1747
1738 1748 /*
1739 1749 * Faster still when you only care about the size.
1740 1750 * This is specifically optimized for zfs_getattr().
1741 1751 */
1742 1752 void
1743 1753 dmu_object_size_from_db(dmu_buf_t *db_fake, uint32_t *blksize,
1744 1754 u_longlong_t *nblk512)
1745 1755 {
1746 1756 dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
1747 1757 dnode_t *dn;
1748 1758
1749 1759 DB_DNODE_ENTER(db);
1750 1760 dn = DB_DNODE(db);
1751 1761
1752 1762 *blksize = dn->dn_datablksz;
1753 1763 /* add 1 for dnode space */
1754 1764 *nblk512 = ((DN_USED_BYTES(dn->dn_phys) + SPA_MINBLOCKSIZE/2) >>
1755 1765 SPA_MINBLOCKSHIFT) + 1;
1756 1766 DB_DNODE_EXIT(db);
1757 1767 }
1758 1768
1759 1769 void
1760 1770 byteswap_uint64_array(void *vbuf, size_t size)
1761 1771 {
1762 1772 uint64_t *buf = vbuf;
1763 1773 size_t count = size >> 3;
1764 1774 int i;
1765 1775
1766 1776 ASSERT((size & 7) == 0);
1767 1777
1768 1778 for (i = 0; i < count; i++)
1769 1779 buf[i] = BSWAP_64(buf[i]);
1770 1780 }
1771 1781
1772 1782 void
1773 1783 byteswap_uint32_array(void *vbuf, size_t size)
1774 1784 {
1775 1785 uint32_t *buf = vbuf;
1776 1786 size_t count = size >> 2;
1777 1787 int i;
1778 1788
1779 1789 ASSERT((size & 3) == 0);
1780 1790
1781 1791 for (i = 0; i < count; i++)
1782 1792 buf[i] = BSWAP_32(buf[i]);
1783 1793 }
1784 1794
1785 1795 void
1786 1796 byteswap_uint16_array(void *vbuf, size_t size)
1787 1797 {
1788 1798 uint16_t *buf = vbuf;
1789 1799 size_t count = size >> 1;
1790 1800 int i;
1791 1801
1792 1802 ASSERT((size & 1) == 0);
1793 1803
1794 1804 for (i = 0; i < count; i++)
1795 1805 buf[i] = BSWAP_16(buf[i]);
1796 1806 }
1797 1807
1798 1808 /* ARGSUSED */
1799 1809 void
1800 1810 byteswap_uint8_array(void *vbuf, size_t size)
1801 1811 {
1802 1812 }
1803 1813
1804 1814 void
1805 1815 dmu_init(void)
1806 1816 {
1807 1817 zfs_dbgmsg_init();
1808 1818 sa_cache_init();
1809 1819 xuio_stat_init();
1810 1820 dmu_objset_init();
1811 1821 dnode_init();
1812 1822 dbuf_init();
1813 1823 zfetch_init();
1814 1824 l2arc_init();
1815 1825 arc_init();
1816 1826 }
1817 1827
1818 1828 void
1819 1829 dmu_fini(void)
1820 1830 {
1821 1831 arc_fini(); /* arc depends on l2arc, so arc must go first */
1822 1832 l2arc_fini();
1823 1833 zfetch_fini();
1824 1834 dbuf_fini();
1825 1835 dnode_fini();
1826 1836 dmu_objset_fini();
1827 1837 xuio_stat_fini();
1828 1838 sa_cache_fini();
1829 1839 zfs_dbgmsg_fini();
1830 1840 }
|
↓ open down ↓ |
1145 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX