blocklayout.c 23.1 KB
Newer Older
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 30 31
/*
 *  linux/fs/nfs/blocklayout/blocklayout.c
 *
 *  Module for the NFSv4.1 pNFS block layout driver.
 *
 *  Copyright (c) 2006 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Andy Adamson <andros@citi.umich.edu>
 *  Fred Isaman <iisaman@umich.edu>
 *
 * permission is granted to use, copy, create derivative works and
 * redistribute this software and such derivative works for any purpose,
 * so long as the name of the university of michigan is not used in
 * any advertising or publicity pertaining to the use or distribution
 * of this software without specific, written prior authorization.  if
 * the above copyright notice or any other identification of the
 * university of michigan is included in any copy of any portion of
 * this software, then the disclaimer below must also be included.
 *
 * this software is provided as is, without representation from the
 * university of michigan as to its fitness for any purpose, and without
 * warranty by the university of michigan of any kind, either express
 * or implied, including without limitation the implied warranties of
 * merchantability and fitness for a particular purpose.  the regents
 * of the university of michigan shall not be liable for any damages,
 * including special, indirect, incidental, or consequential damages,
 * with respect to any claim arising out or in connection with the use
 * of the software, even if it has been or is hereafter advised of the
 * possibility of such damages.
 */
F
Fred Isaman 已提交
32

33 34
#include <linux/module.h>
#include <linux/init.h>
J
Jim Rees 已提交
35 36
#include <linux/mount.h>
#include <linux/namei.h>
F
Fred Isaman 已提交
37
#include <linux/bio.h>		/* struct bio */
38
#include <linux/prefetch.h>
39
#include <linux/pagevec.h>
40

41
#include "../pnfs.h"
42
#include "../nfs4session.h"
43
#include "../internal.h"
44 45 46 47 48 49 50 51
#include "blocklayout.h"

#define NFSDBG_FACILITY	NFSDBG_PNFS_LD

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andy Adamson <andros@citi.umich.edu>");
MODULE_DESCRIPTION("The NFSv4.1 pNFS Block layout driver");

52
static bool is_hole(struct pnfs_block_extent *be)
F
Fred Isaman 已提交
53
{
54 55 56 57 58 59 60 61
	switch (be->be_state) {
	case PNFS_BLOCK_NONE_DATA:
		return true;
	case PNFS_BLOCK_INVALID_DATA:
		return be->be_tag ? false : true;
	default:
		return false;
	}
F
Fred Isaman 已提交
62 63
}

F
Fred Isaman 已提交
64 65 66 67 68
/* The data we are handed might be spread across several bios.  We need
 * to track when the last one is finished.
 */
struct parallel_io {
	struct kref refcnt;
69
	void (*pnfs_callback) (void *data);
F
Fred Isaman 已提交
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
	void *data;
};

static inline struct parallel_io *alloc_parallel(void *data)
{
	struct parallel_io *rv;

	rv  = kmalloc(sizeof(*rv), GFP_NOFS);
	if (rv) {
		rv->data = data;
		kref_init(&rv->refcnt);
	}
	return rv;
}

static inline void get_parallel(struct parallel_io *p)
{
	kref_get(&p->refcnt);
}

static void destroy_parallel(struct kref *kref)
{
	struct parallel_io *p = container_of(kref, struct parallel_io, refcnt);

	dprintk("%s enter\n", __func__);
95
	p->pnfs_callback(p->data);
F
Fred Isaman 已提交
96 97 98 99 100 101 102 103 104 105 106 107 108 109
	kfree(p);
}

static inline void put_parallel(struct parallel_io *p)
{
	kref_put(&p->refcnt, destroy_parallel);
}

static struct bio *
bl_submit_bio(int rw, struct bio *bio)
{
	if (bio) {
		get_parallel(bio->bi_private);
		dprintk("%s submitting %s bio %u@%llu\n", __func__,
110 111
			rw == READ ? "read" : "write", bio->bi_iter.bi_size,
			(unsigned long long)bio->bi_iter.bi_sector);
F
Fred Isaman 已提交
112 113 114 115 116
		submit_bio(rw, bio);
	}
	return NULL;
}

117 118
static struct bio *
bl_alloc_init_bio(int npg, struct block_device *bdev, sector_t disk_sector,
119
		bio_end_io_t end_io, struct parallel_io *par)
