~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_fsops.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  3  * All Rights Reserved.
  4  *
  5  * This program is free software; you can redistribute it and/or
  6  * modify it under the terms of the GNU General Public License as
  7  * published by the Free Software Foundation.
  8  *
  9  * This program is distributed in the hope that it would be useful,
 10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12  * GNU General Public License for more details.
 13  *
 14  * You should have received a copy of the GNU General Public License
 15  * along with this program; if not, write the Free Software Foundation,
 16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 17  */
 18 #include "xfs.h"
 19 #include "xfs_fs.h"
 20 #include "xfs_shared.h"
 21 #include "xfs_format.h"
 22 #include "xfs_log_format.h"
 23 #include "xfs_trans_resv.h"
 24 #include "xfs_sb.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"
 30 #include "xfs_trans.h"
 31 #include "xfs_inode_item.h"
 32 #include "xfs_error.h"
 33 #include "xfs_btree.h"
 34 #include "xfs_alloc_btree.h"
 35 #include "xfs_alloc.h"
 36 #include "xfs_rmap_btree.h"
 37 #include "xfs_ialloc.h"
 38 #include "xfs_fsops.h"
 39 #include "xfs_itable.h"
 40 #include "xfs_trans_space.h"
 41 #include "xfs_rtalloc.h"
 42 #include "xfs_trace.h"
 43 #include "xfs_log.h"
 44 #include "xfs_filestream.h"
 45 #include "xfs_rmap.h"
 46 #include "xfs_ag_resv.h"
 47 
 48 /*
 49  * File system operations
 50  */
 51 
 52 int
 53 xfs_fs_geometry(
 54         xfs_mount_t             *mp,
 55         xfs_fsop_geom_t         *geo,
 56         int                     new_version)
 57 {
 58 
 59         memset(geo, 0, sizeof(*geo));
 60 
 61         geo->blocksize = mp->m_sb.sb_blocksize;
 62         geo->rtextsize = mp->m_sb.sb_rextsize;
 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         }
 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;
