blocklayout.c 24.5 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
	kfree(p);
}

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

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

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

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

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

140 141 142
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,
143
		struct pnfs_block_extent *be, bio_end_io_t end_io,
144
		struct parallel_io *par, unsigned int offset, int *len)
F
Fred Isaman 已提交
145
{
146 147 148 149
	struct pnfs_block_dev *dev =
		container_of(be->be_device, struct pnfs_block_dev, node);
	u64 disk_addr, end;

150
	dprintk("%s: npg %d rw %d isect %llu offset %u len %d\n", __func__,
151 152 153 154 155 156 157 158 159 160 161
		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);
162
		bio = bl_submit_bio(bio);
163 164 165 166 167 168 169 170 171
	}
	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 已提交
172 173
retry:
	if (!bio) {
174 175
		bio = bl_alloc_init_bio(npg, map->bdev,
				disk_addr >> SECTOR_SHIFT, end_io, par);
F
Fred Isaman 已提交
176 177
		if (!bio)
			return ERR_PTR(-ENOMEM);
178
		bio_set_op_attrs(bio, rw, 0);
F
Fred Isaman 已提交
179
	}
180
	if (bio_add_page(bio, page, *len, offset) < *len) {
181
		bio = bl_submit_bio(bio);
F
Fred Isaman 已提交
182 183 184 185 186
		goto retry;
	}
	return bio;
}

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

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

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

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

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

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

218 219 220
	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 已提交
221 222
}

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

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

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

250 251
	blk_start_plug(&plug);

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

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

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

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

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

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

322
	if (bio->bi_error) {
323 324 325
		if (!header->pnfs_error)
			header->pnfs_error = -EIO;
		pnfs_set_lo_fail(header->lseg);
F
Fred Isaman 已提交
326 327 328 329 330 331 332 333 334 335
	}
	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)
{
336 337 338 339
	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 已提交
340
	dprintk("%s enter\n", __func__);
341

342
	if (likely(!hdr->pnfs_error)) {
343
		struct pnfs_block_layout *bl = BLK_LSEG2EXT(hdr->lseg);
344
		u64 start = hdr->args.offset & (loff_t)PAGE_MASK;
345
		u64 end = (hdr->args.offset + hdr->args.count +
346
			PAGE_SIZE - 1) & (loff_t)PAGE_MASK;
347
		u64 lwb = hdr->args.offset + hdr->args.count;
348 349

		ext_tree_mark_written(bl, start >> SECTOR_SHIFT,
350
					(end - start) >> SECTOR_SHIFT, lwb);
351
	}
352

353
	pnfs_ld_write_done(hdr);
F
Fred Isaman 已提交
354 355 356
}

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

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

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

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

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

395
	blk_start_plug(&plug);
396

397
	/* we always write out the whole page */
398
	offset = offset & (loff_t)PAGE_MASK;
399
	isect = offset >> SECTOR_SHIFT;
400

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

411
			extent_length = be.be_length - (isect - be.be_f_offset);
412
		}
413

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

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

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

static void bl_free_layout_hdr(struct pnfs_layout_hdr *lo)
{
	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
442
	int err;
443 444

	dprintk("%s enter\n", __func__);
445 446 447 448

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

449 450 451
	kfree(bl);
}

452 453
static struct pnfs_layout_hdr *__bl_alloc_layout_hdr(struct inode *inode,
		gfp_t gfp_flags, bool is_scsi_layout)
454 455 456 457 458 459 460
{
	struct pnfs_block_layout *bl;

	dprintk("%s enter\n", __func__);
	bl = kzalloc(sizeof(*bl), gfp_flags);
	if (!bl)
		return NULL;
461 462 463

	bl->bl_ext_rw = RB_ROOT;
	bl->bl_ext_ro = RB_ROOT;
464
	spin_lock_init(&bl->bl_ext_lock);
465

466
	bl->bl_scsi_layout = is_scsi_layout;
467 468 469
	return &bl->bl_layout;
}

470 471 472 473 474 475 476 477 478 479 480 481
static struct pnfs_layout_hdr *bl_alloc_layout_hdr(struct inode *inode,
						   gfp_t gfp_flags)
{
	return __bl_alloc_layout_hdr(inode, gfp_flags, false);
}

static struct pnfs_layout_hdr *sl_alloc_layout_hdr(struct inode *inode,
						   gfp_t gfp_flags)
{
	return __bl_alloc_layout_hdr(inode, gfp_flags, true);
}

