PCI: replace pr_debug with dev_dbg

[safe/jmp/linux-2.6] / fs / ntfs / file.c

diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 2f9b5a0..663c0e3 100644 (file)
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -1,7 +1,7 @@
 /*
  * file.c - NTFS kernel file operations.  Part of the Linux-NTFS project.
  *
 /*
  * file.c - NTFS kernel file operations.  Part of the Linux-NTFS project.
  *

- * Copyright (c) 2001-2006 Anton Altaparmakov
+ * Copyright (c) 2001-2007 Anton Altaparmakov

  *
  * This program/include file is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as published
  *
  * This program/include file is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as published


@@ -61,7 +61,7 @@ static int ntfs_file_open(struct inode *vi, struct file *filp)
 {
        if (sizeof(unsigned long) < 8) {
                if (i_size_read(vi) > MAX_LFS_FILESIZE)
 {
        if (sizeof(unsigned long) < 8) {
                if (i_size_read(vi) > MAX_LFS_FILESIZE)

-                       return -EFBIG;
+                       return -EOVERFLOW;

        }
        return generic_file_open(vi, filp);
 }
        }
        return generic_file_open(vi, filp);
 }


@@ -236,8 +236,7 @@ do_non_resident_extend:
                        err = PTR_ERR(page);
                        goto init_err_out;
                }
                        err = PTR_ERR(page);
                        goto init_err_out;
                }

-               wait_on_page_locked(page);
-               if (unlikely(!PageUptodate(page) || PageError(page))) {
+               if (unlikely(PageError(page))) {

                        page_cache_release(page);
                        err = -EIO;
                        goto init_err_out;
                        page_cache_release(page);
                        err = -EIO;
                        goto init_err_out;


@@ -362,7 +361,7 @@ static inline void ntfs_fault_in_pages_readable(const char __user *uaddr,
        volatile char c;
 
        /* Set @end to the first byte outside the last page we care about. */
        volatile char c;
 
        /* Set @end to the first byte outside the last page we care about. */

-       end = (const char __user*)PAGE_ALIGN((ptrdiff_t __user)uaddr + bytes);
+       end = (const char __user*)PAGE_ALIGN((unsigned long)uaddr + bytes);

 
        while (!__get_user(c, uaddr) && (uaddr += PAGE_SIZE, uaddr < end))
                ;
 
        while (!__get_user(c, uaddr) && (uaddr += PAGE_SIZE, uaddr < end))
                ;


@@ -440,7 +439,7 @@ static inline int __ntfs_grab_cache_pages(struct address_space *mapping,
                        pages[nr] = *cached_page;
                        page_cache_get(*cached_page);
                        if (unlikely(!pagevec_add(lru_pvec, *cached_page)))
                        pages[nr] = *cached_page;
                        page_cache_get(*cached_page);
                        if (unlikely(!pagevec_add(lru_pvec, *cached_page)))

-                               __pagevec_lru_add(lru_pvec);
+                               __pagevec_lru_add_file(lru_pvec);

                        *cached_page = NULL;
                }
                index++;
                        *cached_page = NULL;
                }
                index++;


