Merge branch 'r8169-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/romieu...
[linux-2.6] / fs / xfs / xfs_dfrag.c
1 /*
2  * Copyright (c) 2000-2006 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_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_dir2.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"
38 #include "xfs_bmap.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"
44 #include "xfs_rw.h"
45 #include "xfs_vnodeops.h"
46
47 /*
48  * Syssgi interface for swapext
49  */
50 int
51 xfs_swapext(
52         xfs_swapext_t   __user *sxu)
53 {
54         xfs_swapext_t   *sxp;
55         xfs_inode_t     *ip, *tip;
56         struct file     *file, *target_file;
57         int             error = 0;
58
59         sxp = kmem_alloc(sizeof(xfs_swapext_t), KM_MAYFAIL);
60         if (!sxp) {
61                 error = XFS_ERROR(ENOMEM);
62                 goto out;
63         }
64
65         if (copy_from_user(sxp, sxu, sizeof(xfs_swapext_t))) {
66                 error = XFS_ERROR(EFAULT);
67                 goto out_free_sxp;
68         }
69
70         /* Pull information for the target fd */
71         file = fget((int)sxp->sx_fdtarget);
72         if (!file) {
73                 error = XFS_ERROR(EINVAL);
74                 goto out_free_sxp;
75         }
76
77         if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND)) {
78                 error = XFS_ERROR(EBADF);
79                 goto out_put_file;
80         }
81
82         target_file = fget((int)sxp->sx_fdtmp);
83         if (!target_file) {
84                 error = XFS_ERROR(EINVAL);
85                 goto out_put_file;
86         }
87
88         if (!(target_file->f_mode & FMODE_WRITE) ||
89             (target_file->f_flags & O_APPEND)) {
90                 error = XFS_ERROR(EBADF);
91                 goto out_put_target_file;
92         }
93
94         ip = XFS_I(file->f_path.dentry->d_inode);
95         tip = XFS_I(target_file->f_path.dentry->d_inode);
96
97         if (ip->i_mount != tip->i_mount) {
98                 error = XFS_ERROR(EINVAL);
99                 goto out_put_target_file;
100         }
101
102         if (ip->i_ino == tip->i_ino) {
103                 error = XFS_ERROR(EINVAL);
104                 goto out_put_target_file;
105         }
106
107         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
108                 error = XFS_ERROR(EIO);
109                 goto out_put_target_file;
110         }
111
112         error = xfs_swap_extents(ip, tip, sxp);
113
114  out_put_target_file:
115         fput(target_file);
116  out_put_file:
117         fput(file);
118  out_free_sxp:
119         kmem_free(sxp);
120  out:
121         return error;
122 }
123
124 int
125 xfs_swap_extents(
126         xfs_inode_t     *ip,
127         xfs_inode_t     *tip,
128         xfs_swapext_t   *sxp)
129 {
130         xfs_mount_t     *mp;
131         xfs_trans_t     *tp;
132         xfs_bstat_t     *sbp = &sxp->sx_stat;
133         xfs_ifork_t     *tempifp, *ifp, *tifp;
134         int             ilf_fields, tilf_fields;
135         static uint     lock_flags = XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL;
136         int             error = 0;
137         int             aforkblks = 0;
138         int             taforkblks = 0;
139         __uint64_t      tmp;
140         char            locked = 0;
141
142         mp = ip->i_mount;
143
144         tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
145         if (!tempifp) {
146                 error = XFS_ERROR(ENOMEM);
147                 goto error0;
148         }
149
150         sbp = &sxp->sx_stat;
151
152         xfs_lock_two_inodes(ip, tip, lock_flags);
153         locked = 1;
154
155         /* Verify that both files have the same format */
156         if ((ip->i_d.di_mode & S_IFMT) != (tip->i_d.di_mode & S_IFMT)) {
157                 error = XFS_ERROR(EINVAL);
158                 goto error0;
159         }
160
161         /* Verify both files are either real-time or non-realtime */
162         if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
163                 error = XFS_ERROR(EINVAL);
164                 goto error0;
165         }
166
167         /* Should never get a local format */
168         if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL ||
169             tip->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
170                 error = XFS_ERROR(EINVAL);
171                 goto error0;
172         }
173
174         if (VN_CACHED(VFS_I(tip)) != 0) {
175                 xfs_inval_cached_trace(tip, 0, -1, 0, -1);
176                 error = xfs_flushinval_pages(tip, 0, -1,
177                                 FI_REMAPF_LOCKED);
178                 if (error)
179                         goto error0;
180         }
181
182         /* Verify O_DIRECT for ftmp */
183         if (VN_CACHED(VFS_I(tip)) != 0) {
184                 error = XFS_ERROR(EINVAL);
185                 goto error0;
186         }
187
188         /* Verify all data are being swapped */
189         if (sxp->sx_offset != 0 ||
190             sxp->sx_length != ip->i_d.di_size ||
191             sxp->sx_length != tip->i_d.di_size) {
192                 error = XFS_ERROR(EFAULT);
193                 goto error0;
194         }
195
196         /*
197          * If the target has extended attributes, the tmp file
198          * must also in order to ensure the correct data fork
199          * format.
200          */
201         if ( XFS_IFORK_Q(ip) != XFS_IFORK_Q(tip) ) {
202                 error = XFS_ERROR(EINVAL);
203                 goto error0;
204         }
205
206         /*
207          * Compare the current change & modify times with that
208          * passed in.  If they differ, we abort this swap.
209          * This is the mechanism used to ensure the calling
210          * process that the file was not changed out from
211          * under it.
212          */
213         if ((sbp->bs_ctime.tv_sec != ip->i_d.di_ctime.t_sec) ||
214             (sbp->bs_ctime.tv_nsec != ip->i_d.di_ctime.t_nsec) ||
215             (sbp->bs_mtime.tv_sec != ip->i_d.di_mtime.t_sec) ||
216             (sbp->bs_mtime.tv_nsec != ip->i_d.di_mtime.t_nsec)) {
217                 error = XFS_ERROR(EBUSY);
218                 goto error0;
219         }
220
221         /* We need to fail if the file is memory mapped.  Once we have tossed
222          * all existing pages, the page fault will have no option
223          * but to go to the filesystem for pages. By making the page fault call
224          * vop_read (or write in the case of autogrow) they block on the iolock
225          * until we have switched the extents.
226          */
227         if (VN_MAPPED(VFS_I(ip))) {
228                 error = XFS_ERROR(EBUSY);
229                 goto error0;
230         }
231
232         xfs_iunlock(ip, XFS_ILOCK_EXCL);
233         xfs_iunlock(tip, XFS_ILOCK_EXCL);
234
235         /*
236          * There is a race condition here since we gave up the
237          * ilock.  However, the data fork will not change since
238          * we have the iolock (locked for truncation too) so we
239          * are safe.  We don't really care if non-io related
240          * fields change.
241          */
242
243         xfs_tosspages(ip, 0, -1, FI_REMAPF);
244
245         tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
246         if ((error = xfs_trans_reserve(tp, 0,
247                                      XFS_ICHANGE_LOG_RES(mp), 0,
248                                      0, 0))) {
249                 xfs_iunlock(ip,  XFS_IOLOCK_EXCL);
250                 xfs_iunlock(tip, XFS_IOLOCK_EXCL);
251                 xfs_trans_cancel(tp, 0);
252                 locked = 0;
253                 goto error0;
254         }
255         xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
256
257         /*
258          * Count the number of extended attribute blocks
259          */
260         if ( ((XFS_IFORK_Q(ip) != 0) && (ip->i_d.di_anextents > 0)) &&
261              (ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
262                 error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &aforkblks);
263                 if (error) {
264                         xfs_trans_cancel(tp, 0);
265                         goto error0;
266                 }
267         }
268         if ( ((XFS_IFORK_Q(tip) != 0) && (tip->i_d.di_anextents > 0)) &&
269              (tip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
270                 error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK,
271                         &taforkblks);
272                 if (error) {
273                         xfs_trans_cancel(tp, 0);
274                         goto error0;
275                 }
276         }
277
278         /*
279          * Swap the data forks of the inodes
280          */
281         ifp = &ip->i_df;
282         tifp = &tip->i_df;
283         *tempifp = *ifp;        /* struct copy */
284         *ifp = *tifp;           /* struct copy */
285         *tifp = *tempifp;       /* struct copy */
286
287         /*
288          * Fix the on-disk inode values
289          */
290         tmp = (__uint64_t)ip->i_d.di_nblocks;
291         ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks;
292         tip->i_d.di_nblocks = tmp + taforkblks - aforkblks;
293
294         tmp = (__uint64_t) ip->i_d.di_nextents;
295         ip->i_d.di_nextents = tip->i_d.di_nextents;
296         tip->i_d.di_nextents = tmp;
297
298         tmp = (__uint64_t) ip->i_d.di_format;
299         ip->i_d.di_format = tip->i_d.di_format;
300         tip->i_d.di_format = tmp;
301
302         ilf_fields = XFS_ILOG_CORE;
303
304         switch(ip->i_d.di_format) {
305         case XFS_DINODE_FMT_EXTENTS:
306                 /* If the extents fit in the inode, fix the
307                  * pointer.  Otherwise it's already NULL or
308                  * pointing to the extent.
309                  */
310                 if (ip->i_d.di_nextents <= XFS_INLINE_EXTS) {
311                         ifp->if_u1.if_extents =
312                                 ifp->if_u2.if_inline_ext;
313                 }
314                 ilf_fields |= XFS_ILOG_DEXT;
315                 break;
316         case XFS_DINODE_FMT_BTREE:
317                 ilf_fields |= XFS_ILOG_DBROOT;
318                 break;
319         }
320
321         tilf_fields = XFS_ILOG_CORE;
322
323         switch(tip->i_d.di_format) {
324         case XFS_DINODE_FMT_EXTENTS:
325                 /* If the extents fit in the inode, fix the
326                  * pointer.  Otherwise it's already NULL or
327                  * pointing to the extent.
328                  */
329                 if (tip->i_d.di_nextents <= XFS_INLINE_EXTS) {
330                         tifp->if_u1.if_extents =
331                                 tifp->if_u2.if_inline_ext;
332                 }
333                 tilf_fields |= XFS_ILOG_DEXT;
334                 break;
335         case XFS_DINODE_FMT_BTREE:
336                 tilf_fields |= XFS_ILOG_DBROOT;
337                 break;
338         }
339
340
341         IHOLD(ip);
342         xfs_trans_ijoin(tp, ip, lock_flags);
343
344         IHOLD(tip);
345         xfs_trans_ijoin(tp, tip, lock_flags);
346
347         xfs_trans_log_inode(tp, ip,  ilf_fields);
348         xfs_trans_log_inode(tp, tip, tilf_fields);
349
350         /*
351          * If this is a synchronous mount, make sure that the
352          * transaction goes to disk before returning to the user.
353          */
354         if (mp->m_flags & XFS_MOUNT_WSYNC) {
355                 xfs_trans_set_sync(tp);
356         }
357
358         error = xfs_trans_commit(tp, XFS_TRANS_SWAPEXT);
359         locked = 0;
360
361  error0:
362         if (locked) {
363                 xfs_iunlock(ip,  lock_flags);
364                 xfs_iunlock(tip, lock_flags);
365         }
366         if (tempifp != NULL)
367                 kmem_free(tempifp);
368         return error;
369 }