NFSv4/flexfiles: Add data structure support for striped layouts

+73 -61

fs/nfs/flexfilelayout/flexfilelayout.c

··· 171 171 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 172 172 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx); 173 173 174 - return nfs_local_open_fh(clp, cred, fh, &mirror->nfl, mode); 174 + return nfs_local_open_fh(clp, cred, fh, &mirror->dss[0].nfl, mode); 175 175 #else 176 176 return NULL; 177 177 #endif ··· 182 182 { 183 183 int i, j; 184 184 185 - if (m1->fh_versions_cnt != m2->fh_versions_cnt) 185 + if (m1->dss[0].fh_versions_cnt != m2->dss[0].fh_versions_cnt) 186 186 return false; 187 - for (i = 0; i < m1->fh_versions_cnt; i++) { 187 + for (i = 0; i < m1->dss[0].fh_versions_cnt; i++) { 188 188 bool found_fh = false; 189 - for (j = 0; j < m2->fh_versions_cnt; j++) { 190 - if (nfs_compare_fh(&m1->fh_versions[i], 191 - &m2->fh_versions[j]) == 0) { 189 + for (j = 0; j < m2->dss[0].fh_versions_cnt; j++) { 190 + if (nfs_compare_fh(&m1->dss[0].fh_versions[i], 191 + &m2->dss[0].fh_versions[j]) == 0) { 192 192 found_fh = true; 193 193 break; 194 194 } ··· 209 209 210 210 spin_lock(&inode->i_lock); 211 211 list_for_each_entry(pos, &ff_layout->mirrors, mirrors) { 212 - if (memcmp(&mirror->devid, &pos->devid, sizeof(pos->devid)) != 0) 212 + if (memcmp(&mirror->dss[0].devid, &pos->dss[0].devid, 213 + sizeof(pos->dss[0].devid)) != 0) 213 214 continue; 214 215 if (!ff_mirror_match_fh(mirror, pos)) 215 216 continue; ··· 247 246 spin_lock_init(&mirror->lock); 248 247 refcount_set(&mirror->ref, 1); 249 248 INIT_LIST_HEAD(&mirror->mirrors); 250 - nfs_localio_file_init(&mirror->nfl); 249 + nfs_localio_file_init(&mirror->dss[0].nfl); 251 250 } 252 251 return mirror; 253 252 } 254 253 255 254 static void ff_layout_free_mirror(struct nfs4_ff_layout_mirror *mirror) 256 255 { 257 - const struct cred *cred; 256 + const struct cred *cred; 257 + int dss_id = 0; 258 258 259 259 ff_layout_remove_mirror(mirror); 260 - kfree(mirror->fh_versions); 261 - nfs_close_local_fh(&mirror->nfl); 262 - cred = rcu_access_pointer(mirror->ro_cred); 260 + 261 + kfree(mirror->dss[dss_id].fh_versions); 262 + nfs_close_local_fh(&mirror->dss[dss_id].nfl); 263 + cred = rcu_access_pointer(mirror->dss[dss_id].ro_cred); 263 264 put_cred(cred); 264 - cred = rcu_access_pointer(mirror->rw_cred); 265 + cred = rcu_access_pointer(mirror->dss[dss_id].rw_cred); 265 266 put_cred(cred); 266 - nfs4_ff_layout_put_deviceid(mirror->mirror_ds); 267 + nfs4_ff_layout_put_deviceid(mirror->dss[dss_id].mirror_ds); 268 + 269 + kfree(mirror->dss); 267 270 kfree(mirror); 268 271 } 269 272 ··· 377 372 378 373 for (i = 0; i < fls->mirror_array_cnt - 1; i++) { 379 374 for (j = i + 1; j < fls->mirror_array_cnt; j++) 380 - if (fls->mirror_array[i]->efficiency < 381 - fls->mirror_array[j]->efficiency) 375 + if (fls->mirror_array[i]->dss[0].efficiency < 376 + fls->mirror_array[j]->dss[0].efficiency) 382 377 swap(fls->mirror_array[i], 383 378 fls->mirror_array[j]); 384 379 } ··· 432 427 fls->mirror_array_cnt = mirror_array_cnt; 433 428 fls->stripe_unit = stripe_unit; 434 429 430 + u32 dss_count = 0; 435 431 for (i = 0; i < fls->mirror_array_cnt; i++) { 436 432 struct nfs4_ff_layout_mirror *mirror; 437 433 struct cred *kcred; 438 434 const struct cred __rcu *cred; 439 435 kuid_t uid; 440 436 kgid_t gid; 441 - u32 ds_count, fh_count, id; 442 - int j; 437 + u32 fh_count, id; 438 + int j, dss_id = 0; 443 439 444 440 rc = -EIO; 445 441 p = xdr_inline_decode(&stream, 4); 446 442 if (!p) 447 443 goto out_err_free; 448 - ds_count = be32_to_cpup(p); 444 + 445 + dss_count = be32_to_cpup(p); 449 446 450 447 /* FIXME: allow for striping? */ 451 - if (ds_count != 1) 448 + if (dss_count != 1) 452 449 goto out_err_free; 453 450 454 451 fls->mirror_array[i] = ff_layout_alloc_mirror(gfp_flags); ··· 459 452 goto out_err_free; 460 453 } 461 454 462 - fls->mirror_array[i]->ds_count = ds_count; 455 + fls->mirror_array[i]->dss_count = dss_count; 456 + fls->mirror_array[i]->dss = 457 + kcalloc(dss_count, sizeof(struct nfs4_ff_layout_ds_stripe), 458 + gfp_flags); 463 459 464 460 /* deviceid */ 465 - rc = decode_deviceid(&stream, &fls->mirror_array[i]->devid); 461 + rc = decode_deviceid(&stream, &fls->mirror_array[i]->dss[dss_id].devid); 466 462 if (rc) 467 463 goto out_err_free; 468 464 ··· 474 464 p = xdr_inline_decode(&stream, 4); 475 465 if (!p) 476 466 goto out_err_free; 477 - fls->mirror_array[i]->efficiency = be32_to_cpup(p); 467 + fls->mirror_array[i]->dss[dss_id].efficiency = be32_to_cpup(p); 478 468 479 469 /* stateid */ 480 - rc = decode_pnfs_stateid(&stream, &fls->mirror_array[i]->stateid); 470 + rc = decode_pnfs_stateid(&stream, &fls->mirror_array[i]->dss[dss_id].stateid); 481 471 if (rc) 482 472 goto out_err_free; 483 473 ··· 488 478 goto out_err_free; 489 479 fh_count = be32_to_cpup(p); 490 480 491 - fls->mirror_array[i]->fh_versions = 492 - kcalloc(fh_count, sizeof(struct nfs_fh), 493 - gfp_flags); 494 - if (fls->mirror_array[i]->fh_versions == NULL) { 481 + fls->mirror_array[i]->dss[dss_id].fh_versions = 482 + kcalloc(fh_count, sizeof(struct nfs_fh), 483 + gfp_flags); 484 + if (fls->mirror_array[i]->dss[dss_id].fh_versions == NULL) { 495 485 rc = -ENOMEM; 496 486 goto out_err_free; 497 487 } 498 488 499 489 for (j = 0; j < fh_count; j++) { 500 490 rc = decode_nfs_fh(&stream, 501 - &fls->mirror_array[i]->fh_versions[j]); 491 + &fls->mirror_array[i]->dss[dss_id].fh_versions[j]); 502 492 if (rc) 503 493 goto out_err_free; 504 494 } 505 495 506 - fls->mirror_array[i]->fh_versions_cnt = fh_count; 496 + fls->mirror_array[i]->dss[dss_id].fh_versions_cnt = fh_count; 507 497 508 498 /* user */ 509 499 rc = decode_name(&stream, &id); ··· 534 524 cred = RCU_INITIALIZER(kcred); 535 525 536 526 if (lgr->range.iomode == IOMODE_READ) 537 - rcu_assign_pointer(fls->mirror_array[i]->ro_cred, cred); 527 + rcu_assign_pointer(fls->mirror_array[i]->dss[dss_id].ro_cred, cred); 538 528 else 539 - rcu_assign_pointer(fls->mirror_array[i]->rw_cred, cred); 529 + rcu_assign_pointer(fls->mirror_array[i]->dss[dss_id].rw_cred, cred); 540 530 541 531 mirror = ff_layout_add_mirror(lh, fls->mirror_array[i]); 542 532 if (mirror != fls->mirror_array[i]) { 543 533 /* swap cred ptrs so free_mirror will clean up old */ 544 534 if (lgr->range.iomode == IOMODE_READ) { 545 - cred = xchg(&mirror->ro_cred, fls->mirror_array[i]->ro_cred); 546 - rcu_assign_pointer(fls->mirror_array[i]->ro_cred, cred); 535 + cred = xchg(&mirror->dss[dss_id].ro_cred, 536 + fls->mirror_array[i]->dss[dss_id].ro_cred); 537 + rcu_assign_pointer(fls->mirror_array[i]->dss[dss_id].ro_cred, cred); 547 538 } else { 548 - cred = xchg(&mirror->rw_cred, fls->mirror_array[i]->rw_cred); 549 - rcu_assign_pointer(fls->mirror_array[i]->rw_cred, cred); 539 + cred = xchg(&mirror->dss[dss_id].rw_cred, 540 + fls->mirror_array[i]->dss[dss_id].rw_cred); 541 + rcu_assign_pointer(fls->mirror_array[i]->dss[dss_id].rw_cred, cred); 550 542 } 551 543 ff_layout_free_mirror(fls->mirror_array[i]); 552 544 fls->mirror_array[i] = mirror; ··· 636 624 struct nfs4_flexfile_layout *ffl = FF_LAYOUT_FROM_HDR(mirror->layout); 637 625 638 626 nfs4_ff_start_busy_timer(&layoutstat->busy_timer, now); 639 - if (!mirror->start_time) 640 - mirror->start_time = now; 627 + if (!mirror->dss[0].start_time) 628 + mirror->dss[0].start_time = now; 641 629 if (mirror->report_interval != 0) 642 630 report_interval = (s64)mirror->report_interval * 1000LL; 643 631 else if (layoutstats_timer != 0) ··· 692 680 bool report; 693 681 694 682 spin_lock(&mirror->lock); 695 - report = nfs4_ff_layoutstat_start_io(mirror, &mirror->read_stat, now); 696 - nfs4_ff_layout_stat_io_update_requested(&mirror->read_stat, requested); 683 + report = nfs4_ff_layoutstat_start_io(mirror, &mirror->dss[0].read_stat, now); 684 + nfs4_ff_layout_stat_io_update_requested(&mirror->dss[0].read_stat, requested); 697 685 set_bit(NFS4_FF_MIRROR_STAT_AVAIL, &mirror->flags); 698 686 spin_unlock(&mirror->lock); 699 687 ··· 708 696 __u64 completed) 709 697 { 710 698 spin_lock(&mirror->lock); 711 - nfs4_ff_layout_stat_io_update_completed(&mirror->read_stat, 699 + nfs4_ff_layout_stat_io_update_completed(&mirror->dss[0].read_stat, 712 700 requested, completed, 713 701 ktime_get(), task->tk_start); 714 702 set_bit(NFS4_FF_MIRROR_STAT_AVAIL, &mirror->flags); ··· 723 711 bool report; 724 712 725 713 spin_lock(&mirror->lock); 726 - report = nfs4_ff_layoutstat_start_io(mirror , &mirror->write_stat, now); 727 - nfs4_ff_layout_stat_io_update_requested(&mirror->write_stat, requested); 714 + report = nfs4_ff_layoutstat_start_io(mirror, &mirror->dss[0].write_stat, now); 715 + nfs4_ff_layout_stat_io_update_requested(&mirror->dss[0].write_stat, requested); 728 716 set_bit(NFS4_FF_MIRROR_STAT_AVAIL, &mirror->flags); 729 717 spin_unlock(&mirror->lock); 730 718 ··· 743 731 requested = completed = 0; 744 732 745 733 spin_lock(&mirror->lock); 746 - nfs4_ff_layout_stat_io_update_completed(&mirror->write_stat, 734 + nfs4_ff_layout_stat_io_update_completed(&mirror->dss[0].write_stat, 747 735 requested, completed, ktime_get(), task->tk_start); 748 736 set_bit(NFS4_FF_MIRROR_STAT_AVAIL, &mirror->flags); 749 737 spin_unlock(&mirror->lock); ··· 785 773 continue; 786 774 787 775 if (check_device && 788 - nfs4_test_deviceid_unavailable(&mirror->mirror_ds->id_node)) { 776 + nfs4_test_deviceid_unavailable(&mirror->dss[0].mirror_ds->id_node)) { 789 777 // reinitialize the error state in case if this is the last iteration 790 778 ds = ERR_PTR(-EINVAL); 791 779 continue; ··· 894 882 895 883 mirror = FF_LAYOUT_COMP(pgio->pg_lseg, ds_idx); 896 884 pgm = &pgio->pg_mirrors[0]; 897 - pgm->pg_bsize = mirror->mirror_ds->ds_versions[0].rsize; 885 + pgm->pg_bsize = mirror->dss[0].mirror_ds->ds_versions[0].rsize; 898 886 899 887 pgio->pg_mirror_idx = ds_idx; 900 888 return; ··· 966 954 goto retry; 967 955 } 968 956 pgm = &pgio->pg_mirrors[i]; 969 - pgm->pg_bsize = mirror->mirror_ds->ds_versions[0].wsize; 957 + pgm->pg_bsize = mirror->dss[0].mirror_ds->ds_versions[0].wsize; 970 958 } 971 959 972 960 if (NFS_SERVER(pgio->pg_inode)->flags & ··· 2044 2032 /* FIXME: Assume that there is only one NFS version available 2045 2033 * for the DS. 2046 2034 */ 2047 - return &flseg->mirror_array[i]->fh_versions[0]; 2035 + return &flseg->mirror_array[i]->dss[0].fh_versions[0]; 2048 2036 } 2049 2037 2050 2038 static int ff_layout_initiate_commit(struct nfs_commit_data *data, int how) ··· 2160 2148 2161 2149 for (idx = 0; idx < flseg->mirror_array_cnt; idx++) { 2162 2150 mirror = flseg->mirror_array[idx]; 2163 - mirror_ds = mirror->mirror_ds; 2151 + mirror_ds = mirror->dss[0].mirror_ds; 2164 2152 if (IS_ERR_OR_NULL(mirror_ds)) 2165 2153 continue; 2166 - ds = mirror->mirror_ds->ds; 2154 + ds = mirror->dss[0].mirror_ds->ds; 2167 2155 if (!ds) 2168 2156 continue; 2169 2157 ds_clp = ds->ds_clp; ··· 2564 2552 struct nfs4_ff_layout_mirror *mirror) 2565 2553 { 2566 2554 struct nfs4_pnfs_ds_addr *da; 2567 - struct nfs4_pnfs_ds *ds = mirror->mirror_ds->ds; 2568 - struct nfs_fh *fh = &mirror->fh_versions[0]; 2555 + struct nfs4_pnfs_ds *ds = mirror->dss[0].mirror_ds->ds; 2556 + struct nfs_fh *fh = &mirror->dss[0].fh_versions[0]; 2569 2557 __be32 *p; 2570 2558 2571 2559 da = list_first_entry(&ds->ds_addrs, struct nfs4_pnfs_ds_addr, da_node); ··· 2578 2566 xdr_encode_opaque(p, fh->data, fh->size); 2579 2567 /* ff_io_latency4 read */ 2580 2568 spin_lock(&mirror->lock); 2581 - ff_layout_encode_io_latency(xdr, &mirror->read_stat.io_stat); 2569 + ff_layout_encode_io_latency(xdr, &mirror->dss[0].read_stat.io_stat); 2582 2570 /* ff_io_latency4 write */ 2583 - ff_layout_encode_io_latency(xdr, &mirror->write_stat.io_stat); 2571 + ff_layout_encode_io_latency(xdr, &mirror->dss[0].write_stat.io_stat); 2584 2572 spin_unlock(&mirror->lock); 2585 2573 /* nfstime4 */ 2586 - ff_layout_encode_nfstime(xdr, ktime_sub(ktime_get(), mirror->start_time)); 2574 + ff_layout_encode_nfstime(xdr, ktime_sub(ktime_get(), mirror->dss[0].start_time)); 2587 2575 /* bool */ 2588 2576 p = xdr_reserve_space(xdr, 4); 2589 2577 *p = cpu_to_be32(false); ··· 2630 2618 list_for_each_entry(mirror, &ff_layout->mirrors, mirrors) { 2631 2619 if (i >= dev_limit) 2632 2620 break; 2633 - if (IS_ERR_OR_NULL(mirror->mirror_ds)) 2621 + if (IS_ERR_OR_NULL(mirror->dss[0].mirror_ds)) 2634 2622 continue; 2635 2623 if (!test_and_clear_bit(NFS4_FF_MIRROR_STAT_AVAIL, 2636 2624 &mirror->flags) && ··· 2639 2627 /* mirror refcount put in cleanup_layoutstats */ 2640 2628 if (!refcount_inc_not_zero(&mirror->ref)) 2641 2629 continue; 2642 - dev = &mirror->mirror_ds->id_node; 2630 + dev = &mirror->dss[0].mirror_ds->id_node; 2643 2631 memcpy(&devinfo->dev_id, &dev->deviceid, NFS4_DEVICEID4_SIZE); 2644 2632 devinfo->offset = 0; 2645 2633 devinfo->length = NFS4_MAX_UINT64; 2646 2634 spin_lock(&mirror->lock); 2647 - devinfo->read_count = mirror->read_stat.io_stat.ops_completed; 2648 - devinfo->read_bytes = mirror->read_stat.io_stat.bytes_completed; 2649 - devinfo->write_count = mirror->write_stat.io_stat.ops_completed; 2650 - devinfo->write_bytes = mirror->write_stat.io_stat.bytes_completed; 2635 + devinfo->read_count = mirror->dss[0].read_stat.io_stat.ops_completed; 2636 + devinfo->read_bytes = mirror->dss[0].read_stat.io_stat.bytes_completed; 2637 + devinfo->write_count = mirror->dss[0].write_stat.io_stat.ops_completed; 2638 + devinfo->write_bytes = mirror->dss[0].write_stat.io_stat.bytes_completed; 2651 2639 spin_unlock(&mirror->lock); 2652 2640 devinfo->layout_type = LAYOUT_FLEX_FILES; 2653 2641 devinfo->ld_private.ops = &layoutstat_ops;

