fs/nfs/nfs4filelayoutdev.c

   1 /*
   2  *  Device operations for the pnfs nfs4 file layout driver.
   3  *
   4  *  Copyright (c) 2002
   5  *  The Regents of the University of Michigan
   6  *  All Rights Reserved
   7  *
   8  *  Dean Hildebrand <dhildebz@umich.edu>
   9  *  Garth Goodson   <Garth.Goodson@netapp.com>
  10  *
  11  *  Permission is granted to use, copy, create derivative works, and
  12  *  redistribute this software and such derivative works for any purpose,
  13  *  so long as the name of the University of Michigan is not used in
  14  *  any advertising or publicity pertaining to the use or distribution
  15  *  of this software without specific, written prior authorization. If
  16  *  the above copyright notice or any other identification of the
  17  *  University of Michigan is included in any copy of any portion of
  18  *  this software, then the disclaimer below must also be included.
  19  *
  20  *  This software is provided as is, without representation or warranty
  21  *  of any kind either express or implied, including without limitation
  22  *  the implied warranties of merchantability, fitness for a particular
  23  *  purpose, or noninfringement.  The Regents of the University of
  24  *  Michigan shall not be liable for any damages, including special,
  25  *  indirect, incidental, or consequential damages, with respect to any
  26  *  claim arising out of or in connection with the use of the software,
  27  *  even if it has been or is hereafter advised of the possibility of
  28  *  such damages.
  29  */
  30
  31 #include <linux/nfs_fs.h>
  32 #include <linux/vmalloc.h>
  33 #include <linux/module.h>
  34
  35 #include "internal.h"
  36 #include "nfs4session.h"
  37 #include "nfs4filelayout.h"
  38
  39 #define NFSDBG_FACILITY         NFSDBG_PNFS_LD
  40
  41 static unsigned int dataserver_timeo = NFS4_DEF_DS_TIMEO;
  42 static unsigned int dataserver_retrans = NFS4_DEF_DS_RETRANS;
  43
  44 /*
  45  * Data server cache
  46  *
  47  * Data servers can be mapped to different device ids.
  48  * nfs4_pnfs_ds reference counting
  49  *   - set to 1 on allocation
  50  *   - incremented when a device id maps a data server already in the cache.
  51  *   - decremented when deviceid is removed from the cache.
  52  */
  53 static DEFINE_SPINLOCK(nfs4_ds_cache_lock);
  54 static LIST_HEAD(nfs4_data_server_cache);
  55
  56 /* Debug routines */
  57 void
  58 print_ds(struct nfs4_pnfs_ds *ds)
  59 {
  60         if (ds == NULL) {
  61                 printk("%s NULL device\n", __func__);
  62                 return;
  63         }
  64         printk("        ds %s\n"
  65                 "        ref count %d\n"
  66                 "        client %p\n"
  67                 "        cl_exchange_flags %x\n",
  68                 ds->ds_remotestr,
  69                 atomic_read(&ds->ds_count), ds->ds_clp,
  70                 ds->ds_clp ? ds->ds_clp->cl_exchange_flags : 0);
  71 }
  72
  73 static bool
  74 same_sockaddr(struct sockaddr *addr1, struct sockaddr *addr2)
  75 {
  76         struct sockaddr_in *a, *b;
  77         struct sockaddr_in6 *a6, *b6;
  78
  79         if (addr1->sa_family != addr2->sa_family)
  80                 return false;
  81
  82         switch (addr1->sa_family) {
  83         case AF_INET:
  84                 a = (struct sockaddr_in *)addr1;
  85                 b = (struct sockaddr_in *)addr2;
  86
  87                 if (a->sin_addr.s_addr == b->sin_addr.s_addr &&
  88                     a->sin_port == b->sin_port)
  89                         return true;
  90                 break;
  91
  92         case AF_INET6:
  93                 a6 = (struct sockaddr_in6 *)addr1;
  94                 b6 = (struct sockaddr_in6 *)addr2;
  95
  96                 /* LINKLOCAL addresses must have matching scope_id */
  97                 if (ipv6_addr_scope(&a6->sin6_addr) ==
  98                     IPV6_ADDR_SCOPE_LINKLOCAL &&
  99                     a6->sin6_scope_id != b6->sin6_scope_id)
 100                         return false;
 101
 102                 if (ipv6_addr_equal(&a6->sin6_addr, &b6->sin6_addr) &&
 103                     a6->sin6_port == b6->sin6_port)
 104                         return true;
 105                 break;
 106
 107         default:
 108                 dprintk("%s: unhandled address family: %u\n",
 109                         __func__, addr1->sa_family);
 110                 return false;
 111         }
 112
 113         return false;
 114 }
 115
 116 static bool
 117 _same_data_server_addrs_locked(const struct list_head *dsaddrs1,
 118                                const struct list_head *dsaddrs2)
 119 {
 120         struct nfs4_pnfs_ds_addr *da1, *da2;
 121
 122         /* step through both lists, comparing as we go */
 123         for (da1 = list_first_entry(dsaddrs1, typeof(*da1), da_node),
 124              da2 = list_first_entry(dsaddrs2, typeof(*da2), da_node);
 125              da1 != NULL && da2 != NULL;
 126              da1 = list_entry(da1->da_node.next, typeof(*da1), da_node),
 127              da2 = list_entry(da2->da_node.next, typeof(*da2), da_node)) {
 128                 if (!same_sockaddr((struct sockaddr *)&da1->da_addr,
 129                                    (struct sockaddr *)&da2->da_addr))
 130                         return false;
 131         }
 132         if (da1 == NULL && da2 == NULL)
 133                 return true;
 134
 135         return false;
 136 }
 137
 138 /*
 139  * Lookup DS by addresses.  nfs4_ds_cache_lock is held
 140  */
 141 static struct nfs4_pnfs_ds *
 142 _data_server_lookup_locked(const struct list_head *dsaddrs)
 143 {
 144         struct nfs4_pnfs_ds *ds;
 145
 146         list_for_each_entry(ds, &nfs4_data_server_cache, ds_node)
 147                 if (_same_data_server_addrs_locked(&ds->ds_addrs, dsaddrs))
 148                         return ds;
 149         return NULL;
 150 }
 151
 152 /*
 153  * Create an rpc connection to the nfs4_pnfs_ds data server
 154  * Currently only supports IPv4 and IPv6 addresses
 155  */
 156 static int
 157 nfs4_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds)
 158 {
 159         struct nfs_client *clp = ERR_PTR(-EIO);
 160         struct nfs4_pnfs_ds_addr *da;
 161         int status = 0;
 162
 163         dprintk("--> %s DS %s au_flavor %d\n", __func__, ds->ds_remotestr,
 164                 mds_srv->nfs_client->cl_rpcclient->cl_auth->au_flavor);
 165
 166         list_for_each_entry(da, &ds->ds_addrs, da_node) {
 167                 dprintk("%s: DS %s: trying address %s\n",
 168                         __func__, ds->ds_remotestr, da->da_remotestr);
 169
 170                 clp = nfs4_set_ds_client(mds_srv->nfs_client,
 171                                         (struct sockaddr *)&da->da_addr,
 172                                         da->da_addrlen, IPPROTO_TCP,
 173                                         dataserver_timeo, dataserver_retrans);
 174                 if (!IS_ERR(clp))
 175                         break;
 176         }
 177
 178         if (IS_ERR(clp)) {
 179                 status = PTR_ERR(clp);
 180                 goto out;
 181         }
 182
 183         status = nfs4_init_ds_session(clp, mds_srv->nfs_client->cl_lease_time);
 184         if (status)
 185                 goto out_put;
 186
 187         ds->ds_clp = clp;
 188         dprintk("%s [new] addr: %s\n", __func__, ds->ds_remotestr);
 189 out:
 190         return status;
 191 out_put:
 192         nfs_put_client(clp);
 193         goto out;
 194 }
 195
 196 static void
 197 destroy_ds(struct nfs4_pnfs_ds *ds)
 198 {
 199         struct nfs4_pnfs_ds_addr *da;
 200
 201         dprintk("--> %s\n", __func__);
 202         ifdebug(FACILITY)
 203                 print_ds(ds);
 204
 205         if (ds->ds_clp)
 206                 nfs_put_client(ds->ds_clp);
 207
 208         while (!list_empty(&ds->ds_addrs)) {
 209                 da = list_first_entry(&ds->ds_addrs,
 210                                       struct nfs4_pnfs_ds_addr,
 211                                       da_node);
 212                 list_del_init(&da->da_node);
 213                 kfree(da->da_remotestr);
 214                 kfree(da);
 215         }
 216
 217         kfree(ds->ds_remotestr);
 218         kfree(ds);
 219 }
 220
 221 void
 222 nfs4_fl_free_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
 223 {
 224         struct nfs4_pnfs_ds *ds;
 225         int i;
 226
 227         nfs4_print_deviceid(&dsaddr->id_node.deviceid);
 228
 229         for (i = 0; i < dsaddr->ds_num; i++) {
 230                 ds = dsaddr->ds_list[i];
 231                 if (ds != NULL) {
 232                         if (atomic_dec_and_lock(&ds->ds_count,
 233                                                 &nfs4_ds_cache_lock)) {
 234                                 list_del_init(&ds->ds_node);
 235                                 spin_unlock(&nfs4_ds_cache_lock);
 236                                 destroy_ds(ds);
 237                         }
 238                 }
 239         }
 240         kfree(dsaddr->stripe_indices);
 241         kfree(dsaddr);
 242 }
 243
 244 /*
 245  * Create a string with a human readable address and port to avoid
 246  * complicated setup around many dprinks.
 247  */
 248 static char *
 249 nfs4_pnfs_remotestr(struct list_head *dsaddrs, gfp_t gfp_flags)
 250 {
 251         struct nfs4_pnfs_ds_addr *da;
 252         char *remotestr;
 253         size_t len;
 254         char *p;
 255
 256         len = 3;        /* '{', '}' and eol */
 257         list_for_each_entry(da, dsaddrs, da_node) {
 258                 len += strlen(da->da_remotestr) + 1;    /* string plus comma */
 259         }
 260
 261         remotestr = kzalloc(len, gfp_flags);
 262         if (!remotestr)
 263                 return NULL;
 264
 265         p = remotestr;
 266         *(p++) = '{';
 267         len--;
 268         list_for_each_entry(da, dsaddrs, da_node) {
 269                 size_t ll = strlen(da->da_remotestr);
 270
 271                 if (ll > len)
 272                         goto out_err;
 273
 274                 memcpy(p, da->da_remotestr, ll);
 275                 p += ll;
 276                 len -= ll;
 277
 278                 if (len < 1)
 279                         goto out_err;
 280                 (*p++) = ',';
 281                 len--;
 282         }
 283         if (len < 2)
 284                 goto out_err;
 285         *(p++) = '}';
 286         *p = '\0';
 287         return remotestr;
 288 out_err:
 289         kfree(remotestr);
 290         return NULL;
 291 }
 292
 293 static struct nfs4_pnfs_ds *
 294 nfs4_pnfs_ds_add(struct list_head *dsaddrs, gfp_t gfp_flags)
 295 {
 296         struct nfs4_pnfs_ds *tmp_ds, *ds = NULL;
 297         char *remotestr;
 298
 299         if (list_empty(dsaddrs)) {
 300                 dprintk("%s: no addresses defined\n", __func__);
 301                 goto out;
 302         }
 303
 304         ds = kzalloc(sizeof(*ds), gfp_flags);
 305         if (!ds)
 306                 goto out;
 307
 308         /* this is only used for debugging, so it's ok if its NULL */
 309         remotestr = nfs4_pnfs_remotestr(dsaddrs, gfp_flags);
 310
 311         spin_lock(&nfs4_ds_cache_lock);
 312         tmp_ds = _data_server_lookup_locked(dsaddrs);
 313         if (tmp_ds == NULL) {
 314                 INIT_LIST_HEAD(&ds->ds_addrs);
 315                 list_splice_init(dsaddrs, &ds->ds_addrs);
 316                 ds->ds_remotestr = remotestr;
 317                 atomic_set(&ds->ds_count, 1);
 318                 INIT_LIST_HEAD(&ds->ds_node);
 319                 ds->ds_clp = NULL;
 320                 list_add(&ds->ds_node, &nfs4_data_server_cache);
 321                 dprintk("%s add new data server %s\n", __func__,
 322                         ds->ds_remotestr);
 323         } else {
 324                 kfree(remotestr);
 325                 kfree(ds);
 326                 atomic_inc(&tmp_ds->ds_count);
 327                 dprintk("%s data server %s found, inc'ed ds_count to %d\n",
 328                         __func__, tmp_ds->ds_remotestr,
 329                         atomic_read(&tmp_ds->ds_count));
 330                 ds = tmp_ds;
 331         }
 332         spin_unlock(&nfs4_ds_cache_lock);
 333 out:
 334         return ds;
 335 }
 336
 337 /*
 338  * Currently only supports ipv4, ipv6 and one multi-path address.
 339  */
 340 static struct nfs4_pnfs_ds_addr *
 341 decode_ds_addr(struct net *net, struct xdr_stream *streamp, gfp_t gfp_flags)
 342 {
 343         struct nfs4_pnfs_ds_addr *da = NULL;
 344         char *buf, *portstr;
 345         __be16 port;
 346         int nlen, rlen;
 347         int tmp[2];
 348         __be32 *p;
 349         char *netid, *match_netid;
 350         size_t len, match_netid_len;
 351         char *startsep = "";
 352         char *endsep = "";
 353
 354
 355         /* r_netid */
 356         p = xdr_inline_decode(streamp, 4);
 357         if (unlikely(!p))
 358                 goto out_err;
 359         nlen = be32_to_cpup(p++);
 360
 361         p = xdr_inline_decode(streamp, nlen);
 362         if (unlikely(!p))
 363                 goto out_err;
 364
 365         netid = kmalloc(nlen+1, gfp_flags);
 366         if (unlikely(!netid))
 367                 goto out_err;
 368
 369         netid[nlen] = '\0';
 370         memcpy(netid, p, nlen);
 371
 372         /* r_addr: ip/ip6addr with port in dec octets - see RFC 5665 */
 373         p = xdr_inline_decode(streamp, 4);
 374         if (unlikely(!p))
 375                 goto out_free_netid;
 376         rlen = be32_to_cpup(p);
 377
 378         p = xdr_inline_decode(streamp, rlen);
 379         if (unlikely(!p))
 380                 goto out_free_netid;
 381
 382         /* port is ".ABC.DEF", 8 chars max */
 383         if (rlen > INET6_ADDRSTRLEN + IPV6_SCOPE_ID_LEN + 8) {
 384                 dprintk("%s: Invalid address, length %d\n", __func__,
 385                         rlen);
 386                 goto out_free_netid;
 387         }
 388         buf = kmalloc(rlen + 1, gfp_flags);
 389         if (!buf) {
 390                 dprintk("%s: Not enough memory\n", __func__);
 391                 goto out_free_netid;
 392         }
 393         buf[rlen] = '\0';
 394         memcpy(buf, p, rlen);
 395
 396         /* replace port '.' with '-' */
 397         portstr = strrchr(buf, '.');
 398         if (!portstr) {
 399                 dprintk("%s: Failed finding expected dot in port\n",
 400                         __func__);
 401                 goto out_free_buf;
 402         }
 403         *portstr = '-';
 404
 405         /* find '.' between address and port */
 406         portstr = strrchr(buf, '.');
 407         if (!portstr) {
 408                 dprintk("%s: Failed finding expected dot between address and "
 409                         "port\n", __func__);
 410                 goto out_free_buf;
 411         }
 412         *portstr = '\0';
 413
 414         da = kzalloc(sizeof(*da), gfp_flags);
 415         if (unlikely(!da))
 416                 goto out_free_buf;
 417
 418         INIT_LIST_HEAD(&da->da_node);
 419
 420         if (!rpc_pton(net, buf, portstr-buf, (struct sockaddr *)&da->da_addr,
 421                       sizeof(da->da_addr))) {
 422                 dprintk("%s: error parsing address %s\n", __func__, buf);
 423                 goto out_free_da;
 424         }
 425
 426         portstr++;
 427         sscanf(portstr, "%d-%d", &tmp[0], &tmp[1]);
 428         port = htons((tmp[0] << 8) | (tmp[1]));
 429
 430         switch (da->da_addr.ss_family) {
 431         case AF_INET:
 432                 ((struct sockaddr_in *)&da->da_addr)->sin_port = port;
 433                 da->da_addrlen = sizeof(struct sockaddr_in);
 434                 match_netid = "tcp";
 435                 match_netid_len = 3;
 436                 break;
 437
 438         case AF_INET6:
 439                 ((struct sockaddr_in6 *)&da->da_addr)->sin6_port = port;
 440                 da->da_addrlen = sizeof(struct sockaddr_in6);
 441                 match_netid = "tcp6";
 442                 match_netid_len = 4;
 443                 startsep = "[";
 444                 endsep = "]";
 445                 break;
 446
 447         default:
 448                 dprintk("%s: unsupported address family: %u\n",
 449                         __func__, da->da_addr.ss_family);
 450                 goto out_free_da;
 451         }
 452
 453         if (nlen != match_netid_len || strncmp(netid, match_netid, nlen)) {
 454                 dprintk("%s: ERROR: r_netid \"%s\" != \"%s\"\n",
 455                         __func__, netid, match_netid);
 456                 goto out_free_da;
 457         }
 458
 459         /* save human readable address */
 460         len = strlen(startsep) + strlen(buf) + strlen(endsep) + 7;
 461         da->da_remotestr = kzalloc(len, gfp_flags);
 462
 463         /* NULL is ok, only used for dprintk */
 464         if (da->da_remotestr)
 465                 snprintf(da->da_remotestr, len, "%s%s%s:%u", startsep,
 466                          buf, endsep, ntohs(port));
 467
 468         dprintk("%s: Parsed DS addr %s\n", __func__, da->da_remotestr);
 469         kfree(buf);
 470         kfree(netid);
 471         return da;
 472
 473 out_free_da:
 474         kfree(da);
 475 out_free_buf:
 476         dprintk("%s: Error parsing DS addr: %s\n", __func__, buf);
 477         kfree(buf);
 478 out_free_netid:
 479         kfree(netid);
 480 out_err:
 481         return NULL;
 482 }
 483
 484 /* Decode opaque device data and return the result */
 485 static struct nfs4_file_layout_dsaddr*
 486 decode_device(struct inode *ino, struct pnfs_device *pdev, gfp_t gfp_flags)
 487 {
 488         int i;
 489         u32 cnt, num;
 490         u8 *indexp;
 491         __be32 *p;
 492         u8 *stripe_indices;
 493         u8 max_stripe_index;
 494         struct nfs4_file_layout_dsaddr *dsaddr = NULL;
 495         struct xdr_stream stream;
 496         struct xdr_buf buf;
 497         struct page *scratch;
 498         struct list_head dsaddrs;
 499         struct nfs4_pnfs_ds_addr *da;
 500
 501         /* set up xdr stream */
 502         scratch = alloc_page(gfp_flags);
 503         if (!scratch)
 504                 goto out_err;
 505
 506         xdr_init_decode_pages(&stream, &buf, pdev->pages, pdev->pglen);
 507         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
 508
 509         /* Get the stripe count (number of stripe index) */
 510         p = xdr_inline_decode(&stream, 4);
 511         if (unlikely(!p))
 512                 goto out_err_free_scratch;
 513
 514         cnt = be32_to_cpup(p);
 515         dprintk("%s stripe count  %d\n", __func__, cnt);
 516         if (cnt > NFS4_PNFS_MAX_STRIPE_CNT) {
 517                 printk(KERN_WARNING "NFS: %s: stripe count %d greater than "
 518                        "supported maximum %d\n", __func__,
 519                         cnt, NFS4_PNFS_MAX_STRIPE_CNT);
 520                 goto out_err_free_scratch;
 521         }
 522
 523         /* read stripe indices */
 524         stripe_indices = kcalloc(cnt, sizeof(u8), gfp_flags);
 525         if (!stripe_indices)
 526                 goto out_err_free_scratch;
 527
 528         p = xdr_inline_decode(&stream, cnt << 2);
 529         if (unlikely(!p))
 530                 goto out_err_free_stripe_indices;
 531
 532         indexp = &stripe_indices[0];
 533         max_stripe_index = 0;
 534         for (i = 0; i < cnt; i++) {
 535                 *indexp = be32_to_cpup(p++);
 536                 max_stripe_index = max(max_stripe_index, *indexp);
 537                 indexp++;
 538         }
 539
 540         /* Check the multipath list count */
 541         p = xdr_inline_decode(&stream, 4);
 542         if (unlikely(!p))
 543                 goto out_err_free_stripe_indices;
 544
 545         num = be32_to_cpup(p);
 546         dprintk("%s ds_num %u\n", __func__, num);
 547         if (num > NFS4_PNFS_MAX_MULTI_CNT) {
 548                 printk(KERN_WARNING "NFS: %s: multipath count %d greater than "
 549                         "supported maximum %d\n", __func__,
 550                         num, NFS4_PNFS_MAX_MULTI_CNT);
 551                 goto out_err_free_stripe_indices;
 552         }
 553
 554         /* validate stripe indices are all < num */
 555         if (max_stripe_index >= num) {
 556                 printk(KERN_WARNING "NFS: %s: stripe index %u >= num ds %u\n",
 557                         __func__, max_stripe_index, num);
 558                 goto out_err_free_stripe_indices;
 559         }
 560
 561         dsaddr = kzalloc(sizeof(*dsaddr) +
 562                         (sizeof(struct nfs4_pnfs_ds *) * (num - 1)),
 563                         gfp_flags);
 564         if (!dsaddr)
 565                 goto out_err_free_stripe_indices;
 566
 567         dsaddr->stripe_count = cnt;
 568         dsaddr->stripe_indices = stripe_indices;
 569         stripe_indices = NULL;
 570         dsaddr->ds_num = num;
 571         nfs4_init_deviceid_node(&dsaddr->id_node,
 572                                 NFS_SERVER(ino)->pnfs_curr_ld,
 573                                 NFS_SERVER(ino)->nfs_client,
 574                                 &pdev->dev_id);
 575
 576         INIT_LIST_HEAD(&dsaddrs);
 577
 578         for (i = 0; i < dsaddr->ds_num; i++) {
 579                 int j;
 580                 u32 mp_count;
 581
 582                 p = xdr_inline_decode(&stream, 4);
 583                 if (unlikely(!p))
 584                         goto out_err_free_deviceid;
 585
 586                 mp_count = be32_to_cpup(p); /* multipath count */
 587                 for (j = 0; j < mp_count; j++) {
 588                         da = decode_ds_addr(NFS_SERVER(ino)->nfs_client->cl_net,
 589                                             &stream, gfp_flags);
 590                         if (da)
 591                                 list_add_tail(&da->da_node, &dsaddrs);
 592                 }
 593                 if (list_empty(&dsaddrs)) {
 594                         dprintk("%s: no suitable DS addresses found\n",
 595                                 __func__);
 596                         goto out_err_free_deviceid;
 597                 }
 598
 599                 dsaddr->ds_list[i] = nfs4_pnfs_ds_add(&dsaddrs, gfp_flags);
 600                 if (!dsaddr->ds_list[i])
 601                         goto out_err_drain_dsaddrs;
 602
 603                 /* If DS was already in cache, free ds addrs */
 604                 while (!list_empty(&dsaddrs)) {
 605                         da = list_first_entry(&dsaddrs,
 606                                               struct nfs4_pnfs_ds_addr,
 607                                               da_node);
 608                         list_del_init(&da->da_node);
 609                         kfree(da->da_remotestr);
 610                         kfree(da);
 611                 }
 612         }
 613
 614         __free_page(scratch);
 615         return dsaddr;
 616
 617 out_err_drain_dsaddrs:
 618         while (!list_empty(&dsaddrs)) {
 619                 da = list_first_entry(&dsaddrs, struct nfs4_pnfs_ds_addr,
 620                                       da_node);
 621                 list_del_init(&da->da_node);
 622                 kfree(da->da_remotestr);
 623                 kfree(da);
 624         }
 625 out_err_free_deviceid:
 626         nfs4_fl_free_deviceid(dsaddr);
 627         /* stripe_indicies was part of dsaddr */
 628         goto out_err_free_scratch;
 629 out_err_free_stripe_indices:
 630         kfree(stripe_indices);
 631 out_err_free_scratch:
 632         __free_page(scratch);
 633 out_err:
 634         dprintk("%s ERROR: returning NULL\n", __func__);
 635         return NULL;
 636 }
 637
 638 /*
 639  * Decode the opaque device specified in 'dev' and add it to the cache of
 640  * available devices.
 641  */
 642 static struct nfs4_file_layout_dsaddr *
 643 decode_and_add_device(struct inode *inode, struct pnfs_device *dev, gfp_t gfp_flags)
 644 {
 645         struct nfs4_deviceid_node *d;
 646         struct nfs4_file_layout_dsaddr *n, *new;
 647
 648         new = decode_device(inode, dev, gfp_flags);
 649         if (!new) {
 650                 printk(KERN_WARNING "NFS: %s: Could not decode or add device\n",
 651                         __func__);
 652                 return NULL;
 653         }
 654
 655         d = nfs4_insert_deviceid_node(&new->id_node);
 656         n = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
 657         if (n != new) {
 658                 nfs4_fl_free_deviceid(new);
 659                 return n;
 660         }
 661
 662         return new;
 663 }
 664
 665 /*
 666  * Retrieve the information for dev_id, add it to the list
 667  * of available devices, and return it.
 668  */
 669 struct nfs4_file_layout_dsaddr *
 670 filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gfp_t gfp_flags)
 671 {
 672         struct pnfs_device *pdev = NULL;
 673         u32 max_resp_sz;
 674         int max_pages;
 675         struct page **pages = NULL;
 676         struct nfs4_file_layout_dsaddr *dsaddr = NULL;
 677         int rc, i;
 678         struct nfs_server *server = NFS_SERVER(inode);
 679
 680         /*
 681          * Use the session max response size as the basis for setting
 682          * GETDEVICEINFO's maxcount
 683          */
 684         max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
 685         max_pages = nfs_page_array_len(0, max_resp_sz);
 686         dprintk("%s inode %p max_resp_sz %u max_pages %d\n",
 687                 __func__, inode, max_resp_sz, max_pages);
 688
 689         pdev = kzalloc(sizeof(struct pnfs_device), gfp_flags);
 690         if (pdev == NULL)
 691                 return NULL;
 692
 693         pages = kzalloc(max_pages * sizeof(struct page *), gfp_flags);
 694         if (pages == NULL) {
 695                 kfree(pdev);
 696                 return NULL;
 697         }
 698         for (i = 0; i < max_pages; i++) {
 699                 pages[i] = alloc_page(gfp_flags);
 700                 if (!pages[i])
 701                         goto out_free;
 702         }
 703
 704         memcpy(&pdev->dev_id, dev_id, sizeof(*dev_id));
 705         pdev->layout_type = LAYOUT_NFSV4_1_FILES;
 706         pdev->pages = pages;
 707         pdev->pgbase = 0;
 708         pdev->pglen = max_resp_sz;
 709         pdev->mincount = 0;
 710
 711         rc = nfs4_proc_getdeviceinfo(server, pdev);
 712         dprintk("%s getdevice info returns %d\n", __func__, rc);
 713         if (rc)
 714                 goto out_free;
 715
 716         /*
 717          * Found new device, need to decode it and then add it to the
 718          * list of known devices for this mountpoint.
 719          */
 720         dsaddr = decode_and_add_device(inode, pdev, gfp_flags);
 721 out_free:
 722         for (i = 0; i < max_pages; i++)
 723                 __free_page(pages[i]);
 724         kfree(pages);
 725         kfree(pdev);
 726         dprintk("<-- %s dsaddr %p\n", __func__, dsaddr);
 727         return dsaddr;
 728 }
 729
 730 void
 731 nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
 732 {
 733         nfs4_put_deviceid_node(&dsaddr->id_node);
 734 }
 735
 736 /*
 737  * Want res = (offset - layout->pattern_offset)/ layout->stripe_unit
 738  * Then: ((res + fsi) % dsaddr->stripe_count)
 739  */
 740 u32
 741 nfs4_fl_calc_j_index(struct pnfs_layout_segment *lseg, loff_t offset)
 742 {
 743         struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
 744         u64 tmp;
 745
 746         tmp = offset - flseg->pattern_offset;
 747         do_div(tmp, flseg->stripe_unit);
 748         tmp += flseg->first_stripe_index;
 749         return do_div(tmp, flseg->dsaddr->stripe_count);
 750 }
 751
 752 u32
 753 nfs4_fl_calc_ds_index(struct pnfs_layout_segment *lseg, u32 j)
 754 {
 755         return FILELAYOUT_LSEG(lseg)->dsaddr->stripe_indices[j];
 756 }
 757
 758 struct nfs_fh *
 759 nfs4_fl_select_ds_fh(struct pnfs_layout_segment *lseg, u32 j)
 760 {
 761         struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
 762         u32 i;
 763
 764         if (flseg->stripe_type == STRIPE_SPARSE) {
 765                 if (flseg->num_fh == 1)
 766                         i = 0;
 767                 else if (flseg->num_fh == 0)
 768                         /* Use the MDS OPEN fh set in nfs_read_rpcsetup */
 769                         return NULL;
 770                 else
 771                         i = nfs4_fl_calc_ds_index(lseg, j);
 772         } else
 773                 i = j;
 774         return flseg->fh_array[i];
 775 }
 776
 777 struct nfs4_pnfs_ds *
 778 nfs4_fl_prepare_ds(struct pnfs_layout_segment *lseg, u32 ds_idx)
 779 {
 780         struct nfs4_file_layout_dsaddr *dsaddr = FILELAYOUT_LSEG(lseg)->dsaddr;
 781         struct nfs4_pnfs_ds *ds = dsaddr->ds_list[ds_idx];
 782         struct nfs4_deviceid_node *devid = FILELAYOUT_DEVID_NODE(lseg);
 783
 784         if (filelayout_test_devid_unavailable(devid))
 785                 return NULL;
 786
 787         if (ds == NULL) {
 788                 printk(KERN_ERR "NFS: %s: No data server for offset index %d\n",
 789                         __func__, ds_idx);
 790                 filelayout_mark_devid_invalid(devid);
 791                 return NULL;
 792         }
 793
 794         if (!ds->ds_clp) {
 795                 struct nfs_server *s = NFS_SERVER(lseg->pls_layout->plh_inode);
 796                 int err;
 797
 798                 err = nfs4_ds_connect(s, ds);
 799                 if (err) {
 800                         nfs4_mark_deviceid_unavailable(devid);
 801                         return NULL;
 802                 }
 803         }
 804         return ds;
 805 }
 806
 807 module_param(dataserver_retrans, uint, 0644);
 808 MODULE_PARM_DESC(dataserver_retrans, "The  number of times the NFSv4.1 client "
 809                         "retries a request before it attempts further "
 810                         " recovery  action.");
 811 module_param(dataserver_timeo, uint, 0644);
 812 MODULE_PARM_DESC(dataserver_timeo, "The time (in tenths of a second) the "
 813                         "NFSv4.1  client  waits for a response from a "
 814                         " data server before it retries an NFS request.");