xref: /linux/fs/xfs/libxfs/xfs_trans_resv.c (revision 680e6ffa15103ab610c0fc1241d2f98c801b13e2)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4  * Copyright (C) 2010 Red Hat, Inc.
5  * All Rights Reserved.
6  */
7 #include "xfs.h"
8 #include "xfs_fs.h"
9 #include "xfs_shared.h"
10 #include "xfs_format.h"
11 #include "xfs_log_format.h"
12 #include "xfs_trans_resv.h"
13 #include "xfs_mount.h"
14 #include "xfs_da_format.h"
15 #include "xfs_da_btree.h"
16 #include "xfs_inode.h"
17 #include "xfs_bmap_btree.h"
18 #include "xfs_ialloc.h"
19 #include "xfs_quota.h"
20 #include "xfs_trans.h"
21 #include "xfs_qm.h"
22 #include "xfs_trans_space.h"
23 #include "xfs_trace.h"
24 
25 #define _ALLOC	true
26 #define _FREE	false
27 
28 /*
29  * A buffer has a format structure overhead in the log in addition
30  * to the data, so we need to take this into account when reserving
31  * space in a transaction for a buffer.  Round the space required up
32  * to a multiple of 128 bytes so that we don't change the historical
33  * reservation that has been used for this overhead.
34  */
35 STATIC uint
36 xfs_buf_log_overhead(void)
37 {
38 	return round_up(sizeof(struct xlog_op_header) +
39 			sizeof(struct xfs_buf_log_format), 128);
40 }
41 
42 /*
43  * Calculate out transaction log reservation per item in bytes.
44  *
45  * The nbufs argument is used to indicate the number of items that
46  * will be changed in a transaction.  size is used to tell how many
47  * bytes should be reserved per item.
48  */
49 STATIC uint
50 xfs_calc_buf_res(
51 	uint		nbufs,
52 	uint		size)
53 {
54 	return nbufs * (size + xfs_buf_log_overhead());
55 }
56 
57 /*
58  * Per-extent log reservation for the btree changes involved in freeing or
59  * allocating an extent.  In classic XFS there were two trees that will be
60  * modified (bnobt + cntbt).  With rmap enabled, there are three trees
61  * (rmapbt).  With reflink, there are four trees (refcountbt).  The number of
62  * blocks reserved is based on the formula:
63  *
64  * num trees * ((2 blocks/level * max depth) - 1)
65  *
66  * Keep in mind that max depth is calculated separately for each type of tree.
67  */
68 uint
69 xfs_allocfree_log_count(
70 	struct xfs_mount *mp,
71 	uint		num_ops)
72 {
73 	uint		blocks;
74 
75 	blocks = num_ops * 2 * (2 * mp->m_ag_maxlevels - 1);
76 	if (xfs_sb_version_hasrmapbt(&mp->m_sb))
77 		blocks += num_ops * (2 * mp->m_rmap_maxlevels - 1);
78 	if (xfs_sb_version_hasreflink(&mp->m_sb))
79 		blocks += num_ops * (2 * mp->m_refc_maxlevels - 1);
80 
81 	return blocks;
82 }
83 
84 /*
85  * Logging inodes is really tricksy. They are logged in memory format,
86  * which means that what we write into the log doesn't directly translate into
87  * the amount of space they use on disk.
88  *
89  * Case in point - btree format forks in memory format use more space than the
90  * on-disk format. In memory, the buffer contains a normal btree block header so
91  * the btree code can treat it as though it is just another generic buffer.
92  * However, when we write it to the inode fork, we don't write all of this
93  * header as it isn't needed. e.g. the root is only ever in the inode, so
94  * there's no need for sibling pointers which would waste 16 bytes of space.
95  *
96  * Hence when we have an inode with a maximally sized btree format fork, then
97  * amount of information we actually log is greater than the size of the inode
98  * on disk. Hence we need an inode reservation function that calculates all this
99  * correctly. So, we log:
100  *
101  * - 4 log op headers for object
102  *	- for the ilf, the inode core and 2 forks
103  * - inode log format object
104  * - the inode core
105  * - two inode forks containing bmap btree root blocks.
106  *	- the btree data contained by both forks will fit into the inode size,
107  *	  hence when combined with the inode core above, we have a total of the
108  *	  actual inode size.
109  *	- the BMBT headers need to be accounted separately, as they are
110  *	  additional to the records and pointers that fit inside the inode
111  *	  forks.
112  */
113 STATIC uint
114 xfs_calc_inode_res(
115 	struct xfs_mount	*mp,
116 	uint			ninodes)
117 {
118 	return ninodes *
119 		(4 * sizeof(struct xlog_op_header) +
120 		 sizeof(struct xfs_inode_log_format) +
121 		 mp->m_sb.sb_inodesize +
122 		 2 * XFS_BMBT_BLOCK_LEN(mp));
123 }
124 
125 /*
126  * Inode btree record insertion/removal modifies the inode btree and free space
127  * btrees (since the inobt does not use the agfl). This requires the following
128  * reservation:
129  *
130  * the inode btree: max depth * blocksize
131  * the allocation btrees: 2 trees * (max depth - 1) * block size
132  *
133  * The caller must account for SB and AG header modifications, etc.
134  */
135 STATIC uint
136 xfs_calc_inobt_res(
137 	struct xfs_mount	*mp)
138 {
139 	return xfs_calc_buf_res(mp->m_in_maxlevels, XFS_FSB_TO_B(mp, 1)) +
140 		xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
141 				 XFS_FSB_TO_B(mp, 1));
142 }
143 
144 /*
145  * The free inode btree is a conditional feature. The behavior differs slightly
146  * from that of the traditional inode btree in that the finobt tracks records
147  * for inode chunks with at least one free inode. A record can be removed from
148  * the tree during individual inode allocation. Therefore the finobt
149  * reservation is unconditional for both the inode chunk allocation and
150  * individual inode allocation (modify) cases.
151  *
152  * Behavior aside, the reservation for finobt modification is equivalent to the
153  * traditional inobt: cover a full finobt shape change plus block allocation.
154  */
155 STATIC uint
156 xfs_calc_finobt_res(
157 	struct xfs_mount	*mp)
158 {
159 	if (!xfs_sb_version_hasfinobt(&mp->m_sb))
160 		return 0;
161 
162 	return xfs_calc_inobt_res(mp);
163 }
164 
165 /*
166  * Calculate the reservation required to allocate or free an inode chunk. This
167  * includes:
168  *
169  * the allocation btrees: 2 trees * (max depth - 1) * block size
170  * the inode chunk: m_ialloc_blks * N
171  *
172  * The size N of the inode chunk reservation depends on whether it is for
173  * allocation or free and which type of create transaction is in use. An inode
174  * chunk free always invalidates the buffers and only requires reservation for
175  * headers (N == 0). An inode chunk allocation requires a chunk sized
176  * reservation on v4 and older superblocks to initialize the chunk. No chunk
177  * reservation is required for allocation on v5 supers, which use ordered
178  * buffers to initialize.
179  */
180 STATIC uint
181 xfs_calc_inode_chunk_res(
182 	struct xfs_mount	*mp,
183 	bool			alloc)
184 {
185 	uint			res, size = 0;
186 
187 	res = xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
188 			       XFS_FSB_TO_B(mp, 1));
189 	if (alloc) {
190 		/* icreate tx uses ordered buffers */
191 		if (xfs_sb_version_hascrc(&mp->m_sb))
192 			return res;
193 		size = XFS_FSB_TO_B(mp, 1);
194 	}
195 
196 	res += xfs_calc_buf_res(mp->m_ialloc_blks, size);
197 	return res;
198 }
199 
200 /*
201  * Various log reservation values.
202  *
203  * These are based on the size of the file system block because that is what
204  * most transactions manipulate.  Each adds in an additional 128 bytes per
205  * item logged to try to account for the overhead of the transaction mechanism.
206  *
207  * Note:  Most of the reservations underestimate the number of allocation
208  * groups into which they could free extents in the xfs_defer_finish() call.
209  * This is because the number in the worst case is quite high and quite
210  * unusual.  In order to fix this we need to change xfs_defer_finish() to free
211  * extents in only a single AG at a time.  This will require changes to the
212  * EFI code as well, however, so that the EFI for the extents not freed is
213  * logged again in each transaction.  See SGI PV #261917.
214  *
215  * Reservation functions here avoid a huge stack in xfs_trans_init due to
216  * register overflow from temporaries in the calculations.
217  */
218 
219 
220 /*
221  * In a write transaction we can allocate a maximum of 2
222  * extents.  This gives:
223  *    the inode getting the new extents: inode size
224  *    the inode's bmap btree: max depth * block size
225  *    the agfs of the ags from which the extents are allocated: 2 * sector
226  *    the superblock free block counter: sector size
227  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
228  * And the bmap_finish transaction can free bmap blocks in a join:
229  *    the agfs of the ags containing the blocks: 2 * sector size
230  *    the agfls of the ags containing the blocks: 2 * sector size
231  *    the super block free block counter: sector size
232  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
233  */
234 STATIC uint
235 xfs_calc_write_reservation(
236 	struct xfs_mount	*mp)
237 {
238 	return XFS_DQUOT_LOGRES(mp) +
239 		max((xfs_calc_inode_res(mp, 1) +
240 		     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
241 				      XFS_FSB_TO_B(mp, 1)) +
242 		     xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
243 		     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
244 				      XFS_FSB_TO_B(mp, 1))),
245 		    (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
246 		     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
247 				      XFS_FSB_TO_B(mp, 1))));
248 }
249 
250 /*
251  * In truncating a file we free up to two extents at once.  We can modify:
252  *    the inode being truncated: inode size
253  *    the inode's bmap btree: (max depth + 1) * block size
254  * And the bmap_finish transaction can free the blocks and bmap blocks:
255  *    the agf for each of the ags: 4 * sector size
256  *    the agfl for each of the ags: 4 * sector size
257  *    the super block to reflect the freed blocks: sector size
258  *    worst case split in allocation btrees per extent assuming 4 extents:
259  *		4 exts * 2 trees * (2 * max depth - 1) * block size
260  */
261 STATIC uint
262 xfs_calc_itruncate_reservation(
263 	struct xfs_mount	*mp)
264 {
265 	return XFS_DQUOT_LOGRES(mp) +
266 		max((xfs_calc_inode_res(mp, 1) +
267 		     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1,
268 				      XFS_FSB_TO_B(mp, 1))),
269 		    (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
270 		     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 4),
271 				      XFS_FSB_TO_B(mp, 1))));
272 }
273 
274 /*
275  * In renaming a files we can modify:
276  *    the four inodes involved: 4 * inode size
277  *    the two directory btrees: 2 * (max depth + v2) * dir block size
278  *    the two directory bmap btrees: 2 * max depth * block size
279  * And the bmap_finish transaction can free dir and bmap blocks (two sets
280  *	of bmap blocks) giving:
281  *    the agf for the ags in which the blocks live: 3 * sector size
282  *    the agfl for the ags in which the blocks live: 3 * sector size
283  *    the superblock for the free block count: sector size
284  *    the allocation btrees: 3 exts * 2 trees * (2 * max depth - 1) * block size
285  */
286 STATIC uint
287 xfs_calc_rename_reservation(
288 	struct xfs_mount	*mp)
289 {
290 	return XFS_DQUOT_LOGRES(mp) +
291 		max((xfs_calc_inode_res(mp, 4) +
292 		     xfs_calc_buf_res(2 * XFS_DIROP_LOG_COUNT(mp),
293 				      XFS_FSB_TO_B(mp, 1))),
294 		    (xfs_calc_buf_res(7, mp->m_sb.sb_sectsize) +
295 		     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 3),
296 				      XFS_FSB_TO_B(mp, 1))));
297 }
298 
299 /*
300  * For removing an inode from unlinked list at first, we can modify:
301  *    the agi hash list and counters: sector size
302  *    the on disk inode before ours in the agi hash list: inode cluster size
303  *    the on disk inode in the agi hash list: inode cluster size
304  */
305 STATIC uint
306 xfs_calc_iunlink_remove_reservation(
307 	struct xfs_mount        *mp)
308 {
309 	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
310 	       2 * max_t(uint, XFS_FSB_TO_B(mp, 1), mp->m_inode_cluster_size);
311 }
312 
313 /*
314  * For creating a link to an inode:
315  *    the parent directory inode: inode size
316  *    the linked inode: inode size
317  *    the directory btree could split: (max depth + v2) * dir block size
318  *    the directory bmap btree could join or split: (max depth + v2) * blocksize
319  * And the bmap_finish transaction can free some bmap blocks giving:
320  *    the agf for the ag in which the blocks live: sector size
321  *    the agfl for the ag in which the blocks live: sector size
322  *    the superblock for the free block count: sector size
323  *    the allocation btrees: 2 trees * (2 * max depth - 1) * block size
324  */
325 STATIC uint
326 xfs_calc_link_reservation(
327 	struct xfs_mount	*mp)
328 {
329 	return XFS_DQUOT_LOGRES(mp) +
330 		xfs_calc_iunlink_remove_reservation(mp) +
331 		max((xfs_calc_inode_res(mp, 2) +
332 		     xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
333 				      XFS_FSB_TO_B(mp, 1))),
334 		    (xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
335 		     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
336 				      XFS_FSB_TO_B(mp, 1))));
337 }
338 
339 /*
340  * For adding an inode to unlinked list we can modify:
341  *    the agi hash list: sector size
342  *    the on disk inode: inode cluster size
343  */
344 STATIC uint
345 xfs_calc_iunlink_add_reservation(xfs_mount_t *mp)
346 {
347 	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
348 		max_t(uint, XFS_FSB_TO_B(mp, 1), mp->m_inode_cluster_size);
349 }
350 
351 /*
352  * For removing a directory entry we can modify:
353  *    the parent directory inode: inode size
354  *    the removed inode: inode size
355  *    the directory btree could join: (max depth + v2) * dir block size
356  *    the directory bmap btree could join or split: (max depth + v2) * blocksize
357  * And the bmap_finish transaction can free the dir and bmap blocks giving:
358  *    the agf for the ag in which the blocks live: 2 * sector size
359  *    the agfl for the ag in which the blocks live: 2 * sector size
360  *    the superblock for the free block count: sector size
361  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
362  */
363 STATIC uint
364 xfs_calc_remove_reservation(
365 	struct xfs_mount	*mp)
366 {
367 	return XFS_DQUOT_LOGRES(mp) +
368 		xfs_calc_iunlink_add_reservation(mp) +
369 		max((xfs_calc_inode_res(mp, 1) +
370 		     xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
371 				      XFS_FSB_TO_B(mp, 1))),
372 		    (xfs_calc_buf_res(4, mp->m_sb.sb_sectsize) +
373 		     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
374 				      XFS_FSB_TO_B(mp, 1))));
375 }
376 
377 /*
378  * For create, break it in to the two cases that the transaction
379  * covers. We start with the modify case - allocation done by modification
380  * of the state of existing inodes - and the allocation case.
381  */
382 
383 /*
384  * For create we can modify:
385  *    the parent directory inode: inode size
386  *    the new inode: inode size
387  *    the inode btree entry: block size
388  *    the superblock for the nlink flag: sector size
389  *    the directory btree: (max depth + v2) * dir block size
390  *    the directory inode's bmap btree: (max depth + v2) * block size
391  *    the finobt (record modification and allocation btrees)
392  */
393 STATIC uint
394 xfs_calc_create_resv_modify(
395 	struct xfs_mount	*mp)
396 {
397 	return xfs_calc_inode_res(mp, 2) +
398 		xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
399 		(uint)XFS_FSB_TO_B(mp, 1) +
400 		xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp), XFS_FSB_TO_B(mp, 1)) +
401 		xfs_calc_finobt_res(mp);
402 }
403 
404 /*
405  * For icreate we can allocate some inodes giving:
406  *    the agi and agf of the ag getting the new inodes: 2 * sectorsize
407  *    the superblock for the nlink flag: sector size
408  *    the inode chunk (allocation, optional init)
409  *    the inobt (record insertion)
410  *    the finobt (optional, record insertion)
411  */
412 STATIC uint
413 xfs_calc_icreate_resv_alloc(
414 	struct xfs_mount	*mp)
415 {
416 	return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
417 		mp->m_sb.sb_sectsize +
418 		xfs_calc_inode_chunk_res(mp, _ALLOC) +
419 		xfs_calc_inobt_res(mp) +
420 		xfs_calc_finobt_res(mp);
421 }
422 
423 STATIC uint
424 xfs_calc_icreate_reservation(xfs_mount_t *mp)
425 {
426 	return XFS_DQUOT_LOGRES(mp) +
427 		max(xfs_calc_icreate_resv_alloc(mp),
428 		    xfs_calc_create_resv_modify(mp));
429 }
430 
431 STATIC uint
432 xfs_calc_create_tmpfile_reservation(
433 	struct xfs_mount        *mp)
434 {
435 	uint	res = XFS_DQUOT_LOGRES(mp);
436 
437 	res += xfs_calc_icreate_resv_alloc(mp);
438 	return res + xfs_calc_iunlink_add_reservation(mp);
439 }
440 
441 /*
442  * Making a new directory is the same as creating a new file.
443  */
444 STATIC uint
445 xfs_calc_mkdir_reservation(
446 	struct xfs_mount	*mp)
447 {
448 	return xfs_calc_icreate_reservation(mp);
449 }
450 
451 
452 /*
453  * Making a new symplink is the same as creating a new file, but
454  * with the added blocks for remote symlink data which can be up to 1kB in
455  * length (XFS_SYMLINK_MAXLEN).
456  */
457 STATIC uint
458 xfs_calc_symlink_reservation(
459 	struct xfs_mount	*mp)
460 {
461 	return xfs_calc_icreate_reservation(mp) +
462 	       xfs_calc_buf_res(1, XFS_SYMLINK_MAXLEN);
463 }
464 
465 /*
466  * In freeing an inode we can modify:
467  *    the inode being freed: inode size
468  *    the super block free inode counter, AGF and AGFL: sector size
469  *    the on disk inode (agi unlinked list removal)
470  *    the inode chunk (invalidated, headers only)
471  *    the inode btree
472  *    the finobt (record insertion, removal or modification)
473  *
474  * Note that the inode chunk res. includes an allocfree res. for freeing of the
475  * inode chunk. This is technically extraneous because the inode chunk free is
476  * deferred (it occurs after a transaction roll). Include the extra reservation
477  * anyways since we've had reports of ifree transaction overruns due to too many
478  * agfl fixups during inode chunk frees.
479  */
480 STATIC uint
481 xfs_calc_ifree_reservation(
482 	struct xfs_mount	*mp)
483 {
484 	return XFS_DQUOT_LOGRES(mp) +
485 		xfs_calc_inode_res(mp, 1) +
486 		xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
487 		xfs_calc_iunlink_remove_reservation(mp) +
488 		xfs_calc_inode_chunk_res(mp, _FREE) +
489 		xfs_calc_inobt_res(mp) +
490 		xfs_calc_finobt_res(mp);
491 }
492 
493 /*
494  * When only changing the inode we log the inode and possibly the superblock
495  * We also add a bit of slop for the transaction stuff.
496  */
497 STATIC uint
498 xfs_calc_ichange_reservation(
499 	struct xfs_mount	*mp)
500 {
501 	return XFS_DQUOT_LOGRES(mp) +
502 		xfs_calc_inode_res(mp, 1) +
503 		xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
504 
505 }
506 
507 /*
508  * Growing the data section of the filesystem.
509  *	superblock
510  *	agi and agf
511  *	allocation btrees
512  */
513 STATIC uint
514 xfs_calc_growdata_reservation(
515 	struct xfs_mount	*mp)
516 {
517 	return xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
518 		xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
519 				 XFS_FSB_TO_B(mp, 1));
520 }
521 
522 /*
523  * Growing the rt section of the filesystem.
524  * In the first set of transactions (ALLOC) we allocate space to the
525  * bitmap or summary files.
526  *	superblock: sector size
527  *	agf of the ag from which the extent is allocated: sector size
528  *	bmap btree for bitmap/summary inode: max depth * blocksize
529  *	bitmap/summary inode: inode size
530  *	allocation btrees for 1 block alloc: 2 * (2 * maxdepth - 1) * blocksize
531  */
532 STATIC uint
533 xfs_calc_growrtalloc_reservation(
534 	struct xfs_mount	*mp)
535 {
536 	return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
537 		xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
538 				 XFS_FSB_TO_B(mp, 1)) +
539 		xfs_calc_inode_res(mp, 1) +
540 		xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
541 				 XFS_FSB_TO_B(mp, 1));
542 }
543 
544 /*
545  * Growing the rt section of the filesystem.
546  * In the second set of transactions (ZERO) we zero the new metadata blocks.
547  *	one bitmap/summary block: blocksize
548  */
549 STATIC uint
550 xfs_calc_growrtzero_reservation(
551 	struct xfs_mount	*mp)
552 {
553 	return xfs_calc_buf_res(1, mp->m_sb.sb_blocksize);
554 }
555 
556 /*
557  * Growing the rt section of the filesystem.
558  * In the third set of transactions (FREE) we update metadata without
559  * allocating any new blocks.
560  *	superblock: sector size
561  *	bitmap inode: inode size
562  *	summary inode: inode size
563  *	one bitmap block: blocksize
564  *	summary blocks: new summary size
565  */
566 STATIC uint
567 xfs_calc_growrtfree_reservation(
568 	struct xfs_mount	*mp)
569 {
570 	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
571 		xfs_calc_inode_res(mp, 2) +
572 		xfs_calc_buf_res(1, mp->m_sb.sb_blocksize) +
573 		xfs_calc_buf_res(1, mp->m_rsumsize);
574 }
575 
576 /*
577  * Logging the inode modification timestamp on a synchronous write.
578  *	inode
579  */
580 STATIC uint
581 xfs_calc_swrite_reservation(
582 	struct xfs_mount	*mp)
583 {
584 	return xfs_calc_inode_res(mp, 1);
585 }
586 
587 /*
588  * Logging the inode mode bits when writing a setuid/setgid file
589  *	inode
590  */
591 STATIC uint
592 xfs_calc_writeid_reservation(
593 	struct xfs_mount	*mp)
594 {
595 	return xfs_calc_inode_res(mp, 1);
596 }
597 
598 /*
599  * Converting the inode from non-attributed to attributed.
600  *	the inode being converted: inode size
601  *	agf block and superblock (for block allocation)
602  *	the new block (directory sized)
603  *	bmap blocks for the new directory block
604  *	allocation btrees
605  */
606 STATIC uint
607 xfs_calc_addafork_reservation(
608 	struct xfs_mount	*mp)
609 {
610 	return XFS_DQUOT_LOGRES(mp) +
611 		xfs_calc_inode_res(mp, 1) +
612 		xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
613 		xfs_calc_buf_res(1, mp->m_dir_geo->blksize) +
614 		xfs_calc_buf_res(XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1,
615 				 XFS_FSB_TO_B(mp, 1)) +
616 		xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
617 				 XFS_FSB_TO_B(mp, 1));
618 }
619 
620 /*
621  * Removing the attribute fork of a file
622  *    the inode being truncated: inode size
623  *    the inode's bmap btree: max depth * block size
624  * And the bmap_finish transaction can free the blocks and bmap blocks:
625  *    the agf for each of the ags: 4 * sector size
626  *    the agfl for each of the ags: 4 * sector size
627  *    the super block to reflect the freed blocks: sector size
628  *    worst case split in allocation btrees per extent assuming 4 extents:
629  *		4 exts * 2 trees * (2 * max depth - 1) * block size
630  */
631 STATIC uint
632 xfs_calc_attrinval_reservation(
633 	struct xfs_mount	*mp)
634 {
635 	return max((xfs_calc_inode_res(mp, 1) +
636 		    xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK),
637 				     XFS_FSB_TO_B(mp, 1))),
638 		   (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
639 		    xfs_calc_buf_res(xfs_allocfree_log_count(mp, 4),
640 				     XFS_FSB_TO_B(mp, 1))));
641 }
642 
643 /*
644  * Setting an attribute at mount time.
645  *	the inode getting the attribute
646  *	the superblock for allocations
647  *	the agfs extents are allocated from
648  *	the attribute btree * max depth
649  *	the inode allocation btree
650  * Since attribute transaction space is dependent on the size of the attribute,
651  * the calculation is done partially at mount time and partially at runtime(see
652  * below).
653  */
654 STATIC uint
655 xfs_calc_attrsetm_reservation(
656 	struct xfs_mount	*mp)
657 {
658 	return XFS_DQUOT_LOGRES(mp) +
659 		xfs_calc_inode_res(mp, 1) +
660 		xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
661 		xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH, XFS_FSB_TO_B(mp, 1));
662 }
663 
664 /*
665  * Setting an attribute at runtime, transaction space unit per block.
666  * 	the superblock for allocations: sector size
667  *	the inode bmap btree could join or split: max depth * block size
668  * Since the runtime attribute transaction space is dependent on the total
669  * blocks needed for the 1st bmap, here we calculate out the space unit for
670  * one block so that the caller could figure out the total space according
671  * to the attibute extent length in blocks by:
672  *	ext * M_RES(mp)->tr_attrsetrt.tr_logres
673  */
674 STATIC uint
675 xfs_calc_attrsetrt_reservation(
676 	struct xfs_mount	*mp)
677 {
678 	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
679 		xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK),
680 				 XFS_FSB_TO_B(mp, 1));
681 }
682 
683 /*
684  * Removing an attribute.
685  *    the inode: inode size
686  *    the attribute btree could join: max depth * block size
687  *    the inode bmap btree could join or split: max depth * block size
688  * And the bmap_finish transaction can free the attr blocks freed giving:
689  *    the agf for the ag in which the blocks live: 2 * sector size
690  *    the agfl for the ag in which the blocks live: 2 * sector size
691  *    the superblock for the free block count: sector size
692  *    the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
693  */
694 STATIC uint
695 xfs_calc_attrrm_reservation(
696 	struct xfs_mount	*mp)
697 {
698 	return XFS_DQUOT_LOGRES(mp) +
699 		max((xfs_calc_inode_res(mp, 1) +
700 		     xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH,
701 				      XFS_FSB_TO_B(mp, 1)) +
702 		     (uint)XFS_FSB_TO_B(mp,
703 					XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
704 		     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK), 0)),
705 		    (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
706 		     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
707 				      XFS_FSB_TO_B(mp, 1))));
708 }
709 
710 /*
711  * Clearing a bad agino number in an agi hash bucket.
712  */
713 STATIC uint
714 xfs_calc_clear_agi_bucket_reservation(
715 	struct xfs_mount	*mp)
716 {
717 	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
718 }
719 
720 /*
721  * Adjusting quota limits.
722  *    the xfs_disk_dquot_t: sizeof(struct xfs_disk_dquot)
723  */
724 STATIC uint
725 xfs_calc_qm_setqlim_reservation(void)
726 {
727 	return xfs_calc_buf_res(1, sizeof(struct xfs_disk_dquot));
728 }
729 
730 /*
731  * Allocating quota on disk if needed.
732  *	the write transaction log space for quota file extent allocation
733  *	the unit of quota allocation: one system block size
734  */
735 STATIC uint
736 xfs_calc_qm_dqalloc_reservation(
737 	struct xfs_mount	*mp)
738 {
739 	return xfs_calc_write_reservation(mp) +
740 		xfs_calc_buf_res(1,
741 			XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB) - 1);
742 }
743 
744 /*
745  * Turning off quotas.
746  *    the xfs_qoff_logitem_t: sizeof(struct xfs_qoff_logitem) * 2
747  *    the superblock for the quota flags: sector size
748  */
749 STATIC uint
750 xfs_calc_qm_quotaoff_reservation(
751 	struct xfs_mount	*mp)
752 {
753 	return sizeof(struct xfs_qoff_logitem) * 2 +
754 		xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
755 }
756 
757 /*
758  * End of turning off quotas.
759  *    the xfs_qoff_logitem_t: sizeof(struct xfs_qoff_logitem) * 2
760  */
761 STATIC uint
762 xfs_calc_qm_quotaoff_end_reservation(void)
763 {
764 	return sizeof(struct xfs_qoff_logitem) * 2;
765 }
766 
767 /*
768  * Syncing the incore super block changes to disk.
769  *     the super block to reflect the changes: sector size
770  */
771 STATIC uint
772 xfs_calc_sb_reservation(
773 	struct xfs_mount	*mp)
774 {
775 	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
776 }
777 
778 void
779 xfs_trans_resv_calc(
780 	struct xfs_mount	*mp,
781 	struct xfs_trans_resv	*resp)
782 {
783 	/*
784 	 * The following transactions are logged in physical format and
785 	 * require a permanent reservation on space.
786 	 */
787 	resp->tr_write.tr_logres = xfs_calc_write_reservation(mp);
788 	if (xfs_sb_version_hasreflink(&mp->m_sb))
789 		resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
790 	else
791 		resp->tr_write.tr_logcount = XFS_WRITE_LOG_COUNT;
792 	resp->tr_write.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
793 
794 	resp->tr_itruncate.tr_logres = xfs_calc_itruncate_reservation(mp);
795 	if (xfs_sb_version_hasreflink(&mp->m_sb))
796 		resp->tr_itruncate.tr_logcount =
797 				XFS_ITRUNCATE_LOG_COUNT_REFLINK;
798 	else
799 		resp->tr_itruncate.tr_logcount = XFS_ITRUNCATE_LOG_COUNT;
800 	resp->tr_itruncate.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
801 
802 	resp->tr_rename.tr_logres = xfs_calc_rename_reservation(mp);
803 	resp->tr_rename.tr_logcount = XFS_RENAME_LOG_COUNT;
804 	resp->tr_rename.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
805 
806 	resp->tr_link.tr_logres = xfs_calc_link_reservation(mp);
807 	resp->tr_link.tr_logcount = XFS_LINK_LOG_COUNT;
808 	resp->tr_link.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
809 
810 	resp->tr_remove.tr_logres = xfs_calc_remove_reservation(mp);
811 	resp->tr_remove.tr_logcount = XFS_REMOVE_LOG_COUNT;
812 	resp->tr_remove.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
813 
814 	resp->tr_symlink.tr_logres = xfs_calc_symlink_reservation(mp);
815 	resp->tr_symlink.tr_logcount = XFS_SYMLINK_LOG_COUNT;
816 	resp->tr_symlink.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
817 
818 	resp->tr_create.tr_logres = xfs_calc_icreate_reservation(mp);
819 	resp->tr_create.tr_logcount = XFS_CREATE_LOG_COUNT;
820 	resp->tr_create.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
821 
822 	resp->tr_create_tmpfile.tr_logres =
823 			xfs_calc_create_tmpfile_reservation(mp);
824 	resp->tr_create_tmpfile.tr_logcount = XFS_CREATE_TMPFILE_LOG_COUNT;
825 	resp->tr_create_tmpfile.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
826 
827 	resp->tr_mkdir.tr_logres = xfs_calc_mkdir_reservation(mp);
828 	resp->tr_mkdir.tr_logcount = XFS_MKDIR_LOG_COUNT;
829 	resp->tr_mkdir.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
830 
831 	resp->tr_ifree.tr_logres = xfs_calc_ifree_reservation(mp);
832 	resp->tr_ifree.tr_logcount = XFS_INACTIVE_LOG_COUNT;
833 	resp->tr_ifree.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
834 
835 	resp->tr_addafork.tr_logres = xfs_calc_addafork_reservation(mp);
836 	resp->tr_addafork.tr_logcount = XFS_ADDAFORK_LOG_COUNT;
837 	resp->tr_addafork.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
838 
839 	resp->tr_attrinval.tr_logres = xfs_calc_attrinval_reservation(mp);
840 	resp->tr_attrinval.tr_logcount = XFS_ATTRINVAL_LOG_COUNT;
841 	resp->tr_attrinval.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
842 
843 	resp->tr_attrsetm.tr_logres = xfs_calc_attrsetm_reservation(mp);
844 	resp->tr_attrsetm.tr_logcount = XFS_ATTRSET_LOG_COUNT;
845 	resp->tr_attrsetm.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
846 
847 	resp->tr_attrrm.tr_logres = xfs_calc_attrrm_reservation(mp);
848 	resp->tr_attrrm.tr_logcount = XFS_ATTRRM_LOG_COUNT;
849 	resp->tr_attrrm.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
850 
851 	resp->tr_growrtalloc.tr_logres = xfs_calc_growrtalloc_reservation(mp);
852 	resp->tr_growrtalloc.tr_logcount = XFS_DEFAULT_PERM_LOG_COUNT;
853 	resp->tr_growrtalloc.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
854 
855 	resp->tr_qm_dqalloc.tr_logres = xfs_calc_qm_dqalloc_reservation(mp);
856 	if (xfs_sb_version_hasreflink(&mp->m_sb))
857 		resp->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT_REFLINK;
858 	else
859 		resp->tr_qm_dqalloc.tr_logcount = XFS_WRITE_LOG_COUNT;
860 	resp->tr_qm_dqalloc.tr_logflags |= XFS_TRANS_PERM_LOG_RES;
861 
862 	/*
863 	 * The following transactions are logged in logical format with
864 	 * a default log count.
865 	 */
866 	resp->tr_qm_setqlim.tr_logres = xfs_calc_qm_setqlim_reservation();
867 	resp->tr_qm_setqlim.tr_logcount = XFS_DEFAULT_LOG_COUNT;
868 
869 	resp->tr_qm_quotaoff.tr_logres = xfs_calc_qm_quotaoff_reservation(mp);
870 	resp->tr_qm_quotaoff.tr_logcount = XFS_DEFAULT_LOG_COUNT;
871 
872 	resp->tr_qm_equotaoff.tr_logres =
873 		xfs_calc_qm_quotaoff_end_reservation();
874 	resp->tr_qm_equotaoff.tr_logcount = XFS_DEFAULT_LOG_COUNT;
875 
876 	resp->tr_sb.tr_logres = xfs_calc_sb_reservation(mp);
877 	resp->tr_sb.tr_logcount = XFS_DEFAULT_LOG_COUNT;
878 
879 	/* The following transaction are logged in logical format */
880 	resp->tr_ichange.tr_logres = xfs_calc_ichange_reservation(mp);
881 	resp->tr_growdata.tr_logres = xfs_calc_growdata_reservation(mp);
882 	resp->tr_fsyncts.tr_logres = xfs_calc_swrite_reservation(mp);
883 	resp->tr_writeid.tr_logres = xfs_calc_writeid_reservation(mp);
884 	resp->tr_attrsetrt.tr_logres = xfs_calc_attrsetrt_reservation(mp);
885 	resp->tr_clearagi.tr_logres = xfs_calc_clear_agi_bucket_reservation(mp);
886 	resp->tr_growrtzero.tr_logres = xfs_calc_growrtzero_reservation(mp);
887 	resp->tr_growrtfree.tr_logres = xfs_calc_growrtfree_reservation(mp);
888 }
889