1 // SPDX-License-Identifier: GPL-2.0 <<
2 /* 1 /*
3 * Copyright (c) 2000-2005 Silicon Graphics, I 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 * All Rights Reserved. 3 * All Rights Reserved.
>> 4 *
>> 5 * This program is free software; you can redistribute it and/or
>> 6 * modify it under the terms of the GNU General Public License as
>> 7 * published by the Free Software Foundation.
>> 8 *
>> 9 * This program is distributed in the hope that it would be useful,
>> 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> 12 * GNU General Public License for more details.
>> 13 *
>> 14 * You should have received a copy of the GNU General Public License
>> 15 * along with this program; if not, write the Free Software Foundation,
>> 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
5 */ 17 */
6 #include "xfs.h" 18 #include "xfs.h"
7 #include "xfs_fs.h" 19 #include "xfs_fs.h"
8 #include "xfs_shared.h" 20 #include "xfs_shared.h"
9 #include "xfs_format.h" 21 #include "xfs_format.h"
10 #include "xfs_log_format.h" 22 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h" 23 #include "xfs_trans_resv.h"
12 #include "xfs_sb.h" 24 #include "xfs_sb.h"
13 #include "xfs_mount.h" 25 #include "xfs_mount.h"
>> 26 #include "xfs_defer.h"
>> 27 #include "xfs_da_format.h"
>> 28 #include "xfs_da_btree.h"
>> 29 #include "xfs_inode.h"
14 #include "xfs_trans.h" 30 #include "xfs_trans.h"
>> 31 #include "xfs_inode_item.h"
15 #include "xfs_error.h" 32 #include "xfs_error.h"
>> 33 #include "xfs_btree.h"
>> 34 #include "xfs_alloc_btree.h"
16 #include "xfs_alloc.h" 35 #include "xfs_alloc.h"
>> 36 #include "xfs_rmap_btree.h"
>> 37 #include "xfs_ialloc.h"
17 #include "xfs_fsops.h" 38 #include "xfs_fsops.h"
>> 39 #include "xfs_itable.h"
18 #include "xfs_trans_space.h" 40 #include "xfs_trans_space.h"
>> 41 #include "xfs_rtalloc.h"
>> 42 #include "xfs_trace.h"
19 #include "xfs_log.h" 43 #include "xfs_log.h"
20 #include "xfs_log_priv.h" !! 44 #include "xfs_filestream.h"
21 #include "xfs_ag.h" !! 45 #include "xfs_rmap.h"
22 #include "xfs_ag_resv.h" 46 #include "xfs_ag_resv.h"
23 #include "xfs_trace.h" <<
24 47
25 /* 48 /*
26 * Write new AG headers to disk. Non-transacti !! 49 * File system operations
27 * written and completed prior to the growfs t <<
28 * To do this, we use a delayed write buffer l <<
29 * submission and IO completion of the list as <<
30 * IO subsystem to merge all the AG headers in <<
31 * IO and hide most of the latency of the IO f <<
32 * <<
33 * This also means that if we get an error whi <<
34 * list to write, we can cancel the entire lis <<
35 * anything. <<
36 */ 50 */
37 static int <<
38 xfs_resizefs_init_new_ags( <<
39 struct xfs_trans *tp, <<
40 struct aghdr_init_data *id, <<
41 xfs_agnumber_t oagcount, <<
42 xfs_agnumber_t nagcount, <<
43 xfs_rfsblock_t delta, <<
44 struct xfs_perag *last_pag, <<
45 bool *lastag_extend <<
46 { <<
47 struct xfs_mount *mp = tp->t_mo <<
48 xfs_rfsblock_t nb = mp->m_sb. <<
49 int error; <<
50 <<
51 *lastag_extended = false; <<
52 <<
53 INIT_LIST_HEAD(&id->buffer_list); <<
54 for (id->agno = nagcount - 1; <<
55 id->agno >= oagcount; <<
56 id->agno--, delta -= id->agsize) <<
57 <<
58 if (id->agno == nagcount - 1) <<
59 id->agsize = nb - (id- <<
60 (xfs_r <<
61 else <<
62 id->agsize = mp->m_sb. <<
63 51
64 error = xfs_ag_init_headers(mp !! 52 int
65 if (error) { !! 53 xfs_fs_geometry(
66 xfs_buf_delwri_cancel( !! 54 xfs_mount_t *mp,
67 return error; !! 55 xfs_fsop_geom_t *geo,
68 } !! 56 int new_version)
69 } !! 57 {
70 58
71 error = xfs_buf_delwri_submit(&id->buf !! 59 memset(geo, 0, sizeof(*geo));
72 if (error) <<
73 return error; <<
74 60
75 if (delta) { !! 61 geo->blocksize = mp->m_sb.sb_blocksize;
76 *lastag_extended = true; !! 62 geo->rtextsize = mp->m_sb.sb_rextsize;
77 error = xfs_ag_extend_space(la !! 63 geo->agblocks = mp->m_sb.sb_agblocks;
>> 64 geo->agcount = mp->m_sb.sb_agcount;
>> 65 geo->logblocks = mp->m_sb.sb_logblocks;
>> 66 geo->sectsize = mp->m_sb.sb_sectsize;
>> 67 geo->inodesize = mp->m_sb.sb_inodesize;
>> 68 geo->imaxpct = mp->m_sb.sb_imax_pct;
>> 69 geo->datablocks = mp->m_sb.sb_dblocks;
>> 70 geo->rtblocks = mp->m_sb.sb_rblocks;
>> 71 geo->rtextents = mp->m_sb.sb_rextents;
>> 72 geo->logstart = mp->m_sb.sb_logstart;
>> 73 ASSERT(sizeof(geo->uuid)==sizeof(mp->m_sb.sb_uuid));
>> 74 memcpy(geo->uuid, &mp->m_sb.sb_uuid, sizeof(mp->m_sb.sb_uuid));
>> 75 if (new_version >= 2) {
>> 76 geo->sunit = mp->m_sb.sb_unit;
>> 77 geo->swidth = mp->m_sb.sb_width;
78 } 78 }
79 return error; !! 79 if (new_version >= 3) {
>> 80 geo->version = XFS_FSOP_GEOM_VERSION;
>> 81 geo->flags = XFS_FSOP_GEOM_FLAGS_NLINK |
>> 82 XFS_FSOP_GEOM_FLAGS_DIRV2 |
>> 83 (xfs_sb_version_hasattr(&mp->m_sb) ?
>> 84 XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
>> 85 (xfs_sb_version_hasquota(&mp->m_sb) ?
>> 86 XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
>> 87 (xfs_sb_version_hasalign(&mp->m_sb) ?
>> 88 XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
>> 89 (xfs_sb_version_hasdalign(&mp->m_sb) ?
>> 90 XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
>> 91 (xfs_sb_version_hasextflgbit(&mp->m_sb) ?
>> 92 XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
>> 93 (xfs_sb_version_hassector(&mp->m_sb) ?
>> 94 XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
>> 95 (xfs_sb_version_hasasciici(&mp->m_sb) ?
>> 96 XFS_FSOP_GEOM_FLAGS_DIRV2CI : 0) |
>> 97 (xfs_sb_version_haslazysbcount(&mp->m_sb) ?
>> 98 XFS_FSOP_GEOM_FLAGS_LAZYSB : 0) |
>> 99 (xfs_sb_version_hasattr2(&mp->m_sb) ?
>> 100 XFS_FSOP_GEOM_FLAGS_ATTR2 : 0) |
>> 101 (xfs_sb_version_hasprojid32bit(&mp->m_sb) ?
>> 102 XFS_FSOP_GEOM_FLAGS_PROJID32 : 0) |
>> 103 (xfs_sb_version_hascrc(&mp->m_sb) ?
>> 104 XFS_FSOP_GEOM_FLAGS_V5SB : 0) |
>> 105 (xfs_sb_version_hasftype(&mp->m_sb) ?
>> 106 XFS_FSOP_GEOM_FLAGS_FTYPE : 0) |
>> 107 (xfs_sb_version_hasfinobt(&mp->m_sb) ?
>> 108 XFS_FSOP_GEOM_FLAGS_FINOBT : 0) |
>> 109 (xfs_sb_version_hassparseinodes(&mp->m_sb) ?
>> 110 XFS_FSOP_GEOM_FLAGS_SPINODES : 0) |
>> 111 (xfs_sb_version_hasrmapbt(&mp->m_sb) ?
>> 112 XFS_FSOP_GEOM_FLAGS_RMAPBT : 0) |
>> 113 (xfs_sb_version_hasreflink(&mp->m_sb) ?
>> 114 XFS_FSOP_GEOM_FLAGS_REFLINK : 0);
>> 115 geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
>> 116 mp->m_sb.sb_logsectsize : BBSIZE;
>> 117 geo->rtsectsize = mp->m_sb.sb_blocksize;
>> 118 geo->dirblocksize = mp->m_dir_geo->blksize;
>> 119 }
>> 120 if (new_version >= 4) {
>> 121 geo->flags |=
>> 122 (xfs_sb_version_haslogv2(&mp->m_sb) ?
>> 123 XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
>> 124 geo->logsunit = mp->m_sb.sb_logsunit;
>> 125 }
>> 126 return 0;
>> 127 }
>> 128
>> 129 static struct xfs_buf *
>> 130 xfs_growfs_get_hdr_buf(
>> 131 struct xfs_mount *mp,
>> 132 xfs_daddr_t blkno,
>> 133 size_t numblks,
>> 134 int flags,
>> 135 const struct xfs_buf_ops *ops)
>> 136 {
>> 137 struct xfs_buf *bp;
>> 138
>> 139 bp = xfs_buf_get_uncached(mp->m_ddev_targp, numblks, flags);
>> 140 if (!bp)
>> 141 return NULL;
>> 142
>> 143 xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
>> 144 bp->b_bn = blkno;
>> 145 bp->b_maps[0].bm_bn = blkno;
>> 146 bp->b_ops = ops;
>> 147
>> 148 return bp;
80 } 149 }
81 150
82 /* <<
83 * growfs operations <<
84 */ <<
85 static int 151 static int
86 xfs_growfs_data_private( 152 xfs_growfs_data_private(
87 struct xfs_mount *mp, !! 153 xfs_mount_t *mp, /* mount point for filesystem */
88 struct xfs_growfs_data *in) !! 154 xfs_growfs_data_t *in) /* growfs data input struct */
89 { 155 {
90 xfs_agnumber_t oagcount = mp- !! 156 xfs_agf_t *agf;
91 struct xfs_buf *bp; !! 157 struct xfs_agfl *agfl;
92 int error; !! 158 xfs_agi_t *agi;
>> 159 xfs_agnumber_t agno;
>> 160 xfs_extlen_t agsize;
>> 161 xfs_extlen_t tmpsize;
>> 162 xfs_alloc_rec_t *arec;
>> 163 xfs_buf_t *bp;
>> 164 int bucket;
>> 165 int dpct;
>> 166 int error, saved_error = 0;
93 xfs_agnumber_t nagcount; 167 xfs_agnumber_t nagcount;
94 xfs_agnumber_t nagimax = 0; 168 xfs_agnumber_t nagimax = 0;
95 xfs_rfsblock_t nb, nb_div, nb !! 169 xfs_rfsblock_t nb, nb_mod;
96 int64_t delta; !! 170 xfs_rfsblock_t new;
97 bool lastag_extende !! 171 xfs_rfsblock_t nfree;
98 struct xfs_trans *tp; !! 172 xfs_agnumber_t oagcount;
99 struct aghdr_init_data id = {}; !! 173 int pct;
100 struct xfs_perag *last_pag; !! 174 xfs_trans_t *tp;
101 175
102 nb = in->newblocks; 176 nb = in->newblocks;
103 error = xfs_sb_validate_fsb_count(&mp- !! 177 pct = in->imaxpct;
104 if (error) !! 178 if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
>> 179 return -EINVAL;
>> 180 if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
105 return error; 181 return error;
106 !! 182 dpct = pct - mp->m_sb.sb_imax_pct;
107 if (nb > mp->m_sb.sb_dblocks) { !! 183 error = xfs_buf_read_uncached(mp->m_ddev_targp,
108 error = xfs_buf_read_uncached( <<
109 XFS_FSB_TO_BB( 184 XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
110 XFS_FSS_TO_BB( 185 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
>> 186 if (error)
>> 187 return error;
>> 188 xfs_buf_relse(bp);
>> 189
>> 190 new = nb; /* use new as a temporary here */
>> 191 nb_mod = do_div(new, mp->m_sb.sb_agblocks);
>> 192 nagcount = new + (nb_mod != 0);
>> 193 if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
>> 194 nagcount--;
>> 195 nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
>> 196 if (nb < mp->m_sb.sb_dblocks)
>> 197 return -EINVAL;
>> 198 }
>> 199 new = nb - mp->m_sb.sb_dblocks;
>> 200 oagcount = mp->m_sb.sb_agcount;
>> 201
>> 202 /* allocate the new per-ag structures */
>> 203 if (nagcount > oagcount) {
>> 204 error = xfs_initialize_perag(mp, nagcount, &nagimax);
111 if (error) 205 if (error)
112 return error; 206 return error;
113 xfs_buf_relse(bp); <<
114 } 207 }
115 208
116 nb_div = nb; !! 209 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
117 nb_mod = do_div(nb_div, mp->m_sb.sb_ag !! 210 XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
118 if (nb_mod && nb_mod >= XFS_MIN_AG_BLO !! 211 if (error)
119 nb_div++; !! 212 return error;
120 else if (nb_mod) !! 213
121 nb = nb_div * mp->m_sb.sb_agbl !! 214 /*
122 !! 215 * Write new AG headers to disk. Non-transactional, but written
123 if (nb_div > XFS_MAX_AGNUMBER + 1) { !! 216 * synchronously so they are completed prior to the growfs transaction
124 nb_div = XFS_MAX_AGNUMBER + 1; !! 217 * being logged.
125 nb = nb_div * mp->m_sb.sb_agbl <<
126 } <<
127 nagcount = nb_div; <<
128 delta = nb - mp->m_sb.sb_dblocks; <<
129 /* <<
130 * Reject filesystems with a single AG <<
131 * supported, and reject a shrink oper <<
132 * filesystem to become unsupported. <<
133 */ 218 */
134 if (delta < 0 && nagcount < 2) !! 219 nfree = 0;
135 return -EINVAL; !! 220 for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
>> 221 __be32 *agfl_bno;
136 222
137 /* No work to do */ !! 223 /*
138 if (delta == 0) !! 224 * AG freespace header block
139 return 0; !! 225 */
>> 226 bp = xfs_growfs_get_hdr_buf(mp,
>> 227 XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
>> 228 XFS_FSS_TO_BB(mp, 1), 0,
>> 229 &xfs_agf_buf_ops);
>> 230 if (!bp) {
>> 231 error = -ENOMEM;
>> 232 goto error0;
>> 233 }
140 234
141 /* TODO: shrinking the entire AGs hasn !! 235 agf = XFS_BUF_TO_AGF(bp);
142 if (nagcount < oagcount) !! 236 agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
143 return -EINVAL; !! 237 agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
>> 238 agf->agf_seqno = cpu_to_be32(agno);
>> 239 if (agno == nagcount - 1)
>> 240 agsize =
>> 241 nb -
>> 242 (agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
>> 243 else
>> 244 agsize = mp->m_sb.sb_agblocks;
>> 245 agf->agf_length = cpu_to_be32(agsize);
>> 246 agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
>> 247 agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
>> 248 agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
>> 249 agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
>> 250 if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
>> 251 agf->agf_roots[XFS_BTNUM_RMAPi] =
>> 252 cpu_to_be32(XFS_RMAP_BLOCK(mp));
>> 253 agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
>> 254 agf->agf_rmap_blocks = cpu_to_be32(1);
>> 255 }
144 256
145 /* allocate the new per-ag structures !! 257 agf->agf_flfirst = cpu_to_be32(1);
146 error = xfs_initialize_perag(mp, oagco !! 258 agf->agf_fllast = 0;
147 if (error) !! 259 agf->agf_flcount = 0;
148 return error; !! 260 tmpsize = agsize - mp->m_ag_prealloc_blocks;
>> 261 agf->agf_freeblks = cpu_to_be32(tmpsize);
>> 262 agf->agf_longest = cpu_to_be32(tmpsize);
>> 263 if (xfs_sb_version_hascrc(&mp->m_sb))
>> 264 uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
>> 265 if (xfs_sb_version_hasreflink(&mp->m_sb)) {
>> 266 agf->agf_refcount_root = cpu_to_be32(
>> 267 xfs_refc_block(mp));
>> 268 agf->agf_refcount_level = cpu_to_be32(1);
>> 269 agf->agf_refcount_blocks = cpu_to_be32(1);
>> 270 }
149 271
150 if (delta > 0) !! 272 error = xfs_bwrite(bp);
151 error = xfs_trans_alloc(mp, &M !! 273 xfs_buf_relse(bp);
152 XFS_GROWFS_SPA !! 274 if (error)
153 &tp); !! 275 goto error0;
154 else !! 276
155 error = xfs_trans_alloc(mp, &M !! 277 /*
156 0, &tp); !! 278 * AG freelist header block
157 if (error) !! 279 */
158 goto out_free_unused_perag; !! 280 bp = xfs_growfs_get_hdr_buf(mp,
>> 281 XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
>> 282 XFS_FSS_TO_BB(mp, 1), 0,
>> 283 &xfs_agfl_buf_ops);
>> 284 if (!bp) {
>> 285 error = -ENOMEM;
>> 286 goto error0;
>> 287 }
>> 288
>> 289 agfl = XFS_BUF_TO_AGFL(bp);
>> 290 if (xfs_sb_version_hascrc(&mp->m_sb)) {
>> 291 agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
>> 292 agfl->agfl_seqno = cpu_to_be32(agno);
>> 293 uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);
>> 294 }
>> 295
>> 296 agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);
>> 297 for (bucket = 0; bucket < XFS_AGFL_SIZE(mp); bucket++)
>> 298 agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
>> 299
>> 300 error = xfs_bwrite(bp);
>> 301 xfs_buf_relse(bp);
>> 302 if (error)
>> 303 goto error0;
>> 304
>> 305 /*
>> 306 * AG inode header block
>> 307 */
>> 308 bp = xfs_growfs_get_hdr_buf(mp,
>> 309 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
>> 310 XFS_FSS_TO_BB(mp, 1), 0,
>> 311 &xfs_agi_buf_ops);
>> 312 if (!bp) {
>> 313 error = -ENOMEM;
>> 314 goto error0;
>> 315 }
>> 316
>> 317 agi = XFS_BUF_TO_AGI(bp);
>> 318 agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
>> 319 agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
>> 320 agi->agi_seqno = cpu_to_be32(agno);
>> 321 agi->agi_length = cpu_to_be32(agsize);
>> 322 agi->agi_count = 0;
>> 323 agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
>> 324 agi->agi_level = cpu_to_be32(1);
>> 325 agi->agi_freecount = 0;
>> 326 agi->agi_newino = cpu_to_be32(NULLAGINO);
>> 327 agi->agi_dirino = cpu_to_be32(NULLAGINO);
>> 328 if (xfs_sb_version_hascrc(&mp->m_sb))
>> 329 uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);
>> 330 if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
>> 331 agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
>> 332 agi->agi_free_level = cpu_to_be32(1);
>> 333 }
>> 334 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
>> 335 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
>> 336
>> 337 error = xfs_bwrite(bp);
>> 338 xfs_buf_relse(bp);
>> 339 if (error)
>> 340 goto error0;
>> 341
>> 342 /*
>> 343 * BNO btree root block
>> 344 */
>> 345 bp = xfs_growfs_get_hdr_buf(mp,
>> 346 XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
>> 347 BTOBB(mp->m_sb.sb_blocksize), 0,
>> 348 &xfs_allocbt_buf_ops);
>> 349
>> 350 if (!bp) {
>> 351 error = -ENOMEM;
>> 352 goto error0;
>> 353 }
159 354
160 last_pag = xfs_perag_get(mp, oagcount !! 355 xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
161 if (delta > 0) { !! 356
162 error = xfs_resizefs_init_new_ !! 357 arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
163 delta, last_pa !! 358 arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
164 } else { !! 359 arec->ar_blockcount = cpu_to_be32(
165 xfs_warn_mount(mp, XFS_OPSTATE !! 360 agsize - be32_to_cpu(arec->ar_startblock));
166 "EXPERIMENTAL online shrink feature in !! 361
>> 362 error = xfs_bwrite(bp);
>> 363 xfs_buf_relse(bp);
>> 364 if (error)
>> 365 goto error0;
>> 366
>> 367 /*
>> 368 * CNT btree root block
>> 369 */
>> 370 bp = xfs_growfs_get_hdr_buf(mp,
>> 371 XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
>> 372 BTOBB(mp->m_sb.sb_blocksize), 0,
>> 373 &xfs_allocbt_buf_ops);
>> 374 if (!bp) {
>> 375 error = -ENOMEM;
>> 376 goto error0;
>> 377 }
167 378
168 error = xfs_ag_shrink_space(la !! 379 xfs_btree_init_block(mp, bp, XFS_BTNUM_CNT, 0, 1, agno, 0);
>> 380
>> 381 arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
>> 382 arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
>> 383 arec->ar_blockcount = cpu_to_be32(
>> 384 agsize - be32_to_cpu(arec->ar_startblock));
>> 385 nfree += be32_to_cpu(arec->ar_blockcount);
>> 386
>> 387 error = xfs_bwrite(bp);
>> 388 xfs_buf_relse(bp);
>> 389 if (error)
>> 390 goto error0;
>> 391
>> 392 /* RMAP btree root block */
>> 393 if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
>> 394 struct xfs_rmap_rec *rrec;
>> 395 struct xfs_btree_block *block;
>> 396
>> 397 bp = xfs_growfs_get_hdr_buf(mp,
>> 398 XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
>> 399 BTOBB(mp->m_sb.sb_blocksize), 0,
>> 400 &xfs_rmapbt_buf_ops);
>> 401 if (!bp) {
>> 402 error = -ENOMEM;
>> 403 goto error0;
>> 404 }
>> 405
>> 406 xfs_btree_init_block(mp, bp, XFS_BTNUM_RMAP, 0, 0,
>> 407 agno, 0);
>> 408 block = XFS_BUF_TO_BLOCK(bp);
>> 409
>> 410
>> 411 /*
>> 412 * mark the AG header regions as static metadata The BNO
>> 413 * btree block is the first block after the headers, so
>> 414 * it's location defines the size of region the static
>> 415 * metadata consumes.
>> 416 *
>> 417 * Note: unlike mkfs, we never have to account for log
>> 418 * space when growing the data regions
>> 419 */
>> 420 rrec = XFS_RMAP_REC_ADDR(block, 1);
>> 421 rrec->rm_startblock = 0;
>> 422 rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
>> 423 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
>> 424 rrec->rm_offset = 0;
>> 425 be16_add_cpu(&block->bb_numrecs, 1);
>> 426
>> 427 /* account freespace btree root blocks */
>> 428 rrec = XFS_RMAP_REC_ADDR(block, 2);
>> 429 rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
>> 430 rrec->rm_blockcount = cpu_to_be32(2);
>> 431 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
>> 432 rrec->rm_offset = 0;
>> 433 be16_add_cpu(&block->bb_numrecs, 1);
>> 434
>> 435 /* account inode btree root blocks */
>> 436 rrec = XFS_RMAP_REC_ADDR(block, 3);
>> 437 rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
>> 438 rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
>> 439 XFS_IBT_BLOCK(mp));
>> 440 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
>> 441 rrec->rm_offset = 0;
>> 442 be16_add_cpu(&block->bb_numrecs, 1);
>> 443
>> 444 /* account for rmap btree root */
>> 445 rrec = XFS_RMAP_REC_ADDR(block, 4);
>> 446 rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
>> 447 rrec->rm_blockcount = cpu_to_be32(1);
>> 448 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
>> 449 rrec->rm_offset = 0;
>> 450 be16_add_cpu(&block->bb_numrecs, 1);
>> 451
>> 452 /* account for refc btree root */
>> 453 if (xfs_sb_version_hasreflink(&mp->m_sb)) {
>> 454 rrec = XFS_RMAP_REC_ADDR(block, 5);
>> 455 rrec->rm_startblock = cpu_to_be32(
>> 456 xfs_refc_block(mp));
>> 457 rrec->rm_blockcount = cpu_to_be32(1);
>> 458 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
>> 459 rrec->rm_offset = 0;
>> 460 be16_add_cpu(&block->bb_numrecs, 1);
>> 461 }
>> 462
>> 463 error = xfs_bwrite(bp);
>> 464 xfs_buf_relse(bp);
>> 465 if (error)
>> 466 goto error0;
>> 467 }
>> 468
>> 469 /*
>> 470 * INO btree root block
>> 471 */
>> 472 bp = xfs_growfs_get_hdr_buf(mp,
>> 473 XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
>> 474 BTOBB(mp->m_sb.sb_blocksize), 0,
>> 475 &xfs_inobt_buf_ops);
>> 476 if (!bp) {
>> 477 error = -ENOMEM;
>> 478 goto error0;
>> 479 }
>> 480
>> 481 xfs_btree_init_block(mp, bp, XFS_BTNUM_INO , 0, 0, agno, 0);
>> 482
>> 483 error = xfs_bwrite(bp);
>> 484 xfs_buf_relse(bp);
>> 485 if (error)
>> 486 goto error0;
>> 487
>> 488 /*
>> 489 * FINO btree root block
>> 490 */
>> 491 if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
>> 492 bp = xfs_growfs_get_hdr_buf(mp,
>> 493 XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
>> 494 BTOBB(mp->m_sb.sb_blocksize), 0,
>> 495 &xfs_inobt_buf_ops);
>> 496 if (!bp) {
>> 497 error = -ENOMEM;
>> 498 goto error0;
>> 499 }
>> 500
>> 501 xfs_btree_init_block(mp, bp, XFS_BTNUM_FINO,
>> 502 0, 0, agno, 0);
>> 503
>> 504 error = xfs_bwrite(bp);
>> 505 xfs_buf_relse(bp);
>> 506 if (error)
>> 507 goto error0;
>> 508 }
>> 509
>> 510 /*
>> 511 * refcount btree root block
>> 512 */
>> 513 if (xfs_sb_version_hasreflink(&mp->m_sb)) {
>> 514 bp = xfs_growfs_get_hdr_buf(mp,
>> 515 XFS_AGB_TO_DADDR(mp, agno, xfs_refc_block(mp)),
>> 516 BTOBB(mp->m_sb.sb_blocksize), 0,
>> 517 &xfs_refcountbt_buf_ops);
>> 518 if (!bp) {
>> 519 error = -ENOMEM;
>> 520 goto error0;
>> 521 }
>> 522
>> 523 xfs_btree_init_block(mp, bp, XFS_BTNUM_REFC,
>> 524 0, 0, agno, 0);
>> 525
>> 526 error = xfs_bwrite(bp);
>> 527 xfs_buf_relse(bp);
>> 528 if (error)
>> 529 goto error0;
>> 530 }
>> 531 }
>> 532 xfs_trans_agblocks_delta(tp, nfree);
>> 533 /*
>> 534 * There are new blocks in the old last a.g.
>> 535 */
>> 536 if (new) {
>> 537 struct xfs_owner_info oinfo;
>> 538
>> 539 /*
>> 540 * Change the agi length.
>> 541 */
>> 542 error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
>> 543 if (error) {
>> 544 goto error0;
>> 545 }
>> 546 ASSERT(bp);
>> 547 agi = XFS_BUF_TO_AGI(bp);
>> 548 be32_add_cpu(&agi->agi_length, new);
>> 549 ASSERT(nagcount == oagcount ||
>> 550 be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
>> 551 xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
>> 552 /*
>> 553 * Change agf length.
>> 554 */
>> 555 error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
>> 556 if (error) {
>> 557 goto error0;
>> 558 }
>> 559 ASSERT(bp);
>> 560 agf = XFS_BUF_TO_AGF(bp);
>> 561 be32_add_cpu(&agf->agf_length, new);
>> 562 ASSERT(be32_to_cpu(agf->agf_length) ==
>> 563 be32_to_cpu(agi->agi_length));
>> 564
>> 565 xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
>> 566
>> 567 /*
>> 568 * Free the new space.
>> 569 *
>> 570 * XFS_RMAP_OWN_NULL is used here to tell the rmap btree that
>> 571 * this doesn't actually exist in the rmap btree.
>> 572 */
>> 573 xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
>> 574 error = xfs_free_extent(tp,
>> 575 XFS_AGB_TO_FSB(mp, agno,
>> 576 be32_to_cpu(agf->agf_length) - new),
>> 577 new, &oinfo, XFS_AG_RESV_NONE);
>> 578 if (error)
>> 579 goto error0;
169 } 580 }
170 xfs_perag_put(last_pag); <<
171 if (error) <<
172 goto out_trans_cancel; <<
173 581
174 /* 582 /*
175 * Update changed superblock fields tr 583 * Update changed superblock fields transactionally. These are not
176 * seen by the rest of the world until 584 * seen by the rest of the world until the transaction commit applies
177 * them atomically to the superblock. 585 * them atomically to the superblock.
178 */ 586 */
179 if (nagcount > oagcount) 587 if (nagcount > oagcount)
180 xfs_trans_mod_sb(tp, XFS_TRANS 588 xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
181 if (delta) !! 589 if (nb > mp->m_sb.sb_dblocks)
182 xfs_trans_mod_sb(tp, XFS_TRANS !! 590 xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
183 if (id.nfree) !! 591 nb - mp->m_sb.sb_dblocks);
184 xfs_trans_mod_sb(tp, XFS_TRANS !! 592 if (nfree)
185 !! 593 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
186 /* !! 594 if (dpct)
187 * Sync sb counters now to reflect the !! 595 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
188 * particularly important for shrink b <<
189 * will fail if sb_fdblocks is ever la <<
190 */ <<
191 if (xfs_has_lazysbcount(mp)) <<
192 xfs_log_sb(tp); <<
193 <<
194 xfs_trans_set_sync(tp); 596 xfs_trans_set_sync(tp);
195 error = xfs_trans_commit(tp); 597 error = xfs_trans_commit(tp);
196 if (error) 598 if (error)
197 return error; 599 return error;
198 600
199 /* New allocation groups fully initial 601 /* New allocation groups fully initialized, so update mount struct */
200 if (nagimax) 602 if (nagimax)
201 mp->m_maxagi = nagimax; 603 mp->m_maxagi = nagimax;
>> 604 if (mp->m_sb.sb_imax_pct) {
>> 605 __uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
>> 606 do_div(icount, 100);
>> 607 mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
>> 608 } else
>> 609 mp->m_maxicount = 0;
202 xfs_set_low_space_thresholds(mp); 610 xfs_set_low_space_thresholds(mp);
203 mp->m_alloc_set_aside = xfs_alloc_set_ 611 mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
204 612
205 if (delta > 0) { !! 613 /*
>> 614 * If we expanded the last AG, free the per-AG reservation
>> 615 * so we can reinitialize it with the new size.
>> 616 */
>> 617 if (new) {
>> 618 struct xfs_perag *pag;
>> 619
>> 620 pag = xfs_perag_get(mp, agno);
>> 621 error = xfs_ag_resv_free(pag);
>> 622 xfs_perag_put(pag);
>> 623 if (error)
>> 624 goto out;
>> 625 }
>> 626
>> 627 /* Reserve AG metadata blocks. */
>> 628 error = xfs_fs_reserve_ag_blocks(mp);
>> 629 if (error && error != -ENOSPC)
>> 630 goto out;
>> 631
>> 632 /* update secondary superblocks. */
>> 633 for (agno = 1; agno < nagcount; agno++) {
>> 634 error = 0;
206 /* 635 /*
207 * If we expanded the last AG, !! 636 * new secondary superblocks need to be zeroed, not read from
208 * so we can reinitialize it w !! 637 * disk as the contents of the new area we are growing into is
>> 638 * completely unknown.
209 */ 639 */
210 if (lastag_extended) { !! 640 if (agno < oagcount) {
211 struct xfs_perag !! 641 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
212 !! 642 XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
213 pag = xfs_perag_get(mp !! 643 XFS_FSS_TO_BB(mp, 1), 0, &bp,
214 xfs_ag_resv_free(pag); !! 644 &xfs_sb_buf_ops);
215 xfs_perag_put(pag); !! 645 } else {
>> 646 bp = xfs_trans_get_buf(NULL, mp->m_ddev_targp,
>> 647 XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
>> 648 XFS_FSS_TO_BB(mp, 1), 0);
>> 649 if (bp) {
>> 650 bp->b_ops = &xfs_sb_buf_ops;
>> 651 xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
>> 652 } else
>> 653 error = -ENOMEM;
216 } 654 }
>> 655
217 /* 656 /*
218 * Reserve AG metadata blocks. !! 657 * If we get an error reading or writing alternate superblocks,
219 * was a growfs failure, just !! 658 * continue. xfs_repair chooses the "best" superblock based
220 * new user data after the gro !! 659 * on most matches; if we break early, we'll leave more
>> 660 * superblocks un-updated than updated, and xfs_repair may
>> 661 * pick them over the properly-updated primary.
221 */ 662 */
222 error = xfs_fs_reserve_ag_bloc !! 663 if (error) {
223 if (error == -ENOSPC) !! 664 xfs_warn(mp,
224 error = 0; !! 665 "error %d reading secondary superblock for ag %d",
>> 666 error, agno);
>> 667 saved_error = error;
>> 668 continue;
>> 669 }
>> 670 xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
>> 671
>> 672 error = xfs_bwrite(bp);
>> 673 xfs_buf_relse(bp);
>> 674 if (error) {
>> 675 xfs_warn(mp,
>> 676 "write error %d updating secondary superblock for ag %d",
>> 677 error, agno);
>> 678 saved_error = error;
>> 679 continue;
>> 680 }
225 } 681 }
226 return error; <<
227 682
228 out_trans_cancel: !! 683 out:
>> 684 return saved_error ? saved_error : error;
>> 685
>> 686 error0:
229 xfs_trans_cancel(tp); 687 xfs_trans_cancel(tp);
230 out_free_unused_perag: <<
231 if (nagcount > oagcount) <<
232 xfs_free_perag_range(mp, oagco <<
233 return error; 688 return error;
234 } 689 }
235 690
236 static int 691 static int
237 xfs_growfs_log_private( 692 xfs_growfs_log_private(
238 struct xfs_mount *mp, /* mou !! 693 xfs_mount_t *mp, /* mount point for filesystem */
239 struct xfs_growfs_log *in) /* gro !! 694 xfs_growfs_log_t *in) /* growfs log input struct */
240 { 695 {
241 xfs_extlen_t nb; 696 xfs_extlen_t nb;
242 697
243 nb = in->newblocks; 698 nb = in->newblocks;
244 if (nb < XFS_MIN_LOG_BLOCKS || nb < XF 699 if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
245 return -EINVAL; 700 return -EINVAL;
246 if (nb == mp->m_sb.sb_logblocks && 701 if (nb == mp->m_sb.sb_logblocks &&
247 in->isint == (mp->m_sb.sb_logstart 702 in->isint == (mp->m_sb.sb_logstart != 0))
248 return -EINVAL; 703 return -EINVAL;
249 /* 704 /*
250 * Moving the log is hard, need new in 705 * Moving the log is hard, need new interfaces to sync
251 * the log first, hold off all activit 706 * the log first, hold off all activity while moving it.
252 * Can have shorter or longer log in t 707 * Can have shorter or longer log in the same space,
253 * or transform internal to external l 708 * or transform internal to external log or vice versa.
254 */ 709 */
255 return -ENOSYS; 710 return -ENOSYS;
256 } 711 }
257 712
258 static int <<
259 xfs_growfs_imaxpct( <<
260 struct xfs_mount *mp, <<
261 __u32 imaxpct) <<
262 { <<
263 struct xfs_trans *tp; <<
264 int dpct; <<
265 int error; <<
266 <<
267 if (imaxpct > 100) <<
268 return -EINVAL; <<
269 <<
270 error = xfs_trans_alloc(mp, &M_RES(mp) <<
271 XFS_GROWFS_SPACE_RES(m <<
272 if (error) <<
273 return error; <<
274 <<
275 dpct = imaxpct - mp->m_sb.sb_imax_pct; <<
276 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAX <<
277 xfs_trans_set_sync(tp); <<
278 return xfs_trans_commit(tp); <<
279 } <<
280 <<
281 /* 713 /*
282 * protected versions of growfs function acqui 714 * protected versions of growfs function acquire and release locks on the mount
283 * point - exported through ioctls: XFS_IOC_FS 715 * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
284 * XFS_IOC_FSGROWFSRT 716 * XFS_IOC_FSGROWFSRT
285 */ 717 */
>> 718
>> 719
286 int 720 int
287 xfs_growfs_data( 721 xfs_growfs_data(
288 struct xfs_mount *mp, !! 722 xfs_mount_t *mp,
289 struct xfs_growfs_data *in) !! 723 xfs_growfs_data_t *in)
290 { 724 {
291 int error = 0; !! 725 int error;
292 726
293 if (!capable(CAP_SYS_ADMIN)) 727 if (!capable(CAP_SYS_ADMIN))
294 return -EPERM; 728 return -EPERM;
295 if (!mutex_trylock(&mp->m_growlock)) 729 if (!mutex_trylock(&mp->m_growlock))
296 return -EWOULDBLOCK; 730 return -EWOULDBLOCK;
297 !! 731 error = xfs_growfs_data_private(mp, in);
298 /* update imaxpct separately to the ph <<
299 if (in->imaxpct != mp->m_sb.sb_imax_pc <<
300 error = xfs_growfs_imaxpct(mp, <<
301 if (error) <<
302 goto out_error; <<
303 } <<
304 <<
305 if (in->newblocks != mp->m_sb.sb_dbloc <<
306 error = xfs_growfs_data_privat <<
307 if (error) <<
308 goto out_error; <<
309 } <<
310 <<
311 /* Post growfs calculations needed to <<
312 if (mp->m_sb.sb_imax_pct) { <<
313 uint64_t icount = mp->m_sb.sb_ <<
314 do_div(icount, 100); <<
315 M_IGEO(mp)->maxicount = XFS_FS <<
316 } else <<
317 M_IGEO(mp)->maxicount = 0; <<
318 <<
319 /* Update secondary superblocks now th <<
320 error = xfs_update_secondary_sbs(mp); <<
321 <<
322 out_error: <<
323 /* 732 /*
324 * Increment the generation unconditio 733 * Increment the generation unconditionally, the error could be from
325 * updating the secondary superblocks, 734 * updating the secondary superblocks, in which case the new size
326 * is live already. 735 * is live already.
327 */ 736 */
328 mp->m_generation++; 737 mp->m_generation++;
329 mutex_unlock(&mp->m_growlock); 738 mutex_unlock(&mp->m_growlock);
330 return error; 739 return error;
331 } 740 }
332 741
333 int 742 int
334 xfs_growfs_log( 743 xfs_growfs_log(
335 xfs_mount_t *mp, 744 xfs_mount_t *mp,
336 struct xfs_growfs_log *in) !! 745 xfs_growfs_log_t *in)
337 { 746 {
338 int error; 747 int error;
339 748
340 if (!capable(CAP_SYS_ADMIN)) 749 if (!capable(CAP_SYS_ADMIN))
341 return -EPERM; 750 return -EPERM;
342 if (!mutex_trylock(&mp->m_growlock)) 751 if (!mutex_trylock(&mp->m_growlock))
343 return -EWOULDBLOCK; 752 return -EWOULDBLOCK;
344 error = xfs_growfs_log_private(mp, in) 753 error = xfs_growfs_log_private(mp, in);
345 mutex_unlock(&mp->m_growlock); 754 mutex_unlock(&mp->m_growlock);
346 return error; 755 return error;
347 } 756 }
348 757
349 /* 758 /*
>> 759 * exported through ioctl XFS_IOC_FSCOUNTS
>> 760 */
>> 761
>> 762 int
>> 763 xfs_fs_counts(
>> 764 xfs_mount_t *mp,
>> 765 xfs_fsop_counts_t *cnt)
>> 766 {
>> 767 cnt->allocino = percpu_counter_read_positive(&mp->m_icount);
>> 768 cnt->freeino = percpu_counter_read_positive(&mp->m_ifree);
>> 769 cnt->freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
>> 770 mp->m_alloc_set_aside;
>> 771
>> 772 spin_lock(&mp->m_sb_lock);
>> 773 cnt->freertx = mp->m_sb.sb_frextents;
>> 774 spin_unlock(&mp->m_sb_lock);
>> 775 return 0;
>> 776 }
>> 777
>> 778 /*
>> 779 * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
>> 780 *
>> 781 * xfs_reserve_blocks is called to set m_resblks
>> 782 * in the in-core mount table. The number of unused reserved blocks
>> 783 * is kept in m_resblks_avail.
>> 784 *
350 * Reserve the requested number of blocks if a 785 * Reserve the requested number of blocks if available. Otherwise return
351 * as many as possible to satisfy the request. 786 * as many as possible to satisfy the request. The actual number
352 * reserved are returned in outval. !! 787 * reserved are returned in outval
>> 788 *
>> 789 * A null inval pointer indicates that only the current reserved blocks
>> 790 * available should be returned no settings are changed.
353 */ 791 */
>> 792
354 int 793 int
355 xfs_reserve_blocks( 794 xfs_reserve_blocks(
356 struct xfs_mount *mp, !! 795 xfs_mount_t *mp,
357 uint64_t request) !! 796 __uint64_t *inval,
>> 797 xfs_fsop_resblks_t *outval)
358 { 798 {
359 int64_t lcounter, delt !! 799 __int64_t lcounter, delta;
360 int64_t fdblks_delta = !! 800 __int64_t fdblks_delta = 0;
361 int64_t free; !! 801 __uint64_t request;
>> 802 __int64_t free;
362 int error = 0; 803 int error = 0;
363 804
>> 805 /* If inval is null, report current values and return */
>> 806 if (inval == (__uint64_t *)NULL) {
>> 807 if (!outval)
>> 808 return -EINVAL;
>> 809 outval->resblks = mp->m_resblks;
>> 810 outval->resblks_avail = mp->m_resblks_avail;
>> 811 return 0;
>> 812 }
>> 813
>> 814 request = *inval;
>> 815
364 /* 816 /*
365 * With per-cpu counters, this becomes 817 * With per-cpu counters, this becomes an interesting problem. we need
366 * to work out if we are freeing or al 818 * to work out if we are freeing or allocation blocks first, then we can
367 * do the modification as necessary. 819 * do the modification as necessary.
368 * 820 *
369 * We do this under the m_sb_lock so t 821 * We do this under the m_sb_lock so that if we are near ENOSPC, we will
370 * hold out any changes while we work 822 * hold out any changes while we work out what to do. This means that
371 * the amount of free space can change 823 * the amount of free space can change while we do this, so we need to
372 * retry if we end up trying to reserv 824 * retry if we end up trying to reserve more space than is available.
373 */ 825 */
374 spin_lock(&mp->m_sb_lock); 826 spin_lock(&mp->m_sb_lock);
375 827
376 /* 828 /*
377 * If our previous reservation was lar 829 * If our previous reservation was larger than the current value,
378 * then move any unused blocks back to 830 * then move any unused blocks back to the free pool. Modify the resblks
379 * counters directly since we shouldn' 831 * counters directly since we shouldn't have any problems unreserving
380 * space. 832 * space.
381 */ 833 */
382 if (mp->m_resblks > request) { 834 if (mp->m_resblks > request) {
383 lcounter = mp->m_resblks_avail 835 lcounter = mp->m_resblks_avail - request;
384 if (lcounter > 0) { !! 836 if (lcounter > 0) { /* release unused blocks */
385 fdblks_delta = lcounte 837 fdblks_delta = lcounter;
386 mp->m_resblks_avail -= 838 mp->m_resblks_avail -= lcounter;
387 } 839 }
388 mp->m_resblks = request; 840 mp->m_resblks = request;
389 if (fdblks_delta) { 841 if (fdblks_delta) {
390 spin_unlock(&mp->m_sb_ 842 spin_unlock(&mp->m_sb_lock);
391 xfs_add_fdblocks(mp, f !! 843 error = xfs_mod_fdblocks(mp, fdblks_delta, 0);
392 spin_lock(&mp->m_sb_lo 844 spin_lock(&mp->m_sb_lock);
393 } 845 }
394 846
395 goto out; 847 goto out;
396 } 848 }
397 849
398 /* 850 /*
399 * If the request is larger than the c 851 * If the request is larger than the current reservation, reserve the
400 * blocks before we update the reserve 852 * blocks before we update the reserve counters. Sample m_fdblocks and
401 * perform a partial reservation if th 853 * perform a partial reservation if the request exceeds free space.
402 * !! 854 */
403 * The code below estimates how many b !! 855 error = -ENOSPC;
404 * fdblocks to stash in the reserve po !! 856 do {
405 * race since fdblocks updates are not !! 857 free = percpu_counter_sum(&mp->m_fdblocks) -
406 * m_sb_lock. Set the reserve size ev !! 858 mp->m_alloc_set_aside;
407 * space to fill it because mod_fdbloc !! 859 if (!free)
408 * reserve when it can. !! 860 break;
409 */ !! 861
410 free = percpu_counter_sum(&mp->m_fdblo !! 862 delta = request - mp->m_resblks;
411 !! 863 lcounter = free - delta;
412 delta = request - mp->m_resblks; !! 864 if (lcounter < 0)
413 mp->m_resblks = request; !! 865 /* We can't satisfy the request, just get what we can */
414 if (delta > 0 && free > 0) { !! 866 fdblks_delta = free;
>> 867 else
>> 868 fdblks_delta = delta;
>> 869
415 /* 870 /*
416 * We'll either succeed in get 871 * We'll either succeed in getting space from the free block
417 * count or we'll get an ENOSP !! 872 * count or we'll get an ENOSPC. If we get a ENOSPC, it means
418 * here - we don't want to res !! 873 * things changed while we were calculating fdblks_delta and so
419 * from the reserve. !! 874 * we should try again to see if there is anything left to
>> 875 * reserve.
420 * 876 *
421 * The desired reserve size ca !! 877 * Don't set the reserved flag here - we don't want to reserve
422 * Use mod_fdblocks to put the !! 878 * the extra reserve blocks from the reserve.....
423 * fdblocks as appropriate. <<
424 */ 879 */
425 fdblks_delta = min(free, delta <<
426 spin_unlock(&mp->m_sb_lock); 880 spin_unlock(&mp->m_sb_lock);
427 error = xfs_dec_fdblocks(mp, f !! 881 error = xfs_mod_fdblocks(mp, -fdblks_delta, 0);
428 if (!error) <<
429 xfs_add_fdblocks(mp, f <<
430 spin_lock(&mp->m_sb_lock); 882 spin_lock(&mp->m_sb_lock);
>> 883 } while (error == -ENOSPC);
>> 884
>> 885 /*
>> 886 * Update the reserve counters if blocks have been successfully
>> 887 * allocated.
>> 888 */
>> 889 if (!error && fdblks_delta) {
>> 890 mp->m_resblks += fdblks_delta;
>> 891 mp->m_resblks_avail += fdblks_delta;
431 } 892 }
>> 893
432 out: 894 out:
>> 895 if (outval) {
>> 896 outval->resblks = mp->m_resblks;
>> 897 outval->resblks_avail = mp->m_resblks_avail;
>> 898 }
>> 899
433 spin_unlock(&mp->m_sb_lock); 900 spin_unlock(&mp->m_sb_lock);
434 return error; 901 return error;
435 } 902 }
436 903
437 int 904 int
438 xfs_fs_goingdown( 905 xfs_fs_goingdown(
439 xfs_mount_t *mp, 906 xfs_mount_t *mp,
440 uint32_t inflags) !! 907 __uint32_t inflags)
441 { 908 {
442 switch (inflags) { 909 switch (inflags) {
443 case XFS_FSOP_GOING_FLAGS_DEFAULT: { 910 case XFS_FSOP_GOING_FLAGS_DEFAULT: {
444 if (!bdev_freeze(mp->m_super-> !! 911 struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
>> 912
>> 913 if (sb && !IS_ERR(sb)) {
445 xfs_force_shutdown(mp, 914 xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
446 bdev_thaw(mp->m_super- !! 915 thaw_bdev(sb->s_bdev, sb);
447 } 916 }
>> 917
448 break; 918 break;
449 } 919 }
450 case XFS_FSOP_GOING_FLAGS_LOGFLUSH: 920 case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
451 xfs_force_shutdown(mp, SHUTDOW 921 xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
452 break; 922 break;
453 case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH: 923 case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
454 xfs_force_shutdown(mp, 924 xfs_force_shutdown(mp,
455 SHUTDOWN_FORCE 925 SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
456 break; 926 break;
457 default: 927 default:
458 return -EINVAL; 928 return -EINVAL;
459 } 929 }
460 930
461 return 0; 931 return 0;
462 } 932 }
463 933
464 /* 934 /*
465 * Force a shutdown of the filesystem instantl 935 * Force a shutdown of the filesystem instantly while keeping the filesystem
466 * consistent. We don't do an unmount here; ju 936 * consistent. We don't do an unmount here; just shutdown the shop, make sure
467 * that absolutely nothing persistent happens 937 * that absolutely nothing persistent happens to this filesystem after this
468 * point. 938 * point.
469 * <<
470 * The shutdown state change is atomic, result <<
471 * first shutdown call processing the shutdown <<
472 * log once as it requires, and we don't spam <<
473 * shutdowns race to set the shutdown flags. <<
474 */ 939 */
475 void 940 void
476 xfs_do_force_shutdown( 941 xfs_do_force_shutdown(
477 struct xfs_mount *mp, !! 942 xfs_mount_t *mp,
478 uint32_t flags, !! 943 int flags,
479 char *fname, 944 char *fname,
480 int lnnum) 945 int lnnum)
481 { 946 {
482 int tag; !! 947 int logerror;
483 const char *why; <<
484 948
>> 949 logerror = flags & SHUTDOWN_LOG_IO_ERROR;
485 950
486 if (xfs_set_shutdown(mp)) { !! 951 if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
487 xlog_shutdown_wait(mp->m_log); !! 952 xfs_notice(mp,
488 return; !! 953 "%s(0x%x) called from line %d of file %s. Return address = 0x%p",
>> 954 __func__, flags, lnnum, fname, __return_address);
489 } 955 }
490 if (mp->m_sb_bp) !! 956 /*
491 mp->m_sb_bp->b_flags |= XBF_DO !! 957 * No need to duplicate efforts.
>> 958 */
>> 959 if (XFS_FORCED_SHUTDOWN(mp) && !logerror)
>> 960 return;
492 961
493 if (flags & SHUTDOWN_FORCE_UMOUNT) !! 962 /*
494 xfs_alert(mp, "User initiated !! 963 * This flags XFS_MOUNT_FS_SHUTDOWN, makes sure that we don't
>> 964 * queue up anybody new on the log reservations, and wakes up
>> 965 * everybody who's sleeping on log reservations to tell them
>> 966 * the bad news.
>> 967 */
>> 968 if (xfs_log_force_umount(mp, logerror))
>> 969 return;
495 970
496 if (xlog_force_shutdown(mp->m_log, fla !! 971 if (flags & SHUTDOWN_CORRUPT_INCORE) {
497 tag = XFS_PTAG_SHUTDOWN_LOGERR !! 972 xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_CORRUPT,
498 why = "Log I/O Error"; !! 973 "Corruption of in-memory data detected. Shutting down filesystem");
499 } else if (flags & SHUTDOWN_CORRUPT_IN !! 974 if (XFS_ERRLEVEL_HIGH <= xfs_error_level)
500 tag = XFS_PTAG_SHUTDOWN_CORRUP !! 975 xfs_stack_trace();
501 why = "Corruption of in-memory !! 976 } else if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
502 } else if (flags & SHUTDOWN_CORRUPT_ON !! 977 if (logerror) {
503 tag = XFS_PTAG_SHUTDOWN_CORRUP !! 978 xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_LOGERROR,
504 why = "Corruption of on-disk m !! 979 "Log I/O Error Detected. Shutting down filesystem");
505 } else if (flags & SHUTDOWN_DEVICE_REM !! 980 } else if (flags & SHUTDOWN_DEVICE_REQ) {
506 tag = XFS_PTAG_SHUTDOWN_IOERRO !! 981 xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
507 why = "Block device removal"; !! 982 "All device paths lost. Shutting down filesystem");
508 } else { !! 983 } else if (!(flags & SHUTDOWN_REMOTE_REQ)) {
509 tag = XFS_PTAG_SHUTDOWN_IOERRO !! 984 xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
510 why = "Metadata I/O Error"; !! 985 "I/O Error Detected. Shutting down filesystem");
511 } !! 986 }
512 !! 987 }
513 trace_xfs_force_shutdown(mp, tag, flag !! 988 if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
514 !! 989 xfs_alert(mp,
515 xfs_alert_tag(mp, tag, !! 990 "Please umount the filesystem and rectify the problem(s)");
516 "%s (0x%x) detected at %pS (%s:%d). Shutting !! 991 }
517 why, flags, __return_a <<
518 xfs_alert(mp, <<
519 "Please unmount the filesystem <<
520 if (xfs_error_level >= XFS_ERRLEVEL_HI <<
521 xfs_stack_trace(); <<
522 } 992 }
523 993
524 /* 994 /*
525 * Reserve free space for per-AG metadata. 995 * Reserve free space for per-AG metadata.
526 */ 996 */
527 int 997 int
528 xfs_fs_reserve_ag_blocks( 998 xfs_fs_reserve_ag_blocks(
529 struct xfs_mount *mp) 999 struct xfs_mount *mp)
530 { 1000 {
531 xfs_agnumber_t agno; 1001 xfs_agnumber_t agno;
532 struct xfs_perag *pag; 1002 struct xfs_perag *pag;
533 int error = 0; 1003 int error = 0;
534 int err2; 1004 int err2;
535 1005
536 mp->m_finobt_nores = false; !! 1006 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
537 for_each_perag(mp, agno, pag) { !! 1007 pag = xfs_perag_get(mp, agno);
538 err2 = xfs_ag_resv_init(pag, N !! 1008 err2 = xfs_ag_resv_init(pag);
>> 1009 xfs_perag_put(pag);
539 if (err2 && !error) 1010 if (err2 && !error)
540 error = err2; 1011 error = err2;
541 } 1012 }
542 1013
543 if (error && error != -ENOSPC) { 1014 if (error && error != -ENOSPC) {
544 xfs_warn(mp, 1015 xfs_warn(mp,
545 "Error %d reserving per-AG metadata re 1016 "Error %d reserving per-AG metadata reserve pool.", error);
546 xfs_force_shutdown(mp, SHUTDOW 1017 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
547 } 1018 }
548 1019
549 return error; 1020 return error;
550 } 1021 }
551 1022
552 /* 1023 /*
553 * Free space reserved for per-AG metadata. 1024 * Free space reserved for per-AG metadata.
554 */ 1025 */
555 void !! 1026 int
556 xfs_fs_unreserve_ag_blocks( 1027 xfs_fs_unreserve_ag_blocks(
557 struct xfs_mount *mp) 1028 struct xfs_mount *mp)
558 { 1029 {
559 xfs_agnumber_t agno; 1030 xfs_agnumber_t agno;
560 struct xfs_perag *pag; 1031 struct xfs_perag *pag;
>> 1032 int error = 0;
>> 1033 int err2;
561 1034
562 for_each_perag(mp, agno, pag) !! 1035 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
563 xfs_ag_resv_free(pag); !! 1036 pag = xfs_perag_get(mp, agno);
>> 1037 err2 = xfs_ag_resv_free(pag);
>> 1038 xfs_perag_put(pag);
>> 1039 if (err2 && !error)
>> 1040 error = err2;
>> 1041 }
>> 1042
>> 1043 if (error)
>> 1044 xfs_warn(mp,
>> 1045 "Error %d freeing per-AG metadata reserve pool.", error);
>> 1046
>> 1047 return error;
564 } 1048 }
565 1049
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.