F
Fred Isaman 已提交
120 121 122
{
	struct bio *bio;

P
Peng Tao 已提交
123
	npg = min(npg, BIO_MAX_PAGES);
F
Fred Isaman 已提交
124
	bio = bio_alloc(GFP_NOIO, npg);
P
Peng Tao 已提交
125 126 127 128
	if (!bio && (current->flags & PF_MEMALLOC)) {
		while (!bio && (npg /= 2))
			bio = bio_alloc(GFP_NOIO, npg);
	}
F
Fred Isaman 已提交
129

P
Peng Tao 已提交
130
	if (bio) {
131 132
		bio->bi_iter.bi_sector = disk_sector;
		bio->bi_bdev = bdev;
P
Peng Tao 已提交
133 134 135
		bio->bi_end_io = end_io;
		bio->bi_private = par;
	}
F
Fred Isaman 已提交
136 137 138
	return bio;
}

139 140 141
static struct bio *
do_add_page_to_bio(struct bio *bio, int npg, int rw, sector_t isect,
		struct page *page, struct pnfs_block_dev_map *map,
142
		struct pnfs_block_extent *be, bio_end_io_t end_io,
143
		struct parallel_io *par, unsigned int offset, int *len)
F
Fred Isaman 已提交
144
{
145 146 147 148
	struct pnfs_block_dev *dev =
		container_of(be->be_device, struct pnfs_block_dev, node);
	u64 disk_addr, end;

149
	dprintk("%s: npg %d rw %d isect %llu offset %u len %d\n", __func__,
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
		npg, rw, (unsigned long long)isect, offset, *len);

	/* translate to device offset */
	isect += be->be_v_offset;
	isect -= be->be_f_offset;

	/* translate to physical disk offset */
	disk_addr = (u64)isect << SECTOR_SHIFT;
	if (disk_addr < map->start || disk_addr >= map->start + map->len) {
		if (!dev->map(dev, disk_addr, map))
			return ERR_PTR(-EIO);
		bio = bl_submit_bio(rw, bio);
	}
	disk_addr += map->disk_offset;
	disk_addr -= map->start;

	/* limit length to what the device mapping allows */
	end = disk_addr + *len;
	if (end >= map->start + map->len)
		*len = map->start + map->len - disk_addr;

F
Fred Isaman 已提交
171 172
retry:
	if (!bio) {
173 174
		bio = bl_alloc_init_bio(npg, map->bdev,
				disk_addr >> SECTOR_SHIFT, end_io, par);
F
Fred Isaman 已提交
175 176 177
		if (!bio)
			return ERR_PTR(-ENOMEM);
	}
178
	if (bio_add_page(bio, page, *len, offset) < *len) {
F
Fred Isaman 已提交
179 180 181 182 183 184
		bio = bl_submit_bio(rw, bio);
		goto retry;
	}
	return bio;
}

185
static void bl_end_io_read(struct bio *bio)
F
Fred Isaman 已提交
186 187 188
{
	struct parallel_io *par = bio->bi_private;

189
	if (bio->bi_error) {
190
		struct nfs_pgio_header *header = par->data;
191 192 193 194

		if (!header->pnfs_error)
			header->pnfs_error = -EIO;
		pnfs_set_lo_fail(header->lseg);
F
Fred Isaman 已提交
195
	}
196

F
Fred Isaman 已提交
197 198 199 200 201 202 203
	bio_put(bio);
	put_parallel(par);
}

static void bl_read_cleanup(struct work_struct *work)
{
	struct rpc_task *task;
204
	struct nfs_pgio_header *hdr;
F
Fred Isaman 已提交
205 206
	dprintk("%s enter\n", __func__);
	task = container_of(work, struct rpc_task, u.tk_work);
207 208
	hdr = container_of(task, struct nfs_pgio_header, task);
	pnfs_ld_read_done(hdr);
F
Fred Isaman 已提交
209 210 211
}

static void
212
bl_end_par_io_read(void *data)
F
Fred Isaman 已提交
213
{
214
	struct nfs_pgio_header *hdr = data;
F
Fred Isaman 已提交
215

216 217 218
	hdr->task.tk_status = hdr->pnfs_error;
	INIT_WORK(&hdr->task.u.tk_work, bl_read_cleanup);
	schedule_work(&hdr->task.u.tk_work);
F
Fred Isaman 已提交
219 220
}

