aboutsummaryrefslogtreecommitdiffstats
path: root/fs/xfs
diff options
context:
space:
mode:
Diffstat (limited to 'fs/xfs')
-rw-r--r--fs/xfs/Makefile-linux-2.617
-rw-r--r--fs/xfs/linux-2.6/kmem.c5
-rw-r--r--fs/xfs/linux-2.6/xfs_aops.c23
-rw-r--r--fs/xfs/linux-2.6/xfs_buf.c21
-rw-r--r--fs/xfs/linux-2.6/xfs_dmapi_priv.h28
-rw-r--r--fs/xfs/linux-2.6/xfs_file.c28
-rw-r--r--fs/xfs/linux-2.6/xfs_ioctl.c15
-rw-r--r--fs/xfs/linux-2.6/xfs_ioctl32.c2
-rw-r--r--fs/xfs/linux-2.6/xfs_lrw.c2
-rw-r--r--fs/xfs/linux-2.6/xfs_super.c5
-rw-r--r--fs/xfs/support/debug.c4
-rw-r--r--fs/xfs/support/move.c2
-rw-r--r--fs/xfs/support/move.h2
-rw-r--r--fs/xfs/xfs.h23
-rw-r--r--fs/xfs/xfs_bmap.c2
-rw-r--r--fs/xfs/xfs_dfrag.c4
-rw-r--r--fs/xfs/xfs_dir2.c2
-rw-r--r--fs/xfs/xfs_dmapi.h22
-rw-r--r--fs/xfs/xfs_iget.c51
-rw-r--r--fs/xfs/xfs_inode.c64
-rw-r--r--fs/xfs/xfs_inode.h41
-rw-r--r--fs/xfs/xfs_vnodeops.c33
22 files changed, 241 insertions, 155 deletions
diff --git a/fs/xfs/Makefile-linux-2.6 b/fs/xfs/Makefile-linux-2.6
index 291948d508..b49989bb89 100644
--- a/fs/xfs/Makefile-linux-2.6
+++ b/fs/xfs/Makefile-linux-2.6
@@ -21,22 +21,7 @@ EXTRA_CFLAGS += -Ifs/xfs -Ifs/xfs/linux-2.6 -funsigned-char
21XFS_LINUX := linux-2.6 21XFS_LINUX := linux-2.6
22 22
23ifeq ($(CONFIG_XFS_DEBUG),y) 23ifeq ($(CONFIG_XFS_DEBUG),y)
24 EXTRA_CFLAGS += -g -DSTATIC="" -DDEBUG 24 EXTRA_CFLAGS += -g
25 EXTRA_CFLAGS += -DXFS_BUF_LOCK_TRACKING
26endif
27ifeq ($(CONFIG_XFS_TRACE),y)
28 EXTRA_CFLAGS += -DXFS_ALLOC_TRACE
29 EXTRA_CFLAGS += -DXFS_ATTR_TRACE
30 EXTRA_CFLAGS += -DXFS_BLI_TRACE
31 EXTRA_CFLAGS += -DXFS_BMAP_TRACE
32 EXTRA_CFLAGS += -DXFS_BMBT_TRACE
33 EXTRA_CFLAGS += -DXFS_DIR2_TRACE
34 EXTRA_CFLAGS += -DXFS_DQUOT_TRACE
35 EXTRA_CFLAGS += -DXFS_ILOCK_TRACE
36 EXTRA_CFLAGS += -DXFS_LOG_TRACE
37 EXTRA_CFLAGS += -DXFS_RW_TRACE
38 EXTRA_CFLAGS += -DXFS_BUF_TRACE
39 EXTRA_CFLAGS += -DXFS_VNODE_TRACE
40endif 25endif
41 26
42obj-$(CONFIG_XFS_FS) += xfs.o 27obj-$(CONFIG_XFS_FS) += xfs.o
diff --git a/fs/xfs/linux-2.6/kmem.c b/fs/xfs/linux-2.6/kmem.c
index d597375898..004baf6006 100644
--- a/fs/xfs/linux-2.6/kmem.c
+++ b/fs/xfs/linux-2.6/kmem.c
@@ -21,6 +21,7 @@
21#include <linux/highmem.h> 21#include <linux/highmem.h>
22#include <linux/swap.h> 22#include <linux/swap.h>
23#include <linux/blkdev.h> 23#include <linux/blkdev.h>
24#include <linux/backing-dev.h>
24#include "time.h" 25#include "time.h"
25#include "kmem.h" 26#include "kmem.h"
26 27
@@ -53,7 +54,7 @@ kmem_alloc(size_t size, unsigned int __nocast flags)
53 printk(KERN_ERR "XFS: possible memory allocation " 54 printk(KERN_ERR "XFS: possible memory allocation "
54 "deadlock in %s (mode:0x%x)\n", 55 "deadlock in %s (mode:0x%x)\n",
55 __FUNCTION__, lflags); 56 __FUNCTION__, lflags);
56 blk_congestion_wait(WRITE, HZ/50); 57 congestion_wait(WRITE, HZ/50);
57 } while (1); 58 } while (1);
58} 59}
59 60
@@ -131,7 +132,7 @@ kmem_zone_alloc(kmem_zone_t *zone, unsigned int __nocast flags)
131 printk(KERN_ERR "XFS: possible memory allocation " 132 printk(KERN_ERR "XFS: possible memory allocation "
132 "deadlock in %s (mode:0x%x)\n", 133 "deadlock in %s (mode:0x%x)\n",
133 __FUNCTION__, lflags); 134 __FUNCTION__, lflags);
134 blk_congestion_wait(WRITE, HZ/50); 135 congestion_wait(WRITE, HZ/50);
135 } while (1); 136 } while (1);
136} 137}
137 138
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 09360cf1e1..b56eb754e2 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -149,9 +149,10 @@ xfs_destroy_ioend(
149 */ 149 */
150STATIC void 150STATIC void
151xfs_end_bio_delalloc( 151xfs_end_bio_delalloc(
152 void *data) 152 struct work_struct *work)
153{ 153{
154 xfs_ioend_t *ioend = data; 154 xfs_ioend_t *ioend =
155 container_of(work, xfs_ioend_t, io_work);
155 156
156 xfs_destroy_ioend(ioend); 157 xfs_destroy_ioend(ioend);
157} 158}
@@ -161,9 +162,10 @@ xfs_end_bio_delalloc(
161 */ 162 */
162STATIC void 163STATIC void
163xfs_end_bio_written( 164xfs_end_bio_written(
164 void *data) 165 struct work_struct *work)
165{ 166{
166 xfs_ioend_t *ioend = data; 167 xfs_ioend_t *ioend =
168 container_of(work, xfs_ioend_t, io_work);
167 169
168 xfs_destroy_ioend(ioend); 170 xfs_destroy_ioend(ioend);
169} 171}
@@ -176,9 +178,10 @@ xfs_end_bio_written(
176 */ 178 */
177STATIC void 179STATIC void
178xfs_end_bio_unwritten( 180xfs_end_bio_unwritten(
179 void *data) 181 struct work_struct *work)
180{ 182{
181 xfs_ioend_t *ioend = data; 183 xfs_ioend_t *ioend =
184 container_of(work, xfs_ioend_t, io_work);
182 bhv_vnode_t *vp = ioend->io_vnode; 185 bhv_vnode_t *vp = ioend->io_vnode;
183 xfs_off_t offset = ioend->io_offset; 186 xfs_off_t offset = ioend->io_offset;
184 size_t size = ioend->io_size; 187 size_t size = ioend->io_size;
@@ -220,11 +223,11 @@ xfs_alloc_ioend(
220 ioend->io_size = 0; 223 ioend->io_size = 0;
221 224
222 if (type == IOMAP_UNWRITTEN) 225 if (type == IOMAP_UNWRITTEN)
223 INIT_WORK(&ioend->io_work, xfs_end_bio_unwritten, ioend); 226 INIT_WORK(&ioend->io_work, xfs_end_bio_unwritten);
224 else if (type == IOMAP_DELAY) 227 else if (type == IOMAP_DELAY)
225 INIT_WORK(&ioend->io_work, xfs_end_bio_delalloc, ioend); 228 INIT_WORK(&ioend->io_work, xfs_end_bio_delalloc);
226 else 229 else
227 INIT_WORK(&ioend->io_work, xfs_end_bio_written, ioend); 230 INIT_WORK(&ioend->io_work, xfs_end_bio_written);
228 231
229 return ioend; 232 return ioend;
230} 233}
@@ -1403,7 +1406,7 @@ xfs_vm_direct_IO(
1403 xfs_end_io_direct); 1406 xfs_end_io_direct);
1404 } 1407 }
1405 1408
1406 if (unlikely(ret <= 0 && iocb->private)) 1409 if (unlikely(ret != -EIOCBQUEUED && iocb->private))
1407 xfs_destroy_ioend(iocb->private); 1410 xfs_destroy_ioend(iocb->private);
1408 return ret; 1411 return ret;
1409} 1412}
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 9bbadafdcb..4fb01ffdfd 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -15,6 +15,7 @@
15 * along with this program; if not, write the Free Software Foundation, 15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */ 17 */
18#include "xfs.h"
18#include <linux/stddef.h> 19#include <linux/stddef.h>
19#include <linux/errno.h> 20#include <linux/errno.h>
20#include <linux/slab.h> 21#include <linux/slab.h>
@@ -30,7 +31,8 @@
30#include <linux/hash.h> 31#include <linux/hash.h>
31#include <linux/kthread.h> 32#include <linux/kthread.h>
32#include <linux/migrate.h> 33#include <linux/migrate.h>
33#include "xfs_linux.h" 34#include <linux/backing-dev.h>
35#include <linux/freezer.h>
34 36
35STATIC kmem_zone_t *xfs_buf_zone; 37STATIC kmem_zone_t *xfs_buf_zone;
36STATIC kmem_shaker_t xfs_buf_shake; 38STATIC kmem_shaker_t xfs_buf_shake;
@@ -395,7 +397,7 @@ _xfs_buf_lookup_pages(
395 397
396 XFS_STATS_INC(xb_page_retries); 398 XFS_STATS_INC(xb_page_retries);
397 xfsbufd_wakeup(0, gfp_mask); 399 xfsbufd_wakeup(0, gfp_mask);
398 blk_congestion_wait(WRITE, HZ/50); 400 congestion_wait(WRITE, HZ/50);
399 goto retry; 401 goto retry;
400 } 402 }
401 403
@@ -993,9 +995,10 @@ xfs_buf_wait_unpin(
993 995
994STATIC void 996STATIC void
995xfs_buf_iodone_work( 997xfs_buf_iodone_work(
996 void *v) 998 struct work_struct *work)
997{ 999{
998 xfs_buf_t *bp = (xfs_buf_t *)v; 1000 xfs_buf_t *bp =
1001 container_of(work, xfs_buf_t, b_iodone_work);
999 1002
1000 if (bp->b_iodone) 1003 if (bp->b_iodone)
1001 (*(bp->b_iodone))(bp); 1004 (*(bp->b_iodone))(bp);
@@ -1016,10 +1019,10 @@ xfs_buf_ioend(
1016 1019
1017 if ((bp->b_iodone) || (bp->b_flags & XBF_ASYNC)) { 1020 if ((bp->b_iodone) || (bp->b_flags & XBF_ASYNC)) {
1018 if (schedule) { 1021 if (schedule) {
1019 INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work, bp); 1022 INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work);
1020 queue_work(xfslogd_workqueue, &bp->b_iodone_work); 1023 queue_work(xfslogd_workqueue, &bp->b_iodone_work);
1021 } else { 1024 } else {
1022 xfs_buf_iodone_work(bp); 1025 xfs_buf_iodone_work(&bp->b_iodone_work);
1023 } 1026 }
1024 } else { 1027 } else {
1025 up(&bp->b_iodonesema); 1028 up(&bp->b_iodonesema);
@@ -1405,7 +1408,7 @@ xfs_alloc_bufhash(
1405 btp->bt_hashshift = external ? 3 : 8; /* 8 or 256 buckets */ 1408 btp->bt_hashshift = external ? 3 : 8; /* 8 or 256 buckets */
1406 btp->bt_hashmask = (1 << btp->bt_hashshift) - 1; 1409 btp->bt_hashmask = (1 << btp->bt_hashshift) - 1;
1407 btp->bt_hash = kmem_zalloc((1 << btp->bt_hashshift) * 1410 btp->bt_hash = kmem_zalloc((1 << btp->bt_hashshift) *
1408 sizeof(xfs_bufhash_t), KM_SLEEP); 1411 sizeof(xfs_bufhash_t), KM_SLEEP | KM_LARGE);
1409 for (i = 0; i < (1 << btp->bt_hashshift); i++) { 1412 for (i = 0; i < (1 << btp->bt_hashshift); i++) {
1410 spin_lock_init(&btp->bt_hash[i].bh_lock); 1413 spin_lock_init(&btp->bt_hash[i].bh_lock);
1411 INIT_LIST_HEAD(&btp->bt_hash[i].bh_list); 1414 INIT_LIST_HEAD(&btp->bt_hash[i].bh_list);
@@ -1824,11 +1827,11 @@ xfs_buf_init(void)
1824 if (!xfs_buf_zone) 1827 if (!xfs_buf_zone)
1825 goto out_free_trace_buf; 1828 goto out_free_trace_buf;
1826 1829
1827 xfslogd_workqueue = create_workqueue("xfslogd"); 1830 xfslogd_workqueue = create_freezeable_workqueue("xfslogd");
1828 if (!xfslogd_workqueue) 1831 if (!xfslogd_workqueue)
1829 goto out_free_buf_zone; 1832 goto out_free_buf_zone;
1830 1833
1831 xfsdatad_workqueue = create_workqueue("xfsdatad"); 1834 xfsdatad_workqueue = create_freezeable_workqueue("xfsdatad");
1832 if (!xfsdatad_workqueue) 1835 if (!xfsdatad_workqueue)
1833 goto out_destroy_xfslogd_workqueue; 1836 goto out_destroy_xfslogd_workqueue;
1834 1837
diff --git a/fs/xfs/linux-2.6/xfs_dmapi_priv.h b/fs/xfs/linux-2.6/xfs_dmapi_priv.h
new file mode 100644
index 0000000000..a8b0b1685e
--- /dev/null
+++ b/fs/xfs/linux-2.6/xfs_dmapi_priv.h
@@ -0,0 +1,28 @@
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#ifndef __XFS_DMAPI_PRIV_H__
19#define __XFS_DMAPI_PRIV_H__
20
21/*
22 * Based on IO_ISDIRECT, decide which i_ flag is set.
23 */
24#define DM_SEM_FLAG_RD(ioflags) (((ioflags) & IO_ISDIRECT) ? \
25 DM_FLAGS_IMUX : 0)
26#define DM_SEM_FLAG_WR (DM_FLAGS_IALLOCSEM_WR | DM_FLAGS_IMUX)
27
28#endif /*__XFS_DMAPI_PRIV_H__*/
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index d93d8dd195..d26f5cd2ba 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -55,7 +55,7 @@ __xfs_file_read(
55 loff_t pos) 55 loff_t pos)
56{ 56{
57 struct file *file = iocb->ki_filp; 57 struct file *file = iocb->ki_filp;
58 bhv_vnode_t *vp = vn_from_inode(file->f_dentry->d_inode); 58 bhv_vnode_t *vp = vn_from_inode(file->f_path.dentry->d_inode);
59 59
60 BUG_ON(iocb->ki_pos != pos); 60 BUG_ON(iocb->ki_pos != pos);
61 if (unlikely(file->f_flags & O_DIRECT)) 61 if (unlikely(file->f_flags & O_DIRECT))
@@ -131,7 +131,7 @@ xfs_file_sendfile(
131 read_actor_t actor, 131 read_actor_t actor,
132 void *target) 132 void *target)
133{ 133{
134 return bhv_vop_sendfile(vn_from_inode(filp->f_dentry->d_inode), 134 return bhv_vop_sendfile(vn_from_inode(filp->f_path.dentry->d_inode),
135 filp, pos, 0, count, actor, target, NULL); 135 filp, pos, 0, count, actor, target, NULL);
136} 136}
137 137
@@ -143,7 +143,7 @@ xfs_file_sendfile_invis(
143 read_actor_t actor, 143 read_actor_t actor,
144 void *target) 144 void *target)
145{ 145{
146 return bhv_vop_sendfile(vn_from_inode(filp->f_dentry->d_inode), 146 return bhv_vop_sendfile(vn_from_inode(filp->f_path.dentry->d_inode),
147 filp, pos, IO_INVIS, count, actor, target, NULL); 147 filp, pos, IO_INVIS, count, actor, target, NULL);
148} 148}
149 149
@@ -155,7 +155,7 @@ xfs_file_splice_read(
155 size_t len, 155 size_t len,
156 unsigned int flags) 156 unsigned int flags)
157{ 157{
158 return bhv_vop_splice_read(vn_from_inode(infilp->f_dentry->d_inode), 158 return bhv_vop_splice_read(vn_from_inode(infilp->f_path.dentry->d_inode),
159 infilp, ppos, pipe, len, flags, 0, NULL); 159 infilp, ppos, pipe, len, flags, 0, NULL);
160} 160}
161 161
@@ -167,7 +167,7 @@ xfs_file_splice_read_invis(
167 size_t len, 167 size_t len,
168 unsigned int flags) 168 unsigned int flags)
169{ 169{
170 return bhv_vop_splice_read(vn_from_inode(infilp->f_dentry->d_inode), 170 return bhv_vop_splice_read(vn_from_inode(infilp->f_path.dentry->d_inode),
171 infilp, ppos, pipe, len, flags, IO_INVIS, 171 infilp, ppos, pipe, len, flags, IO_INVIS,
172 NULL); 172 NULL);
173} 173}
@@ -180,7 +180,7 @@ xfs_file_splice_write(
180 size_t len, 180 size_t len,
181 unsigned int flags) 181 unsigned int flags)
182{ 182{
183 return bhv_vop_splice_write(vn_from_inode(outfilp->f_dentry->d_inode), 183 return bhv_vop_splice_write(vn_from_inode(outfilp->f_path.dentry->d_inode),
184 pipe, outfilp, ppos, len, flags, 0, NULL); 184 pipe, outfilp, ppos, len, flags, 0, NULL);
185} 185}
186 186
@@ -192,7 +192,7 @@ xfs_file_splice_write_invis(
192 size_t len, 192 size_t len,
193 unsigned int flags) 193 unsigned int flags)
194{ 194{
195 return bhv_vop_splice_write(vn_from_inode(outfilp->f_dentry->d_inode), 195 return bhv_vop_splice_write(vn_from_inode(outfilp->f_path.dentry->d_inode),
196 pipe, outfilp, ppos, len, flags, IO_INVIS, 196 pipe, outfilp, ppos, len, flags, IO_INVIS,
197 NULL); 197 NULL);
198} 198}
@@ -212,7 +212,7 @@ xfs_file_close(
212 struct file *filp, 212 struct file *filp,
213 fl_owner_t id) 213 fl_owner_t id)
214{ 214{
215 return -bhv_vop_close(vn_from_inode(filp->f_dentry->d_inode), 0, 215 return -bhv_vop_close(vn_from_inode(filp->f_path.dentry->d_inode), 0,
216 file_count(filp) > 1 ? L_FALSE : L_TRUE, NULL); 216 file_count(filp) > 1 ? L_FALSE : L_TRUE, NULL);
217} 217}
218 218
@@ -251,7 +251,7 @@ xfs_vm_nopage(
251 unsigned long address, 251 unsigned long address,
252 int *type) 252 int *type)
253{ 253{
254 struct inode *inode = area->vm_file->f_dentry->d_inode; 254 struct inode *inode = area->vm_file->f_path.dentry->d_inode;
255 bhv_vnode_t *vp = vn_from_inode(inode); 255 bhv_vnode_t *vp = vn_from_inode(inode);
256 256
257 ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI); 257 ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);
@@ -268,7 +268,7 @@ xfs_file_readdir(
268 filldir_t filldir) 268 filldir_t filldir)
269{ 269{
270 int error = 0; 270 int error = 0;
271 bhv_vnode_t *vp = vn_from_inode(filp->f_dentry->d_inode); 271 bhv_vnode_t *vp = vn_from_inode(filp->f_path.dentry->d_inode);
272 uio_t uio; 272 uio_t uio;
273 iovec_t iov; 273 iovec_t iov;
274 int eof = 0; 274 int eof = 0;
@@ -345,7 +345,7 @@ xfs_file_mmap(
345 vma->vm_ops = &xfs_file_vm_ops; 345 vma->vm_ops = &xfs_file_vm_ops;
346 346
347#ifdef CONFIG_XFS_DMAPI 347#ifdef CONFIG_XFS_DMAPI
348 if (vn_from_inode(filp->f_dentry->d_inode)->v_vfsp->vfs_flag & VFS_DMI) 348 if (vn_from_inode(filp->f_path.dentry->d_inode)->v_vfsp->vfs_flag & VFS_DMI)
349 vma->vm_ops = &xfs_dmapi_file_vm_ops; 349 vma->vm_ops = &xfs_dmapi_file_vm_ops;
350#endif /* CONFIG_XFS_DMAPI */ 350#endif /* CONFIG_XFS_DMAPI */
351 351
@@ -360,7 +360,7 @@ xfs_file_ioctl(
360 unsigned long p) 360 unsigned long p)
361{ 361{
362 int error; 362 int error;
363 struct inode *inode = filp->f_dentry->d_inode; 363 struct inode *inode = filp->f_path.dentry->d_inode;
364 bhv_vnode_t *vp = vn_from_inode(inode); 364 bhv_vnode_t *vp = vn_from_inode(inode);
365 365
366 error = bhv_vop_ioctl(vp, inode, filp, 0, cmd, (void __user *)p); 366 error = bhv_vop_ioctl(vp, inode, filp, 0, cmd, (void __user *)p);
@@ -382,7 +382,7 @@ xfs_file_ioctl_invis(
382 unsigned long p) 382 unsigned long p)
383{ 383{
384 int error; 384 int error;
385 struct inode *inode = filp->f_dentry->d_inode; 385 struct inode *inode = filp->f_path.dentry->d_inode;
386 bhv_vnode_t *vp = vn_from_inode(inode); 386 bhv_vnode_t *vp = vn_from_inode(inode);
387 387
388 error = bhv_vop_ioctl(vp, inode, filp, IO_INVIS, cmd, (void __user *)p); 388 error = bhv_vop_ioctl(vp, inode, filp, IO_INVIS, cmd, (void __user *)p);
@@ -404,7 +404,7 @@ xfs_vm_mprotect(
404 struct vm_area_struct *vma, 404 struct vm_area_struct *vma,
405 unsigned int newflags) 405 unsigned int newflags)
406{ 406{
407 bhv_vnode_t *vp = vn_from_inode(vma->vm_file->f_dentry->d_inode); 407 bhv_vnode_t *vp = vn_from_inode(vma->vm_file->f_path.dentry->d_inode);
408 int error = 0; 408 int error = 0;
409 409
410 if (vp->v_vfsp->vfs_flag & VFS_DMI) { 410 if (vp->v_vfsp->vfs_flag & VFS_DMI) {
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index a74f854d91..f011c9cd0d 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -107,9 +107,9 @@ xfs_find_handle(
107 if (!file) 107 if (!file)
108 return -EBADF; 108 return -EBADF;
109 109
110 ASSERT(file->f_dentry); 110 ASSERT(file->f_path.dentry);
111 ASSERT(file->f_dentry->d_inode); 111 ASSERT(file->f_path.dentry->d_inode);
112 inode = igrab(file->f_dentry->d_inode); 112 inode = igrab(file->f_path.dentry->d_inode);
113 fput(file); 113 fput(file);
114 break; 114 break;
115 } 115 }
@@ -333,16 +333,19 @@ xfs_open_by_handle(
333 } 333 }
334 334
335 /* Ensure umount returns EBUSY on umounts while this file is open. */ 335 /* Ensure umount returns EBUSY on umounts while this file is open. */
336 mntget(parfilp->f_vfsmnt); 336 mntget(parfilp->f_path.mnt);
337 337
338 /* Create file pointer. */ 338 /* Create file pointer. */
339 filp = dentry_open(dentry, parfilp->f_vfsmnt, hreq.oflags); 339 filp = dentry_open(dentry, parfilp->f_path.mnt, hreq.oflags);
340 if (IS_ERR(filp)) { 340 if (IS_ERR(filp)) {
341 put_unused_fd(new_fd); 341 put_unused_fd(new_fd);
342 return -XFS_ERROR(-PTR_ERR(filp)); 342 return -XFS_ERROR(-PTR_ERR(filp));
343 } 343 }
344 if (inode->i_mode & S_IFREG) 344 if (inode->i_mode & S_IFREG) {
345 /* invisible operation should not change atime */
346 filp->f_flags |= O_NOATIME;
345 filp->f_op = &xfs_invis_file_operations; 347 filp->f_op = &xfs_invis_file_operations;
348 }
346 349
347 fd_install(new_fd, filp); 350 fd_install(new_fd, filp);
348 return new_fd; 351 return new_fd;
diff --git a/fs/xfs/linux-2.6/xfs_ioctl32.c b/fs/xfs/linux-2.6/xfs_ioctl32.c
index 270db0f386..b83cebc165 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl32.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl32.c
@@ -112,7 +112,7 @@ xfs_compat_ioctl(
112 unsigned cmd, 112 unsigned cmd,
113 unsigned long arg) 113 unsigned long arg)
114{ 114{
115 struct inode *inode = file->f_dentry->d_inode; 115 struct inode *inode = file->f_path.dentry->d_inode;
116 bhv_vnode_t *vp = vn_from_inode(inode); 116 bhv_vnode_t *vp = vn_from_inode(inode);
117 int error; 117 int error;
118 118
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index fa842f1c9f..65e79b471d 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -805,7 +805,7 @@ start:
805 !capable(CAP_FSETID)) { 805 !capable(CAP_FSETID)) {
806 error = xfs_write_clear_setuid(xip); 806 error = xfs_write_clear_setuid(xip);
807 if (likely(!error)) 807 if (likely(!error))
808 error = -remove_suid(file->f_dentry); 808 error = -remove_suid(file->f_path.dentry);
809 if (unlikely(error)) { 809 if (unlikely(error)) {
810 xfs_iunlock(xip, iolock); 810 xfs_iunlock(xip, iolock);
811 goto out_unlock_mutex; 811 goto out_unlock_mutex;
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 38c4d128a8..b93265b7c7 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -56,6 +56,7 @@
56#include <linux/mempool.h> 56#include <linux/mempool.h>
57#include <linux/writeback.h> 57#include <linux/writeback.h>
58#include <linux/kthread.h> 58#include <linux/kthread.h>
59#include <linux/freezer.h>
59 60
60STATIC struct quotactl_ops xfs_quotactl_operations; 61STATIC struct quotactl_ops xfs_quotactl_operations;
61STATIC struct super_operations xfs_super_operations; 62STATIC struct super_operations xfs_super_operations;
@@ -227,9 +228,7 @@ xfs_initialize_vnode(
227 xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip); 228 xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
228 xfs_set_inodeops(inode); 229 xfs_set_inodeops(inode);
229 230
230 spin_lock(&ip->i_flags_lock); 231 xfs_iflags_clear(ip, XFS_INEW);
231 ip->i_flags &= ~XFS_INEW;
232 spin_unlock(&ip->i_flags_lock);
233 barrier(); 232 barrier();
234 233
235 unlock_new_inode(inode); 234 unlock_new_inode(inode);
diff --git a/fs/xfs/support/debug.c b/fs/xfs/support/debug.c
index c75f68361e..4363512d2f 100644
--- a/fs/xfs/support/debug.c
+++ b/fs/xfs/support/debug.c
@@ -15,11 +15,9 @@
15 * along with this program; if not, write the Free Software Foundation, 15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */ 17 */
18#include <xfs.h>
18#include "debug.h" 19#include "debug.h"
19#include "spin.h" 20#include "spin.h"
20#include <asm/page.h>
21#include <linux/sched.h>
22#include <linux/kernel.h>
23 21
24static char message[256]; /* keep it off the stack */ 22static char message[256]; /* keep it off the stack */
25static DEFINE_SPINLOCK(xfs_err_lock); 23static DEFINE_SPINLOCK(xfs_err_lock);
diff --git a/fs/xfs/support/move.c b/fs/xfs/support/move.c
index caefa17b80..ac8617ca39 100644
--- a/fs/xfs/support/move.c
+++ b/fs/xfs/support/move.c
@@ -22,7 +22,7 @@
22 * as we go. 22 * as we go.
23 */ 23 */
24int 24int
25uio_read(caddr_t src, size_t len, struct uio *uio) 25xfs_uio_read(caddr_t src, size_t len, struct uio *uio)
26{ 26{
27 size_t count; 27 size_t count;
28 28
diff --git a/fs/xfs/support/move.h b/fs/xfs/support/move.h
index 97a2498d2d..977879c24f 100644
--- a/fs/xfs/support/move.h
+++ b/fs/xfs/support/move.h
@@ -65,6 +65,6 @@ struct uio {
65typedef struct uio uio_t; 65typedef struct uio uio_t;
66typedef struct iovec iovec_t; 66typedef struct iovec iovec_t;
67 67
68extern int uio_read (caddr_t, size_t, uio_t *); 68extern int xfs_uio_read (caddr_t, size_t, uio_t *);
69 69
70#endif /* __XFS_SUPPORT_MOVE_H__ */ 70#endif /* __XFS_SUPPORT_MOVE_H__ */
diff --git a/fs/xfs/xfs.h b/fs/xfs/xfs.h
index 1a48dbb902..bf0a12040b 100644
--- a/fs/xfs/xfs.h
+++ b/fs/xfs/xfs.h
@@ -17,5 +17,28 @@
17 */ 17 */
18#ifndef __XFS_H__ 18#ifndef __XFS_H__
19#define __XFS_H__ 19#define __XFS_H__
20
21#ifdef CONFIG_XFS_DEBUG
22#define STATIC
23#define DEBUG 1
24#define XFS_BUF_LOCK_TRACKING 1
25/* #define QUOTADEBUG 1 */
26#endif
27
28#ifdef CONFIG_XFS_TRACE
29#define XFS_ALLOC_TRACE 1
30#define XFS_ATTR_TRACE 1
31#define XFS_BLI_TRACE 1
32#define XFS_BMAP_TRACE 1
33#define XFS_BMBT_TRACE 1
34#define XFS_DIR2_TRACE 1
35#define XFS_DQUOT_TRACE 1
36#define XFS_ILOCK_TRACE 1
37#define XFS_LOG_TRACE 1
38#define XFS_RW_TRACE 1
39#define XFS_BUF_TRACE 1
40#define XFS_VNODE_TRACE 1
41#endif
42
20#include <linux-2.6/xfs_linux.h> 43#include <linux-2.6/xfs_linux.h>
21#endif /* __XFS_H__ */ 44#endif /* __XFS_H__ */
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 5b050c0679..498ad50d1f 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -1171,6 +1171,8 @@ xfs_bmap_add_extent_delay_real(
1171 xfs_bmap_trace_pre_update(fname, "0", ip, idx, XFS_DATA_FORK); 1171 xfs_bmap_trace_pre_update(fname, "0", ip, idx, XFS_DATA_FORK);
1172 xfs_bmbt_set_blockcount(ep, temp); 1172 xfs_bmbt_set_blockcount(ep, temp);
1173 r[0] = *new; 1173 r[0] = *new;
1174 r[1].br_state = PREV.br_state;
1175 r[1].br_startblock = 0;
1174 r[1].br_startoff = new_endoff; 1176 r[1].br_startoff = new_endoff;
1175 temp2 = PREV.br_startoff + PREV.br_blockcount - new_endoff; 1177 temp2 = PREV.br_startoff + PREV.br_blockcount - new_endoff;
1176 r[1].br_blockcount = temp2; 1178 r[1].br_blockcount = temp2;
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 80562b60fb..50d0faea37 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -71,7 +71,7 @@ xfs_swapext(
71 71
72 /* Pull information for the target fd */ 72 /* Pull information for the target fd */
73 if (((fp = fget((int)sxp->sx_fdtarget)) == NULL) || 73 if (((fp = fget((int)sxp->sx_fdtarget)) == NULL) ||
74 ((vp = vn_from_inode(fp->f_dentry->d_inode)) == NULL)) { 74 ((vp = vn_from_inode(fp->f_path.dentry->d_inode)) == NULL)) {
75 error = XFS_ERROR(EINVAL); 75 error = XFS_ERROR(EINVAL);
76 goto error0; 76 goto error0;
77 } 77 }
@@ -83,7 +83,7 @@ xfs_swapext(
83 } 83 }
84 84
85 if (((tfp = fget((int)sxp->sx_fdtmp)) == NULL) || 85 if (((tfp = fget((int)sxp->sx_fdtmp)) == NULL) ||
86 ((tvp = vn_from_inode(tfp->f_dentry->d_inode)) == NULL)) { 86 ((tvp = vn_from_inode(tfp->f_path.dentry->d_inode)) == NULL)) {
87 error = XFS_ERROR(EINVAL); 87 error = XFS_ERROR(EINVAL);
88 goto error0; 88 goto error0;
89 } 89 }
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 8edbe1adb9..8e8e527933 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -678,7 +678,7 @@ xfs_dir2_put_dirent64_uio(
678 idbp->d_off = pa->cook; 678 idbp->d_off = pa->cook;
679 idbp->d_name[namelen] = '\0'; 679 idbp->d_name[namelen] = '\0';
680 memcpy(idbp->d_name, pa->name, namelen); 680 memcpy(idbp->d_name, pa->name, namelen);
681 rval = uio_read((caddr_t)idbp, reclen, uio); 681 rval = xfs_uio_read((caddr_t)idbp, reclen, uio);
682 pa->done = (rval == 0); 682 pa->done = (rval == 0);
683 return rval; 683 return rval;
684} 684}
diff --git a/fs/xfs/xfs_dmapi.h b/fs/xfs/xfs_dmapi.h
index 4e7865ad6f..adc3d25124 100644
--- a/fs/xfs/xfs_dmapi.h
+++ b/fs/xfs/xfs_dmapi.h
@@ -157,27 +157,9 @@ typedef enum {
157#define DM_FLAGS_IALLOCSEM_WR 0x020 /* thread holds i_alloc_sem wr */ 157#define DM_FLAGS_IALLOCSEM_WR 0x020 /* thread holds i_alloc_sem wr */
158 158
159/* 159/*
160 * Based on IO_ISDIRECT, decide which i_ flag is set. 160 * Pull in platform specific event flags defines
161 */ 161 */
162#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0) 162#include "xfs_dmapi_priv.h"
163#define DM_SEM_FLAG_RD(ioflags) (((ioflags) & IO_ISDIRECT) ? \
164 DM_FLAGS_IMUX : 0)
165#define DM_SEM_FLAG_WR (DM_FLAGS_IALLOCSEM_WR | DM_FLAGS_IMUX)
166#endif
167
168#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && \
169 (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,22))
170#define DM_SEM_FLAG_RD(ioflags) (((ioflags) & IO_ISDIRECT) ? \
171 DM_FLAGS_IALLOCSEM_RD : DM_FLAGS_IMUX)
172#define DM_SEM_FLAG_WR (DM_FLAGS_IALLOCSEM_WR | DM_FLAGS_IMUX)
173#endif
174
175#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,21)
176#define DM_SEM_FLAG_RD(ioflags) (((ioflags) & IO_ISDIRECT) ? \
177 0 : DM_FLAGS_IMUX)
178#define DM_SEM_FLAG_WR (DM_FLAGS_IMUX)
179#endif
180
181 163
182/* 164/*
183 * Macros to turn caller specified delay/block flags into 165 * Macros to turn caller specified delay/block flags into
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index b73d216eca..c1c89dac19 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -215,7 +215,7 @@ again:
215 * If INEW is set this inode is being set up 215 * If INEW is set this inode is being set up
216 * we need to pause and try again. 216 * we need to pause and try again.
217 */ 217 */
218 if (ip->i_flags & XFS_INEW) { 218 if (xfs_iflags_test(ip, XFS_INEW)) {
219 read_unlock(&ih->ih_lock); 219 read_unlock(&ih->ih_lock);
220 delay(1); 220 delay(1);
221 XFS_STATS_INC(xs_ig_frecycle); 221 XFS_STATS_INC(xs_ig_frecycle);
@@ -230,22 +230,50 @@ again:
230 * on its way out of the system, 230 * on its way out of the system,
231 * we need to pause and try again. 231 * we need to pause and try again.
232 */ 232 */
233 if (ip->i_flags & XFS_IRECLAIM) { 233 if (xfs_iflags_test(ip, XFS_IRECLAIM)) {
234 read_unlock(&ih->ih_lock); 234 read_unlock(&ih->ih_lock);
235 delay(1); 235 delay(1);
236 XFS_STATS_INC(xs_ig_frecycle); 236 XFS_STATS_INC(xs_ig_frecycle);
237 237
238 goto again; 238 goto again;
239 } 239 }
240 ASSERT(xfs_iflags_test(ip, XFS_IRECLAIMABLE));
241
242 /*
243 * If lookup is racing with unlink, then we
244 * should return an error immediately so we
245 * don't remove it from the reclaim list and
246 * potentially leak the inode.
247 */
248 if ((ip->i_d.di_mode == 0) &&
249 !(flags & XFS_IGET_CREATE)) {
250 read_unlock(&ih->ih_lock);
251 return ENOENT;
252 }
253
254 /*
255 * There may be transactions sitting in the
256 * incore log buffers or being flushed to disk
257 * at this time. We can't clear the
258 * XFS_IRECLAIMABLE flag until these
259 * transactions have hit the disk, otherwise we
260 * will void the guarantee the flag provides
261 * xfs_iunpin()
262 */
263 if (xfs_ipincount(ip)) {
264 read_unlock(&ih->ih_lock);
265 xfs_log_force(mp, 0,
266 XFS_LOG_FORCE|XFS_LOG_SYNC);
267 XFS_STATS_INC(xs_ig_frecycle);
268 goto again;
269 }
240 270
241 vn_trace_exit(vp, "xfs_iget.alloc", 271 vn_trace_exit(vp, "xfs_iget.alloc",
242 (inst_t *)__return_address); 272 (inst_t *)__return_address);
243 273
244 XFS_STATS_INC(xs_ig_found); 274 XFS_STATS_INC(xs_ig_found);
245 275
246 spin_lock(&ip->i_flags_lock); 276 xfs_iflags_clear(ip, XFS_IRECLAIMABLE);
247 ip->i_flags &= ~XFS_IRECLAIMABLE;
248 spin_unlock(&ip->i_flags_lock);
249 version = ih->ih_version; 277 version = ih->ih_version;
250 read_unlock(&ih->ih_lock); 278 read_unlock(&ih->ih_lock);
251 xfs_ihash_promote(ih, ip, version); 279 xfs_ihash_promote(ih, ip, version);
@@ -299,10 +327,7 @@ finish_inode:
299 if (lock_flags != 0) 327 if (lock_flags != 0)
300 xfs_ilock(ip, lock_flags); 328 xfs_ilock(ip, lock_flags);
301 329
302 spin_lock(&ip->i_flags_lock); 330 xfs_iflags_clear(ip, XFS_ISTALE);
303 ip->i_flags &= ~XFS_ISTALE;
304 spin_unlock(&ip->i_flags_lock);
305
306 vn_trace_exit(vp, "xfs_iget.found", 331 vn_trace_exit(vp, "xfs_iget.found",
307 (inst_t *)__return_address); 332 (inst_t *)__return_address);
308 goto return_ip; 333 goto return_ip;
@@ -371,10 +396,7 @@ finish_inode:
371 ih->ih_next = ip; 396 ih->ih_next = ip;
372 ip->i_udquot = ip->i_gdquot = NULL; 397 ip->i_udquot = ip->i_gdquot = NULL;
373 ih->ih_version++; 398 ih->ih_version++;
374 spin_lock(&ip->i_flags_lock); 399 xfs_iflags_set(ip, XFS_INEW);
375 ip->i_flags |= XFS_INEW;
376 spin_unlock(&ip->i_flags_lock);
377
378 write_unlock(&ih->ih_lock); 400 write_unlock(&ih->ih_lock);
379 401
380 /* 402 /*
@@ -625,7 +647,7 @@ xfs_iput_new(xfs_inode_t *ip,
625 vn_trace_entry(vp, "xfs_iput_new", (inst_t *)__return_address); 647 vn_trace_entry(vp, "xfs_iput_new", (inst_t *)__return_address);
626 648
627 if ((ip->i_d.di_mode == 0)) { 649 if ((ip->i_d.di_mode == 0)) {
628 ASSERT(!(ip->i_flags & XFS_IRECLAIMABLE)); 650 ASSERT(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
629 vn_mark_bad(vp); 651 vn_mark_bad(vp);
630 } 652 }
631 if (inode->i_state & I_NEW) 653 if (inode->i_state & I_NEW)
@@ -683,6 +705,7 @@ xfs_ireclaim(xfs_inode_t *ip)
683 /* 705 /*
684 * Free all memory associated with the inode. 706 * Free all memory associated with the inode.
685 */ 707 */
708 xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
686 xfs_idestroy(ip); 709 xfs_idestroy(ip);
687} 710}
688 711
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index c27d7d495a..44dfac5212 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2193,7 +2193,7 @@ xfs_ifree_cluster(
2193 /* Inode not in memory or we found it already, 2193 /* Inode not in memory or we found it already,
2194 * nothing to do 2194 * nothing to do
2195 */ 2195 */
2196 if (!ip || (ip->i_flags & XFS_ISTALE)) { 2196 if (!ip || xfs_iflags_test(ip, XFS_ISTALE)) {
2197 read_unlock(&ih->ih_lock); 2197 read_unlock(&ih->ih_lock);
2198 continue; 2198 continue;
2199 } 2199 }
@@ -2215,10 +2215,7 @@ xfs_ifree_cluster(
2215 2215
2216 if (ip == free_ip) { 2216 if (ip == free_ip) {
2217 if (xfs_iflock_nowait(ip)) { 2217 if (xfs_iflock_nowait(ip)) {
2218 spin_lock(&ip->i_flags_lock); 2218 xfs_iflags_set(ip, XFS_ISTALE);
2219 ip->i_flags |= XFS_ISTALE;
2220 spin_unlock(&ip->i_flags_lock);
2221
2222 if (xfs_inode_clean(ip)) { 2219 if (xfs_inode_clean(ip)) {
2223 xfs_ifunlock(ip); 2220 xfs_ifunlock(ip);
2224 } else { 2221 } else {
@@ -2231,9 +2228,7 @@ xfs_ifree_cluster(
2231 2228
2232 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) { 2229 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2233 if (xfs_iflock_nowait(ip)) { 2230 if (xfs_iflock_nowait(ip)) {
2234 spin_lock(&ip->i_flags_lock); 2231 xfs_iflags_set(ip, XFS_ISTALE);
2235 ip->i_flags |= XFS_ISTALE;
2236 spin_unlock(&ip->i_flags_lock);
2237 2232
2238 if (xfs_inode_clean(ip)) { 2233 if (xfs_inode_clean(ip)) {
2239 xfs_ifunlock(ip); 2234 xfs_ifunlock(ip);
@@ -2263,9 +2258,7 @@ xfs_ifree_cluster(
2263 AIL_LOCK(mp,s); 2258 AIL_LOCK(mp,s);
2264 iip->ili_flush_lsn = iip->ili_item.li_lsn; 2259 iip->ili_flush_lsn = iip->ili_item.li_lsn;
2265 AIL_UNLOCK(mp, s); 2260 AIL_UNLOCK(mp, s);
2266 spin_lock(&iip->ili_inode->i_flags_lock); 2261 xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
2267 iip->ili_inode->i_flags |= XFS_ISTALE;
2268 spin_unlock(&iip->ili_inode->i_flags_lock);
2269 pre_flushed++; 2262 pre_flushed++;
2270 } 2263 }
2271 lip = lip->li_bio_list; 2264 lip = lip->li_bio_list;
@@ -2748,42 +2741,39 @@ xfs_iunpin(
2748{ 2741{
2749 ASSERT(atomic_read(&ip->i_pincount) > 0); 2742 ASSERT(atomic_read(&ip->i_pincount) > 0);
2750 2743
2751 if (atomic_dec_and_test(&ip->i_pincount)) { 2744 if (atomic_dec_and_lock(&ip->i_pincount, &ip->i_flags_lock)) {
2745
2752 /* 2746 /*
2753 * If the inode is currently being reclaimed, the 2747 * If the inode is currently being reclaimed, the link between
2754 * linux inode _and_ the xfs vnode may have been 2748 * the bhv_vnode and the xfs_inode will be broken after the
2755 * freed so we cannot reference either of them safely. 2749 * XFS_IRECLAIM* flag is set. Hence, if these flags are not
2756 * Hence we should not try to do anything to them 2750 * set, then we can move forward and mark the linux inode dirty
2757 * if the xfs inode is currently in the reclaim 2751 * knowing that it is still valid as it won't freed until after
2758 * path. 2752 * the bhv_vnode<->xfs_inode link is broken in xfs_reclaim. The
2753 * i_flags_lock is used to synchronise the setting of the
2754 * XFS_IRECLAIM* flags and the breaking of the link, and so we
2755 * can execute atomically w.r.t to reclaim by holding this lock
2756 * here.
2759 * 2757 *
2760 * However, we still need to issue the unpin wakeup 2758 * However, we still need to issue the unpin wakeup call as the
2761 * call as the inode reclaim may be blocked waiting for 2759 * inode reclaim may be blocked waiting for the inode to become
2762 * the inode to become unpinned. 2760 * unpinned.
2763 */ 2761 */
2764 struct inode *inode = NULL;
2765 2762
2766 spin_lock(&ip->i_flags_lock); 2763 if (!__xfs_iflags_test(ip, XFS_IRECLAIM|XFS_IRECLAIMABLE)) {
2767 if (!(ip->i_flags & (XFS_IRECLAIM|XFS_IRECLAIMABLE))) {
2768 bhv_vnode_t *vp = XFS_ITOV_NULL(ip); 2764 bhv_vnode_t *vp = XFS_ITOV_NULL(ip);
2765 struct inode *inode = NULL;
2766
2767 BUG_ON(vp == NULL);
2768 inode = vn_to_inode(vp);
2769 BUG_ON(inode->i_state & I_CLEAR);
2769 2770
2770 /* make sync come back and flush this inode */ 2771 /* make sync come back and flush this inode */
2771 if (vp) { 2772 if (!(inode->i_state & (I_NEW|I_FREEING)))
2772 inode = vn_to_inode(vp); 2773 mark_inode_dirty_sync(inode);
2773
2774 if (!(inode->i_state &
2775 (I_NEW|I_FREEING|I_CLEAR))) {
2776 inode = igrab(inode);
2777 if (inode)
2778 mark_inode_dirty_sync(inode);
2779 } else
2780 inode = NULL;
2781 }
2782 } 2774 }
2783 spin_unlock(&ip->i_flags_lock); 2775 spin_unlock(&ip->i_flags_lock);
2784 wake_up(&ip->i_ipin_wait); 2776 wake_up(&ip->i_ipin_wait);
2785 if (inode)
2786 iput(inode);
2787 } 2777 }
2788} 2778}
2789 2779
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index e96eb0835f..bc823720d8 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -305,6 +305,47 @@ typedef struct xfs_inode {
305#endif 305#endif
306} xfs_inode_t; 306} xfs_inode_t;
307 307
308
309/*
310 * i_flags helper functions
311 */
312static inline void
313__xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
314{
315 ip->i_flags |= flags;
316}
317
318static inline void
319xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
320{
321 spin_lock(&ip->i_flags_lock);
322 __xfs_iflags_set(ip, flags);
323 spin_unlock(&ip->i_flags_lock);
324}
325
326static inline void
327xfs_iflags_clear(xfs_inode_t *ip, unsigned short flags)
328{
329 spin_lock(&ip->i_flags_lock);
330 ip->i_flags &= ~flags;
331 spin_unlock(&ip->i_flags_lock);
332}
333
334static inline int
335__xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
336{
337 return (ip->i_flags & flags);
338}
339
340static inline int
341xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
342{
343 int ret;
344 spin_lock(&ip->i_flags_lock);
345 ret = __xfs_iflags_test(ip, flags);
346 spin_unlock(&ip->i_flags_lock);
347 return ret;
348}
308#endif /* __KERNEL__ */ 349#endif /* __KERNEL__ */
309 350
310 351
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 061e2ffdd1..bda774a04b 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -1013,7 +1013,7 @@ xfs_readlink(
1013 pathlen = (int)ip->i_d.di_size; 1013 pathlen = (int)ip->i_d.di_size;
1014 1014
1015 if (ip->i_df.if_flags & XFS_IFINLINE) { 1015 if (ip->i_df.if_flags & XFS_IFINLINE) {
1016 error = uio_read(ip->i_df.if_u1.if_data, pathlen, uiop); 1016 error = xfs_uio_read(ip->i_df.if_u1.if_data, pathlen, uiop);
1017 } 1017 }
1018 else { 1018 else {
1019 /* 1019 /*
@@ -1044,7 +1044,7 @@ xfs_readlink(
1044 byte_cnt = pathlen; 1044 byte_cnt = pathlen;
1045 pathlen -= byte_cnt; 1045 pathlen -= byte_cnt;
1046 1046
1047 error = uio_read(XFS_BUF_PTR(bp), byte_cnt, uiop); 1047 error = xfs_uio_read(XFS_BUF_PTR(bp), byte_cnt, uiop);
1048 xfs_buf_relse (bp); 1048 xfs_buf_relse (bp);
1049 } 1049 }
1050 1050
@@ -3827,11 +3827,16 @@ xfs_reclaim(
3827 */ 3827 */
3828 xfs_synchronize_atime(ip); 3828 xfs_synchronize_atime(ip);
3829 3829
3830 /* If we have nothing to flush with this inode then complete the 3830 /*
3831 * teardown now, otherwise break the link between the xfs inode 3831 * If we have nothing to flush with this inode then complete the
3832 * and the linux inode and clean up the xfs inode later. This 3832 * teardown now, otherwise break the link between the xfs inode and the
3833 * avoids flushing the inode to disk during the delete operation 3833 * linux inode and clean up the xfs inode later. This avoids flushing
3834 * itself. 3834 * the inode to disk during the delete operation itself.
3835 *
3836 * When breaking the link, we need to set the XFS_IRECLAIMABLE flag
3837 * first to ensure that xfs_iunpin() will never see an xfs inode
3838 * that has a linux inode being reclaimed. Synchronisation is provided
3839 * by the i_flags_lock.
3835 */ 3840 */
3836 if (!ip->i_update_core && (ip->i_itemp == NULL)) { 3841 if (!ip->i_update_core && (ip->i_itemp == NULL)) {
3837 xfs_ilock(ip, XFS_ILOCK_EXCL); 3842 xfs_ilock(ip, XFS_ILOCK_EXCL);
@@ -3840,13 +3845,13 @@ xfs_reclaim(
3840 } else { 3845 } else {
3841 xfs_mount_t *mp = ip->i_mount; 3846 xfs_mount_t *mp = ip->i_mount;
3842 3847
3843 /* Protect sync from us */ 3848 /* Protect sync and unpin from us */
3844 XFS_MOUNT_ILOCK(mp); 3849 XFS_MOUNT_ILOCK(mp);
3845 vn_bhv_remove(VN_BHV_HEAD(vp), XFS_ITOBHV(ip));
3846 list_add_tail(&ip->i_reclaim, &mp->m_del_inodes);
3847 spin_lock(&ip->i_flags_lock); 3850 spin_lock(&ip->i_flags_lock);
3848 ip->i_flags |= XFS_IRECLAIMABLE; 3851 __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
3852 vn_bhv_remove(VN_BHV_HEAD(vp), XFS_ITOBHV(ip));
3849 spin_unlock(&ip->i_flags_lock); 3853 spin_unlock(&ip->i_flags_lock);
3854 list_add_tail(&ip->i_reclaim, &mp->m_del_inodes);
3850 XFS_MOUNT_IUNLOCK(mp); 3855 XFS_MOUNT_IUNLOCK(mp);
3851 } 3856 }
3852 return 0; 3857 return 0;
@@ -3872,8 +3877,8 @@ xfs_finish_reclaim(
3872 */ 3877 */
3873 write_lock(&ih->ih_lock); 3878 write_lock(&ih->ih_lock);
3874 spin_lock(&ip->i_flags_lock); 3879 spin_lock(&ip->i_flags_lock);
3875 if ((ip->i_flags & XFS_IRECLAIM) || 3880 if (__xfs_iflags_test(ip, XFS_IRECLAIM) ||
3876 (!(ip->i_flags & XFS_IRECLAIMABLE) && vp == NULL)) { 3881 (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) && vp == NULL)) {
3877 spin_unlock(&ip->i_flags_lock); 3882 spin_unlock(&ip->i_flags_lock);
3878 write_unlock(&ih->ih_lock); 3883 write_unlock(&ih->ih_lock);
3879 if (locked) { 3884 if (locked) {
@@ -3882,7 +3887,7 @@ xfs_finish_reclaim(
3882 } 3887 }
3883 return 1; 3888 return 1;
3884 } 3889 }
3885 ip->i_flags |= XFS_IRECLAIM; 3890 __xfs_iflags_set(ip, XFS_IRECLAIM);
3886 spin_unlock(&ip->i_flags_lock); 3891 spin_unlock(&ip->i_flags_lock);
3887 write_unlock(&ih->ih_lock); 3892 write_unlock(&ih->ih_lock);
3888 3893
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-29 03:03:46 -0400