@@ -532,7 +531,8 @@ static int ntfs_prepare_pages_for_non_resident_write(struct page **pages,
        blocksize_bits = vol->sb->s_blocksize_bits;
        u = 0;
        do {
        blocksize_bits = vol->sb->s_blocksize_bits;
        u = 0;
        do {

-               struct page *page = pages[u];
+               page = pages[u];
+               BUG_ON(!page);

                /*
                 * create_empty_buffers() will create uptodate/dirty buffers if
                 * the page is uptodate/dirty.
                /*
                 * create_empty_buffers() will create uptodate/dirty buffers if
                 * the page is uptodate/dirty.


@@ -607,11 +607,8 @@ do_next_page:
                                        ntfs_submit_bh_for_read(bh);
                                        *wait_bh++ = bh;
                                } else {
                                        ntfs_submit_bh_for_read(bh);
                                        *wait_bh++ = bh;
                                } else {

-                                       u8 *kaddr = kmap_atomic(page, KM_USER0);
-                                       memset(kaddr + bh_offset(bh), 0,
+                                       zero_user(page, bh_offset(bh),

                                                        blocksize);
                                                        blocksize);

-                                       kunmap_atomic(kaddr, KM_USER0);
-                                       flush_dcache_page(page);

                                        set_buffer_uptodate(bh);
                                }
                        }
                                        set_buffer_uptodate(bh);
                                }
                        }


@@ -686,12 +683,8 @@ map_buffer_cached:
                                                ntfs_submit_bh_for_read(bh);
                                                *wait_bh++ = bh;
                                        } else {
                                                ntfs_submit_bh_for_read(bh);
                                                *wait_bh++ = bh;
                                        } else {

-                                               u8 *kaddr = kmap_atomic(page,
-                                                               KM_USER0);
-                                               memset(kaddr + bh_offset(bh),
-                                                               0, blocksize);
-                                               kunmap_atomic(kaddr, KM_USER0);
-                                               flush_dcache_page(page);
+                                               zero_user(page, bh_offset(bh),
+                                                               blocksize);

                                                set_buffer_uptodate(bh);
                                        }
                                }
                                                set_buffer_uptodate(bh);
                                        }
                                }


@@ -709,11 +702,8 @@ map_buffer_cached:
                         */
                        if (bh_end <= pos || bh_pos >= end) {
                                if (!buffer_uptodate(bh)) {
                         */
                        if (bh_end <= pos || bh_pos >= end) {
                                if (!buffer_uptodate(bh)) {

-                                       u8 *kaddr = kmap_atomic(page, KM_USER0);
-                                       memset(kaddr + bh_offset(bh), 0,
+                                       zero_user(page, bh_offset(bh),

                                                        blocksize);
                                                        blocksize);

-                                       kunmap_atomic(kaddr, KM_USER0);
-                                       flush_dcache_page(page);

                                        set_buffer_uptodate(bh);
                                }
                                mark_buffer_dirty(bh);
                                        set_buffer_uptodate(bh);
                                }
                                mark_buffer_dirty(bh);


@@ -752,10 +742,7 @@ map_buffer_cached:
                                if (!buffer_uptodate(bh))
                                        set_buffer_uptodate(bh);
                        } else if (!buffer_uptodate(bh)) {
                                if (!buffer_uptodate(bh))
                                        set_buffer_uptodate(bh);
                        } else if (!buffer_uptodate(bh)) {

-                               u8 *kaddr = kmap_atomic(page, KM_USER0);
-                               memset(kaddr + bh_offset(bh), 0, blocksize);
-                               kunmap_atomic(kaddr, KM_USER0);
-                               flush_dcache_page(page);
+                               zero_user(page, bh_offset(bh), blocksize);

                                set_buffer_uptodate(bh);
                        }
                        continue;
                                set_buffer_uptodate(bh);
                        }
                        continue;


@@ -879,11 +866,8 @@ rl_not_mapped_enoent:
                                        if (!buffer_uptodate(bh))
                                                set_buffer_uptodate(bh);
                                } else if (!buffer_uptodate(bh)) {
                                        if (!buffer_uptodate(bh))
                                                set_buffer_uptodate(bh);
                                } else if (!buffer_uptodate(bh)) {

-                                       u8 *kaddr = kmap_atomic(page, KM_USER0);
-                                       memset(kaddr + bh_offset(bh), 0,
-                                                       blocksize);
-                                       kunmap_atomic(kaddr, KM_USER0);
-                                       flush_dcache_page(page);
+                                       zero_user(page, bh_offset(bh),
+                                               blocksize);

                                        set_buffer_uptodate(bh);
                                }
                                continue;
                                        set_buffer_uptodate(bh);
                                }
                                continue;


@@ -1138,16 +1122,12 @@ rl_not_mapped_enoent:
                         * to zero the overflowing region.
                         */
                        if (unlikely(bh_pos + blocksize > initialized_size)) {
                         * to zero the overflowing region.
                         */
                        if (unlikely(bh_pos + blocksize > initialized_size)) {

-                               u8 *kaddr;

                                int ofs = 0;
 
                                if (likely(bh_pos < initialized_size))
                                        ofs = initialized_size - bh_pos;
                                int ofs = 0;
 
                                if (likely(bh_pos < initialized_size))
                                        ofs = initialized_size - bh_pos;

-                               kaddr = kmap_atomic(page, KM_USER0);
-                               memset(kaddr + bh_offset(bh) + ofs, 0,
-                                               blocksize - ofs);
-                               kunmap_atomic(kaddr, KM_USER0);
-                               flush_dcache_page(page);
+                               zero_user_segment(page, bh_offset(bh) + ofs,
+                                               blocksize);

                        }
                } else /* if (unlikely(!buffer_uptodate(bh))) */
                        err = -EIO;
                        }
                } else /* if (unlikely(!buffer_uptodate(bh))) */
                        err = -EIO;