221
static enum pnfs_try_status
222
bl_read_pagelist(struct nfs_pgio_header *header)
223
{
224
	struct pnfs_block_layout *bl = BLK_LSEG2EXT(header->lseg);
225
	struct pnfs_block_dev_map map = { .start = NFS4_MAX_UINT64 };
F
Fred Isaman 已提交
226
	struct bio *bio = NULL;
227
	struct pnfs_block_extent be;
F
Fred Isaman 已提交
228 229
	sector_t isect, extent_length = 0;
	struct parallel_io *par;
230 231
	loff_t f_offset = header->args.offset;
	size_t bytes_left = header->args.count;
232
	unsigned int pg_offset = header->args.pgbase, pg_len;
233 234
	struct page **pages = header->args.pages;
	int pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
P
Peng Tao 已提交
235
	const bool is_dio = (header->dreq != NULL);
236
	struct blk_plug plug;
237
	int i;
F
Fred Isaman 已提交
238

239
	dprintk("%s enter nr_pages %u offset %lld count %u\n", __func__,
240 241
		header->page_array.npages, f_offset,
		(unsigned int)header->args.count);
F
Fred Isaman 已提交
242

243
	par = alloc_parallel(header);
F
Fred Isaman 已提交
244
	if (!par)
245
		return PNFS_NOT_ATTEMPTED;
F
Fred Isaman 已提交
246 247
	par->pnfs_callback = bl_end_par_io_read;

248 249
	blk_start_plug(&plug);

F
Fred Isaman 已提交
250 251
	isect = (sector_t) (f_offset >> SECTOR_SHIFT);
	/* Code assumes extents are page-aligned */
252
	for (i = pg_index; i < header->page_array.npages; i++) {
253
		if (extent_length <= 0) {
F
Fred Isaman 已提交
254 255
			/* We've used up the previous extent */
			bio = bl_submit_bio(READ, bio);
256

F
Fred Isaman 已提交
257
			/* Get the next one */
258
			if (!ext_tree_lookup(bl, isect, &be, false)) {
259
				header->pnfs_error = -EIO;
F
Fred Isaman 已提交
260 261
				goto out;
			}
262
			extent_length = be.be_length - (isect - be.be_f_offset);
F
Fred Isaman 已提交
263
		}
P
Peng Tao 已提交
264 265 266 267 268 269 270

		if (is_dio) {
			if (pg_offset + bytes_left > PAGE_CACHE_SIZE)
				pg_len = PAGE_CACHE_SIZE - pg_offset;
			else
				pg_len = bytes_left;
		} else {
271
			BUG_ON(pg_offset != 0);
P
Peng Tao 已提交
272 273 274
			pg_len = PAGE_CACHE_SIZE;
		}

275
		if (is_hole(&be)) {
F
Fred Isaman 已提交
276 277 278
			bio = bl_submit_bio(READ, bio);
			/* Fill hole w/ zeroes w/o accessing device */
			dprintk("%s Zeroing page for hole\n", __func__);
P
Peng Tao 已提交
279
			zero_user_segment(pages[i], pg_offset, pg_len);
280 281 282

			/* invalidate map */
			map.start = NFS4_MAX_UINT64;
F
Fred Isaman 已提交
283
		} else {
284
			bio = do_add_page_to_bio(bio,
285
						 header->page_array.npages - i,
F
Fred Isaman 已提交
286
						 READ,
287
						 isect, pages[i], &map, &be,
P
Peng Tao 已提交
288
						 bl_end_io_read, par,
289
						 pg_offset, &pg_len);
F
Fred Isaman 已提交
290
			if (IS_ERR(bio)) {
291
				header->pnfs_error = PTR_ERR(bio);
P
Peng Tao 已提交
292
				bio = NULL;
F
Fred Isaman 已提交
293 294 295
				goto out;
			}
		}
P
Peng Tao 已提交
296
		isect += (pg_len >> SECTOR_SHIFT);
297
		extent_length -= (pg_len >> SECTOR_SHIFT);
298 299
		f_offset += pg_len;
		bytes_left -= pg_len;
300
		pg_offset = 0;
F
Fred Isaman 已提交
301
	}
302
	if ((isect << SECTOR_SHIFT) >= header->inode->i_size) {
303 304
		header->res.eof = 1;
		header->res.count = header->inode->i_size - header->args.offset;
F
Fred Isaman 已提交
305
	} else {
306
		header->res.count = (isect << SECTOR_SHIFT) - header->args.offset;
F
Fred Isaman 已提交
307 308 309
	}
out:
	bl_submit_bio(READ, bio);
310
	blk_finish_plug(&plug);
F
Fred Isaman 已提交
311 312
	put_parallel(par);
	return PNFS_ATTEMPTED;
313 314
}

315
static void bl_end_io_write(struct bio *bio)
F
Fred Isaman 已提交
316 317
{
	struct parallel_io *par = bio->bi_private;
318
	struct nfs_pgio_header *header = par->data;
F
Fred Isaman 已提交
319

320
	if (bio->bi_error) {
321 322 323
		if (!header->pnfs_error)
			header->pnfs_error = -EIO;
		pnfs_set_lo_fail(header->lseg);
F
Fred Isaman 已提交
324 325 326 327 328 329 330 331 332 333
	}
	bio_put(bio);
	put_parallel(par);
}

