block: make gendisk hold a reference to its queue
[linux-2.6.git] / 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_mount.h"
28 #include "xfs_bmap_btree.h"
29 #include "xfs_dinode.h"
30 #include "xfs_inode.h"
31 #include "xfs_inode_item.h"
32 #include "xfs_bmap.h"
33 #include "xfs_itable.h"
34 #include "xfs_dfrag.h"
35 #include "xfs_error.h"
36 #include "xfs_vnodeops.h"
37 #include "xfs_trace.h"
38
39
40 static int xfs_swap_extents(
41         xfs_inode_t     *ip,    /* target inode */
42         xfs_inode_t     *tip,   /* tmp inode */
43         xfs_swapext_t   *sxp);
44
45 /*
46  * ioctl interface for swapext
47  */
48 int
49 xfs_swapext(
50         xfs_swapext_t   *sxp)
51 {
52         xfs_inode_t     *ip, *tip;
53         struct file     *file, *tmp_file;
54         int             error = 0;
55
56         /* Pull information for the target fd */
57         file = fget((int)sxp->sx_fdtarget);
58         if (!file) {
59                 error = XFS_ERROR(EINVAL);
60                 goto out;
61         }
62
63         if (!(file->f_mode & FMODE_WRITE) ||
64             !(file->f_mode & FMODE_READ) ||
65             (file->f_flags & O_APPEND)) {
66                 error = XFS_ERROR(EBADF);
67                 goto out_put_file;
68         }
69
70         tmp_file = fget((int)sxp->sx_fdtmp);
71         if (!tmp_file) {
72                 error = XFS_ERROR(EINVAL);
73                 goto out_put_file;
74         }
75
76         if (!(tmp_file->f_mode & FMODE_WRITE) ||
77             !(tmp_file->f_mode & FMODE_READ) ||
78             (tmp_file->f_flags & O_APPEND)) {
79                 error = XFS_ERROR(EBADF);
80                 goto out_put_tmp_file;
81         }
82
83         if (IS_SWAPFILE(file->f_path.dentry->d_inode) ||
84             IS_SWAPFILE(tmp_file->f_path.dentry->d_inode)) {
85                 error = XFS_ERROR(EINVAL);
86                 goto out_put_tmp_file;
87         }
88
89         ip = XFS_I(file->f_path.dentry->d_inode);
90         tip = XFS_I(tmp_file->f_path.dentry->d_inode);
91
92         if (ip->i_mount != tip->i_mount) {
93                 error = XFS_ERROR(EINVAL);
94                 goto out_put_tmp_file;
95         }
96
97         if (ip->i_ino == tip->i_ino) {
98                 error = XFS_ERROR(EINVAL);
99                 goto out_put_tmp_file;
100         }
101
102         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
103                 error = XFS_ERROR(EIO);
104                 goto out_put_tmp_file;
105         }
106
107         error = xfs_swap_extents(ip, tip, sxp);
108
109  out_put_tmp_file:
110         fput(tmp_file);
111  out_put_file:
112         fput(file);
113  out:
114         return error;
115 }
116
117 /*
118  * We need to check that the format of the data fork in the temporary inode is
119  * valid for the target inode before doing the swap. This is not a problem with
120  * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
121  * data fork depending on the space the attribute fork is taking so we can get
122  * invalid formats on the target inode.
123  *
124  * E.g. target has space for 7 extents in extent format, temp inode only has
125  * space for 6.  If we defragment down to 7 extents, then the tmp format is a
126  * btree, but when swapped it needs to be in extent format. Hence we can't just
127  * blindly swap data forks on attr2 filesystems.
128  *
129  * Note that we check the swap in both directions so that we don't end up with
130  * a corrupt temporary inode, either.
131  *
132  * Note that fixing the way xfs_fsr sets up the attribute fork in the source
133  * inode will prevent this situation from occurring, so all we do here is
134  * reject and log the attempt. basically we are putting the responsibility on
135  * userspace to get this right.
136  */
137 static int
138 xfs_swap_extents_check_format(
139         xfs_inode_t     *ip,    /* target inode */
140         xfs_inode_t     *tip)   /* tmp inode */
141 {
142
143         /* Should never get a local format */
144         if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL ||
145             tip->i_d.di_format == XFS_DINODE_FMT_LOCAL)
146                 return EINVAL;
147
148         /*
149          * if the target inode has less extents that then temporary inode then
150          * why did userspace call us?
151          */
152         if (ip->i_d.di_nextents < tip->i_d.di_nextents)
153                 return EINVAL;
154
155         /*
156          * if the target inode is in extent form and the temp inode is in btree
157          * form then we will end up with the target inode in the wrong format
158          * as we already know there are less extents in the temp inode.
159          */
160         if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
161             tip->i_d.di_format == XFS_DINODE_FMT_BTREE)
162                 return EINVAL;
163
164         /* Check temp in extent form to max in target */
165         if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
166             XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) > ip->i_df.if_ext_max)
167                 return EINVAL;
168
169         /* Check target in extent form to max in temp */
170         if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
171             XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) > tip->i_df.if_ext_max)
172                 return EINVAL;
173
174         /*
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
177          * in the target.
178          *
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
181          * extent format...
182          */
183         if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE &&
184             ((XFS_IFORK_BOFF(ip) &&
185               tip->i_df.if_broot_bytes > XFS_IFORK_BOFF(ip)) ||
186              XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <= ip->i_df.if_ext_max))
187                 return EINVAL;
188
189         /* Reciprocal target->temp btree format checks */
190         if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE &&
191             ((XFS_IFORK_BOFF(tip) &&
192               ip->i_df.if_broot_bytes > XFS_IFORK_BOFF(tip)) ||
193              XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <= tip->i_df.if_ext_max))
194                 return EINVAL;
195
196         return 0;
197 }
198
199 static int
200 xfs_swap_extents(
201         xfs_inode_t     *ip,    /* target inode */
202         xfs_inode_t     *tip,   /* tmp inode */
203         xfs_swapext_t   *sxp)
204 {
205         xfs_mount_t     *mp = ip->i_mount;
206         xfs_trans_t     *tp;
207         xfs_bstat_t     *sbp = &sxp->sx_stat;
208         xfs_ifork_t     *tempifp, *ifp, *tifp;
209         int             ilf_fields, tilf_fields;
210         int             error = 0;
211         int             aforkblks = 0;
212         int             taforkblks = 0;
213         __uint64_t      tmp;
214
215         tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
216         if (!tempifp) {
217                 error = XFS_ERROR(ENOMEM);
218                 goto out;
219         }
220
221         /*
222          * we have to do two separate lock calls here to keep lockdep
223          * happy. If we try to get all the locks in one call, lock will
224          * report false positives when we drop the ILOCK and regain them
225          * below.
226          */
227         xfs_lock_two_inodes(ip, tip, XFS_IOLOCK_EXCL);
228         xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
229
230         /* Verify that both files have the same format */
231         if ((ip->i_d.di_mode & S_IFMT) != (tip->i_d.di_mode & S_IFMT)) {
232                 error = XFS_ERROR(EINVAL);
233                 goto out_unlock;
234         }
235
236         /* Verify both files are either real-time or non-realtime */
237         if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
238                 error = XFS_ERROR(EINVAL);
239                 goto out_unlock;
240         }
241
242         if (VN_CACHED(VFS_I(tip)) != 0) {
243                 error = xfs_flushinval_pages(tip, 0, -1,
244                                 FI_REMAPF_LOCKED);
245                 if (error)
246                         goto out_unlock;
247         }
248
249         /* Verify O_DIRECT for ftmp */
250         if (VN_CACHED(VFS_I(tip)) != 0) {
251                 error = XFS_ERROR(EINVAL);
252                 goto out_unlock;
253         }
254
255         /* Verify all data are being swapped */
256         if (sxp->sx_offset != 0 ||
257             sxp->sx_length != ip->i_d.di_size ||
258             sxp->sx_length != tip->i_d.di_size) {
259                 error = XFS_ERROR(EFAULT);
260                 goto out_unlock;
261         }
262
263         trace_xfs_swap_extent_before(ip, 0);
264         trace_xfs_swap_extent_before(tip, 1);
265
266         /* check inode formats now that data is flushed */
267         error = xfs_swap_extents_check_format(ip, tip);
268         if (error) {
269                 xfs_notice(mp,
270                     "%s: inode 0x%llx format is incompatible for exchanging.",
271                                 __func__, ip->i_ino);
272                 goto out_unlock;
273         }
274
275         /*
276          * Compare the current change & modify times with that
277          * passed in.  If they differ, we abort this swap.
278          * This is the mechanism used to ensure the calling
279          * process that the file was not changed out from
280          * under it.
281          */
282         if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
283             (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
284             (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
285             (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
286                 error = XFS_ERROR(EBUSY);
287                 goto out_unlock;
288         }
289
290         /* We need to fail if the file is memory mapped.  Once we have tossed
291          * all existing pages, the page fault will have no option
292          * but to go to the filesystem for pages. By making the page fault call
293          * vop_read (or write in the case of autogrow) they block on the iolock
294          * until we have switched the extents.
295          */
296         if (VN_MAPPED(VFS_I(ip))) {
297                 error = XFS_ERROR(EBUSY);
298                 goto out_unlock;
299         }
300
301         xfs_iunlock(ip, XFS_ILOCK_EXCL);
302         xfs_iunlock(tip, XFS_ILOCK_EXCL);
303
304         /*
305          * There is a race condition here since we gave up the
306          * ilock.  However, the data fork will not change since
307          * we have the iolock (locked for truncation too) so we
308          * are safe.  We don't really care if non-io related
309          * fields change.
310          */
311
312         xfs_tosspages(ip, 0, -1, FI_REMAPF);
313
314         tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
315         if ((error = xfs_trans_reserve(tp, 0,
316                                      XFS_ICHANGE_LOG_RES(mp), 0,
317                                      0, 0))) {
318                 xfs_iunlock(ip,  XFS_IOLOCK_EXCL);
319                 xfs_iunlock(tip, XFS_IOLOCK_EXCL);
320                 xfs_trans_cancel(tp, 0);
321                 goto out;
322         }
323         xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
324
325         /*
326          * Count the number of extended attribute blocks
327          */
328         if ( ((XFS_IFORK_Q(ip) != 0) && (ip->i_d.di_anextents > 0)) &&
329              (ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
330                 error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &aforkblks);
331                 if (error)
332                         goto out_trans_cancel;
333         }
334         if ( ((XFS_IFORK_Q(tip) != 0) && (tip->i_d.di_anextents > 0)) &&
335              (tip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
336                 error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK,
337                         &taforkblks);
338                 if (error)
339                         goto out_trans_cancel;
340         }
341
342         /*
343          * Swap the data forks of the inodes
344          */
345         ifp = &ip->i_df;
346         tifp = &tip->i_df;
347         *tempifp = *ifp;        /* struct copy */
348         *ifp = *tifp;           /* struct copy */
349         *tifp = *tempifp;       /* struct copy */
350
351         /*
352          * Fix the in-memory data fork values that are dependent on the fork
353          * offset in the inode. We can't assume they remain the same as attr2
354          * has dynamic fork offsets.
355          */
356         ifp->if_ext_max = XFS_IFORK_SIZE(ip, XFS_DATA_FORK) /
357                                         (uint)sizeof(xfs_bmbt_rec_t);
358         tifp->if_ext_max = XFS_IFORK_SIZE(tip, XFS_DATA_FORK) /
359                                         (uint)sizeof(xfs_bmbt_rec_t);
360
361         /*
362          * Fix the on-disk inode values
363          */
364         tmp = (__uint64_t)ip->i_d.di_nblocks;
365         ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks;
366         tip->i_d.di_nblocks = tmp + taforkblks - aforkblks;
367
368         tmp = (__uint64_t) ip->i_d.di_nextents;
369         ip->i_d.di_nextents = tip->i_d.di_nextents;
370         tip->i_d.di_nextents = tmp;
371
372         tmp = (__uint64_t) ip->i_d.di_format;
373         ip->i_d.di_format = tip->i_d.di_format;
374         tip->i_d.di_format = tmp;
375
376         /*
377          * The extents in the source inode could still contain speculative
378          * preallocation beyond EOF (e.g. the file is open but not modified
379          * while defrag is in progress). In that case, we need to copy over the
380          * number of delalloc blocks the data fork in the source inode is
381          * tracking beyond EOF so that when the fork is truncated away when the
382          * temporary inode is unlinked we don't underrun the i_delayed_blks
383          * counter on that inode.
384          */
385         ASSERT(tip->i_delayed_blks == 0);
386         tip->i_delayed_blks = ip->i_delayed_blks;
387         ip->i_delayed_blks = 0;
388
389         ilf_fields = XFS_ILOG_CORE;
390
391         switch(ip->i_d.di_format) {
392         case XFS_DINODE_FMT_EXTENTS:
393                 /* If the extents fit in the inode, fix the
394                  * pointer.  Otherwise it's already NULL or
395                  * pointing to the extent.
396                  */
397                 if (ip->i_d.di_nextents <= XFS_INLINE_EXTS) {
398                         ifp->if_u1.if_extents =
399                                 ifp->if_u2.if_inline_ext;
400                 }
401                 ilf_fields |= XFS_ILOG_DEXT;
402                 break;
403         case XFS_DINODE_FMT_BTREE:
404                 ilf_fields |= XFS_ILOG_DBROOT;
405                 break;
406         }
407
408         tilf_fields = XFS_ILOG_CORE;
409
410         switch(tip->i_d.di_format) {
411         case XFS_DINODE_FMT_EXTENTS:
412                 /* If the extents fit in the inode, fix the
413                  * pointer.  Otherwise it's already NULL or
414                  * pointing to the extent.
415                  */
416                 if (tip->i_d.di_nextents <= XFS_INLINE_EXTS) {
417                         tifp->if_u1.if_extents =
418                                 tifp->if_u2.if_inline_ext;
419                 }
420                 tilf_fields |= XFS_ILOG_DEXT;
421                 break;
422         case XFS_DINODE_FMT_BTREE:
423                 tilf_fields |= XFS_ILOG_DBROOT;
424                 break;
425         }
426
427
428         xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
429         xfs_trans_ijoin_ref(tp, tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
430
431         xfs_trans_log_inode(tp, ip,  ilf_fields);
432         xfs_trans_log_inode(tp, tip, tilf_fields);
433
434         /*
435          * If this is a synchronous mount, make sure that the
436          * transaction goes to disk before returning to the user.
437          */
438         if (mp->m_flags & XFS_MOUNT_WSYNC)
439                 xfs_trans_set_sync(tp);
440
441         error = xfs_trans_commit(tp, XFS_TRANS_SWAPEXT);
442
443         trace_xfs_swap_extent_after(ip, 0);
444         trace_xfs_swap_extent_after(tip, 1);
445 out:
446         kmem_free(tempifp);
447         return error;
448
449 out_unlock:
450         xfs_iunlock(ip,  XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
451         xfs_iunlock(tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
452         goto out;
453
454 out_trans_cancel:
455         xfs_trans_cancel(tp, 0);
456         goto out_unlock;
457 }