/* * Copyright (c) 2001 The Regents of the University of Michigan. * All rights reserved. * * Kendrick Smith <[email protected]> * Andy Adamson <[email protected]> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include <linux/nfs4.h> #include <linux/sunrpc/clnt.h> #include <linux/sunrpc/xprt.h> #include <linux/sunrpc/svc_xprt.h> #include <linux/slab.h> #include "nfsd.h" #include "state.h" #include "netns.h" #include "trace.h" #include "xdr4cb.h" #include "xdr4.h" #define NFSDDBG_FACILITY … static void nfsd4_mark_cb_fault(struct nfs4_client *clp); #define NFSPROC4_CB_NULL … #define NFSPROC4_CB_COMPOUND … /* Index of predefined Linux callback client operations */ struct nfs4_cb_compound_hdr { … }; static __be32 *xdr_encode_empty_array(__be32 *p) { … } /* * Encode/decode NFSv4 CB basic data types * * Basic NFSv4 callback data types are defined in section 15 of RFC * 3530: "Network File System (NFS) version 4 Protocol" and section * 20 of RFC 5661: "Network File System (NFS) Version 4 Minor Version * 1 Protocol" */ static void encode_uint32(struct xdr_stream *xdr, u32 n) { … } static void encode_bitmap4(struct xdr_stream *xdr, const __u32 *bitmap, size_t len) { … } static int decode_cb_fattr4(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_cb_fattr *fattr) { … } static void encode_nfs_cb_opnum4(struct xdr_stream *xdr, enum nfs_cb_opnum4 op) { … } /* * nfs_fh4 * * typedef opaque nfs_fh4<NFS4_FHSIZE>; */ static void encode_nfs_fh4(struct xdr_stream *xdr, const struct knfsd_fh *fh) { … } /* * stateid4 * * struct stateid4 { * uint32_t seqid; * opaque other[12]; * }; */ static void encode_stateid4(struct xdr_stream *xdr, const stateid_t *sid) { … } /* * sessionid4 * * typedef opaque sessionid4[NFS4_SESSIONID_SIZE]; */ static void encode_sessionid4(struct xdr_stream *xdr, const struct nfsd4_session *session) { … } /* * nfsstat4 */ static const struct { … } nfs_cb_errtbl[] = …; /* * If we cannot translate the error, the recovery routines should * handle it. * * Note: remaining NFSv4 error codes have values > 10000, so should * not conflict with native Linux error codes. */ static int nfs_cb_stat_to_errno(int status) { … } static int decode_cb_op_status(struct xdr_stream *xdr, enum nfs_cb_opnum4 expected, int *status) { … } /* * CB_COMPOUND4args * * struct CB_COMPOUND4args { * utf8str_cs tag; * uint32_t minorversion; * uint32_t callback_ident; * nfs_cb_argop4 argarray<>; * }; */ static void encode_cb_compound4args(struct xdr_stream *xdr, struct nfs4_cb_compound_hdr *hdr) { … } /* * Update argarray element count */ static void encode_cb_nops(struct nfs4_cb_compound_hdr *hdr) { … } /* * CB_COMPOUND4res * * struct CB_COMPOUND4res { * nfsstat4 status; * utf8str_cs tag; * nfs_cb_resop4 resarray<>; * }; */ static int decode_cb_compound4res(struct xdr_stream *xdr, struct nfs4_cb_compound_hdr *hdr) { … } /* * CB_RECALL4args * * struct CB_RECALL4args { * stateid4 stateid; * bool truncate; * nfs_fh4 fh; * }; */ static void encode_cb_recall4args(struct xdr_stream *xdr, const struct nfs4_delegation *dp, struct nfs4_cb_compound_hdr *hdr) { … } /* * CB_RECALLANY4args * * struct CB_RECALLANY4args { * uint32_t craa_objects_to_keep; * bitmap4 craa_type_mask; * }; */ static void encode_cb_recallany4args(struct xdr_stream *xdr, struct nfs4_cb_compound_hdr *hdr, struct nfsd4_cb_recall_any *ra) { … } /* * CB_GETATTR4args * struct CB_GETATTR4args { * nfs_fh4 fh; * bitmap4 attr_request; * }; * * The size and change attributes are the only one * guaranteed to be serviced by the client. */ static void encode_cb_getattr4args(struct xdr_stream *xdr, struct nfs4_cb_compound_hdr *hdr, struct nfs4_cb_fattr *fattr) { … } /* * CB_SEQUENCE4args * * struct CB_SEQUENCE4args { * sessionid4 csa_sessionid; * sequenceid4 csa_sequenceid; * slotid4 csa_slotid; * slotid4 csa_highest_slotid; * bool csa_cachethis; * referring_call_list4 csa_referring_call_lists<>; * }; */ static void encode_cb_sequence4args(struct xdr_stream *xdr, const struct nfsd4_callback *cb, struct nfs4_cb_compound_hdr *hdr) { … } /* * CB_SEQUENCE4resok * * struct CB_SEQUENCE4resok { * sessionid4 csr_sessionid; * sequenceid4 csr_sequenceid; * slotid4 csr_slotid; * slotid4 csr_highest_slotid; * slotid4 csr_target_highest_slotid; * }; * * union CB_SEQUENCE4res switch (nfsstat4 csr_status) { * case NFS4_OK: * CB_SEQUENCE4resok csr_resok4; * default: * void; * }; * * Our current back channel implmentation supports a single backchannel * with a single slot. */ static int decode_cb_sequence4resok(struct xdr_stream *xdr, struct nfsd4_callback *cb) { … } static int decode_cb_sequence4res(struct xdr_stream *xdr, struct nfsd4_callback *cb) { … } /* * NFSv4.0 and NFSv4.1 XDR encode functions * * NFSv4.0 callback argument types are defined in section 15 of RFC * 3530: "Network File System (NFS) version 4 Protocol" and section 20 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1 * Protocol". */ /* * NB: Without this zero space reservation, callbacks over krb5p fail */ static void nfs4_xdr_enc_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr, const void *__unused) { … } /* * 20.1. Operation 3: CB_GETATTR - Get Attributes */ static void nfs4_xdr_enc_cb_getattr(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { … } /* * 20.2. Operation 4: CB_RECALL - Recall a Delegation */ static void nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { … } /* * 20.6. Operation 8: CB_RECALL_ANY - Keep Any N Recallable Objects */ static void nfs4_xdr_enc_cb_recall_any(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { … } /* * NFSv4.0 and NFSv4.1 XDR decode functions * * NFSv4.0 callback result types are defined in section 15 of RFC * 3530: "Network File System (NFS) version 4 Protocol" and section 20 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1 * Protocol". */ static int nfs4_xdr_dec_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr, void *__unused) { … } /* * 20.1. Operation 3: CB_GETATTR - Get Attributes */ static int nfs4_xdr_dec_cb_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr, void *data) { … } /* * 20.2. Operation 4: CB_RECALL - Recall a Delegation */ static int nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp, struct xdr_stream *xdr, void *data) { … } /* * 20.6. Operation 8: CB_RECALL_ANY - Keep Any N Recallable Objects */ static int nfs4_xdr_dec_cb_recall_any(struct rpc_rqst *rqstp, struct xdr_stream *xdr, void *data) { … } #ifdef CONFIG_NFSD_PNFS /* * CB_LAYOUTRECALL4args * * struct layoutrecall_file4 { * nfs_fh4 lor_fh; * offset4 lor_offset; * length4 lor_length; * stateid4 lor_stateid; * }; * * union layoutrecall4 switch(layoutrecall_type4 lor_recalltype) { * case LAYOUTRECALL4_FILE: * layoutrecall_file4 lor_layout; * case LAYOUTRECALL4_FSID: * fsid4 lor_fsid; * case LAYOUTRECALL4_ALL: * void; * }; * * struct CB_LAYOUTRECALL4args { * layouttype4 clora_type; * layoutiomode4 clora_iomode; * bool clora_changed; * layoutrecall4 clora_recall; * }; */ static void encode_cb_layout4args(struct xdr_stream *xdr, const struct nfs4_layout_stateid *ls, struct nfs4_cb_compound_hdr *hdr) { … } static void nfs4_xdr_enc_cb_layout(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { … } static int nfs4_xdr_dec_cb_layout(struct rpc_rqst *rqstp, struct xdr_stream *xdr, void *data) { … } #endif /* CONFIG_NFSD_PNFS */ static void encode_stateowner(struct xdr_stream *xdr, struct nfs4_stateowner *so) { … } static void nfs4_xdr_enc_cb_notify_lock(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { … } static int nfs4_xdr_dec_cb_notify_lock(struct rpc_rqst *rqstp, struct xdr_stream *xdr, void *data) { … } /* * struct write_response4 { * stateid4 wr_callback_id<1>; * length4 wr_count; * stable_how4 wr_committed; * verifier4 wr_writeverf; * }; * union offload_info4 switch (nfsstat4 coa_status) { * case NFS4_OK: * write_response4 coa_resok4; * default: * length4 coa_bytes_copied; * }; * struct CB_OFFLOAD4args { * nfs_fh4 coa_fh; * stateid4 coa_stateid; * offload_info4 coa_offload_info; * }; */ static void encode_offload_info4(struct xdr_stream *xdr, const struct nfsd4_cb_offload *cbo) { … } static void encode_cb_offload4args(struct xdr_stream *xdr, const struct nfsd4_cb_offload *cbo, struct nfs4_cb_compound_hdr *hdr) { … } static void nfs4_xdr_enc_cb_offload(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { … } static int nfs4_xdr_dec_cb_offload(struct rpc_rqst *rqstp, struct xdr_stream *xdr, void *data) { … } /* * RPC procedure tables */ #define PROC(proc, call, argtype, restype) … static const struct rpc_procinfo nfs4_cb_procedures[] = …; static unsigned int nfs4_cb_counts[ARRAY_SIZE(nfs4_cb_procedures)]; static const struct rpc_version nfs_cb_version4 = …; static const struct rpc_version *nfs_cb_version[2] = …; static const struct rpc_program cb_program; static struct rpc_stat cb_stats = …; #define NFS4_CALLBACK … static const struct rpc_program cb_program = …; static int max_cb_time(struct net *net) { … } static bool nfsd4_queue_cb(struct nfsd4_callback *cb) { … } static void nfsd41_cb_inflight_begin(struct nfs4_client *clp) { … } static void nfsd41_cb_inflight_end(struct nfs4_client *clp) { … } static void nfsd41_cb_inflight_wait_complete(struct nfs4_client *clp) { … } static const struct cred *get_backchannel_cred(struct nfs4_client *clp, struct rpc_clnt *client, struct nfsd4_session *ses) { … } static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *conn, struct nfsd4_session *ses) { … } static void nfsd4_mark_cb_state(struct nfs4_client *clp, int newstate) { … } static void nfsd4_mark_cb_down(struct nfs4_client *clp) { … } static void nfsd4_mark_cb_fault(struct nfs4_client *clp) { … } static void nfsd4_cb_probe_done(struct rpc_task *task, void *calldata) { … } static void nfsd4_cb_probe_release(void *calldata) { … } static const struct rpc_call_ops nfsd4_cb_probe_ops = …; /* * Poke the callback thread to process any updates to the callback * parameters, and send a null probe. */ void nfsd4_probe_callback(struct nfs4_client *clp) { … } void nfsd4_probe_callback_sync(struct nfs4_client *clp) { … } void nfsd4_change_callback(struct nfs4_client *clp, struct nfs4_cb_conn *conn) { … } /* * There's currently a single callback channel slot. * If the slot is available, then mark it busy. Otherwise, set the * thread for sleeping on the callback RPC wait queue. */ static bool nfsd41_cb_get_slot(struct nfsd4_callback *cb, struct rpc_task *task) { … } static void nfsd41_cb_release_slot(struct nfsd4_callback *cb) { … } static void nfsd41_destroy_cb(struct nfsd4_callback *cb) { … } /* * TODO: cb_sequence should support referring call lists, cachethis, multiple * slots, and mark callback channel down on communication errors. */ static void nfsd4_cb_prepare(struct rpc_task *task, void *calldata) { … } static bool nfsd4_cb_sequence_done(struct rpc_task *task, struct nfsd4_callback *cb) { … } static void nfsd4_cb_done(struct rpc_task *task, void *calldata) { … } static void nfsd4_cb_release(void *calldata) { … } static const struct rpc_call_ops nfsd4_cb_ops = …; /* must be called under the state lock */ void nfsd4_shutdown_callback(struct nfs4_client *clp) { … } static struct nfsd4_conn * __nfsd4_find_backchannel(struct nfs4_client *clp) { … } /* * Note there isn't a lot of locking in this code; instead we depend on * the fact that it is run from clp->cl_callback_wq, which won't run two * work items at once. So, for example, clp->cl_callback_wq handles all * access of cl_cb_client and all calls to rpc_create or rpc_shutdown_client. */ static void nfsd4_process_cb_update(struct nfsd4_callback *cb) { … } static void nfsd4_run_cb_work(struct work_struct *work) { … } void nfsd4_init_cb(struct nfsd4_callback *cb, struct nfs4_client *clp, const struct nfsd4_callback_ops *ops, enum nfsd4_cb_op op) { … } /** * nfsd4_run_cb - queue up a callback job to run * @cb: callback to queue * * Kick off a callback to do its thing. Returns false if it was already * on a queue, true otherwise. */ bool nfsd4_run_cb(struct nfsd4_callback *cb) { … }
Codebase Browser
linux