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 348 349

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

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

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

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

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

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

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

394
	blk_start_plug(&plug);
395

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

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

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

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

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

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

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

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

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

448 449 450
	kfree(bl);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

756
	return 0;
757 758
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

MODULE_ALIAS("nfs-layouttype4-3");

module_init(nfs4blocklayout_init);
module_exit(nfs4blocklayout_exit);