fs/nfs/flexfilelayout/flexfilelayoutdev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Device operations for the pnfs nfs4 file layout driver.
   4  *
   5  * Copyright (c) 2014, Primary Data, Inc. All rights reserved.
   6  *
   7  * Tao Peng <bergwolf@primarydata.com>
   8  */
   9
  10 #include <linux/nfs_fs.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/module.h>
  13 #include <linux/sunrpc/addr.h>
  14
  15 #include "../internal.h"
  16 #include "../nfs4session.h"
  17 #include "flexfilelayout.h"
  18
  19 #define NFSDBG_FACILITY         NFSDBG_PNFS_LD
  20
  21 static unsigned int dataserver_timeo = NFS_DEF_TCP_RETRANS;
  22 static unsigned int dataserver_retrans;
  23
  24 static bool ff_layout_has_available_ds(struct pnfs_layout_segment *lseg);
  25
  26 void nfs4_ff_layout_put_deviceid(struct nfs4_ff_layout_ds *mirror_ds)
  27 {
  28         if (!IS_ERR_OR_NULL(mirror_ds))
  29                 nfs4_put_deviceid_node(&mirror_ds->id_node);
  30 }
  31
  32 void nfs4_ff_layout_free_deviceid(struct nfs4_ff_layout_ds *mirror_ds)
  33 {
  34         nfs4_print_deviceid(&mirror_ds->id_node.deviceid);
  35         nfs4_pnfs_ds_put(mirror_ds->ds);
  36         kfree(mirror_ds->ds_versions);
  37         kfree_rcu(mirror_ds, id_node.rcu);
  38 }
  39
  40 /* Decode opaque device data and construct new_ds using it */
  41 struct nfs4_ff_layout_ds *
  42 nfs4_ff_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,
  43                             gfp_t gfp_flags)
  44 {
  45         struct xdr_stream stream;
  46         struct xdr_buf buf;
  47         struct page *scratch;
  48         struct list_head dsaddrs;
  49         struct nfs4_pnfs_ds_addr *da;
  50         struct nfs4_ff_layout_ds *new_ds = NULL;
  51         struct nfs4_ff_ds_version *ds_versions = NULL;
  52         u32 mp_count;
  53         u32 version_count;
  54         __be32 *p;
  55         int i, ret = -ENOMEM;
  56
  57         /* set up xdr stream */
  58         scratch = alloc_page(gfp_flags);
  59         if (!scratch)
  60                 goto out_err;
  61
  62         new_ds = kzalloc(sizeof(struct nfs4_ff_layout_ds), gfp_flags);
  63         if (!new_ds)
  64                 goto out_scratch;
  65
  66         nfs4_init_deviceid_node(&new_ds->id_node,
  67                                 server,
  68                                 &pdev->dev_id);
  69         INIT_LIST_HEAD(&dsaddrs);
  70
  71         xdr_init_decode_pages(&stream, &buf, pdev->pages, pdev->pglen);
  72         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
  73
  74         /* multipath count */
  75         p = xdr_inline_decode(&stream, 4);
  76         if (unlikely(!p))
  77                 goto out_err_drain_dsaddrs;
  78         mp_count = be32_to_cpup(p);
  79         dprintk("%s: multipath ds count %d\n", __func__, mp_count);
  80
  81         for (i = 0; i < mp_count; i++) {
  82                 /* multipath ds */
  83                 da = nfs4_decode_mp_ds_addr(server->nfs_client->cl_net,
  84                                             &stream, gfp_flags);
  85                 if (da)
  86                         list_add_tail(&da->da_node, &dsaddrs);
  87         }
  88         if (list_empty(&dsaddrs)) {
  89                 dprintk("%s: no suitable DS addresses found\n",
  90                         __func__);
  91                 ret = -ENOMEDIUM;
  92                 goto out_err_drain_dsaddrs;
  93         }
  94
  95         /* version count */
  96         p = xdr_inline_decode(&stream, 4);
  97         if (unlikely(!p))
  98                 goto out_err_drain_dsaddrs;
  99         version_count = be32_to_cpup(p);
 100         dprintk("%s: version count %d\n", __func__, version_count);
 101
 102         ds_versions = kcalloc(version_count,
 103                               sizeof(struct nfs4_ff_ds_version),
 104                               gfp_flags);
 105         if (!ds_versions)
 106                 goto out_scratch;
 107
 108         for (i = 0; i < version_count; i++) {
 109                 /* 20 = version(4) + minor_version(4) + rsize(4) + wsize(4) +
 110                  * tightly_coupled(4) */
 111                 p = xdr_inline_decode(&stream, 20);
 112                 if (unlikely(!p))
 113                         goto out_err_drain_dsaddrs;
 114                 ds_versions[i].version = be32_to_cpup(p++);
 115                 ds_versions[i].minor_version = be32_to_cpup(p++);
 116                 ds_versions[i].rsize = nfs_block_size(be32_to_cpup(p++), NULL);
 117                 ds_versions[i].wsize = nfs_block_size(be32_to_cpup(p++), NULL);
 118                 ds_versions[i].tightly_coupled = be32_to_cpup(p);
 119
 120                 if (ds_versions[i].rsize > NFS_MAX_FILE_IO_SIZE)
 121                         ds_versions[i].rsize = NFS_MAX_FILE_IO_SIZE;
 122                 if (ds_versions[i].wsize > NFS_MAX_FILE_IO_SIZE)
 123                         ds_versions[i].wsize = NFS_MAX_FILE_IO_SIZE;
 124
 125                 /*
 126                  * check for valid major/minor combination.
 127                  * currently we support dataserver which talk:
 128                  *   v3, v4.0, v4.1, v4.2
 129                  */
 130                 if (!((ds_versions[i].version == 3 && ds_versions[i].minor_version == 0) ||
 131                         (ds_versions[i].version == 4 && ds_versions[i].minor_version < 3))) {
 132                         dprintk("%s: [%d] unsupported ds version %d-%d\n", __func__,
 133                                 i, ds_versions[i].version,
 134                                 ds_versions[i].minor_version);
 135                         ret = -EPROTONOSUPPORT;
 136                         goto out_err_drain_dsaddrs;
 137                 }
 138
 139                 dprintk("%s: [%d] vers %u minor_ver %u rsize %u wsize %u coupled %d\n",
 140                         __func__, i, ds_versions[i].version,
 141                         ds_versions[i].minor_version,
 142                         ds_versions[i].rsize,
 143                         ds_versions[i].wsize,
 144                         ds_versions[i].tightly_coupled);
 145         }
 146
 147         new_ds->ds_versions = ds_versions;
 148         new_ds->ds_versions_cnt = version_count;
 149
 150         new_ds->ds = nfs4_pnfs_ds_add(&dsaddrs, gfp_flags);
 151         if (!new_ds->ds)
 152                 goto out_err_drain_dsaddrs;
 153
 154         /* If DS was already in cache, free ds addrs */
 155         while (!list_empty(&dsaddrs)) {
 156                 da = list_first_entry(&dsaddrs,
 157                                       struct nfs4_pnfs_ds_addr,
 158                                       da_node);
 159                 list_del_init(&da->da_node);
 160                 kfree(da->da_remotestr);
 161                 kfree(da);
 162         }
 163
 164         __free_page(scratch);
 165         return new_ds;
 166
 167 out_err_drain_dsaddrs:
 168         while (!list_empty(&dsaddrs)) {
 169                 da = list_first_entry(&dsaddrs, struct nfs4_pnfs_ds_addr,
 170                                       da_node);
 171                 list_del_init(&da->da_node);
 172                 kfree(da->da_remotestr);
 173                 kfree(da);
 174         }
 175
 176         kfree(ds_versions);
 177 out_scratch:
 178         __free_page(scratch);
 179 out_err:
 180         kfree(new_ds);
 181
 182         dprintk("%s ERROR: returning %d\n", __func__, ret);
 183         return NULL;
 184 }
 185
 186 static void ff_layout_mark_devid_invalid(struct pnfs_layout_segment *lseg,
 187                 struct nfs4_deviceid_node *devid)
 188 {
 189         nfs4_delete_deviceid(devid->ld, devid->nfs_client, &devid->deviceid);
 190         if (!ff_layout_has_available_ds(lseg))
 191                 pnfs_error_mark_layout_for_return(lseg->pls_layout->plh_inode,
 192                                 lseg);
 193 }
 194
 195 static bool ff_layout_mirror_valid(struct pnfs_layout_segment *lseg,
 196                                    struct nfs4_ff_layout_mirror *mirror,
 197                                    bool create)
 198 {
 199         if (mirror == NULL || IS_ERR(mirror->mirror_ds))
 200                 goto outerr;
 201         if (mirror->mirror_ds == NULL) {
 202                 if (create) {
 203                         struct nfs4_deviceid_node *node;
 204                         struct pnfs_layout_hdr *lh = lseg->pls_layout;
 205                         struct nfs4_ff_layout_ds *mirror_ds = ERR_PTR(-ENODEV);
 206
 207                         node = nfs4_find_get_deviceid(NFS_SERVER(lh->plh_inode),
 208                                         &mirror->devid, lh->plh_lc_cred,
 209                                         GFP_KERNEL);
 210                         if (node)
 211                                 mirror_ds = FF_LAYOUT_MIRROR_DS(node);
 212
 213                         /* check for race with another call to this function */
 214                         if (cmpxchg(&mirror->mirror_ds, NULL, mirror_ds) &&
 215                             mirror_ds != ERR_PTR(-ENODEV))
 216                                 nfs4_put_deviceid_node(node);
 217                 } else
 218                         goto outerr;
 219         }
 220
 221         if (IS_ERR(mirror->mirror_ds))
 222                 goto outerr;
 223
 224         if (mirror->mirror_ds->ds == NULL) {
 225                 struct nfs4_deviceid_node *devid;
 226                 devid = &mirror->mirror_ds->id_node;
 227                 ff_layout_mark_devid_invalid(lseg, devid);
 228                 return false;
 229         }
 230         return true;
 231 outerr:
 232         pnfs_error_mark_layout_for_return(lseg->pls_layout->plh_inode, lseg);
 233         return false;
 234 }
 235
 236 static void extend_ds_error(struct nfs4_ff_layout_ds_err *err,
 237                             u64 offset, u64 length)
 238 {
 239         u64 end;
 240
 241         end = max_t(u64, pnfs_end_offset(err->offset, err->length),
 242                     pnfs_end_offset(offset, length));
 243         err->offset = min_t(u64, err->offset, offset);
 244         err->length = end - err->offset;
 245 }
 246
 247 static int
 248 ff_ds_error_match(const struct nfs4_ff_layout_ds_err *e1,
 249                 const struct nfs4_ff_layout_ds_err *e2)
 250 {
 251         int ret;
 252
 253         if (e1->opnum != e2->opnum)
 254                 return e1->opnum < e2->opnum ? -1 : 1;
 255         if (e1->status != e2->status)
 256                 return e1->status < e2->status ? -1 : 1;
 257         ret = memcmp(e1->stateid.data, e2->stateid.data,
 258                         sizeof(e1->stateid.data));
 259         if (ret != 0)
 260                 return ret;
 261         ret = memcmp(&e1->deviceid, &e2->deviceid, sizeof(e1->deviceid));
 262         if (ret != 0)
 263                 return ret;
 264         if (pnfs_end_offset(e1->offset, e1->length) < e2->offset)
 265                 return -1;
 266         if (e1->offset > pnfs_end_offset(e2->offset, e2->length))
 267                 return 1;
 268         /* If ranges overlap or are contiguous, they are the same */
 269         return 0;
 270 }
 271
 272 static void
 273 ff_layout_add_ds_error_locked(struct nfs4_flexfile_layout *flo,
 274                               struct nfs4_ff_layout_ds_err *dserr)
 275 {
 276         struct nfs4_ff_layout_ds_err *err, *tmp;
 277         struct list_head *head = &flo->error_list;
 278         int match;
 279
 280         /* Do insertion sort w/ merges */
 281         list_for_each_entry_safe(err, tmp, &flo->error_list, list) {
 282                 match = ff_ds_error_match(err, dserr);
 283                 if (match < 0)
 284                         continue;
 285                 if (match > 0) {
 286                         /* Add entry "dserr" _before_ entry "err" */
 287                         head = &err->list;
 288                         break;
 289                 }
 290                 /* Entries match, so merge "err" into "dserr" */
 291                 extend_ds_error(dserr, err->offset, err->length);
 292                 list_replace(&err->list, &dserr->list);
 293                 kfree(err);
 294                 return;
 295         }
 296
 297         list_add_tail(&dserr->list, head);
 298 }
 299
 300 int ff_layout_track_ds_error(struct nfs4_flexfile_layout *flo,
 301                              struct nfs4_ff_layout_mirror *mirror, u64 offset,
 302                              u64 length, int status, enum nfs_opnum4 opnum,
 303                              gfp_t gfp_flags)
 304 {
 305         struct nfs4_ff_layout_ds_err *dserr;
 306
 307         if (status == 0)
 308                 return 0;
 309
 310         if (mirror->mirror_ds == NULL)
 311                 return -EINVAL;
 312
 313         dserr = kmalloc(sizeof(*dserr), gfp_flags);
 314         if (!dserr)
 315                 return -ENOMEM;
 316
 317         INIT_LIST_HEAD(&dserr->list);
 318         dserr->offset = offset;
 319         dserr->length = length;
 320         dserr->status = status;
 321         dserr->opnum = opnum;
 322         nfs4_stateid_copy(&dserr->stateid, &mirror->stateid);
 323         memcpy(&dserr->deviceid, &mirror->mirror_ds->id_node.deviceid,
 324                NFS4_DEVICEID4_SIZE);
 325
 326         spin_lock(&flo->generic_hdr.plh_inode->i_lock);
 327         ff_layout_add_ds_error_locked(flo, dserr);
 328         spin_unlock(&flo->generic_hdr.plh_inode->i_lock);
 329
 330         return 0;
 331 }
 332
 333 static const struct cred *
 334 ff_layout_get_mirror_cred(struct nfs4_ff_layout_mirror *mirror, u32 iomode)
 335 {
 336         const struct cred *cred, __rcu **pcred;
 337
 338         if (iomode == IOMODE_READ)
 339                 pcred = &mirror->ro_cred;
 340         else
 341                 pcred = &mirror->rw_cred;
 342
 343         rcu_read_lock();
 344         do {
 345                 cred = rcu_dereference(*pcred);
 346                 if (!cred)
 347                         break;
 348
 349                 cred = get_cred_rcu(cred);
 350         } while(!cred);
 351         rcu_read_unlock();
 352         return cred;
 353 }
 354
 355 struct nfs_fh *
 356 nfs4_ff_layout_select_ds_fh(struct pnfs_layout_segment *lseg, u32 mirror_idx)
 357 {
 358         struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, mirror_idx);
 359         struct nfs_fh *fh = NULL;
 360
 361         if (!ff_layout_mirror_valid(lseg, mirror, false)) {
 362                 pr_err_ratelimited("NFS: %s: No data server for mirror offset index %d\n",
 363                         __func__, mirror_idx);
 364                 goto out;
 365         }
 366
 367         /* FIXME: For now assume there is only 1 version available for the DS */
 368         fh = &mirror->fh_versions[0];
 369 out:
 370         return fh;
 371 }
 372
 373 int
 374 nfs4_ff_layout_select_ds_stateid(struct pnfs_layout_segment *lseg,
 375                                 u32 mirror_idx,
 376                                 nfs4_stateid *stateid)
 377 {
 378         struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, mirror_idx);
 379
 380         if (!ff_layout_mirror_valid(lseg, mirror, false)) {
 381                 pr_err_ratelimited("NFS: %s: No data server for mirror offset index %d\n",
 382                         __func__, mirror_idx);
 383                 goto out;
 384         }
 385
 386         nfs4_stateid_copy(stateid, &mirror->stateid);
 387         return 1;
 388 out:
 389         return 0;
 390 }
 391
 392 /**
 393  * nfs4_ff_layout_prepare_ds - prepare a DS connection for an RPC call
 394  * @lseg: the layout segment we're operating on
 395  * @ds_idx: index of the DS to use
 396  * @fail_return: return layout on connect failure?
 397  *
 398  * Try to prepare a DS connection to accept an RPC call. This involves
 399  * selecting a mirror to use and connecting the client to it if it's not
 400  * already connected.
 401  *
 402  * Since we only need a single functioning mirror to satisfy a read, we don't
 403  * want to return the layout if there is one. For writes though, any down
 404  * mirror should result in a LAYOUTRETURN. @fail_return is how we distinguish
 405  * between the two cases.
 406  *
 407  * Returns a pointer to a connected DS object on success or NULL on failure.
 408  */
 409 struct nfs4_pnfs_ds *
 410 nfs4_ff_layout_prepare_ds(struct pnfs_layout_segment *lseg, u32 ds_idx,
 411                           bool fail_return)
 412 {
 413         struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);
 414         struct nfs4_pnfs_ds *ds = NULL;
 415         struct nfs4_deviceid_node *devid;
 416         struct inode *ino = lseg->pls_layout->plh_inode;
 417         struct nfs_server *s = NFS_SERVER(ino);
 418         unsigned int max_payload;
 419         int status;
 420
 421         if (!ff_layout_mirror_valid(lseg, mirror, true)) {
 422                 pr_err_ratelimited("NFS: %s: No data server for offset index %d\n",
 423                         __func__, ds_idx);
 424                 goto out;
 425         }
 426
 427         devid = &mirror->mirror_ds->id_node;
 428         if (ff_layout_test_devid_unavailable(devid))
 429                 goto out_fail;
 430
 431         ds = mirror->mirror_ds->ds;
 432         /* matching smp_wmb() in _nfs4_pnfs_v3/4_ds_connect */
 433         smp_rmb();
 434         if (ds->ds_clp)
 435                 goto out;
 436
 437         /* FIXME: For now we assume the server sent only one version of NFS
 438          * to use for the DS.
 439          */
 440         status = nfs4_pnfs_ds_connect(s, ds, devid, dataserver_timeo,
 441                              dataserver_retrans,
 442                              mirror->mirror_ds->ds_versions[0].version,
 443                              mirror->mirror_ds->ds_versions[0].minor_version);
 444
 445         /* connect success, check rsize/wsize limit */
 446         if (!status) {
 447                 max_payload =
 448                         nfs_block_size(rpc_max_payload(ds->ds_clp->cl_rpcclient),
 449                                        NULL);
 450                 if (mirror->mirror_ds->ds_versions[0].rsize > max_payload)
 451                         mirror->mirror_ds->ds_versions[0].rsize = max_payload;
 452                 if (mirror->mirror_ds->ds_versions[0].wsize > max_payload)
 453                         mirror->mirror_ds->ds_versions[0].wsize = max_payload;
 454                 goto out;
 455         }
 456 out_fail:
 457         ff_layout_track_ds_error(FF_LAYOUT_FROM_HDR(lseg->pls_layout),
 458                                  mirror, lseg->pls_range.offset,
 459                                  lseg->pls_range.length, NFS4ERR_NXIO,
 460                                  OP_ILLEGAL, GFP_NOIO);
 461         if (fail_return || !ff_layout_has_available_ds(lseg))
 462                 pnfs_error_mark_layout_for_return(ino, lseg);
 463         ds = NULL;
 464 out:
 465         return ds;
 466 }
 467
 468 const struct cred *
 469 ff_layout_get_ds_cred(struct pnfs_layout_segment *lseg, u32 ds_idx,
 470                       const struct cred *mdscred)
 471 {
 472         struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);
 473         const struct cred *cred;
 474
 475         if (mirror && !mirror->mirror_ds->ds_versions[0].tightly_coupled) {
 476                 cred = ff_layout_get_mirror_cred(mirror, lseg->pls_range.iomode);
 477                 if (!cred)
 478                         cred = get_cred(mdscred);
 479         } else {
 480                 cred = get_cred(mdscred);
 481         }
 482         return cred;
 483 }
 484
 485 /**
 486  * nfs4_ff_find_or_create_ds_client - Find or create a DS rpc client
 487  * @lseg: pointer to layout segment
 488  * @ds_idx: mirror index
 489  * @ds_clp: nfs_client for the DS
 490  * @inode: pointer to inode
 491  *
 492  * Find or create a DS rpc client with th MDS server rpc client auth flavor
 493  * in the nfs_client cl_ds_clients list.
 494  */
 495 struct rpc_clnt *
 496 nfs4_ff_find_or_create_ds_client(struct pnfs_layout_segment *lseg, u32 ds_idx,
 497                                  struct nfs_client *ds_clp, struct inode *inode)
 498 {
 499         struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);
 500
 501         switch (mirror->mirror_ds->ds_versions[0].version) {
 502         case 3:
 503                 /* For NFSv3 DS, flavor is set when creating DS connections */
 504                 return ds_clp->cl_rpcclient;
 505         case 4:
 506                 return nfs4_find_or_create_ds_client(ds_clp, inode);
 507         default:
 508                 BUG();
 509         }
 510 }
 511
 512 void ff_layout_free_ds_ioerr(struct list_head *head)
 513 {
 514         struct nfs4_ff_layout_ds_err *err;
 515
 516         while (!list_empty(head)) {
 517                 err = list_first_entry(head,
 518                                 struct nfs4_ff_layout_ds_err,
 519                                 list);
 520                 list_del(&err->list);
 521                 kfree(err);
 522         }
 523 }
 524
 525 /* called with inode i_lock held */
 526 int ff_layout_encode_ds_ioerr(struct xdr_stream *xdr, const struct list_head *head)
 527 {
 528         struct nfs4_ff_layout_ds_err *err;
 529         __be32 *p;
 530
 531         list_for_each_entry(err, head, list) {
 532                 /* offset(8) + length(8) + stateid(NFS4_STATEID_SIZE)
 533                  * + array length + deviceid(NFS4_DEVICEID4_SIZE)
 534                  * + status(4) + opnum(4)
 535                  */
 536                 p = xdr_reserve_space(xdr,
 537                                 28 + NFS4_STATEID_SIZE + NFS4_DEVICEID4_SIZE);
 538                 if (unlikely(!p))
 539                         return -ENOBUFS;
 540                 p = xdr_encode_hyper(p, err->offset);
 541                 p = xdr_encode_hyper(p, err->length);
 542                 p = xdr_encode_opaque_fixed(p, &err->stateid,
 543                                             NFS4_STATEID_SIZE);
 544                 /* Encode 1 error */
 545                 *p++ = cpu_to_be32(1);
 546                 p = xdr_encode_opaque_fixed(p, &err->deviceid,
 547                                             NFS4_DEVICEID4_SIZE);
 548                 *p++ = cpu_to_be32(err->status);
 549                 *p++ = cpu_to_be32(err->opnum);
 550                 dprintk("%s: offset %llu length %llu status %d op %d\n",
 551                         __func__, err->offset, err->length, err->status,
 552                         err->opnum);
 553         }
 554
 555         return 0;
 556 }
 557
 558 static
 559 unsigned int do_layout_fetch_ds_ioerr(struct pnfs_layout_hdr *lo,
 560                                       const struct pnfs_layout_range *range,
 561                                       struct list_head *head,
 562                                       unsigned int maxnum)
 563 {
 564         struct nfs4_flexfile_layout *flo = FF_LAYOUT_FROM_HDR(lo);
 565         struct inode *inode = lo->plh_inode;
 566         struct nfs4_ff_layout_ds_err *err, *n;
 567         unsigned int ret = 0;
 568
 569         spin_lock(&inode->i_lock);
 570         list_for_each_entry_safe(err, n, &flo->error_list, list) {
 571                 if (!pnfs_is_range_intersecting(err->offset,
 572                                 pnfs_end_offset(err->offset, err->length),
 573                                 range->offset,
 574                                 pnfs_end_offset(range->offset, range->length)))
 575                         continue;
 576                 if (!maxnum)
 577                         break;
 578                 list_move(&err->list, head);
 579                 maxnum--;
 580                 ret++;
 581         }
 582         spin_unlock(&inode->i_lock);
 583         return ret;
 584 }
 585
 586 unsigned int ff_layout_fetch_ds_ioerr(struct pnfs_layout_hdr *lo,
 587                                       const struct pnfs_layout_range *range,
 588                                       struct list_head *head,
 589                                       unsigned int maxnum)
 590 {
 591         unsigned int ret;
 592
 593         ret = do_layout_fetch_ds_ioerr(lo, range, head, maxnum);
 594         /* If we're over the max, discard all remaining entries */
 595         if (ret == maxnum) {
 596                 LIST_HEAD(discard);
 597                 do_layout_fetch_ds_ioerr(lo, range, &discard, -1);
 598                 ff_layout_free_ds_ioerr(&discard);
 599         }
 600         return ret;
 601 }
 602
 603 static bool ff_read_layout_has_available_ds(struct pnfs_layout_segment *lseg)
 604 {
 605         struct nfs4_ff_layout_mirror *mirror;
 606         struct nfs4_deviceid_node *devid;
 607         u32 idx;
 608
 609         for (idx = 0; idx < FF_LAYOUT_MIRROR_COUNT(lseg); idx++) {
 610                 mirror = FF_LAYOUT_COMP(lseg, idx);
 611                 if (mirror) {
 612                         if (!mirror->mirror_ds)
 613                                 return true;
 614                         if (IS_ERR(mirror->mirror_ds))
 615                                 continue;
 616                         devid = &mirror->mirror_ds->id_node;
 617                         if (!ff_layout_test_devid_unavailable(devid))
 618                                 return true;
 619                 }
 620         }
 621
 622         return false;
 623 }
 624
 625 static bool ff_rw_layout_has_available_ds(struct pnfs_layout_segment *lseg)
 626 {
 627         struct nfs4_ff_layout_mirror *mirror;
 628         struct nfs4_deviceid_node *devid;
 629         u32 idx;
 630
 631         for (idx = 0; idx < FF_LAYOUT_MIRROR_COUNT(lseg); idx++) {
 632                 mirror = FF_LAYOUT_COMP(lseg, idx);
 633                 if (!mirror || IS_ERR(mirror->mirror_ds))
 634                         return false;
 635                 if (!mirror->mirror_ds)
 636                         continue;
 637                 devid = &mirror->mirror_ds->id_node;
 638                 if (ff_layout_test_devid_unavailable(devid))
 639                         return false;
 640         }
 641
 642         return FF_LAYOUT_MIRROR_COUNT(lseg) != 0;
 643 }
 644
 645 static bool ff_layout_has_available_ds(struct pnfs_layout_segment *lseg)
 646 {
 647         if (lseg->pls_range.iomode == IOMODE_READ)
 648                 return  ff_read_layout_has_available_ds(lseg);
 649         /* Note: RW layout needs all mirrors available */
 650         return ff_rw_layout_has_available_ds(lseg);
 651 }
 652
 653 bool ff_layout_avoid_mds_available_ds(struct pnfs_layout_segment *lseg)
 654 {
 655         return ff_layout_no_fallback_to_mds(lseg) ||
 656                ff_layout_has_available_ds(lseg);
 657 }
 658
 659 bool ff_layout_avoid_read_on_rw(struct pnfs_layout_segment *lseg)
 660 {
 661         return lseg->pls_range.iomode == IOMODE_RW &&
 662                ff_layout_no_read_on_rw(lseg);
 663 }
 664
 665 module_param(dataserver_retrans, uint, 0644);
 666 MODULE_PARM_DESC(dataserver_retrans, "The  number of times the NFSv4.1 client "
 667                         "retries a request before it attempts further "
 668                         " recovery  action.");
 669 module_param(dataserver_timeo, uint, 0644);
 670 MODULE_PARM_DESC(dataserver_timeo, "The time (in tenths of a second) the "
 671                         "NFSv4.1  client  waits for a response from a "
 672                         " data server before it retries an NFS request.");