file.c 8.64 KB
Newer Older
1
/* AFS filesystem file handling
Linus Torvalds's avatar
Linus Torvalds committed
2
 *
3
 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13 14 15 16
 * Written by David Howells (dhowells@redhat.com)
 *
 * 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.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
17
#include <linux/writeback.h>
18
#include <linux/gfp.h>
Linus Torvalds's avatar
Linus Torvalds committed
19 20
#include "internal.h"

David Howells's avatar
David Howells committed
21
static int afs_readpage(struct file *file, struct page *page);
22 23
static void afs_invalidatepage(struct page *page, unsigned int offset,
			       unsigned int length);
David Howells's avatar
David Howells committed
24
static int afs_releasepage(struct page *page, gfp_t gfp_flags);
25
static int afs_launder_page(struct page *page);
Linus Torvalds's avatar
Linus Torvalds committed
26

27 28 29
static int afs_readpages(struct file *filp, struct address_space *mapping,
			 struct list_head *pages, unsigned nr_pages);

David Howells's avatar
David Howells committed
30 31
const struct file_operations afs_file_operations = {
	.open		= afs_open,
32
	.flush		= afs_flush,
David Howells's avatar
David Howells committed
33 34
	.release	= afs_release,
	.llseek		= generic_file_llseek,
35
	.read_iter	= generic_file_read_iter,
Al Viro's avatar
Al Viro committed
36
	.write_iter	= afs_file_write,
David Howells's avatar
David Howells committed
37
	.mmap		= generic_file_readonly_mmap,
38
	.splice_read	= generic_file_splice_read,
39
	.fsync		= afs_fsync,
David Howells's avatar
David Howells committed
40 41
	.lock		= afs_lock,
	.flock		= afs_flock,
David Howells's avatar
David Howells committed
42 43
};

44
const struct inode_operations afs_file_inode_operations = {
David Howells's avatar
David Howells committed
45
	.getattr	= afs_getattr,
46
	.setattr	= afs_setattr,
David Howells's avatar
David Howells committed
47
	.permission	= afs_permission,
Linus Torvalds's avatar
Linus Torvalds committed
48 49
};

50
const struct address_space_operations afs_fs_aops = {
David Howells's avatar
David Howells committed
51
	.readpage	= afs_readpage,
52
	.readpages	= afs_readpages,
53 54
	.set_page_dirty	= afs_set_page_dirty,
	.launder_page	= afs_launder_page,
David Howells's avatar
David Howells committed
55 56
	.releasepage	= afs_releasepage,
	.invalidatepage	= afs_invalidatepage,
Nick Piggin's avatar
Nick Piggin committed
57 58
	.write_begin	= afs_write_begin,
	.write_end	= afs_write_end,
59 60
	.writepage	= afs_writepage,
	.writepages	= afs_writepages,
Linus Torvalds's avatar
Linus Torvalds committed
61 62
};

David Howells's avatar
David Howells committed
63 64 65 66 67 68 69
/*
 * open an AFS file or directory and attach a key to it
 */
int afs_open(struct inode *inode, struct file *file)
{
	struct afs_vnode *vnode = AFS_FS_I(inode);
	struct key *key;
70
	int ret;
David Howells's avatar
David Howells committed
71

David Howells's avatar
David Howells committed
72
	_enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
David Howells's avatar
David Howells committed
73 74 75 76 77 78 79

	key = afs_request_key(vnode->volume->cell);
	if (IS_ERR(key)) {
		_leave(" = %ld [key]", PTR_ERR(key));
		return PTR_ERR(key);
	}

80 81 82 83 84 85
	ret = afs_validate(vnode, key);
	if (ret < 0) {
		_leave(" = %d [val]", ret);
		return ret;
	}

David Howells's avatar
David Howells committed
86 87 88 89 90 91 92 93 94 95 96 97
	file->private_data = key;
	_leave(" = 0");
	return 0;
}

/*
 * release an AFS file or directory and discard its key
 */
int afs_release(struct inode *inode, struct file *file)
{
	struct afs_vnode *vnode = AFS_FS_I(inode);

David Howells's avatar
David Howells committed
98
	_enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
David Howells's avatar
David Howells committed
99 100 101 102 103 104

	key_put(file->private_data);
	_leave(" = 0");
	return 0;
}

105
#ifdef CONFIG_AFS_FSCACHE
Linus Torvalds's avatar
Linus Torvalds committed
106 107 108
/*
 * deal with notification that a page was read from the cache
 */
109 110 111
static void afs_file_readpage_read_complete(struct page *page,
					    void *data,
					    int error)
