file.c 4.1 KB
Newer Older
R
Ryusuke Konishi 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * file.c - NILFS regular file handling primitives including fsync().
 *
 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Written by Amagai Yoshiji <amagai@osrg.net>,
 *            Ryusuke Konishi <ryusuke@osrg.net>
 */

#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/writeback.h>
#include "nilfs.h"
#include "segment.h"

30
int nilfs_sync_file(struct file *file, int datasync)
R
Ryusuke Konishi 已提交
31 32 33 34 35 36 37 38 39
{
	/*
	 * Called from fsync() system call
	 * This is the only entry point that can catch write and synch
	 * timing for both data blocks and intermediate blocks.
	 *
	 * This function should be implemented when the writeback function
	 * will be implemented.
	 */
40
	struct inode *inode = file->f_mapping->host;
R
Ryusuke Konishi 已提交
41 42 43 44 45 46
	int err;

	if (!nilfs_inode_dirty(inode))
		return 0;

	if (datasync)
47 48
		err = nilfs_construct_dsync_segment(inode->i_sb, inode, 0,
						    LLONG_MAX);
R
Ryusuke Konishi 已提交
49 50 51 52 53 54
	else
		err = nilfs_construct_segment(inode->i_sb);

	return err;
}

R
Ryusuke Konishi 已提交
55
static int nilfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
R
Ryusuke Konishi 已提交
56
{
R
Ryusuke Konishi 已提交
57 58 59 60 61
	struct page *page = vmf->page;
	struct inode *inode = vma->vm_file->f_dentry->d_inode;
	struct nilfs_transaction_info ti;
	int ret;

62
	if (unlikely(nilfs_near_disk_full(inode->i_sb->s_fs_info)))
R
Ryusuke Konishi 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
		return VM_FAULT_SIGBUS; /* -ENOSPC */

	lock_page(page);
	if (page->mapping != inode->i_mapping ||
	    page_offset(page) >= i_size_read(inode) || !PageUptodate(page)) {
		unlock_page(page);
		return VM_FAULT_NOPAGE; /* make the VM retry the fault */
	}

	/*
	 * check to see if the page is mapped already (no holes)
	 */
	if (PageMappedToDisk(page)) {
		unlock_page(page);
		goto mapped;
	}
	if (page_has_buffers(page)) {
		struct buffer_head *bh, *head;
		int fully_mapped = 1;

		bh = head = page_buffers(page);
		do {
			if (!buffer_mapped(bh)) {
				fully_mapped = 0;
				break;
			}
		} while (bh = bh->b_this_page, bh != head);

		if (fully_mapped) {
			SetPageMappedToDisk(page);
			unlock_page(page);
			goto mapped;
		}
	}
	unlock_page(page);

	/*
	 * fill hole blocks
	 */
	ret = nilfs_transaction_begin(inode->i_sb, &ti, 1);
	/* never returns -ENOMEM, but may return -ENOSPC */
	if (unlikely(ret))
		return VM_FAULT_SIGBUS;

	ret = block_page_mkwrite(vma, vmf, nilfs_get_block);
	if (unlikely(ret)) {
		nilfs_transaction_abort(inode->i_sb);
		return ret;
	}
	nilfs_transaction_commit(inode->i_sb);

 mapped:
R
Ryusuke Konishi 已提交
115 116 117 118 119
	SetPageChecked(page);
	wait_on_page_writeback(page);
	return 0;
}

120
static const struct vm_operations_struct nilfs_file_vm_ops = {
R
Ryusuke Konishi 已提交
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
	.fault		= filemap_fault,
	.page_mkwrite	= nilfs_page_mkwrite,
};

static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	file_accessed(file);
	vma->vm_ops = &nilfs_file_vm_ops;
	vma->vm_flags |= VM_CAN_NONLINEAR;
	return 0;
}

/*
 * We have mostly NULL's here: the current defaults are ok for
 * the nilfs filesystem.
 */
137
const struct file_operations nilfs_file_operations = {
R
Ryusuke Konishi 已提交
138 139 140 141
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
	.write		= do_sync_write,
	.aio_read	= generic_file_aio_read,
142
	.aio_write	= generic_file_aio_write,
R
Ryusuke Konishi 已提交
143
	.unlocked_ioctl	= nilfs_ioctl,
R
Ryusuke Konishi 已提交
144
#ifdef CONFIG_COMPAT
R
Ryusuke Konishi 已提交
145
	.compat_ioctl	= nilfs_compat_ioctl,
R
Ryusuke Konishi 已提交
146 147 148 149 150 151 152 153
#endif	/* CONFIG_COMPAT */
	.mmap		= nilfs_file_mmap,
	.open		= generic_file_open,
	/* .release	= nilfs_release_file, */
	.fsync		= nilfs_sync_file,
	.splice_read	= generic_file_splice_read,
};

154
const struct inode_operations nilfs_file_inode_operations = {
R
Ryusuke Konishi 已提交
155 156 157
	.truncate	= nilfs_truncate,
	.setattr	= nilfs_setattr,
	.permission     = nilfs_permission,
R
Ryusuke Konishi 已提交
158
	.fiemap		= nilfs_fiemap,
R
Ryusuke Konishi 已提交
159 160 161
};

/* end of file */