@@ -1287,11 +1267,8 @@ rl_not_mapped_enoent:
                                if (PageUptodate(page))
                                        set_buffer_uptodate(bh);
                                else {
                                if (PageUptodate(page))
                                        set_buffer_uptodate(bh);
                                else {

-                                       u8 *kaddr = kmap_atomic(page, KM_USER0);
-                                       memset(kaddr + bh_offset(bh), 0,
+                                       zero_user(page, bh_offset(bh),

                                                        blocksize);
                                                        blocksize);

-                                       kunmap_atomic(kaddr, KM_USER0);
-                                       flush_dcache_page(page);

                                        set_buffer_uptodate(bh);
                                }
                        }
                                        set_buffer_uptodate(bh);
                                }
                        }


@@ -1312,7 +1289,7 @@ static inline size_t ntfs_copy_from_user(struct page **pages,
                size_t bytes)
 {
        struct page **last_page = pages + nr_pages;
                size_t bytes)
 {
        struct page **last_page = pages + nr_pages;

-       char *kaddr;
+       char *addr;

        size_t total = 0;
        unsigned len;
        int left;
        size_t total = 0;
        unsigned len;
        int left;


@@ -1321,13 +1298,13 @@ static inline size_t ntfs_copy_from_user(struct page **pages,
                len = PAGE_CACHE_SIZE - ofs;
                if (len > bytes)
                        len = bytes;
                len = PAGE_CACHE_SIZE - ofs;
                if (len > bytes)
                        len = bytes;

-               kaddr = kmap_atomic(*pages, KM_USER0);
-               left = __copy_from_user_inatomic(kaddr + ofs, buf, len);
-               kunmap_atomic(kaddr, KM_USER0);
+               addr = kmap_atomic(*pages, KM_USER0);
+               left = __copy_from_user_inatomic(addr + ofs, buf, len);
+               kunmap_atomic(addr, KM_USER0);

                if (unlikely(left)) {
                        /* Do it the slow way. */
                if (unlikely(left)) {
                        /* Do it the slow way. */

-                       kaddr = kmap(*pages);
-                       left = __copy_from_user(kaddr + ofs, buf, len);
+                       addr = kmap(*pages);
+                       left = __copy_from_user(addr + ofs, buf, len);

                        kunmap(*pages);
                        if (unlikely(left))
                                goto err_out;
                        kunmap(*pages);
                        if (unlikely(left))
                                goto err_out;


@@ -1351,9 +1328,7 @@ err_out:
                len = PAGE_CACHE_SIZE;
                if (len > bytes)
                        len = bytes;
                len = PAGE_CACHE_SIZE;
                if (len > bytes)
                        len = bytes;

-               kaddr = kmap_atomic(*pages, KM_USER0);
-               memset(kaddr, 0, len);
-               kunmap_atomic(kaddr, KM_USER0);
+               zero_user(*pages, 0, len);

        }
        goto out;
 }
        }
        goto out;
 }