F
Fred Isaman 已提交
482
static void bl_free_lseg(struct pnfs_layout_segment *lseg)
483
{
F
Fred Isaman 已提交
484 485
	dprintk("%s enter\n", __func__);
	kfree(lseg);
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 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
/* 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
556 557 558
bl_alloc_extent(struct xdr_stream *xdr, struct pnfs_layout_hdr *lo,
		struct layout_verification *lv, struct list_head *extents,
		gfp_t gfp_mask)
559
{
560 561 562
	struct pnfs_block_extent *be;
	struct nfs4_deviceid id;
	int error;
563
	__be32 *p;
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 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613

	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)
{
614 615 616 617 618 619
	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,
	};
620 621 622 623 624 625 626 627
	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;
628 629 630 631
	LIST_HEAD(extents);

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

632 633 634 635 636 637
	lseg = kzalloc(sizeof(*lseg), gfp_mask);
	if (!lseg)
		return ERR_PTR(-ENOMEM);

	status = -ENOMEM;
	scratch = alloc_page(gfp_mask);
638
	if (!scratch)
639
		goto out;
640

641 642 643
	xdr_init_decode_pages(&xdr, &buf,
			lgr->layoutp->pages, lgr->layoutp->len);
	xdr_set_scratch_buffer(&xdr, page_address(scratch), PAGE_SIZE);
644

645 646
	status = -EIO;
	p = xdr_inline_decode(&xdr, 4);
647
	if (unlikely(!p))
648
		goto out_free_scratch;
649 650

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

653 654 655
	/*
	 * Decode individual extents, putting them in temporary staging area
	 * until whole layout is decoded to make error recovery easier.
656 657
	 */
	for (i = 0; i < count; i++) {
658 659 660
		status = bl_alloc_extent(&xdr, lo, &lv, &extents, gfp_mask);
		if (status)
			goto process_extents;
661
	}
662

663 664 665
	if (lgr->range.offset + lgr->range.length !=
			lv.start << SECTOR_SHIFT) {
		dprintk("%s Final length mismatch\n", __func__);
666 667
		status = -EIO;
		goto process_extents;
668
	}
669

670 671
	if (lv.start < lv.cowread) {
		dprintk("%s Final uncovered COW extent\n", __func__);
672
		status = -EIO;
673 674
	}

675
process_extents:
676
	while (!list_empty(&extents)) {
677 678 679
		struct pnfs_block_extent *be =
			list_first_entry(&extents, struct pnfs_block_extent,
					 be_list);
680 681
		list_del(&be->be_list);

682 683
		if (!status)
			status = ext_tree_insert(bl, be);
F
Fred Isaman 已提交
684

685 686 687 688 689 690 691 692 693 694
		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 已提交
695 696 697 698 699
	if (status) {
		kfree(lseg);
		return ERR_PTR(status);
	}
	return lseg;
700 701
}

702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
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);
	}

727
	ext_tree_remove(bl, range->iomode & IOMODE_RW, offset, end);
728 729
}

730 731
static int
bl_prepare_layoutcommit(struct nfs4_layoutcommit_args *arg)
732
{
733
	return ext_tree_prepare_commit(arg);
734 735 736 737 738
}

static void
bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
{
739
	ext_tree_mark_committed(&lcdata->args, lcdata->res.status);
740 741 742 743 744 745
}

static int
bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)
{
	dprintk("%s enter\n", __func__);
746 747 748 749 750

	if (server->pnfs_blksize == 0) {
		dprintk("%s Server did not return blksize\n", __func__);
		return -EINVAL;
	}
751 752 753 754 755 756
	if (server->pnfs_blksize > PAGE_SIZE) {
		printk(KERN_ERR "%s: pNFS blksize %d not supported.\n",
			__func__, server->pnfs_blksize);
		return -EINVAL;
	}

757
	return 0;
758 759
}

P
Peng Tao 已提交
760
static bool
761
is_aligned_req(struct nfs_pageio_descriptor *pgio,
762
		struct nfs_page *req, unsigned int alignment, bool is_write)
P
Peng Tao 已提交
763
{
764 765 766 767 768 769 770 771 772 773 774 775 776
	/*
	 * 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;

777 778
	if (is_write &&
	    (req_offset(req) + req->wb_bytes == i_size_read(pgio->pg_inode))) {
779 780 781 782 783 784 785 786 787 788 789
		/*
		 * 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 已提交
790 791 792 793 794
}

static void
bl_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
795
	if (!is_aligned_req(pgio, req, SECTOR_SIZE, false)) {
P
Peng Tao 已提交
796
		nfs_pageio_reset_read_mds(pgio);
797 798 799 800
		return;
	}

	pnfs_generic_pg_init_read(pgio, req);
P
Peng Tao 已提交
801 802
}

803 804 805 806 807
/*
 * 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 已提交
808 809 810
bl_pg_test_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
		struct nfs_page *req)
{
811
	if (!is_aligned_req(pgio, req, SECTOR_SIZE, false))
812
		return 0;
P
Peng Tao 已提交
813 814 815
	return pnfs_generic_pg_test(pgio, prev, req);
}

816 817 818 819 820 821 822 823 824 825
/*
 * 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 */
826
	end = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
827
	if (end != inode->i_mapping->nrpages) {
828
		rcu_read_lock();
829
		end = page_cache_next_hole(mapping, idx + 1, ULONG_MAX);
830 831 832 833
		rcu_read_unlock();
	}

	if (!end)
834
		return i_size_read(inode) - (idx << PAGE_SHIFT);
835
	else
836
		return (end - idx) << PAGE_SHIFT;
837 838
}

839
static void
P
Peng Tao 已提交
840 841
bl_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
842 843
	u64 wb_size;