+17 -10

fs/nfs/flexfilelayout/flexfilelayout.h

··· 71 71 struct nfs4_ff_busy_timer busy_timer; 72 72 }; 73 73 74 - struct nfs4_ff_layout_mirror { 75 - struct pnfs_layout_hdr *layout; 76 - struct list_head mirrors; 77 - u32 ds_count; 78 - u32 efficiency; 74 + struct nfs4_ff_layout_mirror; 75 + 76 + struct nfs4_ff_layout_ds_stripe { 77 + struct nfs4_ff_layout_mirror *mirror; 79 78 struct nfs4_deviceid devid; 79 + u32 efficiency; 80 80 struct nfs4_ff_layout_ds *mirror_ds; 81 81 u32 fh_versions_cnt; 82 82 struct nfs_fh *fh_versions; ··· 84 84 const struct cred __rcu *ro_cred; 85 85 const struct cred __rcu *rw_cred; 86 86 struct nfs_file_localio nfl; 87 - refcount_t ref; 88 - spinlock_t lock; 89 - unsigned long flags; 90 87 struct nfs4_ff_layoutstat read_stat; 91 88 struct nfs4_ff_layoutstat write_stat; 92 89 ktime_t start_time; 90 + }; 91 + 92 + struct nfs4_ff_layout_mirror { 93 + struct pnfs_layout_hdr *layout; 94 + struct list_head mirrors; 95 + u32 dss_count; 96 + struct nfs4_ff_layout_ds_stripe *dss; 97 + refcount_t ref; 98 + spinlock_t lock; 99 + unsigned long flags; 93 100 u32 report_interval; 94 101 }; 95 102 ··· 162 155 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, idx); 163 156 164 157 if (mirror != NULL) { 165 - struct nfs4_ff_layout_ds *mirror_ds = mirror->mirror_ds; 158 + struct nfs4_ff_layout_ds *mirror_ds = mirror->dss[0].mirror_ds; 166 159 167 160 if (!IS_ERR_OR_NULL(mirror_ds)) 168 161 return &mirror_ds->id_node; ··· 191 184 static inline int 192 185 nfs4_ff_layout_ds_version(const struct nfs4_ff_layout_mirror *mirror) 193 186 { 194 - return mirror->mirror_ds->ds_versions[0].version; 187 + return mirror->dss[0].mirror_ds->ds_versions[0].version; 195 188 } 196 189 197 190 struct nfs4_ff_layout_ds *

+27 -27

fs/nfs/flexfilelayout/flexfilelayoutdev.c

··· 259 259 if (status == 0) 260 260 return 0; 261 261 262 - if (IS_ERR_OR_NULL(mirror->mirror_ds)) 262 + if (IS_ERR_OR_NULL(mirror->dss[0].mirror_ds)) 263 263 return -EINVAL; 264 264 265 265 dserr = kmalloc(sizeof(*dserr), gfp_flags); ··· 271 271 dserr->length = length; 272 272 dserr->status = status; 273 273 dserr->opnum = opnum; 274 - nfs4_stateid_copy(&dserr->stateid, &mirror->stateid); 275 - memcpy(&dserr->deviceid, &mirror->mirror_ds->id_node.deviceid, 274 + nfs4_stateid_copy(&dserr->stateid, &mirror->dss[0].stateid); 275 + memcpy(&dserr->deviceid, &mirror->dss[0].mirror_ds->id_node.deviceid, 276 276 NFS4_DEVICEID4_SIZE); 277 277 278 278 spin_lock(&flo->generic_hdr.plh_inode->i_lock); ··· 287 287 const struct cred *cred, __rcu **pcred; 288 288 289 289 if (iomode == IOMODE_READ) 290 - pcred = &mirror->ro_cred; 290 + pcred = &mirror->dss[0].ro_cred; 291 291 else 292 - pcred = &mirror->rw_cred; 292 + pcred = &mirror->dss[0].rw_cred; 293 293 294 294 rcu_read_lock(); 295 295 do { ··· 307 307 nfs4_ff_layout_select_ds_fh(struct nfs4_ff_layout_mirror *mirror) 308 308 { 309 309 /* FIXME: For now assume there is only 1 version available for the DS */ 310 - return &mirror->fh_versions[0]; 310 + return &mirror->dss[0].fh_versions[0]; 311 311 } 312 312 313 313 void ··· 315 315 nfs4_stateid *stateid) 316 316 { 317 317 if (nfs4_ff_layout_ds_version(mirror) == 4) 318 - nfs4_stateid_copy(stateid, &mirror->stateid); 318 + nfs4_stateid_copy(stateid, &mirror->dss[0].stateid); 319 319 } 320 320 321 321 static bool ··· 324 324 { 325 325 if (mirror == NULL) 326 326 goto outerr; 327 - if (mirror->mirror_ds == NULL) { 327 + if (mirror->dss[0].mirror_ds == NULL) { 328 328 struct nfs4_deviceid_node *node; 329 329 struct nfs4_ff_layout_ds *mirror_ds = ERR_PTR(-ENODEV); 330 330 331 331 node = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode), 332 - &mirror->devid, lo->plh_lc_cred, 332 + &mirror->dss[0].devid, lo->plh_lc_cred, 333 333 GFP_KERNEL); 334 334 if (node) 335 335 mirror_ds = FF_LAYOUT_MIRROR_DS(node); 336 336 337 337 /* check for race with another call to this function */ 338 - if (cmpxchg(&mirror->mirror_ds, NULL, mirror_ds) && 338 + if (cmpxchg(&mirror->dss[0].mirror_ds, NULL, mirror_ds) && 339 339 mirror_ds != ERR_PTR(-ENODEV)) 340 340 nfs4_put_deviceid_node(node); 341 341 } 342 342 343 - if (IS_ERR(mirror->mirror_ds)) 343 + if (IS_ERR(mirror->dss[0].mirror_ds)) 344 344 goto outerr; 345 345 346 346 return true; ··· 379 379 if (!ff_layout_init_mirror_ds(lseg->pls_layout, mirror)) 380 380 goto noconnect; 381 381 382 - ds = mirror->mirror_ds->ds; 382 + ds = mirror->dss[0].mirror_ds->ds; 383 383 if (READ_ONCE(ds->ds_clp)) 384 384 goto out; 385 385 /* matching smp_wmb() in _nfs4_pnfs_v3/4_ds_connect */ ··· 388 388 /* FIXME: For now we assume the server sent only one version of NFS 389 389 * to use for the DS. 390 390 */ 391 - status = nfs4_pnfs_ds_connect(s, ds, &mirror->mirror_ds->id_node, 391 + status = nfs4_pnfs_ds_connect(s, ds, &mirror->dss[0].mirror_ds->id_node, 392 392 dataserver_timeo, dataserver_retrans, 393 - mirror->mirror_ds->ds_versions[0].version, 394 - mirror->mirror_ds->ds_versions[0].minor_version); 393 + mirror->dss[0].mirror_ds->ds_versions[0].version, 394 + mirror->dss[0].mirror_ds->ds_versions[0].minor_version); 395 395 396 396 /* connect success, check rsize/wsize limit */ 397 397 if (!status) { ··· 404 404 max_payload = 405 405 nfs_block_size(rpc_max_payload(ds->ds_clp->cl_rpcclient), 406 406 NULL); 407 - if (mirror->mirror_ds->ds_versions[0].rsize > max_payload) 408 - mirror->mirror_ds->ds_versions[0].rsize = max_payload; 409 - if (mirror->mirror_ds->ds_versions[0].wsize > max_payload) 410 - mirror->mirror_ds->ds_versions[0].wsize = max_payload; 407 + if (mirror->dss[0].mirror_ds->ds_versions[0].rsize > max_payload) 408 + mirror->dss[0].mirror_ds->ds_versions[0].rsize = max_payload; 409 + if (mirror->dss[0].mirror_ds->ds_versions[0].wsize > max_payload) 410 + mirror->dss[0].mirror_ds->ds_versions[0].wsize = max_payload; 411 411 goto out; 412 412 } 413 413 noconnect: ··· 430 430 { 431 431 const struct cred *cred; 432 432 433 - if (mirror && !mirror->mirror_ds->ds_versions[0].tightly_coupled) { 433 + if (mirror && !mirror->dss[0].mirror_ds->ds_versions[0].tightly_coupled) { 434 434 cred = ff_layout_get_mirror_cred(mirror, range->iomode); 435 435 if (!cred) 436 436 cred = get_cred(mdscred); ··· 453 453 nfs4_ff_find_or_create_ds_client(struct nfs4_ff_layout_mirror *mirror, 454 454 struct nfs_client *ds_clp, struct inode *inode) 455 455 { 456 - switch (mirror->mirror_ds->ds_versions[0].version) { 456 + switch (mirror->dss[0].mirror_ds->ds_versions[0].version) { 457 457 case 3: 458 458 /* For NFSv3 DS, flavor is set when creating DS connections */ 459 459 return ds_clp->cl_rpcclient; ··· 564 564 for (idx = 0; idx < FF_LAYOUT_MIRROR_COUNT(lseg); idx++) { 565 565 mirror = FF_LAYOUT_COMP(lseg, idx); 566 566 if (mirror) { 567 - if (!mirror->mirror_ds) 567 + if (!mirror->dss[0].mirror_ds) 568 568 return true; 569 - if (IS_ERR(mirror->mirror_ds)) 569 + if (IS_ERR(mirror->dss[0].mirror_ds)) 570 570 continue; 571 - devid = &mirror->mirror_ds->id_node; 571 + devid = &mirror->dss[0].mirror_ds->id_node; 572 572 if (!nfs4_test_deviceid_unavailable(devid)) 573 573 return true; 574 574 } ··· 585 585 586 586 for (idx = 0; idx < FF_LAYOUT_MIRROR_COUNT(lseg); idx++) { 587 587 mirror = FF_LAYOUT_COMP(lseg, idx); 588 - if (!mirror || IS_ERR(mirror->mirror_ds)) 588 + if (!mirror || IS_ERR(mirror->dss[0].mirror_ds)) 589 589 return false; 590 - if (!mirror->mirror_ds) 590 + if (!mirror->dss[0].mirror_ds) 591 591 continue; 592 - devid = &mirror->mirror_ds->id_node; 592 + devid = &mirror->dss[0].mirror_ds->id_node; 593 593 if (nfs4_test_deviceid_unavailable(devid)) 594 594 return false; 595 595 }

Configure Feed

Configure Feed