fs/nfs/flexfilelayout/flexfilelayoutdev.c

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