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