initial commit
[freebsd-arm:freebsd-arm.git] / cddl / contrib / opensolaris / uts / common / fs / zfs / space_map.c
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25
26 #pragma ident   "%Z%%M% %I%     %E% SMI"
27
28 #include <sys/zfs_context.h>
29 #include <sys/spa.h>
30 #include <sys/dmu.h>
31 #include <sys/zio.h>
32 #include <sys/space_map.h>
33
34 /*
35  * Space map routines.
36  * NOTE: caller is responsible for all locking.
37  */
38 static int
39 space_map_seg_compare(const void *x1, const void *x2)
40 {
41         const space_seg_t *s1 = x1;
42         const space_seg_t *s2 = x2;
43
44         if (s1->ss_start < s2->ss_start) {
45                 if (s1->ss_end > s2->ss_start)
46                         return (0);
47                 return (-1);
48         }
49         if (s1->ss_start > s2->ss_start) {
50                 if (s1->ss_start < s2->ss_end)
51                         return (0);
52                 return (1);
53         }
54         return (0);
55 }
56
57 void
58 space_map_create(space_map_t *sm, uint64_t start, uint64_t size, uint8_t shift,
59         kmutex_t *lp)
60 {
61         bzero(sm, sizeof (*sm));
62
63         cv_init(&sm->sm_load_cv, NULL, CV_DEFAULT, NULL);
64         avl_create(&sm->sm_root, space_map_seg_compare,
65             sizeof (space_seg_t), offsetof(struct space_seg, ss_node));
66
67         sm->sm_start = start;
68         sm->sm_size = size;
69         sm->sm_shift = shift;
70         sm->sm_lock = lp;
71 }
72
73 void
74 space_map_destroy(space_map_t *sm)
75 {
76         ASSERT(!sm->sm_loaded && !sm->sm_loading);
77         VERIFY3U(sm->sm_space, ==, 0);
78         avl_destroy(&sm->sm_root);
79         cv_destroy(&sm->sm_load_cv);
80 }
81
82 void
83 space_map_add(space_map_t *sm, uint64_t start, uint64_t size)
84 {
85         avl_index_t where;
86         space_seg_t ssearch, *ss_before, *ss_after, *ss;
87         uint64_t end = start + size;
88         int merge_before, merge_after;
89
90         ASSERT(MUTEX_HELD(sm->sm_lock));
91         VERIFY(size != 0);
92         VERIFY3U(start, >=, sm->sm_start);
93         VERIFY3U(end, <=, sm->sm_start + sm->sm_size);
94         VERIFY(sm->sm_space + size <= sm->sm_size);
95         VERIFY(P2PHASE(start, 1ULL << sm->sm_shift) == 0);
96         VERIFY(P2PHASE(size, 1ULL << sm->sm_shift) == 0);
97
98         ssearch.ss_start = start;
99         ssearch.ss_end = end;
100         ss = avl_find(&sm->sm_root, &ssearch, &where);
101
102         if (ss != NULL && ss->ss_start <= start && ss->ss_end >= end) {
103                 zfs_panic_recover("zfs: allocating allocated segment"
104                     "(offset=%llu size=%llu)\n",
105                     (longlong_t)start, (longlong_t)size);
106                 return;
107         }
108
109         /* Make sure we don't overlap with either of our neighbors */
110         VERIFY(ss == NULL);
111
112         ss_before = avl_nearest(&sm->sm_root, where, AVL_BEFORE);
113         ss_after = avl_nearest(&sm->sm_root, where, AVL_AFTER);
114
115         merge_before = (ss_before != NULL && ss_before->ss_end == start);
116         merge_after = (ss_after != NULL && ss_after->ss_start == end);
117
118         if (merge_before && merge_after) {
119                 avl_remove(&sm->sm_root, ss_before);
120                 ss_after->ss_start = ss_before->ss_start;
121                 kmem_free(ss_before, sizeof (*ss_before));
122         } else if (merge_before) {
123                 ss_before->ss_end = end;
124         } else if (merge_after) {
125                 ss_after->ss_start = start;
126         } else {
127                 ss = kmem_alloc(sizeof (*ss), KM_SLEEP);
128                 ss->ss_start = start;
129                 ss->ss_end = end;
130                 avl_insert(&sm->sm_root, ss, where);
131         }
132
133         sm->sm_space += size;
134 }
135
136 void
137 space_map_remove(space_map_t *sm, uint64_t start, uint64_t size)
138 {
139         avl_index_t where;
140         space_seg_t ssearch, *ss, *newseg;
141         uint64_t end = start + size;
142         int left_over, right_over;
143
144         ASSERT(MUTEX_HELD(sm->sm_lock));
145         VERIFY(size != 0);
146         VERIFY(P2PHASE(start, 1ULL << sm->sm_shift) == 0);
147         VERIFY(P2PHASE(size, 1ULL << sm->sm_shift) == 0);
148
149         ssearch.ss_start = start;
150         ssearch.ss_end = end;
151         ss = avl_find(&sm->sm_root, &ssearch, &where);
152
153         /* Make sure we completely overlap with someone */
154         if (ss == NULL) {
155                 zfs_panic_recover("zfs: freeing free segment "
156                     "(offset=%llu size=%llu)",
157                     (longlong_t)start, (longlong_t)size);
158                 return;
159         }
160         VERIFY3U(ss->ss_start, <=, start);
161         VERIFY3U(ss->ss_end, >=, end);
162         VERIFY(sm->sm_space - size <= sm->sm_size);
163
164         left_over = (ss->ss_start != start);
165         right_over = (ss->ss_end != end);
166
167         if (left_over && right_over) {
168                 newseg = kmem_alloc(sizeof (*newseg), KM_SLEEP);
169                 newseg->ss_start = end;
170                 newseg->ss_end = ss->ss_end;
171                 ss->ss_end = start;
172                 avl_insert_here(&sm->sm_root, newseg, ss, AVL_AFTER);
173         } else if (left_over) {
174                 ss->ss_end = start;
175         } else if (right_over) {
176                 ss->ss_start = end;
177         } else {
178                 avl_remove(&sm->sm_root, ss);
179                 kmem_free(ss, sizeof (*ss));
180         }
181
182         sm->sm_space -= size;
183 }
184
185 int
186 space_map_contains(space_map_t *sm, uint64_t start, uint64_t size)
187 {
188         avl_index_t where;
189         space_seg_t ssearch, *ss;
190         uint64_t end = start + size;
191
192         ASSERT(MUTEX_HELD(sm->sm_lock));
193         VERIFY(size != 0);
194         VERIFY(P2PHASE(start, 1ULL << sm->sm_shift) == 0);
195         VERIFY(P2PHASE(size, 1ULL << sm->sm_shift) == 0);
196
197         ssearch.ss_start = start;
198         ssearch.ss_end = end;
199         ss = avl_find(&sm->sm_root, &ssearch, &where);
200
201         return (ss != NULL && ss->ss_start <= start && ss->ss_end >= end);
202 }
203
204 void
205 space_map_vacate(space_map_t *sm, space_map_func_t *func, space_map_t *mdest)
206 {
207         space_seg_t *ss;
208         void *cookie = NULL;
209
210         ASSERT(MUTEX_HELD(sm->sm_lock));
211
212         while ((ss = avl_destroy_nodes(&sm->sm_root, &cookie)) != NULL) {
213                 if (func != NULL)
214                         func(mdest, ss->ss_start, ss->ss_end - ss->ss_start);
215                 kmem_free(ss, sizeof (*ss));
216         }
217         sm->sm_space = 0;
218 }
219
220 void
221 space_map_walk(space_map_t *sm, space_map_func_t *func, space_map_t *mdest)
222 {
223         space_seg_t *ss;
224
225         for (ss = avl_first(&sm->sm_root); ss; ss = AVL_NEXT(&sm->sm_root, ss))
226                 func(mdest, ss->ss_start, ss->ss_end - ss->ss_start);
227 }
228
229 void
230 space_map_excise(space_map_t *sm, uint64_t start, uint64_t size)
231 {
232         avl_tree_t *t = &sm->sm_root;
233         avl_index_t where;
234         space_seg_t *ss, search;
235         uint64_t end = start + size;
236         uint64_t rm_start, rm_end;
237
238         ASSERT(MUTEX_HELD(sm->sm_lock));
239
240         search.ss_start = start;
241         search.ss_end = start;
242
243         for (;;) {
244                 ss = avl_find(t, &search, &where);
245
246                 if (ss == NULL)
247                         ss = avl_nearest(t, where, AVL_AFTER);
248
249                 if (ss == NULL || ss->ss_start >= end)
250                         break;
251
252                 rm_start = MAX(ss->ss_start, start);
253                 rm_end = MIN(ss->ss_end, end);
254
255                 space_map_remove(sm, rm_start, rm_end - rm_start);
256         }
257 }
258
259 /*
260  * Replace smd with the union of smd and sms.
261  */
262 void
263 space_map_union(space_map_t *smd, space_map_t *sms)
264 {
265         avl_tree_t *t = &sms->sm_root;
266         space_seg_t *ss;
267
268         ASSERT(MUTEX_HELD(smd->sm_lock));
269
270         /*
271          * For each source segment, remove any intersections with the
272          * destination, then add the source segment to the destination.
273          */
274         for (ss = avl_first(t); ss != NULL; ss = AVL_NEXT(t, ss)) {
275                 space_map_excise(smd, ss->ss_start, ss->ss_end - ss->ss_start);
276                 space_map_add(smd, ss->ss_start, ss->ss_end - ss->ss_start);
277         }
278 }
279
280 /*
281  * Wait for any in-progress space_map_load() to complete.
282  */
283 void
284 space_map_load_wait(space_map_t *sm)
285 {
286         ASSERT(MUTEX_HELD(sm->sm_lock));
287
288         while (sm->sm_loading)
289                 cv_wait(&sm->sm_load_cv, sm->sm_lock);
290 }
291
292 /*
293  * Note: space_map_load() will drop sm_lock across dmu_read() calls.
294  * The caller must be OK with this.
295  */
296 int
297 space_map_load(space_map_t *sm, space_map_ops_t *ops, uint8_t maptype,
298         space_map_obj_t *smo, objset_t *os)
299 {
300         uint64_t *entry, *entry_map, *entry_map_end;
301         uint64_t bufsize, size, offset, end, space;
302         uint64_t mapstart = sm->sm_start;
303         int error = 0;
304
305         ASSERT(MUTEX_HELD(sm->sm_lock));
306
307         space_map_load_wait(sm);
308
309         if (sm->sm_loaded)
310                 return (0);
311
312         sm->sm_loading = B_TRUE;
313         end = smo->smo_objsize;
314         space = smo->smo_alloc;
315
316         ASSERT(sm->sm_ops == NULL);
317         VERIFY3U(sm->sm_space, ==, 0);
318
319         if (maptype == SM_FREE) {
320                 space_map_add(sm, sm->sm_start, sm->sm_size);
321                 space = sm->sm_size - space;
322         }
323
324         bufsize = 1ULL << SPACE_MAP_BLOCKSHIFT;
325         entry_map = zio_buf_alloc(bufsize);
326
327         mutex_exit(sm->sm_lock);
328         if (end > bufsize)
329                 dmu_prefetch(os, smo->smo_object, bufsize, end - bufsize);
330         mutex_enter(sm->sm_lock);
331
332         for (offset = 0; offset < end; offset += bufsize) {
333                 size = MIN(end - offset, bufsize);
334                 VERIFY(P2PHASE(size, sizeof (uint64_t)) == 0);
335                 VERIFY(size != 0);
336
337                 dprintf("object=%llu  offset=%llx  size=%llx\n",
338                     smo->smo_object, offset, size);
339
340                 mutex_exit(sm->sm_lock);
341                 error = dmu_read(os, smo->smo_object, offset, size, entry_map);
342                 mutex_enter(sm->sm_lock);
343                 if (error != 0)
344                         break;
345
346                 entry_map_end = entry_map + (size / sizeof (uint64_t));
347                 for (entry = entry_map; entry < entry_map_end; entry++) {
348                         uint64_t e = *entry;
349
350                         if (SM_DEBUG_DECODE(e))         /* Skip debug entries */
351                                 continue;
352
353                         (SM_TYPE_DECODE(e) == maptype ?
354                             space_map_add : space_map_remove)(sm,
355                             (SM_OFFSET_DECODE(e) << sm->sm_shift) + mapstart,
356                             SM_RUN_DECODE(e) << sm->sm_shift);
357                 }
358         }
359
360         if (error == 0) {
361                 VERIFY3U(sm->sm_space, ==, space);
362
363                 sm->sm_loaded = B_TRUE;
364                 sm->sm_ops = ops;
365                 if (ops != NULL)
366                         ops->smop_load(sm);
367         } else {
368                 space_map_vacate(sm, NULL, NULL);
369         }
370
371         zio_buf_free(entry_map, bufsize);
372
373         sm->sm_loading = B_FALSE;
374
375         cv_broadcast(&sm->sm_load_cv);
376
377         return (error);
378 }
379
380 void
381 space_map_unload(space_map_t *sm)
382 {
383         ASSERT(MUTEX_HELD(sm->sm_lock));
384
385         if (sm->sm_loaded && sm->sm_ops != NULL)
386                 sm->sm_ops->smop_unload(sm);
387
388         sm->sm_loaded = B_FALSE;
389         sm->sm_ops = NULL;
390
391         space_map_vacate(sm, NULL, NULL);
392 }
393
394 uint64_t
395 space_map_alloc(space_map_t *sm, uint64_t size)
396 {
397         uint64_t start;
398
399         start = sm->sm_ops->smop_alloc(sm, size);
400         if (start != -1ULL)
401                 space_map_remove(sm, start, size);
402         return (start);
403 }
404
405 void
406 space_map_claim(space_map_t *sm, uint64_t start, uint64_t size)
407 {
408         sm->sm_ops->smop_claim(sm, start, size);
409         space_map_remove(sm, start, size);
410 }
411
412 void
413 space_map_free(space_map_t *sm, uint64_t start, uint64_t size)
414 {
415         space_map_add(sm, start, size);
416         sm->sm_ops->smop_free(sm, start, size);
417 }
418
419 /*
420  * Note: space_map_sync() will drop sm_lock across dmu_write() calls.
421  */
422 void
423 space_map_sync(space_map_t *sm, uint8_t maptype,
424         space_map_obj_t *smo, objset_t *os, dmu_tx_t *tx)
425 {
426         spa_t *spa = dmu_objset_spa(os);
427         void *cookie = NULL;
428         space_seg_t *ss;
429         uint64_t bufsize, start, size, run_len;
430         uint64_t *entry, *entry_map, *entry_map_end;
431
432         ASSERT(MUTEX_HELD(sm->sm_lock));
433
434         if (sm->sm_space == 0)
435                 return;
436
437         dprintf("object %4llu, txg %llu, pass %d, %c, count %lu, space %llx\n",
438             smo->smo_object, dmu_tx_get_txg(tx), spa_sync_pass(spa),
439             maptype == SM_ALLOC ? 'A' : 'F', avl_numnodes(&sm->sm_root),
440             sm->sm_space);
441
442         if (maptype == SM_ALLOC)
443                 smo->smo_alloc += sm->sm_space;
444         else
445                 smo->smo_alloc -= sm->sm_space;
446
447         bufsize = (8 + avl_numnodes(&sm->sm_root)) * sizeof (uint64_t);
448         bufsize = MIN(bufsize, 1ULL << SPACE_MAP_BLOCKSHIFT);
449         entry_map = zio_buf_alloc(bufsize);
450         entry_map_end = entry_map + (bufsize / sizeof (uint64_t));
451         entry = entry_map;
452
453         *entry++ = SM_DEBUG_ENCODE(1) |
454             SM_DEBUG_ACTION_ENCODE(maptype) |
455             SM_DEBUG_SYNCPASS_ENCODE(spa_sync_pass(spa)) |
456             SM_DEBUG_TXG_ENCODE(dmu_tx_get_txg(tx));
457
458         while ((ss = avl_destroy_nodes(&sm->sm_root, &cookie)) != NULL) {
459                 size = ss->ss_end - ss->ss_start;
460                 start = (ss->ss_start - sm->sm_start) >> sm->sm_shift;
461
462                 sm->sm_space -= size;
463                 size >>= sm->sm_shift;
464
465                 while (size) {
466                         run_len = MIN(size, SM_RUN_MAX);
467
468                         if (entry == entry_map_end) {
469                                 mutex_exit(sm->sm_lock);
470                                 dmu_write(os, smo->smo_object, smo->smo_objsize,
471                                     bufsize, entry_map, tx);
472                                 mutex_enter(sm->sm_lock);
473                                 smo->smo_objsize += bufsize;
474                                 entry = entry_map;
475                         }
476
477                         *entry++ = SM_OFFSET_ENCODE(start) |
478                             SM_TYPE_ENCODE(maptype) |
479                             SM_RUN_ENCODE(run_len);
480
481                         start += run_len;
482                         size -= run_len;
483                 }
484                 kmem_free(ss, sizeof (*ss));
485         }
486
487         if (entry != entry_map) {
488                 size = (entry - entry_map) * sizeof (uint64_t);
489                 mutex_exit(sm->sm_lock);
490                 dmu_write(os, smo->smo_object, smo->smo_objsize,
491                     size, entry_map, tx);
492                 mutex_enter(sm->sm_lock);
493                 smo->smo_objsize += size;
494         }
495
496         zio_buf_free(entry_map, bufsize);
497
498         VERIFY3U(sm->sm_space, ==, 0);
499 }
500
501 void
502 space_map_truncate(space_map_obj_t *smo, objset_t *os, dmu_tx_t *tx)
503 {
504         VERIFY(dmu_free_range(os, smo->smo_object, 0, -1ULL, tx) == 0);
505
506         smo->smo_objsize = 0;
507         smo->smo_alloc = 0;
508 }