/* Function scheduled for call during bl_end_par_io_write,
 * it marks sectors as written and extends the commitlist.
 */
static void bl_write_cleanup(struct work_struct *work)
{
334 335 336 337
	struct rpc_task *task = container_of(work, struct rpc_task, u.tk_work);
	struct nfs_pgio_header *hdr =
			container_of(task, struct nfs_pgio_header, task);

F
Fred Isaman 已提交
338
	dprintk("%s enter\n", __func__);
339

340
	if (likely(!hdr->pnfs_error)) {
341 342 343 344 345 346 347
		struct pnfs_block_layout *bl = BLK_LSEG2EXT(hdr->lseg);
		u64 start = hdr->args.offset & (loff_t)PAGE_CACHE_MASK;
		u64 end = (hdr->args.offset + hdr->args.count +
			PAGE_CACHE_SIZE - 1) & (loff_t)PAGE_CACHE_MASK;

		ext_tree_mark_written(bl, start >> SECTOR_SHIFT,
					(end - start) >> SECTOR_SHIFT);
348
	}
349

350
	pnfs_ld_write_done(hdr);
F
Fred Isaman 已提交
351 352 353
}

/* Called when last of bios associated with a bl_write_pagelist call finishes */
354
static void bl_end_par_io_write(void *data)
F
Fred Isaman 已提交
355
{
356
	struct nfs_pgio_header *hdr = data;
F
Fred Isaman 已提交
357

358
	hdr->task.tk_status = hdr->pnfs_error;
359
	hdr->verf.committed = NFS_FILE_SYNC;
360 361
	INIT_WORK(&hdr->task.u.tk_work, bl_write_cleanup);
	schedule_work(&hdr->task.u.tk_work);
F
Fred Isaman 已提交
362 363
}

364
static enum pnfs_try_status
365
bl_write_pagelist(struct nfs_pgio_header *header, int sync)
366
{
367
	struct pnfs_block_layout *bl = BLK_LSEG2EXT(header->lseg);
368
	struct pnfs_block_dev_map map = { .start = NFS4_MAX_UINT64 };
F
Fred Isaman 已提交
369
	struct bio *bio = NULL;
370
	struct pnfs_block_extent be;
371
	sector_t isect, extent_length = 0;
P
Peng Tao 已提交
372
	struct parallel_io *par = NULL;
373 374 375
	loff_t offset = header->args.offset;
	size_t count = header->args.count;
	struct page **pages = header->args.pages;
J
Jan Kara 已提交
376
	int pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
377
	unsigned int pg_len;
378
	struct blk_plug plug;
379
	int i;
F
Fred Isaman 已提交
380 381

	dprintk("%s enter, %Zu@%lld\n", __func__, count, offset);
P
Peng Tao 已提交
382

383
	/* At this point, header->page_aray is a (sequential) list of nfs_pages.
384 385
	 * We want to write each, and if there is an error set pnfs_error
	 * to have it redone using nfs.
F
Fred Isaman 已提交
386
	 */
387
	par = alloc_parallel(header);
F
Fred Isaman 已提交
388
	if (!par)
389
		return PNFS_NOT_ATTEMPTED;
F
Fred Isaman 已提交
390 391
	par->pnfs_callback = bl_end_par_io_write;

392
	blk_start_plug(&plug);
393

394 395 396
	/* we always write out the whole page */
	offset = offset & (loff_t)PAGE_CACHE_MASK;
	isect = offset >> SECTOR_SHIFT;
397

398
	for (i = pg_index; i < header->page_array.npages; i++) {
399
		if (extent_length <= 0) {
F
Fred Isaman 已提交
400 401 402
			/* We've used up the previous extent */
			bio = bl_submit_bio(WRITE, bio);
			/* Get the next one */
403
			if (!ext_tree_lookup(bl, isect, &be, true)) {
404
				header->pnfs_error = -EINVAL;
F
Fred Isaman 已提交
405 406
				goto out;
			}
407

408
			extent_length = be.be_length - (isect - be.be_f_offset);
409
		}
410

411
		pg_len = PAGE_CACHE_SIZE;
412
		bio = do_add_page_to_bio(bio, header->page_array.npages - i,
413
					 WRITE, isect, pages[i], &map, &be,
414
					 bl_end_io_write, par,
415
					 0, &pg_len);
416
		if (IS_ERR(bio)) {
417
			header->pnfs_error = PTR_ERR(bio);
P
Peng Tao 已提交
418
			bio = NULL;
419
			goto out;
F
Fred Isaman 已提交
420
		}
421 422 423 424 425

		offset += pg_len;
		count -= pg_len;
		isect += (pg_len >> SECTOR_SHIFT);
		extent_length -= (pg_len >> SECTOR_SHIFT);
F
Fred Isaman 已提交
426
	}
427

428
	header->res.count = header->args.count;
F
Fred Isaman 已提交
429 430
out:
	bl_submit_bio(WRITE, bio);
431
	blk_finish_plug(&plug);
F
Fred Isaman 已提交
432 433
	put_parallel(par);
	return PNFS_ATTEMPTED;
434 435 436 437 438
}

