blocklayout.c 26.8 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
		bio->bi_iter.bi_sector = disk_sector;
133
		bio_set_dev(bio, 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 143 144
static bool offset_in_map(u64 offset, struct pnfs_block_dev_map *map)
{
	return offset >= map->start && offset < map->start + map->len;
}

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

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

192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
static void bl_mark_devices_unavailable(struct nfs_pgio_header *header, bool rw)
{
	struct pnfs_block_layout *bl = BLK_LSEG2EXT(header->lseg);
	size_t bytes_left = header->args.count;
	sector_t isect, extent_length = 0;
	struct pnfs_block_extent be;

	isect = header->args.offset >> SECTOR_SHIFT;
	bytes_left += header->args.offset - (isect << SECTOR_SHIFT);

	while (bytes_left > 0) {
		if (!ext_tree_lookup(bl, isect, &be, rw))
				return;
		extent_length = be.be_length - (isect - be.be_f_offset);
		nfs4_mark_deviceid_unavailable(be.be_device);
		isect += extent_length;
		if (bytes_left > extent_length << SECTOR_SHIFT)
			bytes_left -= extent_length << SECTOR_SHIFT;
		else
			bytes_left = 0;
	}
}

215
static void bl_end_io_read(struct bio *bio)
F
Fred Isaman 已提交
216 217 218
{
	struct parallel_io *par = bio->bi_private;

219
	if (bio->bi_status) {
220
		struct nfs_pgio_header *header = par->data;
221 222 223 224

		if (!header->pnfs_error)
			header->pnfs_error = -EIO;
		pnfs_set_lo_fail(header->lseg);
225
		bl_mark_devices_unavailable(header, false);
F
Fred Isaman 已提交
226
	}
227

F
Fred Isaman 已提交
228 229 230 231 232 233 234
	bio_put(bio);
	put_parallel(par);
}

static void bl_read_cleanup(struct work_struct *work)
{
	struct rpc_task *task;
235
	struct nfs_pgio_header *hdr;
F
Fred Isaman 已提交
236 237
	dprintk("%s enter\n", __func__);
	task = container_of(work, struct rpc_task, u.tk_work);
238 239
	hdr = container_of(task, struct nfs_pgio_header, task);
	pnfs_ld_read_done(hdr);
F
Fred Isaman 已提交
240 241 242
}

static void
243
bl_end_par_io_read(void *data)
F
Fred Isaman 已提交
244
{
245
	struct nfs_pgio_header *hdr = data;
F
Fred Isaman 已提交
246

247 248 249
	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 已提交
250 251
}

252
static enum pnfs_try_status
253
bl_read_pagelist(struct nfs_pgio_header *header)
254
{
255
	struct pnfs_block_layout *bl = BLK_LSEG2EXT(header->lseg);
256
	struct pnfs_block_dev_map map = { .start = NFS4_MAX_UINT64 };
F
Fred Isaman 已提交
257
	struct bio *bio = NULL;
258
	struct pnfs_block_extent be;
F
Fred Isaman 已提交
259 260
	sector_t isect, extent_length = 0;
	struct parallel_io *par;
261 262
	loff_t f_offset = header->args.offset;
	size_t bytes_left = header->args.count;
263
	unsigned int pg_offset = header->args.pgbase, pg_len;
264
	struct page **pages = header->args.pages;
265
	int pg_index = header->args.pgbase >> PAGE_SHIFT;
P
Peng Tao 已提交
266
	const bool is_dio = (header->dreq != NULL);
267
	struct blk_plug plug;
268
	int i;
F
Fred Isaman 已提交
269

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

274
	par = alloc_parallel(header);
F
Fred Isaman 已提交
275
	if (!par)
276
		return PNFS_NOT_ATTEMPTED;
F
Fred Isaman 已提交
277 278
	par->pnfs_callback = bl_end_par_io_read;

279 280
	blk_start_plug(&plug);

F
Fred Isaman 已提交
281 282
	isect = (sector_t) (f_offset >> SECTOR_SHIFT);
	/* Code assumes extents are page-aligned */
283
	for (i = pg_index; i < header->page_array.npages; i++) {
284
		if (extent_length <= 0) {
F
Fred Isaman 已提交
285
			/* We've used up the previous extent */
286
			bio = bl_submit_bio(bio);
287

F
Fred Isaman 已提交
288
			/* Get the next one */
289
			if (!ext_tree_lookup(bl, isect, &be, false)) {
290
				header->pnfs_error = -EIO;
F
Fred Isaman 已提交
291 292
				goto out;
			}
293
			extent_length = be.be_length - (isect - be.be_f_offset);
F
Fred Isaman 已提交
294
		}
P
Peng Tao 已提交
295 296

		if (is_dio) {
297 298
			if (pg_offset + bytes_left > PAGE_SIZE)
				pg_len = PAGE_SIZE - pg_offset;
P
Peng Tao 已提交
299 300 301
			else
				pg_len = bytes_left;
		} else {
302
			BUG_ON(pg_offset != 0);
303
			pg_len = PAGE_SIZE;
P
Peng Tao 已提交
304 305
		}

306
		if (is_hole(&be)) {
307
			bio = bl_submit_bio(bio);
F
Fred Isaman 已提交
308 309
			/* Fill hole w/ zeroes w/o accessing device */
			dprintk("%s Zeroing page for hole\n", __func__);
P
Peng Tao 已提交
310
			zero_user_segment(pages[i], pg_offset, pg_len);
311 312 313

			/* invalidate map */
			map.start = NFS4_MAX_UINT64;
F
Fred Isaman 已提交
314
		} else {
315
			bio = do_add_page_to_bio(bio,
316
						 header->page_array.npages - i,
F
Fred Isaman 已提交
317
						 READ,
318
						 isect, pages[i], &map, &be,
P
Peng Tao 已提交
319
						 bl_end_io_read, par,
320
						 pg_offset, &pg_len);
F
Fred Isaman 已提交
321
			if (IS_ERR(bio)) {
322
				header->pnfs_error = PTR_ERR(bio);
P
Peng Tao 已提交
323
				bio = NULL;
F
Fred Isaman 已提交
324 325 326
				goto out;
			}
		}
P
Peng Tao 已提交
327
		isect += (pg_len >> SECTOR_SHIFT);
328
		extent_length -= (pg_len >> SECTOR_SHIFT);
329 330
		f_offset += pg_len;
		bytes_left -= pg_len;
331
		pg_offset = 0;
F
Fred Isaman 已提交
332
	}
333
	if ((isect << SECTOR_SHIFT) >= header->inode->i_size) {
334 335
		header->res.eof = 1;
		header->res.count = header->inode->i_size - header->args.offset;
F
Fred Isaman 已提交
336
	} else {
337
		header->res.count = (isect << SECTOR_SHIFT) - header->args.offset;
F
Fred Isaman 已提交
338 339
	}
out:
340
	bl_submit_bio(bio);
341
	blk_finish_plug(&plug);
F
Fred Isaman 已提交
342 343
	put_parallel(par);
	return PNFS_ATTEMPTED;
344 345
}

346
static void bl_end_io_write(struct bio *bio)
F
Fred Isaman 已提交
347 348
{
	struct parallel_io *par = bio->bi_private;
349
	struct nfs_pgio_header *header = par->data;
F
Fred Isaman 已提交
350

351
	if (bio->bi_status) {
352 353 354
		if (!header->pnfs_error)
			header->pnfs_error = -EIO;
		pnfs_set_lo_fail(header->lseg);
355
		bl_mark_devices_unavailable(header, true);
F
Fred Isaman 已提交
356 357 358 359 360 361 362 363 364 365
	}
	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)
{
366 367 368 369
	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 已提交
370
	dprintk("%s enter\n", __func__);
371

372
	if (likely(!hdr->pnfs_error)) {
373
		struct pnfs_block_layout *bl = BLK_LSEG2EXT(hdr->lseg);
374
		u64 start = hdr->args.offset & (loff_t)PAGE_MASK;
375
		u64 end = (hdr->args.offset + hdr->args.count +
376
			PAGE_SIZE - 1) & (loff_t)PAGE_MASK;
377
		u64 lwb = hdr->args.offset + hdr->args.count;
378 379

		ext_tree_mark_written(bl, start >> SECTOR_SHIFT,
380
					(end - start) >> SECTOR_SHIFT, lwb);
381
	}
382

383
	pnfs_ld_write_done(hdr);
F
Fred Isaman 已提交
384 385 386
}

/* Called when last of bios associated with a bl_write_pagelist call finishes */
387
static void bl_end_par_io_write(void *data)
F
Fred Isaman 已提交
388
{
389
	struct nfs_pgio_header *hdr = data;
F
Fred Isaman 已提交
390

391
	hdr->task.tk_status = hdr->pnfs_error;
392
	hdr->verf.committed = NFS_FILE_SYNC;
393 394
	INIT_WORK(&hdr->task.u.tk_work, bl_write_cleanup);
	schedule_work(&hdr->task.u.tk_work);
F
Fred Isaman 已提交
395 396
}

397
static enum pnfs_try_status
398
bl_write_pagelist(struct nfs_pgio_header *header, int sync)
399
{
400
	struct pnfs_block_layout *bl = BLK_LSEG2EXT(header->lseg);
401
	struct pnfs_block_dev_map map = { .start = NFS4_MAX_UINT64 };
F
Fred Isaman 已提交
402
	struct bio *bio = NULL;
403
	struct pnfs_block_extent be;
404
	sector_t isect, extent_length = 0;
P
Peng Tao 已提交
405
	struct parallel_io *par = NULL;
406 407 408
	loff_t offset = header->args.offset;
	size_t count = header->args.count;
	struct page **pages = header->args.pages;
409
	int pg_index = header->args.pgbase >> PAGE_SHIFT;
410
	unsigned int pg_len;
411
	struct blk_plug plug;
412
	int i;
F
Fred Isaman 已提交
413

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

416
	/* At this point, header->page_aray is a (sequential) list of nfs_pages.
417 418
	 * We want to write each, and if there is an error set pnfs_error
	 * to have it redone using nfs.
F
Fred Isaman 已提交
419
	 */
420
	par = alloc_parallel(header);
F
Fred Isaman 已提交
421
	if (!par)
422
		return PNFS_NOT_ATTEMPTED;
F
Fred Isaman 已提交
423 424
	par->pnfs_callback = bl_end_par_io_write;

425
	blk_start_plug(&plug);
426

427
	/* we always write out the whole page */
428
	offset = offset & (loff_t)PAGE_MASK;
429
	isect = offset >> SECTOR_SHIFT;
430

431
	for (i = pg_index; i < header->page_array.npages; i++) {
432
		if (extent_length <= 0) {
F
Fred Isaman 已提交
433
			/* We've used up the previous extent */
434
			bio = bl_submit_bio(bio);
F
Fred Isaman 已提交
435
			/* Get the next one */
436
			if (!ext_tree_lookup(bl, isect, &be, true)) {
437
				header->pnfs_error = -EINVAL;
F
Fred Isaman 已提交
438 439
				goto out;
			}
440

441
			extent_length = be.be_length - (isect - be.be_f_offset);
442
		}
443

444
		pg_len = PAGE_SIZE;
445
		bio = do_add_page_to_bio(bio, header->page_array.npages - i,
446
					 WRITE, isect, pages[i], &map, &be,
447
					 bl_end_io_write, par,
448
					 0, &pg_len);
449
		if (IS_ERR(bio)) {
450
			header->pnfs_error = PTR_ERR(bio);
P
Peng Tao 已提交
451
			bio = NULL;
452
			goto out;
F
Fred Isaman 已提交
453
		}
454 455 456 457 458

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

461
	header->res.count = header->args.count;
F
Fred Isaman 已提交
462
out:
463
	bl_submit_bio(bio);
464
	blk_finish_plug(&plug);
F
Fred Isaman 已提交
465 466
	put_parallel(par);
	return PNFS_ATTEMPTED;
467 468 469 470 471
}

static void bl_free_layout_hdr(struct pnfs_layout_hdr *lo)
{
	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
472
	int err;
473 474

	dprintk("%s enter\n", __func__);
475 476 477 478

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

479 480 481
	kfree(bl);
}

482 483
static struct pnfs_layout_hdr *__bl_alloc_layout_hdr(struct inode *inode,
		gfp_t gfp_flags, bool is_scsi_layout)
484 485 486 487 488 489 490
{
	struct pnfs_block_layout *bl;

	dprintk("%s enter\n", __func__);
	bl = kzalloc(sizeof(*bl), gfp_flags);
	if (!bl)
		return NULL;
491 492 493

	bl->bl_ext_rw = RB_ROOT;
	bl->bl_ext_ro = RB_ROOT;
494
	spin_lock_init(&bl->bl_ext_lock);
495

496
	bl->bl_scsi_layout = is_scsi_layout;
497 498 499
	return &bl->bl_layout;
}

500 501 502 503 504 505 506 507 508 509 510 511
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 已提交
512
static void bl_free_lseg(struct pnfs_layout_segment *lseg)
513
{
F
Fred Isaman 已提交
514 515
	dprintk("%s enter\n", __func__);
	kfree(lseg);
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 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
/* 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;
}

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
static struct nfs4_deviceid_node *
bl_find_get_deviceid(struct nfs_server *server,
		const struct nfs4_deviceid *id, struct rpc_cred *cred,
		gfp_t gfp_mask)
{
	struct nfs4_deviceid_node *node;
	unsigned long start, end;

retry:
	node = nfs4_find_get_deviceid(server, id, cred, gfp_mask);
	if (!node)
		return ERR_PTR(-ENODEV);

	if (test_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags) == 0)
		return node;

	end = jiffies;
	start = end - PNFS_DEVICE_RETRY_TIMEOUT;
	if (!time_in_range(node->timestamp_unavailable, start, end)) {
		nfs4_delete_deviceid(node->ld, node->nfs_client, id);
		goto retry;
	}
	return ERR_PTR(-ENODEV);
}

610
static int
611 612 613
bl_alloc_extent(struct xdr_stream *xdr, struct pnfs_layout_hdr *lo,
		struct layout_verification *lv, struct list_head *extents,
		gfp_t gfp_mask)
614
{
615 616 617
	struct pnfs_block_extent *be;
	struct nfs4_deviceid id;
	int error;
618
	__be32 *p;
619 620 621 622 623 624 625 626 627 628 629 630

	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);

631
	be->be_device = bl_find_get_deviceid(NFS_SERVER(lo->plh_inode), &id,
632
						lo->plh_lc_cred, gfp_mask);
633 634
	if (IS_ERR(be->be_device)) {
		error = PTR_ERR(be->be_device);
635
		goto out_free_be;
636
	}
637 638 639 640 641

	/*
	 * The next three values are read in as bytes, but stored in the
	 * extent structure in 512-byte granularity.
	 */
642
	error = -EIO;
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
	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)
{
671 672 673 674 675 676
	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,
	};
677 678 679 680 681 682 683 684
	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;
685 686 687 688
	LIST_HEAD(extents);

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

689 690 691 692 693 694
	lseg = kzalloc(sizeof(*lseg), gfp_mask);
	if (!lseg)
		return ERR_PTR(-ENOMEM);

	status = -ENOMEM;
	scratch = alloc_page(gfp_mask);
695
	if (!scratch)
696
		goto out;
697

698 699 700
	xdr_init_decode_pages(&xdr, &buf,
			lgr->layoutp->pages, lgr->layoutp->len);
	xdr_set_scratch_buffer(&xdr, page_address(scratch), PAGE_SIZE);
701

702 703
	status = -EIO;
	p = xdr_inline_decode(&xdr, 4);
704
	if (unlikely(!p))
705
		goto out_free_scratch;
706 707

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

710 711 712
	/*
	 * Decode individual extents, putting them in temporary staging area
	 * until whole layout is decoded to make error recovery easier.
713 714
	 */
	for (i = 0; i < count; i++) {
715 716 717
		status = bl_alloc_extent(&xdr, lo, &lv, &extents, gfp_mask);
		if (status)
			goto process_extents;
718
	}
719

720 721 722
	if (lgr->range.offset + lgr->range.length !=
			lv.start << SECTOR_SHIFT) {
		dprintk("%s Final length mismatch\n", __func__);
723 724
		status = -EIO;
		goto process_extents;
725
	}
726

727 728
	if (lv.start < lv.cowread) {
		dprintk("%s Final uncovered COW extent\n", __func__);
729
		status = -EIO;
730 731
	}

732
process_extents:
733
	while (!list_empty(&extents)) {
734 735 736
		struct pnfs_block_extent *be =
			list_first_entry(&extents, struct pnfs_block_extent,
					 be_list);
737 738
		list_del(&be->be_list);

739 740
		if (!status)
			status = ext_tree_insert(bl, be);
F
Fred Isaman 已提交
741

742 743 744 745 746 747 748 749 750 751
		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);
752 753 754 755
	switch (status) {
	case -ENODEV:
		/* Our extent block devices are unavailable */
		set_bit(NFS_LSEG_UNAVAILABLE, &lseg->pls_flags);
756
		/* Fall through */
757 758 759
	case 0:
		return lseg;
	default:
F
Fred Isaman 已提交
760 761 762
		kfree(lseg);
		return ERR_PTR(status);
	}
763 764
}

765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
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);
	}

