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"
24 #include "xfs_trans.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_bmap_btree.h"
31 #include "xfs_alloc_btree.h"
32 #include "xfs_ialloc_btree.h"
33 #include "xfs_dir2_sf.h"
34 #include "xfs_attr_sf.h"
35 #include "xfs_dinode.h"
36 #include "xfs_inode.h"
37 #include "xfs_inode_item.h"
39 #include "xfs_btree.h"
40 #include "xfs_ialloc.h"
41 #include "xfs_itable.h"
42 #include "xfs_dfrag.h"
43 #include "xfs_error.h"
45 #include "xfs_vnodeops.h"
48 * Syssgi interface for swapext
54 xfs_inode_t
*ip
, *tip
;
55 struct file
*file
, *target_file
;
58 sxp
= kmem_alloc(sizeof(xfs_swapext_t
), KM_MAYFAIL
);
60 error
= XFS_ERROR(ENOMEM
);
64 /* Pull information for the target fd */
65 file
= fget((int)sxp
->sx_fdtarget
);
67 error
= XFS_ERROR(EINVAL
);
71 if (!(file
->f_mode
& FMODE_WRITE
) || (file
->f_flags
& O_APPEND
)) {
72 error
= XFS_ERROR(EBADF
);
76 target_file
= fget((int)sxp
->sx_fdtmp
);
78 error
= XFS_ERROR(EINVAL
);
82 if (!(target_file
->f_mode
& FMODE_WRITE
) ||
83 (target_file
->f_flags
& O_APPEND
)) {
84 error
= XFS_ERROR(EBADF
);
85 goto out_put_target_file
;
88 ip
= XFS_I(file
->f_path
.dentry
->d_inode
);
89 tip
= XFS_I(target_file
->f_path
.dentry
->d_inode
);
91 if (ip
->i_mount
!= tip
->i_mount
) {
92 error
= XFS_ERROR(EINVAL
);
93 goto out_put_target_file
;
96 if (ip
->i_ino
== tip
->i_ino
) {
97 error
= XFS_ERROR(EINVAL
);
98 goto out_put_target_file
;
101 if (XFS_FORCED_SHUTDOWN(ip
->i_mount
)) {
102 error
= XFS_ERROR(EIO
);
103 goto out_put_target_file
;
106 error
= xfs_swap_extents(ip
, tip
, sxp
);
126 xfs_bstat_t
*sbp
= &sxp
->sx_stat
;
127 xfs_ifork_t
*tempifp
, *ifp
, *tifp
;
128 int ilf_fields
, tilf_fields
;
129 static uint lock_flags
= XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
;
138 tempifp
= kmem_alloc(sizeof(xfs_ifork_t
), KM_MAYFAIL
);
140 error
= XFS_ERROR(ENOMEM
);
147 * we have to do two separate lock calls here to keep lockdep
148 * happy. If we try to get all the locks in one call, lock will
149 * report false positives when we drop the ILOCK and regain them
152 xfs_lock_two_inodes(ip
, tip
, XFS_IOLOCK_EXCL
);
153 xfs_lock_two_inodes(ip
, tip
, XFS_ILOCK_EXCL
);
156 /* Verify that both files have the same format */
157 if ((ip
->i_d
.di_mode
& S_IFMT
) != (tip
->i_d
.di_mode
& S_IFMT
)) {
158 error
= XFS_ERROR(EINVAL
);
162 /* Verify both files are either real-time or non-realtime */
163 if (XFS_IS_REALTIME_INODE(ip
) != XFS_IS_REALTIME_INODE(tip
)) {
164 error
= XFS_ERROR(EINVAL
);
168 /* Should never get a local format */
169 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
||
170 tip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
) {
171 error
= XFS_ERROR(EINVAL
);
175 if (VN_CACHED(VFS_I(tip
)) != 0) {
176 xfs_inval_cached_trace(tip
, 0, -1, 0, -1);
177 error
= xfs_flushinval_pages(tip
, 0, -1,
183 /* Verify O_DIRECT for ftmp */
184 if (VN_CACHED(VFS_I(tip
)) != 0) {
185 error
= XFS_ERROR(EINVAL
);
189 /* Verify all data are being swapped */
190 if (sxp
->sx_offset
!= 0 ||
191 sxp
->sx_length
!= ip
->i_d
.di_size
||
192 sxp
->sx_length
!= tip
->i_d
.di_size
) {
193 error
= XFS_ERROR(EFAULT
);
198 * If the target has extended attributes, the tmp file
199 * must also in order to ensure the correct data fork
202 if ( XFS_IFORK_Q(ip
) != XFS_IFORK_Q(tip
) ) {
203 error
= XFS_ERROR(EINVAL
);
208 * Compare the current change & modify times with that
209 * passed in. If they differ, we abort this swap.
210 * This is the mechanism used to ensure the calling
211 * process that the file was not changed out from
214 if ((sbp
->bs_ctime
.tv_sec
!= ip
->i_d
.di_ctime
.t_sec
) ||
215 (sbp
->bs_ctime
.tv_nsec
!= ip
->i_d
.di_ctime
.t_nsec
) ||
216 (sbp
->bs_mtime
.tv_sec
!= ip
->i_d
.di_mtime
.t_sec
) ||
217 (sbp
->bs_mtime
.tv_nsec
!= ip
->i_d
.di_mtime
.t_nsec
)) {
218 error
= XFS_ERROR(EBUSY
);
222 /* We need to fail if the file is memory mapped. Once we have tossed
223 * all existing pages, the page fault will have no option
224 * but to go to the filesystem for pages. By making the page fault call
225 * vop_read (or write in the case of autogrow) they block on the iolock
226 * until we have switched the extents.
228 if (VN_MAPPED(VFS_I(ip
))) {
229 error
= XFS_ERROR(EBUSY
);
233 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
234 xfs_iunlock(tip
, XFS_ILOCK_EXCL
);
237 * There is a race condition here since we gave up the
238 * ilock. However, the data fork will not change since
239 * we have the iolock (locked for truncation too) so we
240 * are safe. We don't really care if non-io related
244 xfs_tosspages(ip
, 0, -1, FI_REMAPF
);
246 tp
= xfs_trans_alloc(mp
, XFS_TRANS_SWAPEXT
);
247 if ((error
= xfs_trans_reserve(tp
, 0,
248 XFS_ICHANGE_LOG_RES(mp
), 0,
250 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
251 xfs_iunlock(tip
, XFS_IOLOCK_EXCL
);
252 xfs_trans_cancel(tp
, 0);
256 xfs_lock_two_inodes(ip
, tip
, XFS_ILOCK_EXCL
);
259 * Count the number of extended attribute blocks
261 if ( ((XFS_IFORK_Q(ip
) != 0) && (ip
->i_d
.di_anextents
> 0)) &&
262 (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
263 error
= xfs_bmap_count_blocks(tp
, ip
, XFS_ATTR_FORK
, &aforkblks
);
265 xfs_trans_cancel(tp
, 0);
269 if ( ((XFS_IFORK_Q(tip
) != 0) && (tip
->i_d
.di_anextents
> 0)) &&
270 (tip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
271 error
= xfs_bmap_count_blocks(tp
, tip
, XFS_ATTR_FORK
,
274 xfs_trans_cancel(tp
, 0);
280 * Swap the data forks of the inodes
284 *tempifp
= *ifp
; /* struct copy */
285 *ifp
= *tifp
; /* struct copy */
286 *tifp
= *tempifp
; /* struct copy */
289 * Fix the on-disk inode values
291 tmp
= (__uint64_t
)ip
->i_d
.di_nblocks
;
292 ip
->i_d
.di_nblocks
= tip
->i_d
.di_nblocks
- taforkblks
+ aforkblks
;
293 tip
->i_d
.di_nblocks
= tmp
+ taforkblks
- aforkblks
;
295 tmp
= (__uint64_t
) ip
->i_d
.di_nextents
;
296 ip
->i_d
.di_nextents
= tip
->i_d
.di_nextents
;
297 tip
->i_d
.di_nextents
= tmp
;
299 tmp
= (__uint64_t
) ip
->i_d
.di_format
;
300 ip
->i_d
.di_format
= tip
->i_d
.di_format
;
301 tip
->i_d
.di_format
= tmp
;
303 ilf_fields
= XFS_ILOG_CORE
;
305 switch(ip
->i_d
.di_format
) {
306 case XFS_DINODE_FMT_EXTENTS
:
307 /* If the extents fit in the inode, fix the
308 * pointer. Otherwise it's already NULL or
309 * pointing to the extent.
311 if (ip
->i_d
.di_nextents
<= XFS_INLINE_EXTS
) {
312 ifp
->if_u1
.if_extents
=
313 ifp
->if_u2
.if_inline_ext
;
315 ilf_fields
|= XFS_ILOG_DEXT
;
317 case XFS_DINODE_FMT_BTREE
:
318 ilf_fields
|= XFS_ILOG_DBROOT
;
322 tilf_fields
= XFS_ILOG_CORE
;
324 switch(tip
->i_d
.di_format
) {
325 case XFS_DINODE_FMT_EXTENTS
:
326 /* If the extents fit in the inode, fix the
327 * pointer. Otherwise it's already NULL or
328 * pointing to the extent.
330 if (tip
->i_d
.di_nextents
<= XFS_INLINE_EXTS
) {
331 tifp
->if_u1
.if_extents
=
332 tifp
->if_u2
.if_inline_ext
;
334 tilf_fields
|= XFS_ILOG_DEXT
;
336 case XFS_DINODE_FMT_BTREE
:
337 tilf_fields
|= XFS_ILOG_DBROOT
;
343 xfs_trans_ijoin(tp
, ip
, lock_flags
);
346 xfs_trans_ijoin(tp
, tip
, lock_flags
);
348 xfs_trans_log_inode(tp
, ip
, ilf_fields
);
349 xfs_trans_log_inode(tp
, tip
, tilf_fields
);
352 * If this is a synchronous mount, make sure that the
353 * transaction goes to disk before returning to the user.
355 if (mp
->m_flags
& XFS_MOUNT_WSYNC
) {
356 xfs_trans_set_sync(tp
);
359 error
= xfs_trans_commit(tp
, XFS_TRANS_SWAPEXT
);
364 xfs_iunlock(ip
, lock_flags
);
365 xfs_iunlock(tip
, lock_flags
);