Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_log_format.h"
11#include "xfs_trans_resv.h"
12#include "xfs_bit.h"
13#include "xfs_mount.h"
14#include "xfs_inode.h"
15#include "xfs_bmap.h"
16#include "xfs_trans.h"
17#include "xfs_rtalloc.h"
18#include "xfs_error.h"
19
20/*
21 * Realtime allocator bitmap functions shared with userspace.
22 */
23
24/*
25 * Real time buffers need verifiers to avoid runtime warnings during IO.
26 * We don't have anything to verify, however, so these are just dummy
27 * operations.
28 */
29static void
30xfs_rtbuf_verify_read(
31 struct xfs_buf *bp)
32{
33 return;
34}
35
36static void
37xfs_rtbuf_verify_write(
38 struct xfs_buf *bp)
39{
40 return;
41}
42
43const struct xfs_buf_ops xfs_rtbuf_ops = {
44 .name = "rtbuf",
45 .verify_read = xfs_rtbuf_verify_read,
46 .verify_write = xfs_rtbuf_verify_write,
47};
48
49/*
50 * Get a buffer for the bitmap or summary file block specified.
51 * The buffer is returned read and locked.
52 */
53int
54xfs_rtbuf_get(
55 xfs_mount_t *mp, /* file system mount structure */
56 xfs_trans_t *tp, /* transaction pointer */
57 xfs_rtblock_t block, /* block number in bitmap or summary */
58 int issum, /* is summary not bitmap */
59 struct xfs_buf **bpp) /* output: buffer for the block */
60{
61 struct xfs_buf *bp; /* block buffer, result */
62 xfs_inode_t *ip; /* bitmap or summary inode */
63 xfs_bmbt_irec_t map;
64 int nmap = 1;
65 int error; /* error value */
66
67 ip = issum ? mp->m_rsumip : mp->m_rbmip;
68
69 error = xfs_bmapi_read(ip, block, 1, &map, &nmap, 0);
70 if (error)
71 return error;
72
73 if (XFS_IS_CORRUPT(mp, nmap == 0 || !xfs_bmap_is_written_extent(&map)))
74 return -EFSCORRUPTED;
75
76 ASSERT(map.br_startblock != NULLFSBLOCK);
77 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
78 XFS_FSB_TO_DADDR(mp, map.br_startblock),
79 mp->m_bsize, 0, &bp, &xfs_rtbuf_ops);
80 if (error)
81 return error;
82
83 xfs_trans_buf_set_type(tp, bp, issum ? XFS_BLFT_RTSUMMARY_BUF
84 : XFS_BLFT_RTBITMAP_BUF);
85 *bpp = bp;
86 return 0;
87}
88
89/*
90 * Searching backward from start to limit, find the first block whose
91 * allocated/free state is different from start's.
92 */
93int
94xfs_rtfind_back(
95 xfs_mount_t *mp, /* file system mount point */
96 xfs_trans_t *tp, /* transaction pointer */
97 xfs_rtblock_t start, /* starting block to look at */
98 xfs_rtblock_t limit, /* last block to look at */
99 xfs_rtblock_t *rtblock) /* out: start block found */
100{
101 xfs_rtword_t *b; /* current word in buffer */
102 int bit; /* bit number in the word */
103 xfs_rtblock_t block; /* bitmap block number */
104 struct xfs_buf *bp; /* buf for the block */
105 xfs_rtword_t *bufp; /* starting word in buffer */
106 int error; /* error value */
107 xfs_rtblock_t firstbit; /* first useful bit in the word */
108 xfs_rtblock_t i; /* current bit number rel. to start */
109 xfs_rtblock_t len; /* length of inspected area */
110 xfs_rtword_t mask; /* mask of relevant bits for value */
111 xfs_rtword_t want; /* mask for "good" values */
112 xfs_rtword_t wdiff; /* difference from wanted value */
113 int word; /* word number in the buffer */
114
115 /*
116 * Compute and read in starting bitmap block for starting block.
117 */
118 block = XFS_BITTOBLOCK(mp, start);
119 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
120 if (error) {
121 return error;
122 }
123 bufp = bp->b_addr;
124 /*
125 * Get the first word's index & point to it.
126 */
127 word = XFS_BITTOWORD(mp, start);
128 b = &bufp[word];
129 bit = (int)(start & (XFS_NBWORD - 1));
130 len = start - limit + 1;
131 /*
132 * Compute match value, based on the bit at start: if 1 (free)
133 * then all-ones, else all-zeroes.
134 */
135 want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
136 /*
137 * If the starting position is not word-aligned, deal with the
138 * partial word.
139 */
140 if (bit < XFS_NBWORD - 1) {
141 /*
142 * Calculate first (leftmost) bit number to look at,
143 * and mask for all the relevant bits in this word.
144 */
145 firstbit = XFS_RTMAX((xfs_srtblock_t)(bit - len + 1), 0);
146 mask = (((xfs_rtword_t)1 << (bit - firstbit + 1)) - 1) <<
147 firstbit;
148 /*
149 * Calculate the difference between the value there
150 * and what we're looking for.
151 */
152 if ((wdiff = (*b ^ want) & mask)) {
153 /*
154 * Different. Mark where we are and return.
155 */
156 xfs_trans_brelse(tp, bp);
157 i = bit - XFS_RTHIBIT(wdiff);
158 *rtblock = start - i + 1;
159 return 0;
160 }
161 i = bit - firstbit + 1;
162 /*
163 * Go on to previous block if that's where the previous word is
164 * and we need the previous word.
165 */
166 if (--word == -1 && i < len) {
167 /*
168 * If done with this block, get the previous one.
169 */
170 xfs_trans_brelse(tp, bp);
171 error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
172 if (error) {
173 return error;
174 }
175 bufp = bp->b_addr;
176 word = XFS_BLOCKWMASK(mp);
177 b = &bufp[word];
178 } else {
179 /*
180 * Go on to the previous word in the buffer.
181 */
182 b--;
183 }
184 } else {
185 /*
186 * Starting on a word boundary, no partial word.
187 */
188 i = 0;
189 }
190 /*
191 * Loop over whole words in buffers. When we use up one buffer
192 * we move on to the previous one.
193 */
194 while (len - i >= XFS_NBWORD) {
195 /*
196 * Compute difference between actual and desired value.
197 */
198 if ((wdiff = *b ^ want)) {
199 /*
200 * Different, mark where we are and return.
201 */
202 xfs_trans_brelse(tp, bp);
203 i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
204 *rtblock = start - i + 1;
205 return 0;
206 }
207 i += XFS_NBWORD;
208 /*
209 * Go on to previous block if that's where the previous word is
210 * and we need the previous word.
211 */
212 if (--word == -1 && i < len) {
213 /*
214 * If done with this block, get the previous one.
215 */
216 xfs_trans_brelse(tp, bp);
217 error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
218 if (error) {
219 return error;
220 }
221 bufp = bp->b_addr;
222 word = XFS_BLOCKWMASK(mp);
223 b = &bufp[word];
224 } else {
225 /*
226 * Go on to the previous word in the buffer.
227 */
228 b--;
229 }
230 }
231 /*
232 * If not ending on a word boundary, deal with the last
233 * (partial) word.
234 */
235 if (len - i) {
236 /*
237 * Calculate first (leftmost) bit number to look at,
238 * and mask for all the relevant bits in this word.
239 */
240 firstbit = XFS_NBWORD - (len - i);
241 mask = (((xfs_rtword_t)1 << (len - i)) - 1) << firstbit;
242 /*
243 * Compute difference between actual and desired value.
244 */
245 if ((wdiff = (*b ^ want) & mask)) {
246 /*
247 * Different, mark where we are and return.
248 */
249 xfs_trans_brelse(tp, bp);
250 i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
251 *rtblock = start - i + 1;
252 return 0;
253 } else
254 i = len;
255 }
256 /*
257 * No match, return that we scanned the whole area.
258 */
259 xfs_trans_brelse(tp, bp);
260 *rtblock = start - i + 1;
261 return 0;
262}
263
264/*
265 * Searching forward from start to limit, find the first block whose
266 * allocated/free state is different from start's.
267 */
268int
269xfs_rtfind_forw(
270 xfs_mount_t *mp, /* file system mount point */
271 xfs_trans_t *tp, /* transaction pointer */
272 xfs_rtblock_t start, /* starting block to look at */
273 xfs_rtblock_t limit, /* last block to look at */
274 xfs_rtblock_t *rtblock) /* out: start block found */
275{
276 xfs_rtword_t *b; /* current word in buffer */
277 int bit; /* bit number in the word */
278 xfs_rtblock_t block; /* bitmap block number */
279 struct xfs_buf *bp; /* buf for the block */
280 xfs_rtword_t *bufp; /* starting word in buffer */
281 int error; /* error value */
282 xfs_rtblock_t i; /* current bit number rel. to start */
283 xfs_rtblock_t lastbit; /* last useful bit in the word */
284 xfs_rtblock_t len; /* length of inspected area */
285 xfs_rtword_t mask; /* mask of relevant bits for value */
286 xfs_rtword_t want; /* mask for "good" values */
287 xfs_rtword_t wdiff; /* difference from wanted value */
288 int word; /* word number in the buffer */
289
290 /*
291 * Compute and read in starting bitmap block for starting block.
292 */
293 block = XFS_BITTOBLOCK(mp, start);
294 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
295 if (error) {
296 return error;
297 }
298 bufp = bp->b_addr;
299 /*
300 * Get the first word's index & point to it.
301 */
302 word = XFS_BITTOWORD(mp, start);
303 b = &bufp[word];
304 bit = (int)(start & (XFS_NBWORD - 1));
305 len = limit - start + 1;
306 /*
307 * Compute match value, based on the bit at start: if 1 (free)
308 * then all-ones, else all-zeroes.
309 */
310 want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
311 /*
312 * If the starting position is not word-aligned, deal with the
313 * partial word.
314 */
315 if (bit) {
316 /*
317 * Calculate last (rightmost) bit number to look at,
318 * and mask for all the relevant bits in this word.
319 */
320 lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
321 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
322 /*
323 * Calculate the difference between the value there
324 * and what we're looking for.
325 */
326 if ((wdiff = (*b ^ want) & mask)) {
327 /*
328 * Different. Mark where we are and return.
329 */
330 xfs_trans_brelse(tp, bp);
331 i = XFS_RTLOBIT(wdiff) - bit;
332 *rtblock = start + i - 1;
333 return 0;
334 }
335 i = lastbit - bit;
336 /*
337 * Go on to next block if that's where the next word is
338 * and we need the next word.
339 */
340 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
341 /*
342 * If done with this block, get the previous one.
343 */
344 xfs_trans_brelse(tp, bp);
345 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
346 if (error) {
347 return error;
348 }
349 b = bufp = bp->b_addr;
350 word = 0;
351 } else {
352 /*
353 * Go on to the previous word in the buffer.
354 */
355 b++;
356 }
357 } else {
358 /*
359 * Starting on a word boundary, no partial word.
360 */
361 i = 0;
362 }
363 /*
364 * Loop over whole words in buffers. When we use up one buffer
365 * we move on to the next one.
366 */
367 while (len - i >= XFS_NBWORD) {
368 /*
369 * Compute difference between actual and desired value.
370 */
371 if ((wdiff = *b ^ want)) {
372 /*
373 * Different, mark where we are and return.
374 */
375 xfs_trans_brelse(tp, bp);
376 i += XFS_RTLOBIT(wdiff);
377 *rtblock = start + i - 1;
378 return 0;
379 }
380 i += XFS_NBWORD;
381 /*
382 * Go on to next block if that's where the next word is
383 * and we need the next word.
384 */
385 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
386 /*
387 * If done with this block, get the next one.
388 */
389 xfs_trans_brelse(tp, bp);
390 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
391 if (error) {
392 return error;
393 }
394 b = bufp = bp->b_addr;
395 word = 0;
396 } else {
397 /*
398 * Go on to the next word in the buffer.
399 */
400 b++;
401 }
402 }
403 /*
404 * If not ending on a word boundary, deal with the last
405 * (partial) word.
406 */
407 if ((lastbit = len - i)) {
408 /*
409 * Calculate mask for all the relevant bits in this word.
410 */
411 mask = ((xfs_rtword_t)1 << lastbit) - 1;
412 /*
413 * Compute difference between actual and desired value.
414 */
415 if ((wdiff = (*b ^ want) & mask)) {
416 /*
417 * Different, mark where we are and return.
418 */
419 xfs_trans_brelse(tp, bp);
420 i += XFS_RTLOBIT(wdiff);
421 *rtblock = start + i - 1;
422 return 0;
423 } else
424 i = len;
425 }
426 /*
427 * No match, return that we scanned the whole area.
428 */
429 xfs_trans_brelse(tp, bp);
430 *rtblock = start + i - 1;
431 return 0;
432}
433
434/*
435 * Read and/or modify the summary information for a given extent size,
436 * bitmap block combination.
437 * Keeps track of a current summary block, so we don't keep reading
438 * it from the buffer cache.
439 *
440 * Summary information is returned in *sum if specified.
441 * If no delta is specified, returns summary only.
442 */
443int
444xfs_rtmodify_summary_int(
445 xfs_mount_t *mp, /* file system mount structure */
446 xfs_trans_t *tp, /* transaction pointer */
447 int log, /* log2 of extent size */
448 xfs_rtblock_t bbno, /* bitmap block number */
449 int delta, /* change to make to summary info */
450 struct xfs_buf **rbpp, /* in/out: summary block buffer */
451 xfs_fsblock_t *rsb, /* in/out: summary block number */
452 xfs_suminfo_t *sum) /* out: summary info for this block */
453{
454 struct xfs_buf *bp; /* buffer for the summary block */
455 int error; /* error value */
456 xfs_fsblock_t sb; /* summary fsblock */
457 int so; /* index into the summary file */
458 xfs_suminfo_t *sp; /* pointer to returned data */
459
460 /*
461 * Compute entry number in the summary file.
462 */
463 so = XFS_SUMOFFS(mp, log, bbno);
464 /*
465 * Compute the block number in the summary file.
466 */
467 sb = XFS_SUMOFFSTOBLOCK(mp, so);
468 /*
469 * If we have an old buffer, and the block number matches, use that.
470 */
471 if (*rbpp && *rsb == sb)
472 bp = *rbpp;
473 /*
474 * Otherwise we have to get the buffer.
475 */
476 else {
477 /*
478 * If there was an old one, get rid of it first.
479 */
480 if (*rbpp)
481 xfs_trans_brelse(tp, *rbpp);
482 error = xfs_rtbuf_get(mp, tp, sb, 1, &bp);
483 if (error) {
484 return error;
485 }
486 /*
487 * Remember this buffer and block for the next call.
488 */
489 *rbpp = bp;
490 *rsb = sb;
491 }
492 /*
493 * Point to the summary information, modify/log it, and/or copy it out.
494 */
495 sp = XFS_SUMPTR(mp, bp, so);
496 if (delta) {
497 uint first = (uint)((char *)sp - (char *)bp->b_addr);
498
499 *sp += delta;
500 if (mp->m_rsum_cache) {
501 if (*sp == 0 && log == mp->m_rsum_cache[bbno])
502 mp->m_rsum_cache[bbno]++;
503 if (*sp != 0 && log < mp->m_rsum_cache[bbno])
504 mp->m_rsum_cache[bbno] = log;
505 }
506 xfs_trans_log_buf(tp, bp, first, first + sizeof(*sp) - 1);
507 }
508 if (sum)
509 *sum = *sp;
510 return 0;
511}
512
513int
514xfs_rtmodify_summary(
515 xfs_mount_t *mp, /* file system mount structure */
516 xfs_trans_t *tp, /* transaction pointer */
517 int log, /* log2 of extent size */
518 xfs_rtblock_t bbno, /* bitmap block number */
519 int delta, /* change to make to summary info */
520 struct xfs_buf **rbpp, /* in/out: summary block buffer */
521 xfs_fsblock_t *rsb) /* in/out: summary block number */
522{
523 return xfs_rtmodify_summary_int(mp, tp, log, bbno,
524 delta, rbpp, rsb, NULL);
525}
526
527/*
528 * Set the given range of bitmap bits to the given value.
529 * Do whatever I/O and logging is required.
530 */
531int
532xfs_rtmodify_range(
533 xfs_mount_t *mp, /* file system mount point */
534 xfs_trans_t *tp, /* transaction pointer */
535 xfs_rtblock_t start, /* starting block to modify */
536 xfs_extlen_t len, /* length of extent to modify */
537 int val) /* 1 for free, 0 for allocated */
538{
539 xfs_rtword_t *b; /* current word in buffer */
540 int bit; /* bit number in the word */
541 xfs_rtblock_t block; /* bitmap block number */
542 struct xfs_buf *bp; /* buf for the block */
543 xfs_rtword_t *bufp; /* starting word in buffer */
544 int error; /* error value */
545 xfs_rtword_t *first; /* first used word in the buffer */
546 int i; /* current bit number rel. to start */
547 int lastbit; /* last useful bit in word */
548 xfs_rtword_t mask; /* mask o frelevant bits for value */
549 int word; /* word number in the buffer */
550
551 /*
552 * Compute starting bitmap block number.
553 */
554 block = XFS_BITTOBLOCK(mp, start);
555 /*
556 * Read the bitmap block, and point to its data.
557 */
558 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
559 if (error) {
560 return error;
561 }
562 bufp = bp->b_addr;
563 /*
564 * Compute the starting word's address, and starting bit.
565 */
566 word = XFS_BITTOWORD(mp, start);
567 first = b = &bufp[word];
568 bit = (int)(start & (XFS_NBWORD - 1));
569 /*
570 * 0 (allocated) => all zeroes; 1 (free) => all ones.
571 */
572 val = -val;
573 /*
574 * If not starting on a word boundary, deal with the first
575 * (partial) word.
576 */
577 if (bit) {
578 /*
579 * Compute first bit not changed and mask of relevant bits.
580 */
581 lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
582 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
583 /*
584 * Set/clear the active bits.
585 */
586 if (val)
587 *b |= mask;
588 else
589 *b &= ~mask;
590 i = lastbit - bit;
591 /*
592 * Go on to the next block if that's where the next word is
593 * and we need the next word.
594 */
595 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
596 /*
597 * Log the changed part of this block.
598 * Get the next one.
599 */
600 xfs_trans_log_buf(tp, bp,
601 (uint)((char *)first - (char *)bufp),
602 (uint)((char *)b - (char *)bufp));
603 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
604 if (error) {
605 return error;
606 }
607 first = b = bufp = bp->b_addr;
608 word = 0;
609 } else {
610 /*
611 * Go on to the next word in the buffer
612 */
613 b++;
614 }
615 } else {
616 /*
617 * Starting on a word boundary, no partial word.
618 */
619 i = 0;
620 }
621 /*
622 * Loop over whole words in buffers. When we use up one buffer
623 * we move on to the next one.
624 */
625 while (len - i >= XFS_NBWORD) {
626 /*
627 * Set the word value correctly.
628 */
629 *b = val;
630 i += XFS_NBWORD;
631 /*
632 * Go on to the next block if that's where the next word is
633 * and we need the next word.
634 */
635 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
636 /*
637 * Log the changed part of this block.
638 * Get the next one.
639 */
640 xfs_trans_log_buf(tp, bp,
641 (uint)((char *)first - (char *)bufp),
642 (uint)((char *)b - (char *)bufp));
643 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
644 if (error) {
645 return error;
646 }
647 first = b = bufp = bp->b_addr;
648 word = 0;
649 } else {
650 /*
651 * Go on to the next word in the buffer
652 */
653 b++;
654 }
655 }
656 /*
657 * If not ending on a word boundary, deal with the last
658 * (partial) word.
659 */
660 if ((lastbit = len - i)) {
661 /*
662 * Compute a mask of relevant bits.
663 */
664 mask = ((xfs_rtword_t)1 << lastbit) - 1;
665 /*
666 * Set/clear the active bits.
667 */
668 if (val)
669 *b |= mask;
670 else
671 *b &= ~mask;
672 b++;
673 }
674 /*
675 * Log any remaining changed bytes.
676 */
677 if (b > first)
678 xfs_trans_log_buf(tp, bp, (uint)((char *)first - (char *)bufp),
679 (uint)((char *)b - (char *)bufp - 1));
680 return 0;
681}
682
683/*
684 * Mark an extent specified by start and len freed.
685 * Updates all the summary information as well as the bitmap.
686 */
687int
688xfs_rtfree_range(
689 xfs_mount_t *mp, /* file system mount point */
690 xfs_trans_t *tp, /* transaction pointer */
691 xfs_rtblock_t start, /* starting block to free */
692 xfs_extlen_t len, /* length to free */
693 struct xfs_buf **rbpp, /* in/out: summary block buffer */
694 xfs_fsblock_t *rsb) /* in/out: summary block number */
695{
696 xfs_rtblock_t end; /* end of the freed extent */
697 int error; /* error value */
698 xfs_rtblock_t postblock; /* first block freed > end */
699 xfs_rtblock_t preblock; /* first block freed < start */
700
701 end = start + len - 1;
702 /*
703 * Modify the bitmap to mark this extent freed.
704 */
705 error = xfs_rtmodify_range(mp, tp, start, len, 1);
706 if (error) {
707 return error;
708 }
709 /*
710 * Assume we're freeing out of the middle of an allocated extent.
711 * We need to find the beginning and end of the extent so we can
712 * properly update the summary.
713 */
714 error = xfs_rtfind_back(mp, tp, start, 0, &preblock);
715 if (error) {
716 return error;
717 }
718 /*
719 * Find the next allocated block (end of allocated extent).
720 */
721 error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1,
722 &postblock);
723 if (error)
724 return error;
725 /*
726 * If there are blocks not being freed at the front of the
727 * old extent, add summary data for them to be allocated.
728 */
729 if (preblock < start) {
730 error = xfs_rtmodify_summary(mp, tp,
731 XFS_RTBLOCKLOG(start - preblock),
732 XFS_BITTOBLOCK(mp, preblock), -1, rbpp, rsb);
733 if (error) {
734 return error;
735 }
736 }
737 /*
738 * If there are blocks not being freed at the end of the
739 * old extent, add summary data for them to be allocated.
740 */
741 if (postblock > end) {
742 error = xfs_rtmodify_summary(mp, tp,
743 XFS_RTBLOCKLOG(postblock - end),
744 XFS_BITTOBLOCK(mp, end + 1), -1, rbpp, rsb);
745 if (error) {
746 return error;
747 }
748 }
749 /*
750 * Increment the summary information corresponding to the entire
751 * (new) free extent.
752 */
753 error = xfs_rtmodify_summary(mp, tp,
754 XFS_RTBLOCKLOG(postblock + 1 - preblock),
755 XFS_BITTOBLOCK(mp, preblock), 1, rbpp, rsb);
756 return error;
757}
758
759/*
760 * Check that the given range is either all allocated (val = 0) or
761 * all free (val = 1).
762 */
763int
764xfs_rtcheck_range(
765 xfs_mount_t *mp, /* file system mount point */
766 xfs_trans_t *tp, /* transaction pointer */
767 xfs_rtblock_t start, /* starting block number of extent */
768 xfs_extlen_t len, /* length of extent */
769 int val, /* 1 for free, 0 for allocated */
770 xfs_rtblock_t *new, /* out: first block not matching */
771 int *stat) /* out: 1 for matches, 0 for not */
772{
773 xfs_rtword_t *b; /* current word in buffer */
774 int bit; /* bit number in the word */
775 xfs_rtblock_t block; /* bitmap block number */
776 struct xfs_buf *bp; /* buf for the block */
777 xfs_rtword_t *bufp; /* starting word in buffer */
778 int error; /* error value */
779 xfs_rtblock_t i; /* current bit number rel. to start */
780 xfs_rtblock_t lastbit; /* last useful bit in word */
781 xfs_rtword_t mask; /* mask of relevant bits for value */
782 xfs_rtword_t wdiff; /* difference from wanted value */
783 int word; /* word number in the buffer */
784
785 /*
786 * Compute starting bitmap block number
787 */
788 block = XFS_BITTOBLOCK(mp, start);
789 /*
790 * Read the bitmap block.
791 */
792 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
793 if (error) {
794 return error;
795 }
796 bufp = bp->b_addr;
797 /*
798 * Compute the starting word's address, and starting bit.
799 */
800 word = XFS_BITTOWORD(mp, start);
801 b = &bufp[word];
802 bit = (int)(start & (XFS_NBWORD - 1));
803 /*
804 * 0 (allocated) => all zero's; 1 (free) => all one's.
805 */
806 val = -val;
807 /*
808 * If not starting on a word boundary, deal with the first
809 * (partial) word.
810 */
811 if (bit) {
812 /*
813 * Compute first bit not examined.
814 */
815 lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
816 /*
817 * Mask of relevant bits.
818 */
819 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
820 /*
821 * Compute difference between actual and desired value.
822 */
823 if ((wdiff = (*b ^ val) & mask)) {
824 /*
825 * Different, compute first wrong bit and return.
826 */
827 xfs_trans_brelse(tp, bp);
828 i = XFS_RTLOBIT(wdiff) - bit;
829 *new = start + i;
830 *stat = 0;
831 return 0;
832 }
833 i = lastbit - bit;
834 /*
835 * Go on to next block if that's where the next word is
836 * and we need the next word.
837 */
838 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
839 /*
840 * If done with this block, get the next one.
841 */
842 xfs_trans_brelse(tp, bp);
843 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
844 if (error) {
845 return error;
846 }
847 b = bufp = bp->b_addr;
848 word = 0;
849 } else {
850 /*
851 * Go on to the next word in the buffer.
852 */
853 b++;
854 }
855 } else {
856 /*
857 * Starting on a word boundary, no partial word.
858 */
859 i = 0;
860 }
861 /*
862 * Loop over whole words in buffers. When we use up one buffer
863 * we move on to the next one.
864 */
865 while (len - i >= XFS_NBWORD) {
866 /*
867 * Compute difference between actual and desired value.
868 */
869 if ((wdiff = *b ^ val)) {
870 /*
871 * Different, compute first wrong bit and return.
872 */
873 xfs_trans_brelse(tp, bp);
874 i += XFS_RTLOBIT(wdiff);
875 *new = start + i;
876 *stat = 0;
877 return 0;
878 }
879 i += XFS_NBWORD;
880 /*
881 * Go on to next block if that's where the next word is
882 * and we need the next word.
883 */
884 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
885 /*
886 * If done with this block, get the next one.
887 */
888 xfs_trans_brelse(tp, bp);
889 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
890 if (error) {
891 return error;
892 }
893 b = bufp = bp->b_addr;
894 word = 0;
895 } else {
896 /*
897 * Go on to the next word in the buffer.
898 */
899 b++;
900 }
901 }
902 /*
903 * If not ending on a word boundary, deal with the last
904 * (partial) word.
905 */
906 if ((lastbit = len - i)) {
907 /*
908 * Mask of relevant bits.
909 */
910 mask = ((xfs_rtword_t)1 << lastbit) - 1;
911 /*
912 * Compute difference between actual and desired value.
913 */
914 if ((wdiff = (*b ^ val) & mask)) {
915 /*
916 * Different, compute first wrong bit and return.
917 */
918 xfs_trans_brelse(tp, bp);
919 i += XFS_RTLOBIT(wdiff);
920 *new = start + i;
921 *stat = 0;
922 return 0;
923 } else
924 i = len;
925 }
926 /*
927 * Successful, return.
928 */
929 xfs_trans_brelse(tp, bp);
930 *new = start + i;
931 *stat = 1;
932 return 0;
933}
934
935#ifdef DEBUG
936/*
937 * Check that the given extent (block range) is allocated already.
938 */
939STATIC int /* error */
940xfs_rtcheck_alloc_range(
941 xfs_mount_t *mp, /* file system mount point */
942 xfs_trans_t *tp, /* transaction pointer */
943 xfs_rtblock_t bno, /* starting block number of extent */
944 xfs_extlen_t len) /* length of extent */
945{
946 xfs_rtblock_t new; /* dummy for xfs_rtcheck_range */
947 int stat;
948 int error;
949
950 error = xfs_rtcheck_range(mp, tp, bno, len, 0, &new, &stat);
951 if (error)
952 return error;
953 ASSERT(stat);
954 return 0;
955}
956#else
957#define xfs_rtcheck_alloc_range(m,t,b,l) (0)
958#endif
959/*
960 * Free an extent in the realtime subvolume. Length is expressed in
961 * realtime extents, as is the block number.
962 */
963int /* error */
964xfs_rtfree_extent(
965 xfs_trans_t *tp, /* transaction pointer */
966 xfs_rtblock_t bno, /* starting block number to free */
967 xfs_extlen_t len) /* length of extent freed */
968{
969 int error; /* error value */
970 xfs_mount_t *mp; /* file system mount structure */
971 xfs_fsblock_t sb; /* summary file block number */
972 struct xfs_buf *sumbp = NULL; /* summary file block buffer */
973
974 mp = tp->t_mountp;
975
976 ASSERT(mp->m_rbmip->i_itemp != NULL);
977 ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
978
979 error = xfs_rtcheck_alloc_range(mp, tp, bno, len);
980 if (error)
981 return error;
982
983 /*
984 * Free the range of realtime blocks.
985 */
986 error = xfs_rtfree_range(mp, tp, bno, len, &sumbp, &sb);
987 if (error) {
988 return error;
989 }
990 /*
991 * Mark more blocks free in the superblock.
992 */
993 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FREXTENTS, (long)len);
994 /*
995 * If we've now freed all the blocks, reset the file sequence
996 * number to 0.
997 */
998 if (tp->t_frextents_delta + mp->m_sb.sb_frextents ==
999 mp->m_sb.sb_rextents) {
1000 if (!(mp->m_rbmip->i_diflags & XFS_DIFLAG_NEWRTBM))
1001 mp->m_rbmip->i_diflags |= XFS_DIFLAG_NEWRTBM;
1002 *(uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0;
1003 xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
1004 }
1005 return 0;
1006}
1007
1008/* Find all the free records within a given range. */
1009int
1010xfs_rtalloc_query_range(
1011 struct xfs_mount *mp,
1012 struct xfs_trans *tp,
1013 const struct xfs_rtalloc_rec *low_rec,
1014 const struct xfs_rtalloc_rec *high_rec,
1015 xfs_rtalloc_query_range_fn fn,
1016 void *priv)
1017{
1018 struct xfs_rtalloc_rec rec;
1019 xfs_rtblock_t rtstart;
1020 xfs_rtblock_t rtend;
1021 xfs_rtblock_t high_key;
1022 int is_free;
1023 int error = 0;
1024
1025 if (low_rec->ar_startext > high_rec->ar_startext)
1026 return -EINVAL;
1027 if (low_rec->ar_startext >= mp->m_sb.sb_rextents ||
1028 low_rec->ar_startext == high_rec->ar_startext)
1029 return 0;
1030
1031 high_key = min(high_rec->ar_startext, mp->m_sb.sb_rextents - 1);
1032
1033 /* Iterate the bitmap, looking for discrepancies. */
1034 rtstart = low_rec->ar_startext;
1035 while (rtstart <= high_key) {
1036 /* Is the first block free? */
1037 error = xfs_rtcheck_range(mp, tp, rtstart, 1, 1, &rtend,
1038 &is_free);
1039 if (error)
1040 break;
1041
1042 /* How long does the extent go for? */
1043 error = xfs_rtfind_forw(mp, tp, rtstart, high_key, &rtend);
1044 if (error)
1045 break;
1046
1047 if (is_free) {
1048 rec.ar_startext = rtstart;
1049 rec.ar_extcount = rtend - rtstart + 1;
1050
1051 error = fn(mp, tp, &rec, priv);
1052 if (error)
1053 break;
1054 }
1055
1056 rtstart = rtend + 1;
1057 }
1058
1059 return error;
1060}
1061
1062/* Find all the free records. */
1063int
1064xfs_rtalloc_query_all(
1065 struct xfs_mount *mp,
1066 struct xfs_trans *tp,
1067 xfs_rtalloc_query_range_fn fn,
1068 void *priv)
1069{
1070 struct xfs_rtalloc_rec keys[2];
1071
1072 keys[0].ar_startext = 0;
1073 keys[1].ar_startext = mp->m_sb.sb_rextents - 1;
1074 keys[0].ar_extcount = keys[1].ar_extcount = 0;
1075
1076 return xfs_rtalloc_query_range(mp, tp, &keys[0], &keys[1], fn, priv);
1077}
1078
1079/* Is the given extent all free? */
1080int
1081xfs_rtalloc_extent_is_free(
1082 struct xfs_mount *mp,
1083 struct xfs_trans *tp,
1084 xfs_rtblock_t start,
1085 xfs_extlen_t len,
1086 bool *is_free)
1087{
1088 xfs_rtblock_t end;
1089 int matches;
1090 int error;
1091
1092 error = xfs_rtcheck_range(mp, tp, start, len, 1, &end, &matches);
1093 if (error)
1094 return error;
1095
1096 *is_free = matches;
1097 return 0;
1098}
1/*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_shared.h"
21#include "xfs_format.h"
22#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
24#include "xfs_bit.h"
25#include "xfs_mount.h"
26#include "xfs_inode.h"
27#include "xfs_bmap.h"
28#include "xfs_bmap_util.h"
29#include "xfs_bmap_btree.h"
30#include "xfs_alloc.h"
31#include "xfs_error.h"
32#include "xfs_trans.h"
33#include "xfs_trans_space.h"
34#include "xfs_trace.h"
35#include "xfs_buf.h"
36#include "xfs_icache.h"
37#include "xfs_rtalloc.h"
38
39
40/*
41 * Realtime allocator bitmap functions shared with userspace.
42 */
43
44/*
45 * Real time buffers need verifiers to avoid runtime warnings during IO.
46 * We don't have anything to verify, however, so these are just dummy
47 * operations.
48 */
49static void
50xfs_rtbuf_verify_read(
51 struct xfs_buf *bp)
52{
53 return;
54}
55
56static void
57xfs_rtbuf_verify_write(
58 struct xfs_buf *bp)
59{
60 return;
61}
62
63const struct xfs_buf_ops xfs_rtbuf_ops = {
64 .name = "rtbuf",
65 .verify_read = xfs_rtbuf_verify_read,
66 .verify_write = xfs_rtbuf_verify_write,
67};
68
69/*
70 * Get a buffer for the bitmap or summary file block specified.
71 * The buffer is returned read and locked.
72 */
73static int
74xfs_rtbuf_get(
75 xfs_mount_t *mp, /* file system mount structure */
76 xfs_trans_t *tp, /* transaction pointer */
77 xfs_rtblock_t block, /* block number in bitmap or summary */
78 int issum, /* is summary not bitmap */
79 xfs_buf_t **bpp) /* output: buffer for the block */
80{
81 xfs_buf_t *bp; /* block buffer, result */
82 xfs_inode_t *ip; /* bitmap or summary inode */
83 xfs_bmbt_irec_t map;
84 int nmap = 1;
85 int error; /* error value */
86
87 ip = issum ? mp->m_rsumip : mp->m_rbmip;
88
89 error = xfs_bmapi_read(ip, block, 1, &map, &nmap, XFS_DATA_FORK);
90 if (error)
91 return error;
92
93 ASSERT(map.br_startblock != NULLFSBLOCK);
94 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
95 XFS_FSB_TO_DADDR(mp, map.br_startblock),
96 mp->m_bsize, 0, &bp, &xfs_rtbuf_ops);
97 if (error)
98 return error;
99
100 xfs_trans_buf_set_type(tp, bp, issum ? XFS_BLFT_RTSUMMARY_BUF
101 : XFS_BLFT_RTBITMAP_BUF);
102 *bpp = bp;
103 return 0;
104}
105
106/*
107 * Searching backward from start to limit, find the first block whose
108 * allocated/free state is different from start's.
109 */
110int
111xfs_rtfind_back(
112 xfs_mount_t *mp, /* file system mount point */
113 xfs_trans_t *tp, /* transaction pointer */
114 xfs_rtblock_t start, /* starting block to look at */
115 xfs_rtblock_t limit, /* last block to look at */
116 xfs_rtblock_t *rtblock) /* out: start block found */
117{
118 xfs_rtword_t *b; /* current word in buffer */
119 int bit; /* bit number in the word */
120 xfs_rtblock_t block; /* bitmap block number */
121 xfs_buf_t *bp; /* buf for the block */
122 xfs_rtword_t *bufp; /* starting word in buffer */
123 int error; /* error value */
124 xfs_rtblock_t firstbit; /* first useful bit in the word */
125 xfs_rtblock_t i; /* current bit number rel. to start */
126 xfs_rtblock_t len; /* length of inspected area */
127 xfs_rtword_t mask; /* mask of relevant bits for value */
128 xfs_rtword_t want; /* mask for "good" values */
129 xfs_rtword_t wdiff; /* difference from wanted value */
130 int word; /* word number in the buffer */
131
132 /*
133 * Compute and read in starting bitmap block for starting block.
134 */
135 block = XFS_BITTOBLOCK(mp, start);
136 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
137 if (error) {
138 return error;
139 }
140 bufp = bp->b_addr;
141 /*
142 * Get the first word's index & point to it.
143 */
144 word = XFS_BITTOWORD(mp, start);
145 b = &bufp[word];
146 bit = (int)(start & (XFS_NBWORD - 1));
147 len = start - limit + 1;
148 /*
149 * Compute match value, based on the bit at start: if 1 (free)
150 * then all-ones, else all-zeroes.
151 */
152 want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
153 /*
154 * If the starting position is not word-aligned, deal with the
155 * partial word.
156 */
157 if (bit < XFS_NBWORD - 1) {
158 /*
159 * Calculate first (leftmost) bit number to look at,
160 * and mask for all the relevant bits in this word.
161 */
162 firstbit = XFS_RTMAX((xfs_srtblock_t)(bit - len + 1), 0);
163 mask = (((xfs_rtword_t)1 << (bit - firstbit + 1)) - 1) <<
164 firstbit;
165 /*
166 * Calculate the difference between the value there
167 * and what we're looking for.
168 */
169 if ((wdiff = (*b ^ want) & mask)) {
170 /*
171 * Different. Mark where we are and return.
172 */
173 xfs_trans_brelse(tp, bp);
174 i = bit - XFS_RTHIBIT(wdiff);
175 *rtblock = start - i + 1;
176 return 0;
177 }
178 i = bit - firstbit + 1;
179 /*
180 * Go on to previous block if that's where the previous word is
181 * and we need the previous word.
182 */
183 if (--word == -1 && i < len) {
184 /*
185 * If done with this block, get the previous one.
186 */
187 xfs_trans_brelse(tp, bp);
188 error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
189 if (error) {
190 return error;
191 }
192 bufp = bp->b_addr;
193 word = XFS_BLOCKWMASK(mp);
194 b = &bufp[word];
195 } else {
196 /*
197 * Go on to the previous word in the buffer.
198 */
199 b--;
200 }
201 } else {
202 /*
203 * Starting on a word boundary, no partial word.
204 */
205 i = 0;
206 }
207 /*
208 * Loop over whole words in buffers. When we use up one buffer
209 * we move on to the previous one.
210 */
211 while (len - i >= XFS_NBWORD) {
212 /*
213 * Compute difference between actual and desired value.
214 */
215 if ((wdiff = *b ^ want)) {
216 /*
217 * Different, mark where we are and return.
218 */
219 xfs_trans_brelse(tp, bp);
220 i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
221 *rtblock = start - i + 1;
222 return 0;
223 }
224 i += XFS_NBWORD;
225 /*
226 * Go on to previous block if that's where the previous word is
227 * and we need the previous word.
228 */
229 if (--word == -1 && i < len) {
230 /*
231 * If done with this block, get the previous one.
232 */
233 xfs_trans_brelse(tp, bp);
234 error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
235 if (error) {
236 return error;
237 }
238 bufp = bp->b_addr;
239 word = XFS_BLOCKWMASK(mp);
240 b = &bufp[word];
241 } else {
242 /*
243 * Go on to the previous word in the buffer.
244 */
245 b--;
246 }
247 }
248 /*
249 * If not ending on a word boundary, deal with the last
250 * (partial) word.
251 */
252 if (len - i) {
253 /*
254 * Calculate first (leftmost) bit number to look at,
255 * and mask for all the relevant bits in this word.
256 */
257 firstbit = XFS_NBWORD - (len - i);
258 mask = (((xfs_rtword_t)1 << (len - i)) - 1) << firstbit;
259 /*
260 * Compute difference between actual and desired value.
261 */
262 if ((wdiff = (*b ^ want) & mask)) {
263 /*
264 * Different, mark where we are and return.
265 */
266 xfs_trans_brelse(tp, bp);
267 i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
268 *rtblock = start - i + 1;
269 return 0;
270 } else
271 i = len;
272 }
273 /*
274 * No match, return that we scanned the whole area.
275 */
276 xfs_trans_brelse(tp, bp);
277 *rtblock = start - i + 1;
278 return 0;
279}
280
281/*
282 * Searching forward from start to limit, find the first block whose
283 * allocated/free state is different from start's.
284 */
285int
286xfs_rtfind_forw(
287 xfs_mount_t *mp, /* file system mount point */
288 xfs_trans_t *tp, /* transaction pointer */
289 xfs_rtblock_t start, /* starting block to look at */
290 xfs_rtblock_t limit, /* last block to look at */
291 xfs_rtblock_t *rtblock) /* out: start block found */
292{
293 xfs_rtword_t *b; /* current word in buffer */
294 int bit; /* bit number in the word */
295 xfs_rtblock_t block; /* bitmap block number */
296 xfs_buf_t *bp; /* buf for the block */
297 xfs_rtword_t *bufp; /* starting word in buffer */
298 int error; /* error value */
299 xfs_rtblock_t i; /* current bit number rel. to start */
300 xfs_rtblock_t lastbit; /* last useful bit in the word */
301 xfs_rtblock_t len; /* length of inspected area */
302 xfs_rtword_t mask; /* mask of relevant bits for value */
303 xfs_rtword_t want; /* mask for "good" values */
304 xfs_rtword_t wdiff; /* difference from wanted value */
305 int word; /* word number in the buffer */
306
307 /*
308 * Compute and read in starting bitmap block for starting block.
309 */
310 block = XFS_BITTOBLOCK(mp, start);
311 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
312 if (error) {
313 return error;
314 }
315 bufp = bp->b_addr;
316 /*
317 * Get the first word's index & point to it.
318 */
319 word = XFS_BITTOWORD(mp, start);
320 b = &bufp[word];
321 bit = (int)(start & (XFS_NBWORD - 1));
322 len = limit - start + 1;
323 /*
324 * Compute match value, based on the bit at start: if 1 (free)
325 * then all-ones, else all-zeroes.
326 */
327 want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
328 /*
329 * If the starting position is not word-aligned, deal with the
330 * partial word.
331 */
332 if (bit) {
333 /*
334 * Calculate last (rightmost) bit number to look at,
335 * and mask for all the relevant bits in this word.
336 */
337 lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
338 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
339 /*
340 * Calculate the difference between the value there
341 * and what we're looking for.
342 */
343 if ((wdiff = (*b ^ want) & mask)) {
344 /*
345 * Different. Mark where we are and return.
346 */
347 xfs_trans_brelse(tp, bp);
348 i = XFS_RTLOBIT(wdiff) - bit;
349 *rtblock = start + i - 1;
350 return 0;
351 }
352 i = lastbit - bit;
353 /*
354 * Go on to next block if that's where the next word is
355 * and we need the next word.
356 */
357 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
358 /*
359 * If done with this block, get the previous one.
360 */
361 xfs_trans_brelse(tp, bp);
362 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
363 if (error) {
364 return error;
365 }
366 b = bufp = bp->b_addr;
367 word = 0;
368 } else {
369 /*
370 * Go on to the previous word in the buffer.
371 */
372 b++;
373 }
374 } else {
375 /*
376 * Starting on a word boundary, no partial word.
377 */
378 i = 0;
379 }
380 /*
381 * Loop over whole words in buffers. When we use up one buffer
382 * we move on to the next one.
383 */
384 while (len - i >= XFS_NBWORD) {
385 /*
386 * Compute difference between actual and desired value.
387 */
388 if ((wdiff = *b ^ want)) {
389 /*
390 * Different, mark where we are and return.
391 */
392 xfs_trans_brelse(tp, bp);
393 i += XFS_RTLOBIT(wdiff);
394 *rtblock = start + i - 1;
395 return 0;
396 }
397 i += XFS_NBWORD;
398 /*
399 * Go on to next block if that's where the next word is
400 * and we need the next word.
401 */
402 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
403 /*
404 * If done with this block, get the next one.
405 */
406 xfs_trans_brelse(tp, bp);
407 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
408 if (error) {
409 return error;
410 }
411 b = bufp = bp->b_addr;
412 word = 0;
413 } else {
414 /*
415 * Go on to the next word in the buffer.
416 */
417 b++;
418 }
419 }
420 /*
421 * If not ending on a word boundary, deal with the last
422 * (partial) word.
423 */
424 if ((lastbit = len - i)) {
425 /*
426 * Calculate mask for all the relevant bits in this word.
427 */
428 mask = ((xfs_rtword_t)1 << lastbit) - 1;
429 /*
430 * Compute difference between actual and desired value.
431 */
432 if ((wdiff = (*b ^ want) & mask)) {
433 /*
434 * Different, mark where we are and return.
435 */
436 xfs_trans_brelse(tp, bp);
437 i += XFS_RTLOBIT(wdiff);
438 *rtblock = start + i - 1;
439 return 0;
440 } else
441 i = len;
442 }
443 /*
444 * No match, return that we scanned the whole area.
445 */
446 xfs_trans_brelse(tp, bp);
447 *rtblock = start + i - 1;
448 return 0;
449}
450
451/*
452 * Read and/or modify the summary information for a given extent size,
453 * bitmap block combination.
454 * Keeps track of a current summary block, so we don't keep reading
455 * it from the buffer cache.
456 *
457 * Summary information is returned in *sum if specified.
458 * If no delta is specified, returns summary only.
459 */
460int
461xfs_rtmodify_summary_int(
462 xfs_mount_t *mp, /* file system mount structure */
463 xfs_trans_t *tp, /* transaction pointer */
464 int log, /* log2 of extent size */
465 xfs_rtblock_t bbno, /* bitmap block number */
466 int delta, /* change to make to summary info */
467 xfs_buf_t **rbpp, /* in/out: summary block buffer */
468 xfs_fsblock_t *rsb, /* in/out: summary block number */
469 xfs_suminfo_t *sum) /* out: summary info for this block */
470{
471 xfs_buf_t *bp; /* buffer for the summary block */
472 int error; /* error value */
473 xfs_fsblock_t sb; /* summary fsblock */
474 int so; /* index into the summary file */
475 xfs_suminfo_t *sp; /* pointer to returned data */
476
477 /*
478 * Compute entry number in the summary file.
479 */
480 so = XFS_SUMOFFS(mp, log, bbno);
481 /*
482 * Compute the block number in the summary file.
483 */
484 sb = XFS_SUMOFFSTOBLOCK(mp, so);
485 /*
486 * If we have an old buffer, and the block number matches, use that.
487 */
488 if (*rbpp && *rsb == sb)
489 bp = *rbpp;
490 /*
491 * Otherwise we have to get the buffer.
492 */
493 else {
494 /*
495 * If there was an old one, get rid of it first.
496 */
497 if (*rbpp)
498 xfs_trans_brelse(tp, *rbpp);
499 error = xfs_rtbuf_get(mp, tp, sb, 1, &bp);
500 if (error) {
501 return error;
502 }
503 /*
504 * Remember this buffer and block for the next call.
505 */
506 *rbpp = bp;
507 *rsb = sb;
508 }
509 /*
510 * Point to the summary information, modify/log it, and/or copy it out.
511 */
512 sp = XFS_SUMPTR(mp, bp, so);
513 if (delta) {
514 uint first = (uint)((char *)sp - (char *)bp->b_addr);
515
516 *sp += delta;
517 xfs_trans_log_buf(tp, bp, first, first + sizeof(*sp) - 1);
518 }
519 if (sum)
520 *sum = *sp;
521 return 0;
522}
523
524int
525xfs_rtmodify_summary(
526 xfs_mount_t *mp, /* file system mount structure */
527 xfs_trans_t *tp, /* transaction pointer */
528 int log, /* log2 of extent size */
529 xfs_rtblock_t bbno, /* bitmap block number */
530 int delta, /* change to make to summary info */
531 xfs_buf_t **rbpp, /* in/out: summary block buffer */
532 xfs_fsblock_t *rsb) /* in/out: summary block number */
533{
534 return xfs_rtmodify_summary_int(mp, tp, log, bbno,
535 delta, rbpp, rsb, NULL);
536}
537
538/*
539 * Set the given range of bitmap bits to the given value.
540 * Do whatever I/O and logging is required.
541 */
542int
543xfs_rtmodify_range(
544 xfs_mount_t *mp, /* file system mount point */
545 xfs_trans_t *tp, /* transaction pointer */
546 xfs_rtblock_t start, /* starting block to modify */
547 xfs_extlen_t len, /* length of extent to modify */
548 int val) /* 1 for free, 0 for allocated */
549{
550 xfs_rtword_t *b; /* current word in buffer */
551 int bit; /* bit number in the word */
552 xfs_rtblock_t block; /* bitmap block number */
553 xfs_buf_t *bp; /* buf for the block */
554 xfs_rtword_t *bufp; /* starting word in buffer */
555 int error; /* error value */
556 xfs_rtword_t *first; /* first used word in the buffer */
557 int i; /* current bit number rel. to start */
558 int lastbit; /* last useful bit in word */
559 xfs_rtword_t mask; /* mask o frelevant bits for value */
560 int word; /* word number in the buffer */
561
562 /*
563 * Compute starting bitmap block number.
564 */
565 block = XFS_BITTOBLOCK(mp, start);
566 /*
567 * Read the bitmap block, and point to its data.
568 */
569 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
570 if (error) {
571 return error;
572 }
573 bufp = bp->b_addr;
574 /*
575 * Compute the starting word's address, and starting bit.
576 */
577 word = XFS_BITTOWORD(mp, start);
578 first = b = &bufp[word];
579 bit = (int)(start & (XFS_NBWORD - 1));
580 /*
581 * 0 (allocated) => all zeroes; 1 (free) => all ones.
582 */
583 val = -val;
584 /*
585 * If not starting on a word boundary, deal with the first
586 * (partial) word.
587 */
588 if (bit) {
589 /*
590 * Compute first bit not changed and mask of relevant bits.
591 */
592 lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
593 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
594 /*
595 * Set/clear the active bits.
596 */
597 if (val)
598 *b |= mask;
599 else
600 *b &= ~mask;
601 i = lastbit - bit;
602 /*
603 * Go on to the next block if that's where the next word is
604 * and we need the next word.
605 */
606 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
607 /*
608 * Log the changed part of this block.
609 * Get the next one.
610 */
611 xfs_trans_log_buf(tp, bp,
612 (uint)((char *)first - (char *)bufp),
613 (uint)((char *)b - (char *)bufp));
614 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
615 if (error) {
616 return error;
617 }
618 first = b = bufp = bp->b_addr;
619 word = 0;
620 } else {
621 /*
622 * Go on to the next word in the buffer
623 */
624 b++;
625 }
626 } else {
627 /*
628 * Starting on a word boundary, no partial word.
629 */
630 i = 0;
631 }
632 /*
633 * Loop over whole words in buffers. When we use up one buffer
634 * we move on to the next one.
635 */
636 while (len - i >= XFS_NBWORD) {
637 /*
638 * Set the word value correctly.
639 */
640 *b = val;
641 i += XFS_NBWORD;
642 /*
643 * Go on to the next block if that's where the next word is
644 * and we need the next word.
645 */
646 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
647 /*
648 * Log the changed part of this block.
649 * Get the next one.
650 */
651 xfs_trans_log_buf(tp, bp,
652 (uint)((char *)first - (char *)bufp),
653 (uint)((char *)b - (char *)bufp));
654 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
655 if (error) {
656 return error;
657 }
658 first = b = bufp = bp->b_addr;
659 word = 0;
660 } else {
661 /*
662 * Go on to the next word in the buffer
663 */
664 b++;
665 }
666 }
667 /*
668 * If not ending on a word boundary, deal with the last
669 * (partial) word.
670 */
671 if ((lastbit = len - i)) {
672 /*
673 * Compute a mask of relevant bits.
674 */
675 bit = 0;
676 mask = ((xfs_rtword_t)1 << lastbit) - 1;
677 /*
678 * Set/clear the active bits.
679 */
680 if (val)
681 *b |= mask;
682 else
683 *b &= ~mask;
684 b++;
685 }
686 /*
687 * Log any remaining changed bytes.
688 */
689 if (b > first)
690 xfs_trans_log_buf(tp, bp, (uint)((char *)first - (char *)bufp),
691 (uint)((char *)b - (char *)bufp - 1));
692 return 0;
693}
694
695/*
696 * Mark an extent specified by start and len freed.
697 * Updates all the summary information as well as the bitmap.
698 */
699int
700xfs_rtfree_range(
701 xfs_mount_t *mp, /* file system mount point */
702 xfs_trans_t *tp, /* transaction pointer */
703 xfs_rtblock_t start, /* starting block to free */
704 xfs_extlen_t len, /* length to free */
705 xfs_buf_t **rbpp, /* in/out: summary block buffer */
706 xfs_fsblock_t *rsb) /* in/out: summary block number */
707{
708 xfs_rtblock_t end; /* end of the freed extent */
709 int error; /* error value */
710 xfs_rtblock_t postblock; /* first block freed > end */
711 xfs_rtblock_t preblock; /* first block freed < start */
712
713 end = start + len - 1;
714 /*
715 * Modify the bitmap to mark this extent freed.
716 */
717 error = xfs_rtmodify_range(mp, tp, start, len, 1);
718 if (error) {
719 return error;
720 }
721 /*
722 * Assume we're freeing out of the middle of an allocated extent.
723 * We need to find the beginning and end of the extent so we can
724 * properly update the summary.
725 */
726 error = xfs_rtfind_back(mp, tp, start, 0, &preblock);
727 if (error) {
728 return error;
729 }
730 /*
731 * Find the next allocated block (end of allocated extent).
732 */
733 error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1,
734 &postblock);
735 if (error)
736 return error;
737 /*
738 * If there are blocks not being freed at the front of the
739 * old extent, add summary data for them to be allocated.
740 */
741 if (preblock < start) {
742 error = xfs_rtmodify_summary(mp, tp,
743 XFS_RTBLOCKLOG(start - preblock),
744 XFS_BITTOBLOCK(mp, preblock), -1, rbpp, rsb);
745 if (error) {
746 return error;
747 }
748 }
749 /*
750 * If there are blocks not being freed at the end of the
751 * old extent, add summary data for them to be allocated.
752 */
753 if (postblock > end) {
754 error = xfs_rtmodify_summary(mp, tp,
755 XFS_RTBLOCKLOG(postblock - end),
756 XFS_BITTOBLOCK(mp, end + 1), -1, rbpp, rsb);
757 if (error) {
758 return error;
759 }
760 }
761 /*
762 * Increment the summary information corresponding to the entire
763 * (new) free extent.
764 */
765 error = xfs_rtmodify_summary(mp, tp,
766 XFS_RTBLOCKLOG(postblock + 1 - preblock),
767 XFS_BITTOBLOCK(mp, preblock), 1, rbpp, rsb);
768 return error;
769}
770
771/*
772 * Check that the given range is either all allocated (val = 0) or
773 * all free (val = 1).
774 */
775int
776xfs_rtcheck_range(
777 xfs_mount_t *mp, /* file system mount point */
778 xfs_trans_t *tp, /* transaction pointer */
779 xfs_rtblock_t start, /* starting block number of extent */
780 xfs_extlen_t len, /* length of extent */
781 int val, /* 1 for free, 0 for allocated */
782 xfs_rtblock_t *new, /* out: first block not matching */
783 int *stat) /* out: 1 for matches, 0 for not */
784{
785 xfs_rtword_t *b; /* current word in buffer */
786 int bit; /* bit number in the word */
787 xfs_rtblock_t block; /* bitmap block number */
788 xfs_buf_t *bp; /* buf for the block */
789 xfs_rtword_t *bufp; /* starting word in buffer */
790 int error; /* error value */
791 xfs_rtblock_t i; /* current bit number rel. to start */
792 xfs_rtblock_t lastbit; /* last useful bit in word */
793 xfs_rtword_t mask; /* mask of relevant bits for value */
794 xfs_rtword_t wdiff; /* difference from wanted value */
795 int word; /* word number in the buffer */
796
797 /*
798 * Compute starting bitmap block number
799 */
800 block = XFS_BITTOBLOCK(mp, start);
801 /*
802 * Read the bitmap block.
803 */
804 error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
805 if (error) {
806 return error;
807 }
808 bufp = bp->b_addr;
809 /*
810 * Compute the starting word's address, and starting bit.
811 */
812 word = XFS_BITTOWORD(mp, start);
813 b = &bufp[word];
814 bit = (int)(start & (XFS_NBWORD - 1));
815 /*
816 * 0 (allocated) => all zero's; 1 (free) => all one's.
817 */
818 val = -val;
819 /*
820 * If not starting on a word boundary, deal with the first
821 * (partial) word.
822 */
823 if (bit) {
824 /*
825 * Compute first bit not examined.
826 */
827 lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
828 /*
829 * Mask of relevant bits.
830 */
831 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
832 /*
833 * Compute difference between actual and desired value.
834 */
835 if ((wdiff = (*b ^ val) & mask)) {
836 /*
837 * Different, compute first wrong bit and return.
838 */
839 xfs_trans_brelse(tp, bp);
840 i = XFS_RTLOBIT(wdiff) - bit;
841 *new = start + i;
842 *stat = 0;
843 return 0;
844 }
845 i = lastbit - bit;
846 /*
847 * Go on to next block if that's where the next word is
848 * and we need the next word.
849 */
850 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
851 /*
852 * If done with this block, get the next one.
853 */
854 xfs_trans_brelse(tp, bp);
855 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
856 if (error) {
857 return error;
858 }
859 b = bufp = bp->b_addr;
860 word = 0;
861 } else {
862 /*
863 * Go on to the next word in the buffer.
864 */
865 b++;
866 }
867 } else {
868 /*
869 * Starting on a word boundary, no partial word.
870 */
871 i = 0;
872 }
873 /*
874 * Loop over whole words in buffers. When we use up one buffer
875 * we move on to the next one.
876 */
877 while (len - i >= XFS_NBWORD) {
878 /*
879 * Compute difference between actual and desired value.
880 */
881 if ((wdiff = *b ^ val)) {
882 /*
883 * Different, compute first wrong bit and return.
884 */
885 xfs_trans_brelse(tp, bp);
886 i += XFS_RTLOBIT(wdiff);
887 *new = start + i;
888 *stat = 0;
889 return 0;
890 }
891 i += XFS_NBWORD;
892 /*
893 * Go on to next block if that's where the next word is
894 * and we need the next word.
895 */
896 if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
897 /*
898 * If done with this block, get the next one.
899 */
900 xfs_trans_brelse(tp, bp);
901 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
902 if (error) {
903 return error;
904 }
905 b = bufp = bp->b_addr;
906 word = 0;
907 } else {
908 /*
909 * Go on to the next word in the buffer.
910 */
911 b++;
912 }
913 }
914 /*
915 * If not ending on a word boundary, deal with the last
916 * (partial) word.
917 */
918 if ((lastbit = len - i)) {
919 /*
920 * Mask of relevant bits.
921 */
922 mask = ((xfs_rtword_t)1 << lastbit) - 1;
923 /*
924 * Compute difference between actual and desired value.
925 */
926 if ((wdiff = (*b ^ val) & mask)) {
927 /*
928 * Different, compute first wrong bit and return.
929 */
930 xfs_trans_brelse(tp, bp);
931 i += XFS_RTLOBIT(wdiff);
932 *new = start + i;
933 *stat = 0;
934 return 0;
935 } else
936 i = len;
937 }
938 /*
939 * Successful, return.
940 */
941 xfs_trans_brelse(tp, bp);
942 *new = start + i;
943 *stat = 1;
944 return 0;
945}
946
947#ifdef DEBUG
948/*
949 * Check that the given extent (block range) is allocated already.
950 */
951STATIC int /* error */
952xfs_rtcheck_alloc_range(
953 xfs_mount_t *mp, /* file system mount point */
954 xfs_trans_t *tp, /* transaction pointer */
955 xfs_rtblock_t bno, /* starting block number of extent */
956 xfs_extlen_t len) /* length of extent */
957{
958 xfs_rtblock_t new; /* dummy for xfs_rtcheck_range */
959 int stat;
960 int error;
961
962 error = xfs_rtcheck_range(mp, tp, bno, len, 0, &new, &stat);
963 if (error)
964 return error;
965 ASSERT(stat);
966 return 0;
967}
968#else
969#define xfs_rtcheck_alloc_range(m,t,b,l) (0)
970#endif
971/*
972 * Free an extent in the realtime subvolume. Length is expressed in
973 * realtime extents, as is the block number.
974 */
975int /* error */
976xfs_rtfree_extent(
977 xfs_trans_t *tp, /* transaction pointer */
978 xfs_rtblock_t bno, /* starting block number to free */
979 xfs_extlen_t len) /* length of extent freed */
980{
981 int error; /* error value */
982 xfs_mount_t *mp; /* file system mount structure */
983 xfs_fsblock_t sb; /* summary file block number */
984 xfs_buf_t *sumbp = NULL; /* summary file block buffer */
985
986 mp = tp->t_mountp;
987
988 ASSERT(mp->m_rbmip->i_itemp != NULL);
989 ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
990
991 error = xfs_rtcheck_alloc_range(mp, tp, bno, len);
992 if (error)
993 return error;
994
995 /*
996 * Free the range of realtime blocks.
997 */
998 error = xfs_rtfree_range(mp, tp, bno, len, &sumbp, &sb);
999 if (error) {
1000 return error;
1001 }
1002 /*
1003 * Mark more blocks free in the superblock.
1004 */
1005 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FREXTENTS, (long)len);
1006 /*
1007 * If we've now freed all the blocks, reset the file sequence
1008 * number to 0.
1009 */
1010 if (tp->t_frextents_delta + mp->m_sb.sb_frextents ==
1011 mp->m_sb.sb_rextents) {
1012 if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
1013 mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
1014 *(__uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0;
1015 xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
1016 }
1017 return 0;
1018}