static void bl_free_layout_hdr(struct pnfs_layout_hdr *lo)
{
	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
439
	int err;
440 441

	dprintk("%s enter\n", __func__);
442 443 444 445

	err = ext_tree_remove(bl, true, 0, LLONG_MAX);
	WARN_ON(err);

446 447 448 449 450 451 452 453 454 455 456 457
	kfree(bl);
}

static struct pnfs_layout_hdr *bl_alloc_layout_hdr(struct inode *inode,
						   gfp_t gfp_flags)
{
	struct pnfs_block_layout *bl;

	dprintk("%s enter\n", __func__);
	bl = kzalloc(sizeof(*bl), gfp_flags);
	if (!bl)
		return NULL;
458 459 460

	bl->bl_ext_rw = RB_ROOT;
	bl->bl_ext_ro = RB_ROOT;
461
	spin_lock_init(&bl->bl_ext_lock);
462

463 464 465
	return &bl->bl_layout;
}

F
Fred Isaman 已提交
466
static void bl_free_lseg(struct pnfs_layout_segment *lseg)
467
{
F
Fred Isaman 已提交
468 469
	dprintk("%s enter\n", __func__);
	kfree(lseg);
470 471
}

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
/* Tracks info needed to ensure extents in layout obey constraints of spec */
struct layout_verification {
	u32 mode;	/* R or RW */
	u64 start;	/* Expected start of next non-COW extent */
	u64 inval;	/* Start of INVAL coverage */
	u64 cowread;	/* End of COW read coverage */
};

/* Verify the extent meets the layout requirements of the pnfs-block draft,
 * section 2.3.1.
 */
static int verify_extent(struct pnfs_block_extent *be,
			 struct layout_verification *lv)
{
	if (lv->mode == IOMODE_READ) {
		if (be->be_state == PNFS_BLOCK_READWRITE_DATA ||
		    be->be_state == PNFS_BLOCK_INVALID_DATA)
			return -EIO;
		if (be->be_f_offset != lv->start)
			return -EIO;
		lv->start += be->be_length;
		return 0;
	}
	/* lv->mode == IOMODE_RW */
	if (be->be_state == PNFS_BLOCK_READWRITE_DATA) {
		if (be->be_f_offset != lv->start)
			return -EIO;
		if (lv->cowread > lv->start)
			return -EIO;
		lv->start += be->be_length;
		lv->inval = lv->start;
		return 0;
	} else if (be->be_state == PNFS_BLOCK_INVALID_DATA) {
		if (be->be_f_offset != lv->start)
			return -EIO;
		lv->start += be->be_length;
		return 0;
	} else if (be->be_state == PNFS_BLOCK_READ_DATA) {
		if (be->be_f_offset > lv->start)
			return -EIO;
		if (be->be_f_offset < lv->inval)
			return -EIO;
		if (be->be_f_offset < lv->cowread)
			return -EIO;
		/* It looks like you might want to min this with lv->start,
		 * but you really don't.
		 */
		lv->inval = lv->inval + be->be_length;
		lv->cowread = be->be_f_offset + be->be_length;
		return 0;
	} else
		return -EIO;
}

static int decode_sector_number(__be32 **rp, sector_t *sp)
{
	uint64_t s;

	*rp = xdr_decode_hyper(*rp, &s);
	if (s & 0x1ff) {
		printk(KERN_WARNING "NFS: %s: sector not aligned\n", __func__);
		return -1;
	}
	*sp = s >> SECTOR_SHIFT;
	return 0;
}

static int
540 541 542
bl_alloc_extent(struct xdr_stream *xdr, struct pnfs_layout_hdr *lo,
		struct layout_verification *lv, struct list_head *extents,
		gfp_t gfp_mask)
