]>
Commit | Line | Data |
---|---|---|
a1d477c2 MA |
1 | /* |
2 | * CDDL HEADER START | |
3 | * | |
4 | * This file and its contents are supplied under the terms of the | |
5 | * Common Development and Distribution License ("CDDL"), version 1.0. | |
6 | * You may only use this file in accordance with the terms of version | |
7 | * 1.0 of the CDDL. | |
8 | * | |
9 | * A full copy of the text of the CDDL should have accompanied this | |
10 | * source. A copy of the CDDL is also available via the Internet at | |
11 | * http://www.illumos.org/license/CDDL. | |
12 | * | |
13 | * CDDL HEADER END | |
14 | */ | |
15 | ||
16 | /* | |
17 | * Copyright (c) 2015 by Delphix. All rights reserved. | |
18 | */ | |
19 | ||
20 | #include <sys/dmu_tx.h> | |
21 | #include <sys/spa.h> | |
22 | #include <sys/dmu.h> | |
23 | #include <sys/dsl_pool.h> | |
24 | #include <sys/vdev_indirect_births.h> | |
25 | ||
26 | #ifdef ZFS_DEBUG | |
27 | static boolean_t | |
28 | vdev_indirect_births_verify(vdev_indirect_births_t *vib) | |
29 | { | |
30 | ASSERT(vib != NULL); | |
31 | ||
32 | ASSERT(vib->vib_object != 0); | |
33 | ASSERT(vib->vib_objset != NULL); | |
34 | ASSERT(vib->vib_phys != NULL); | |
35 | ASSERT(vib->vib_dbuf != NULL); | |
36 | ||
37 | EQUIV(vib->vib_phys->vib_count > 0, vib->vib_entries != NULL); | |
38 | ||
39 | return (B_TRUE); | |
40 | } | |
ce767d69 AZ |
41 | #else |
42 | #define vdev_indirect_births_verify(vib) ((void) sizeof (vib), B_TRUE) | |
a1d477c2 MA |
43 | #endif |
44 | ||
45 | uint64_t | |
46 | vdev_indirect_births_count(vdev_indirect_births_t *vib) | |
47 | { | |
48 | ASSERT(vdev_indirect_births_verify(vib)); | |
49 | ||
50 | return (vib->vib_phys->vib_count); | |
51 | } | |
52 | ||
53 | uint64_t | |
54 | vdev_indirect_births_object(vdev_indirect_births_t *vib) | |
55 | { | |
56 | ASSERT(vdev_indirect_births_verify(vib)); | |
57 | ||
58 | return (vib->vib_object); | |
59 | } | |
60 | ||
61 | static uint64_t | |
62 | vdev_indirect_births_size_impl(vdev_indirect_births_t *vib) | |
63 | { | |
64 | return (vib->vib_phys->vib_count * sizeof (*vib->vib_entries)); | |
65 | } | |
66 | ||
67 | void | |
68 | vdev_indirect_births_close(vdev_indirect_births_t *vib) | |
69 | { | |
70 | ASSERT(vdev_indirect_births_verify(vib)); | |
71 | ||
72 | if (vib->vib_phys->vib_count > 0) { | |
73 | uint64_t births_size = vdev_indirect_births_size_impl(vib); | |
74 | ||
d230a65c | 75 | vmem_free(vib->vib_entries, births_size); |
a1d477c2 MA |
76 | vib->vib_entries = NULL; |
77 | } | |
78 | ||
79 | dmu_buf_rele(vib->vib_dbuf, vib); | |
80 | ||
81 | vib->vib_objset = NULL; | |
82 | vib->vib_object = 0; | |
83 | vib->vib_dbuf = NULL; | |
84 | vib->vib_phys = NULL; | |
85 | ||
86 | kmem_free(vib, sizeof (*vib)); | |
87 | } | |
88 | ||
89 | uint64_t | |
90 | vdev_indirect_births_alloc(objset_t *os, dmu_tx_t *tx) | |
91 | { | |
92 | ASSERT(dmu_tx_is_syncing(tx)); | |
93 | ||
94 | return (dmu_object_alloc(os, | |
95 | DMU_OTN_UINT64_METADATA, SPA_OLD_MAXBLOCKSIZE, | |
96 | DMU_OTN_UINT64_METADATA, sizeof (vdev_indirect_birth_phys_t), | |
97 | tx)); | |
98 | } | |
99 | ||
100 | vdev_indirect_births_t * | |
101 | vdev_indirect_births_open(objset_t *os, uint64_t births_object) | |
102 | { | |
103 | vdev_indirect_births_t *vib = kmem_zalloc(sizeof (*vib), KM_SLEEP); | |
104 | ||
105 | vib->vib_objset = os; | |
106 | vib->vib_object = births_object; | |
107 | ||
108 | VERIFY0(dmu_bonus_hold(os, vib->vib_object, vib, &vib->vib_dbuf)); | |
109 | vib->vib_phys = vib->vib_dbuf->db_data; | |
110 | ||
111 | if (vib->vib_phys->vib_count > 0) { | |
112 | uint64_t births_size = vdev_indirect_births_size_impl(vib); | |
d230a65c | 113 | vib->vib_entries = vmem_alloc(births_size, KM_SLEEP); |
a1d477c2 MA |
114 | VERIFY0(dmu_read(vib->vib_objset, vib->vib_object, 0, |
115 | births_size, vib->vib_entries, DMU_READ_PREFETCH)); | |
116 | } | |
117 | ||
118 | ASSERT(vdev_indirect_births_verify(vib)); | |
119 | ||
120 | return (vib); | |
121 | } | |
122 | ||
123 | void | |
124 | vdev_indirect_births_free(objset_t *os, uint64_t object, dmu_tx_t *tx) | |
125 | { | |
126 | VERIFY0(dmu_object_free(os, object, tx)); | |
127 | } | |
128 | ||
129 | void | |
130 | vdev_indirect_births_add_entry(vdev_indirect_births_t *vib, | |
131 | uint64_t max_offset, uint64_t txg, dmu_tx_t *tx) | |
132 | { | |
133 | vdev_indirect_birth_entry_phys_t vibe; | |
134 | uint64_t old_size; | |
135 | uint64_t new_size; | |
136 | vdev_indirect_birth_entry_phys_t *new_entries; | |
137 | ||
138 | ASSERT(dmu_tx_is_syncing(tx)); | |
139 | ASSERT(dsl_pool_sync_context(dmu_tx_pool(tx))); | |
140 | ASSERT(vdev_indirect_births_verify(vib)); | |
141 | ||
142 | dmu_buf_will_dirty(vib->vib_dbuf, tx); | |
143 | ||
144 | vibe.vibe_offset = max_offset; | |
145 | vibe.vibe_phys_birth_txg = txg; | |
146 | ||
147 | old_size = vdev_indirect_births_size_impl(vib); | |
148 | dmu_write(vib->vib_objset, vib->vib_object, old_size, sizeof (vibe), | |
149 | &vibe, tx); | |
150 | vib->vib_phys->vib_count++; | |
151 | new_size = vdev_indirect_births_size_impl(vib); | |
152 | ||
d230a65c | 153 | new_entries = vmem_alloc(new_size, KM_SLEEP); |
a1d477c2 | 154 | if (old_size > 0) { |
861166b0 | 155 | memcpy(new_entries, vib->vib_entries, old_size); |
d230a65c | 156 | vmem_free(vib->vib_entries, old_size); |
a1d477c2 MA |
157 | } |
158 | new_entries[vib->vib_phys->vib_count - 1] = vibe; | |
159 | vib->vib_entries = new_entries; | |
160 | } | |
161 | ||
162 | uint64_t | |
163 | vdev_indirect_births_last_entry_txg(vdev_indirect_births_t *vib) | |
164 | { | |
165 | ASSERT(vdev_indirect_births_verify(vib)); | |
166 | ASSERT(vib->vib_phys->vib_count > 0); | |
167 | ||
168 | vdev_indirect_birth_entry_phys_t *last = | |
169 | &vib->vib_entries[vib->vib_phys->vib_count - 1]; | |
170 | return (last->vibe_phys_birth_txg); | |
171 | } | |
172 | ||
173 | /* | |
174 | * Return the txg in which the given range was copied (i.e. its physical | |
175 | * birth txg). The specified offset+asize must be contiguously mapped | |
176 | * (i.e. not a split block). | |
177 | * | |
178 | * The entries are sorted by increasing phys_birth, and also by increasing | |
179 | * offset. We find the specified offset by binary search. Note that we | |
180 | * can not use bsearch() because looking at each entry independently is | |
181 | * insufficient to find the correct entry. Each entry implicitly relies | |
182 | * on the previous entry: an entry indicates that the offsets from the | |
183 | * end of the previous entry to the end of this entry were written in the | |
184 | * specified txg. | |
185 | */ | |
186 | uint64_t | |
187 | vdev_indirect_births_physbirth(vdev_indirect_births_t *vib, uint64_t offset, | |
188 | uint64_t asize) | |
189 | { | |
190 | vdev_indirect_birth_entry_phys_t *base; | |
191 | vdev_indirect_birth_entry_phys_t *last; | |
192 | ||
193 | ASSERT(vdev_indirect_births_verify(vib)); | |
194 | ASSERT(vib->vib_phys->vib_count > 0); | |
195 | ||
196 | base = vib->vib_entries; | |
197 | last = base + vib->vib_phys->vib_count - 1; | |
198 | ||
199 | ASSERT3U(offset, <, last->vibe_offset); | |
200 | ||
201 | while (last >= base) { | |
202 | vdev_indirect_birth_entry_phys_t *p = | |
203 | base + ((last - base) / 2); | |
204 | if (offset >= p->vibe_offset) { | |
205 | base = p + 1; | |
206 | } else if (p == vib->vib_entries || | |
207 | offset >= (p - 1)->vibe_offset) { | |
208 | ASSERT3U(offset + asize, <=, p->vibe_offset); | |
209 | return (p->vibe_phys_birth_txg); | |
210 | } else { | |
211 | last = p - 1; | |
212 | } | |
213 | } | |
214 | ASSERT(!"offset not found"); | |
215 | return (-1); | |
216 | } | |
217 | ||
93ce2b4c | 218 | #if defined(_KERNEL) |
a1d477c2 MA |
219 | EXPORT_SYMBOL(vdev_indirect_births_add_entry); |
220 | EXPORT_SYMBOL(vdev_indirect_births_alloc); | |
221 | EXPORT_SYMBOL(vdev_indirect_births_close); | |
222 | EXPORT_SYMBOL(vdev_indirect_births_count); | |
223 | EXPORT_SYMBOL(vdev_indirect_births_free); | |
224 | EXPORT_SYMBOL(vdev_indirect_births_last_entry_txg); | |
225 | EXPORT_SYMBOL(vdev_indirect_births_object); | |
226 | EXPORT_SYMBOL(vdev_indirect_births_open); | |
227 | EXPORT_SYMBOL(vdev_indirect_births_physbirth); | |
228 | #endif |