2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
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.
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.
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
20 #include "xfs_types.h"
24 #include "xfs_trans.h"
29 #include "xfs_dmapi.h"
30 #include "xfs_mount.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_alloc_btree.h"
33 #include "xfs_ialloc_btree.h"
34 #include "xfs_dir_sf.h"
35 #include "xfs_dir2_sf.h"
36 #include "xfs_attr_sf.h"
37 #include "xfs_dinode.h"
38 #include "xfs_inode.h"
39 #include "xfs_inode_item.h"
40 #include "xfs_btree.h"
41 #include "xfs_error.h"
42 #include "xfs_alloc.h"
43 #include "xfs_ialloc.h"
44 #include "xfs_fsops.h"
45 #include "xfs_itable.h"
46 #include "xfs_trans_space.h"
47 #include "xfs_rtalloc.h"
51 * File system operations
60 geo
->blocksize
= mp
->m_sb
.sb_blocksize
;
61 geo
->rtextsize
= mp
->m_sb
.sb_rextsize
;
62 geo
->agblocks
= mp
->m_sb
.sb_agblocks
;
63 geo
->agcount
= mp
->m_sb
.sb_agcount
;
64 geo
->logblocks
= mp
->m_sb
.sb_logblocks
;
65 geo
->sectsize
= mp
->m_sb
.sb_sectsize
;
66 geo
->inodesize
= mp
->m_sb
.sb_inodesize
;
67 geo
->imaxpct
= mp
->m_sb
.sb_imax_pct
;
68 geo
->datablocks
= mp
->m_sb
.sb_dblocks
;
69 geo
->rtblocks
= mp
->m_sb
.sb_rblocks
;
70 geo
->rtextents
= mp
->m_sb
.sb_rextents
;
71 geo
->logstart
= mp
->m_sb
.sb_logstart
;
72 ASSERT(sizeof(geo
->uuid
)==sizeof(mp
->m_sb
.sb_uuid
));
73 memcpy(geo
->uuid
, &mp
->m_sb
.sb_uuid
, sizeof(mp
->m_sb
.sb_uuid
));
74 if (new_version
>= 2) {
75 geo
->sunit
= mp
->m_sb
.sb_unit
;
76 geo
->swidth
= mp
->m_sb
.sb_width
;
78 if (new_version
>= 3) {
79 geo
->version
= XFS_FSOP_GEOM_VERSION
;
81 (XFS_SB_VERSION_HASATTR(&mp
->m_sb
) ?
82 XFS_FSOP_GEOM_FLAGS_ATTR
: 0) |
83 (XFS_SB_VERSION_HASNLINK(&mp
->m_sb
) ?
84 XFS_FSOP_GEOM_FLAGS_NLINK
: 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_HASSHARED(&mp
->m_sb
) ?
92 XFS_FSOP_GEOM_FLAGS_SHARED
: 0) |
93 (XFS_SB_VERSION_HASEXTFLGBIT(&mp
->m_sb
) ?
94 XFS_FSOP_GEOM_FLAGS_EXTFLG
: 0) |
95 (XFS_SB_VERSION_HASDIRV2(&mp
->m_sb
) ?
96 XFS_FSOP_GEOM_FLAGS_DIRV2
: 0) |
97 (XFS_SB_VERSION_HASSECTOR(&mp
->m_sb
) ?
98 XFS_FSOP_GEOM_FLAGS_SECTOR
: 0) |
99 (XFS_SB_VERSION_HASATTR2(&mp
->m_sb
) ?
100 XFS_FSOP_GEOM_FLAGS_ATTR2
: 0);
101 geo
->logsectsize
= XFS_SB_VERSION_HASSECTOR(&mp
->m_sb
) ?
102 mp
->m_sb
.sb_logsectsize
: BBSIZE
;
103 geo
->rtsectsize
= mp
->m_sb
.sb_blocksize
;
104 geo
->dirblocksize
= mp
->m_dirblksize
;
106 if (new_version
>= 4) {
108 (XFS_SB_VERSION_HASLOGV2(&mp
->m_sb
) ?
109 XFS_FSOP_GEOM_FLAGS_LOGV2
: 0);
110 geo
->logsunit
= mp
->m_sb
.sb_logsunit
;
116 xfs_growfs_data_private(
117 xfs_mount_t
*mp
, /* mount point for filesystem */
118 xfs_growfs_data_t
*in
) /* growfs data input struct */
124 xfs_extlen_t tmpsize
;
125 xfs_alloc_rec_t
*arec
;
126 xfs_btree_sblock_t
*block
;
131 xfs_agnumber_t nagcount
;
132 xfs_agnumber_t nagimax
= 0;
133 xfs_rfsblock_t nb
, nb_mod
;
135 xfs_rfsblock_t nfree
;
136 xfs_agnumber_t oagcount
;
143 if (nb
< mp
->m_sb
.sb_dblocks
|| pct
< 0 || pct
> 100)
144 return XFS_ERROR(EINVAL
);
145 dpct
= pct
- mp
->m_sb
.sb_imax_pct
;
146 error
= xfs_read_buf(mp
, mp
->m_ddev_targp
,
147 XFS_FSB_TO_BB(mp
, nb
) - XFS_FSS_TO_BB(mp
, 1),
148 XFS_FSS_TO_BB(mp
, 1), 0, &bp
);
154 new = nb
; /* use new as a temporary here */
155 nb_mod
= do_div(new, mp
->m_sb
.sb_agblocks
);
156 nagcount
= new + (nb_mod
!= 0);
157 if (nb_mod
&& nb_mod
< XFS_MIN_AG_BLOCKS
) {
159 nb
= nagcount
* mp
->m_sb
.sb_agblocks
;
160 if (nb
< mp
->m_sb
.sb_dblocks
)
161 return XFS_ERROR(EINVAL
);
163 new = nb
- mp
->m_sb
.sb_dblocks
;
164 oagcount
= mp
->m_sb
.sb_agcount
;
165 if (nagcount
> oagcount
) {
166 down_write(&mp
->m_peraglock
);
167 mp
->m_perag
= kmem_realloc(mp
->m_perag
,
168 sizeof(xfs_perag_t
) * nagcount
,
169 sizeof(xfs_perag_t
) * oagcount
,
171 memset(&mp
->m_perag
[oagcount
], 0,
172 (nagcount
- oagcount
) * sizeof(xfs_perag_t
));
173 mp
->m_flags
|= XFS_MOUNT_32BITINODES
;
174 nagimax
= xfs_initialize_perag(mp
, nagcount
);
175 up_write(&mp
->m_peraglock
);
177 tp
= xfs_trans_alloc(mp
, XFS_TRANS_GROWFS
);
178 if ((error
= xfs_trans_reserve(tp
, XFS_GROWFS_SPACE_RES(mp
),
179 XFS_GROWDATA_LOG_RES(mp
), 0, 0, 0))) {
180 xfs_trans_cancel(tp
, 0);
185 for (agno
= nagcount
- 1; agno
>= oagcount
; agno
--, new -= agsize
) {
187 * AG freelist header block
189 bp
= xfs_buf_get(mp
->m_ddev_targp
,
190 XFS_AG_DADDR(mp
, agno
, XFS_AGF_DADDR(mp
)),
191 XFS_FSS_TO_BB(mp
, 1), 0);
192 agf
= XFS_BUF_TO_AGF(bp
);
193 memset(agf
, 0, mp
->m_sb
.sb_sectsize
);
194 INT_SET(agf
->agf_magicnum
, ARCH_CONVERT
, XFS_AGF_MAGIC
);
195 INT_SET(agf
->agf_versionnum
, ARCH_CONVERT
, XFS_AGF_VERSION
);
196 INT_SET(agf
->agf_seqno
, ARCH_CONVERT
, agno
);
197 if (agno
== nagcount
- 1)
200 (agno
* (xfs_rfsblock_t
)mp
->m_sb
.sb_agblocks
);
202 agsize
= mp
->m_sb
.sb_agblocks
;
203 INT_SET(agf
->agf_length
, ARCH_CONVERT
, agsize
);
204 INT_SET(agf
->agf_roots
[XFS_BTNUM_BNOi
], ARCH_CONVERT
,
206 INT_SET(agf
->agf_roots
[XFS_BTNUM_CNTi
], ARCH_CONVERT
,
208 INT_SET(agf
->agf_levels
[XFS_BTNUM_BNOi
], ARCH_CONVERT
, 1);
209 INT_SET(agf
->agf_levels
[XFS_BTNUM_CNTi
], ARCH_CONVERT
, 1);
210 agf
->agf_flfirst
= 0;
211 INT_SET(agf
->agf_fllast
, ARCH_CONVERT
, XFS_AGFL_SIZE(mp
) - 1);
212 agf
->agf_flcount
= 0;
213 tmpsize
= agsize
- XFS_PREALLOC_BLOCKS(mp
);
214 INT_SET(agf
->agf_freeblks
, ARCH_CONVERT
, tmpsize
);
215 INT_SET(agf
->agf_longest
, ARCH_CONVERT
, tmpsize
);
216 error
= xfs_bwrite(mp
, bp
);
221 * AG inode header block
223 bp
= xfs_buf_get(mp
->m_ddev_targp
,
224 XFS_AG_DADDR(mp
, agno
, XFS_AGI_DADDR(mp
)),
225 XFS_FSS_TO_BB(mp
, 1), 0);
226 agi
= XFS_BUF_TO_AGI(bp
);
227 memset(agi
, 0, mp
->m_sb
.sb_sectsize
);
228 INT_SET(agi
->agi_magicnum
, ARCH_CONVERT
, XFS_AGI_MAGIC
);
229 INT_SET(agi
->agi_versionnum
, ARCH_CONVERT
, XFS_AGI_VERSION
);
230 INT_SET(agi
->agi_seqno
, ARCH_CONVERT
, agno
);
231 INT_SET(agi
->agi_length
, ARCH_CONVERT
, agsize
);
233 INT_SET(agi
->agi_root
, ARCH_CONVERT
, XFS_IBT_BLOCK(mp
));
234 INT_SET(agi
->agi_level
, ARCH_CONVERT
, 1);
235 agi
->agi_freecount
= 0;
236 INT_SET(agi
->agi_newino
, ARCH_CONVERT
, NULLAGINO
);
237 INT_SET(agi
->agi_dirino
, ARCH_CONVERT
, NULLAGINO
);
238 for (bucket
= 0; bucket
< XFS_AGI_UNLINKED_BUCKETS
; bucket
++)
239 INT_SET(agi
->agi_unlinked
[bucket
], ARCH_CONVERT
,
241 error
= xfs_bwrite(mp
, bp
);
246 * BNO btree root block
248 bp
= xfs_buf_get(mp
->m_ddev_targp
,
249 XFS_AGB_TO_DADDR(mp
, agno
, XFS_BNO_BLOCK(mp
)),
250 BTOBB(mp
->m_sb
.sb_blocksize
), 0);
251 block
= XFS_BUF_TO_SBLOCK(bp
);
252 memset(block
, 0, mp
->m_sb
.sb_blocksize
);
253 INT_SET(block
->bb_magic
, ARCH_CONVERT
, XFS_ABTB_MAGIC
);
255 INT_SET(block
->bb_numrecs
, ARCH_CONVERT
, 1);
256 INT_SET(block
->bb_leftsib
, ARCH_CONVERT
, NULLAGBLOCK
);
257 INT_SET(block
->bb_rightsib
, ARCH_CONVERT
, NULLAGBLOCK
);
258 arec
= XFS_BTREE_REC_ADDR(mp
->m_sb
.sb_blocksize
, xfs_alloc
,
259 block
, 1, mp
->m_alloc_mxr
[0]);
260 INT_SET(arec
->ar_startblock
, ARCH_CONVERT
,
261 XFS_PREALLOC_BLOCKS(mp
));
262 INT_SET(arec
->ar_blockcount
, ARCH_CONVERT
,
263 agsize
- INT_GET(arec
->ar_startblock
, ARCH_CONVERT
));
264 error
= xfs_bwrite(mp
, bp
);
269 * CNT btree root block
271 bp
= xfs_buf_get(mp
->m_ddev_targp
,
272 XFS_AGB_TO_DADDR(mp
, agno
, XFS_CNT_BLOCK(mp
)),
273 BTOBB(mp
->m_sb
.sb_blocksize
), 0);
274 block
= XFS_BUF_TO_SBLOCK(bp
);
275 memset(block
, 0, mp
->m_sb
.sb_blocksize
);
276 INT_SET(block
->bb_magic
, ARCH_CONVERT
, XFS_ABTC_MAGIC
);
278 INT_SET(block
->bb_numrecs
, ARCH_CONVERT
, 1);
279 INT_SET(block
->bb_leftsib
, ARCH_CONVERT
, NULLAGBLOCK
);
280 INT_SET(block
->bb_rightsib
, ARCH_CONVERT
, NULLAGBLOCK
);
281 arec
= XFS_BTREE_REC_ADDR(mp
->m_sb
.sb_blocksize
, xfs_alloc
,
282 block
, 1, mp
->m_alloc_mxr
[0]);
283 INT_SET(arec
->ar_startblock
, ARCH_CONVERT
,
284 XFS_PREALLOC_BLOCKS(mp
));
285 INT_SET(arec
->ar_blockcount
, ARCH_CONVERT
,
286 agsize
- INT_GET(arec
->ar_startblock
, ARCH_CONVERT
));
287 nfree
+= INT_GET(arec
->ar_blockcount
, ARCH_CONVERT
);
288 error
= xfs_bwrite(mp
, bp
);
293 * INO btree root block
295 bp
= xfs_buf_get(mp
->m_ddev_targp
,
296 XFS_AGB_TO_DADDR(mp
, agno
, XFS_IBT_BLOCK(mp
)),
297 BTOBB(mp
->m_sb
.sb_blocksize
), 0);
298 block
= XFS_BUF_TO_SBLOCK(bp
);
299 memset(block
, 0, mp
->m_sb
.sb_blocksize
);
300 INT_SET(block
->bb_magic
, ARCH_CONVERT
, XFS_IBT_MAGIC
);
302 block
->bb_numrecs
= 0;
303 INT_SET(block
->bb_leftsib
, ARCH_CONVERT
, NULLAGBLOCK
);
304 INT_SET(block
->bb_rightsib
, ARCH_CONVERT
, NULLAGBLOCK
);
305 error
= xfs_bwrite(mp
, bp
);
310 xfs_trans_agblocks_delta(tp
, nfree
);
312 * There are new blocks in the old last a.g.
316 * Change the agi length.
318 error
= xfs_ialloc_read_agi(mp
, tp
, agno
, &bp
);
323 agi
= XFS_BUF_TO_AGI(bp
);
324 INT_MOD(agi
->agi_length
, ARCH_CONVERT
, new);
325 ASSERT(nagcount
== oagcount
||
326 INT_GET(agi
->agi_length
, ARCH_CONVERT
) ==
327 mp
->m_sb
.sb_agblocks
);
328 xfs_ialloc_log_agi(tp
, bp
, XFS_AGI_LENGTH
);
332 error
= xfs_alloc_read_agf(mp
, tp
, agno
, 0, &bp
);
337 agf
= XFS_BUF_TO_AGF(bp
);
338 INT_MOD(agf
->agf_length
, ARCH_CONVERT
, new);
339 ASSERT(INT_GET(agf
->agf_length
, ARCH_CONVERT
) ==
340 INT_GET(agi
->agi_length
, ARCH_CONVERT
));
342 * Free the new space.
344 error
= xfs_free_extent(tp
, XFS_AGB_TO_FSB(mp
, agno
,
345 INT_GET(agf
->agf_length
, ARCH_CONVERT
) - new), new);
350 if (nagcount
> oagcount
)
351 xfs_trans_mod_sb(tp
, XFS_TRANS_SB_AGCOUNT
, nagcount
- oagcount
);
352 if (nb
> mp
->m_sb
.sb_dblocks
)
353 xfs_trans_mod_sb(tp
, XFS_TRANS_SB_DBLOCKS
,
354 nb
- mp
->m_sb
.sb_dblocks
);
356 xfs_trans_mod_sb(tp
, XFS_TRANS_SB_FDBLOCKS
, nfree
);
358 xfs_trans_mod_sb(tp
, XFS_TRANS_SB_IMAXPCT
, dpct
);
359 error
= xfs_trans_commit(tp
, 0, NULL
);
363 /* New allocation groups fully initialized, so update mount struct */
365 mp
->m_maxagi
= nagimax
;
366 if (mp
->m_sb
.sb_imax_pct
) {
367 __uint64_t icount
= mp
->m_sb
.sb_dblocks
* mp
->m_sb
.sb_imax_pct
;
369 mp
->m_maxicount
= icount
<< mp
->m_sb
.sb_inopblog
;
372 for (agno
= 1; agno
< nagcount
; agno
++) {
373 error
= xfs_read_buf(mp
, mp
->m_ddev_targp
,
374 XFS_AGB_TO_DADDR(mp
, agno
, XFS_SB_BLOCK(mp
)),
375 XFS_FSS_TO_BB(mp
, 1), 0, &bp
);
377 xfs_fs_cmn_err(CE_WARN
, mp
,
378 "error %d reading secondary superblock for ag %d",
382 sbp
= XFS_BUF_TO_SBP(bp
);
383 xfs_xlatesb(sbp
, &mp
->m_sb
, -1, XFS_SB_ALL_BITS
);
385 * If we get an error writing out the alternate superblocks,
386 * just issue a warning and continue. The real work is
387 * already done and committed.
389 if (!(error
= xfs_bwrite(mp
, bp
))) {
392 xfs_fs_cmn_err(CE_WARN
, mp
,
393 "write error %d updating secondary superblock for ag %d",
395 break; /* no point in continuing */
401 xfs_trans_cancel(tp
, XFS_TRANS_ABORT
);
406 xfs_growfs_log_private(
407 xfs_mount_t
*mp
, /* mount point for filesystem */
408 xfs_growfs_log_t
*in
) /* growfs log input struct */
413 if (nb
< XFS_MIN_LOG_BLOCKS
|| nb
< XFS_B_TO_FSB(mp
, XFS_MIN_LOG_BYTES
))
414 return XFS_ERROR(EINVAL
);
415 if (nb
== mp
->m_sb
.sb_logblocks
&&
416 in
->isint
== (mp
->m_sb
.sb_logstart
!= 0))
417 return XFS_ERROR(EINVAL
);
419 * Moving the log is hard, need new interfaces to sync
420 * the log first, hold off all activity while moving it.
421 * Can have shorter or longer log in the same space,
422 * or transform internal to external log or vice versa.
424 return XFS_ERROR(ENOSYS
);
428 * protected versions of growfs function acquire and release locks on the mount
429 * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
437 xfs_growfs_data_t
*in
)
440 if (!cpsema(&mp
->m_growlock
))
441 return XFS_ERROR(EWOULDBLOCK
);
442 error
= xfs_growfs_data_private(mp
, in
);
443 vsema(&mp
->m_growlock
);
450 xfs_growfs_log_t
*in
)
453 if (!cpsema(&mp
->m_growlock
))
454 return XFS_ERROR(EWOULDBLOCK
);
455 error
= xfs_growfs_log_private(mp
, in
);
456 vsema(&mp
->m_growlock
);
461 * exported through ioctl XFS_IOC_FSCOUNTS
467 xfs_fsop_counts_t
*cnt
)
472 cnt
->freedata
= mp
->m_sb
.sb_fdblocks
;
473 cnt
->freertx
= mp
->m_sb
.sb_frextents
;
474 cnt
->freeino
= mp
->m_sb
.sb_ifree
;
475 cnt
->allocino
= mp
->m_sb
.sb_icount
;
476 XFS_SB_UNLOCK(mp
, s
);
481 * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
483 * xfs_reserve_blocks is called to set m_resblks
484 * in the in-core mount table. The number of unused reserved blocks
485 * is kept in m_resbls_avail.
487 * Reserve the requested number of blocks if available. Otherwise return
488 * as many as possible to satisfy the request. The actual number
489 * reserved are returned in outval
491 * A null inval pointer indicates that only the current reserved blocks
492 * available should be returned no settings are changed.
499 xfs_fsop_resblks_t
*outval
)
501 __int64_t lcounter
, delta
;
505 /* If inval is null, report current values and return */
507 if (inval
== (__uint64_t
*)NULL
) {
508 outval
->resblks
= mp
->m_resblks
;
509 outval
->resblks_avail
= mp
->m_resblks_avail
;
517 * If our previous reservation was larger than the current value,
518 * then move any unused blocks back to the free pool.
521 if (mp
->m_resblks
> request
) {
522 lcounter
= mp
->m_resblks_avail
- request
;
523 if (lcounter
> 0) { /* release unused blocks */
524 mp
->m_sb
.sb_fdblocks
+= lcounter
;
525 mp
->m_resblks_avail
-= lcounter
;
527 mp
->m_resblks
= request
;
529 delta
= request
- mp
->m_resblks
;
530 lcounter
= mp
->m_sb
.sb_fdblocks
- delta
;
532 /* We can't satisfy the request, just get what we can */
533 mp
->m_resblks
+= mp
->m_sb
.sb_fdblocks
;
534 mp
->m_resblks_avail
+= mp
->m_sb
.sb_fdblocks
;
535 mp
->m_sb
.sb_fdblocks
= 0;
537 mp
->m_sb
.sb_fdblocks
= lcounter
;
538 mp
->m_resblks
= request
;
539 mp
->m_resblks_avail
+= delta
;
543 outval
->resblks
= mp
->m_resblks
;
544 outval
->resblks_avail
= mp
->m_resblks_avail
;
545 XFS_SB_UNLOCK(mp
, s
);
555 case XFS_FSOP_GOING_FLAGS_DEFAULT
: {
556 struct vfs
*vfsp
= XFS_MTOVFS(mp
);
557 struct super_block
*sb
= freeze_bdev(vfsp
->vfs_super
->s_bdev
);
560 xfs_force_shutdown(mp
, XFS_FORCE_UMOUNT
);
561 thaw_bdev(sb
->s_bdev
, sb
);
566 case XFS_FSOP_GOING_FLAGS_LOGFLUSH
:
567 xfs_force_shutdown(mp
, XFS_FORCE_UMOUNT
);
569 case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH
:
570 xfs_force_shutdown(mp
, XFS_FORCE_UMOUNT
|XFS_LOG_IO_ERROR
);
573 return XFS_ERROR(EINVAL
);