Linus Torvalds's avatar
Linus Torvalds committed
112
{
113
	_enter("%p,%p,%d", page, data, error);
Linus Torvalds's avatar
Linus Torvalds committed
114

115 116 117
	/* if the read completes with an error, we just unlock the page and let
	 * the VM reissue the readpage */
	if (!error)
Linus Torvalds's avatar
Linus Torvalds committed
118 119
		SetPageUptodate(page);
	unlock_page(page);
120
}
121
#endif
Linus Torvalds's avatar
Linus Torvalds committed
122 123

/*
124
 * read page from file, directory or symlink, given a key to use
Linus Torvalds's avatar
Linus Torvalds committed
125
 */
126
int afs_page_filler(void *data, struct page *page)
Linus Torvalds's avatar
Linus Torvalds committed
127
{
128 129 130
	struct inode *inode = page->mapping->host;
	struct afs_vnode *vnode = AFS_FS_I(inode);
	struct key *key = data;
131 132
	size_t len;
	off_t offset;
Linus Torvalds's avatar
Linus Torvalds committed
133 134
	int ret;

David Howells's avatar
David Howells committed
135
	_enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index);
Linus Torvalds's avatar
Linus Torvalds committed
136

Matt Mackall's avatar
Matt Mackall committed
137
	BUG_ON(!PageLocked(page));
Linus Torvalds's avatar
Linus Torvalds committed
138 139

	ret = -ESTALE;
140
	if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
Linus Torvalds's avatar
Linus Torvalds committed
141 142 143
		goto error;

	/* is it cached? */
144 145
#ifdef CONFIG_AFS_FSCACHE
	ret = fscache_read_or_alloc_page(vnode->cache,
Linus Torvalds's avatar
Linus Torvalds committed
146 147 148 149 150 151 152 153 154 155 156 157
					 page,
					 afs_file_readpage_read_complete,
					 NULL,
					 GFP_KERNEL);
#else
	ret = -ENOBUFS;
#endif
	switch (ret) {
		/* read BIO submitted (page in cache) */
	case 0:
		break;

158
		/* page not yet cached */
Linus Torvalds's avatar
Linus Torvalds committed
159
	case -ENODATA:
160 161 162 163 164 165
		_debug("cache said ENODATA");
		goto go_on;

		/* page will not be cached */
	case -ENOBUFS:
		_debug("cache said ENOBUFS");
Linus Torvalds's avatar
Linus Torvalds committed
166
	default:
167
	go_on:
168 169
		offset = page->index << PAGE_CACHE_SHIFT;
		len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
170 171 172

		/* read the contents of the file from the server into the
		 * page */
David Howells's avatar
David Howells committed
173
		ret = afs_vnode_fetch_data(vnode, key, offset, len, page);
Linus Torvalds's avatar
Linus Torvalds committed
174
		if (ret < 0) {
175
			if (ret == -ENOENT) {
Linus Torvalds's avatar
Linus Torvalds committed
176 177
				_debug("got NOENT from server"
				       " - marking file deleted and stale");
178
				set_bit(AFS_VNODE_DELETED, &vnode->flags);
Linus Torvalds's avatar
Linus Torvalds committed
179 180
				ret = -ESTALE;
			}
181 182 183

#ifdef CONFIG_AFS_FSCACHE
			fscache_uncache_page(vnode->cache, page);
Linus Torvalds's avatar
Linus Torvalds committed
184
#endif
185
			BUG_ON(PageFsCache(page));
Linus Torvalds's avatar
Linus Torvalds committed
186 187 188 189 190
			goto error;
		}

		SetPageUptodate(page);

191 192 193 194 195 196
		/* send the page to the cache */
#ifdef CONFIG_AFS_FSCACHE
		if (PageFsCache(page) &&
		    fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {
			fscache_uncache_page(vnode->cache, page);
			BUG_ON(PageFsCache(page));
Linus Torvalds's avatar
Linus Torvalds committed
197 198
		}
#endif
199
		unlock_page(page);
Linus Torvalds's avatar
Linus Torvalds committed
200 201 202 203 204
	}

	_leave(" = 0");
	return 0;

205
error:
Linus Torvalds's avatar
Linus Torvalds committed
206 207 208 209
	SetPageError(page);
	unlock_page(page);
	_leave(" = %d", ret);
	return ret;
210
}
Linus Torvalds's avatar
Linus Torvalds committed
211

212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
/*
 * read page from file, directory or symlink, given a file to nominate the key
 * to be used
 */
static int afs_readpage(struct file *file, struct page *page)
{
	struct key *key;
	int ret;

	if (file) {
		key = file->private_data;
		ASSERT(key != NULL);
		ret = afs_page_filler(key, page);
	} else {
		struct inode *inode = page->mapping->host;
		key = afs_request_key(AFS_FS_S(inode->i_sb)->volume->cell);
		if (IS_ERR(key)) {
			ret = PTR_ERR(key);
		} else {
			ret = afs_page_filler(key, page);
			key_put(key);
		}
	}
	return ret;
}

