89b5dce34c38c526aac92b7639f90f2876286583
[dragonfly.git] / sys / vfs / hammer / hammer_blockmap.c
1 /*
2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sys/vfs/hammer/hammer_blockmap.c,v 1.27 2008/07/31 22:30:33 dillon Exp $
35  */
36
37 /*
38  * HAMMER blockmap
39  */
40 #include "hammer.h"
41
42 static int hammer_res_rb_compare(hammer_reserve_t res1, hammer_reserve_t res2);
43 static void hammer_reserve_setdelay_offset(hammer_mount_t hmp,
44                                     hammer_off_t base_offset, int zone,
45                                     struct hammer_blockmap_layer2 *layer2);
46 static void hammer_reserve_setdelay(hammer_mount_t hmp, hammer_reserve_t resv);
47
48 /*
49  * Reserved big-blocks red-black tree support
50  */
51 RB_GENERATE2(hammer_res_rb_tree, hammer_reserve, rb_node,
52              hammer_res_rb_compare, hammer_off_t, zone_offset);
53
54 static int
55 hammer_res_rb_compare(hammer_reserve_t res1, hammer_reserve_t res2)
56 {
57         if (res1->zone_offset < res2->zone_offset)
58                 return(-1);
59         if (res1->zone_offset > res2->zone_offset)
60                 return(1);
61         return(0);
62 }
63
64 /*
65  * Allocate bytes from a zone
66  */
67 hammer_off_t
68 hammer_blockmap_alloc(hammer_transaction_t trans, int zone, int bytes,
69                       hammer_off_t hint, int *errorp)
70 {
71         hammer_mount_t hmp;
72         hammer_volume_t root_volume;
73         hammer_blockmap_t blockmap;
74         hammer_blockmap_t freemap;
75         hammer_reserve_t resv;
76         struct hammer_blockmap_layer1 *layer1;
77         struct hammer_blockmap_layer2 *layer2;
78         hammer_buffer_t buffer1 = NULL;
79         hammer_buffer_t buffer2 = NULL;
80         hammer_buffer_t buffer3 = NULL;
81         hammer_off_t tmp_offset;
82         hammer_off_t next_offset;
83         hammer_off_t result_offset;
84         hammer_off_t layer1_offset;
85         hammer_off_t layer2_offset;
86         hammer_off_t base_off;
87         int loops = 0;
88         int offset;             /* offset within big-block */
89         int use_hint;
90
91         hmp = trans->hmp;
92
93         /*
94          * Deal with alignment and buffer-boundary issues.
95          *
96          * Be careful, certain primary alignments are used below to allocate
97          * new blockmap blocks.
98          */
99         bytes = (bytes + 15) & ~15;
100         KKASSERT(bytes > 0 && bytes <= HAMMER_XBUFSIZE);
101         KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES);
102
103         /*
104          * Setup
105          */
106         root_volume = trans->rootvol;
107         *errorp = 0;
108         blockmap = &hmp->blockmap[zone];
109         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
110         KKASSERT(HAMMER_ZONE_DECODE(blockmap->next_offset) == zone);
111
112         /*
113          * Use the hint if we have one.
114          */
115         if (hint && HAMMER_ZONE_DECODE(hint) == zone) {
116                 next_offset = (hint + 15) & ~(hammer_off_t)15;
117                 use_hint = 1;
118         } else {
119                 next_offset = blockmap->next_offset;
120                 use_hint = 0;
121         }
122 again:
123
124         /*
125          * use_hint is turned off if we leave the hinted big-block.
126          */
127         if (use_hint && ((next_offset ^ hint) & ~HAMMER_HINTBLOCK_MASK64)) {
128                 next_offset = blockmap->next_offset;
129                 use_hint = 0;
130         }
131
132         /*
133          * Check for wrap
134          */
135         if (next_offset == HAMMER_ZONE_ENCODE(zone + 1, 0)) {
136                 if (++loops == 2) {
137                         result_offset = 0;
138                         *errorp = ENOSPC;
139                         goto failed;
140                 }
141                 next_offset = HAMMER_ZONE_ENCODE(zone, 0);
142         }
143
144         /*
145          * The allocation request may not cross a buffer boundary.  Special
146          * large allocations must not cross a large-block boundary.
147          */
148         tmp_offset = next_offset + bytes - 1;
149         if (bytes <= HAMMER_BUFSIZE) {
150                 if ((next_offset ^ tmp_offset) & ~HAMMER_BUFMASK64) {
151                         next_offset = tmp_offset & ~HAMMER_BUFMASK64;
152                         goto again;
153                 }
154         } else {
155                 if ((next_offset ^ tmp_offset) & ~HAMMER_LARGEBLOCK_MASK64) {
156                         next_offset = tmp_offset & ~HAMMER_LARGEBLOCK_MASK64;
157                         goto again;
158                 }
159         }
160         offset = (int)next_offset & HAMMER_LARGEBLOCK_MASK;
161
162         /*
163          * Dive layer 1.
164          */
165         layer1_offset = freemap->phys_offset +
166                         HAMMER_BLOCKMAP_LAYER1_OFFSET(next_offset);
167
168         layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer1);
169         if (*errorp) {
170                 result_offset = 0;
171                 goto failed;
172         }
173
174         /*
175          * Check CRC.
176          */
177         if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) {
178                 hammer_lock_ex(&hmp->blkmap_lock);
179                 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE))
180                         panic("CRC FAILED: LAYER1");
181                 hammer_unlock(&hmp->blkmap_lock);
182         }
183
184         /*
185          * If we are at a big-block boundary and layer1 indicates no 
186          * free big-blocks, then we cannot allocate a new bigblock in
187          * layer2, skip to the next layer1 entry.
188          */
189         if (offset == 0 && layer1->blocks_free == 0) {
190                 next_offset = (next_offset + HAMMER_BLOCKMAP_LAYER2) &
191                               ~HAMMER_BLOCKMAP_LAYER2_MASK;
192                 goto again;
193         }
194         KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
195
196         /*
197          * Skip this layer1 entry if it is pointing to a layer2 big-block
198          * on a volume that we are currently trying to remove from the
199          * file-system. This is used by the volume-del code together with
200          * the reblocker to free up a volume.
201          */
202         if ((int)HAMMER_VOL_DECODE(layer1->phys_offset) ==
203             hmp->volume_to_remove) {
204                 next_offset = (next_offset + HAMMER_BLOCKMAP_LAYER2) &
205                               ~HAMMER_BLOCKMAP_LAYER2_MASK;
206                 goto again;
207         }
208
209         /*
210          * Dive layer 2, each entry represents a large-block.
211          */
212         layer2_offset = layer1->phys_offset +
213                         HAMMER_BLOCKMAP_LAYER2_OFFSET(next_offset);
214         layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer2);
215         if (*errorp) {
216                 result_offset = 0;
217                 goto failed;
218         }
219
220         /*
221          * Check CRC.  This can race another thread holding the lock
222          * and in the middle of modifying layer2.
223          */
224         if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) {
225                 hammer_lock_ex(&hmp->blkmap_lock);
226                 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE))
227                         panic("CRC FAILED: LAYER2");
228                 hammer_unlock(&hmp->blkmap_lock);
229         }
230
231         /*
232          * Skip the layer if the zone is owned by someone other then us.
233          */
234         if (layer2->zone && layer2->zone != zone) {
235                 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset);
236                 goto again;
237         }
238         if (offset < layer2->append_off) {
239                 next_offset += layer2->append_off - offset;
240                 goto again;
241         }
242
243         /*
244          * If operating in the current non-hint blockmap block, do not
245          * allow it to get over-full.  Also drop any active hinting so
246          * blockmap->next_offset is updated at the end.
247          *
248          * We do this for B-Tree and meta-data allocations to provide
249          * localization for updates.
250          */
251         if ((zone == HAMMER_ZONE_BTREE_INDEX ||
252              zone == HAMMER_ZONE_META_INDEX) &&
253             offset >= HAMMER_LARGEBLOCK_OVERFILL &&
254             !((next_offset ^ blockmap->next_offset) & ~HAMMER_LARGEBLOCK_MASK64)
255         ) {
256                 if (offset >= HAMMER_LARGEBLOCK_OVERFILL) {
257                         next_offset += (HAMMER_LARGEBLOCK_SIZE - offset);
258                         use_hint = 0;
259                         goto again;
260                 }
261         }
262
263         /*
264          * We need the lock from this point on.  We have to re-check zone
265          * ownership after acquiring the lock and also check for reservations.
266          */
267         hammer_lock_ex(&hmp->blkmap_lock);
268
269         if (layer2->zone && layer2->zone != zone) {
270                 hammer_unlock(&hmp->blkmap_lock);
271                 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset);
272                 goto again;
273         }
274         if (offset < layer2->append_off) {
275                 hammer_unlock(&hmp->blkmap_lock);
276                 next_offset += layer2->append_off - offset;
277                 goto again;
278         }
279
280         /*
281          * The bigblock might be reserved by another zone.  If it is reserved
282          * by our zone we may have to move next_offset past the append_off.
283          */
284         base_off = (next_offset &
285                     (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) | 
286                     HAMMER_ZONE_RAW_BUFFER;
287         resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root, base_off);
288         if (resv) {
289                 if (resv->zone != zone) {
290                         hammer_unlock(&hmp->blkmap_lock);
291                         next_offset = (next_offset + HAMMER_LARGEBLOCK_SIZE) &
292                                       ~HAMMER_LARGEBLOCK_MASK64;
293                         goto again;
294                 }
295                 if (offset < resv->append_off) {
296                         hammer_unlock(&hmp->blkmap_lock);
297                         next_offset += resv->append_off - offset;
298                         goto again;
299                 }
300                 ++resv->refs;
301         }
302
303         /*
304          * Ok, we can allocate out of this layer2 big-block.  Assume ownership
305          * of the layer for real.  At this point we've validated any
306          * reservation that might exist and can just ignore resv.
307          */
308         if (layer2->zone == 0) {
309                 /*
310                  * Assign the bigblock to our zone
311                  */
312                 hammer_modify_buffer(trans, buffer1,
313                                      layer1, sizeof(*layer1));
314                 --layer1->blocks_free;
315                 layer1->layer1_crc = crc32(layer1,
316                                            HAMMER_LAYER1_CRCSIZE);
317                 hammer_modify_buffer_done(buffer1);
318                 hammer_modify_buffer(trans, buffer2,
319                                      layer2, sizeof(*layer2));
320                 layer2->zone = zone;
321                 KKASSERT(layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE);
322                 KKASSERT(layer2->append_off == 0);
323                 hammer_modify_volume_field(trans, trans->rootvol,
324                                            vol0_stat_freebigblocks);
325                 --root_volume->ondisk->vol0_stat_freebigblocks;
326                 hmp->copy_stat_freebigblocks =
327                         root_volume->ondisk->vol0_stat_freebigblocks;
328                 hammer_modify_volume_done(trans->rootvol);
329         } else {
330                 hammer_modify_buffer(trans, buffer2,
331                                      layer2, sizeof(*layer2));
332         }
333         KKASSERT(layer2->zone == zone);
334
335         layer2->bytes_free -= bytes;
336         KKASSERT(layer2->append_off <= offset);
337         layer2->append_off = offset + bytes;
338         layer2->entry_crc = crc32(layer2, HAMMER_LAYER2_CRCSIZE);
339         hammer_modify_buffer_done(buffer2);
340         KKASSERT(layer2->bytes_free >= 0);
341
342         /*
343          * We hold the blockmap lock and should be the only ones
344          * capable of modifying resv->append_off.  Track the allocation
345          * as appropriate.
346          */
347         KKASSERT(bytes != 0);
348         if (resv) {
349                 KKASSERT(resv->append_off <= offset);
350                 resv->append_off = offset + bytes;
351                 resv->flags &= ~HAMMER_RESF_LAYER2FREE;
352                 hammer_blockmap_reserve_complete(hmp, resv);
353         }
354
355         /*
356          * If we are allocating from the base of a new buffer we can avoid
357          * a disk read by calling hammer_bnew().
358          */
359         if ((next_offset & HAMMER_BUFMASK) == 0) {
360                 hammer_bnew_ext(trans->hmp, next_offset, bytes,
361                                 errorp, &buffer3);
362         }
363         result_offset = next_offset;
364
365         /*
366          * If we weren't supplied with a hint or could not use the hint
367          * then we wound up using blockmap->next_offset as the hint and
368          * need to save it.
369          */
370         if (use_hint == 0) {
371                 hammer_modify_volume(NULL, root_volume, NULL, 0);
372                 blockmap->next_offset = next_offset + bytes;
373                 hammer_modify_volume_done(root_volume);
374         }
375         hammer_unlock(&hmp->blkmap_lock);
376 failed:
377
378         /*
379          * Cleanup
380          */
381         if (buffer1)
382                 hammer_rel_buffer(buffer1, 0);
383         if (buffer2)
384                 hammer_rel_buffer(buffer2, 0);
385         if (buffer3)
386                 hammer_rel_buffer(buffer3, 0);
387
388         return(result_offset);
389 }
390
391 /*
392  * Frontend function - Reserve bytes in a zone.
393  *
394  * This code reserves bytes out of a blockmap without committing to any
395  * meta-data modifications, allowing the front-end to directly issue disk
396  * write I/O for large blocks of data
397  *
398  * The backend later finalizes the reservation with hammer_blockmap_finalize()
399  * upon committing the related record.
400  */
401 hammer_reserve_t
402 hammer_blockmap_reserve(hammer_mount_t hmp, int zone, int bytes,
403                         hammer_off_t *zone_offp, int *errorp)
404 {
405         hammer_volume_t root_volume;
406         hammer_blockmap_t blockmap;
407         hammer_blockmap_t freemap;
408         struct hammer_blockmap_layer1 *layer1;
409         struct hammer_blockmap_layer2 *layer2;
410         hammer_buffer_t buffer1 = NULL;
411         hammer_buffer_t buffer2 = NULL;
412         hammer_buffer_t buffer3 = NULL;
413         hammer_off_t tmp_offset;
414         hammer_off_t next_offset;
415         hammer_off_t layer1_offset;
416         hammer_off_t layer2_offset;
417         hammer_off_t base_off;
418         hammer_reserve_t resv;
419         hammer_reserve_t resx;
420         int loops = 0;
421         int offset;
422
423         /*
424          * Setup
425          */
426         KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES);
427         root_volume = hammer_get_root_volume(hmp, errorp);
428         if (*errorp)
429                 return(NULL);
430         blockmap = &hmp->blockmap[zone];
431         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
432         KKASSERT(HAMMER_ZONE_DECODE(blockmap->next_offset) == zone);
433
434         /*
435          * Deal with alignment and buffer-boundary issues.
436          *
437          * Be careful, certain primary alignments are used below to allocate
438          * new blockmap blocks.
439          */
440         bytes = (bytes + 15) & ~15;
441         KKASSERT(bytes > 0 && bytes <= HAMMER_XBUFSIZE);
442
443         next_offset = blockmap->next_offset;
444 again:
445         resv = NULL;
446         /*
447          * Check for wrap
448          */
449         if (next_offset == HAMMER_ZONE_ENCODE(zone + 1, 0)) {
450                 if (++loops == 2) {
451                         *errorp = ENOSPC;
452                         goto failed;
453                 }
454                 next_offset = HAMMER_ZONE_ENCODE(zone, 0);
455         }
456
457         /*
458          * The allocation request may not cross a buffer boundary.  Special
459          * large allocations must not cross a large-block boundary.
460          */
461         tmp_offset = next_offset + bytes - 1;
462         if (bytes <= HAMMER_BUFSIZE) {
463                 if ((next_offset ^ tmp_offset) & ~HAMMER_BUFMASK64) {
464                         next_offset = tmp_offset & ~HAMMER_BUFMASK64;
465                         goto again;
466                 }
467         } else {
468                 if ((next_offset ^ tmp_offset) & ~HAMMER_LARGEBLOCK_MASK64) {
469                         next_offset = tmp_offset & ~HAMMER_LARGEBLOCK_MASK64;
470                         goto again;
471                 }
472         }
473         offset = (int)next_offset & HAMMER_LARGEBLOCK_MASK;
474
475         /*
476          * Dive layer 1.
477          */
478         layer1_offset = freemap->phys_offset +
479                         HAMMER_BLOCKMAP_LAYER1_OFFSET(next_offset);
480         layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer1);
481         if (*errorp)
482                 goto failed;
483
484         /*
485          * Check CRC.
486          */
487         if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) {
488                 hammer_lock_ex(&hmp->blkmap_lock);
489                 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE))
490                         panic("CRC FAILED: LAYER1");
491                 hammer_unlock(&hmp->blkmap_lock);
492         }
493
494         /*
495          * If we are at a big-block boundary and layer1 indicates no 
496          * free big-blocks, then we cannot allocate a new bigblock in
497          * layer2, skip to the next layer1 entry.
498          */
499         if ((next_offset & HAMMER_LARGEBLOCK_MASK) == 0 &&
500             layer1->blocks_free == 0) {
501                 next_offset = (next_offset + HAMMER_BLOCKMAP_LAYER2) &
502                               ~HAMMER_BLOCKMAP_LAYER2_MASK;
503                 goto again;
504         }
505         KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
506
507         /*
508          * Dive layer 2, each entry represents a large-block.
509          */
510         layer2_offset = layer1->phys_offset +
511                         HAMMER_BLOCKMAP_LAYER2_OFFSET(next_offset);
512         layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer2);
513         if (*errorp)
514                 goto failed;
515
516         /*
517          * Check CRC if not allocating into uninitialized space (which we
518          * aren't when reserving space).
519          */
520         if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) {
521                 hammer_lock_ex(&hmp->blkmap_lock);
522                 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE))
523                         panic("CRC FAILED: LAYER2");
524                 hammer_unlock(&hmp->blkmap_lock);
525         }
526
527         /*
528          * Skip the layer if the zone is owned by someone other then us.
529          */
530         if (layer2->zone && layer2->zone != zone) {
531                 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset);
532                 goto again;
533         }
534         if (offset < layer2->append_off) {
535                 next_offset += layer2->append_off - offset;
536                 goto again;
537         }
538
539         /*
540          * We need the lock from this point on.  We have to re-check zone
541          * ownership after acquiring the lock and also check for reservations.
542          */
543         hammer_lock_ex(&hmp->blkmap_lock);
544
545         if (layer2->zone && layer2->zone != zone) {
546                 hammer_unlock(&hmp->blkmap_lock);
547                 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset);
548                 goto again;
549         }
550         if (offset < layer2->append_off) {
551                 hammer_unlock(&hmp->blkmap_lock);
552                 next_offset += layer2->append_off - offset;
553                 goto again;
554         }
555
556         /*
557          * The bigblock might be reserved by another zone.  If it is reserved
558          * by our zone we may have to move next_offset past the append_off.
559          */
560         base_off = (next_offset &
561                     (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) |
562                     HAMMER_ZONE_RAW_BUFFER;
563         resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root, base_off);
564         if (resv) {
565                 if (resv->zone != zone) {
566                         hammer_unlock(&hmp->blkmap_lock);
567                         next_offset = (next_offset + HAMMER_LARGEBLOCK_SIZE) &
568                                       ~HAMMER_LARGEBLOCK_MASK64;
569                         goto again;
570                 }
571                 if (offset < resv->append_off) {
572                         hammer_unlock(&hmp->blkmap_lock);
573                         next_offset += resv->append_off - offset;
574                         goto again;
575                 }
576                 ++resv->refs;
577                 resx = NULL;
578         } else {
579                 resx = kmalloc(sizeof(*resv), hmp->m_misc,
580                                M_WAITOK | M_ZERO | M_USE_RESERVE);
581                 resx->refs = 1;
582                 resx->zone = zone;
583                 resx->zone_offset = base_off;
584                 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE)
585                         resx->flags |= HAMMER_RESF_LAYER2FREE;
586                 resv = RB_INSERT(hammer_res_rb_tree, &hmp->rb_resv_root, resx);
587                 KKASSERT(resv == NULL);
588                 resv = resx;
589                 ++hammer_count_reservations;
590         }
591         resv->append_off = offset + bytes;
592
593         /*
594          * If we are not reserving a whole buffer but are at the start of
595          * a new block, call hammer_bnew() to avoid a disk read.
596          *
597          * If we are reserving a whole buffer (or more), the caller will
598          * probably use a direct read, so do nothing.
599          */
600         if (bytes < HAMMER_BUFSIZE && (next_offset & HAMMER_BUFMASK) == 0) {
601                 hammer_bnew(hmp, next_offset, errorp, &buffer3);
602         }
603
604         /*
605          * Adjust our iterator and alloc_offset.  The layer1 and layer2
606          * space beyond alloc_offset is uninitialized.  alloc_offset must
607          * be big-block aligned.
608          */
609         blockmap->next_offset = next_offset + bytes;
610         hammer_unlock(&hmp->blkmap_lock);
611
612 failed:
613         if (buffer1)
614                 hammer_rel_buffer(buffer1, 0);
615         if (buffer2)
616                 hammer_rel_buffer(buffer2, 0);
617         if (buffer3)
618                 hammer_rel_buffer(buffer3, 0);
619         hammer_rel_volume(root_volume, 0);
620         *zone_offp = next_offset;
621
622         return(resv);
623 }
624
625 /*
626  * Dereference a reservation structure.  Upon the final release the
627  * underlying big-block is checked and if it is entirely free we delete
628  * any related HAMMER buffers to avoid potential conflicts with future
629  * reuse of the big-block.
630  */
631 void
632 hammer_blockmap_reserve_complete(hammer_mount_t hmp, hammer_reserve_t resv)
633 {
634         hammer_off_t base_offset;
635         int error;
636
637         KKASSERT(resv->refs > 0);
638         KKASSERT((resv->zone_offset & HAMMER_OFF_ZONE_MASK) ==
639                  HAMMER_ZONE_RAW_BUFFER);
640
641         /*
642          * Setting append_off to the max prevents any new allocations
643          * from occuring while we are trying to dispose of the reservation,
644          * allowing us to safely delete any related HAMMER buffers.
645          *
646          * If we are unable to clean out all related HAMMER buffers we
647          * requeue the delay.
648          */
649         if (resv->refs == 1 && (resv->flags & HAMMER_RESF_LAYER2FREE)) {
650                 resv->append_off = HAMMER_LARGEBLOCK_SIZE;
651                 base_offset = resv->zone_offset & ~HAMMER_OFF_ZONE_MASK;
652                 base_offset = HAMMER_ZONE_ENCODE(resv->zone, base_offset);
653                 error = hammer_del_buffers(hmp, base_offset,
654                                            resv->zone_offset,
655                                            HAMMER_LARGEBLOCK_SIZE,
656                                            0);
657                 if (error)
658                         hammer_reserve_setdelay(hmp, resv);
659         }
660         if (--resv->refs == 0) {
661                 KKASSERT((resv->flags & HAMMER_RESF_ONDELAY) == 0);
662                 RB_REMOVE(hammer_res_rb_tree, &hmp->rb_resv_root, resv);
663                 kfree(resv, hmp->m_misc);
664                 --hammer_count_reservations;
665         }
666 }
667
668 /*
669  * Prevent a potentially free big-block from being reused until after
670  * the related flushes have completely cycled, otherwise crash recovery
671  * could resurrect a data block that was already reused and overwritten.
672  *
673  * The caller might reset the underlying layer2 entry's append_off to 0, so
674  * our covering append_off must be set to max to prevent any reallocation
675  * until after the flush delays complete, not to mention proper invalidation
676  * of any underlying cached blocks.
677  */
678 static void
679 hammer_reserve_setdelay_offset(hammer_mount_t hmp, hammer_off_t base_offset,
680                         int zone, struct hammer_blockmap_layer2 *layer2)
681 {
682         hammer_reserve_t resv;
683
684         /*
685          * Allocate the reservation if necessary.
686          *
687          * NOTE: need lock in future around resv lookup/allocation and
688          * the setdelay call, currently refs is not bumped until the call.
689          */
690 again:
691         resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root, base_offset);
692         if (resv == NULL) {
693                 resv = kmalloc(sizeof(*resv), hmp->m_misc,
694                                M_WAITOK | M_ZERO | M_USE_RESERVE);
695                 resv->zone = zone;
696                 resv->zone_offset = base_offset;
697                 resv->refs = 0;
698                 resv->append_off = HAMMER_LARGEBLOCK_SIZE;
699
700                 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE)
701                         resv->flags |= HAMMER_RESF_LAYER2FREE;
702                 if (RB_INSERT(hammer_res_rb_tree, &hmp->rb_resv_root, resv)) {
703                         kfree(resv, hmp->m_misc);
704                         goto again;
705                 }
706                 ++hammer_count_reservations;
707         } else {
708                 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE)
709                         resv->flags |= HAMMER_RESF_LAYER2FREE;
710         }
711         hammer_reserve_setdelay(hmp, resv);
712 }
713
714 /*
715  * Enter the reservation on the on-delay list, or move it if it
716  * is already on the list.
717  */
718 static void
719 hammer_reserve_setdelay(hammer_mount_t hmp, hammer_reserve_t resv)
720 {
721         if (resv->flags & HAMMER_RESF_ONDELAY) {
722                 TAILQ_REMOVE(&hmp->delay_list, resv, delay_entry);
723                 resv->flush_group = hmp->flusher.next + 1;
724                 TAILQ_INSERT_TAIL(&hmp->delay_list, resv, delay_entry);
725         } else {
726                 ++resv->refs;
727                 ++hmp->rsv_fromdelay;
728                 resv->flags |= HAMMER_RESF_ONDELAY;
729                 resv->flush_group = hmp->flusher.next + 1;
730                 TAILQ_INSERT_TAIL(&hmp->delay_list, resv, delay_entry);
731         }
732 }
733
734 void
735 hammer_reserve_clrdelay(hammer_mount_t hmp, hammer_reserve_t resv)
736 {
737         KKASSERT(resv->flags & HAMMER_RESF_ONDELAY);
738         resv->flags &= ~HAMMER_RESF_ONDELAY;
739         TAILQ_REMOVE(&hmp->delay_list, resv, delay_entry);
740         --hmp->rsv_fromdelay;
741         hammer_blockmap_reserve_complete(hmp, resv);
742 }
743
744 /*
745  * Backend function - free (offset, bytes) in a zone.
746  *
747  * XXX error return
748  */
749 void
750 hammer_blockmap_free(hammer_transaction_t trans,
751                      hammer_off_t zone_offset, int bytes)
752 {
753         hammer_mount_t hmp;
754         hammer_volume_t root_volume;
755         hammer_blockmap_t blockmap;
756         hammer_blockmap_t freemap;
757         struct hammer_blockmap_layer1 *layer1;
758         struct hammer_blockmap_layer2 *layer2;
759         hammer_buffer_t buffer1 = NULL;
760         hammer_buffer_t buffer2 = NULL;
761         hammer_off_t layer1_offset;
762         hammer_off_t layer2_offset;
763         hammer_off_t base_off;
764         int error;
765         int zone;
766
767         if (bytes == 0)
768                 return;
769         hmp = trans->hmp;
770
771         /*
772          * Alignment
773          */
774         bytes = (bytes + 15) & ~15;
775         KKASSERT(bytes <= HAMMER_XBUFSIZE);
776         KKASSERT(((zone_offset ^ (zone_offset + (bytes - 1))) & 
777                   ~HAMMER_LARGEBLOCK_MASK64) == 0);
778
779         /*
780          * Basic zone validation & locking
781          */
782         zone = HAMMER_ZONE_DECODE(zone_offset);
783         KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES);
784         root_volume = trans->rootvol;
785         error = 0;
786
787         blockmap = &hmp->blockmap[zone];
788         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
789
790         /*
791          * Dive layer 1.
792          */
793         layer1_offset = freemap->phys_offset +
794                         HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset);
795         layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1);
796         if (error)
797                 goto failed;
798         KKASSERT(layer1->phys_offset &&
799                  layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
800         if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) {
801                 hammer_lock_ex(&hmp->blkmap_lock);
802                 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE))
803                         panic("CRC FAILED: LAYER1");
804                 hammer_unlock(&hmp->blkmap_lock);
805         }
806
807         /*
808          * Dive layer 2, each entry represents a large-block.
809          */
810         layer2_offset = layer1->phys_offset +
811                         HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset);
812         layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2);
813         if (error)
814                 goto failed;
815         if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) {
816                 hammer_lock_ex(&hmp->blkmap_lock);
817                 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE))
818                         panic("CRC FAILED: LAYER2");
819                 hammer_unlock(&hmp->blkmap_lock);
820         }
821
822         hammer_lock_ex(&hmp->blkmap_lock);
823
824         hammer_modify_buffer(trans, buffer2, layer2, sizeof(*layer2));
825
826         /*
827          * Free space previously allocated via blockmap_alloc().
828          */
829         KKASSERT(layer2->zone == zone);
830         layer2->bytes_free += bytes;
831         KKASSERT(layer2->bytes_free <= HAMMER_LARGEBLOCK_SIZE);
832
833         /*
834          * If a big-block becomes entirely free we must create a covering
835          * reservation to prevent premature reuse.  Note, however, that
836          * the big-block and/or reservation may still have an append_off
837          * that allows further (non-reused) allocations.
838          *
839          * Once the reservation has been made we re-check layer2 and if
840          * the big-block is still entirely free we reset the layer2 entry.
841          * The reservation will prevent premature reuse.
842          *
843          * NOTE: hammer_buffer's are only invalidated when the reservation
844          * is completed, if the layer2 entry is still completely free at
845          * that time.  Any allocations from the reservation that may have
846          * occured in the mean time, or active references on the reservation
847          * from new pending allocations, will prevent the invalidation from
848          * occuring.
849          */
850         if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE) {
851                 base_off = (zone_offset & (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) | HAMMER_ZONE_RAW_BUFFER;
852
853                 hammer_reserve_setdelay_offset(hmp, base_off, zone, layer2);
854                 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE) {
855                         layer2->zone = 0;
856                         layer2->append_off = 0;
857                         hammer_modify_buffer(trans, buffer1,
858                                              layer1, sizeof(*layer1));
859                         ++layer1->blocks_free;
860                         layer1->layer1_crc = crc32(layer1,
861                                                    HAMMER_LAYER1_CRCSIZE);
862                         hammer_modify_buffer_done(buffer1);
863                         hammer_modify_volume_field(trans,
864                                         trans->rootvol,
865                                         vol0_stat_freebigblocks);
866                         ++root_volume->ondisk->vol0_stat_freebigblocks;
867                         hmp->copy_stat_freebigblocks =
868                            root_volume->ondisk->vol0_stat_freebigblocks;
869                         hammer_modify_volume_done(trans->rootvol);
870                 }
871         }
872         layer2->entry_crc = crc32(layer2, HAMMER_LAYER2_CRCSIZE);
873         hammer_modify_buffer_done(buffer2);
874         hammer_unlock(&hmp->blkmap_lock);
875
876 failed:
877         if (buffer1)
878                 hammer_rel_buffer(buffer1, 0);
879         if (buffer2)
880                 hammer_rel_buffer(buffer2, 0);
881 }
882
883 /*
884  * Backend function - finalize (offset, bytes) in a zone.
885  *
886  * Allocate space that was previously reserved by the frontend.
887  */
888 int
889 hammer_blockmap_finalize(hammer_transaction_t trans,
890                          hammer_reserve_t resv,
891                          hammer_off_t zone_offset, int bytes)
892 {
893         hammer_mount_t hmp;
894         hammer_volume_t root_volume;
895         hammer_blockmap_t blockmap;
896         hammer_blockmap_t freemap;
897         struct hammer_blockmap_layer1 *layer1;
898         struct hammer_blockmap_layer2 *layer2;
899         hammer_buffer_t buffer1 = NULL;
900         hammer_buffer_t buffer2 = NULL;
901         hammer_off_t layer1_offset;
902         hammer_off_t layer2_offset;
903         int error;
904         int zone;
905         int offset;
906
907         if (bytes == 0)
908                 return(0);
909         hmp = trans->hmp;
910
911         /*
912          * Alignment
913          */
914         bytes = (bytes + 15) & ~15;
915         KKASSERT(bytes <= HAMMER_XBUFSIZE);
916
917         /*
918          * Basic zone validation & locking
919          */
920         zone = HAMMER_ZONE_DECODE(zone_offset);
921         KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES);
922         root_volume = trans->rootvol;
923         error = 0;
924
925         blockmap = &hmp->blockmap[zone];
926         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
927
928         /*
929          * Dive layer 1.
930          */
931         layer1_offset = freemap->phys_offset +
932                         HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset);
933         layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1);
934         if (error)
935                 goto failed;
936         KKASSERT(layer1->phys_offset &&
937                  layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
938         if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) {
939                 hammer_lock_ex(&hmp->blkmap_lock);
940                 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE))
941                         panic("CRC FAILED: LAYER1");
942                 hammer_unlock(&hmp->blkmap_lock);
943         }
944
945         /*
946          * Dive layer 2, each entry represents a large-block.
947          */
948         layer2_offset = layer1->phys_offset +
949                         HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset);
950         layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2);
951         if (error)
952                 goto failed;
953         if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) {
954                 hammer_lock_ex(&hmp->blkmap_lock);
955                 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE))
956                         panic("CRC FAILED: LAYER2");
957                 hammer_unlock(&hmp->blkmap_lock);
958         }
959
960         hammer_lock_ex(&hmp->blkmap_lock);
961
962         hammer_modify_buffer(trans, buffer2, layer2, sizeof(*layer2));
963
964         /*
965          * Finalize some or all of the space covered by a current
966          * reservation.  An allocation in the same layer may have
967          * already assigned ownership.
968          */
969         if (layer2->zone == 0) {
970                 hammer_modify_buffer(trans, buffer1,
971                                      layer1, sizeof(*layer1));
972                 --layer1->blocks_free;
973                 layer1->layer1_crc = crc32(layer1,
974                                            HAMMER_LAYER1_CRCSIZE);
975                 hammer_modify_buffer_done(buffer1);
976                 layer2->zone = zone;
977                 KKASSERT(layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE);
978                 KKASSERT(layer2->append_off == 0);
979                 hammer_modify_volume_field(trans,
980                                 trans->rootvol,
981                                 vol0_stat_freebigblocks);
982                 --root_volume->ondisk->vol0_stat_freebigblocks;
983                 hmp->copy_stat_freebigblocks =
984                    root_volume->ondisk->vol0_stat_freebigblocks;
985                 hammer_modify_volume_done(trans->rootvol);
986         }
987         if (layer2->zone != zone)
988                 kprintf("layer2 zone mismatch %d %d\n", layer2->zone, zone);
989         KKASSERT(layer2->zone == zone);
990         KKASSERT(bytes != 0);
991         layer2->bytes_free -= bytes;
992         if (resv)
993                 resv->flags &= ~HAMMER_RESF_LAYER2FREE;
994
995         /*
996          * Finalizations can occur out of order, or combined with allocations.
997          * append_off must be set to the highest allocated offset.
998          */
999         offset = ((int)zone_offset & HAMMER_LARGEBLOCK_MASK) + bytes;
1000         if (layer2->append_off < offset)
1001                 layer2->append_off = offset;
1002
1003         layer2->entry_crc = crc32(layer2, HAMMER_LAYER2_CRCSIZE);
1004         hammer_modify_buffer_done(buffer2);
1005         hammer_unlock(&hmp->blkmap_lock);
1006
1007 failed:
1008         if (buffer1)
1009                 hammer_rel_buffer(buffer1, 0);
1010         if (buffer2)
1011                 hammer_rel_buffer(buffer2, 0);
1012         return(error);
1013 }
1014
1015 /*
1016  * Return the number of free bytes in the big-block containing the
1017  * specified blockmap offset.
1018  */
1019 int
1020 hammer_blockmap_getfree(hammer_mount_t hmp, hammer_off_t zone_offset,
1021                         int *curp, int *errorp)
1022 {
1023         hammer_volume_t root_volume;
1024         hammer_blockmap_t blockmap;
1025         hammer_blockmap_t freemap;
1026         struct hammer_blockmap_layer1 *layer1;
1027         struct hammer_blockmap_layer2 *layer2;
1028         hammer_buffer_t buffer = NULL;
1029         hammer_off_t layer1_offset;
1030         hammer_off_t layer2_offset;
1031         int bytes;
1032         int zone;
1033
1034         zone = HAMMER_ZONE_DECODE(zone_offset);
1035         KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES);
1036         root_volume = hammer_get_root_volume(hmp, errorp);
1037         if (*errorp) {
1038                 *curp = 0;
1039                 return(0);
1040         }
1041         blockmap = &hmp->blockmap[zone];
1042         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
1043
1044         /*
1045          * Dive layer 1.
1046          */
1047         layer1_offset = freemap->phys_offset +
1048                         HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset);
1049         layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer);
1050         if (*errorp) {
1051                 bytes = 0;
1052                 goto failed;
1053         }
1054         KKASSERT(layer1->phys_offset);
1055         if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) {
1056                 hammer_lock_ex(&hmp->blkmap_lock);
1057                 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE))
1058                         panic("CRC FAILED: LAYER1");
1059                 hammer_unlock(&hmp->blkmap_lock);
1060         }
1061
1062         /*
1063          * Dive layer 2, each entry represents a large-block.
1064          *
1065          * (reuse buffer, layer1 pointer becomes invalid)
1066          */
1067         layer2_offset = layer1->phys_offset +
1068                         HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset);
1069         layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer);
1070         if (*errorp) {
1071                 bytes = 0;
1072                 goto failed;
1073         }
1074         if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) {
1075                 hammer_lock_ex(&hmp->blkmap_lock);
1076                 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE))
1077                         panic("CRC FAILED: LAYER2");
1078                 hammer_unlock(&hmp->blkmap_lock);
1079         }
1080         KKASSERT(layer2->zone == zone);
1081
1082         bytes = layer2->bytes_free;
1083
1084         if ((blockmap->next_offset ^ zone_offset) & ~HAMMER_LARGEBLOCK_MASK64)
1085                 *curp = 0;
1086         else
1087                 *curp = 1;
1088 failed:
1089         if (buffer)
1090                 hammer_rel_buffer(buffer, 0);
1091         hammer_rel_volume(root_volume, 0);
1092         if (hammer_debug_general & 0x0800) {
1093                 kprintf("hammer_blockmap_getfree: %016llx -> %d\n",
1094                         (long long)zone_offset, bytes);
1095         }
1096         return(bytes);
1097 }
1098
1099
1100 /*
1101  * Lookup a blockmap offset.
1102  */
1103 hammer_off_t
1104 hammer_blockmap_lookup(hammer_mount_t hmp, hammer_off_t zone_offset,
1105                        int *errorp)
1106 {
1107         hammer_volume_t root_volume;
1108         hammer_blockmap_t freemap;
1109         struct hammer_blockmap_layer1 *layer1;
1110         struct hammer_blockmap_layer2 *layer2;
1111         hammer_buffer_t buffer = NULL;
1112         hammer_off_t layer1_offset;
1113         hammer_off_t layer2_offset;
1114         hammer_off_t result_offset;
1115         hammer_off_t base_off;
1116         hammer_reserve_t resv;
1117         int zone;
1118
1119         /*
1120          * Calculate the zone-2 offset.
1121          */
1122         zone = HAMMER_ZONE_DECODE(zone_offset);
1123         KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES);
1124
1125         result_offset = (zone_offset & ~HAMMER_OFF_ZONE_MASK) |
1126                         HAMMER_ZONE_RAW_BUFFER;
1127
1128         /*
1129          * We can actually stop here, normal blockmaps are now direct-mapped
1130          * onto the freemap and so represent zone-2 addresses.
1131          */
1132         if (hammer_verify_zone == 0) {
1133                 *errorp = 0;
1134                 return(result_offset);
1135         }
1136
1137         /*
1138          * Validate the allocation zone
1139          */
1140         root_volume = hammer_get_root_volume(hmp, errorp);
1141         if (*errorp)
1142                 return(0);
1143         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
1144         KKASSERT(freemap->phys_offset != 0);
1145
1146         /*
1147          * Dive layer 1.
1148          */
1149         layer1_offset = freemap->phys_offset +
1150                         HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset);
1151         layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer);
1152         if (*errorp)
1153                 goto failed;
1154         KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
1155         if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) {
1156                 hammer_lock_ex(&hmp->blkmap_lock);
1157                 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE))
1158                         panic("CRC FAILED: LAYER1");
1159                 hammer_unlock(&hmp->blkmap_lock);
1160         }
1161
1162         /*
1163          * Dive layer 2, each entry represents a large-block.
1164          */
1165         layer2_offset = layer1->phys_offset +
1166                         HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset);
1167         layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer);
1168
1169         if (*errorp)
1170                 goto failed;
1171         if (layer2->zone == 0) {
1172                 base_off = (zone_offset & (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) | HAMMER_ZONE_RAW_BUFFER;
1173                 resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root,
1174                                  base_off);
1175                 KKASSERT(resv && resv->zone == zone);
1176
1177         } else if (layer2->zone != zone) {
1178                 panic("hammer_blockmap_lookup: bad zone %d/%d\n",
1179                         layer2->zone, zone);
1180         }
1181         if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) {
1182                 hammer_lock_ex(&hmp->blkmap_lock);
1183                 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE))
1184                         panic("CRC FAILED: LAYER2");
1185                 hammer_unlock(&hmp->blkmap_lock);
1186         }
1187
1188 failed:
1189         if (buffer)
1190                 hammer_rel_buffer(buffer, 0);
1191         hammer_rel_volume(root_volume, 0);
1192         if (hammer_debug_general & 0x0800) {
1193                 kprintf("hammer_blockmap_lookup: %016llx -> %016llx\n",
1194                         (long long)zone_offset, (long long)result_offset);
1195         }
1196         return(result_offset);
1197 }
1198
1199
1200 /*
1201  * Check space availability
1202  */
1203 int
1204 _hammer_checkspace(hammer_mount_t hmp, int slop, int64_t *resp)
1205 {
1206         const int in_size = sizeof(struct hammer_inode_data) +
1207                             sizeof(union hammer_btree_elm);
1208         const int rec_size = (sizeof(union hammer_btree_elm) * 2);
1209         int64_t usedbytes;
1210
1211         usedbytes = hmp->rsv_inodes * in_size +
1212                     hmp->rsv_recs * rec_size +
1213                     hmp->rsv_databytes +
1214                     ((int64_t)hmp->rsv_fromdelay << HAMMER_LARGEBLOCK_BITS) +
1215                     ((int64_t)hidirtybufspace << 2) +
1216                     (slop << HAMMER_LARGEBLOCK_BITS);
1217
1218         hammer_count_extra_space_used = usedbytes;      /* debugging */
1219         if (resp)
1220                 *resp = usedbytes;
1221
1222         if (hmp->copy_stat_freebigblocks >=
1223             (usedbytes >> HAMMER_LARGEBLOCK_BITS)) {
1224                 return(0);
1225         }
1226         return (ENOSPC);
1227 }
1228