790
	ext_tree_remove(bl, range->iomode & IOMODE_RW, offset, end);
791 792
}

793 794
static int
bl_prepare_layoutcommit(struct nfs4_layoutcommit_args *arg)
795
{
796
	return ext_tree_prepare_commit(arg);
797 798 799 800 801
}

static void
bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
{
802
	ext_tree_mark_committed(&lcdata->args, lcdata->res.status);
803 804 805 806 807 808
}

static int
bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)
{
	dprintk("%s enter\n", __func__);
809 810 811 812 813

	if (server->pnfs_blksize == 0) {
		dprintk("%s Server did not return blksize\n", __func__);
		return -EINVAL;
	}
814 815 816 817 818 819
	if (server->pnfs_blksize > PAGE_SIZE) {
		printk(KERN_ERR "%s: pNFS blksize %d not supported.\n",
			__func__, server->pnfs_blksize);
		return -EINVAL;
	}

820
	return 0;
821 822
}

P
Peng Tao 已提交
823
static bool
824
is_aligned_req(struct nfs_pageio_descriptor *pgio,
825
		struct nfs_page *req, unsigned int alignment, bool is_write)
P
Peng Tao 已提交
826
{
827 828 829 830 831 832 833 834 835 836 837 838 839
	/*
	 * 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;

840 841
	if (is_write &&
	    (req_offset(req) + req->wb_bytes == i_size_read(pgio->pg_inode))) {
842 843 844 845 846 847 848 849 850 851 852
		/*
		 * 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 已提交
853 854 855 856 857
}

static void
bl_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
858
	if (!is_aligned_req(pgio, req, SECTOR_SIZE, false)) {
P
Peng Tao 已提交
859
		nfs_pageio_reset_read_mds(pgio);
860 861 862 863
		return;
	}

	pnfs_generic_pg_init_read(pgio, req);
864 865 866 867 868 869 870

	if (pgio->pg_lseg &&
		test_bit(NFS_LSEG_UNAVAILABLE, &pgio->pg_lseg->pls_flags)) {
		pnfs_error_mark_layout_for_return(pgio->pg_inode, pgio->pg_lseg);
		pnfs_set_lo_fail(pgio->pg_lseg);
		nfs_pageio_reset_read_mds(pgio);
	}
P
Peng Tao 已提交
871 872
}

873 874 875 876 877
/*
 * 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 已提交
878 879 880
bl_pg_test_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
		struct nfs_page *req)
{
881
	if (!is_aligned_req(pgio, req, SECTOR_SIZE, false))
882
		return 0;
P
Peng Tao 已提交
883 884 885
	return pnfs_generic_pg_test(pgio, prev, req);
}

886 887 888 889 890 891 892 893 894 895
/*
 * 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 */
896
	end = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
897
	if (end != inode->i_mapping->nrpages) {
898
		rcu_read_lock();
899
		end = page_cache_next_hole(mapping, idx + 1, ULONG_MAX);
900 901 902 903
		rcu_read_unlock();
	}

	if (!end)
904
		return i_size_read(inode) - (idx << PAGE_SHIFT);
905
	else
906
		return (end - idx) << PAGE_SHIFT;
907 908
}

