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 pnfs_set_lo_fail(lseg); 206 rpc_wake_up(&tbl->slot_tbl_waitq); 207 /* fall through */ 208 default: 209 reset: 210 dprintk("%s Retry through MDS. Error %d\n", __func__, 211 task->tk_status); 212 return -NFS4ERR_RESET_TO_MDS; 213 } 214 out: 215 task->tk_status = 0; 216 return -EAGAIN; 217 out_bad_stateid: 218 task->tk_status = -EIO; 219 return 0; 220 wait_on_recovery: 221 rpc_sleep_on(&mds_client->cl_rpcwaitq, task, NULL); 222 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &mds_client->cl_state) == 0) 223 rpc_wake_up_queued_task(&mds_client->cl_rpcwaitq, task); 224 goto out; 225 } 226 227 /* NFS_PROTO call done callback routines */ 228 229 static int filelayout_read_done_cb(struct rpc_task *task, 230 struct nfs_pgio_header *hdr) 231 { 232 int err; 233 234 trace_nfs4_pnfs_read(hdr, task->tk_status); 235 err = filelayout_async_handle_error(task, hdr->args.context->state, 236 hdr->ds_clp, hdr->lseg); 237 238 switch (err) { 239 case -NFS4ERR_RESET_TO_MDS: 240 filelayout_reset_read(hdr); 241 return task->tk_status; 242 case -EAGAIN: 243 rpc_restart_call_prepare(task); 244 return -EAGAIN; 245 } 246 247 return 0; 248 } 249 250 /* 251 * We reference the rpc_cred of the first WRITE that triggers the need for 252 * a LAYOUTCOMMIT, and use it to send the layoutcommit compound. 253 * rfc5661 is not clear about which credential should be used. 254 */ 255 static void 256 filelayout_set_layoutcommit(struct nfs_pgio_header *hdr) 257 { 258 259 if (FILELAYOUT_LSEG(hdr->lseg)->commit_through_mds || 260 hdr->res.verf->committed != NFS_DATA_SYNC) 261 return; 262 263 pnfs_set_layoutcommit(hdr->inode, hdr->lseg, 264 hdr->mds_offset + hdr->res.count); 265 dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino, 266 (unsigned long) NFS_I(hdr->inode)->layout->plh_lwb); 267 } 268 269 bool 270 filelayout_test_devid_unavailable(struct nfs4_deviceid_node *node) 271 { 272 return filelayout_test_devid_invalid(node) || 273 nfs4_test_deviceid_unavailable(node); 274 } 275 276 static bool 277 filelayout_reset_to_mds(struct pnfs_layout_segment *lseg) 278 { 279 struct nfs4_deviceid_node *node = FILELAYOUT_DEVID_NODE(lseg); 280 281 return filelayout_test_devid_unavailable(node); 282 } 283 284 /* 285 * Call ops for the async read/write cases 286 * In the case of dense layouts, the offset needs to be reset to its 287 * original value. 288 */ 289 static void filelayout_read_prepare(struct rpc_task *task, void *data) 290 { 291 struct nfs_pgio_header *hdr = data; 292 293 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) { 294 rpc_exit(task, -EIO); 295 return; 296 } 297 if (filelayout_reset_to_mds(hdr->lseg)) { 298 dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid); 299 filelayout_reset_read(hdr); 300 rpc_exit(task, 0); 301 return; 302 } 303 hdr->pgio_done_cb = filelayout_read_done_cb; 304 305 if (nfs41_setup_sequence(hdr->ds_clp->cl_session, 306 &hdr->args.seq_args, 307 &hdr->res.seq_res, 308 task)) 309 return; 310 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, 311 hdr->args.lock_context, FMODE_READ) == -EIO) 312 rpc_exit(task, -EIO); /* lost lock, terminate I/O */ 313 } 314 315 static void filelayout_read_call_done(struct rpc_task *task, void *data) 316 { 317 struct nfs_pgio_header *hdr = data; 318 319 dprintk("--> %s task->tk_status %d\n", __func__, task->tk_status); 320 321 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) && 322 task->tk_status == 0) { 323 nfs41_sequence_done(task, &hdr->res.seq_res); 324 return; 325 } 326 327 /* Note this may cause RPC to be resent */ 328 hdr->mds_ops->rpc_call_done(task, data); 329 } 330 331 static void filelayout_read_count_stats(struct rpc_task *task, void *data) 332 { 333 struct nfs_pgio_header *hdr = data; 334 335 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics); 336 } 337 338 static int filelayout_write_done_cb(struct rpc_task *task, 339 struct nfs_pgio_header *hdr) 340 { 341 int err; 342 343 trace_nfs4_pnfs_write(hdr, task->tk_status); 344 err = filelayout_async_handle_error(task, hdr->args.context->state, 345 hdr->ds_clp, hdr->lseg); 346 347 switch (err) { 348 case -NFS4ERR_RESET_TO_MDS: 349 filelayout_reset_write(hdr); 350 return task->tk_status; 351 case -EAGAIN: 352 rpc_restart_call_prepare(task); 353 return -EAGAIN; 354 } 355 356 filelayout_set_layoutcommit(hdr); 357 return 0; 358 } 359 360 static int filelayout_commit_done_cb(struct rpc_task *task, 361 struct nfs_commit_data *data) 362 { 363 int err; 364 365 trace_nfs4_pnfs_commit_ds(data, task->tk_status); 366 err = filelayout_async_handle_error(task, NULL, data->ds_clp, 367 data->lseg); 368 369 switch (err) { 370 case -NFS4ERR_RESET_TO_MDS: 371 pnfs_generic_prepare_to_resend_writes(data); 372 return -EAGAIN; 373 case -EAGAIN: 374 rpc_restart_call_prepare(task); 375 return -EAGAIN; 376 } 377 378 if (data->verf.committed == NFS_UNSTABLE) 379 pnfs_set_layoutcommit(data->inode, data->lseg, data->lwb); 380 381 return 0; 382 } 383 384 static void filelayout_write_prepare(struct rpc_task *task, void *data) 385 { 386 struct nfs_pgio_header *hdr = data; 387 388 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) { 389 rpc_exit(task, -EIO); 390 return; 391 } 392 if (filelayout_reset_to_mds(hdr->lseg)) { 393 dprintk("%s task %u reset io to MDS\n", __func__, task->tk_pid); 394 filelayout_reset_write(hdr); 395 rpc_exit(task, 0); 396 return; 397 } 398 if (nfs41_setup_sequence(hdr->ds_clp->cl_session, 399 &hdr->args.seq_args, 400 &hdr->res.seq_res, 401 task)) 402 return; 403 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, 404 hdr->args.lock_context, FMODE_WRITE) == -EIO) 405 rpc_exit(task, -EIO); /* lost lock, terminate I/O */ 406 } 407 408 static void filelayout_write_call_done(struct rpc_task *task, void *data) 409 { 410 struct nfs_pgio_header *hdr = data; 411 412 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) && 413 task->tk_status == 0) { 414 nfs41_sequence_done(task, &hdr->res.seq_res); 415 return; 416 } 417 418 /* Note this may cause RPC to be resent */ 419 hdr->mds_ops->rpc_call_done(task, data); 420 } 421 422 static void filelayout_write_count_stats(struct rpc_task *task, void *data) 423 { 424 struct nfs_pgio_header *hdr = data; 425 426 rpc_count_iostats(task, NFS_SERVER(hdr->inode)->client->cl_metrics); 427 } 428 429 static void filelayout_commit_prepare(struct rpc_task *task, void *data) 430 { 431 struct nfs_commit_data *wdata = data; 432 433 nfs41_setup_sequence(wdata->ds_clp->cl_session, 434 &wdata->args.seq_args, 435 &wdata->res.seq_res, 436 task); 437 } 438 439 static void filelayout_commit_count_stats(struct rpc_task *task, void *data) 440 { 441 struct nfs_commit_data *cdata = data; 442 443 rpc_count_iostats(task, NFS_SERVER(cdata->inode)->client->cl_metrics); 444 } 445 446 static const struct rpc_call_ops filelayout_read_call_ops = { 447 .rpc_call_prepare = filelayout_read_prepare, 448 .rpc_call_done = filelayout_read_call_done, 449 .rpc_count_stats = filelayout_read_count_stats, 450 .rpc_release = pnfs_generic_rw_release, 451 }; 452 453 static const struct rpc_call_ops filelayout_write_call_ops = { 454 .rpc_call_prepare = filelayout_write_prepare, 455 .rpc_call_done = filelayout_write_call_done, 456 .rpc_count_stats = filelayout_write_count_stats, 457 .rpc_release = pnfs_generic_rw_release, 458 }; 459 460 static const struct rpc_call_ops filelayout_commit_call_ops = { 461 .rpc_call_prepare = filelayout_commit_prepare, 462 .rpc_call_done = pnfs_generic_write_commit_done, 463 .rpc_count_stats = filelayout_commit_count_stats, 464 .rpc_release = pnfs_generic_commit_release, 465 }; 466 467 static enum pnfs_try_status 468 filelayout_read_pagelist(struct nfs_pgio_header *hdr) 469 { 470 struct pnfs_layout_segment *lseg = hdr->lseg; 471 struct nfs4_pnfs_ds *ds; 472 struct rpc_clnt *ds_clnt; 473 loff_t offset = hdr->args.offset; 474 u32 j, idx; 475 struct nfs_fh *fh; 476 477 dprintk("--> %s ino %lu pgbase %u req %Zu@%llu\n", 478 __func__, hdr->inode->i_ino, 479 hdr->args.pgbase, (size_t)hdr->args.count, offset); 480 481 /* Retrieve the correct rpc_client for the byte range */ 482 j = nfs4_fl_calc_j_index(lseg, offset); 483 idx = nfs4_fl_calc_ds_index(lseg, j); 484 ds = nfs4_fl_prepare_ds(lseg, idx); 485 if (!ds) 486 return PNFS_NOT_ATTEMPTED; 487 488 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode); 489 if (IS_ERR(ds_clnt)) 490 return PNFS_NOT_ATTEMPTED; 491 492 dprintk("%s USE DS: %s cl_count %d\n", __func__, 493 ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count)); 494 495 /* No multipath support. Use first DS */ 496 atomic_inc(&ds->ds_clp->cl_count); 497 hdr->ds_clp = ds->ds_clp; 498 hdr->ds_commit_idx = idx; 499 fh = nfs4_fl_select_ds_fh(lseg, j); 500 if (fh) 501 hdr->args.fh = fh; 502 503 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset); 504 hdr->mds_offset = offset; 505 506 /* Perform an asynchronous read to ds */ 507 nfs_initiate_pgio(ds_clnt, hdr, hdr->cred, 508 NFS_PROTO(hdr->inode), &filelayout_read_call_ops, 509 0, RPC_TASK_SOFTCONN); 510 return PNFS_ATTEMPTED; 511 } 512 513 /* Perform async writes. */ 514 static enum pnfs_try_status 515 filelayout_write_pagelist(struct nfs_pgio_header *hdr, int sync) 516 { 517 struct pnfs_layout_segment *lseg = hdr->lseg; 518 struct nfs4_pnfs_ds *ds; 519 struct rpc_clnt *ds_clnt; 520 loff_t offset = hdr->args.offset; 521 u32 j, idx; 522 struct nfs_fh *fh; 523 524 /* Retrieve the correct rpc_client for the byte range */ 525 j = nfs4_fl_calc_j_index(lseg, offset); 526 idx = nfs4_fl_calc_ds_index(lseg, j); 527 ds = nfs4_fl_prepare_ds(lseg, idx); 528 if (!ds) 529 return PNFS_NOT_ATTEMPTED; 530 531 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, hdr->inode); 532 if (IS_ERR(ds_clnt)) 533 return PNFS_NOT_ATTEMPTED; 534 535 dprintk("%s ino %lu sync %d req %Zu@%llu DS: %s cl_count %d\n", 536 __func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count, 537 offset, ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count)); 538 539 hdr->pgio_done_cb = filelayout_write_done_cb; 540 atomic_inc(&ds->ds_clp->cl_count); 541 hdr->ds_clp = ds->ds_clp; 542 hdr->ds_commit_idx = idx; 543 fh = nfs4_fl_select_ds_fh(lseg, j); 544 if (fh) 545 hdr->args.fh = fh; 546 hdr->args.offset = filelayout_get_dserver_offset(lseg, offset); 547 548 /* Perform an asynchronous write */ 549 nfs_initiate_pgio(ds_clnt, hdr, hdr->cred, 550 NFS_PROTO(hdr->inode), &filelayout_write_call_ops, 551 sync, RPC_TASK_SOFTCONN); 552 return PNFS_ATTEMPTED; 553 } 554 555 /* 556 * filelayout_check_layout() 557 * 558 * Make sure layout segment parameters are sane WRT the device. 559 * At this point no generic layer initialization of the lseg has occurred, 560 * and nothing has been added to the layout_hdr cache. 561 * 562 */ 563 static int 564 filelayout_check_layout(struct pnfs_layout_hdr *lo, 565 struct nfs4_filelayout_segment *fl, 566 struct nfs4_layoutget_res *lgr, 567 struct nfs4_deviceid *id, 568 gfp_t gfp_flags) 569 { 570 struct nfs4_deviceid_node *d; 571 struct nfs4_file_layout_dsaddr *dsaddr; 572 int status = -EINVAL; 573 574 dprintk("--> %s\n", __func__); 575 576 /* FIXME: remove this check when layout segment support is added */ 577 if (lgr->range.offset != 0 || 578 lgr->range.length != NFS4_MAX_UINT64) { 579 dprintk("%s Only whole file layouts supported. Use MDS i/o\n", 580 __func__); 581 goto out; 582 } 583 584 if (fl->pattern_offset > lgr->range.offset) { 585 dprintk("%s pattern_offset %lld too large\n", 586 __func__, fl->pattern_offset); 587 goto out; 588 } 589 590 if (!fl->stripe_unit) { 591 dprintk("%s Invalid stripe unit (%u)\n", 592 __func__, fl->stripe_unit); 593 goto out; 594 } 595 596 /* find and reference the deviceid */ 597 d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode), id, 598 lo->plh_lc_cred, gfp_flags); 599 if (d == NULL) 600 goto out; 601 602 dsaddr = container_of(d, struct nfs4_file_layout_dsaddr, id_node); 603 /* Found deviceid is unavailable */ 604 if (filelayout_test_devid_unavailable(&dsaddr->id_node)) 605 goto out_put; 606 607 fl->dsaddr = dsaddr; 608 609 if (fl->first_stripe_index >= dsaddr->stripe_count) { 610 dprintk("%s Bad first_stripe_index %u\n", 611 __func__, fl->first_stripe_index); 612 goto out_put; 613 } 614 615 if ((fl->stripe_type == STRIPE_SPARSE && 616 fl->num_fh > 1 && fl->num_fh != dsaddr->ds_num) || 617 (fl->stripe_type == STRIPE_DENSE && 618 fl->num_fh != dsaddr->stripe_count)) { 619 dprintk("%s num_fh %u not valid for given packing\n", 620 __func__, fl->num_fh); 621 goto out_put; 622 } 623 624 status = 0; 625 out: 626 dprintk("--> %s returns %d\n", __func__, status); 627 return status; 628 out_put: 629 nfs4_fl_put_deviceid(dsaddr); 630 goto out; 631 } 632 633 static void _filelayout_free_lseg(struct nfs4_filelayout_segment *fl) 634 { 635 int i; 636 637 if (fl->fh_array) { 638 for (i = 0; i < fl->num_fh; i++) { 639 if (!fl->fh_array[i]) 640 break; 641 kfree(fl->fh_array[i]); 642 } 643 kfree(fl->fh_array); 644 } 645 kfree(fl); 646 } 647 648 static int 649 filelayout_decode_layout(struct pnfs_layout_hdr *flo, 650 struct nfs4_filelayout_segment *fl, 651 struct nfs4_layoutget_res *lgr, 652 struct nfs4_deviceid *id, 653 gfp_t gfp_flags) 654 { 655 struct xdr_stream stream; 656 struct xdr_buf buf; 657 struct page *scratch; 658 __be32 *p; 659 uint32_t nfl_util; 660 int i; 661 662 dprintk("%s: set_layout_map Begin\n", __func__); 663 664 scratch = alloc_page(gfp_flags); 665 if (!scratch) 666 return -ENOMEM; 667 668 xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len); 669 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE); 670 671 /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8), 672 * num_fh (4) */ 673 p = xdr_inline_decode(&stream, NFS4_DEVICEID4_SIZE + 20); 674 if (unlikely(!p)) 675 goto out_err; 676 677 memcpy(id, p, sizeof(*id)); 678 p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE); 679 nfs4_print_deviceid(id); 680 681 nfl_util = be32_to_cpup(p++); 682 if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS) 683 fl->commit_through_mds = 1; 684 if (nfl_util & NFL4_UFLG_DENSE) 685 fl->stripe_type = STRIPE_DENSE; 686 else 687 fl->stripe_type = STRIPE_SPARSE; 688 fl->stripe_unit = nfl_util & ~NFL4_UFLG_MASK; 689 690 fl->first_stripe_index = be32_to_cpup(p++); 691 p = xdr_decode_hyper(p, &fl->pattern_offset); 692 fl->num_fh = be32_to_cpup(p++); 693 694 dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n", 695 __func__, nfl_util, fl->num_fh, fl->first_stripe_index, 696 fl->pattern_offset); 697 698 /* Note that a zero value for num_fh is legal for STRIPE_SPARSE. 699 * Futher checking is done in filelayout_check_layout */ 700 if (fl->num_fh > 701 max(NFS4_PNFS_MAX_STRIPE_CNT, NFS4_PNFS_MAX_MULTI_CNT)) 702 goto out_err; 703 704 if (fl->num_fh > 0) { 705 fl->fh_array = kcalloc(fl->num_fh, sizeof(fl->fh_array[0]), 706 gfp_flags); 707 if (!fl->fh_array) 708 goto out_err; 709 } 710 711 for (i = 0; i < fl->num_fh; i++) { 712 /* Do we want to use a mempool here? */ 713 fl->fh_array[i] = kmalloc(sizeof(struct nfs_fh), gfp_flags); 714 if (!fl->fh_array[i]) 715 goto out_err; 716 717 p = xdr_inline_decode(&stream, 4); 718 if (unlikely(!p)) 719 goto out_err; 720 fl->fh_array[i]->size = be32_to_cpup(p++); 721 if (sizeof(struct nfs_fh) < fl->fh_array[i]->size) { 722 printk(KERN_ERR "NFS: Too big fh %d received %d\n", 723 i, fl->fh_array[i]->size); 724 goto out_err; 725 } 726 727 p = xdr_inline_decode(&stream, fl->fh_array[i]->size); 728 if (unlikely(!p)) 729 goto out_err; 730 memcpy(fl->fh_array[i]->data, p, fl->fh_array[i]->size); 731 dprintk("DEBUG: %s: fh len %d\n", __func__, 732 fl->fh_array[i]->size); 733 } 734 735 __free_page(scratch); 736 return 0; 737 738 out_err: 739 __free_page(scratch); 740 return -EIO; 741 } 742 743 static void 744 filelayout_free_lseg(struct pnfs_layout_segment *lseg) 745 { 746 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 747 748 dprintk("--> %s\n", __func__); 749 nfs4_fl_put_deviceid(fl->dsaddr); 750 /* This assumes a single RW lseg */ 751 if (lseg->pls_range.iomode == IOMODE_RW) { 752 struct nfs4_filelayout *flo; 753 754 flo = FILELAYOUT_FROM_HDR(lseg->pls_layout); 755 flo->commit_info.nbuckets = 0; 756 kfree(flo->commit_info.buckets); 757 flo->commit_info.buckets = NULL; 758 } 759 _filelayout_free_lseg(fl); 760 } 761 762 static int 763 filelayout_alloc_commit_info(struct pnfs_layout_segment *lseg, 764 struct nfs_commit_info *cinfo, 765 gfp_t gfp_flags) 766 { 767 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 768 struct pnfs_commit_bucket *buckets; 769 int size, i; 770 771 if (fl->commit_through_mds) 772 return 0; 773 774 size = (fl->stripe_type == STRIPE_SPARSE) ? 775 fl->dsaddr->ds_num : fl->dsaddr->stripe_count; 776 777 if (cinfo->ds->nbuckets >= size) { 778 /* This assumes there is only one IOMODE_RW lseg. What 779 * we really want to do is have a layout_hdr level 780 * dictionary of <multipath_list4, fh> keys, each 781 * associated with a struct list_head, populated by calls 782 * to filelayout_write_pagelist(). 783 * */ 784 return 0; 785 } 786 787 buckets = kcalloc(size, sizeof(struct pnfs_commit_bucket), 788 gfp_flags); 789 if (!buckets) 790 return -ENOMEM; 791 for (i = 0; i < size; i++) { 792 INIT_LIST_HEAD(&buckets[i].written); 793 INIT_LIST_HEAD(&buckets[i].committing); 794 /* mark direct verifier as unset */ 795 buckets[i].direct_verf.committed = NFS_INVALID_STABLE_HOW; 796 } 797 798 spin_lock(&cinfo->inode->i_lock); 799 if (cinfo->ds->nbuckets >= size) 800 goto out; 801 for (i = 0; i < cinfo->ds->nbuckets; i++) { 802 list_splice(&cinfo->ds->buckets[i].written, 803 &buckets[i].written); 804 list_splice(&cinfo->ds->buckets[i].committing, 805 &buckets[i].committing); 806 buckets[i].direct_verf.committed = 807 cinfo->ds->buckets[i].direct_verf.committed; 808 buckets[i].wlseg = cinfo->ds->buckets[i].wlseg; 809 buckets[i].clseg = cinfo->ds->buckets[i].clseg; 810 } 811 swap(cinfo->ds->buckets, buckets); 812 cinfo->ds->nbuckets = size; 813 out: 814 spin_unlock(&cinfo->inode->i_lock); 815 kfree(buckets); 816 return 0; 817 } 818 819 static struct pnfs_layout_segment * 820 filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid, 821 struct nfs4_layoutget_res *lgr, 822 gfp_t gfp_flags) 823 { 824 struct nfs4_filelayout_segment *fl; 825 int rc; 826 struct nfs4_deviceid id; 827 828 dprintk("--> %s\n", __func__); 829 fl = kzalloc(sizeof(*fl), gfp_flags); 830 if (!fl) 831 return NULL; 832 833 rc = filelayout_decode_layout(layoutid, fl, lgr, &id, gfp_flags); 834 if (rc != 0 || filelayout_check_layout(layoutid, fl, lgr, &id, gfp_flags)) { 835 _filelayout_free_lseg(fl); 836 return NULL; 837 } 838 return &fl->generic_hdr; 839 } 840 841 /* 842 * filelayout_pg_test(). Called by nfs_can_coalesce_requests() 843 * 844 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number 845 * of bytes (maximum @req->wb_bytes) that can be coalesced. 846 */ 847 static size_t 848 filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev, 849 struct nfs_page *req) 850 { 851 unsigned int size; 852 u64 p_stripe, r_stripe; 853 u32 stripe_offset; 854 u64 segment_offset = pgio->pg_lseg->pls_range.offset; 855 u32 stripe_unit = FILELAYOUT_LSEG(pgio->pg_lseg)->stripe_unit; 856 857 /* calls nfs_generic_pg_test */ 858 size = pnfs_generic_pg_test(pgio, prev, req); 859 if (!size) 860 return 0; 861 862 /* see if req and prev are in the same stripe */ 863 if (prev) { 864 p_stripe = (u64)req_offset(prev) - segment_offset; 865 r_stripe = (u64)req_offset(req) - segment_offset; 866 do_div(p_stripe, stripe_unit); 867 do_div(r_stripe, stripe_unit); 868 869 if (p_stripe != r_stripe) 870 return 0; 871 } 872 873 /* calculate remaining bytes in the current stripe */ 874 div_u64_rem((u64)req_offset(req) - segment_offset, 875 stripe_unit, 876 &stripe_offset); 877 WARN_ON_ONCE(stripe_offset > stripe_unit); 878 if (stripe_offset >= stripe_unit) 879 return 0; 880 return min(stripe_unit - (unsigned int)stripe_offset, size); 881 } 882 883 static void 884 filelayout_pg_init_read(struct nfs_pageio_descriptor *pgio, 885 struct nfs_page *req) 886 { 887 if (!pgio->pg_lseg) { 888 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 889 req->wb_context, 890 0, 891 NFS4_MAX_UINT64, 892 IOMODE_READ, 893 false, 894 GFP_KERNEL); 895 if (IS_ERR(pgio->pg_lseg)) { 896 pgio->pg_error = PTR_ERR(pgio->pg_lseg); 897 pgio->pg_lseg = NULL; 898 return; 899 } 900 } 901 /* If no lseg, fall back to read through mds */ 902 if (pgio->pg_lseg == NULL) 903 nfs_pageio_reset_read_mds(pgio); 904 } 905 906 static void 907 filelayout_pg_init_write(struct nfs_pageio_descriptor *pgio, 908 struct nfs_page *req) 909 { 910 struct nfs_commit_info cinfo; 911 int status; 912 913 if (!pgio->pg_lseg) { 914 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 915 req->wb_context, 916 0, 917 NFS4_MAX_UINT64, 918 IOMODE_RW, 919 false, 920 GFP_NOFS); 921 if (IS_ERR(pgio->pg_lseg)) { 922 pgio->pg_error = PTR_ERR(pgio->pg_lseg); 923 pgio->pg_lseg = NULL; 924 return; 925 } 926 } 927 928 /* If no lseg, fall back to write through mds */ 929 if (pgio->pg_lseg == NULL) 930 goto out_mds; 931 nfs_init_cinfo(&cinfo, pgio->pg_inode, pgio->pg_dreq); 932 status = filelayout_alloc_commit_info(pgio->pg_lseg, &cinfo, GFP_NOFS); 933 if (status < 0) { 934 pnfs_put_lseg(pgio->pg_lseg); 935 pgio->pg_lseg = NULL; 936 goto out_mds; 937 } 938 return; 939 out_mds: 940 nfs_pageio_reset_write_mds(pgio); 941 } 942 943 static const struct nfs_pageio_ops filelayout_pg_read_ops = { 944 .pg_init = filelayout_pg_init_read, 945 .pg_test = filelayout_pg_test, 946 .pg_doio = pnfs_generic_pg_readpages, 947 .pg_cleanup = pnfs_generic_pg_cleanup, 948 }; 949 950 static const struct nfs_pageio_ops filelayout_pg_write_ops = { 951 .pg_init = filelayout_pg_init_write, 952 .pg_test = filelayout_pg_test, 953 .pg_doio = pnfs_generic_pg_writepages, 954 .pg_cleanup = pnfs_generic_pg_cleanup, 955 }; 956 957 static u32 select_bucket_index(struct nfs4_filelayout_segment *fl, u32 j) 958 { 959 if (fl->stripe_type == STRIPE_SPARSE) 960 return nfs4_fl_calc_ds_index(&fl->generic_hdr, j); 961 else 962 return j; 963 } 964 965 static void 966 filelayout_mark_request_commit(struct nfs_page *req, 967 struct pnfs_layout_segment *lseg, 968 struct nfs_commit_info *cinfo, 969 u32 ds_commit_idx) 970 971 { 972 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 973 u32 i, j; 974 975 if (fl->commit_through_mds) { 976 nfs_request_add_commit_list(req, cinfo); 977 } else { 978 /* Note that we are calling nfs4_fl_calc_j_index on each page 979 * that ends up being committed to a data server. An attractive 980 * alternative is to add a field to nfs_write_data and nfs_page 981 * to store the value calculated in filelayout_write_pagelist 982 * and just use that here. 983 */ 984 j = nfs4_fl_calc_j_index(lseg, req_offset(req)); 985 i = select_bucket_index(fl, j); 986 pnfs_layout_mark_request_commit(req, lseg, cinfo, i); 987 } 988 } 989 990 static u32 calc_ds_index_from_commit(struct pnfs_layout_segment *lseg, u32 i) 991 { 992 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg); 993 994 if (flseg->stripe_type == STRIPE_SPARSE) 995 return i; 996 else 997 return nfs4_fl_calc_ds_index(lseg, i); 998 } 999 1000 static struct nfs_fh * 1001 select_ds_fh_from_commit(struct pnfs_layout_segment *lseg, u32 i) 1002 { 1003 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg); 1004 1005 if (flseg->stripe_type == STRIPE_SPARSE) { 1006 if (flseg->num_fh == 1) 1007 i = 0; 1008 else if (flseg->num_fh == 0) 1009 /* Use the MDS OPEN fh set in nfs_read_rpcsetup */ 1010 return NULL; 1011 } 1012 return flseg->fh_array[i]; 1013 } 1014 1015 static int filelayout_initiate_commit(struct nfs_commit_data *data, int how) 1016 { 1017 struct pnfs_layout_segment *lseg = data->lseg; 1018 struct nfs4_pnfs_ds *ds; 1019 struct rpc_clnt *ds_clnt; 1020 u32 idx; 1021 struct nfs_fh *fh; 1022 1023 idx = calc_ds_index_from_commit(lseg, data->ds_commit_index); 1024 ds = nfs4_fl_prepare_ds(lseg, idx); 1025 if (!ds) 1026 goto out_err; 1027 1028 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, data->inode); 1029 if (IS_ERR(ds_clnt)) 1030 goto out_err; 1031 1032 dprintk("%s ino %lu, how %d cl_count %d\n", __func__, 1033 data->inode->i_ino, how, atomic_read(&ds->ds_clp->cl_count)); 1034 data->commit_done_cb = filelayout_commit_done_cb; 1035 atomic_inc(&ds->ds_clp->cl_count); 1036 data->ds_clp = ds->ds_clp; 1037 fh = select_ds_fh_from_commit(lseg, data->ds_commit_index); 1038 if (fh) 1039 data->args.fh = fh; 1040 return nfs_initiate_commit(ds_clnt, data, NFS_PROTO(data->inode), 1041 &filelayout_commit_call_ops, how, 1042 RPC_TASK_SOFTCONN); 1043 out_err: 1044 pnfs_generic_prepare_to_resend_writes(data); 1045 pnfs_generic_commit_release(data); 1046 return -EAGAIN; 1047 } 1048 1049 /* filelayout_search_commit_reqs - Search lists in @cinfo for the head reqest 1050 * for @page 1051 * @cinfo - commit info for current inode 1052 * @page - page to search for matching head request 1053 * 1054 * Returns a the head request if one is found, otherwise returns NULL. 1055 */ 1056 static struct nfs_page * 1057 filelayout_search_commit_reqs(struct nfs_commit_info *cinfo, struct page *page) 1058 { 1059 struct nfs_page *freq, *t; 1060 struct pnfs_commit_bucket *b; 1061 int i; 1062 1063 /* Linearly search the commit lists for each bucket until a matching 1064 * request is found */ 1065 for (i = 0, b = cinfo->ds->buckets; i < cinfo->ds->nbuckets; i++, b++) { 1066 list_for_each_entry_safe(freq, t, &b->written, wb_list) { 1067 if (freq->wb_page == page) 1068 return freq->wb_head; 1069 } 1070 list_for_each_entry_safe(freq, t, &b->committing, wb_list) { 1071 if (freq->wb_page == page) 1072 return freq->wb_head; 1073 } 1074 } 1075 1076 return NULL; 1077 } 1078 1079 static int 1080 filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages, 1081 int how, struct nfs_commit_info *cinfo) 1082 { 1083 return pnfs_generic_commit_pagelist(inode, mds_pages, how, cinfo, 1084 filelayout_initiate_commit); 1085 } 1086 1087 static struct nfs4_deviceid_node * 1088 filelayout_alloc_deviceid_node(struct nfs_server *server, 1089 struct pnfs_device *pdev, gfp_t gfp_flags) 1090 { 1091 struct nfs4_file_layout_dsaddr *dsaddr; 1092 1093 dsaddr = nfs4_fl_alloc_deviceid_node(server, pdev, gfp_flags); 1094 if (!dsaddr) 1095 return NULL; 1096 return &dsaddr->id_node; 1097 } 1098 1099 static void 1100 filelayout_free_deviceid_node(struct nfs4_deviceid_node *d) 1101 { 1102 nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node)); 1103 } 1104 1105 static struct pnfs_layout_hdr * 1106 filelayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags) 1107 { 1108 struct nfs4_filelayout *flo; 1109 1110 flo = kzalloc(sizeof(*flo), gfp_flags); 1111 return flo != NULL ? &flo->generic_hdr : NULL; 1112 } 1113 1114 static void 1115 filelayout_free_layout_hdr(struct pnfs_layout_hdr *lo) 1116 { 1117 kfree(FILELAYOUT_FROM_HDR(lo)); 1118 } 1119 1120 static struct pnfs_ds_commit_info * 1121 filelayout_get_ds_info(struct inode *inode) 1122 { 1123 struct pnfs_layout_hdr *layout = NFS_I(inode)->layout; 1124 1125 if (layout == NULL) 1126 return NULL; 1127 else 1128 return &FILELAYOUT_FROM_HDR(layout)->commit_info; 1129 } 1130 1131 static struct pnfs_layoutdriver_type filelayout_type = { 1132 .id = LAYOUT_NFSV4_1_FILES, 1133 .name = "LAYOUT_NFSV4_1_FILES", 1134 .owner = THIS_MODULE, 1135 .alloc_layout_hdr = filelayout_alloc_layout_hdr, 1136 .free_layout_hdr = filelayout_free_layout_hdr, 1137 .alloc_lseg = filelayout_alloc_lseg, 1138 .free_lseg = filelayout_free_lseg, 1139 .pg_read_ops = &filelayout_pg_read_ops, 1140 .pg_write_ops = &filelayout_pg_write_ops, 1141 .get_ds_info = &filelayout_get_ds_info, 1142 .mark_request_commit = filelayout_mark_request_commit, 1143 .clear_request_commit = pnfs_generic_clear_request_commit, 1144 .scan_commit_lists = pnfs_generic_scan_commit_lists, 1145 .recover_commit_reqs = pnfs_generic_recover_commit_reqs, 1146 .search_commit_reqs = filelayout_search_commit_reqs, 1147 .commit_pagelist = filelayout_commit_pagelist, 1148 .read_pagelist = filelayout_read_pagelist, 1149 .write_pagelist = filelayout_write_pagelist, 1150 .alloc_deviceid_node = filelayout_alloc_deviceid_node, 1151 .free_deviceid_node = filelayout_free_deviceid_node, 1152 .sync = pnfs_nfs_generic_sync, 1153 }; 1154 1155 static int __init nfs4filelayout_init(void) 1156 { 1157 printk(KERN_INFO "%s: NFSv4 File Layout Driver Registering...\n", 1158 __func__); 1159 return pnfs_register_layoutdriver(&filelayout_type); 1160 } 1161 1162 static void __exit nfs4filelayout_exit(void) 1163 { 1164 printk(KERN_INFO "%s: NFSv4 File Layout Driver Unregistering...\n", 1165 __func__); 1166 pnfs_unregister_layoutdriver(&filelayout_type); 1167 } 1168 1169 MODULE_ALIAS("nfs-layouttype4-1"); 1170 1171 module_init(nfs4filelayout_init); 1172 module_exit(nfs4filelayout_exit); 1173