543
{
544 545 546
	struct pnfs_block_extent *be;
	struct nfs4_deviceid id;
	int error;
547
	__be32 *p;
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597

	p = xdr_inline_decode(xdr, 28 + NFS4_DEVICEID4_SIZE);
	if (!p)
		return -EIO;

	be = kzalloc(sizeof(*be), GFP_NOFS);
	if (!be)
		return -ENOMEM;

	memcpy(&id, p, NFS4_DEVICEID4_SIZE);
	p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);

	error = -EIO;
	be->be_device = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode), &id,
						lo->plh_lc_cred, gfp_mask);
	if (!be->be_device)
		goto out_free_be;

	/*
	 * The next three values are read in as bytes, but stored in the
	 * extent structure in 512-byte granularity.
	 */
	if (decode_sector_number(&p, &be->be_f_offset) < 0)
		goto out_put_deviceid;
	if (decode_sector_number(&p, &be->be_length) < 0)
		goto out_put_deviceid;
	if (decode_sector_number(&p, &be->be_v_offset) < 0)
		goto out_put_deviceid;
	be->be_state = be32_to_cpup(p++);

	error = verify_extent(be, lv);
	if (error) {
		dprintk("%s: extent verification failed\n", __func__);
		goto out_put_deviceid;
	}

	list_add_tail(&be->be_list, extents);
	return 0;

out_put_deviceid:
	nfs4_put_deviceid_node(be->be_device);
out_free_be:
	kfree(be);
	return error;
}

static struct pnfs_layout_segment *
bl_alloc_lseg(struct pnfs_layout_hdr *lo, struct nfs4_layoutget_res *lgr,
		gfp_t gfp_mask)
{
598 599 600 601 602 603
	struct layout_verification lv = {
		.mode = lgr->range.iomode,
		.start = lgr->range.offset >> SECTOR_SHIFT,
		.inval = lgr->range.offset >> SECTOR_SHIFT,
		.cowread = lgr->range.offset >> SECTOR_SHIFT,
	};
604 605 606 607 608 609 610 611
	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
	struct pnfs_layout_segment *lseg;
	struct xdr_buf buf;
	struct xdr_stream xdr;
	struct page *scratch;
	int status, i;
	uint32_t count;
	__be32 *p;
612 613 614 615
	LIST_HEAD(extents);

	dprintk("---> %s\n", __func__);

616 617 618 619 620 621
	lseg = kzalloc(sizeof(*lseg), gfp_mask);
	if (!lseg)
		return ERR_PTR(-ENOMEM);

	status = -ENOMEM;
	scratch = alloc_page(gfp_mask);
622
	if (!scratch)
623
		goto out;
624

625 626 627
	xdr_init_decode_pages(&xdr, &buf,
			lgr->layoutp->pages, lgr->layoutp->len);
	xdr_set_scratch_buffer(&xdr, page_address(scratch), PAGE_SIZE);
628

629 630
	status = -EIO;
	p = xdr_inline_decode(&xdr, 4);
631
	if (unlikely(!p))
632
		goto out_free_scratch;
633 634

	count = be32_to_cpup(p++);
635
	dprintk("%s: number of extents %d\n", __func__, count);
636

637 638 639
	/*
	 * Decode individual extents, putting them in temporary staging area
	 * until whole layout is decoded to make error recovery easier.
640 641
	 */
	for (i = 0; i < count; i++) {
642 643 644
		status = bl_alloc_extent(&xdr, lo, &lv, &extents, gfp_mask);
		if (status)
			goto process_extents;
645
	}
646

647 648 649
	if (lgr->range.offset + lgr->range.length !=
			lv.start << SECTOR_SHIFT) {
		dprintk("%s Final length mismatch\n", __func__);
650 651
		status = -EIO;
		goto process_extents;
652
	}
653

654 655
	if (lv.start < lv.cowread) {
		dprintk("%s Final uncovered COW extent\n", __func__);
656
		status = -EIO;
657 658
	}

659
process_extents:
660
	while (!list_empty(&extents)) {
661 662 663
		struct pnfs_block_extent *be =
			list_first_entry(&extents, struct pnfs_block_extent,
					 be_list);
664 665
		list_del(&be->be_list);

666 667
		if (!status)
			status = ext_tree_insert(bl, be);
F
Fred Isaman 已提交
668

669 670 671 672 673 674 675 676 677 678
		if (status) {
			nfs4_put_deviceid_node(be->be_device);
			kfree(be);
		}
	}

out_free_scratch:
	__free_page(scratch);
out:
	dprintk("%s returns %d\n", __func__, status);
F
Fred Isaman 已提交
679 680 681 682 683
	if (status) {
		kfree(lseg);
		return ERR_PTR(status);
	}
	return lseg;
684 685
}

