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_lseg(struct nfs4_filelayout_segment *fl) 633 { 634 int i; 635 636 if (fl->fh_array) { 637 for (i = 0; i < fl->num_fh; i++) { 638 if (!fl->fh_array[i]) 639 break; 640 kfree(fl->fh_array[i]); 641 } 642 kfree(fl->fh_array); 643 } 644 kfree(fl); 645 } 646 647 static int 648 filelayout_decode_layout(struct pnfs_layout_hdr *flo, 649 struct nfs4_filelayout_segment *fl, 650 struct nfs4_layoutget_res *lgr, 651 struct nfs4_deviceid *id, 652 gfp_t gfp_flags) 653 { 654 struct xdr_stream stream; 655 struct xdr_buf buf; 656 struct page *scratch; 657 __be32 *p; 658 uint32_t nfl_util; 659 int i; 660 661 dprintk("%s: set_layout_map Begin\n", __func__); 662 663 scratch = alloc_page(gfp_flags); 664 if (!scratch) 665 return -ENOMEM; 666 667 xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len); 668 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE); 669 670 /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8), 671 * num_fh (4) */ 672 p = xdr_inline_decode(&stream, NFS4_DEVICEID4_SIZE + 20); 673 if (unlikely(!p)) 674 goto out_err; 675 676 memcpy(id, p, sizeof(*id)); 677 p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE); 678 nfs4_print_deviceid(id); 679 680 nfl_util = be32_to_cpup(p++); 681 if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS) 682 fl->commit_through_mds = 1; 683 if (nfl_util & NFL4_UFLG_DENSE) 684 fl->stripe_type = STRIPE_DENSE; 685 else 686 fl->stripe_type = STRIPE_SPARSE; 687 fl->stripe_unit = nfl_util & ~NFL4_UFLG_MASK; 688 689 fl->first_stripe_index = be32_to_cpup(p++); 690 p = xdr_decode_hyper(p, &fl->pattern_offset); 691 fl->num_fh = be32_to_cpup(p++); 692 693 dprintk("%s: nfl_util 0x%X num_fh %u fsi %u po %llu\n", 694 __func__, nfl_util, fl->num_fh, fl->first_stripe_index, 695 fl->pattern_offset); 696 697 /* Note that a zero value for num_fh is legal for STRIPE_SPARSE. 698 * Futher checking is done in filelayout_check_layout */ 699 if (fl->num_fh > 700 max(NFS4_PNFS_MAX_STRIPE_CNT, NFS4_PNFS_MAX_MULTI_CNT)) 701 goto out_err; 702 703 if (fl->num_fh > 0) { 704 fl->fh_array = kcalloc(fl->num_fh, sizeof(fl->fh_array[0]), 705 gfp_flags); 706 if (!fl->fh_array) 707 goto out_err; 708 } 709 710 for (i = 0; i < fl->num_fh; i++) { 711 /* Do we want to use a mempool here? */ 712 fl->fh_array[i] = kmalloc(sizeof(struct nfs_fh), gfp_flags); 713 if (!fl->fh_array[i]) 714 goto out_err; 715 716 p = xdr_inline_decode(&stream, 4); 717 if (unlikely(!p)) 718 goto out_err; 719 fl->fh_array[i]->size = be32_to_cpup(p++); 720 if (sizeof(struct nfs_fh) < fl->fh_array[i]->size) { 721 printk(KERN_ERR "NFS: Too big fh %d received %d\n", 722 i, fl->fh_array[i]->size); 723 goto out_err; 724 } 725 726 p = xdr_inline_decode(&stream, fl->fh_array[i]->size); 727 if (unlikely(!p)) 728 goto out_err; 729 memcpy(fl->fh_array[i]->data, p, fl->fh_array[i]->size); 730 dprintk("DEBUG: %s: fh len %d\n", __func__, 731 fl->fh_array[i]->size); 732 } 733 734 __free_page(scratch); 735 return 0; 736 737 out_err: 738 __free_page(scratch); 739 return -EIO; 740 } 741 742 static void 743 filelayout_free_lseg(struct pnfs_layout_segment *lseg) 744 { 745 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 746 747 dprintk("--> %s\n", __func__); 748 nfs4_fl_put_deviceid(fl->dsaddr); 749 /* This assumes a single RW lseg */ 750 if (lseg->pls_range.iomode == IOMODE_RW) { 751 struct nfs4_filelayout *flo; 752 753 flo = FILELAYOUT_FROM_HDR(lseg->pls_layout); 754 flo->commit_info.nbuckets = 0; 755 kfree(flo->commit_info.buckets); 756 flo->commit_info.buckets = NULL; 757 } 758 _filelayout_free_lseg(fl); 759 } 760 761 static int 762 filelayout_alloc_commit_info(struct pnfs_layout_segment *lseg, 763 struct nfs_commit_info *cinfo, 764 gfp_t gfp_flags) 765 { 766 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 767 struct pnfs_commit_bucket *buckets; 768 int size, i; 769 770 if (fl->commit_through_mds) 771 return 0; 772 773 size = (fl->stripe_type == STRIPE_SPARSE) ? 774 fl->dsaddr->ds_num : fl->dsaddr->stripe_count; 775 776 if (cinfo->ds->nbuckets >= size) { 777 /* This assumes there is only one IOMODE_RW lseg. What 778 * we really want to do is have a layout_hdr level 779 * dictionary of <multipath_list4, fh> keys, each 780 * associated with a struct list_head, populated by calls 781 * to filelayout_write_pagelist(). 782 * */ 783 return 0; 784 } 785 786 buckets = kcalloc(size, sizeof(struct pnfs_commit_bucket), 787 gfp_flags); 788 if (!buckets) 789 return -ENOMEM; 790 for (i = 0; i < size; i++) { 791 INIT_LIST_HEAD(&buckets[i].written); 792 INIT_LIST_HEAD(&buckets[i].committing); 793 /* mark direct verifier as unset */ 794 buckets[i].direct_verf.committed = NFS_INVALID_STABLE_HOW; 795 } 796 797 spin_lock(cinfo->lock); 798 if (cinfo->ds->nbuckets >= size) 799 goto out; 800 for (i = 0; i < cinfo->ds->nbuckets; i++) { 801 list_splice(&cinfo->ds->buckets[i].written, 802 &buckets[i].written); 803 list_splice(&cinfo->ds->buckets[i].committing, 804 &buckets[i].committing); 805 buckets[i].direct_verf.committed = 806 cinfo->ds->buckets[i].direct_verf.committed; 807 buckets[i].wlseg = cinfo->ds->buckets[i].wlseg; 808 buckets[i].clseg = cinfo->ds->buckets[i].clseg; 809 } 810 swap(cinfo->ds->buckets, buckets); 811 cinfo->ds->nbuckets = size; 812 out: 813 spin_unlock(cinfo->lock); 814 kfree(buckets); 815 return 0; 816 } 817 818 static struct pnfs_layout_segment * 819 filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid, 820 struct nfs4_layoutget_res *lgr, 821 gfp_t gfp_flags) 822 { 823 struct nfs4_filelayout_segment *fl; 824 int rc; 825 struct nfs4_deviceid id; 826 827 dprintk("--> %s\n", __func__); 828 fl = kzalloc(sizeof(*fl), gfp_flags); 829 if (!fl) 830 return NULL; 831 832 rc = filelayout_decode_layout(layoutid, fl, lgr, &id, gfp_flags); 833 if (rc != 0 || filelayout_check_layout(layoutid, fl, lgr, &id, gfp_flags)) { 834 _filelayout_free_lseg(fl); 835 return NULL; 836 } 837 return &fl->generic_hdr; 838 } 839 840 /* 841 * filelayout_pg_test(). Called by nfs_can_coalesce_requests() 842 * 843 * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number 844 * of bytes (maximum @req->wb_bytes) that can be coalesced. 845 */ 846 static size_t 847 filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev, 848 struct nfs_page *req) 849 { 850 unsigned int size; 851 u64 p_stripe, r_stripe; 852 u32 stripe_offset; 853 u64 segment_offset = pgio->pg_lseg->pls_range.offset; 854 u32 stripe_unit = FILELAYOUT_LSEG(pgio->pg_lseg)->stripe_unit; 855 856 /* calls nfs_generic_pg_test */ 857 size = pnfs_generic_pg_test(pgio, prev, req); 858 if (!size) 859 return 0; 860 861 /* see if req and prev are in the same stripe */ 862 if (prev) { 863 p_stripe = (u64)req_offset(prev) - segment_offset; 864 r_stripe = (u64)req_offset(req) - segment_offset; 865 do_div(p_stripe, stripe_unit); 866 do_div(r_stripe, stripe_unit); 867 868 if (p_stripe != r_stripe) 869 return 0; 870 } 871 872 /* calculate remaining bytes in the current stripe */ 873 div_u64_rem((u64)req_offset(req) - segment_offset, 874 stripe_unit, 875 &stripe_offset); 876 WARN_ON_ONCE(stripe_offset > stripe_unit); 877 if (stripe_offset >= stripe_unit) 878 return 0; 879 return min(stripe_unit - (unsigned int)stripe_offset, size); 880 } 881 882 static void 883 filelayout_pg_init_read(struct nfs_pageio_descriptor *pgio, 884 struct nfs_page *req) 885 { 886 if (!pgio->pg_lseg) 887 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 888 req->wb_context, 889 0, 890 NFS4_MAX_UINT64, 891 IOMODE_READ, 892 GFP_KERNEL); 893 /* If no lseg, fall back to read through mds */ 894 if (pgio->pg_lseg == NULL) 895 nfs_pageio_reset_read_mds(pgio); 896 } 897 898 static void 899 filelayout_pg_init_write(struct nfs_pageio_descriptor *pgio, 900 struct nfs_page *req) 901 { 902 struct nfs_commit_info cinfo; 903 int status; 904 905 if (!pgio->pg_lseg) 906 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode, 907 req->wb_context, 908 0, 909 NFS4_MAX_UINT64, 910 IOMODE_RW, 911 GFP_NOFS); 912 /* If no lseg, fall back to write through mds */ 913 if (pgio->pg_lseg == NULL) 914 goto out_mds; 915 nfs_init_cinfo(&cinfo, pgio->pg_inode, pgio->pg_dreq); 916 status = filelayout_alloc_commit_info(pgio->pg_lseg, &cinfo, GFP_NOFS); 917 if (status < 0) { 918 pnfs_put_lseg(pgio->pg_lseg); 919 pgio->pg_lseg = NULL; 920 goto out_mds; 921 } 922 return; 923 out_mds: 924 nfs_pageio_reset_write_mds(pgio); 925 } 926 927 static const struct nfs_pageio_ops filelayout_pg_read_ops = { 928 .pg_init = filelayout_pg_init_read, 929 .pg_test = filelayout_pg_test, 930 .pg_doio = pnfs_generic_pg_readpages, 931 .pg_cleanup = pnfs_generic_pg_cleanup, 932 }; 933 934 static const struct nfs_pageio_ops filelayout_pg_write_ops = { 935 .pg_init = filelayout_pg_init_write, 936 .pg_test = filelayout_pg_test, 937 .pg_doio = pnfs_generic_pg_writepages, 938 .pg_cleanup = pnfs_generic_pg_cleanup, 939 }; 940 941 static u32 select_bucket_index(struct nfs4_filelayout_segment *fl, u32 j) 942 { 943 if (fl->stripe_type == STRIPE_SPARSE) 944 return nfs4_fl_calc_ds_index(&fl->generic_hdr, j); 945 else 946 return j; 947 } 948 949 static void 950 filelayout_mark_request_commit(struct nfs_page *req, 951 struct pnfs_layout_segment *lseg, 952 struct nfs_commit_info *cinfo, 953 u32 ds_commit_idx) 954 955 { 956 struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg); 957 u32 i, j; 958 959 if (fl->commit_through_mds) { 960 nfs_request_add_commit_list(req, &cinfo->mds->list, cinfo); 961 } else { 962 /* Note that we are calling nfs4_fl_calc_j_index on each page 963 * that ends up being committed to a data server. An attractive 964 * alternative is to add a field to nfs_write_data and nfs_page 965 * to store the value calculated in filelayout_write_pagelist 966 * and just use that here. 967 */ 968 j = nfs4_fl_calc_j_index(lseg, req_offset(req)); 969 i = select_bucket_index(fl, j); 970 pnfs_layout_mark_request_commit(req, lseg, cinfo, i); 971 } 972 } 973 974 static u32 calc_ds_index_from_commit(struct pnfs_layout_segment *lseg, u32 i) 975 { 976 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg); 977 978 if (flseg->stripe_type == STRIPE_SPARSE) 979 return i; 980 else 981 return nfs4_fl_calc_ds_index(lseg, i); 982 } 983 984 static struct nfs_fh * 985 select_ds_fh_from_commit(struct pnfs_layout_segment *lseg, u32 i) 986 { 987 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg); 988 989 if (flseg->stripe_type == STRIPE_SPARSE) { 990 if (flseg->num_fh == 1) 991 i = 0; 992 else if (flseg->num_fh == 0) 993 /* Use the MDS OPEN fh set in nfs_read_rpcsetup */ 994 return NULL; 995 } 996 return flseg->fh_array[i]; 997 } 998 999 static int filelayout_initiate_commit(struct nfs_commit_data *data, int how) 1000 { 1001 struct pnfs_layout_segment *lseg = data->lseg; 1002 struct nfs4_pnfs_ds *ds; 1003 struct rpc_clnt *ds_clnt; 1004 u32 idx; 1005 struct nfs_fh *fh; 1006 1007 idx = calc_ds_index_from_commit(lseg, data->ds_commit_index); 1008 ds = nfs4_fl_prepare_ds(lseg, idx); 1009 if (!ds) 1010 goto out_err; 1011 1012 ds_clnt = nfs4_find_or_create_ds_client(ds->ds_clp, data->inode); 1013 if (IS_ERR(ds_clnt)) 1014 goto out_err; 1015 1016 dprintk("%s ino %lu, how %d cl_count %d\n", __func__, 1017 data->inode->i_ino, how, atomic_read(&ds->ds_clp->cl_count)); 1018 data->commit_done_cb = filelayout_commit_done_cb; 1019 atomic_inc(&ds->ds_clp->cl_count); 1020 data->ds_clp = ds->ds_clp; 1021 fh = select_ds_fh_from_commit(lseg, data->ds_commit_index); 1022 if (fh) 1023 data->args.fh = fh; 1024 return nfs_initiate_commit(ds_clnt, data, NFS_PROTO(data->inode), 1025 &filelayout_commit_call_ops, how, 1026 RPC_TASK_SOFTCONN); 1027 out_err: 1028 pnfs_generic_prepare_to_resend_writes(data); 1029 pnfs_generic_commit_release(data); 1030 return -EAGAIN; 1031 } 1032 1033 /* filelayout_search_commit_reqs - Search lists in @cinfo for the head reqest 1034 * for @page 1035 * @cinfo - commit info for current inode 1036 * @page - page to search for matching head request 1037 * 1038 * Returns a the head request if one is found, otherwise returns NULL. 1039 */ 1040 static struct nfs_page * 1041 filelayout_search_commit_reqs(struct nfs_commit_info *cinfo, struct page *page) 1042 { 1043 struct nfs_page *freq, *t; 1044 struct pnfs_commit_bucket *b; 1045 int i; 1046 1047 /* Linearly search the commit lists for each bucket until a matching 1048 * request is found */ 1049 for (i = 0, b = cinfo->ds->buckets; i < cinfo->ds->nbuckets; i++, b++) { 1050 list_for_each_entry_safe(freq, t, &b->written, wb_list) { 1051 if (freq->wb_page == page) 1052 return freq->wb_head; 1053 } 1054 list_for_each_entry_safe(freq, t, &b->committing, wb_list) { 1055 if (freq->wb_page == page) 1056 return freq->wb_head; 1057 } 1058 } 1059 1060 return NULL; 1061 } 1062 1063 static int 1064 filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages, 1065 int how, struct nfs_commit_info *cinfo) 1066 { 1067 return pnfs_generic_commit_pagelist(inode, mds_pages, how, cinfo, 1068 filelayout_initiate_commit); 1069 } 1070 1071 static struct nfs4_deviceid_node * 1072 filelayout_alloc_deviceid_node(struct nfs_server *server, 1073 struct pnfs_device *pdev, gfp_t gfp_flags) 1074 { 1075 struct nfs4_file_layout_dsaddr *dsaddr; 1076 1077 dsaddr = nfs4_fl_alloc_deviceid_node(server, pdev, gfp_flags); 1078 if (!dsaddr) 1079 return NULL; 1080 return &dsaddr->id_node; 1081 } 1082 1083 static void 1084 filelayout_free_deviceid_node(struct nfs4_deviceid_node *d) 1085 { 1086 nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node)); 1087 } 1088 1089 static struct pnfs_layout_hdr * 1090 filelayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags) 1091 { 1092 struct nfs4_filelayout *flo; 1093 1094 flo = kzalloc(sizeof(*flo), gfp_flags); 1095 return flo != NULL ? &flo->generic_hdr : NULL; 1096 } 1097 1098 static void 1099 filelayout_free_layout_hdr(struct pnfs_layout_hdr *lo) 1100 { 1101 kfree(FILELAYOUT_FROM_HDR(lo)); 1102 } 1103 1104 static struct pnfs_ds_commit_info * 1105 filelayout_get_ds_info(struct inode *inode) 1106 { 1107 struct pnfs_layout_hdr *layout = NFS_I(inode)->layout; 1108 1109 if (layout == NULL) 1110 return NULL; 1111 else 1112 return &FILELAYOUT_FROM_HDR(layout)->commit_info; 1113 } 1114 1115 static struct pnfs_layoutdriver_type filelayout_type = { 1116 .id = LAYOUT_NFSV4_1_FILES, 1117 .name = "LAYOUT_NFSV4_1_FILES", 1118 .owner = THIS_MODULE, 1119 .alloc_layout_hdr = filelayout_alloc_layout_hdr, 1120 .free_layout_hdr = filelayout_free_layout_hdr, 1121 .alloc_lseg = filelayout_alloc_lseg, 1122 .free_lseg = filelayout_free_lseg, 1123 .pg_read_ops = &filelayout_pg_read_ops, 1124 .pg_write_ops = &filelayout_pg_write_ops, 1125 .get_ds_info = &filelayout_get_ds_info, 1126 .mark_request_commit = filelayout_mark_request_commit, 1127 .clear_request_commit = pnfs_generic_clear_request_commit, 1128 .scan_commit_lists = pnfs_generic_scan_commit_lists, 1129 .recover_commit_reqs = pnfs_generic_recover_commit_reqs, 1130 .search_commit_reqs = filelayout_search_commit_reqs, 1131 .commit_pagelist = filelayout_commit_pagelist, 1132 .read_pagelist = filelayout_read_pagelist, 1133 .write_pagelist = filelayout_write_pagelist, 1134 .alloc_deviceid_node = filelayout_alloc_deviceid_node, 1135 .free_deviceid_node = filelayout_free_deviceid_node, 1136 .sync = pnfs_nfs_generic_sync, 1137 }; 1138 1139 static int __init nfs4filelayout_init(void) 1140 { 1141 printk(KERN_INFO "%s: NFSv4 File Layout Driver Registering...\n", 1142 __func__); 1143 return pnfs_register_layoutdriver(&filelayout_type); 1144 } 1145 1146 static void __exit nfs4filelayout_exit(void) 1147 { 1148 printk(KERN_INFO "%s: NFSv4 File Layout Driver Unregistering...\n", 1149 __func__); 1150 pnfs_unregister_layoutdriver(&filelayout_type); 1151 } 1152 1153 MODULE_ALIAS("nfs-layouttype4-1"); 1154 1155 module_init(nfs4filelayout_init); 1156 module_exit(nfs4filelayout_exit); 1157