149 }
150 
151 static int
152 xfs_growfs_data_private(
153         xfs_mount_t             *mp,            /* mount point for filesystem */
154         xfs_growfs_data_t       *in)            /* growfs data input struct */
155 {
156         xfs_agf_t               *agf;
157         struct xfs_agfl         *agfl;
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;
167         xfs_agnumber_t          nagcount;
168         xfs_agnumber_t          nagimax = 0;
169         xfs_rfsblock_t          nb, nb_mod;
170         xfs_rfsblock_t          new;
171         xfs_rfsblock_t          nfree;
172         xfs_agnumber_t          oagcount;
173         int                     pct;
174         xfs_trans_t             *tp;
175 
176         nb = in->newblocks;
177         pct = in->imaxpct;
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)))
181                 return error;
182         dpct = pct - mp->m_sb.sb_imax_pct;
183         error = xfs_buf_read_uncached(mp->m_ddev_targp,
184                                 XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
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);
205                 if (error)
206                         return error;
207         }
208 
209         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
210                         XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
211         if (error)
212                 return error;
213 
214         /*
215          * Write new AG headers to disk. Non-transactional, but written
216          * synchronously so they are completed prior to the growfs transaction
217          * being logged.
218          */
219         nfree = 0;
220         for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
221                 __be32  *agfl_bno;
222 
223                 /*
224                  * AG freespace header block
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                 }
234 
235                 agf = XFS_BUF_TO_AGF(bp);
236                 agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
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                 }
256 
257                 agf->agf_flfirst = cpu_to_be32(1);
258                 agf->agf_fllast = 0;
259                 agf->agf_flcount = 0;
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                 }
271 
272                 error = xfs_bwrite(bp);
273                 xfs_buf_relse(bp);
274                 if (error)
275                         goto error0;
276 
277                 /*
278                  * AG freelist header block
279                  */
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                 }
354 
355                 xfs_btree_init_block(mp, bp, XFS_BTNUM_BNO, 0, 1, agno, 0);
356 
357                 arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
358                 arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
359                 arec->ar_blockcount = cpu_to_be32(
360                         agsize - be32_to_cpu(arec->ar_startblock));
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                 }
378 
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;
580         }
581 
582         /*
583          * Update changed superblock fields transactionally. These are not
584          * seen by the rest of the world until the transaction commit applies
585          * them atomically to the superblock.
586          */
587         if (nagcount > oagcount)
588                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
589         if (nb > mp->m_sb.sb_dblocks)
590                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
591                                  nb - mp->m_sb.sb_dblocks);
592         if (nfree)
593                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
594         if (dpct)
595                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
596         xfs_trans_set_sync(tp);
597         error = xfs_trans_commit(tp);
598         if (error)
599                 return error;
600 
601         /* New allocation groups fully initialized, so update mount struct */
602         if (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;
610         xfs_set_low_space_thresholds(mp);
611         mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
612 
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;
635                 /*
636                  * new secondary superblocks need to be zeroed, not read from
637                  * disk as the contents of the new area we are growing into is
638                  * completely unknown.
639                  */
640                 if (agno < oagcount) {
641                         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
642                                   XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
643                                   XFS_FSS_TO_BB(mp, 1), 0, &bp,
644                                   &xfs_sb_buf_ops);
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;
654                 }
655 
656                 /*
657                  * If we get an error reading or writing alternate superblocks,
658                  * continue.  xfs_repair chooses the "best" superblock based
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.
662                  */
663                 if (error) {
664                         xfs_warn(mp,
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                 }
681         }
682 
683  out:
684         return saved_error ? saved_error : error;
685 
686  error0:
687         xfs_trans_cancel(tp);
688         return error;
689 }
690 
691 static int
692 xfs_growfs_log_private(
693         xfs_mount_t             *mp,    /* mount point for filesystem */
694         xfs_growfs_log_t        *in)    /* growfs log input struct */
695 {
696         xfs_extlen_t            nb;
697 
698         nb = in->newblocks;
699         if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
700                 return -EINVAL;
701         if (nb == mp->m_sb.sb_logblocks &&
702             in->isint == (mp->m_sb.sb_logstart != 0))
703                 return -EINVAL;
704         /*
705          * Moving the log is hard, need new interfaces to sync
706          * the log first, hold off all activity while moving it.
707          * Can have shorter or longer log in the same space,
708          * or transform internal to external log or vice versa.
709          */
710         return -ENOSYS;
711 }
712 
713 /*
714  * protected versions of growfs function acquire and release locks on the mount
715  * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
716  * XFS_IOC_FSGROWFSRT
717  */
718 
719 
720 int
721 xfs_growfs_data(
722         xfs_mount_t             *mp,
723         xfs_growfs_data_t       *in)
724 {
725         int error;
726 
727         if (!capable(CAP_SYS_ADMIN))
728                 return -EPERM;
729         if (!mutex_trylock(&mp->m_growlock))
730                 return -EWOULDBLOCK;
731         error = xfs_growfs_data_private(mp, in);
732         /*
733          * Increment the generation unconditionally, the error could be from
734          * updating the secondary superblocks, in which case the new size
735          * is live already.
736          */
737         mp->m_generation++;
738         mutex_unlock(&mp->m_growlock);
739         return error;
740 }
741 
742 int
743 xfs_growfs_log(
744         xfs_mount_t             *mp,
745         xfs_growfs_log_t        *in)
746 {
747         int error;
748 
749         if (!capable(CAP_SYS_ADMIN))
750                 return -EPERM;
751         if (!mutex_trylock(&mp->m_growlock))
752                 return -EWOULDBLOCK;
753         error = xfs_growfs_log_private(mp, in);
754         mutex_unlock(&mp->m_growlock);
755         return error;
756 }
757 
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  *
785  * Reserve the requested number of blocks if available. Otherwise return
786  * as many as possible to satisfy the request. The actual number
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.
791  */
792 
793 int
794 xfs_reserve_blocks(
795         xfs_mount_t             *mp,
796         __uint64_t              *inval,
797         xfs_fsop_resblks_t      *outval)
798 {
799         __int64_t               lcounter, delta;
800         __int64_t               fdblks_delta = 0;
801         __uint64_t              request;
802         __int64_t               free;
803         int                     error = 0;
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 
816         /*
817          * With per-cpu counters, this becomes an interesting problem. we need
818          * to work out if we are freeing or allocation blocks first, then we can
819          * do the modification as necessary.
820          *
821          * We do this under the m_sb_lock so that if we are near ENOSPC, we will
822          * hold out any changes while we work out what to do. This means that
823          * the amount of free space can change while we do this, so we need to
824          * retry if we end up trying to reserve more space than is available.
825          */
826         spin_lock(&mp->m_sb_lock);
827 
828         /*
829          * If our previous reservation was larger than the current value,
830          * then move any unused blocks back to the free pool. Modify the resblks
831          * counters directly since we shouldn't have any problems unreserving
832          * space.
833          */
834         if (mp->m_resblks > request) {
835                 lcounter = mp->m_resblks_avail - request;
836                 if (lcounter  > 0) {            /* release unused blocks */
837                         fdblks_delta = lcounter;
838                         mp->m_resblks_avail -= lcounter;
839                 }
840                 mp->m_resblks = request;
841                 if (fdblks_delta) {
842                         spin_unlock(&mp->m_sb_lock);
843                         error = xfs_mod_fdblocks(mp, fdblks_delta, 0);
844                         spin_lock(&mp->m_sb_lock);
845                 }
846 
847                 goto out;
848         }
849 
850         /*
851          * If the request is larger than the current reservation, reserve the
852          * blocks before we update the reserve counters. Sample m_fdblocks and
853          * perform a partial reservation if the request exceeds free space.
854          */
855         error = -ENOSPC;
856         do {
857                 free = percpu_counter_sum(&mp->m_fdblocks) -
858                                                 mp->m_alloc_set_aside;
859                 if (!free)
860                         break;
861 
862                 delta = request - mp->m_resblks;
863                 lcounter = free - delta;
864                 if (lcounter < 0)
865                         /* We can't satisfy the request, just get what we can */
866                         fdblks_delta = free;
867                 else
868                         fdblks_delta = delta;
869 
870                 /*
871                  * We'll either succeed in getting space from the free block
872                  * count or we'll get an ENOSPC. If we get a ENOSPC, it means
873                  * things changed while we were calculating fdblks_delta and so
874                  * we should try again to see if there is anything left to
875                  * reserve.
876                  *
877                  * Don't set the reserved flag here - we don't want to reserve
878                  * the extra reserve blocks from the reserve.....
879                  */
880                 spin_unlock(&mp->m_sb_lock);
881                 error = xfs_mod_fdblocks(mp, -fdblks_delta, 0);
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;
892         }
893 
894 out:
895         if (outval) {
896                 outval->resblks = mp->m_resblks;
897                 outval->resblks_avail = mp->m_resblks_avail;
898         }
899 
900         spin_unlock(&mp->m_sb_lock);
901         return error;
902 }
903 
904 int
905 xfs_fs_goingdown(
906         xfs_mount_t     *mp,
907         __uint32_t      inflags)
908 {
909         switch (inflags) {
910         case XFS_FSOP_GOING_FLAGS_DEFAULT: {
911                 struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
912 
913                 if (sb && !IS_ERR(sb)) {
914                         xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
915                         thaw_bdev(sb->s_bdev, sb);
916                 }
917 
918                 break;
919         }
920         case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
921                 xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
922                 break;
923         case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
924                 xfs_force_shutdown(mp,
925                                 SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
926                 break;
927         default:
928                 return -EINVAL;
929         }
930 
931         return 0;
932 }
933 
934 /*
935  * Force a shutdown of the filesystem instantly while keeping the filesystem
936  * consistent. We don't do an unmount here; just shutdown the shop, make sure
937  * that absolutely nothing persistent happens to this filesystem after this
938  * point.
939  */
940 void
941 xfs_do_force_shutdown(
942         xfs_mount_t     *mp,
943         int             flags,
944         char            *fname,
945         int             lnnum)
946 {
947         int             logerror;
948 
949         logerror = flags & SHUTDOWN_LOG_IO_ERROR;
950 
951         if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
952                 xfs_notice(mp,
953         "%s(0x%x) called from line %d of file %s.  Return address = 0x%p",
954                         __func__, flags, lnnum, fname, __return_address);
955         }
956         /*
957          * No need to duplicate efforts.
958          */
959         if (XFS_FORCED_SHUTDOWN(mp) && !logerror)
960                 return;
961 
962         /*
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;
970 
971         if (flags & SHUTDOWN_CORRUPT_INCORE) {
972                 xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_CORRUPT,
973     "Corruption of in-memory data detected.  Shutting down filesystem");
974                 if (XFS_ERRLEVEL_HIGH <= xfs_error_level)
975                         xfs_stack_trace();
976         } else if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
977                 if (logerror) {
978                         xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_LOGERROR,
979                 "Log I/O Error Detected.  Shutting down filesystem");
980                 } else if (flags & SHUTDOWN_DEVICE_REQ) {
981                         xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
982                 "All device paths lost.  Shutting down filesystem");
983                 } else if (!(flags & SHUTDOWN_REMOTE_REQ)) {
984                         xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
985                 "I/O Error Detected. Shutting down filesystem");
986                 }
987         }
988         if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
989                 xfs_alert(mp,
990         "Please umount the filesystem and rectify the problem(s)");
991         }
992 }
993 
994 /*
995  * Reserve free space for per-AG metadata.
996  */
997 int
998 xfs_fs_reserve_ag_blocks(
999         struct xfs_mount        *mp)
1000 {
1001         xfs_agnumber_t          agno;
1002         struct xfs_perag        *pag;
1003         int                     error = 0;
1004         int                     err2;
1005 
1006         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
1007                 pag = xfs_perag_get(mp, agno);
1008                 err2 = xfs_ag_resv_init(pag);
1009                 xfs_perag_put(pag);
1010                 if (err2 && !error)
1011                         error = err2;
1012         }
1013 
1014         if (error && error != -ENOSPC) {
1015                 xfs_warn(mp,
1016         "Error %d reserving per-AG metadata reserve pool.", error);
1017                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1018         }
1019 
1020         return error;
1021 }
1022 
1023 /*
1024  * Free space reserved for per-AG metadata.
1025  */
1026 int
1027 xfs_fs_unreserve_ag_blocks(
1028         struct xfs_mount        *mp)
1029 {
1030         xfs_agnumber_t          agno;
1031         struct xfs_perag        *pag;
1032         int                     error = 0;
1033         int                     err2;
1034 
1035         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
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;
1048 }
1049 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp