spacepaste

Paste details

reply | raw

  1.  
  2. diff --git a/include/sys/dmu_impl.h b/include/sys/dmu_impl.h
  3. index 03a63077f..7880091b1 100644
  4. --- a/include/sys/dmu_impl.h
  5. +++ b/include/sys/dmu_impl.h
  6. @@ -276,6 +276,18 @@ typedef struct dmu_sendarg {
  7. boolean_t dsa_sent_end;
  8. } dmu_sendarg_t;
  10. +typedef void dmu_done_func_t(void *private, int error, int numbufsp, dmu_buf_t **dbpp);
  11. +
  12. +typedef struct dmu_op {
  13. + dmu_done_func_t dop_done_func;
  14. + void *dop_private;
  15. + dmu_buf_t **dop_dbp;
  16. + uint64_t dop_nblks;
  17. + boolean_t *dop_read;
  18. + void *dop_tag
  19. + int dop_err;
  20. +} dmu_op_t;
  21. +
  22. void dmu_object_zapify(objset_t *, uint64_t, dmu_object_type_t, dmu_tx_t *);
  23. void dmu_object_free_zapified(objset_t *, uint64_t, dmu_tx_t *);
  24. int dmu_buf_hold_noread(objset_t *, uint64_t, uint64_t,
  25. diff --git a/module/zfs/dmu.c b/module/zfs/dmu.c
  26. index 8779eb358..0e5d162cc 100644
  27. --- a/module/zfs/dmu.c
  28. +++ b/module/zfs/dmu.c
  29. @@ -478,6 +478,51 @@ dmu_spill_hold_by_bonus(dmu_buf_t *bonus, uint32_t flags, void *tag,
  30. return (err);
  31. }
  33. +void dmu_done_func(zio_t *zio)
  34. +{
  35. + dmu_op_t *dop = zio->io_private;
  36. + dmu_buf_t **dbp = dop->dop_dbp;
  37. + uint64_t nblks = dop->dop_nblks, i;
  38. + dmu_done_func_t done_func = dop->dop_done_func;
  39. + void *tag = dop->dop_tag;
  40. + void *private = dop->dop_private;
  41. + boolean_t read = dop->dop_read;
  42. + int err = zio->io_err;
  43. +
  44. + if (done_func != NULL)
  45. + kmem_free(dop);
  46. +
  47. + if (err) {
  48. + dmu_buf_rele_array(dbp, nblks, tag);
  49. + goto out;
  50. + }
  51. +
  52. + /* wait for other io to complete */
  53. + if (read) {
  54. + for (i = 0; i < nblks; i++) {
  55. + dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
  56. + mutex_enter(&db->db_mtx);
  57. + while (db->db_state == DB_READ ||
  58. + db->db_state == DB_FILL)
  59. + cv_wait(&db->db_changed, &db->db_mtx);
  60. + if (db->db_state == DB_UNCACHED)
  61. + err = SET_ERROR(EIO);
  62. + mutex_exit(&db->db_mtx);
  63. + if (err) {
  64. + dmu_buf_rele_array(dbp, nblks, tag);
  65. + gptp pout;
  66. + }
  67. + }
  68. + }
  69. +
  70. + err = 0;
  71. +out:
  72. + if (done_func != NULL)
  73. + dop->dop_done(private, err, nblks, dbp;
  74. + else
  75. + dop->dop_err = err;
  76. +}
  77. +
  78. /*
  79. * Note: longer-term, we should modify all of the dmu_buf_*() interfaces
  80. * to take a held dnode rather than <os, object> -- the lookup is wasteful,
  81. @@ -485,8 +530,9 @@ dmu_spill_hold_by_bonus(dmu_buf_t *bonus, uint32_t flags, void *tag,
  82. * whose dnodes are in the same block.
  83. */
  84. static int
  85. -dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
  86. - boolean_t read, void *tag, int *numbufsp, dmu_buf_t ***dbpp, uint32_t flags)
  87. +dmu_buf_hold_array_by_dnode(dnode_t *dn, dmu_done_func_t done_func, void *private,
  88. + uint64_t offset, uint64_t length, boolean_t read, void *tag, int *numbufsp,
  89. + dmu_buf_t ***dbpp, uint32_t flags)
  90. {
  91. dmu_buf_t **dbp;
  92. uint64_t blkid, nblks, i;
  93. @@ -523,8 +569,18 @@ dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
  94. nblks = 1;
  95. }
  96. dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks, KM_SLEEP);
  97. + dmu_op_t *dop = kmem_zalloc(sizeof (dmu_op_t), KM_SLEEP);
  98. +
  99. + dop->dop_done_func = dmu_done_func;
  100. + dop->dop_private = private;
  101. + dop->dop_dbp = dbp;
  102. + dop->dop_nblks = nlks;
  103. + dop->dop_read = read;
  104. + dop->dop_tag = tag;
  105. +
  106. + zio = zio_root(dn->dn_objset->os_spa, &dmu_done_func, dop,
  107. + ZIO_FLAG_CANFAIL);
  109. - zio = zio_root(dn->dn_objset->os_spa, NULL, NULL, ZIO_FLAG_CANFAIL);
  110. blkid = dbuf_whichblock(dn, 0, offset);
  111. for (i = 0; i < nblks; i++) {
  112. dmu_buf_impl_t *db = dbuf_hold(dn, blkid + i, tag);
  113. @@ -548,34 +604,21 @@ dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
  114. }
  115. rw_exit(&dn->dn_struct_rwlock);
  117. - /* wait for async i/o */
  118. - err = zio_wait(zio);
  119. - if (err) {
  120. - dmu_buf_rele_array(dbp, nblks, tag);
  121. - return (err);
  122. + if (done_func != NULL) {
  123. + return (0);
  124. }
  126. - /* wait for other io to complete */
  127. - if (read) {
  128. - for (i = 0; i < nblks; i++) {
  129. - dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
  130. - mutex_enter(&db->db_mtx);
  131. - while (db->db_state == DB_READ ||
  132. - db->db_state == DB_FILL)
  133. - cv_wait(&db->db_changed, &db->db_mtx);
  134. - if (db->db_state == DB_UNCACHED)
  135. - err = SET_ERROR(EIO);
  136. - mutex_exit(&db->db_mtx);
  137. - if (err) {
  138. - dmu_buf_rele_array(dbp, nblks, tag);
  139. - return (err);
  140. - }
  141. - }
  142. + (void) zio_wait(zio);
  143. +
  144. + err = dop->dop_err;
  145. + kmem_free(dop);
  146. +
  147. + if (err == 0) {
  148. + *numbufsp = nblks;
  149. + *dbpp = dbp;
  150. }
  152. - *numbufsp = nblks;
  153. - *dbpp = dbp;
  154. - return (0);
  155. + return (err);
  156. }
  158. static int
  159. @@ -589,8 +632,8 @@ dmu_buf_hold_array(objset_t *os, uint64_t object, uint64_t offset,
  160. if (err)
  161. return (err);
  163. - err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag,
  164. - numbufsp, dbpp, DMU_READ_PREFETCH);
  165. + err = dmu_buf_hold_array_by_dnode(dn, NULL, NULL, offset,
  166. + length, read, tag, numbufsp, dbpp, DMU_READ_PREFETCH);
  168. dnode_rele(dn, FTAG);
  170. @@ -608,8 +651,8 @@ dmu_buf_hold_array_by_bonus(dmu_buf_t *db_fake, uint64_t offset,
  172. DB_DNODE_ENTER(db);
  173. dn = DB_DNODE(db);
  174. - err = dmu_buf_hold_array_by_dnode(dn, offset, length, read, tag,
  175. - numbufsp, dbpp, DMU_READ_PREFETCH);
  176. + err = dmu_buf_hold_array_by_dnode(dn, NULL, NULL, offset,
  177. + length, read, tag, numbufsp, dbpp, DMU_READ_PREFETCH);
  178. DB_DNODE_EXIT(db);
  180. return (err);
  181. @@ -955,8 +998,9 @@ dmu_read_impl(dnode_t *dn, uint64_t offset, uint64_t size,
  182. * NB: we could do this block-at-a-time, but it's nice
  183. * to be reading in parallel.
  184. */
  185. - err = dmu_buf_hold_array_by_dnode(dn, offset, mylen,
  186. - TRUE, FTAG, &numbufs, &dbp, flags);
  187. + err = dmu_buf_hold_array_by_dnode(dn, NULL, NULL,
  188. + offset, mylen, TRUE, FTAG, &numbufs, &dbp,
  189. + flags);
  190. if (err)
  191. break;
  193. @@ -1064,8 +1108,9 @@ dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
  194. if (size == 0)
  195. return;
  197. - VERIFY0(dmu_buf_hold_array_by_dnode(dn, offset, size,
  198. - FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH));
  199. + VERIFY0(dmu_buf_hold_array_by_dnode(dn, NULL, NULL,
  200. + offset, size, FALSE, FTAG, &numbufs, &dbp,
  201. + DMU_READ_PREFETCH));
  202. dmu_write_impl(dbp, numbufs, offset, size, buf, tx);
  203. dmu_buf_rele_array(dbp, numbufs, FTAG);
  204. }
  205. @@ -1391,8 +1436,8 @@ dmu_read_uio_dnode(dnode_t *dn, uio_t *uio, uint64_t size)
  206. * NB: we could do this block-at-a-time, but it's nice
  207. * to be reading in parallel.
  208. */
  209. - err = dmu_buf_hold_array_by_dnode(dn, uio->uio_loffset, size,
  210. - TRUE, FTAG, &numbufs, &dbp, 0);
  211. + err = dmu_buf_hold_array_by_dnode(dn, NULL, NULL,
  212. + uio->uio_loffset, size, TRUE, FTAG, &numbufs, &dbp, 0);
  213. if (err)
  214. return (err);
  216. @@ -1495,8 +1540,9 @@ dmu_write_uio_dnode(dnode_t *dn, uio_t *uio, uint64_t size, dmu_tx_t *tx)
  217. int err = 0;
  218. int i;
  220. - err = dmu_buf_hold_array_by_dnode(dn, uio->uio_loffset, size,
  221. - FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH);
  222. + err = dmu_buf_hold_array_by_dnode(dn, NULL, NULL,
  223. + uio->uio_loffset, size, FALSE, FTAG, &numbufs, &dbp,
  224. + DMU_READ_PREFETCH);
  225. if (err)
  226. return (err);
  228.  
Powered by spacepaste. Paste removal.