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