844
	if (!is_aligned_req(pgio, req, PAGE_SIZE, true)) {
P
Peng Tao 已提交
845
		nfs_pageio_reset_write_mds(pgio);
846
		return;
847
	}
848 849 850 851 852 853 854 855

	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 已提交
856 857
}

858 859 860 861 862
/*
 * 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 已提交
863 864 865
bl_pg_test_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
		 struct nfs_page *req)
{
866
	if (!is_aligned_req(pgio, req, PAGE_SIZE, true))
867
		return 0;
P
Peng Tao 已提交
868 869 870
	return pnfs_generic_pg_test(pgio, prev, req);
}

B
Benny Halevy 已提交
871
static const struct nfs_pageio_ops bl_pg_read_ops = {
P
Peng Tao 已提交
872 873
	.pg_init = bl_pg_init_read,
	.pg_test = bl_pg_test_read,
B
Benny Halevy 已提交
874
	.pg_doio = pnfs_generic_pg_readpages,
875
	.pg_cleanup = pnfs_generic_pg_cleanup,
B
Benny Halevy 已提交
876 877 878
};

static const struct nfs_pageio_ops bl_pg_write_ops = {
P
Peng Tao 已提交
879 880
	.pg_init = bl_pg_init_write,
	.pg_test = bl_pg_test_write,
B
Benny Halevy 已提交
881
	.pg_doio = pnfs_generic_pg_writepages,
882
	.pg_cleanup = pnfs_generic_pg_cleanup,
B
Benny Halevy 已提交
883 884
};

885 886 887
static struct pnfs_layoutdriver_type blocklayout_type = {
	.id				= LAYOUT_BLOCK_VOLUME,
	.name				= "LAYOUT_BLOCK_VOLUME",
888
	.owner				= THIS_MODULE,
889 890
	.flags				= PNFS_LAYOUTRET_ON_SETATTR |
					  PNFS_READ_WHOLE_PAGE,
891 892 893 894 895 896
	.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,
897
	.return_range			= bl_return_range,
898
	.prepare_layoutcommit		= bl_prepare_layoutcommit,
899 900
	.cleanup_layoutcommit		= bl_cleanup_layoutcommit,
	.set_layoutdriver		= bl_set_layoutdriver,
901 902
	.alloc_deviceid_node		= bl_alloc_deviceid_node,
	.free_deviceid_node		= bl_free_deviceid_node,
B
Benny Halevy 已提交
903 904
	.pg_read_ops			= &bl_pg_read_ops,
	.pg_write_ops			= &bl_pg_write_ops,
905
	.sync				= pnfs_generic_sync,
906 907
};

908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
static struct pnfs_layoutdriver_type scsilayout_type = {
	.id				= LAYOUT_SCSI,
	.name				= "LAYOUT_SCSI",
	.owner				= THIS_MODULE,
	.flags				= PNFS_LAYOUTRET_ON_SETATTR |
					  PNFS_READ_WHOLE_PAGE,
	.read_pagelist			= bl_read_pagelist,
	.write_pagelist			= bl_write_pagelist,
	.alloc_layout_hdr		= sl_alloc_layout_hdr,
	.free_layout_hdr		= bl_free_layout_hdr,
	.alloc_lseg			= bl_alloc_lseg,
	.free_lseg			= bl_free_lseg,
	.return_range			= bl_return_range,
	.prepare_layoutcommit		= bl_prepare_layoutcommit,
	.cleanup_layoutcommit		= bl_cleanup_layoutcommit,
	.set_layoutdriver		= bl_set_layoutdriver,
	.alloc_deviceid_node		= bl_alloc_deviceid_node,
	.free_deviceid_node		= bl_free_deviceid_node,
	.pg_read_ops			= &bl_pg_read_ops,
	.pg_write_ops			= &bl_pg_write_ops,
	.sync				= pnfs_generic_sync,
};


932 933 934 935 936 937
static int __init nfs4blocklayout_init(void)
{
	int ret;

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

938
	ret = bl_init_pipefs();
J
Jim Rees 已提交
939 940
	if (ret)
		goto out;
941 942

	ret = pnfs_register_layoutdriver(&blocklayout_type);
943
	if (ret)
944 945 946 947 948
		goto out_cleanup_pipe;

	ret = pnfs_register_layoutdriver(&scsilayout_type);
	if (ret)
		goto out_unregister_block;
949
	return 0;
J
Jim Rees 已提交
950

951
out_unregister_block:
J
Jim Rees 已提交
952
	pnfs_unregister_layoutdriver(&blocklayout_type);
953 954
out_cleanup_pipe:
	bl_cleanup_pipefs();
955
out:
956 957 958 959 960 961 962 963
	return ret;
}

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

964
	pnfs_unregister_layoutdriver(&scsilayout_type);
965
	pnfs_unregister_layoutdriver(&blocklayout_type);
966
	bl_cleanup_pipefs();
967 968 969 970 971 972
}

MODULE_ALIAS("nfs-layouttype4-3");

module_init(nfs4blocklayout_init);
module_exit(nfs4blocklayout_exit);