2 * Device operations for the pnfs nfs4 file layout driver.
5 * The Regents of the University of Michigan
8 * Dean Hildebrand <dhildebz@umich.edu>
9 * Garth Goodson <Garth.Goodson@netapp.com>
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.
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
31 #include <linux/nfs_fs.h>
32 #include <linux/vmalloc.h>
33 #include <linux/module.h>
36 #include "nfs4session.h"
37 #include "nfs4filelayout.h"
39 #define NFSDBG_FACILITY NFSDBG_PNFS_LD
41 static unsigned int dataserver_timeo = NFS4_DEF_DS_TIMEO;
42 static unsigned int dataserver_retrans = NFS4_DEF_DS_RETRANS;
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.
53 static DEFINE_SPINLOCK(nfs4_ds_cache_lock);
54 static LIST_HEAD(nfs4_data_server_cache);
58 print_ds(struct nfs4_pnfs_ds *ds)
61 printk("%s NULL device\n", __func__);
67 " cl_exchange_flags %x\n",
69 atomic_read(&ds->ds_count), ds->ds_clp,
70 ds->ds_clp ? ds->ds_clp->cl_exchange_flags : 0);
74 same_sockaddr(struct sockaddr *addr1, struct sockaddr *addr2)
76 struct sockaddr_in *a, *b;
77 struct sockaddr_in6 *a6, *b6;
79 if (addr1->sa_family != addr2->sa_family)
82 switch (addr1->sa_family) {
84 a = (struct sockaddr_in *)addr1;
85 b = (struct sockaddr_in *)addr2;
87 if (a->sin_addr.s_addr == b->sin_addr.s_addr &&
88 a->sin_port == b->sin_port)
93 a6 = (struct sockaddr_in6 *)addr1;
94 b6 = (struct sockaddr_in6 *)addr2;
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)
102 if (ipv6_addr_equal(&a6->sin6_addr, &b6->sin6_addr) &&
103 a6->sin6_port == b6->sin6_port)
108 dprintk("%s: unhandled address family: %u\n",
109 __func__, addr1->sa_family);
117 _same_data_server_addrs_locked(const struct list_head *dsaddrs1,
118 const struct list_head *dsaddrs2)
120 struct nfs4_pnfs_ds_addr *da1, *da2;
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))
132 if (da1 == NULL && da2 == NULL)
139 * Lookup DS by addresses. nfs4_ds_cache_lock is held
141 static struct nfs4_pnfs_ds *
142 _data_server_lookup_locked(const struct list_head *dsaddrs)
144 struct nfs4_pnfs_ds *ds;
146 list_for_each_entry(ds, &nfs4_data_server_cache, ds_node)
147 if (_same_data_server_addrs_locked(&ds->ds_addrs, dsaddrs))
153 * Create an rpc connection to the nfs4_pnfs_ds data server
154 * Currently only supports IPv4 and IPv6 addresses
157 nfs4_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds)
159 struct nfs_client *clp = ERR_PTR(-EIO);
160 struct nfs4_pnfs_ds_addr *da;
163 dprintk("--> %s DS %s au_flavor %d\n", __func__, ds->ds_remotestr,
164 mds_srv->nfs_client->cl_rpcclient->cl_auth->au_flavor);
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);
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);
179 status = PTR_ERR(clp);
183 status = nfs4_init_ds_session(clp, mds_srv->nfs_client->cl_lease_time);
188 dprintk("%s [new] addr: %s\n", __func__, ds->ds_remotestr);
197 destroy_ds(struct nfs4_pnfs_ds *ds)
199 struct nfs4_pnfs_ds_addr *da;
201 dprintk("--> %s\n", __func__);
206 nfs_put_client(ds->ds_clp);
208 while (!list_empty(&ds->ds_addrs)) {
209 da = list_first_entry(&ds->ds_addrs,
210 struct nfs4_pnfs_ds_addr,
212 list_del_init(&da->da_node);
213 kfree(da->da_remotestr);
217 kfree(ds->ds_remotestr);
222 nfs4_fl_free_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
224 struct nfs4_pnfs_ds *ds;
227 nfs4_print_deviceid(&dsaddr->id_node.deviceid);
229 for (i = 0; i < dsaddr->ds_num; i++) {
230 ds = dsaddr->ds_list[i];
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);
240 kfree(dsaddr->stripe_indices);
245 * Create a string with a human readable address and port to avoid
246 * complicated setup around many dprinks.
249 nfs4_pnfs_remotestr(struct list_head *dsaddrs, gfp_t gfp_flags)
251 struct nfs4_pnfs_ds_addr *da;
256 len = 3; /* '{', '}' and eol */
257 list_for_each_entry(da, dsaddrs, da_node) {
258 len += strlen(da->da_remotestr) + 1; /* string plus comma */
261 remotestr = kzalloc(len, gfp_flags);
268 list_for_each_entry(da, dsaddrs, da_node) {
269 size_t ll = strlen(da->da_remotestr);
274 memcpy(p, da->da_remotestr, ll);
293 static struct nfs4_pnfs_ds *
294 nfs4_pnfs_ds_add(struct list_head *dsaddrs, gfp_t gfp_flags)
296 struct nfs4_pnfs_ds *tmp_ds, *ds = NULL;
299 if (list_empty(dsaddrs)) {
300 dprintk("%s: no addresses defined\n", __func__);
304 ds = kzalloc(sizeof(*ds), gfp_flags);
308 /* this is only used for debugging, so it's ok if its NULL */
309 remotestr = nfs4_pnfs_remotestr(dsaddrs, gfp_flags);
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);
320 list_add(&ds->ds_node, &nfs4_data_server_cache);
321 dprintk("%s add new data server %s\n", __func__,
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));
332 spin_unlock(&nfs4_ds_cache_lock);
338 * Currently only supports ipv4, ipv6 and one multi-path address.
340 static struct nfs4_pnfs_ds_addr *
341 decode_ds_addr(struct net *net, struct xdr_stream *streamp, gfp_t gfp_flags)
343 struct nfs4_pnfs_ds_addr *da = NULL;
349 char *netid, *match_netid;
350 size_t len, match_netid_len;
356 p = xdr_inline_decode(streamp, 4);
359 nlen = be32_to_cpup(p++);
361 p = xdr_inline_decode(streamp, nlen);
365 netid = kmalloc(nlen+1, gfp_flags);
366 if (unlikely(!netid))
370 memcpy(netid, p, nlen);
372 /* r_addr: ip/ip6addr with port in dec octets - see RFC 5665 */
373 p = xdr_inline_decode(streamp, 4);
376 rlen = be32_to_cpup(p);
378 p = xdr_inline_decode(streamp, rlen);
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__,
388 buf = kmalloc(rlen + 1, gfp_flags);
390 dprintk("%s: Not enough memory\n", __func__);
394 memcpy(buf, p, rlen);
396 /* replace port '.' with '-' */
397 portstr = strrchr(buf, '.');
399 dprintk("%s: Failed finding expected dot in port\n",
405 /* find '.' between address and port */
406 portstr = strrchr(buf, '.');
408 dprintk("%s: Failed finding expected dot between address and "
414 da = kzalloc(sizeof(*da), gfp_flags);
418 INIT_LIST_HEAD(&da->da_node);
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);
427 sscanf(portstr, "%d-%d", &tmp[0], &tmp[1]);
428 port = htons((tmp[0] << 8) | (tmp[1]));
430 switch (da->da_addr.ss_family) {
432 ((struct sockaddr_in *)&da->da_addr)->sin_port = port;
433 da->da_addrlen = sizeof(struct sockaddr_in);
439 ((struct sockaddr_in6 *)&da->da_addr)->sin6_port = port;
440 da->da_addrlen = sizeof(struct sockaddr_in6);
441 match_netid = "tcp6";
448 dprintk("%s: unsupported address family: %u\n",
449 __func__, da->da_addr.ss_family);
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);
459 /* save human readable address */
460 len = strlen(startsep) + strlen(buf) + strlen(endsep) + 7;
461 da->da_remotestr = kzalloc(len, gfp_flags);
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));
468 dprintk("%s: Parsed DS addr %s\n", __func__, da->da_remotestr);
476 dprintk("%s: Error parsing DS addr: %s\n", __func__, buf);
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)
494 struct nfs4_file_layout_dsaddr *dsaddr = NULL;
495 struct xdr_stream stream;
497 struct page *scratch;
498 struct list_head dsaddrs;
499 struct nfs4_pnfs_ds_addr *da;
501 /* set up xdr stream */
502 scratch = alloc_page(gfp_flags);
506 xdr_init_decode_pages(&stream, &buf, pdev->pages, pdev->pglen);
507 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
509 /* Get the stripe count (number of stripe index) */
510 p = xdr_inline_decode(&stream, 4);
512 goto out_err_free_scratch;
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;
523 /* read stripe indices */
524 stripe_indices = kcalloc(cnt, sizeof(u8), gfp_flags);
526 goto out_err_free_scratch;
528 p = xdr_inline_decode(&stream, cnt << 2);
530 goto out_err_free_stripe_indices;
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);
540 /* Check the multipath list count */
541 p = xdr_inline_decode(&stream, 4);
543 goto out_err_free_stripe_indices;
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;
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;
561 dsaddr = kzalloc(sizeof(*dsaddr) +
562 (sizeof(struct nfs4_pnfs_ds *) * (num - 1)),
565 goto out_err_free_stripe_indices;
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,
576 INIT_LIST_HEAD(&dsaddrs);
578 for (i = 0; i < dsaddr->ds_num; i++) {
582 p = xdr_inline_decode(&stream, 4);
584 goto out_err_free_deviceid;
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,
591 list_add_tail(&da->da_node, &dsaddrs);
593 if (list_empty(&dsaddrs)) {
594 dprintk("%s: no suitable DS addresses found\n",
596 goto out_err_free_deviceid;
599 dsaddr->ds_list[i] = nfs4_pnfs_ds_add(&dsaddrs, gfp_flags);
600 if (!dsaddr->ds_list[i])
601 goto out_err_drain_dsaddrs;
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,
608 list_del_init(&da->da_node);
609 kfree(da->da_remotestr);
614 __free_page(scratch);
617 out_err_drain_dsaddrs:
618 while (!list_empty(&dsaddrs)) {
619 da = list_first_entry(&dsaddrs, struct nfs4_pnfs_ds_addr,
621 list_del_init(&da->da_node);
622 kfree(da->da_remotestr);
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);
634 dprintk("%s ERROR: returning NULL\n", __func__);
639 * Decode the opaque device specified in 'dev' and add it to the cache of
642 static struct nfs4_file_layout_dsaddr *
643 decode_and_add_device(struct inode *inode, struct pnfs_device *dev, gfp_t gfp_flags)
645 struct nfs4_deviceid_node *d;
646 struct nfs4_file_layout_dsaddr *n, *new;
648 new = decode_device(inode, dev, gfp_flags);
650 printk(KERN_WARNING "NFS: %s: Could not decode or add device\n",
655 d = nfs4_insert_deviceid_node(&new->id_node);
656 n = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
658 nfs4_fl_free_deviceid(new);
666 * Retrieve the information for dev_id, add it to the list
667 * of available devices, and return it.
669 struct nfs4_file_layout_dsaddr *
670 filelayout_get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gfp_t gfp_flags)
672 struct pnfs_device *pdev = NULL;
675 struct page **pages = NULL;
676 struct nfs4_file_layout_dsaddr *dsaddr = NULL;
678 struct nfs_server *server = NFS_SERVER(inode);
681 * Use the session max response size as the basis for setting
682 * GETDEVICEINFO's maxcount
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);
689 pdev = kzalloc(sizeof(struct pnfs_device), gfp_flags);
693 pages = kzalloc(max_pages * sizeof(struct page *), gfp_flags);
698 for (i = 0; i < max_pages; i++) {
699 pages[i] = alloc_page(gfp_flags);
704 memcpy(&pdev->dev_id, dev_id, sizeof(*dev_id));
705 pdev->layout_type = LAYOUT_NFSV4_1_FILES;
708 pdev->pglen = max_resp_sz;
711 rc = nfs4_proc_getdeviceinfo(server, pdev);
712 dprintk("%s getdevice info returns %d\n", __func__, rc);
717 * Found new device, need to decode it and then add it to the
718 * list of known devices for this mountpoint.
720 dsaddr = decode_and_add_device(inode, pdev, gfp_flags);
722 for (i = 0; i < max_pages; i++)
723 __free_page(pages[i]);
726 dprintk("<-- %s dsaddr %p\n", __func__, dsaddr);
731 nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
733 nfs4_put_deviceid_node(&dsaddr->id_node);
737 * Want res = (offset - layout->pattern_offset)/ layout->stripe_unit
738 * Then: ((res + fsi) % dsaddr->stripe_count)
741 nfs4_fl_calc_j_index(struct pnfs_layout_segment *lseg, loff_t offset)
743 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
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);
753 nfs4_fl_calc_ds_index(struct pnfs_layout_segment *lseg, u32 j)
755 return FILELAYOUT_LSEG(lseg)->dsaddr->stripe_indices[j];
759 nfs4_fl_select_ds_fh(struct pnfs_layout_segment *lseg, u32 j)
761 struct nfs4_filelayout_segment *flseg = FILELAYOUT_LSEG(lseg);
764 if (flseg->stripe_type == STRIPE_SPARSE) {
765 if (flseg->num_fh == 1)
767 else if (flseg->num_fh == 0)
768 /* Use the MDS OPEN fh set in nfs_read_rpcsetup */
771 i = nfs4_fl_calc_ds_index(lseg, j);
774 return flseg->fh_array[i];
777 struct nfs4_pnfs_ds *
778 nfs4_fl_prepare_ds(struct pnfs_layout_segment *lseg, u32 ds_idx)
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);
784 if (filelayout_test_devid_unavailable(devid))
788 printk(KERN_ERR "NFS: %s: No data server for offset index %d\n",
790 filelayout_mark_devid_invalid(devid);
795 struct nfs_server *s = NFS_SERVER(lseg->pls_layout->plh_inode);
798 err = nfs4_ds_connect(s, ds);
800 nfs4_mark_deviceid_unavailable(devid);
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.");