From: Daniel McNeil This adds i_seqcount to the inode structure and then uses i_size_read() and i_size_write() to provide atomic access to i_size. This is a port of Andrea Arcangeli's i_size atomic access patch from 2.4. This only uses the generic reader/writer consistent mechanism. Before: mnm:/usr/src/25> size vmlinux text data bss dec hex filename 2229582 1027683 162436 3419701 342e35 vmlinux After: mnm:/usr/src/25> size vmlinux text data bss dec hex filename 2225642 1027655 162436 3415733 341eb5 vmlinux 3.9k more text, a lot of it fastpath :( drivers/block/loop.c | 2 - fs/attr.c | 2 - fs/binfmt_aout.c | 4 +-- fs/block_dev.c | 6 ++-- fs/buffer.c | 17 ++++++++----- fs/direct-io.c | 8 ++++-- fs/ext3/inode.c | 4 +-- fs/inode.c | 1 fs/ioctl.c | 2 - fs/libfs.c | 6 ++++ fs/locks.c | 4 +-- fs/mpage.c | 8 +++--- fs/nfs/inode.c | 8 ++++-- fs/nfs/write.c | 21 ++++++++--------- fs/open.c | 2 - fs/quota_v1.c | 8 ++++-- fs/read_write.c | 4 +-- fs/stat.c | 2 - include/linux/fs.h | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++ ipc/shm.c | 2 - mm/filemap.c | 32 ++++++++++++++----------- mm/memory.c | 4 +-- mm/nommu.c | 4 +-- mm/readahead.c | 5 ++-- mm/shmem.c | 18 ++++++++------ mm/swapfile.c | 4 +-- 26 files changed, 164 insertions(+), 77 deletions(-) diff -puN drivers/block/loop.c~i_size-atomic-access drivers/block/loop.c --- 25/drivers/block/loop.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/drivers/block/loop.c 2003-06-19 23:37:08.000000000 -0700 @@ -146,7 +146,7 @@ struct loop_func_table *xfer_funcs[MAX_L static int figure_loop_size(struct loop_device *lo) { - loff_t size = lo->lo_backing_file->f_dentry->d_inode->i_mapping->host->i_size; + loff_t size = i_size_read(lo->lo_backing_file->f_dentry->d_inode->i_mapping->host); sector_t x; /* * Unfortunately, if we want to do I/O on the device, diff -puN fs/attr.c~i_size-atomic-access fs/attr.c --- 25/fs/attr.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/attr.c 2003-06-19 23:37:08.000000000 -0700 @@ -68,7 +68,7 @@ int inode_setattr(struct inode * inode, int error = 0; if (ia_valid & ATTR_SIZE) { - if (attr->ia_size != inode->i_size) { + if (attr->ia_size != i_size_read(inode)) { error = vmtruncate(inode, attr->ia_size); if (error || (ia_valid == ATTR_SIZE)) goto out; diff -puN fs/binfmt_aout.c~i_size-atomic-access fs/binfmt_aout.c --- 25/fs/binfmt_aout.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/binfmt_aout.c 2003-06-19 23:37:08.000000000 -0700 @@ -269,7 +269,7 @@ static int load_aout_binary(struct linux if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC && N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) || N_TRSIZE(ex) || N_DRSIZE(ex) || - bprm->file->f_dentry->d_inode->i_size < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) { + i_size_read(bprm->file->f_dentry->d_inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) { return -ENOEXEC; } @@ -454,7 +454,7 @@ static int load_aout_library(struct file /* We come in here for the regular a.out style of shared libraries */ if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || N_TRSIZE(ex) || N_DRSIZE(ex) || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) || - inode->i_size < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) { + i_size_read(inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) { goto out; } diff -puN fs/block_dev.c~i_size-atomic-access fs/block_dev.c --- 25/fs/block_dev.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/block_dev.c 2003-06-19 23:37:08.000000000 -0700 @@ -29,7 +29,7 @@ static sector_t max_block(struct block_device *bdev) { sector_t retval = ~((sector_t)0); - loff_t sz = bdev->bd_inode->i_size; + loff_t sz = i_size_read(bdev->bd_inode); if (sz) { unsigned int size = block_size(bdev); @@ -156,7 +156,7 @@ static int blkdev_commit_write(struct fi static loff_t block_llseek(struct file *file, loff_t offset, int origin) { /* ewww */ - loff_t size = file->f_dentry->d_inode->i_bdev->bd_inode->i_size; + loff_t size = i_size_read(file->f_dentry->d_inode->i_bdev->bd_inode); loff_t retval; lock_kernel(); @@ -485,7 +485,7 @@ int check_disk_change(struct block_devic static void bd_set_size(struct block_device *bdev, loff_t size) { unsigned bsize = bdev_hardsect_size(bdev); - bdev->bd_inode->i_size = size; + i_size_write(bdev->bd_inode, size); while (bsize < PAGE_CACHE_SIZE) { if (size & bsize) break; diff -puN fs/buffer.c~i_size-atomic-access fs/buffer.c --- 25/fs/buffer.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/buffer.c 2003-06-19 23:37:08.000000000 -0700 @@ -1758,7 +1758,7 @@ static int __block_write_full_page(struc BUG_ON(!PageLocked(page)); - last_block = (inode->i_size - 1) >> inode->i_blkbits; + last_block = (i_size_read(inode) - 1) >> inode->i_blkbits; if (!page_has_buffers(page)) { if (!PageUptodate(page)) @@ -2095,7 +2095,7 @@ int block_read_full_page(struct page *pa head = page_buffers(page); iblock = (sector_t)page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits); - lblock = (inode->i_size+blocksize-1) >> inode->i_blkbits; + lblock = (i_size_read(inode)+blocksize-1) >> inode->i_blkbits; bh = head; nr = 0; i = 0; @@ -2320,8 +2320,12 @@ int generic_commit_write(struct file *fi struct inode *inode = page->mapping->host; loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; __block_commit_write(inode,page,from,to); + /* + * No need to use i_size_read() here, the i_size + * cannot change under us because we hold i_sem. + */ if (pos > inode->i_size) { - inode->i_size = pos; + i_size_write(inode, pos); mark_inode_dirty(inode); } return 0; @@ -2473,7 +2477,7 @@ int nobh_commit_write(struct file *file, set_page_dirty(page); if (pos > inode->i_size) { - inode->i_size = pos; + i_size_write(inode, pos); mark_inode_dirty(inode); } return 0; @@ -2603,7 +2607,8 @@ int block_write_full_page(struct page *p struct writeback_control *wbc) { struct inode * const inode = page->mapping->host; - const unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT; + loff_t i_size = i_size_read(inode); + const unsigned long end_index = i_size >> PAGE_CACHE_SHIFT; unsigned offset; void *kaddr; @@ -2612,7 +2617,7 @@ int block_write_full_page(struct page *p return __block_write_full_page(inode, page, get_block, wbc); /* Is the page fully outside i_size? (truncate in progress) */ - offset = inode->i_size & (PAGE_CACHE_SIZE-1); + offset = i_size & (PAGE_CACHE_SIZE-1); if (page->index >= end_index+1 || !offset) { /* * The page may have dirty, unmapped buffers. For example, diff -puN fs/direct-io.c~i_size-atomic-access fs/direct-io.c --- 25/fs/direct-io.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/direct-io.c 2003-06-19 23:37:09.000000000 -0700 @@ -757,7 +757,7 @@ do_holes: char *kaddr; if (dio->block_in_file >= - dio->inode->i_size>>blkbits) { + i_size_read(dio->inode)>>blkbits) { /* We hit eof */ page_cache_release(page); goto out; @@ -943,13 +943,15 @@ direct_io_worker(int rw, struct kiocb *i if (ret == 0) ret = dio->page_errors; if (ret == 0 && dio->result) { + loff_t i_size = i_size_read(inode); + ret = dio->result; /* * Adjust the return value if the read crossed a * non-block-aligned EOF. */ - if (rw == READ && (offset + ret > inode->i_size)) - ret = inode->i_size - offset; + if (rw == READ && (offset + ret > i_size)) + ret = i_size - offset; } kfree(dio); } diff -puN fs/ext3/inode.c~i_size-atomic-access fs/ext3/inode.c --- 25/fs/ext3/inode.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/ext3/inode.c 2003-06-19 23:37:08.000000000 -0700 @@ -1200,7 +1200,7 @@ static int ext3_journalled_commit_write( if (!partial) SetPageUptodate(page); if (pos > inode->i_size) - inode->i_size = pos; + i_size_write(inode, pos); EXT3_I(inode)->i_state |= EXT3_STATE_JDATA; if (inode->i_size > EXT3_I(inode)->i_disksize) { EXT3_I(inode)->i_disksize = inode->i_size; @@ -1574,7 +1574,7 @@ out_stop: loff_t end = offset + ret; if (end > inode->i_size) { ei->i_disksize = end; - inode->i_size = end; + i_size_write(inode, end); err = ext3_mark_inode_dirty(handle, inode); if (!ret) ret = err; diff -puN fs/inode.c~i_size-atomic-access fs/inode.c --- 25/fs/inode.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/inode.c 2003-06-19 23:37:08.000000000 -0700 @@ -190,6 +190,7 @@ void inode_init_once(struct inode *inode INIT_LIST_HEAD(&inode->i_data.i_mmap); INIT_LIST_HEAD(&inode->i_data.i_mmap_shared); spin_lock_init(&inode->i_lock); + i_size_ordered_init(inode); } static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) diff -puN fs/ioctl.c~i_size-atomic-access fs/ioctl.c --- 25/fs/ioctl.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/ioctl.c 2003-06-19 23:37:08.000000000 -0700 @@ -40,7 +40,7 @@ static int file_ioctl(struct file *filp, return -EBADF; return put_user(inode->i_sb->s_blocksize, (int *) arg); case FIONREAD: - return put_user(inode->i_size - filp->f_pos, (int *) arg); + return put_user(i_size_read(inode) - filp->f_pos, (int *) arg); } if (filp->f_op && filp->f_op->ioctl) return filp->f_op->ioctl(inode, filp, cmd, arg); diff -puN fs/libfs.c~i_size-atomic-access fs/libfs.c --- 25/fs/libfs.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/libfs.c 2003-06-19 23:37:08.000000000 -0700 @@ -328,8 +328,12 @@ int simple_commit_write(struct file *fil struct inode *inode = page->mapping->host; loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; + /* + * No need to use i_size_read() here, the i_size + * cannot change under us because we hold the i_sem. + */ if (pos > inode->i_size) - inode->i_size = pos; + i_size_write(inode, pos); set_page_dirty(page); return 0; } diff -puN fs/locks.c~i_size-atomic-access fs/locks.c --- 25/fs/locks.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/locks.c 2003-06-19 23:37:08.000000000 -0700 @@ -285,7 +285,7 @@ static int flock_to_posix_lock(struct fi start = filp->f_pos; break; case 2: /*SEEK_END*/ - start = filp->f_dentry->d_inode->i_size; + start = i_size_read(filp->f_dentry->d_inode); break; default: return -EINVAL; @@ -335,7 +335,7 @@ static int flock64_to_posix_lock(struct start = filp->f_pos; break; case 2: /*SEEK_END*/ - start = filp->f_dentry->d_inode->i_size; + start = i_size_read(filp->f_dentry->d_inode); break; default: return -EINVAL; diff -puN fs/mpage.c~i_size-atomic-access fs/mpage.c --- 25/fs/mpage.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/mpage.c 2003-06-19 23:37:08.000000000 -0700 @@ -227,7 +227,7 @@ do_mpage_readpage(struct bio *bio, struc goto confused; block_in_file = page->index << (PAGE_CACHE_SHIFT - blkbits); - last_block = (inode->i_size + blocksize - 1) >> blkbits; + last_block = (i_size_read(inode) + blocksize - 1) >> blkbits; bh.b_page = page; for (page_block = 0; page_block < blocks_per_page; @@ -459,7 +459,7 @@ mpage_writepage(struct bio *bio, struct */ BUG_ON(!PageUptodate(page)); block_in_file = page->index << (PAGE_CACHE_SHIFT - blkbits); - last_block = (inode->i_size - 1) >> blkbits; + last_block = (i_size_read(inode) - 1) >> blkbits; map_bh.b_page = page; for (page_block = 0; page_block < blocks_per_page; ) { @@ -489,9 +489,9 @@ mpage_writepage(struct bio *bio, struct first_unmapped = page_block; - end_index = inode->i_size >> PAGE_CACHE_SHIFT; + end_index = i_size_read(inode) >> PAGE_CACHE_SHIFT; if (page->index >= end_index) { - unsigned offset = inode->i_size & (PAGE_CACHE_SIZE - 1); + unsigned offset = i_size_read(inode) & (PAGE_CACHE_SIZE - 1); char *kaddr; if (page->index > end_index || !offset) diff -puN fs/nfs/inode.c~i_size-atomic-access fs/nfs/inode.c --- 25/fs/nfs/inode.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/nfs/inode.c 2003-06-19 23:37:09.000000000 -0700 @@ -1001,6 +1001,7 @@ __nfs_refresh_inode(struct inode *inode, loff_t new_isize; int invalid = 0; int mtime_update = 0; + loff_t cur_isize; dfprintk(VFS, "NFS: refresh_inode(%s/%ld ct=%d info=0x%x)\n", inode->i_sb->s_id, inode->i_ino, @@ -1087,8 +1088,9 @@ __nfs_refresh_inode(struct inode *inode, * If we have pending writebacks, things can get * messy. */ - if (nfs_have_writebacks(inode) && new_isize < inode->i_size) - new_isize = inode->i_size; + cur_isize = i_size_read(inode); + if (nfs_have_writebacks(inode) && new_isize < cur_isize) + new_isize = cur_isize; nfsi->read_cache_ctime = fattr->ctime; inode->i_ctime = fattr->ctime; @@ -1102,7 +1104,7 @@ __nfs_refresh_inode(struct inode *inode, } nfsi->read_cache_isize = new_size; - inode->i_size = new_isize; + i_size_write(inode, new_isize); if (inode->i_mode != fattr->mode || inode->i_uid != fattr->uid || diff -puN fs/nfs/write.c~i_size-atomic-access fs/nfs/write.c --- 25/fs/nfs/write.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/nfs/write.c 2003-06-19 23:37:09.000000000 -0700 @@ -187,8 +187,8 @@ nfs_writepage_sync(struct file *file, st * If we've extended the file, update the inode * now so we don't invalidate the cache. */ - if (wdata.args.offset > inode->i_size) - inode->i_size = wdata.args.offset; + if (wdata.args.offset > i_size_read(inode)) + i_size_write(inode, wdata.args.offset); } while (count); if (PageError(page)) @@ -218,8 +218,8 @@ nfs_writepage_async(struct file *file, s nfs_unlock_request(req); nfs_strategy(inode); end = ((loff_t)page->index<i_size < end) - inode->i_size = end; + if (i_size_read(inode) < end) + i_size_write(inode, end); out: return status; @@ -234,9 +234,10 @@ nfs_writepage(struct page *page, struct struct inode *inode = page->mapping->host; unsigned long end_index; unsigned offset = PAGE_CACHE_SIZE; + loff_t i_size = i_size_read(inode); int err; - end_index = inode->i_size >> PAGE_CACHE_SHIFT; + end_index = i_size >> PAGE_CACHE_SHIFT; /* Ensure we've flushed out any previous writes */ nfs_wb_page(inode,page); @@ -245,7 +246,7 @@ nfs_writepage(struct page *page, struct if (page->index < end_index) goto do_it; /* things got complicated... */ - offset = inode->i_size & (PAGE_CACHE_SIZE-1); + offset = i_size & (PAGE_CACHE_SIZE-1); /* OK, are we completely out? */ err = -EIO; @@ -708,8 +709,8 @@ nfs_updatepage(struct file *file, struct status = 0; end = ((loff_t)page->index<i_size < end) - inode->i_size = end; + if (i_size_read(inode) < end) + i_size_write(inode, end); /* If we wrote past the end of the page. * Call the strategy routine so it can send out a bunch @@ -723,7 +724,7 @@ nfs_updatepage(struct file *file, struct nfs_unlock_request(req); done: dprintk("NFS: nfs_updatepage returns %d (isize %Ld)\n", - status, (long long)inode->i_size); + status, (long long)i_size_read(inode)); if (status < 0) ClearPageUptodate(page); return status; @@ -958,7 +959,7 @@ nfs_commit_rpcsetup(struct list_head *he end = req_offset(last) + last->wb_bytes; len = end - start; /* If 'len' is not a 32-bit quantity, pass '0' in the COMMIT call */ - if (end >= inode->i_size || len < 0 || len > (~((u32)0) >> 1)) + if (end >= i_size_read(inode) || len < 0 || len > (~((u32)0) >> 1)) len = 0; data->inode = inode; diff -puN fs/open.c~i_size-atomic-access fs/open.c --- 25/fs/open.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/open.c 2003-06-19 23:37:08.000000000 -0700 @@ -1011,7 +1011,7 @@ asmlinkage long sys_vhangup(void) */ int generic_file_open(struct inode * inode, struct file * filp) { - if (!(filp->f_flags & O_LARGEFILE) && inode->i_size > MAX_NON_LFS) + if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS) return -EFBIG; return 0; } diff -puN fs/quota_v1.c~i_size-atomic-access fs/quota_v1.c --- 25/fs/quota_v1.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/quota_v1.c 2003-06-19 23:37:08.000000000 -0700 @@ -132,12 +132,14 @@ static int v1_check_quota_file(struct su mm_segment_t fs; ssize_t size; loff_t offset = 0; + loff_t isize; static const uint quota_magics[] = V2_INITQMAGICS; - if (!inode->i_size) + isize = i_size_read(inode); + if (!isize) return 0; - blocks = inode->i_size >> BLOCK_SIZE_BITS; - off = inode->i_size & (BLOCK_SIZE - 1); + blocks = isize >> BLOCK_SIZE_BITS; + off = isize & (BLOCK_SIZE - 1); if ((blocks % sizeof(struct v1_disk_dqblk) * BLOCK_SIZE + off) % sizeof(struct v1_disk_dqblk)) return 0; /* Doublecheck whether we didn't get file with new format - with old quotactl() this could happen */ diff -puN fs/read_write.c~i_size-atomic-access fs/read_write.c --- 25/fs/read_write.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/read_write.c 2003-06-19 23:37:09.000000000 -0700 @@ -55,7 +55,7 @@ loff_t remote_llseek(struct file *file, lock_kernel(); switch (origin) { case 2: - offset += file->f_dentry->d_inode->i_size; + offset += i_size_read(file->f_dentry->d_inode); break; case 1: offset += file->f_pos; @@ -84,7 +84,7 @@ loff_t default_llseek(struct file *file, lock_kernel(); switch (origin) { case 2: - offset += file->f_dentry->d_inode->i_size; + offset += i_size_read(file->f_dentry->d_inode); break; case 1: offset += file->f_pos; diff -puN fs/stat.c~i_size-atomic-access fs/stat.c --- 25/fs/stat.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/fs/stat.c 2003-06-19 23:37:08.000000000 -0700 @@ -28,7 +28,7 @@ void generic_fillattr(struct inode *inod stat->atime = inode->i_atime; stat->mtime = inode->i_mtime; stat->ctime = inode->i_ctime; - stat->size = inode->i_size; + stat->size = i_size_read(inode); stat->blocks = inode->i_blocks; stat->blksize = inode->i_blksize; } diff -puN include/linux/fs.h~i_size-atomic-access include/linux/fs.h --- 25/include/linux/fs.h~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/include/linux/fs.h 2003-06-19 23:37:08.000000000 -0700 @@ -350,6 +350,17 @@ struct block_device { struct gendisk * bd_disk; }; +/* + * Use sequence counter to get consistent i_size on 32-bit processors. + */ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) +#include +#define __NEED_I_SIZE_ORDERED +#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount) +#else +#define i_size_ordered_init(inode) do { } while (0) +#endif + struct inode { struct hlist_node i_hash; struct list_head i_list; @@ -400,8 +411,60 @@ struct inode { union { void *generic_ip; } u; +#ifdef __NEED_I_SIZE_ORDERED + seqcount_t i_size_seqcount; +#endif }; +/* + * NOTE: in a 32bit arch with a preemptable kernel and + * an UP compile the i_size_read/write must be atomic + * with respect to the local cpu (unlike with preempt disabled), + * but they don't need to be atomic with respect to other cpus like in + * true SMP (so they need either to either locally disable irq around + * the read or for example on x86 they can be still implemented as a + * cmpxchg8b without the need of the lock prefix). For SMP compiles + * and 64bit archs it makes no difference if preempt is enabled or not. + */ +static inline loff_t i_size_read(struct inode *inode) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + loff_t i_size; + unsigned int seq; + + do { + seq = read_seqcount_begin(&inode->i_size_seqcount); + i_size = inode->i_size; + } while (read_seqcount_retry(&inode->i_size_seqcount, seq)); + return i_size; +#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT) + loff_t i_size; + + preempt_disable(); + i_size = inode->i_size; + preempt_enable(); + return i_size; +#else + return inode->i_size; +#endif +} + + +static inline void i_size_write(struct inode *inode, loff_t i_size) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + write_seqcount_begin(&inode->i_size_seqcount); + inode->i_size = i_size; + write_seqcount_end(&inode->i_size_seqcount); +#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT) + preempt_disable(); + inode->i_size = i_size; + preempt_enable(); +#else + inode->i_size = i_size; +#endif +} + struct fown_struct { rwlock_t lock; /* protects pid, uid, euid fields */ int pid; /* pid or -pgrp where SIGIO should be sent */ diff -puN ipc/shm.c~i_size-atomic-access ipc/shm.c --- 25/ipc/shm.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/ipc/shm.c 2003-06-19 23:37:08.000000000 -0700 @@ -703,7 +703,7 @@ long sys_shmat(int shmid, char __user *s } file = shp->shm_file; - size = file->f_dentry->d_inode->i_size; + size = i_size_read(file->f_dentry->d_inode); shp->shm_nattch++; shm_unlock(shp); diff -puN mm/filemap.c~i_size-atomic-access mm/filemap.c --- 25/mm/filemap.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/mm/filemap.c 2003-06-19 23:37:08.000000000 -0700 @@ -612,14 +612,15 @@ void do_generic_mapping_read(struct addr for (;;) { struct page *page; unsigned long end_index, nr, ret; + loff_t isize = i_size_read(inode); - end_index = inode->i_size >> PAGE_CACHE_SHIFT; + end_index = isize >> PAGE_CACHE_SHIFT; if (index > end_index) break; nr = PAGE_CACHE_SIZE; if (index == end_index) { - nr = inode->i_size & ~PAGE_CACHE_MASK; + nr = isize & ~PAGE_CACHE_MASK; if (nr <= offset) break; } @@ -836,7 +837,7 @@ __generic_file_aio_read(struct kiocb *io retval = 0; if (!count) goto out; /* skip atime */ - size = inode->i_size; + size = i_size_read(inode); if (pos < size) { retval = generic_file_direct_IO(READ, iocb, iov, pos, nr_segs); @@ -1025,7 +1026,7 @@ retry_all: * An external ptracer can access pages that normally aren't * accessible.. */ - size = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; + size = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; if ((pgoff >= size) && (area->vm_mm == current->mm)) return NULL; @@ -1292,7 +1293,7 @@ static int filemap_populate(struct vm_ar pgoff, len >> PAGE_CACHE_SHIFT); repeat: - size = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; + size = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; if (pgoff + (len >> PAGE_CACHE_SHIFT) > size) return -EINVAL; @@ -1605,7 +1606,7 @@ inline int generic_write_checks(struct i if (!isblk) { /* FIXME: this is for backwards compatibility with 2.4 */ if (file->f_flags & O_APPEND) - *pos = inode->i_size; + *pos = i_size_read(inode); if (limit != RLIM_INFINITY) { if (*pos >= limit) { @@ -1651,15 +1652,17 @@ inline int generic_write_checks(struct i if (unlikely(*pos + *count > inode->i_sb->s_maxbytes)) *count = inode->i_sb->s_maxbytes - *pos; } else { + loff_t isize; if (bdev_read_only(inode->i_bdev)) return -EPERM; - if (*pos >= inode->i_size) { - if (*count || *pos > inode->i_size) + isize = i_size_read(inode); + if (*pos >= isize) { + if (*count || *pos > isize) return -ENOSPC; } - if (*pos + *count > inode->i_size) - *count = inode->i_size - *pos; + if (*pos + *count > isize) + *count = isize - *pos; } return 0; } @@ -1745,8 +1748,8 @@ generic_file_aio_write_nolock(struct kio iov, pos, nr_segs); if (written > 0) { loff_t end = pos + written; - if (end > inode->i_size && !isblk) { - inode->i_size = end; + if (end > i_size_read(inode) && !isblk) { + i_size_write(inode, end); mark_inode_dirty(inode); } *ppos = end; @@ -1794,14 +1797,15 @@ generic_file_aio_write_nolock(struct kio status = a_ops->prepare_write(file, page, offset, offset+bytes); if (unlikely(status)) { + loff_t isize = i_size_read(inode); /* * prepare_write() may have instantiated a few blocks * outside i_size. Trim these off again. */ unlock_page(page); page_cache_release(page); - if (pos + bytes > inode->i_size) - vmtruncate(inode, inode->i_size); + if (pos + bytes > isize) + vmtruncate(inode, isize); break; } if (likely(nr_segs == 1)) diff -puN mm/memory.c~i_size-atomic-access mm/memory.c --- 25/mm/memory.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/mm/memory.c 2003-06-19 23:37:08.000000000 -0700 @@ -1162,7 +1162,7 @@ int vmtruncate(struct inode * inode, lof if (inode->i_size < offset) goto do_expand; - inode->i_size = offset; + i_size_write(inode, offset); invalidate_mmap_range(mapping, offset + PAGE_SIZE - 1, 0); truncate_inode_pages(mapping, offset); goto out_truncate; @@ -1173,7 +1173,7 @@ do_expand: goto out_sig; if (offset > inode->i_sb->s_maxbytes) goto out; - inode->i_size = offset; + i_size_write(inode, offset); out_truncate: if (inode->i_op && inode->i_op->truncate) diff -puN mm/nommu.c~i_size-atomic-access mm/nommu.c --- 25/mm/nommu.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/mm/nommu.c 2003-06-19 23:37:08.000000000 -0700 @@ -48,7 +48,7 @@ int vmtruncate(struct inode *inode, loff if (inode->i_size < offset) goto do_expand; - inode->i_size = offset; + i_size_write(inode, offset); truncate_inode_pages(mapping, offset); goto out_truncate; @@ -59,7 +59,7 @@ do_expand: goto out_sig; if (offset > inode->i_sb->s_maxbytes) goto out; - inode->i_size = offset; + i_size_write(inode, offset); out_truncate: if (inode->i_op && inode->i_op->truncate) { diff -puN mm/readahead.c~i_size-atomic-access mm/readahead.c --- 25/mm/readahead.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/mm/readahead.c 2003-06-19 23:37:08.000000000 -0700 @@ -208,11 +208,12 @@ __do_page_cache_readahead(struct address LIST_HEAD(page_pool); int page_idx; int ret = 0; + loff_t isize = i_size_read(inode); - if (inode->i_size == 0) + if (isize == 0) goto out; - end_index = ((inode->i_size - 1) >> PAGE_CACHE_SHIFT); + end_index = ((isize - 1) >> PAGE_CACHE_SHIFT); /* * Preallocate as many pages as we will need. diff -puN mm/shmem.c~i_size-atomic-access mm/shmem.c --- 25/mm/shmem.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/mm/shmem.c 2003-06-19 23:37:08.000000000 -0700 @@ -298,7 +298,7 @@ static swp_entry_t *shmem_swp_alloc(stru static const swp_entry_t unswapped = {0}; if (sgp != SGP_WRITE && - ((loff_t) index << PAGE_CACHE_SHIFT) >= inode->i_size) + ((loff_t) index << PAGE_CACHE_SHIFT) >= i_size_read(inode)) return ERR_PTR(-EINVAL); while (!(entry = shmem_swp_entry(info, index, &page))) { @@ -331,7 +331,7 @@ static swp_entry_t *shmem_swp_alloc(stru return ERR_PTR(-ENOMEM); } if (sgp != SGP_WRITE && - ((loff_t) index << PAGE_CACHE_SHIFT) >= inode->i_size) { + ((loff_t) index << PAGE_CACHE_SHIFT) >= i_size_read(inode)) { entry = ERR_PTR(-EINVAL); break; } @@ -640,7 +640,7 @@ found: /* Racing against delete or truncate? Must leave out of page cache */ limit = (inode->i_state & I_FREEING)? 0: - (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; + (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; if (idx >= limit || move_from_swap_cache(page, idx, inode->i_mapping) == 0) @@ -963,7 +963,7 @@ static int shmem_populate(struct vm_area enum sgp_type sgp = nonblock? SGP_QUICK: SGP_CACHE; unsigned long size; - size = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; + size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT; if (pgoff >= size || pgoff + (len >> PAGE_SHIFT) > size) return -EINVAL; @@ -1238,12 +1238,13 @@ static void do_shmem_file_read(struct fi for (;;) { struct page *page = NULL; unsigned long end_index, nr, ret; + loff_t i_size = i_size_read(inode); - end_index = inode->i_size >> PAGE_CACHE_SHIFT; + end_index = i_size >> PAGE_CACHE_SHIFT; if (index > end_index) break; if (index == end_index) { - nr = inode->i_size & ~PAGE_CACHE_MASK; + nr = i_size & ~PAGE_CACHE_MASK; if (nr <= offset) break; } @@ -1260,9 +1261,10 @@ static void do_shmem_file_read(struct fi * are called without i_sem protection against truncate */ nr = PAGE_CACHE_SIZE; - end_index = inode->i_size >> PAGE_CACHE_SHIFT; + i_size = i_size_read(inode); + end_index = i_size >> PAGE_CACHE_SHIFT; if (index == end_index) { - nr = inode->i_size & ~PAGE_CACHE_MASK; + nr = i_size & ~PAGE_CACHE_MASK; if (nr <= offset) { page_cache_release(page); break; diff -puN mm/swapfile.c~i_size-atomic-access mm/swapfile.c --- 25/mm/swapfile.c~i_size-atomic-access 2003-06-19 23:37:08.000000000 -0700 +++ 25-akpm/mm/swapfile.c 2003-06-19 23:37:09.000000000 -0700 @@ -922,7 +922,7 @@ static int setup_swap_extents(struct swa */ probe_block = 0; page_no = 0; - last_block = inode->i_size >> blkbits; + last_block = i_size_read(inode) >> blkbits; while ((probe_block + blocks_per_page) <= last_block && page_no < sis->max) { unsigned block_in_page; @@ -1308,7 +1308,7 @@ asmlinkage long sys_swapon(const char __ goto bad_swap; } - swapfilesize = mapping->host->i_size >> PAGE_SHIFT; + swapfilesize = i_size_read(mapping->host) >> PAGE_SHIFT; /* * Read the swap header. _