686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
static void
bl_return_range(struct pnfs_layout_hdr *lo,
		struct pnfs_layout_range *range)
{
	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
	sector_t offset = range->offset >> SECTOR_SHIFT, end;

	if (range->offset % 8) {
		dprintk("%s: offset %lld not block size aligned\n",
			__func__, range->offset);
		return;
	}

	if (range->length != NFS4_MAX_UINT64) {
		if (range->length % 8) {
			dprintk("%s: length %lld not block size aligned\n",
				__func__, range->length);
			return;
		}

		end = offset + (range->length >> SECTOR_SHIFT);
	} else {
		end = round_down(NFS4_MAX_UINT64, PAGE_SIZE);
	}

711
	ext_tree_remove(bl, range->iomode & IOMODE_RW, offset, end);
712 713
}

714 715
static int
bl_prepare_layoutcommit(struct nfs4_layoutcommit_args *arg)
716
{
717
	return ext_tree_prepare_commit(arg);
718 719 720 721 722
}

static void
bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
{
723
	ext_tree_mark_committed(&lcdata->args, lcdata->res.status);
724 725 726 727 728 729
}

static int
bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)
{
	dprintk("%s enter\n", __func__);
730 731 732 733 734

	if (server->pnfs_blksize == 0) {
		dprintk("%s Server did not return blksize\n", __func__);
		return -EINVAL;
	}
735 736 737 738 739 740
	if (server->pnfs_blksize > PAGE_SIZE) {
		printk(KERN_ERR "%s: pNFS blksize %d not supported.\n",
			__func__, server->pnfs_blksize);
		return -EINVAL;
	}

741
	return 0;
742 743
}

P
Peng Tao 已提交
744
static bool
745 746
is_aligned_req(struct nfs_pageio_descriptor *pgio,
		struct nfs_page *req, unsigned int alignment)
P
Peng Tao 已提交
747
{
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
	/*
	 * Always accept buffered writes, higher layers take care of the
	 * right alignment.
	 */
	if (pgio->pg_dreq == NULL)
		return true;

	if (!IS_ALIGNED(req->wb_offset, alignment))
		return false;

	if (IS_ALIGNED(req->wb_bytes, alignment))
		return true;

	if (req_offset(req) + req->wb_bytes == i_size_read(pgio->pg_inode)) {
		/*
		 * If the write goes up to the inode size, just write
		 * the full page.  Data past the inode size is
		 * guaranteed to be zeroed by the higher level client
		 * code, and this behaviour is mandated by RFC 5663
		 * section 2.3.2.
		 */
		return true;
	}

	return false;
P
Peng Tao 已提交
773 774 775 776 777
}

static void
bl_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
778
	if (!is_aligned_req(pgio, req, SECTOR_SIZE)) {
P
Peng Tao 已提交
779
		nfs_pageio_reset_read_mds(pgio);
780 781 782 783
		return;
	}

	pnfs_generic_pg_init_read(pgio, req);
P
Peng Tao 已提交
784 785
}

786 787 788 789 790
/*
 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number
 * of bytes (maximum @req->wb_bytes) that can be coalesced.
 */
static size_t
P
Peng Tao 已提交
791 792 793
bl_pg_test_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
		struct nfs_page *req)
{
794
	if (!is_aligned_req(pgio, req, SECTOR_SIZE))
795
		return 0;
P
Peng Tao 已提交
796 797 798
	return pnfs_generic_pg_test(pgio, prev, req);
}

799 800 801 802 803 804 805 806 807 808 809
/*
 * Return the number of contiguous bytes for a given inode
 * starting at page frame idx.
 */
static u64 pnfs_num_cont_bytes(struct inode *inode, pgoff_t idx)
{
	struct address_space *mapping = inode->i_mapping;
	pgoff_t end;

	/* Optimize common case that writes from 0 to end of file */
	end = DIV_ROUND_UP(i_size_read(inode), PAGE_CACHE_SIZE);
810
	if (end != inode->i_mapping->nrpages) {
811
		rcu_read_lock();
812
		end = page_cache_next_hole(mapping, idx + 1, ULONG_MAX);
813 814 815 816 817 818 819 820 821
		rcu_read_unlock();
	}

	if (!end)
		return i_size_read(inode) - (idx << PAGE_CACHE_SHIFT);
	else
		return (end - idx) << PAGE_CACHE_SHIFT;
}