909
static void
P
Peng Tao 已提交
910 911
bl_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
912 913
	u64 wb_size;

914
	if (!is_aligned_req(pgio, req, PAGE_SIZE, true)) {
P
Peng Tao 已提交
915
		nfs_pageio_reset_write_mds(pgio);
916
		return;
917
	}
918 919 920 921 922 923 924 925

	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);
926 927 928 929 930 931 932 933

	if (pgio->pg_lseg &&
		test_bit(NFS_LSEG_UNAVAILABLE, &pgio->pg_lseg->pls_flags)) {

		pnfs_error_mark_layout_for_return(pgio->pg_inode, pgio->pg_lseg);
		pnfs_set_lo_fail(pgio->pg_lseg);
		nfs_pageio_reset_write_mds(pgio);
	}
P
Peng Tao 已提交
934 935
}

936 937 938 939 940
/*
 * 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 已提交
941 942 943
bl_pg_test_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
		 struct nfs_page *req)
{
944
	if (!is_aligned_req(pgio, req, PAGE_SIZE, true))
945
		return 0;
P
Peng Tao 已提交
946 947 948
	return pnfs_generic_pg_test(pgio, prev, req);
}

B
Benny Halevy 已提交
949
static const struct nfs_pageio_ops bl_pg_read_ops = {
P
Peng Tao 已提交
950 951
	.pg_init = bl_pg_init_read,
	.pg_test = bl_pg_test_read,
B
Benny Halevy 已提交
952
	.pg_doio = pnfs_generic_pg_readpages,
953
	.pg_cleanup = pnfs_generic_pg_cleanup,
B
Benny Halevy 已提交
954 955 956
};

static const struct nfs_pageio_ops bl_pg_write_ops = {
P
Peng Tao 已提交
957 958
	.pg_init = bl_pg_init_write,
	.pg_test = bl_pg_test_write,
B
Benny Halevy 已提交
959
	.pg_doio = pnfs_generic_pg_writepages,
960
	.pg_cleanup = pnfs_generic_pg_cleanup,
B
Benny Halevy 已提交
961 962
};

963 964 965
static struct pnfs_layoutdriver_type blocklayout_type = {
	.id				= LAYOUT_BLOCK_VOLUME,
	.name				= "LAYOUT_BLOCK_VOLUME",
966
	.owner				= THIS_MODULE,
967
	.flags				= PNFS_LAYOUTRET_ON_SETATTR |
968
					  PNFS_LAYOUTRET_ON_ERROR |
969
					  PNFS_READ_WHOLE_PAGE,
970 971 972 973 974 975
	.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,
976
	.return_range			= bl_return_range,
977
	.prepare_layoutcommit		= bl_prepare_layoutcommit,
978 979
	.cleanup_layoutcommit		= bl_cleanup_layoutcommit,
	.set_layoutdriver		= bl_set_layoutdriver,
980 981
	.alloc_deviceid_node		= bl_alloc_deviceid_node,
	.free_deviceid_node		= bl_free_deviceid_node,
B
Benny Halevy 已提交
982 983
	.pg_read_ops			= &bl_pg_read_ops,
	.pg_write_ops			= &bl_pg_write_ops,
984
	.sync				= pnfs_generic_sync,
985 986
};

987 988 989 990 991
static struct pnfs_layoutdriver_type scsilayout_type = {
	.id				= LAYOUT_SCSI,
	.name				= "LAYOUT_SCSI",
	.owner				= THIS_MODULE,
	.flags				= PNFS_LAYOUTRET_ON_SETATTR |
992
					  PNFS_LAYOUTRET_ON_ERROR |
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
					  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,
};


1012 1013 1014 1015 1016 1017
static int __init nfs4blocklayout_init(void)
{
	int ret;

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

1018
	ret = bl_init_pipefs();
J
Jim Rees 已提交
1019 1020
	if (ret)
		goto out;
1021 1022

	ret = pnfs_register_layoutdriver(&blocklayout_type);
1023
	if (ret)
1024 1025 1026 1027 1028
		goto out_cleanup_pipe;

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

1031
out_unregister_block:
J
Jim Rees 已提交
1032
	pnfs_unregister_layoutdriver(&blocklayout_type);
1033 1034
out_cleanup_pipe:
	bl_cleanup_pipefs();
1035
out:
1036 1037 1038 1039 1040 1041 1042 1043
	return ret;
}

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

1044
	pnfs_unregister_layoutdriver(&scsilayout_type);
1045
	pnfs_unregister_layoutdriver(&blocklayout_type);
1046
	bl_cleanup_pipefs();
1047 1048 1049
}

MODULE_ALIAS("nfs-layouttype4-3");
1050
MODULE_ALIAS("nfs-layouttype4-5");
1051 1052 1053

module_init(nfs4blocklayout_init);
module_exit(nfs4blocklayout_exit);