Linus Torvalds's avatar
Linus Torvalds committed
238
/*
239
 * read a set of pages
Linus Torvalds's avatar
Linus Torvalds committed
240
 */
241 242
static int afs_readpages(struct file *file, struct address_space *mapping,
			 struct list_head *pages, unsigned nr_pages)
Linus Torvalds's avatar
Linus Torvalds committed
243
{
244
	struct key *key = file->private_data;
245 246
	struct afs_vnode *vnode;
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
247

248 249 250 251
	_enter("{%d},{%lu},,%d",
	       key_serial(key), mapping->host->i_ino, nr_pages);

	ASSERT(key != NULL);
Linus Torvalds's avatar
Linus Torvalds committed
252

253
	vnode = AFS_FS_I(mapping->host);
254
	if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
255 256 257
		_leave(" = -ESTALE");
		return -ESTALE;
	}
Linus Torvalds's avatar
Linus Torvalds committed
258

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
	/* attempt to read as many of the pages as possible */
#ifdef CONFIG_AFS_FSCACHE
	ret = fscache_read_or_alloc_pages(vnode->cache,
					  mapping,
					  pages,
					  &nr_pages,
					  afs_file_readpage_read_complete,
					  NULL,
					  mapping_gfp_mask(mapping));
#else
	ret = -ENOBUFS;
#endif

	switch (ret) {
		/* all pages are being read from the cache */
	case 0:
		BUG_ON(!list_empty(pages));
		BUG_ON(nr_pages != 0);
		_leave(" = 0 [reading all]");
		return 0;

		/* there were pages that couldn't be read from the cache */
	case -ENODATA:
	case -ENOBUFS:
		break;

		/* other error */
	default:
		_leave(" = %d", ret);
		return ret;
Linus Torvalds's avatar
Linus Torvalds committed
289 290
	}

291
	/* load the missing pages from the network */
292
	ret = read_cache_pages(mapping, pages, afs_page_filler, key);
293 294 295

	_leave(" = %d [netting]", ret);
	return ret;
296
}
Linus Torvalds's avatar
Linus Torvalds committed
297

298 299 300 301 302 303 304 305 306 307
/*
 * write back a dirty page
 */
static int afs_launder_page(struct page *page)
{
	_enter("{%lu}", page->index);

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
308
/*
309 310 311 312
 * invalidate part or all of a page
 * - release a page and clean up its private data if offset is 0 (indicating
 *   the entire page)
 */
313 314
static void afs_invalidatepage(struct page *page, unsigned int offset,
			       unsigned int length)
315 316 317
{
	struct afs_writeback *wb = (struct afs_writeback *) page_private(page);

318
	_enter("{%lu},%u,%u", page->index, offset, length);
319 320 321 322

	BUG_ON(!PageLocked(page));

	/* we clean up only if the entire page is being invalidated */
323
	if (offset == 0 && length == PAGE_CACHE_SIZE) {
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
#ifdef CONFIG_AFS_FSCACHE
		if (PageFsCache(page)) {
			struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
			fscache_wait_on_page_write(vnode->cache, page);
			fscache_uncache_page(vnode->cache, page);
		}
#endif

		if (PagePrivate(page)) {
			if (wb && !PageWriteback(page)) {
				set_page_private(page, 0);
				afs_put_writeback(wb);
			}

			if (!page_private(page))
				ClearPagePrivate(page);
		}
	}

	_leave("");
}

/*
 * release a page and clean up its private state if it's not busy
 * - return true if the page can now be released, false if not
Linus Torvalds's avatar
Linus Torvalds committed
349
 */
David Howells's avatar
David Howells committed
350
static int afs_releasepage(struct page *page, gfp_t gfp_flags)
Linus Torvalds's avatar
Linus Torvalds committed
351
{
352
	struct afs_writeback *wb = (struct afs_writeback *) page_private(page);
David Howells's avatar
David Howells committed
353
	struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);
Linus Torvalds's avatar
Linus Torvalds committed
354

David Howells's avatar
David Howells committed
355 356 357
	_enter("{{%x:%u}[%lu],%lx},%x",
	       vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,
	       gfp_flags);
Linus Torvalds's avatar
Linus Torvalds committed
358

359 360 361
	/* deny if page is being written to the cache and the caller hasn't
	 * elected to wait */
#ifdef CONFIG_AFS_FSCACHE
362 363 364
	if (!fscache_maybe_release_page(vnode->cache, page, gfp_flags)) {
		_leave(" = F [cache busy]");
		return 0;
365 366 367
	}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
368
	if (PagePrivate(page)) {
369 370 371 372
		if (wb) {
			set_page_private(page, 0);
			afs_put_writeback(wb);
		}
Linus Torvalds's avatar
Linus Torvalds committed
373 374 375
		ClearPagePrivate(page);
	}

376 377 378
	/* indicate that the page can be released */
	_leave(" = T");
	return 1;
379
}