@@ -1431,26 +1406,26 @@ static inline size_t ntfs_copy_from_user_iovec(struct page **pages,
                size_t *iov_ofs, size_t bytes)
 {
        struct page **last_page = pages + nr_pages;
                size_t *iov_ofs, size_t bytes)
 {
        struct page **last_page = pages + nr_pages;

-       char *kaddr;
+       char *addr;

        size_t copied, len, total = 0;
 
        do {
                len = PAGE_CACHE_SIZE - ofs;
                if (len > bytes)
                        len = bytes;
        size_t copied, len, total = 0;
 
        do {
                len = PAGE_CACHE_SIZE - ofs;
                if (len > bytes)
                        len = bytes;

-               kaddr = kmap_atomic(*pages, KM_USER0);
-               copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs,
+               addr = kmap_atomic(*pages, KM_USER0);
+               copied = __ntfs_copy_from_user_iovec_inatomic(addr + ofs,

                                *iov, *iov_ofs, len);
                                *iov, *iov_ofs, len);

-               kunmap_atomic(kaddr, KM_USER0);
+               kunmap_atomic(addr, KM_USER0);

                if (unlikely(copied != len)) {
                        /* Do it the slow way. */
                if (unlikely(copied != len)) {
                        /* Do it the slow way. */

-                       kaddr = kmap(*pages);
-                       copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs,
+                       addr = kmap(*pages);
+                       copied = __ntfs_copy_from_user_iovec_inatomic(addr + ofs,

                                        *iov, *iov_ofs, len);
                        /*
                         * Zero the rest of the target like __copy_from_user().
                         */
                                        *iov, *iov_ofs, len);
                        /*
                         * Zero the rest of the target like __copy_from_user().
                         */

-                       memset(kaddr + ofs + copied, 0, len - copied);
+                       memset(addr + ofs + copied, 0, len - copied);

                        kunmap(*pages);
                        if (unlikely(copied != len))
                                goto err_out;
                        kunmap(*pages);
                        if (unlikely(copied != len))
                                goto err_out;


@@ -1474,9 +1449,7 @@ err_out:
                len = PAGE_CACHE_SIZE;
                if (len > bytes)
                        len = bytes;
                len = PAGE_CACHE_SIZE;
                if (len > bytes)
                        len = bytes;

-               kaddr = kmap_atomic(*pages, KM_USER0);
-               memset(kaddr, 0, len);
-               kunmap_atomic(kaddr, KM_USER0);
+               zero_user(*pages, 0, len);

        }
        goto out;
 }
        }
        goto out;
 }


