X-Git-Url: https://git.camperquake.de/gitweb.cgi?a=blobdiff_plain;f=module%2Fzfs%2Fzpl_file.c;h=0ef2c1558f0b38dc9c010dddf217e75f03aeabc3;hb=b18019d2d810585185493c62e9567fa85e51692c;hp=585f971e8dc23abe2dea38d23077cc51d9234798;hpb=c0d35759c5ab1abaa6b72062cc4ecd0d86628de8;p=zfs.git diff --git a/module/zfs/zpl_file.c b/module/zfs/zpl_file.c index 585f971..0ef2c15 100644 --- a/module/zfs/zpl_file.c +++ b/module/zfs/zpl_file.c @@ -30,34 +30,124 @@ static int +zpl_open(struct inode *ip, struct file *filp) +{ + cred_t *cr = CRED(); + int error; + + crhold(cr); + error = -zfs_open(ip, filp->f_mode, filp->f_flags, cr); + crfree(cr); + ASSERT3S(error, <=, 0); + + if (error) + return (error); + + return generic_file_open(ip, filp); +} + +static int +zpl_release(struct inode *ip, struct file *filp) +{ + cred_t *cr = CRED(); + int error; + + crhold(cr); + error = -zfs_close(ip, filp->f_flags, cr); + crfree(cr); + ASSERT3S(error, <=, 0); + + return (error); +} + +static int zpl_readdir(struct file *filp, void *dirent, filldir_t filldir) { struct dentry *dentry = filp->f_path.dentry; - cred_t *cr; + cred_t *cr = CRED(); int error; - cr = (cred_t *)get_current_cred(); + crhold(cr); error = -zfs_readdir(dentry->d_inode, dirent, filldir, &filp->f_pos, cr); - put_cred(cr); + crfree(cr); ASSERT3S(error, <=, 0); return (error); } +#if defined(HAVE_FSYNC_WITH_DENTRY) +/* + * Linux 2.6.x - 2.6.34 API, + * Through 2.6.34 the nfsd kernel server would pass a NULL 'file struct *' + * to the fops->fsync() hook. For this reason, we must be careful not to + * use filp unconditionally. + */ static int zpl_fsync(struct file *filp, struct dentry *dentry, int datasync) { - cred_t *cr; + cred_t *cr = CRED(); int error; - cr = (cred_t *)get_current_cred(); - error = -zfs_fsync(filp->f_path.dentry->d_inode, datasync, cr); - put_cred(cr); + crhold(cr); + error = -zfs_fsync(dentry->d_inode, datasync, cr); + crfree(cr); + ASSERT3S(error, <=, 0); + + return (error); +} + +#elif defined(HAVE_FSYNC_WITHOUT_DENTRY) +/* + * Linux 2.6.35 - 3.0 API, + * As of 2.6.35 the dentry argument to the fops->fsync() hook was deemed + * redundant. The dentry is still accessible via filp->f_path.dentry, + * and we are guaranteed that filp will never be NULL. + */ +static int +zpl_fsync(struct file *filp, int datasync) +{ + struct inode *inode = filp->f_mapping->host; + cred_t *cr = CRED(); + int error; + + crhold(cr); + error = -zfs_fsync(inode, datasync, cr); + crfree(cr); + ASSERT3S(error, <=, 0); + + return (error); +} + +#elif defined(HAVE_FSYNC_RANGE) +/* + * Linux 3.1 - 3.x API, + * As of 3.1 the responsibility to call filemap_write_and_wait_range() has + * been pushed down in to the .fsync() vfs hook. Additionally, the i_mutex + * lock is no longer held by the caller, for zfs we don't require the lock + * to be held so we don't acquire it. + */ +static int +zpl_fsync(struct file *filp, loff_t start, loff_t end, int datasync) +{ + struct inode *inode = filp->f_mapping->host; + cred_t *cr = CRED(); + int error; + + error = filemap_write_and_wait_range(inode->i_mapping, start, end); + if (error) + return (error); + + crhold(cr); + error = -zfs_fsync(inode, datasync, cr); + crfree(cr); ASSERT3S(error, <=, 0); return (error); } +#else +#error "Unsupported fops->fsync() implementation" +#endif ssize_t zpl_read_common(struct inode *ip, const char *buf, size_t len, loff_t pos, @@ -87,13 +177,13 @@ zpl_read_common(struct inode *ip, const char *buf, size_t len, loff_t pos, static ssize_t zpl_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos) { - cred_t *cr; + cred_t *cr = CRED(); ssize_t read; - cr = (cred_t *)get_current_cred(); + crhold(cr); read = zpl_read_common(filp->f_mapping->host, buf, len, *ppos, UIO_USERSPACE, filp->f_flags, cr); - put_cred(cr); + crfree(cr); if (read < 0) return (read); @@ -130,13 +220,13 @@ zpl_write_common(struct inode *ip, const char *buf, size_t len, loff_t pos, static ssize_t zpl_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos) { - cred_t *cr; + cred_t *cr = CRED(); ssize_t wrote; - cr = (cred_t *)get_current_cred(); + crhold(cr); wrote = zpl_write_common(filp->f_mapping->host, buf, len, *ppos, UIO_USERSPACE, filp->f_flags, cr); - put_cred(cr); + crfree(cr); if (wrote < 0) return (wrote); @@ -191,9 +281,15 @@ zpl_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos) static int zpl_mmap(struct file *filp, struct vm_area_struct *vma) { - znode_t *zp = ITOZ(filp->f_mapping->host); + struct inode *ip = filp->f_mapping->host; + znode_t *zp = ITOZ(ip); int error; + error = -zfs_map(ip, vma->vm_pgoff, (caddr_t *)vma->vm_start, + (size_t)(vma->vm_end - vma->vm_start), vma->vm_flags); + if (error) + return (error); + error = generic_file_mmap(filp, vma); if (error) return (error); @@ -218,33 +314,14 @@ static int zpl_readpage(struct file *filp, struct page *pp) { struct inode *ip; - loff_t off, i_size; - size_t len, wrote; - cred_t *cr; - void *pb; + struct page *pl[1]; int error = 0; ASSERT(PageLocked(pp)); ip = pp->mapping->host; - off = page_offset(pp); - i_size = i_size_read(ip); - ASSERT3S(off, <, i_size); - - cr = (cred_t *)get_current_cred(); - len = MIN(PAGE_CACHE_SIZE, i_size - off); - - pb = kmap(pp); - - /* O_DIRECT is passed to bypass the page cache and avoid deadlock. */ - wrote = zpl_read_common(ip, pb, len, off, UIO_SYSSPACE, O_DIRECT, cr); - if (wrote != len) - error = -EIO; + pl[0] = pp; - if (!error && (len < PAGE_CACHE_SIZE)) - memset(pb + len, 0, PAGE_CACHE_SIZE - len); - - kunmap(pp); - put_cred(cr); + error = -zfs_getpage(ip, pl, 1); if (error) { SetPageError(pp); @@ -256,68 +333,77 @@ zpl_readpage(struct file *filp, struct page *pp) } unlock_page(pp); - - return (error); + return error; } /* - * Write out dirty pages to the ARC, this function is only required to - * support mmap(2). Mapped pages may be dirtied by memory operations - * which never call .write(). These dirty pages are kept in sync with - * the ARC buffers via this hook. - * - * Currently this function relies on zpl_write_common() and the O_DIRECT - * flag to push out the page. This works but the more correct way is - * to update zfs_putapage() to be Linux friendly and use that interface. + * Populate a set of pages with data for the Linux page cache. This + * function will only be called for read ahead and never for demand + * paging. For simplicity, the code relies on read_cache_pages() to + * correctly lock each page for IO and call zpl_readpage(). */ static int -zpl_writepage(struct page *pp, struct writeback_control *wbc) +zpl_readpages(struct file *filp, struct address_space *mapping, + struct list_head *pages, unsigned nr_pages) { - struct inode *ip; - loff_t off, i_size; - size_t len, read; - cred_t *cr; - void *pb; - int error = 0; - - ASSERT(PageLocked(pp)); - ip = pp->mapping->host; - off = page_offset(pp); - i_size = i_size_read(ip); - - cr = (cred_t *)get_current_cred(); - len = MIN(PAGE_CACHE_SIZE, i_size - off); - - pb = kmap(pp); - - /* O_DIRECT is passed to bypass the page cache and avoid deadlock. */ - read = zpl_write_common(ip, pb, len, off, UIO_SYSSPACE, O_DIRECT, cr); - if (read != len) - error = -EIO; + return (read_cache_pages(mapping, pages, + (filler_t *)zpl_readpage, filp)); +} - kunmap(pp); - put_cred(cr); +int +zpl_putpage(struct page *pp, struct writeback_control *wbc, void *data) +{ + struct address_space *mapping = data; - if (error) { - SetPageError(pp); - ClearPageUptodate(pp); + ASSERT(PageLocked(pp)); + ASSERT(!PageWriteback(pp)); + + /* + * Disable the normal reclaim path for zpl_putpage(). This + * ensures that all memory allocations under this call path + * will never enter direct reclaim. If this were to happen + * the VM might try to write out additional pages by calling + * zpl_putpage() again resulting in a deadlock. + */ + if (current->flags & PF_MEMALLOC) { + (void) zfs_putpage(mapping->host, pp, wbc); } else { - ClearPageError(pp); - SetPageUptodate(pp); + current->flags |= PF_MEMALLOC; + (void) zfs_putpage(mapping->host, pp, wbc); + current->flags &= ~PF_MEMALLOC; } - unlock_page(pp); + return (0); +} - return (error); +static int +zpl_writepages(struct address_space *mapping, struct writeback_control *wbc) +{ + return write_cache_pages(mapping, wbc, zpl_putpage, mapping); +} + +/* + * Write out dirty pages to the ARC, this function is only required to + * support mmap(2). Mapped pages may be dirtied by memory operations + * which never call .write(). These dirty pages are kept in sync with + * the ARC buffers via this hook. + */ +static int +zpl_writepage(struct page *pp, struct writeback_control *wbc) +{ + return zpl_putpage(pp, wbc, pp->mapping); } const struct address_space_operations zpl_address_space_operations = { + .readpages = zpl_readpages, .readpage = zpl_readpage, .writepage = zpl_writepage, + .writepages = zpl_writepages, }; const struct file_operations zpl_file_operations = { - .open = generic_file_open, + .open = zpl_open, + .release = zpl_release, .llseek = generic_file_llseek, .read = zpl_read, .write = zpl_write,