2 * Copyright (c) 2000-2006 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"
22 #include "xfs_trans.h"
25 #include "xfs_mount.h"
26 #include "xfs_bmap_btree.h"
27 #include "xfs_dinode.h"
28 #include "xfs_inode.h"
29 #include "xfs_inode_item.h"
31 #include "xfs_itable.h"
32 #include "xfs_dfrag.h"
33 #include "xfs_error.h"
34 #include "xfs_vnodeops.h"
35 #include "xfs_trace.h"
38 static int xfs_swap_extents(
39 xfs_inode_t
*ip
, /* target inode */
40 xfs_inode_t
*tip
, /* tmp inode */
44 * ioctl interface for swapext
50 xfs_inode_t
*ip
, *tip
;
54 /* Pull information for the target fd */
55 f
= fdget((int)sxp
->sx_fdtarget
);
57 error
= XFS_ERROR(EINVAL
);
61 if (!(f
.file
->f_mode
& FMODE_WRITE
) ||
62 !(f
.file
->f_mode
& FMODE_READ
) ||
63 (f
.file
->f_flags
& O_APPEND
)) {
64 error
= XFS_ERROR(EBADF
);
68 tmp
= fdget((int)sxp
->sx_fdtmp
);
70 error
= XFS_ERROR(EINVAL
);
74 if (!(tmp
.file
->f_mode
& FMODE_WRITE
) ||
75 !(tmp
.file
->f_mode
& FMODE_READ
) ||
76 (tmp
.file
->f_flags
& O_APPEND
)) {
77 error
= XFS_ERROR(EBADF
);
78 goto out_put_tmp_file
;
81 if (IS_SWAPFILE(f
.file
->f_path
.dentry
->d_inode
) ||
82 IS_SWAPFILE(tmp
.file
->f_path
.dentry
->d_inode
)) {
83 error
= XFS_ERROR(EINVAL
);
84 goto out_put_tmp_file
;
87 ip
= XFS_I(f
.file
->f_path
.dentry
->d_inode
);
88 tip
= XFS_I(tmp
.file
->f_path
.dentry
->d_inode
);
90 if (ip
->i_mount
!= tip
->i_mount
) {
91 error
= XFS_ERROR(EINVAL
);
92 goto out_put_tmp_file
;
95 if (ip
->i_ino
== tip
->i_ino
) {
96 error
= XFS_ERROR(EINVAL
);
97 goto out_put_tmp_file
;
100 if (XFS_FORCED_SHUTDOWN(ip
->i_mount
)) {
101 error
= XFS_ERROR(EIO
);
102 goto out_put_tmp_file
;
105 error
= xfs_swap_extents(ip
, tip
, sxp
);
116 * We need to check that the format of the data fork in the temporary inode is
117 * valid for the target inode before doing the swap. This is not a problem with
118 * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
119 * data fork depending on the space the attribute fork is taking so we can get
120 * invalid formats on the target inode.
122 * E.g. target has space for 7 extents in extent format, temp inode only has
123 * space for 6. If we defragment down to 7 extents, then the tmp format is a
124 * btree, but when swapped it needs to be in extent format. Hence we can't just
125 * blindly swap data forks on attr2 filesystems.
127 * Note that we check the swap in both directions so that we don't end up with
128 * a corrupt temporary inode, either.
130 * Note that fixing the way xfs_fsr sets up the attribute fork in the source
131 * inode will prevent this situation from occurring, so all we do here is
132 * reject and log the attempt. basically we are putting the responsibility on
133 * userspace to get this right.
136 xfs_swap_extents_check_format(
137 xfs_inode_t
*ip
, /* target inode */
138 xfs_inode_t
*tip
) /* tmp inode */
141 /* Should never get a local format */
142 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
||
143 tip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
)
147 * if the target inode has less extents that then temporary inode then
148 * why did userspace call us?
150 if (ip
->i_d
.di_nextents
< tip
->i_d
.di_nextents
)
154 * if the target inode is in extent form and the temp inode is in btree
155 * form then we will end up with the target inode in the wrong format
156 * as we already know there are less extents in the temp inode.
158 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
159 tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
)
162 /* Check temp in extent form to max in target */
163 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
164 XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) >
165 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
168 /* Check target in extent form to max in temp */
169 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
170 XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) >
171 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
175 * If we are in a btree format, check that the temp root block will fit
176 * in the target and that it has enough extents to be in btree format
179 * Note that we have to be careful to allow btree->extent conversions
180 * (a common defrag case) which will occur when the temp inode is in
183 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
184 if (XFS_IFORK_BOFF(ip
) &&
185 tip
->i_df
.if_broot_bytes
> XFS_IFORK_BOFF(ip
))
187 if (XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) <=
188 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
192 /* Reciprocal target->temp btree format checks */
193 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
194 if (XFS_IFORK_BOFF(tip
) &&
195 ip
->i_df
.if_broot_bytes
> XFS_IFORK_BOFF(tip
))
198 if (XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) <=
199 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
208 xfs_inode_t
*ip
, /* target inode */
209 xfs_inode_t
*tip
, /* tmp inode */
212 xfs_mount_t
*mp
= ip
->i_mount
;
214 xfs_bstat_t
*sbp
= &sxp
->sx_stat
;
215 xfs_ifork_t
*tempifp
, *ifp
, *tifp
;
216 int src_log_flags
, target_log_flags
;
222 tempifp
= kmem_alloc(sizeof(xfs_ifork_t
), KM_MAYFAIL
);
224 error
= XFS_ERROR(ENOMEM
);
229 * we have to do two separate lock calls here to keep lockdep
230 * happy. If we try to get all the locks in one call, lock will
231 * report false positives when we drop the ILOCK and regain them
234 xfs_lock_two_inodes(ip
, tip
, XFS_IOLOCK_EXCL
);
235 xfs_lock_two_inodes(ip
, tip
, XFS_ILOCK_EXCL
);
237 /* Verify that both files have the same format */
238 if ((ip
->i_d
.di_mode
& S_IFMT
) != (tip
->i_d
.di_mode
& S_IFMT
)) {
239 error
= XFS_ERROR(EINVAL
);
243 /* Verify both files are either real-time or non-realtime */
244 if (XFS_IS_REALTIME_INODE(ip
) != XFS_IS_REALTIME_INODE(tip
)) {
245 error
= XFS_ERROR(EINVAL
);
249 error
= -filemap_write_and_wait(VFS_I(ip
)->i_mapping
);
252 truncate_pagecache_range(VFS_I(ip
), 0, -1);
254 /* Verify O_DIRECT for ftmp */
255 if (VN_CACHED(VFS_I(tip
)) != 0) {
256 error
= XFS_ERROR(EINVAL
);
260 /* Verify all data are being swapped */
261 if (sxp
->sx_offset
!= 0 ||
262 sxp
->sx_length
!= ip
->i_d
.di_size
||
263 sxp
->sx_length
!= tip
->i_d
.di_size
) {
264 error
= XFS_ERROR(EFAULT
);
268 trace_xfs_swap_extent_before(ip
, 0);
269 trace_xfs_swap_extent_before(tip
, 1);
271 /* check inode formats now that data is flushed */
272 error
= xfs_swap_extents_check_format(ip
, tip
);
275 "%s: inode 0x%llx format is incompatible for exchanging.",
276 __func__
, ip
->i_ino
);
281 * Compare the current change & modify times with that
282 * passed in. If they differ, we abort this swap.
283 * This is the mechanism used to ensure the calling
284 * process that the file was not changed out from
287 if ((sbp
->bs_ctime
.tv_sec
!= VFS_I(ip
)->i_ctime
.tv_sec
) ||
288 (sbp
->bs_ctime
.tv_nsec
!= VFS_I(ip
)->i_ctime
.tv_nsec
) ||
289 (sbp
->bs_mtime
.tv_sec
!= VFS_I(ip
)->i_mtime
.tv_sec
) ||
290 (sbp
->bs_mtime
.tv_nsec
!= VFS_I(ip
)->i_mtime
.tv_nsec
)) {
291 error
= XFS_ERROR(EBUSY
);
295 /* We need to fail if the file is memory mapped. Once we have tossed
296 * all existing pages, the page fault will have no option
297 * but to go to the filesystem for pages. By making the page fault call
298 * vop_read (or write in the case of autogrow) they block on the iolock
299 * until we have switched the extents.
301 if (VN_MAPPED(VFS_I(ip
))) {
302 error
= XFS_ERROR(EBUSY
);
306 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
307 xfs_iunlock(tip
, XFS_ILOCK_EXCL
);
310 * There is a race condition here since we gave up the
311 * ilock. However, the data fork will not change since
312 * we have the iolock (locked for truncation too) so we
313 * are safe. We don't really care if non-io related
316 truncate_pagecache_range(VFS_I(ip
), 0, -1);
318 tp
= xfs_trans_alloc(mp
, XFS_TRANS_SWAPEXT
);
319 if ((error
= xfs_trans_reserve(tp
, 0,
320 XFS_ICHANGE_LOG_RES(mp
), 0,
322 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
323 xfs_iunlock(tip
, XFS_IOLOCK_EXCL
);
324 xfs_trans_cancel(tp
, 0);
327 xfs_lock_two_inodes(ip
, tip
, XFS_ILOCK_EXCL
);
330 * Count the number of extended attribute blocks
332 if ( ((XFS_IFORK_Q(ip
) != 0) && (ip
->i_d
.di_anextents
> 0)) &&
333 (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
334 error
= xfs_bmap_count_blocks(tp
, ip
, XFS_ATTR_FORK
, &aforkblks
);
336 goto out_trans_cancel
;
338 if ( ((XFS_IFORK_Q(tip
) != 0) && (tip
->i_d
.di_anextents
> 0)) &&
339 (tip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
340 error
= xfs_bmap_count_blocks(tp
, tip
, XFS_ATTR_FORK
,
343 goto out_trans_cancel
;
347 * Swap the data forks of the inodes
351 *tempifp
= *ifp
; /* struct copy */
352 *ifp
= *tifp
; /* struct copy */
353 *tifp
= *tempifp
; /* struct copy */
356 * Fix the on-disk inode values
358 tmp
= (__uint64_t
)ip
->i_d
.di_nblocks
;
359 ip
->i_d
.di_nblocks
= tip
->i_d
.di_nblocks
- taforkblks
+ aforkblks
;
360 tip
->i_d
.di_nblocks
= tmp
+ taforkblks
- aforkblks
;
362 tmp
= (__uint64_t
) ip
->i_d
.di_nextents
;
363 ip
->i_d
.di_nextents
= tip
->i_d
.di_nextents
;
364 tip
->i_d
.di_nextents
= tmp
;
366 tmp
= (__uint64_t
) ip
->i_d
.di_format
;
367 ip
->i_d
.di_format
= tip
->i_d
.di_format
;
368 tip
->i_d
.di_format
= tmp
;
371 * The extents in the source inode could still contain speculative
372 * preallocation beyond EOF (e.g. the file is open but not modified
373 * while defrag is in progress). In that case, we need to copy over the
374 * number of delalloc blocks the data fork in the source inode is
375 * tracking beyond EOF so that when the fork is truncated away when the
376 * temporary inode is unlinked we don't underrun the i_delayed_blks
377 * counter on that inode.
379 ASSERT(tip
->i_delayed_blks
== 0);
380 tip
->i_delayed_blks
= ip
->i_delayed_blks
;
381 ip
->i_delayed_blks
= 0;
383 src_log_flags
= XFS_ILOG_CORE
;
384 switch (ip
->i_d
.di_format
) {
385 case XFS_DINODE_FMT_EXTENTS
:
386 /* If the extents fit in the inode, fix the
387 * pointer. Otherwise it's already NULL or
388 * pointing to the extent.
390 if (ip
->i_d
.di_nextents
<= XFS_INLINE_EXTS
) {
391 ifp
->if_u1
.if_extents
=
392 ifp
->if_u2
.if_inline_ext
;
394 src_log_flags
|= XFS_ILOG_DEXT
;
396 case XFS_DINODE_FMT_BTREE
:
397 src_log_flags
|= XFS_ILOG_DBROOT
;
401 target_log_flags
= XFS_ILOG_CORE
;
402 switch (tip
->i_d
.di_format
) {
403 case XFS_DINODE_FMT_EXTENTS
:
404 /* If the extents fit in the inode, fix the
405 * pointer. Otherwise it's already NULL or
406 * pointing to the extent.
408 if (tip
->i_d
.di_nextents
<= XFS_INLINE_EXTS
) {
409 tifp
->if_u1
.if_extents
=
410 tifp
->if_u2
.if_inline_ext
;
412 target_log_flags
|= XFS_ILOG_DEXT
;
414 case XFS_DINODE_FMT_BTREE
:
415 target_log_flags
|= XFS_ILOG_DBROOT
;
420 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);
421 xfs_trans_ijoin(tp
, tip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);
423 xfs_trans_log_inode(tp
, ip
, src_log_flags
);
424 xfs_trans_log_inode(tp
, tip
, target_log_flags
);
427 * If this is a synchronous mount, make sure that the
428 * transaction goes to disk before returning to the user.
430 if (mp
->m_flags
& XFS_MOUNT_WSYNC
)
431 xfs_trans_set_sync(tp
);
433 error
= xfs_trans_commit(tp
, 0);
435 trace_xfs_swap_extent_after(ip
, 0);
436 trace_xfs_swap_extent_after(tip
, 1);
442 xfs_iunlock(ip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);
443 xfs_iunlock(tip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);
447 xfs_trans_cancel(tp
, 0);