822
static void
P
Peng Tao 已提交
823 824
bl_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
825 826 827
	u64 wb_size;

	if (!is_aligned_req(pgio, req, PAGE_SIZE)) {
P
Peng Tao 已提交
828
		nfs_pageio_reset_write_mds(pgio);
829
		return;
830
	}
831 832 833 834 835 836 837 838

	if (pgio->pg_dreq == NULL)
		wb_size = pnfs_num_cont_bytes(pgio->pg_inode,
					      req->wb_index);
	else
		wb_size = nfs_dreq_bytes_left(pgio->pg_dreq);

	pnfs_generic_pg_init_write(pgio, req, wb_size);
P
Peng Tao 已提交
839 840
}

841 842 843 844 845
/*
 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number
 * of bytes (maximum @req->wb_bytes) that can be coalesced.
 */
static size_t
P
Peng Tao 已提交
846 847 848
bl_pg_test_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
		 struct nfs_page *req)
{
849
	if (!is_aligned_req(pgio, req, PAGE_SIZE))
850
		return 0;
P
Peng Tao 已提交
851 852 853
	return pnfs_generic_pg_test(pgio, prev, req);
}

B
Benny Halevy 已提交
854
static const struct nfs_pageio_ops bl_pg_read_ops = {
P
Peng Tao 已提交
855 856
	.pg_init = bl_pg_init_read,
	.pg_test = bl_pg_test_read,
B
Benny Halevy 已提交
857
	.pg_doio = pnfs_generic_pg_readpages,
858
	.pg_cleanup = pnfs_generic_pg_cleanup,
B
Benny Halevy 已提交
859 860 861
};

static const struct nfs_pageio_ops bl_pg_write_ops = {
P
Peng Tao 已提交
862 863
	.pg_init = bl_pg_init_write,
	.pg_test = bl_pg_test_write,
B
Benny Halevy 已提交
864
	.pg_doio = pnfs_generic_pg_writepages,
865
	.pg_cleanup = pnfs_generic_pg_cleanup,
B
Benny Halevy 已提交
866 867
};

868 869 870
static struct pnfs_layoutdriver_type blocklayout_type = {
	.id				= LAYOUT_BLOCK_VOLUME,
	.name				= "LAYOUT_BLOCK_VOLUME",
871
	.owner				= THIS_MODULE,
872 873
	.flags				= PNFS_LAYOUTRET_ON_SETATTR |
					  PNFS_READ_WHOLE_PAGE,
874 875 876 877 878 879
	.read_pagelist			= bl_read_pagelist,
	.write_pagelist			= bl_write_pagelist,
	.alloc_layout_hdr		= bl_alloc_layout_hdr,
	.free_layout_hdr		= bl_free_layout_hdr,
	.alloc_lseg			= bl_alloc_lseg,
	.free_lseg			= bl_free_lseg,
880
	.return_range			= bl_return_range,
881
	.prepare_layoutcommit		= bl_prepare_layoutcommit,
882 883
	.cleanup_layoutcommit		= bl_cleanup_layoutcommit,
	.set_layoutdriver		= bl_set_layoutdriver,
884 885
	.alloc_deviceid_node		= bl_alloc_deviceid_node,
	.free_deviceid_node		= bl_free_deviceid_node,
B
Benny Halevy 已提交
886 887
	.pg_read_ops			= &bl_pg_read_ops,
	.pg_write_ops			= &bl_pg_write_ops,
888
	.sync				= pnfs_generic_sync,
889 890 891 892 893 894 895 896 897
};

static int __init nfs4blocklayout_init(void)
{
	int ret;

	dprintk("%s: NFSv4 Block Layout Driver Registering...\n", __func__);

	ret = pnfs_register_layoutdriver(&blocklayout_type);
J
Jim Rees 已提交
898 899
	if (ret)
		goto out;
900
	ret = bl_init_pipefs();
901
	if (ret)
902 903
		goto out_unregister;
	return 0;
J
Jim Rees 已提交
904

905
out_unregister:
J
Jim Rees 已提交
906
	pnfs_unregister_layoutdriver(&blocklayout_type);
907
out:
908 909 910 911 912 913 914 915
	return ret;
}

static void __exit nfs4blocklayout_exit(void)
{
	dprintk("%s: NFSv4 Block Layout Driver Unregistering...\n",
	       __func__);

916
	bl_cleanup_pipefs();
917 918 919 920 921 922 923
	pnfs_unregister_layoutdriver(&blocklayout_type);
}

MODULE_ALIAS("nfs-layouttype4-3");

module_init(nfs4blocklayout_init);
module_exit(nfs4blocklayout_exit);