1 /* 2 * Module for the pnfs nfs4 file layout driver. 3 * Defines all I/O and Policy interface operations, plus code 4 * to register itself with the pNFS client. 5 * 6 * Copyright (c) 2002 7 * The Regents of the University of Michigan 8 * All Rights Reserved 9 * 10 * Dean Hildebrand <dhildebz@umich.edu> 11 * 12 * Permission is granted to use, copy, create derivative works, and 13 * redistribute this software and such derivative works for any purpose, 14 * so long as the name of the University of Michigan is not used in 15 * any advertising or publicity pertaining to the use or distribution 16 * of this software without specific, written prior authorization. If 17 * the above copyright notice or any other identification of the 18 * University of Michigan is included in any copy of any portion of 19 * this software, then the disclaimer below must also be included. 20 * 21 * This software is provided as is, without representation or warranty 22 * of any kind either express or implied, including without limitation 23 * the implied warranties of merchantability, fitness for a particular 24 * purpose, or noninfringement. The Regents of the University of 25 * Michigan shall not be liable for any damages, including special, 26 * indirect, incidental, or consequential damages, with respect to any 27 * claim arising out of or in connection with the use of the software, 28 * even if it has been or is hereafter advised of the possibility of 29 * such damages. 30 */ 31 32 #include <linux/nfs_fs.h> 33 #include <linux/nfs_page.h> 34 #include <linux/module.h> 35 #include <linux/backing-dev.h> 36 37 #include <linux/sunrpc/metrics.h> 38 39 #include "../nfs4session.h" 40 #include "../internal.h" 41 #include "../delegation.h" 42 #include "filelayout.h" 43 #include "../nfs4trace.h" 44 45 #define NFSDBG_FACILITY NFSDBG_PNFS_LD 46 47 MODULE_LICENSE("GPL"); 48 MODULE_AUTHOR("Dean Hildebrand <dhildebz@umich.edu>"); 49 MODULE_DESCRIPTION("The NFSv4 file layout driver"); 50 51 #define FILELAYOUT_POLL_RETRY_MAX (15*HZ) 52 53 static loff_t 54 filelayout_get_dense_offset(struct nfs4_filelayout_segment *flseg, 55 loff_t offset) 56 { 57 u32 stripe_width = flseg->stripe_unit * flseg->dsaddr->stripe_count; 58 u64 stripe_no; 59 u32 rem; 60 61 offset -= flseg->pattern_offset; 62 stripe_no = div_u64(offset, stripe_width); 63 div_u64_rem(offset, flseg->stripe_unit, &rem); 64 65 return stripe_no * flseg->stripe_unit + rem; 66 } 67 68 /* This function is used by the layout driver to calculate the 69 * offset of the file on the dserver based on whether the 70 * layout type is STRIPE_DENSE or STRIPE_SPARSE 71 */ 72 static loff_t 73 filelayout_get_dserver_offset(struct pnfs_layout_segment *lseg, loff_t offset) 74 { 75 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg); 76 77 switch (flseg->stripe_type) { 78 case STRIPE_SPARSE: 79 return offset; 80 81 case STRIPE_DENSE: 82 return filelayout_get_dense_offset(flseg, offset); 83 } 84 85 BUG(); 86 } 87 88 static void filelayout_reset_write(struct nfs_pgio_header *hdr) 89 { 90 struct rpc_task *task = &hdr->task; 91 92 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) { 93 dprintk("%s Reset task %5u for i/o through MDS " 94 "(req %s/%llu, %u bytes @ offset %llu)\n", __func__, 95 hdr->task.tk_pid, 96 hdr->inode->i_sb->s_id, 97 (unsigned long long)NFS_FILEID(hdr->inode), 98 hdr->args.count, 99 (unsigned long long)hdr->args.offset); 100 101 task->tk_status = pnfs_write_done_resend_to_mds(hdr); 102 } 103 } 104 105 static void filelayout_reset_read(struct nfs_pgio_header *hdr) 106 { 107 struct rpc_task *task = &hdr->task; 108 109 if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) { 110 dprintk("%s Reset task %5u for i/o through MDS " 111 "(req %s/%llu, %u bytes @ offset %llu)\n", __func__, 112 hdr->task.tk_pid, 113 hdr->inode->i_sb->s_id, 114 (unsigned long long)NFS_FILEID(hdr->inode), 115 hdr->args.count, 116 (unsigned long long)hdr->args.offset); 117 118 task->tk_status = pnfs_read_done_resend_to_mds(hdr); 119 } 120 } 121 122 static int filelayout_async_handle_error(struct rpc_task *task, 123 struct nfs4_state *state, 124 struct nfs_client *clp, 125 struct pnfs_layout_segment *lseg) 126 { 127 struct pnfs_layout_hdr *lo = lseg->pls_layout; 128 struct inode *inode = lo->plh_inode; 129 struct nfs_server *mds_server = NFS_SERVER(inode); 130 struct nfs4_deviceid_node *devid = FILELAYOUT_DEVID_NODE(lseg); 131 struct nfs_client *mds_client = mds_server->nfs_client; 132 struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table; 133 134 if (task->tk_status >= 0) 135 return 0; 136 137 switch (task->tk_status) { 138 /* MDS state errors */ 139 case -NFS4ERR_DELEG_REVOKED: 140 case -NFS4ERR_ADMIN_REVOKED: 141 case -NFS4ERR_BAD_STATEID: 142 case -NFS4ERR_OPENMODE: 143 if (state == NULL) 144 break; 145 if (nfs4_schedule_stateid_recovery(mds_server, state) < 0) 146 goto out_bad_stateid; 147 goto wait_on_recovery; 148 case -NFS4ERR_EXPIRED: 149 if (state != NULL) { 150 if (nfs4_schedule_stateid_recovery(mds_server, state) < 0) 151 goto out_bad_stateid; 152 } 153 nfs4_schedule_lease_recovery(mds_client); 154 goto wait_on_recovery; 155 /* DS session errors */ 156 case -NFS4ERR_BADSESSION: 157 case -NFS4ERR_BADSLOT: 158 case -NFS4ERR_BAD_HIGH_SLOT: 159 case -NFS4ERR_DEADSESSION: 160 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 161 case -NFS4ERR_SEQ_FALSE_RETRY: 162 case -NFS4ERR_SEQ_MISORDERED: 163 dprintk("%s ERROR %d, Reset session. Exchangeid " 164 "flags 0x%x\n", __func__, task->tk_status, 165 clp->cl_exchange_flags); 166 nfs4_schedule_session_recovery(clp->cl_session, task->tk_status); 167 break; 168 case -NFS4ERR_DELAY: 169 case -NFS4ERR_GRACE: 170 rpc_delay(task, FILELAYOUT_POLL_RETRY_MAX); 171 break; 172 case -NFS4ERR_RETRY_UNCACHED_REP: 173 break; 174 /* Invalidate Layout errors */ 175 case -NFS4ERR_PNFS_NO_LAYOUT: 176 case -ESTALE: /* mapped NFS4ERR_STALE */ 177 case -EBADHANDLE: /* mapped NFS4ERR_BADHANDLE */ 178 case -EISDIR: /* mapped NFS4ERR_ISDIR */ 179 case -NFS4ERR_FHEXPIRED: 180 case -NFS4ERR_WRONG_TYPE: 181 dprintk("%s Invalid layout error %d\n", __func__, 182 task->tk_status); 183 /* 184 * Destroy layout so new i/o will get a new layout. 185 * Layout will not be destroyed until all current lseg 186 * references are put. Mark layout as invalid to resend failed 187 * i/o and all i/o waiting on the slot table to the MDS until 188 * layout is destroyed and a new valid layout is obtained. 189 */ 190 pnfs_destroy_layout(NFS_I(inode)); 191 rpc_wake_up(&tbl->slot_tbl_waitq); 192 goto reset; 193 /* RPC connection errors */ 194 case -ECONNREFUSED: 195 case -EHOSTDOWN: 196 case -EHOSTUNREACH: 197 case -ENETUNREACH: 198 case -EIO: 199 case -ETIMEDOUT: 200 case -EPIPE: 201 dprintk("%s DS connection error %d\n", __func__, 202 task->tk_status); 203 nfs4_mark_deviceid_unavailable(devid); 204 pnfs_error_mark_layout_for_return(inode, lseg); 205 rpc_wake_up(&tbl->slot_tbl_waitq); 206 /* fall through */ 207 default: 208 reset: 209 dprintk("%s Retry through MDS. Error %d\n", __func__, 210 task->tk_status); 211 return -NFS4ERR_RESET_TO_MDS; 212 } 213 out: 214 task->tk_status = 0; 215 return -EAGAIN; 216 out_bad_stateid: 217 task->tk_status = -EIO; 218 return 0; 219 wait_on_recovery: 220 rpc_sleep_on(&mds_client->cl_rpcwaitq, task, NULL); 221 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &mds_client->cl_state) == 0) 222 rpc_wake_up_queued_task(&mds_client->cl_rpcwaitq, task); 223 goto out; 224 } 225 226 /* NFS_PROTO call done callback routines */ 227 228 static int filelayout_read_done_cb(struct rpc_task *task, 229 struct nfs_pgio_header *hdr) 230 { 231 int err; 232 233 trace_nfs4_pnfs_read(hdr, task->tk_status); 234 err = filelayout_async_handle_error(task, hdr->args.context->state, 235 hdr->ds_clp, hdr->lseg); 236 237 switch (err) { 238 case -NFS4ERR_RESET_TO_MDS: 239 filelayout_reset_read(hdr); 240 return task->tk_status; 241 case -EAGAIN: 242 rpc_restart_call_prepare(task); 243 return -EAGAIN; 244 } 245 246 return 0; 247 } 248 249 /* 250 * We reference the rpc_cred of the first WRITE that triggers the need for 251 * a LAYOUTCOMMIT, and use it to send the layoutcommit compound. 252 * rfc5661 is not clear about which credential should be used. 253 */ 254 static void 255 filelayout_set_layoutcommit(struct nfs_pgio_header *hdr) 256 { 257 258 if (FILELAYOUT_LSEG(hdr->lseg)->commit_through_mds || 259 hdr->res.verf->committed != NFS_DATA_SYNC) 260 return; 261 262 pnfs_set_layoutcommit(hdr->inode, hdr->lseg, 263 hdr->mds_offset + hdr->res.count); 264 dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino, 265 (unsigned long) NFS_I(hdr->inode)->layout->plh_lwb); 266 } 267 268 bool 269 filelayout_test_devid_unavailable(struct nfs4_deviceid_node *node) 270 { 271 return filelayout_test_devid_invalid(node) || 272 nfs4_test_deviceid_unavailable(node); 273 } 274 275 static bool 276 filelayout_reset_to_mds(struct pnfs_layout_segment *lseg) 277 { 278 struct nfs4_deviceid_node *node = FILELAYOUT_DEVID_NODE(lseg); 279 280 return filelayout_test_devid_unavailable(node); 281 } 282 283 /* 284 * Call ops for the async read/write cases 285 * In the case of dense layouts, the offset needs to be reset to its 286 * original value. 287 */ 288 static void filelayout_read_prepare(struct rpc_task *task, void *data) 289 { 290 struct nfs_pgio_header *hdr = data; 291 292 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) { 293 rpc_exit(task, -EIO); 294 return; 295 } 296 if (filelayout_reset_to_mds(hdr->lseg)) { 297 dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid); 298 filelayout_reset_read(hdr); 299 rpc_exit(task, 0); 300 return; 301 } 302 hdr->pgio_done_cb = filelayout_read_done_cb; 303 304 if (nfs41_setup_sequence(hdr->ds_clp->cl_session, 305 &hdr->args.seq_args, 306 &hdr->res.seq_res, 307 task)) 308 return; 309 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, 310 hdr->args.lock_context, FMODE_READ) == -EIO) 311 rpc_exit(task, -EIO); /* lost lock, terminate I/O */ 312 } 313 314 static void filelayout_read_call_done(struct rpc_task *task, void *data) 315 { 316 struct nfs_pgio_header *hdr = data; 317 318 dprintk("--> %s task->tk_status %d\n", __func__, task->tk_status); 319 320 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) && 321 task->tk_status == 0) { 322 nfs41_sequence_done(task, &hdr->res.seq_res); 323 return; 324 } 325 326 /* Note this may cause RPC to be resent */ 327 hdr->mds_ops->rpc_call_done(task, data); 328 } 329 330 static void filelayout_read_count_stats(struct rpc_task *task, void *data) 331 { 332 struct nfs_pgio_header *hdr = data; 333 334 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics); 335 } 336 337 static int filelayout_write_done_cb(struct rpc_task *task, 338 struct nfs_pgio_header *hdr) 339 { 340 int err; 341 342 trace_nfs4_pnfs_write(hdr, task->tk_status); 343 err = filelayout_async_handle_error(task, hdr->args.context->state, 344 hdr->ds_clp, hdr->lseg); 345 346 switch (err) { 347 case -NFS4ERR_RESET_TO_MDS: 348 filelayout_reset_write(hdr); 349 return task->tk_status; 350 case -EAGAIN: 351 rpc_restart_call_prepare(task); 352 return -EAGAIN; 353 } 354 355 filelayout_set_layoutcommit(hdr); 356 return 0; 357 } 358 359 static int filelayout_commit_done_cb(struct rpc_task *task, 360 struct nfs_commit_data *data) 361 { 362 int err; 363 364 trace_nfs4_pnfs_commit_ds(data, task->tk_status); 365 err = filelayout_async_handle_error(task, NULL, data->ds_clp, 366 data->lseg); 367 368 switch (err) { 369 case -NFS4ERR_RESET_TO_MDS: 370 pnfs_generic_prepare_to_resend_writes(data); 371 return -EAGAIN; 372 case -EAGAIN: 373 rpc_restart_call_prepare(task); 374 return -EAGAIN; 375 } 376 377 if (data->verf.committed == NFS_UNSTABLE) 378 pnfs_set_layoutcommit(data->inode, data->lseg, data->lwb); 379 380 return 0; 381 } 382 383 static void filelayout_write_prepare(struct rpc_task *task, void *data) 384 { 385 struct nfs_pgio_header *hdr = data; 386 387 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) { 388 rpc_exit(task, -EIO); 389 return; 390 } 391 if (filelayout_reset_to_mds(hdr->lseg)) { 392 dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid); 393 filelayout_reset_write(hdr); 394 rpc_exit(task, 0); 395 return; 396 } 397 if (nfs41_setup_sequence(hdr->ds_clp->cl_session, 398 &hdr->args.seq_args, 399 &hdr->res.seq_res, 400 task)) 401 return; 402 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, 403 hdr->args.lock_context, FMODE_WRITE) == -EIO) 404 rpc_exit(task, -EIO); /* lost lock, terminate I/O */ 405 } 406 407 static void filelayout_write_call_done(struct rpc_task *task, void *data) 408 { 409 struct nfs_pgio_header *hdr = data; 410 411 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) && 412 task->tk_status == 0) { 413 nfs41_sequence_done(task, &hdr->res.seq_res); 414 return; 415 } 416 417 /* Note this may cause RPC to be resent */ 418 hdr->mds_ops->rpc_call_done(task, data); 419 } 420 421 static void filelayout_write_count_stats(struct rpc_task *task, void *data) 422 { 423 struct nfs_pgio_header *hdr = data; 424 425 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics); 426 } 427 428 static void filelayout_commit_prepare(struct rpc_task *task, void *data) 429 { 430 struct nfs_commit_data *wdata = data; 431 432 nfs41_setup_sequence(wdata->ds_clp->cl_session, 433 &wdata->args.seq_args, 434 &wdata->res.seq_res, 435 task); 436 } 437 438 static void filelayout_commit_count_stats(struct rpc_task *task, void *data) 439 { 440 struct nfs_commit_data *cdata = data; 441 442 rpc_count_iostats(task, NFS_SERVER(cdata->inode)->client->cl_metrics); 443 } 444 445 static const struct rpc_call_ops filelayout_read_call_ops = { 446 .rpc_call_prepare = filelayout_read_prepare, 447 .rpc_call_done = filelayout_read_call_done, 448 .rpc_count_stats = filelayout_read_count_stats, 449 .rpc_release = pnfs_generic_rw_release, 450 }; 451 452 static const struct rpc_call_ops filelayout_write_call_ops = { 453 .rpc_call_prepare = filelayout_write_prepare, 454 .rpc_call_done = filelayout_write_call_done, 455 .rpc_count_stats = filelayout_write_count_stats, 456 .rpc_release = pnfs_generic_rw_release, 457 }; 458 459 static const struct rpc_call_ops filelayout_commit_call_ops = { 460 .rpc_call_prepare = filelayout_commit_prepare, 461 .rpc_call_done = pnfs_generic_write_commit_done, 462 .rpc_count_stats = filelayout_commit_count_stats, 463 .rpc_release = pnfs_generic_commit_release, 464 }; 465 466 static enum pnfs_try_status 467 filelayout_read_pagelist(struct nfs_pgio_header *hdr) 468 { 469 struct pnfs_layout_segment *lseg = hdr->lseg; 470 struct nfs4_pnfs_ds *ds; 471 struct rpc_clnt *ds_clnt; 472 loff_t offset = hdr->args.offset; 473 u32 j, idx; 474 struct nfs_fh *fh; 475 476 dprintk("--> %s ino %lu pgbase %u req %Zu@%llu\n", 477 __func__, hdr->inode->i_ino, 478 hdr->args.pgbase, (size_t)hdr->args.count, offset); 479 480 /* Retrieve the correct rpc_client for the byte range */ 481 j = nfs4_fl_calc_j_index(lseg, offset); 482 idx = nfs4_fl_calc_ds_index(lseg, j); 483 ds = nfs4_fl_prepare_ds(lseg, idx); 484 if (!ds) 485 return PNFS_NOT_ATTEMPTED; 486 487 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode); 488 if (IS_ERR(ds_clnt)) 489 return PNFS_NOT_ATTEMPTED; 490 491 dprintk("%s USE DS: %s cl_count %d\n", __func__, 492 ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count)); 493 494 /* No multipath support. Use first DS */ 495 atomic_inc(&ds->ds_clp->cl_count); 496 hdr->ds_clp = ds->ds_clp; 497 hdr->ds_commit_idx = idx; 498 fh = nfs4_fl_select_ds_fh(lseg, j); 499 if (fh) 500 hdr->args.fh = fh; 501 502 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset); 503 hdr->mds_offset = offset; 504 505 /* Perform an asynchronous read to ds */ 506 nfs_initiate_pgio(ds_clnt, hdr, hdr->cred, 507 NFS_PROTO(hdr->inode), &filelayout_read_call_ops, 508 0, RPC_TASK_SOFTCONN); 509 return PNFS_ATTEMPTED; 510 } 511 512 /* Perform async writes. */ 513 static enum pnfs_try_status 514 filelayout_write_pagelist(struct nfs_pgio_header *hdr, int sync) 515 { 516 struct pnfs_layout_segment *lseg = hdr->lseg; 517 struct nfs4_pnfs_ds *ds; 518 struct rpc_clnt *ds_clnt; 519 loff_t offset = hdr->args.offset; 520 u32 j, idx; 521 struct nfs_fh *fh; 522 523 /* Retrieve the correct rpc_client for the byte range */ 524 j = nfs4_fl_calc_j_index(lseg, offset); 525 idx = nfs4_fl_calc_ds_index(lseg, j); 526 ds = nfs4_fl_prepare_ds(lseg, idx); 527 if (!ds) 528 return PNFS_NOT_ATTEMPTED; 529 530 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode); 531 if (IS_ERR(ds_clnt)) 532 return PNFS_NOT_ATTEMPTED; 533 534 dprintk("%s ino %lu sync %d req %Zu@%llu DS: %s cl_count %d\n", 535 __func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count, 536 offset, ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count)); 537 538 hdr->pgio_done_cb = filelayout_write_done_cb; 539 atomic_inc(&ds->ds_clp->cl_count); 540 hdr->ds_clp = ds->ds_clp; 541 hdr->ds_commit_idx = idx; 542 fh = nfs4_fl_select_ds_fh(lseg, j); 543 if (fh) 544 hdr->args.fh = fh; 545 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset); 546 547 /* Perform an asynchronous write */ 548 nfs_initiate_pgio(ds_clnt, hdr, hdr->cred, 549 NFS_PROTO(hdr->inode), &filelayout_write_call_ops, 550 sync, RPC_TASK_SOFTCONN); 551 return PNFS_ATTEMPTED; 552 } 553 554 /* 555 * filelayout_check_layout() 556 * 557 * Make sure layout segment parameters are sane WRT the device. 558 * At this point no generic layer initialization of the lseg has occurred, 559 * and nothing has been added to the layout_hdr cache. 560 * 561 */ 562 static int 563 filelayout_check_layout(struct pnfs_layout_hdr *lo, 564 struct nfs4_filelayout_segment *fl, 565 struct nfs4_layoutget_res *lgr, 566 struct nfs4_deviceid *id, 567 gfp_t gfp_flags) 568 { 569 struct nfs4_deviceid_node *d; 570 struct nfs4_file_layout_dsaddr *dsaddr; 571 int status = -EINVAL; 572 573 dprintk("--> %s\n", __func__); 574 575 /* FIXME: remove this check when layout segment support is added */ 576 if (lgr->range.offset != 0 || 577 lgr->range.length != NFS4_MAX_UINT64) { 578 dprintk("%s Only whole file layouts supported. Use MDS i/o\n", 579 __func__); 580 goto out; 581 } 582 583 if (fl->pattern_offset > lgr->range.offset) { 584 dprintk("%s pattern_offset %lld too large\n", 585 __func__, fl->pattern_offset); 586 goto out; 587 } 588 589 if (!fl->stripe_unit) { 590 dprintk("%s Invalid stripe unit (%u)\n", 591 __func__, fl->stripe_unit); 592 goto out; 593 } 594 595 /* find and reference the deviceid */ 596 d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode), id, 597 lo->plh_lc_cred, gfp_flags); 598 if (d == NULL) 599 goto out; 600 601 dsaddr = container_of(d, struct nfs4_file_layout_dsaddr, id_node); 602 /* Found deviceid is unavailable */ 603 if (filelayout_test_devid_unavailable(&dsaddr->id_node)) 604 goto out_put; 605 606 fl->dsaddr = dsaddr; 607 608 if (fl->first_stripe_index >= dsaddr->stripe_count) { 609 dprintk("%s Bad first_stripe_index %u\n", 610 __func__, fl->first_stripe_index); 611 goto out_put; 612 } 613 614 if ((fl->stripe_type == STRIPE_SPARSE && 615 fl->num_fh > 1 && fl->num_fh != dsaddr->ds_num) || 616 (fl->stripe_type == STRIPE_DENSE && 617 fl->num_fh != dsaddr->stripe_count)) { 618 dprintk("%s num_fh %u not valid for given packing\n", 619 __func__, fl->num_fh); 620 goto out_put; 621 } 622 623 status = 0; 624 out: 625 dprintk("--> %s returns %d\n", __func__, status); 626 return status; 627 out_put: 628 nfs4_fl_put_deviceid(dsaddr); 629 goto out; 630 } 631 632 static void filelayout_free_fh_array(struct nfs4_filelayout_segment *fl) 633 { 634 int i; 635 636 for (i = 0; i < fl->num_fh; i++) { 637 if (!fl->fh_array[i]) 638 break; 639 kfree(fl->fh_array[i]); 640 } 641 kfree(fl->fh_array); 642 fl->fh_array = NULL; 643 } 644 645 static void 646 _filelayout_free_lseg(struct nfs4_filelayout_segment *fl) 647 { 648 filelayout_free_fh_array(fl); 649 kfree(fl); 650 } 651 652 static int 653 filelayout_decode_layout(struct pnfs_layout_hdr *flo, 654 struct nfs4_filelayout_segment *fl, 655 struct nfs4_layoutget_res *lgr, 656 struct nfs4_deviceid *id, 657 gfp_t gfp_flags) 658 { 659 struct xdr_stream stream; 660 struct xdr_buf buf; 661 struct page *scratch; 662 __be32 *p; 663 uint32_t nfl_util; 664 int i; 665 666 dprintk("%s: set_layout_map Begin\n", __func__); 667 668 scratch = alloc_page(gfp_flags); 669 if (!scratch) 670 return -ENOMEM; 671 672 xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len); 673 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE); 674 675 /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8), 676 * num_fh (4) */ 677 p = xdr_inline_decode(&stream, NFS4_DEVICEID4_SIZE + 20); 678 if (unlikely(!p)) 679 goto out_err; 680 681 memcpy(id, p, sizeof(*id)); 682 p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE); 683 nfs4_print_deviceid(id); 684 685 nfl_util = be32_to_cpup(p++); 686 if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS) 687 fl->commit_through_mds = 1; 688 if (nfl_util & NFL4_UFLG_DENSE) 689 fl->stripe_type = STRIPE_DENSE; 690 else 691 fl->stripe_type = STRIPE_SPARSE; 692 fl->stripe_unit = nfl_util & ~NFL4_UFLG_MASK; 693 694 fl->first_stripe_index = be32_to_cpup(p++); 695 p = xdr_decode_hyper(p, &fl->pattern_offset); 696 fl->num_fh = be32_to_cpup(p++); 697 698 dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n", 699 __func__, nfl_util, fl->num_fh, fl->first_stripe_index, 700 fl->pattern_offset); 701 702 /* Note that a zero value for num_fh is legal for STRIPE_SPARSE. 703 * Futher checking is done in filelayout_check_layout */ 704 if (fl->num_fh > 705 max(NFS4_PNFS_MAX_STRIPE_CNT, NFS4_PNFS_MAX_MULTI_CNT)) 706 goto out_err; 707 708 if (fl->num_fh > 0) { 709 fl->fh_array = kcalloc(fl->num_fh, sizeof(fl->fh_array[0]), 710 gfp_flags); 711 if (!fl->fh_array) 712 goto out_err; 713 } 714 715 for (i = 0; i < fl->num_fh; i++) { 716 /* Do we want to use a mempool here? */ 717 fl->fh_array[i] = kmalloc(sizeof(struct nfs_fh), gfp_flags); 718 if (!fl->fh_array[i]) 719 goto out_err_free; 720 721 p = xdr_inline_decode(&stream, 4); 722 if (unlikely(!p)) 723 goto out_err_free; 724 fl->fh_array[i]->size = be32_to_cpup(p++); 725 if (sizeof(struct nfs_fh) < fl->fh_array[i]->size) { 726 printk(KERN_ERR "NFS: Too big fh %d received %d\n", 727 i, fl->fh_array[i]->size); 728 goto out_err_free; 729 } 730 731 p = xdr_inline_decode(&stream, fl->fh_array[i]->size); 732 if (unlikely(!p)) 733 goto out_err_free; 734 memcpy(fl->fh_array[i]->data, p, fl->fh_array[i]->size); 735 dprintk("DEBUG: %s: fh len %d\n", __func__, 736 fl->fh_array[i]->size); 737 } 738 739 __free_page(scratch); 740 return 0; 741 742 out_err_free: 743 filelayout_free_fh_array(fl); 744 out_err: 745 __free_page(scratch); 746 return -EIO; 747 } 748 749 static void 750 filelayout_free_lseg(struct pnfs_layout_segment *lseg) 751 { 752 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 753 754 dprintk("--> %s\n", __func__); 755 nfs4_fl_put_deviceid(fl->dsaddr); 756 /* This assumes a single RW lseg */ 757 if (lseg->pls_range.iomode == IOMODE_RW) { 758 struct nfs4_filelayout *flo; 759 760 flo = FILELAYOUT_FROM_HDR(lseg->pls_layout); 761 flo->commit_info.nbuckets = 0; 762 kfree(flo->commit_info.buckets); 763 flo->commit_info.buckets = NULL; 764 } 765 _filelayout_free_lseg(fl); 766 } 767 768 static int 769 filelayout_alloc_commit_info(struct pnfs_layout_segment *lseg, 770 struct nfs_commit_info *cinfo, 771 gfp_t gfp_flags) 772 { 773 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 774 struct pnfs_commit_bucket *buckets; 775 int size, i; 776 777 if (fl->commit_through_mds) 778 return 0; 779 780 size = (fl->stripe_type == STRIPE_SPARSE) ? 781 fl->dsaddr->ds_num : fl->dsaddr->stripe_count; 782 783 if (cinfo->ds->nbuckets >= size) { 784 /* This assumes there is only one IOMODE_RW lseg. What 785 * we really want to do is have a layout_hdr level 786 * dictionary of <multipath_list4, fh> keys, each 787 * associated with a struct list_head, populated by calls 788 * to filelayout_write_pagelist(). 789 * */ 790 return 0; 791 } 792 793 buckets = kcalloc(size, sizeof(struct pnfs_commit_bucket), 794 gfp_flags); 795 if (!buckets) 796 return -ENOMEM; 797 for (i = 0; i < size; i++) { 798 INIT_LIST_HEAD(&buckets[i].written); 799 INIT_LIST_HEAD(&buckets[i].committing); 800 /* mark direct verifier as unset */ 801 buckets[i].direct_verf.committed = NFS_INVALID_STABLE_HOW; 802 } 803 804 spin_lock(cinfo->lock); 805 if (cinfo->ds->nbuckets >= size) 806 goto out; 807 for (i = 0; i < cinfo->ds->nbuckets; i++) { 808 list_splice(&cinfo->ds->buckets[i].written, 809 &buckets[i].written); 810 list_splice(&cinfo->ds->buckets[i].committing, 811 &buckets[i].committing); 812 buckets[i].direct_verf.committed = 813 cinfo->ds->buckets[i].direct_verf.committed; 814 buckets[i].wlseg = cinfo->ds->buckets[i].wlseg; 815 buckets[i].clseg = cinfo->ds->buckets[i].clseg; 816 } 817 swap(cinfo->ds->buckets, buckets); 818 cinfo->ds->nbuckets = size; 819 out: 820 spin_unlock(cinfo->lock); 821 kfree(buckets); 822 return 0; 823 } 824 825 static struct pnfs_layout_segment * 826 filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid, 827 struct nfs4_layoutget_res *lgr, 828 gfp_t gfp_flags) 829 { 830 struct nfs4_filelayout_segment *fl; 831 int rc; 832 struct nfs4_deviceid id; 833 834 dprintk("--> %s\n", __func__); 835 fl = kzalloc(sizeof(*fl), gfp_flags); 836 if (!fl) 837 return NULL; 838 839 rc = filelayout_decode_layout(layoutid, fl, lgr, &id, gfp_flags); 840 if (rc != 0 || filelayout_check_layout(layoutid, fl, lgr, &id, gfp_flags)) { 841 _filelayout_free_lseg(fl); 842 return NULL; 843 } 844 return &fl->generic_hdr; 845 } 846 847 /* 848 * filelayout_pg_test(). Called by nfs_can_coalesce_requests() 849 * 850 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number 851 * of bytes (maximum @req->wb_bytes) that can be coalesced. 852 */ 853 static size_t 854 filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev, 855 struct nfs_page *req) 856 { 857 unsigned int size; 858 u64 p_stripe, r_stripe; 859 u32 stripe_offset; 860 u64 segment_offset = pgio->pg_lseg->pls_range.offset; 861 u32 stripe_unit = FILELAYOUT_LSEG(pgio->pg_lseg)->stripe_unit; 862 863 /* calls nfs_generic_pg_test */ 864 size = pnfs_generic_pg_test(pgio, prev, req); 865 if (!size) 866 return 0; 867 868 /* see if req and prev are in the same stripe */ 869 if (prev) { 870 p_stripe = (u64)req_offset(prev) - segment_offset; 871 r_stripe = (u64)req_offset(req) - segment_offset; 872 do_div(p_stripe, stripe_unit); 873 do_div(r_stripe, stripe_unit); 874 875 if (p_stripe != r_stripe) 876 return 0; 877 } 878 879 /* calculate remaining bytes in the current stripe */ 880 div_u64_rem((u64)req_offset(req) - segment_offset, 881 stripe_unit, 882 &stripe_offset); 883 WARN_ON_ONCE(stripe_offset > stripe_unit); 884 if (stripe_offset >= stripe_unit) 885 return 0; 886 return min(stripe_unit - (unsigned int)stripe_offset, size); 887 } 888 889 static void 890 filelayout_pg_init_read(struct nfs_pageio_descriptor *pgio, 891 struct nfs_page *req) 892 { 893 if (!pgio->pg_lseg) 894 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 895 req->wb_context, 896 0, 897 NFS4_MAX_UINT64, 898 IOMODE_READ, 899 GFP_KERNEL); 900 /* If no lseg, fall back to read through mds */ 901 if (pgio->pg_lseg == NULL) 902 nfs_pageio_reset_read_mds(pgio); 903 } 904 905 static void 906 filelayout_pg_init_write(struct nfs_pageio_descriptor *pgio, 907 struct nfs_page *req) 908 { 909 struct nfs_commit_info cinfo; 910 int status; 911 912 if (!pgio->pg_lseg) 913 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 914 req->wb_context, 915 0, 916 NFS4_MAX_UINT64, 917 IOMODE_RW, 918 GFP_NOFS); 919 /* If no lseg, fall back to write through mds */ 920 if (pgio->pg_lseg == NULL) 921 goto out_mds; 922 nfs_init_cinfo(&cinfo, pgio->pg_inode, pgio->pg_dreq); 923 status = filelayout_alloc_commit_info(pgio->pg_lseg, &cinfo, GFP_NOFS); 924 if (status < 0) { 925 pnfs_put_lseg(pgio->pg_lseg); 926 pgio->pg_lseg = NULL; 927 goto out_mds; 928 } 929 return; 930 out_mds: 931 nfs_pageio_reset_write_mds(pgio); 932 } 933 934 static const struct nfs_pageio_ops filelayout_pg_read_ops = { 935 .pg_init = filelayout_pg_init_read, 936 .pg_test = filelayout_pg_test, 937 .pg_doio = pnfs_generic_pg_readpages, 938 .pg_cleanup = pnfs_generic_pg_cleanup, 939 }; 940 941 static const struct nfs_pageio_ops filelayout_pg_write_ops = { 942 .pg_init = filelayout_pg_init_write, 943 .pg_test = filelayout_pg_test, 944 .pg_doio = pnfs_generic_pg_writepages, 945 .pg_cleanup = pnfs_generic_pg_cleanup, 946 }; 947 948 static u32 select_bucket_index(struct nfs4_filelayout_segment *fl, u32 j) 949 { 950 if (fl->stripe_type == STRIPE_SPARSE) 951 return nfs4_fl_calc_ds_index(&fl->generic_hdr, j); 952 else 953 return j; 954 } 955 956 static void 957 filelayout_mark_request_commit(struct nfs_page *req, 958 struct pnfs_layout_segment *lseg, 959 struct nfs_commit_info *cinfo, 960 u32 ds_commit_idx) 961 962 { 963 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 964 u32 i, j; 965 966 if (fl->commit_through_mds) { 967 nfs_request_add_commit_list(req, &cinfo->mds->list, cinfo); 968 } else { 969 /* Note that we are calling nfs4_fl_calc_j_index on each page 970 * that ends up being committed to a data server. An attractive 971 * alternative is to add a field to nfs_write_data and nfs_page 972 * to store the value calculated in filelayout_write_pagelist 973 * and just use that here. 974 */ 975 j = nfs4_fl_calc_j_index(lseg, req_offset(req)); 976 i = select_bucket_index(fl, j); 977 pnfs_layout_mark_request_commit(req, lseg, cinfo, i); 978 } 979 } 980 981 static u32 calc_ds_index_from_commit(struct pnfs_layout_segment *lseg, u32 i) 982 { 983 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg); 984 985 if (flseg->stripe_type == STRIPE_SPARSE) 986 return i; 987 else 988 return nfs4_fl_calc_ds_index(lseg, i); 989 } 990 991 static struct nfs_fh * 992 select_ds_fh_from_commit(struct pnfs_layout_segment *lseg, u32 i) 993 { 994 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg); 995 996 if (flseg->stripe_type == STRIPE_SPARSE) { 997 if (flseg->num_fh == 1) 998 i = 0; 999 else if (flseg->num_fh == 0) 1000 /* Use the MDS OPEN fh set in nfs_read_rpcsetup */ 1001 return NULL; 1002 } 1003 return flseg->fh_array[i]; 1004 } 1005 1006 static int filelayout_initiate_commit(struct nfs_commit_data *data, int how) 1007 { 1008 struct pnfs_layout_segment *lseg = data->lseg; 1009 struct nfs4_pnfs_ds *ds; 1010 struct rpc_clnt *ds_clnt; 1011 u32 idx; 1012 struct nfs_fh *fh; 1013 1014 idx = calc_ds_index_from_commit(lseg, data->ds_commit_index); 1015 ds = nfs4_fl_prepare_ds(lseg, idx); 1016 if (!ds) 1017 goto out_err; 1018 1019 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, data->inode); 1020 if (IS_ERR(ds_clnt)) 1021 goto out_err; 1022 1023 dprintk("%s ino %lu, how %d cl_count %d\n", __func__, 1024 data->inode->i_ino, how, atomic_read(&ds->ds_clp->cl_count)); 1025 data->commit_done_cb = filelayout_commit_done_cb; 1026 atomic_inc(&ds->ds_clp->cl_count); 1027 data->ds_clp = ds->ds_clp; 1028 fh = select_ds_fh_from_commit(lseg, data->ds_commit_index); 1029 if (fh) 1030 data->args.fh = fh; 1031 return nfs_initiate_commit(ds_clnt, data, NFS_PROTO(data->inode), 1032 &filelayout_commit_call_ops, how, 1033 RPC_TASK_SOFTCONN); 1034 out_err: 1035 pnfs_generic_prepare_to_resend_writes(data); 1036 pnfs_generic_commit_release(data); 1037 return -EAGAIN; 1038 } 1039 1040 /* filelayout_search_commit_reqs - Search lists in @cinfo for the head reqest 1041 * for @page 1042 * @cinfo - commit info for current inode 1043 * @page - page to search for matching head request 1044 * 1045 * Returns a the head request if one is found, otherwise returns NULL. 1046 */ 1047 static struct nfs_page * 1048 filelayout_search_commit_reqs(struct nfs_commit_info *cinfo, struct page *page) 1049 { 1050 struct nfs_page *freq, *t; 1051 struct pnfs_commit_bucket *b; 1052 int i; 1053 1054 /* Linearly search the commit lists for each bucket until a matching 1055 * request is found */ 1056 for (i = 0, b = cinfo->ds->buckets; i < cinfo->ds->nbuckets; i++, b++) { 1057 list_for_each_entry_safe(freq, t, &b->written, wb_list) { 1058 if (freq->wb_page == page) 1059 return freq->wb_head; 1060 } 1061 list_for_each_entry_safe(freq, t, &b->committing, wb_list) { 1062 if (freq->wb_page == page) 1063 return freq->wb_head; 1064 } 1065 } 1066 1067 return NULL; 1068 } 1069 1070 static int 1071 filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages, 1072 int how, struct nfs_commit_info *cinfo) 1073 { 1074 return pnfs_generic_commit_pagelist(inode, mds_pages, how, cinfo, 1075 filelayout_initiate_commit); 1076 } 1077 1078 static struct nfs4_deviceid_node * 1079 filelayout_alloc_deviceid_node(struct nfs_server *server, 1080 struct pnfs_device *pdev, gfp_t gfp_flags) 1081 { 1082 struct nfs4_file_layout_dsaddr *dsaddr; 1083 1084 dsaddr = nfs4_fl_alloc_deviceid_node(server, pdev, gfp_flags); 1085 if (!dsaddr) 1086 return NULL; 1087 return &dsaddr->id_node; 1088 } 1089 1090 static void 1091 filelayout_free_deviceid_node(struct nfs4_deviceid_node *d) 1092 { 1093 nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node)); 1094 } 1095 1096 static struct pnfs_layout_hdr * 1097 filelayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags) 1098 { 1099 struct nfs4_filelayout *flo; 1100 1101 flo = kzalloc(sizeof(*flo), gfp_flags); 1102 return flo != NULL ? &flo->generic_hdr : NULL; 1103 } 1104 1105 static void 1106 filelayout_free_layout_hdr(struct pnfs_layout_hdr *lo) 1107 { 1108 kfree(FILELAYOUT_FROM_HDR(lo)); 1109 } 1110 1111 static struct pnfs_ds_commit_info * 1112 filelayout_get_ds_info(struct inode *inode) 1113 { 1114 struct pnfs_layout_hdr *layout = NFS_I(inode)->layout; 1115 1116 if (layout == NULL) 1117 return NULL; 1118 else 1119 return &FILELAYOUT_FROM_HDR(layout)->commit_info; 1120 } 1121 1122 static struct pnfs_layoutdriver_type filelayout_type = { 1123 .id = LAYOUT_NFSV4_1_FILES, 1124 .name = "LAYOUT_NFSV4_1_FILES", 1125 .owner = THIS_MODULE, 1126 .alloc_layout_hdr = filelayout_alloc_layout_hdr, 1127 .free_layout_hdr = filelayout_free_layout_hdr, 1128 .alloc_lseg = filelayout_alloc_lseg, 1129 .free_lseg = filelayout_free_lseg, 1130 .pg_read_ops = &filelayout_pg_read_ops, 1131 .pg_write_ops = &filelayout_pg_write_ops, 1132 .get_ds_info = &filelayout_get_ds_info, 1133 .mark_request_commit = filelayout_mark_request_commit, 1134 .clear_request_commit = pnfs_generic_clear_request_commit, 1135 .scan_commit_lists = pnfs_generic_scan_commit_lists, 1136 .recover_commit_reqs = pnfs_generic_recover_commit_reqs, 1137 .search_commit_reqs = filelayout_search_commit_reqs, 1138 .commit_pagelist = filelayout_commit_pagelist, 1139 .read_pagelist = filelayout_read_pagelist, 1140 .write_pagelist = filelayout_write_pagelist, 1141 .alloc_deviceid_node = filelayout_alloc_deviceid_node, 1142 .free_deviceid_node = filelayout_free_deviceid_node, 1143 .sync = pnfs_nfs_generic_sync, 1144 }; 1145 1146 static int __init nfs4filelayout_init(void) 1147 { 1148 printk(KERN_INFO "%s: NFSv4 File Layout Driver Registering...\n", 1149 __func__); 1150 return pnfs_register_layoutdriver(&filelayout_type); 1151 } 1152 1153 static void __exit nfs4filelayout_exit(void) 1154 { 1155 printk(KERN_INFO "%s: NFSv4 File Layout Driver Unregistering...\n", 1156 __func__); 1157 pnfs_unregister_layoutdriver(&filelayout_type); 1158 } 1159 1160 MODULE_ALIAS("nfs-layouttype4-1"); 1161 1162 module_init(nfs4filelayout_init); 1163 module_exit(nfs4filelayout_exit); 1164