@@ -1760,8 +1733,6 @@ static int ntfs_commit_pages_after_write(struct page **pages,
        read_unlock_irqrestore(&ni->size_lock, flags);
        BUG_ON(initialized_size != i_size);
        if (end > initialized_size) {
        read_unlock_irqrestore(&ni->size_lock, flags);
        BUG_ON(initialized_size != i_size);
        if (end > initialized_size) {

-               unsigned long flags;
-

                write_lock_irqsave(&ni->size_lock, flags);
                ni->initialized_size = end;
                i_size_write(vi, end);
                write_lock_irqsave(&ni->size_lock, flags);
                ni->initialized_size = end;
                i_size_write(vi, end);


@@ -2105,15 +2076,7 @@ err_out:
        *ppos = pos;
        if (cached_page)
                page_cache_release(cached_page);
        *ppos = pos;
        if (cached_page)
                page_cache_release(cached_page);

-       /* For now, when the user asks for O_SYNC, we actually give O_DSYNC. */
-       if (likely(!status)) {
-               if (unlikely((file->f_flags & O_SYNC) || IS_SYNC(vi))) {
-                       if (!mapping->a_ops->writepage || !is_sync_kiocb(iocb))
-                               status = generic_osync_inode(vi, mapping,
-                                               OSYNC_METADATA|OSYNC_DATA);
-               }
-       }
-       pagevec_lru_add(&lru_pvec);
+       pagevec_lru_add_file(&lru_pvec);

        ntfs_debug("Done.  Returning %s (written 0x%lx, status %li).",
                        written ? "written" : "status", (unsigned long)written,
                        (long)status);
        ntfs_debug("Done.  Returning %s (written 0x%lx, status %li).",
                        written ? "written" : "status", (unsigned long)written,
                        (long)status);


@@ -2130,28 +2093,13 @@ static ssize_t ntfs_file_aio_write_nolock(struct kiocb *iocb,
        struct address_space *mapping = file->f_mapping;
        struct inode *inode = mapping->host;
        loff_t pos;
        struct address_space *mapping = file->f_mapping;
        struct inode *inode = mapping->host;
        loff_t pos;

-       unsigned long seg;

        size_t count;           /* after file limit checks */
        ssize_t written, err;
 
        count = 0;
        size_t count;           /* after file limit checks */
        ssize_t written, err;
 
        count = 0;

-       for (seg = 0; seg < nr_segs; seg++) {
-               const struct iovec *iv = &iov[seg];
-               /*
-                * If any segment has a negative length, or the cumulative
-                * length ever wraps negative then return -EINVAL.
-                */
-               count += iv->iov_len;
-               if (unlikely((ssize_t)(count|iv->iov_len) < 0))
-                       return -EINVAL;
-               if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
-                       continue;
-               if (!seg)
-                       return -EFAULT;
-               nr_segs = seg;
-               count -= iv->iov_len;   /* This segment is no good */
-               break;
-       }
+       err = generic_segment_checks(iov, &nr_segs, &count, VERIFY_READ);
+       if (err)
+               return err;

        pos = *ppos;
        vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
        /* We can write back this queue in page reclaim. */
        pos = *ppos;
        vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
        /* We can write back this queue in page reclaim. */


@@ -2162,7 +2110,7 @@ static ssize_t ntfs_file_aio_write_nolock(struct kiocb *iocb,
                goto out;
        if (!count)
                goto out;
                goto out;
        if (!count)
                goto out;

-       err = remove_suid(file->f_dentry);
+       err = file_remove_suid(file);

        if (err)
                goto out;
        file_update_time(file);
        if (err)
                goto out;
        file_update_time(file);


@@ -2189,36 +2137,8 @@ static ssize_t ntfs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
        mutex_lock(&inode->i_mutex);
        ret = ntfs_file_aio_write_nolock(iocb, iov, nr_segs, &iocb->ki_pos);
        mutex_unlock(&inode->i_mutex);
        mutex_lock(&inode->i_mutex);
        ret = ntfs_file_aio_write_nolock(iocb, iov, nr_segs, &iocb->ki_pos);
        mutex_unlock(&inode->i_mutex);

-       if (ret > 0 && ((file->f_flags & O_SYNC) || IS_SYNC(inode))) {
-               int err = sync_page_range(inode, mapping, pos, ret);
-               if (err < 0)
-                       ret = err;
-       }
-       return ret;
-}
-
-/**
- * ntfs_file_writev -
- *
- * Basically the same as generic_file_writev() except that it ends up calling
- * ntfs_file_aio_write_nolock() instead of __generic_file_aio_write_nolock().
- */
-static ssize_t ntfs_file_writev(struct file *file, const struct iovec *iov,
-               unsigned long nr_segs, loff_t *ppos)
-{
-       struct address_space *mapping = file->f_mapping;
-       struct inode *inode = mapping->host;
-       struct kiocb kiocb;
-       ssize_t ret;
-
-       mutex_lock(&inode->i_mutex);
-       init_sync_kiocb(&kiocb, file);
-       ret = ntfs_file_aio_write_nolock(&kiocb, iov, nr_segs, ppos);
-       if (ret == -EIOCBQUEUED)
-               ret = wait_on_sync_kiocb(&kiocb);
-       mutex_unlock(&inode->i_mutex);
-       if (ret > 0 && ((file->f_flags & O_SYNC) || IS_SYNC(inode))) {
-               int err = sync_page_range(inode, mapping, *ppos - ret, ret);
+       if (ret > 0) {
+               int err = generic_write_sync(file, pos, ret);

                if (err < 0)
                        ret = err;
        }
                if (err < 0)
                        ret = err;
        }


@@ -2226,18 +2146,6 @@ static ssize_t ntfs_file_writev(struct file *file, const struct iovec *iov,
 }
 
 /**
 }
 
 /**

- * ntfs_file_write - simple wrapper for ntfs_file_writev()
- */
-static ssize_t ntfs_file_write(struct file *file, const char __user *buf,
-               size_t count, loff_t *ppos)
-{
-       struct iovec local_iov = { .iov_base = (void __user *)buf,
-                                  .iov_len = count };
-
-       return ntfs_file_writev(file, &local_iov, 1, ppos);
-}
-
-/**

  * ntfs_file_fsync - sync a file to disk
  * @filp:      file to be synced
  * @dentry:    dentry describing the file to sync
  * ntfs_file_fsync - sync a file to disk
  * @filp:      file to be synced
  * @dentry:    dentry describing the file to sync


@@ -2296,10 +2204,10 @@ static int ntfs_file_fsync(struct file *filp, struct dentry *dentry,
 
 const struct file_operations ntfs_file_ops = {
        .llseek         = generic_file_llseek,   /* Seek inside file. */
 
 const struct file_operations ntfs_file_ops = {
        .llseek         = generic_file_llseek,   /* Seek inside file. */

-       .read           = generic_file_read,     /* Read from file. */
+       .read           = do_sync_read,          /* Read from file. */

        .aio_read       = generic_file_aio_read, /* Async read from file. */
 #ifdef NTFS_RW
        .aio_read       = generic_file_aio_read, /* Async read from file. */
 #ifdef NTFS_RW

-       .write          = ntfs_file_write,       /* Write to file. */
+       .write          = do_sync_write,         /* Write to file. */

        .aio_write      = ntfs_file_aio_write,   /* Async write to file. */
        /*.release      = ,*/                    /* Last file is closed.  See
                                                    fs/ext2/file.c::
        .aio_write      = ntfs_file_aio_write,   /* Async write to file. */
        /*.release      = ,*/                    /* Last file is closed.  See
                                                    fs/ext2/file.c::


@@ -2316,7 +2224,7 @@ const struct file_operations ntfs_file_ops = {
                                                    mounted filesystem. */
        .mmap           = generic_file_mmap,     /* Mmap file. */
        .open           = ntfs_file_open,        /* Open file. */
                                                    mounted filesystem. */
        .mmap           = generic_file_mmap,     /* Mmap file. */
        .open           = ntfs_file_open,        /* Open file. */

-       .sendfile       = generic_file_sendfile, /* Zero-copy data send with
+       .splice_read    = generic_file_splice_read /* Zero-copy data send with

                                                    the data source being on
                                                    the ntfs partition.  We do
                                                    not need to care about the
                                                    the data source being on
                                                    the ntfs partition.  We do
                                                    not need to care about the


@@ -2328,7 +2236,7 @@ const struct file_operations ntfs_file_ops = {
                                                    the data source. */
 };
 
                                                    the data source. */
 };
 

-struct inode_operations ntfs_file_inode_ops = {
+const struct inode_operations ntfs_file_inode_ops = {

 #ifdef NTFS_RW
        .truncate       = ntfs_truncate_vfs,
        .setattr        = ntfs_setattr,
 #ifdef NTFS_RW
        .truncate       = ntfs_truncate_vfs,
        .setattr        = ntfs_setattr,


@@ -2337,4 +2245,4 @@ struct inode_operations ntfs_file_inode_ops = {
 
 const struct file_operations ntfs_empty_file_ops = {};
 
 
 const struct file_operations ntfs_empty_file_ops = {};
 

-struct inode_operations ntfs_empty_inode_ops = {};
+const struct inode_operations ntfs_empty_inode_ops = {};