1/*
  2 * file.c - NILFS regular file handling primitives including fsync().
  3 *
  4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
  5 *
  6 * This program is free software; you can redistribute it and/or modify
  7 * it under the terms of the GNU General Public License as published by
  8 * the Free Software Foundation; either version 2 of the License, or
  9 * (at your option) any later version.
 10 *
 11 * This program is distributed in the hope that it will be useful,
 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14 * GNU General Public License for more details.
 15 *
 16 * You should have received a copy of the GNU General Public License
 17 * along with this program; if not, write to the Free Software
 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 19 *
 20 * Written by Amagai Yoshiji <amagai@osrg.net>,
 21 *            Ryusuke Konishi <ryusuke@osrg.net>
 22 */
 23
 24#include <linux/fs.h>
 25#include <linux/mm.h>
 26#include <linux/writeback.h>
 27#include "nilfs.h"
 28#include "segment.h"
 29
 30int nilfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 31{
 32	/*
 33	 * Called from fsync() system call
 34	 * This is the only entry point that can catch write and synch
 35	 * timing for both data blocks and intermediate blocks.
 36	 *
 37	 * This function should be implemented when the writeback function
 38	 * will be implemented.
 39	 */
 40	struct the_nilfs *nilfs;
 41	struct inode *inode = file->f_mapping->host;
 42	int err;
 43
 44	err = filemap_write_and_wait_range(inode->i_mapping, start, end);
 45	if (err)
 46		return err;
 47	mutex_lock(&inode->i_mutex);
 48
 49	if (nilfs_inode_dirty(inode)) {
 50		if (datasync)
 51			err = nilfs_construct_dsync_segment(inode->i_sb, inode,
 52							    0, LLONG_MAX);
 53		else
 54			err = nilfs_construct_segment(inode->i_sb);
 55	}
 56	mutex_unlock(&inode->i_mutex);
 57
 58	nilfs = inode->i_sb->s_fs_info;
 59	if (!err && nilfs_test_opt(nilfs, BARRIER)) {
 60		err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
 61		if (err != -EIO)
 62			err = 0;
 63	}
 64	return err;
 65}
 66
 67static int nilfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 68{
 69	struct page *page = vmf->page;
 70	struct inode *inode = vma->vm_file->f_dentry->d_inode;
 71	struct nilfs_transaction_info ti;
 72	int ret;
 73
 74	if (unlikely(nilfs_near_disk_full(inode->i_sb->s_fs_info)))
 75		return VM_FAULT_SIGBUS; /* -ENOSPC */
 76
 77	lock_page(page);
 78	if (page->mapping != inode->i_mapping ||
 79	    page_offset(page) >= i_size_read(inode) || !PageUptodate(page)) {
 80		unlock_page(page);
 81		return VM_FAULT_NOPAGE; /* make the VM retry the fault */
 82	}
 83
 84	/*
 85	 * check to see if the page is mapped already (no holes)
 86	 */
 87	if (PageMappedToDisk(page))
 88		goto mapped;
 89
 90	if (page_has_buffers(page)) {
 91		struct buffer_head *bh, *head;
 92		int fully_mapped = 1;
 93
 94		bh = head = page_buffers(page);
 95		do {
 96			if (!buffer_mapped(bh)) {
 97				fully_mapped = 0;
 98				break;
 99			}
100		} while (bh = bh->b_this_page, bh != head);
101
102		if (fully_mapped) {
103			SetPageMappedToDisk(page);
104			goto mapped;
105		}
106	}
107	unlock_page(page);
108
109	/*
110	 * fill hole blocks
111	 */
112	ret = nilfs_transaction_begin(inode->i_sb, &ti, 1);
113	/* never returns -ENOMEM, but may return -ENOSPC */
114	if (unlikely(ret))
115		return VM_FAULT_SIGBUS;
116
117	ret = block_page_mkwrite(vma, vmf, nilfs_get_block);
118	if (ret != VM_FAULT_LOCKED) {
119		nilfs_transaction_abort(inode->i_sb);
120		return ret;
121	}
122	nilfs_set_file_dirty(inode, 1 << (PAGE_SHIFT - inode->i_blkbits));
123	nilfs_transaction_commit(inode->i_sb);
124
125 mapped:
126	wait_on_page_writeback(page);
127	return VM_FAULT_LOCKED;
128}
129
130static const struct vm_operations_struct nilfs_file_vm_ops = {
131	.fault		= filemap_fault,
132	.page_mkwrite	= nilfs_page_mkwrite,
133};
134
135static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma)
136{
137	file_accessed(file);
138	vma->vm_ops = &nilfs_file_vm_ops;
139	vma->vm_flags |= VM_CAN_NONLINEAR;
140	return 0;
141}
142
143/*
144 * We have mostly NULL's here: the current defaults are ok for
145 * the nilfs filesystem.
146 */
147const struct file_operations nilfs_file_operations = {
148	.llseek		= generic_file_llseek,
149	.read		= do_sync_read,
150	.write		= do_sync_write,
151	.aio_read	= generic_file_aio_read,
152	.aio_write	= generic_file_aio_write,
153	.unlocked_ioctl	= nilfs_ioctl,
154#ifdef CONFIG_COMPAT
155	.compat_ioctl	= nilfs_compat_ioctl,
156#endif	/* CONFIG_COMPAT */
157	.mmap		= nilfs_file_mmap,
158	.open		= generic_file_open,
159	/* .release	= nilfs_release_file, */
160	.fsync		= nilfs_sync_file,
161	.splice_read	= generic_file_splice_read,
162};
163
164const struct inode_operations nilfs_file_inode_operations = {
165	.truncate	= nilfs_truncate,
166	.setattr	= nilfs_setattr,
167	.permission     = nilfs_permission,
168	.fiemap		= nilfs_fiemap,
169};
170
171/* end of file */