X-Git-Url: https://git.camperquake.de/gitweb.cgi?a=blobdiff_plain;f=module%2Fzfs%2Fzpl_file.c;h=6598c177971d46abbe6e3299f698249e70853582;hb=refs%2Fheads%2Frertzinger%2Ffeature-zpool-get--p;hp=c2e3a6bdcf489811b03035a1fc7f39bb060967c2;hpb=cfc9a5c88f91f7b4d606fce89505e1f404691ea5;p=zfs.git diff --git a/module/zfs/zpl_file.c b/module/zfs/zpl_file.c index c2e3a6b..6598c17 100644 --- a/module/zfs/zpl_file.c +++ b/module/zfs/zpl_file.c @@ -52,6 +52,9 @@ zpl_release(struct inode *ip, struct file *filp) cred_t *cr = CRED(); int error; + if (ITOZ(ip)->z_atime_dirty) + mark_inode_dirty(ip); + crhold(cr); error = -zfs_close(ip, filp->f_flags, cr); crfree(cr); @@ -61,52 +64,106 @@ zpl_release(struct inode *ip, struct file *filp) } static int -zpl_readdir(struct file *filp, void *dirent, filldir_t filldir) +zpl_iterate(struct file *filp, struct dir_context *ctx) { struct dentry *dentry = filp->f_path.dentry; cred_t *cr = CRED(); int error; crhold(cr); - error = -zfs_readdir(dentry->d_inode, dirent, filldir, - &filp->f_pos, cr); + error = -zfs_readdir(dentry->d_inode, ctx, cr); crfree(cr); ASSERT3S(error, <=, 0); return (error); } +#if !defined(HAVE_VFS_ITERATE) +static int +zpl_readdir(struct file *filp, void *dirent, filldir_t filldir) +{ + struct dir_context ctx = DIR_CONTEXT_INIT(dirent, filldir, filp->f_pos); + int error; + + error = zpl_iterate(filp, &ctx); + filp->f_pos = ctx.pos; + + return (error); +} +#endif /* HAVE_VFS_ITERATE */ + +#if defined(HAVE_FSYNC_WITH_DENTRY) /* - * 2.6.35 API change, - * As of 2.6.35 the dentry argument to the .fsync() vfs hook was deemed + * 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(); + int error; + + 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. - * - * 2.6.34 API change, - * Prior to 2.6.34 the nfsd kernel server would pass a NULL file struct * - * to the .fsync() hook. For this reason, we must be careful not to use - * filp unconditionally in the 3 argument case. */ -#ifdef HAVE_2ARGS_FSYNC static int zpl_fsync(struct file *filp, int datasync) { - struct dentry *dentry = filp->f_path.dentry; -#else + 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, struct dentry *dentry, int datasync) +zpl_fsync(struct file *filp, loff_t start, loff_t end, int datasync) { -#endif /* HAVE_2ARGS_FSYNC */ + 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(dentry->d_inode, datasync, 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, @@ -194,6 +251,28 @@ zpl_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos) return (wrote); } +static loff_t +zpl_llseek(struct file *filp, loff_t offset, int whence) +{ +#if defined(SEEK_HOLE) && defined(SEEK_DATA) + if (whence == SEEK_DATA || whence == SEEK_HOLE) { + struct inode *ip = filp->f_mapping->host; + loff_t maxbytes = ip->i_sb->s_maxbytes; + loff_t error; + + spl_inode_lock(ip); + error = -zfs_holey(ip, whence, &offset); + if (error == 0) + error = lseek_execute(filp, ip, offset, maxbytes); + spl_inode_unlock(ip); + + return (error); + } +#endif /* SEEK_HOLE && SEEK_DATA */ + + return generic_file_llseek(filp, offset, whence); +} + /* * It's worth taking a moment to describe how mmap is implemented * for zfs because it differs considerably from other Linux filesystems. @@ -260,60 +339,6 @@ zpl_mmap(struct file *filp, struct vm_area_struct *vma) return (error); } -static struct page ** -pages_vector_from_list(struct list_head *pages, unsigned nr_pages) -{ - struct page **pl; - struct page *t; - unsigned page_idx; - - pl = kmalloc(sizeof(*pl) * nr_pages, GFP_NOFS); - if (!pl) - return ERR_PTR(-ENOMEM); - - page_idx = 0; - list_for_each_entry_reverse(t, pages, lru) { - pl[page_idx] = t; - page_idx++; - } - - return pl; -} - -static int -zpl_readpages(struct file *file, struct address_space *mapping, - struct list_head *pages, unsigned nr_pages) -{ - struct inode *ip; - struct page **pl; - struct page *p, *n; - int error; - - ip = mapping->host; - - pl = pages_vector_from_list(pages, nr_pages); - if (IS_ERR(pl)) - return PTR_ERR(pl); - - error = -zfs_getpage(ip, pl, nr_pages); - if (error) - goto error; - - list_for_each_entry_safe_reverse(p, n, pages, lru) { - - list_del(&p->lru); - - flush_dcache_page(p); - SetPageUptodate(p); - unlock_page(p); - page_cache_release(p); - } - -error: - kfree(pl); - return error; -} - /* * Populate a page with data for the Linux page cache. This function is * only used to support mmap(2). There will be an identical copy of the @@ -349,33 +374,39 @@ zpl_readpage(struct file *filp, struct page *pp) return error; } +/* + * 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_readpages(struct file *filp, struct address_space *mapping, + struct list_head *pages, unsigned nr_pages) +{ + return (read_cache_pages(mapping, pages, + (filler_t *)zpl_readpage, filp)); +} + int zpl_putpage(struct page *pp, struct writeback_control *wbc, void *data) { - int error; + struct address_space *mapping = data; + + ASSERT(PageLocked(pp)); + ASSERT(!PageWriteback(pp)); + ASSERT(!(current->flags & PF_NOFS)); /* - * 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. + * Annotate this call path with a flag that indicates that it is + * unsafe to use KM_SLEEP during memory allocations due to the + * potential for a deadlock. KM_PUSHPAGE should be used instead. */ - current->flags |= PF_MEMALLOC; - error = -zfs_putpage(pp, wbc, data); - current->flags &= ~PF_MEMALLOC; - - if (error) { - SetPageError(pp); - ClearPageUptodate(pp); - } else { - ClearPageError(pp); - SetPageUptodate(pp); - flush_dcache_page(pp); - } + current->flags |= PF_NOFS; + (void) zfs_putpage(mapping->host, pp, wbc); + current->flags &= ~PF_NOFS; - unlock_page(pp); - return error; + return (0); } static int @@ -396,6 +427,71 @@ zpl_writepage(struct page *pp, struct writeback_control *wbc) return zpl_putpage(pp, wbc, pp->mapping); } +/* + * The only flag combination which matches the behavior of zfs_space() + * is FALLOC_FL_PUNCH_HOLE. This flag was introduced in the 2.6.38 kernel. + */ +long +zpl_fallocate_common(struct inode *ip, int mode, loff_t offset, loff_t len) +{ + cred_t *cr = CRED(); + int error = -EOPNOTSUPP; + + if (mode & FALLOC_FL_KEEP_SIZE) + return (-EOPNOTSUPP); + + crhold(cr); + +#ifdef FALLOC_FL_PUNCH_HOLE + if (mode & FALLOC_FL_PUNCH_HOLE) { + flock64_t bf; + + bf.l_type = F_WRLCK; + bf.l_whence = 0; + bf.l_start = offset; + bf.l_len = len; + bf.l_pid = 0; + + error = -zfs_space(ip, F_FREESP, &bf, FWRITE, offset, cr); + } +#endif /* FALLOC_FL_PUNCH_HOLE */ + + crfree(cr); + + ASSERT3S(error, <=, 0); + return (error); +} + +#ifdef HAVE_FILE_FALLOCATE +static long +zpl_fallocate(struct file *filp, int mode, loff_t offset, loff_t len) +{ + return zpl_fallocate_common(filp->f_path.dentry->d_inode, + mode, offset, len); +} +#endif /* HAVE_FILE_FALLOCATE */ + +static long +zpl_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) +{ + switch (cmd) { + case ZFS_IOC_GETFLAGS: + case ZFS_IOC_SETFLAGS: + return (-EOPNOTSUPP); + default: + return (-ENOTTY); + } +} + +#ifdef CONFIG_COMPAT +static long +zpl_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) +{ + return zpl_ioctl(filp, cmd, arg); +} +#endif /* CONFIG_COMPAT */ + + const struct address_space_operations zpl_address_space_operations = { .readpages = zpl_readpages, .readpage = zpl_readpage, @@ -406,17 +502,31 @@ const struct address_space_operations zpl_address_space_operations = { const struct file_operations zpl_file_operations = { .open = zpl_open, .release = zpl_release, - .llseek = generic_file_llseek, + .llseek = zpl_llseek, .read = zpl_read, .write = zpl_write, - .readdir = zpl_readdir, .mmap = zpl_mmap, .fsync = zpl_fsync, +#ifdef HAVE_FILE_FALLOCATE + .fallocate = zpl_fallocate, +#endif /* HAVE_FILE_FALLOCATE */ + .unlocked_ioctl = zpl_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = zpl_compat_ioctl, +#endif }; const struct file_operations zpl_dir_file_operations = { .llseek = generic_file_llseek, .read = generic_read_dir, +#ifdef HAVE_VFS_ITERATE + .iterate = zpl_iterate, +#else .readdir = zpl_readdir, +#endif .fsync = zpl_fsync, + .unlocked_ioctl = zpl_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = zpl_compat_ioctl, +#endif };