2 * Common NFS I/O operations for the pnfs file based
5 * Copyright (c) 2014, Primary Data, Inc. All rights reserved.
7 * Tom Haynes <loghyr@primarydata.com>
10 #include <linux/nfs_fs.h>
11 #include <linux/nfs_page.h>
12 #include <linux/sunrpc/addr.h>
13 #include <linux/module.h>
15 #include "nfs4session.h"
19 #define NFSDBG_FACILITY NFSDBG_PNFS
21 void pnfs_generic_rw_release(void *data
)
23 struct nfs_pgio_header
*hdr
= data
;
25 nfs_put_client(hdr
->ds_clp
);
26 hdr
->mds_ops
->rpc_release(data
);
28 EXPORT_SYMBOL_GPL(pnfs_generic_rw_release
);
30 /* Fake up some data that will cause nfs_commit_release to retry the writes. */
31 void pnfs_generic_prepare_to_resend_writes(struct nfs_commit_data
*data
)
33 struct nfs_page
*first
= nfs_list_entry(data
->pages
.next
);
35 data
->task
.tk_status
= 0;
36 memcpy(&data
->verf
.verifier
, &first
->wb_verf
,
37 sizeof(data
->verf
.verifier
));
38 data
->verf
.verifier
.data
[0]++; /* ensure verifier mismatch */
40 EXPORT_SYMBOL_GPL(pnfs_generic_prepare_to_resend_writes
);
42 void pnfs_generic_write_commit_done(struct rpc_task
*task
, void *data
)
44 struct nfs_commit_data
*wdata
= data
;
46 /* Note this may cause RPC to be resent */
47 wdata
->mds_ops
->rpc_call_done(task
, data
);
49 EXPORT_SYMBOL_GPL(pnfs_generic_write_commit_done
);
51 void pnfs_generic_commit_release(void *calldata
)
53 struct nfs_commit_data
*data
= calldata
;
55 data
->completion_ops
->completion(data
);
56 pnfs_put_lseg(data
->lseg
);
57 nfs_put_client(data
->ds_clp
);
58 nfs_commitdata_release(data
);
60 EXPORT_SYMBOL_GPL(pnfs_generic_commit_release
);
62 /* The generic layer is about to remove the req from the commit list.
63 * If this will make the bucket empty, it will need to put the lseg reference.
64 * Note this must be called holding i_lock
67 pnfs_generic_clear_request_commit(struct nfs_page
*req
,
68 struct nfs_commit_info
*cinfo
)
70 struct pnfs_layout_segment
*freeme
= NULL
;
72 if (!test_and_clear_bit(PG_COMMIT_TO_DS
, &req
->wb_flags
))
74 cinfo
->ds
->nwritten
--;
75 if (list_is_singular(&req
->wb_list
)) {
76 struct pnfs_commit_bucket
*bucket
;
78 bucket
= list_first_entry(&req
->wb_list
,
79 struct pnfs_commit_bucket
,
81 freeme
= bucket
->wlseg
;
85 nfs_request_remove_commit_list(req
, cinfo
);
86 pnfs_put_lseg_locked(freeme
);
88 EXPORT_SYMBOL_GPL(pnfs_generic_clear_request_commit
);
91 pnfs_generic_transfer_commit_list(struct list_head
*src
, struct list_head
*dst
,
92 struct nfs_commit_info
*cinfo
, int max
)
94 struct nfs_page
*req
, *tmp
;
97 list_for_each_entry_safe(req
, tmp
, src
, wb_list
) {
98 if (!nfs_lock_request(req
))
100 kref_get(&req
->wb_kref
);
101 if (cond_resched_lock(&cinfo
->inode
->i_lock
))
102 list_safe_reset_next(req
, tmp
, wb_list
);
103 nfs_request_remove_commit_list(req
, cinfo
);
104 clear_bit(PG_COMMIT_TO_DS
, &req
->wb_flags
);
105 nfs_list_add_request(req
, dst
);
107 if ((ret
== max
) && !cinfo
->dreq
)
114 pnfs_generic_scan_ds_commit_list(struct pnfs_commit_bucket
*bucket
,
115 struct nfs_commit_info
*cinfo
,
118 struct list_head
*src
= &bucket
->written
;
119 struct list_head
*dst
= &bucket
->committing
;
122 lockdep_assert_held(&cinfo
->inode
->i_lock
);
123 ret
= pnfs_generic_transfer_commit_list(src
, dst
, cinfo
, max
);
125 cinfo
->ds
->nwritten
-= ret
;
126 cinfo
->ds
->ncommitting
+= ret
;
127 if (bucket
->clseg
== NULL
)
128 bucket
->clseg
= pnfs_get_lseg(bucket
->wlseg
);
129 if (list_empty(src
)) {
130 pnfs_put_lseg_locked(bucket
->wlseg
);
131 bucket
->wlseg
= NULL
;
137 /* Move reqs from written to committing lists, returning count
140 int pnfs_generic_scan_commit_lists(struct nfs_commit_info
*cinfo
,
145 lockdep_assert_held(&cinfo
->inode
->i_lock
);
146 for (i
= 0; i
< cinfo
->ds
->nbuckets
&& max
!= 0; i
++) {
147 cnt
= pnfs_generic_scan_ds_commit_list(&cinfo
->ds
->buckets
[i
],
154 EXPORT_SYMBOL_GPL(pnfs_generic_scan_commit_lists
);
156 /* Pull everything off the committing lists and dump into @dst. */
157 void pnfs_generic_recover_commit_reqs(struct list_head
*dst
,
158 struct nfs_commit_info
*cinfo
)
160 struct pnfs_commit_bucket
*b
;
161 struct pnfs_layout_segment
*freeme
;
165 lockdep_assert_held(&cinfo
->inode
->i_lock
);
167 for (i
= 0, b
= cinfo
->ds
->buckets
; i
< cinfo
->ds
->nbuckets
; i
++, b
++) {
168 nwritten
= pnfs_generic_transfer_commit_list(&b
->written
,
172 cinfo
->ds
->nwritten
-= nwritten
;
173 if (list_empty(&b
->written
)) {
176 spin_unlock(&cinfo
->inode
->i_lock
);
177 pnfs_put_lseg(freeme
);
178 spin_lock(&cinfo
->inode
->i_lock
);
183 EXPORT_SYMBOL_GPL(pnfs_generic_recover_commit_reqs
);
185 static void pnfs_generic_retry_commit(struct nfs_commit_info
*cinfo
, int idx
)
187 struct pnfs_ds_commit_info
*fl_cinfo
= cinfo
->ds
;
188 struct pnfs_commit_bucket
*bucket
;
189 struct pnfs_layout_segment
*freeme
;
190 struct list_head
*pos
;
194 spin_lock(&cinfo
->inode
->i_lock
);
195 for (i
= idx
; i
< fl_cinfo
->nbuckets
; i
++) {
196 bucket
= &fl_cinfo
->buckets
[i
];
197 if (list_empty(&bucket
->committing
))
199 freeme
= bucket
->clseg
;
200 bucket
->clseg
= NULL
;
201 list_for_each(pos
, &bucket
->committing
)
202 cinfo
->ds
->ncommitting
--;
203 list_splice_init(&bucket
->committing
, &pages
);
204 spin_unlock(&cinfo
->inode
->i_lock
);
205 nfs_retry_commit(&pages
, freeme
, cinfo
, i
);
206 pnfs_put_lseg(freeme
);
207 spin_lock(&cinfo
->inode
->i_lock
);
209 spin_unlock(&cinfo
->inode
->i_lock
);
213 pnfs_generic_alloc_ds_commits(struct nfs_commit_info
*cinfo
,
214 struct list_head
*list
)
216 struct pnfs_ds_commit_info
*fl_cinfo
;
217 struct pnfs_commit_bucket
*bucket
;
218 struct nfs_commit_data
*data
;
220 unsigned int nreq
= 0;
222 fl_cinfo
= cinfo
->ds
;
223 bucket
= fl_cinfo
->buckets
;
224 for (i
= 0; i
< fl_cinfo
->nbuckets
; i
++, bucket
++) {
225 if (list_empty(&bucket
->committing
))
227 data
= nfs_commitdata_alloc(false);
230 data
->ds_commit_index
= i
;
231 list_add(&data
->pages
, list
);
235 /* Clean up on error */
236 pnfs_generic_retry_commit(cinfo
, i
);
241 void pnfs_fetch_commit_bucket_list(struct list_head
*pages
,
242 struct nfs_commit_data
*data
,
243 struct nfs_commit_info
*cinfo
)
245 struct pnfs_commit_bucket
*bucket
;
246 struct list_head
*pos
;
248 bucket
= &cinfo
->ds
->buckets
[data
->ds_commit_index
];
249 spin_lock(&cinfo
->inode
->i_lock
);
250 list_for_each(pos
, &bucket
->committing
)
251 cinfo
->ds
->ncommitting
--;
252 list_splice_init(&bucket
->committing
, pages
);
253 data
->lseg
= bucket
->clseg
;
254 bucket
->clseg
= NULL
;
255 spin_unlock(&cinfo
->inode
->i_lock
);
259 /* Helper function for pnfs_generic_commit_pagelist to catch an empty
260 * page list. This can happen when two commits race.
262 * This must be called instead of nfs_init_commit - call one or the other, but
266 pnfs_generic_commit_cancel_empty_pagelist(struct list_head
*pages
,
267 struct nfs_commit_data
*data
,
268 struct nfs_commit_info
*cinfo
)
270 if (list_empty(pages
)) {
271 if (atomic_dec_and_test(&cinfo
->mds
->rpcs_out
))
272 wake_up_atomic_t(&cinfo
->mds
->rpcs_out
);
273 /* don't call nfs_commitdata_release - it tries to put
274 * the open_context which is not acquired until nfs_init_commit
275 * which has not been called on @data */
276 WARN_ON_ONCE(data
->context
);
277 nfs_commit_free(data
);
284 /* This follows nfs_commit_list pretty closely */
286 pnfs_generic_commit_pagelist(struct inode
*inode
, struct list_head
*mds_pages
,
287 int how
, struct nfs_commit_info
*cinfo
,
288 int (*initiate_commit
)(struct nfs_commit_data
*data
,
291 struct nfs_commit_data
*data
, *tmp
;
293 unsigned int nreq
= 0;
295 if (!list_empty(mds_pages
)) {
296 data
= nfs_commitdata_alloc(true);
297 data
->ds_commit_index
= -1;
298 list_add(&data
->pages
, &list
);
302 nreq
+= pnfs_generic_alloc_ds_commits(cinfo
, &list
);
307 atomic_add(nreq
, &cinfo
->mds
->rpcs_out
);
309 list_for_each_entry_safe(data
, tmp
, &list
, pages
) {
310 list_del_init(&data
->pages
);
311 if (data
->ds_commit_index
< 0) {
312 /* another commit raced with us */
313 if (pnfs_generic_commit_cancel_empty_pagelist(mds_pages
,
317 nfs_init_commit(data
, mds_pages
, NULL
, cinfo
);
318 nfs_initiate_commit(NFS_CLIENT(inode
), data
,
319 NFS_PROTO(data
->inode
),
320 data
->mds_ops
, how
, 0);
324 pnfs_fetch_commit_bucket_list(&pages
, data
, cinfo
);
326 /* another commit raced with us */
327 if (pnfs_generic_commit_cancel_empty_pagelist(&pages
,
331 nfs_init_commit(data
, &pages
, data
->lseg
, cinfo
);
332 initiate_commit(data
, how
);
336 return PNFS_ATTEMPTED
;
338 EXPORT_SYMBOL_GPL(pnfs_generic_commit_pagelist
);
343 * Data servers can be mapped to different device ids.
344 * nfs4_pnfs_ds reference counting
345 * - set to 1 on allocation
346 * - incremented when a device id maps a data server already in the cache.
347 * - decremented when deviceid is removed from the cache.
349 static DEFINE_SPINLOCK(nfs4_ds_cache_lock
);
350 static LIST_HEAD(nfs4_data_server_cache
);
354 print_ds(struct nfs4_pnfs_ds
*ds
)
357 printk(KERN_WARNING
"%s NULL device\n", __func__
);
360 printk(KERN_WARNING
" ds %s\n"
363 " cl_exchange_flags %x\n",
365 atomic_read(&ds
->ds_count
), ds
->ds_clp
,
366 ds
->ds_clp
? ds
->ds_clp
->cl_exchange_flags
: 0);
370 same_sockaddr(struct sockaddr
*addr1
, struct sockaddr
*addr2
)
372 struct sockaddr_in
*a
, *b
;
373 struct sockaddr_in6
*a6
, *b6
;
375 if (addr1
->sa_family
!= addr2
->sa_family
)
378 switch (addr1
->sa_family
) {
380 a
= (struct sockaddr_in
*)addr1
;
381 b
= (struct sockaddr_in
*)addr2
;
383 if (a
->sin_addr
.s_addr
== b
->sin_addr
.s_addr
&&
384 a
->sin_port
== b
->sin_port
)
389 a6
= (struct sockaddr_in6
*)addr1
;
390 b6
= (struct sockaddr_in6
*)addr2
;
392 /* LINKLOCAL addresses must have matching scope_id */
393 if (ipv6_addr_src_scope(&a6
->sin6_addr
) ==
394 IPV6_ADDR_SCOPE_LINKLOCAL
&&
395 a6
->sin6_scope_id
!= b6
->sin6_scope_id
)
398 if (ipv6_addr_equal(&a6
->sin6_addr
, &b6
->sin6_addr
) &&
399 a6
->sin6_port
== b6
->sin6_port
)
404 dprintk("%s: unhandled address family: %u\n",
405 __func__
, addr1
->sa_family
);
413 * Checks if 'dsaddrs1' contains a subset of 'dsaddrs2'. If it does,
417 _same_data_server_addrs_locked(const struct list_head
*dsaddrs1
,
418 const struct list_head
*dsaddrs2
)
420 struct nfs4_pnfs_ds_addr
*da1
, *da2
;
421 struct sockaddr
*sa1
, *sa2
;
424 list_for_each_entry(da1
, dsaddrs1
, da_node
) {
425 sa1
= (struct sockaddr
*)&da1
->da_addr
;
427 list_for_each_entry(da2
, dsaddrs2
, da_node
) {
428 sa2
= (struct sockaddr
*)&da2
->da_addr
;
429 match
= same_sockaddr(sa1
, sa2
);
440 * Lookup DS by addresses. nfs4_ds_cache_lock is held
442 static struct nfs4_pnfs_ds
*
443 _data_server_lookup_locked(const struct list_head
*dsaddrs
)
445 struct nfs4_pnfs_ds
*ds
;
447 list_for_each_entry(ds
, &nfs4_data_server_cache
, ds_node
)
448 if (_same_data_server_addrs_locked(&ds
->ds_addrs
, dsaddrs
))
453 static void destroy_ds(struct nfs4_pnfs_ds
*ds
)
455 struct nfs4_pnfs_ds_addr
*da
;
457 dprintk("--> %s\n", __func__
);
461 nfs_put_client(ds
->ds_clp
);
463 while (!list_empty(&ds
->ds_addrs
)) {
464 da
= list_first_entry(&ds
->ds_addrs
,
465 struct nfs4_pnfs_ds_addr
,
467 list_del_init(&da
->da_node
);
468 kfree(da
->da_remotestr
);
472 kfree(ds
->ds_remotestr
);
476 void nfs4_pnfs_ds_put(struct nfs4_pnfs_ds
*ds
)
478 if (atomic_dec_and_lock(&ds
->ds_count
,
479 &nfs4_ds_cache_lock
)) {
480 list_del_init(&ds
->ds_node
);
481 spin_unlock(&nfs4_ds_cache_lock
);
485 EXPORT_SYMBOL_GPL(nfs4_pnfs_ds_put
);
488 * Create a string with a human readable address and port to avoid
489 * complicated setup around many dprinks.
492 nfs4_pnfs_remotestr(struct list_head
*dsaddrs
, gfp_t gfp_flags
)
494 struct nfs4_pnfs_ds_addr
*da
;
499 len
= 3; /* '{', '}' and eol */
500 list_for_each_entry(da
, dsaddrs
, da_node
) {
501 len
+= strlen(da
->da_remotestr
) + 1; /* string plus comma */
504 remotestr
= kzalloc(len
, gfp_flags
);
511 list_for_each_entry(da
, dsaddrs
, da_node
) {
512 size_t ll
= strlen(da
->da_remotestr
);
517 memcpy(p
, da
->da_remotestr
, ll
);
537 * Given a list of multipath struct nfs4_pnfs_ds_addr, add it to ds cache if
538 * uncached and return cached struct nfs4_pnfs_ds.
540 struct nfs4_pnfs_ds
*
541 nfs4_pnfs_ds_add(struct list_head
*dsaddrs
, gfp_t gfp_flags
)
543 struct nfs4_pnfs_ds
*tmp_ds
, *ds
= NULL
;
546 if (list_empty(dsaddrs
)) {
547 dprintk("%s: no addresses defined\n", __func__
);
551 ds
= kzalloc(sizeof(*ds
), gfp_flags
);
555 /* this is only used for debugging, so it's ok if its NULL */
556 remotestr
= nfs4_pnfs_remotestr(dsaddrs
, gfp_flags
);
558 spin_lock(&nfs4_ds_cache_lock
);
559 tmp_ds
= _data_server_lookup_locked(dsaddrs
);
560 if (tmp_ds
== NULL
) {
561 INIT_LIST_HEAD(&ds
->ds_addrs
);
562 list_splice_init(dsaddrs
, &ds
->ds_addrs
);
563 ds
->ds_remotestr
= remotestr
;
564 atomic_set(&ds
->ds_count
, 1);
565 INIT_LIST_HEAD(&ds
->ds_node
);
567 list_add(&ds
->ds_node
, &nfs4_data_server_cache
);
568 dprintk("%s add new data server %s\n", __func__
,
573 atomic_inc(&tmp_ds
->ds_count
);
574 dprintk("%s data server %s found, inc'ed ds_count to %d\n",
575 __func__
, tmp_ds
->ds_remotestr
,
576 atomic_read(&tmp_ds
->ds_count
));
579 spin_unlock(&nfs4_ds_cache_lock
);
583 EXPORT_SYMBOL_GPL(nfs4_pnfs_ds_add
);
585 static void nfs4_wait_ds_connect(struct nfs4_pnfs_ds
*ds
)
588 wait_on_bit(&ds
->ds_state
, NFS4DS_CONNECTING
,
592 static void nfs4_clear_ds_conn_bit(struct nfs4_pnfs_ds
*ds
)
594 smp_mb__before_atomic();
595 clear_bit(NFS4DS_CONNECTING
, &ds
->ds_state
);
596 smp_mb__after_atomic();
597 wake_up_bit(&ds
->ds_state
, NFS4DS_CONNECTING
);
600 static struct nfs_client
*(*get_v3_ds_connect
)(
601 struct nfs_server
*mds_srv
,
602 const struct sockaddr
*ds_addr
,
605 unsigned int ds_timeo
,
606 unsigned int ds_retrans
);
608 static bool load_v3_ds_connect(void)
610 if (!get_v3_ds_connect
) {
611 get_v3_ds_connect
= symbol_request(nfs3_set_ds_client
);
612 WARN_ON_ONCE(!get_v3_ds_connect
);
615 return(get_v3_ds_connect
!= NULL
);
618 void nfs4_pnfs_v3_ds_connect_unload(void)
620 if (get_v3_ds_connect
) {
621 symbol_put(nfs3_set_ds_client
);
622 get_v3_ds_connect
= NULL
;
626 static int _nfs4_pnfs_v3_ds_connect(struct nfs_server
*mds_srv
,
627 struct nfs4_pnfs_ds
*ds
,
629 unsigned int retrans
)
631 struct nfs_client
*clp
= ERR_PTR(-EIO
);
632 struct nfs4_pnfs_ds_addr
*da
;
635 dprintk("--> %s DS %s\n", __func__
, ds
->ds_remotestr
);
637 if (!load_v3_ds_connect())
640 list_for_each_entry(da
, &ds
->ds_addrs
, da_node
) {
641 dprintk("%s: DS %s: trying address %s\n",
642 __func__
, ds
->ds_remotestr
, da
->da_remotestr
);
645 struct xprt_create xprt_args
= {
646 .ident
= XPRT_TRANSPORT_TCP
,
648 .dstaddr
= (struct sockaddr
*)&da
->da_addr
,
649 .addrlen
= da
->da_addrlen
,
650 .servername
= clp
->cl_hostname
,
652 /* Add this address as an alias */
653 rpc_clnt_add_xprt(clp
->cl_rpcclient
, &xprt_args
,
654 rpc_clnt_test_and_add_xprt
, NULL
);
656 clp
= get_v3_ds_connect(mds_srv
,
657 (struct sockaddr
*)&da
->da_addr
,
658 da
->da_addrlen
, IPPROTO_TCP
,
663 status
= PTR_ERR(clp
);
669 dprintk("%s [new] addr: %s\n", __func__
, ds
->ds_remotestr
);
674 static int _nfs4_pnfs_v4_ds_connect(struct nfs_server
*mds_srv
,
675 struct nfs4_pnfs_ds
*ds
,
677 unsigned int retrans
,
680 struct nfs_client
*clp
= ERR_PTR(-EIO
);
681 struct nfs4_pnfs_ds_addr
*da
;
684 dprintk("--> %s DS %s\n", __func__
, ds
->ds_remotestr
);
686 list_for_each_entry(da
, &ds
->ds_addrs
, da_node
) {
687 dprintk("%s: DS %s: trying address %s\n",
688 __func__
, ds
->ds_remotestr
, da
->da_remotestr
);
690 if (!IS_ERR(clp
) && clp
->cl_mvops
->session_trunk
) {
691 struct xprt_create xprt_args
= {
692 .ident
= XPRT_TRANSPORT_TCP
,
694 .dstaddr
= (struct sockaddr
*)&da
->da_addr
,
695 .addrlen
= da
->da_addrlen
,
696 .servername
= clp
->cl_hostname
,
698 struct nfs4_add_xprt_data xprtdata
= {
700 .cred
= nfs4_get_clid_cred(clp
),
702 struct rpc_add_xprt_test rpcdata
= {
703 .add_xprt_test
= clp
->cl_mvops
->session_trunk
,
708 * Test this address for session trunking and
711 rpc_clnt_add_xprt(clp
->cl_rpcclient
, &xprt_args
,
712 rpc_clnt_setup_test_and_add_xprt
,
715 put_rpccred(xprtdata
.cred
);
717 clp
= nfs4_set_ds_client(mds_srv
,
718 (struct sockaddr
*)&da
->da_addr
,
719 da
->da_addrlen
, IPPROTO_TCP
,
720 timeo
, retrans
, minor_version
);
724 status
= nfs4_init_ds_session(clp
,
725 mds_srv
->nfs_client
->cl_lease_time
);
736 status
= PTR_ERR(clp
);
742 dprintk("%s [new] addr: %s\n", __func__
, ds
->ds_remotestr
);
748 * Create an rpc connection to the nfs4_pnfs_ds data server.
749 * Currently only supports IPv4 and IPv6 addresses.
750 * If connection fails, make devid unavailable and return a -errno.
752 int nfs4_pnfs_ds_connect(struct nfs_server
*mds_srv
, struct nfs4_pnfs_ds
*ds
,
753 struct nfs4_deviceid_node
*devid
, unsigned int timeo
,
754 unsigned int retrans
, u32 version
, u32 minor_version
)
760 if (test_and_set_bit(NFS4DS_CONNECTING
, &ds
->ds_state
) == 0) {
762 err
= _nfs4_pnfs_v3_ds_connect(mds_srv
, ds
, timeo
,
764 } else if (version
== 4) {
765 err
= _nfs4_pnfs_v4_ds_connect(mds_srv
, ds
, timeo
,
766 retrans
, minor_version
);
768 dprintk("%s: unsupported DS version %d\n", __func__
,
770 err
= -EPROTONOSUPPORT
;
773 nfs4_clear_ds_conn_bit(ds
);
775 nfs4_wait_ds_connect(ds
);
777 /* what was waited on didn't connect AND didn't mark unavail */
778 if (!ds
->ds_clp
&& !nfs4_test_deviceid_unavailable(devid
))
783 * At this point the ds->ds_clp should be ready, but it might have
787 if (!ds
->ds_clp
|| !nfs_client_init_is_complete(ds
->ds_clp
)) {
788 WARN_ON_ONCE(ds
->ds_clp
||
789 !nfs4_test_deviceid_unavailable(devid
));
792 err
= nfs_client_init_status(ds
->ds_clp
);
797 EXPORT_SYMBOL_GPL(nfs4_pnfs_ds_connect
);
800 * Currently only supports ipv4, ipv6 and one multi-path address.
802 struct nfs4_pnfs_ds_addr
*
803 nfs4_decode_mp_ds_addr(struct net
*net
, struct xdr_stream
*xdr
, gfp_t gfp_flags
)
805 struct nfs4_pnfs_ds_addr
*da
= NULL
;
811 char *netid
, *match_netid
;
812 size_t len
, match_netid_len
;
818 p
= xdr_inline_decode(xdr
, 4);
821 nlen
= be32_to_cpup(p
++);
823 p
= xdr_inline_decode(xdr
, nlen
);
827 netid
= kmalloc(nlen
+1, gfp_flags
);
828 if (unlikely(!netid
))
832 memcpy(netid
, p
, nlen
);
834 /* r_addr: ip/ip6addr with port in dec octets - see RFC 5665 */
835 p
= xdr_inline_decode(xdr
, 4);
838 rlen
= be32_to_cpup(p
);
840 p
= xdr_inline_decode(xdr
, rlen
);
844 /* port is ".ABC.DEF", 8 chars max */
845 if (rlen
> INET6_ADDRSTRLEN
+ IPV6_SCOPE_ID_LEN
+ 8) {
846 dprintk("%s: Invalid address, length %d\n", __func__
,
850 buf
= kmalloc(rlen
+ 1, gfp_flags
);
852 dprintk("%s: Not enough memory\n", __func__
);
856 memcpy(buf
, p
, rlen
);
858 /* replace port '.' with '-' */
859 portstr
= strrchr(buf
, '.');
861 dprintk("%s: Failed finding expected dot in port\n",
867 /* find '.' between address and port */
868 portstr
= strrchr(buf
, '.');
870 dprintk("%s: Failed finding expected dot between address and "
876 da
= kzalloc(sizeof(*da
), gfp_flags
);
880 INIT_LIST_HEAD(&da
->da_node
);
882 if (!rpc_pton(net
, buf
, portstr
-buf
, (struct sockaddr
*)&da
->da_addr
,
883 sizeof(da
->da_addr
))) {
884 dprintk("%s: error parsing address %s\n", __func__
, buf
);
889 sscanf(portstr
, "%d-%d", &tmp
[0], &tmp
[1]);
890 port
= htons((tmp
[0] << 8) | (tmp
[1]));
892 switch (da
->da_addr
.ss_family
) {
894 ((struct sockaddr_in
*)&da
->da_addr
)->sin_port
= port
;
895 da
->da_addrlen
= sizeof(struct sockaddr_in
);
901 ((struct sockaddr_in6
*)&da
->da_addr
)->sin6_port
= port
;
902 da
->da_addrlen
= sizeof(struct sockaddr_in6
);
903 match_netid
= "tcp6";
910 dprintk("%s: unsupported address family: %u\n",
911 __func__
, da
->da_addr
.ss_family
);
915 if (nlen
!= match_netid_len
|| strncmp(netid
, match_netid
, nlen
)) {
916 dprintk("%s: ERROR: r_netid \"%s\" != \"%s\"\n",
917 __func__
, netid
, match_netid
);
921 /* save human readable address */
922 len
= strlen(startsep
) + strlen(buf
) + strlen(endsep
) + 7;
923 da
->da_remotestr
= kzalloc(len
, gfp_flags
);
925 /* NULL is ok, only used for dprintk */
926 if (da
->da_remotestr
)
927 snprintf(da
->da_remotestr
, len
, "%s%s%s:%u", startsep
,
928 buf
, endsep
, ntohs(port
));
930 dprintk("%s: Parsed DS addr %s\n", __func__
, da
->da_remotestr
);
938 dprintk("%s: Error parsing DS addr: %s\n", __func__
, buf
);
945 EXPORT_SYMBOL_GPL(nfs4_decode_mp_ds_addr
);
948 pnfs_layout_mark_request_commit(struct nfs_page
*req
,
949 struct pnfs_layout_segment
*lseg
,
950 struct nfs_commit_info
*cinfo
,
953 struct list_head
*list
;
954 struct pnfs_commit_bucket
*buckets
;
956 spin_lock(&cinfo
->inode
->i_lock
);
957 buckets
= cinfo
->ds
->buckets
;
958 list
= &buckets
[ds_commit_idx
].written
;
959 if (list_empty(list
)) {
960 if (!pnfs_is_valid_lseg(lseg
)) {
961 spin_unlock(&cinfo
->inode
->i_lock
);
962 cinfo
->completion_ops
->resched_write(cinfo
, req
);
965 /* Non-empty buckets hold a reference on the lseg. That ref
966 * is normally transferred to the COMMIT call and released
967 * there. It could also be released if the last req is pulled
968 * off due to a rewrite, in which case it will be done in
969 * pnfs_common_clear_request_commit
971 WARN_ON_ONCE(buckets
[ds_commit_idx
].wlseg
!= NULL
);
972 buckets
[ds_commit_idx
].wlseg
= pnfs_get_lseg(lseg
);
974 set_bit(PG_COMMIT_TO_DS
, &req
->wb_flags
);
975 cinfo
->ds
->nwritten
++;
977 nfs_request_add_commit_list_locked(req
, list
, cinfo
);
978 spin_unlock(&cinfo
->inode
->i_lock
);
979 nfs_mark_page_unstable(req
->wb_page
, cinfo
);
981 EXPORT_SYMBOL_GPL(pnfs_layout_mark_request_commit
);
984 pnfs_nfs_generic_sync(struct inode
*inode
, bool datasync
)
988 if (!pnfs_layoutcommit_outstanding(inode
))
990 ret
= nfs_commit_inode(inode
, FLUSH_SYNC
);
995 return pnfs_layoutcommit_inode(inode
, true);
997 EXPORT_SYMBOL_GPL(pnfs_nfs_generic_sync
);