LCOV - code coverage report
Current view: top level - include/linux/sunrpc - xdr.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 1 0.0 %
Date: 2014-02-18 Functions: 0 0 -
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * XDR standard data types and function declarations
       3                 :            :  *
       4                 :            :  * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
       5                 :            :  *
       6                 :            :  * Based on:
       7                 :            :  *   RFC 4506 "XDR: External Data Representation Standard", May 2006
       8                 :            :  */
       9                 :            : 
      10                 :            : #ifndef _SUNRPC_XDR_H_
      11                 :            : #define _SUNRPC_XDR_H_
      12                 :            : 
      13                 :            : #ifdef __KERNEL__
      14                 :            : 
      15                 :            : #include <linux/uio.h>
      16                 :            : #include <asm/byteorder.h>
      17                 :            : #include <asm/unaligned.h>
      18                 :            : #include <linux/scatterlist.h>
      19                 :            : 
      20                 :            : /*
      21                 :            :  * Buffer adjustment
      22                 :            :  */
      23                 :            : #define XDR_QUADLEN(l)          (((l) + 3) >> 2)
      24                 :            : 
      25                 :            : /*
      26                 :            :  * Generic opaque `network object.' At the kernel level, this type
      27                 :            :  * is used only by lockd.
      28                 :            :  */
      29                 :            : #define XDR_MAX_NETOBJ          1024
      30                 :            : struct xdr_netobj {
      31                 :            :         unsigned int            len;
      32                 :            :         u8 *                    data;
      33                 :            : };
      34                 :            : 
      35                 :            : /*
      36                 :            :  * This is the legacy generic XDR function. rqstp is either a rpc_rqst
      37                 :            :  * (client side) or svc_rqst pointer (server side).
      38                 :            :  * Encode functions always assume there's enough room in the buffer.
      39                 :            :  */
      40                 :            : typedef int     (*kxdrproc_t)(void *rqstp, __be32 *data, void *obj);
      41                 :            : 
      42                 :            : /*
      43                 :            :  * Basic structure for transmission/reception of a client XDR message.
      44                 :            :  * Features a header (for a linear buffer containing RPC headers
      45                 :            :  * and the data payload for short messages), and then an array of
      46                 :            :  * pages.
      47                 :            :  * The tail iovec allows you to append data after the page array. Its
      48                 :            :  * main interest is for appending padding to the pages in order to
      49                 :            :  * satisfy the int_32-alignment requirements in RFC1832.
      50                 :            :  *
      51                 :            :  * For the future, we might want to string several of these together
      52                 :            :  * in a list if anybody wants to make use of NFSv4 COMPOUND
      53                 :            :  * operations and/or has a need for scatter/gather involving pages.
      54                 :            :  */
      55                 :            : struct xdr_buf {
      56                 :            :         struct kvec     head[1],        /* RPC header + non-page data */
      57                 :            :                         tail[1];        /* Appended after page data */
      58                 :            : 
      59                 :            :         struct page **  pages;          /* Array of pages */
      60                 :            :         unsigned int    page_base,      /* Start of page data */
      61                 :            :                         page_len,       /* Length of page data */
      62                 :            :                         flags;          /* Flags for data disposition */
      63                 :            : #define XDRBUF_READ             0x01            /* target of file read */
      64                 :            : #define XDRBUF_WRITE            0x02            /* source of file write */
      65                 :            : 
      66                 :            :         unsigned int    buflen,         /* Total length of storage buffer */
      67                 :            :                         len;            /* Length of XDR encoded message */
      68                 :            : };
      69                 :            : 
      70                 :            : /*
      71                 :            :  * pre-xdr'ed macros.
      72                 :            :  */
      73                 :            : 
      74                 :            : #define xdr_zero        cpu_to_be32(0)
      75                 :            : #define xdr_one         cpu_to_be32(1)
      76                 :            : #define xdr_two         cpu_to_be32(2)
      77                 :            : 
      78                 :            : #define rpc_success             cpu_to_be32(RPC_SUCCESS)
      79                 :            : #define rpc_prog_unavail        cpu_to_be32(RPC_PROG_UNAVAIL)
      80                 :            : #define rpc_prog_mismatch       cpu_to_be32(RPC_PROG_MISMATCH)
      81                 :            : #define rpc_proc_unavail        cpu_to_be32(RPC_PROC_UNAVAIL)
      82                 :            : #define rpc_garbage_args        cpu_to_be32(RPC_GARBAGE_ARGS)
      83                 :            : #define rpc_system_err          cpu_to_be32(RPC_SYSTEM_ERR)
      84                 :            : #define rpc_drop_reply          cpu_to_be32(RPC_DROP_REPLY)
      85                 :            : 
      86                 :            : #define rpc_auth_ok             cpu_to_be32(RPC_AUTH_OK)
      87                 :            : #define rpc_autherr_badcred     cpu_to_be32(RPC_AUTH_BADCRED)
      88                 :            : #define rpc_autherr_rejectedcred cpu_to_be32(RPC_AUTH_REJECTEDCRED)
      89                 :            : #define rpc_autherr_badverf     cpu_to_be32(RPC_AUTH_BADVERF)
      90                 :            : #define rpc_autherr_rejectedverf cpu_to_be32(RPC_AUTH_REJECTEDVERF)
      91                 :            : #define rpc_autherr_tooweak     cpu_to_be32(RPC_AUTH_TOOWEAK)
      92                 :            : #define rpcsec_gsserr_credproblem       cpu_to_be32(RPCSEC_GSS_CREDPROBLEM)
      93                 :            : #define rpcsec_gsserr_ctxproblem        cpu_to_be32(RPCSEC_GSS_CTXPROBLEM)
      94                 :            : #define rpc_autherr_oldseqnum   cpu_to_be32(101)
      95                 :            : 
      96                 :            : /*
      97                 :            :  * Miscellaneous XDR helper functions
      98                 :            :  */
      99                 :            : __be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int len);
     100                 :            : __be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int len);
     101                 :            : __be32 *xdr_encode_string(__be32 *p, const char *s);
     102                 :            : __be32 *xdr_decode_string_inplace(__be32 *p, char **sp, unsigned int *lenp,
     103                 :            :                         unsigned int maxlen);
     104                 :            : __be32 *xdr_encode_netobj(__be32 *p, const struct xdr_netobj *);
     105                 :            : __be32 *xdr_decode_netobj(__be32 *p, struct xdr_netobj *);
     106                 :            : 
     107                 :            : void    xdr_inline_pages(struct xdr_buf *, unsigned int,
     108                 :            :                          struct page **, unsigned int, unsigned int);
     109                 :            : void    xdr_terminate_string(struct xdr_buf *, const u32);
     110                 :            : 
     111                 :            : static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int len)
     112                 :            : {
     113                 :            :         return xdr_encode_opaque(p, s, len);
     114                 :            : }
     115                 :            : 
     116                 :            : /*
     117                 :            :  * Decode 64bit quantities (NFSv3 support)
     118                 :            :  */
     119                 :            : static inline __be32 *
     120                 :            : xdr_encode_hyper(__be32 *p, __u64 val)
     121                 :            : {
     122                 :            :         put_unaligned_be64(val, p);
     123                 :            :         return p + 2;
     124                 :            : }
     125                 :            : 
     126                 :            : static inline __be32 *
     127                 :            : xdr_decode_hyper(__be32 *p, __u64 *valp)
     128                 :            : {
     129                 :          0 :         *valp = get_unaligned_be64(p);
     130                 :            :         return p + 2;
     131                 :            : }
     132                 :            : 
     133                 :            : static inline __be32 *
     134                 :            : xdr_decode_opaque_fixed(__be32 *p, void *ptr, unsigned int len)
     135                 :            : {
     136                 :            :         memcpy(ptr, p, len);
     137                 :            :         return p + XDR_QUADLEN(len);
     138                 :            : }
     139                 :            : 
     140                 :            : /*
     141                 :            :  * Adjust kvec to reflect end of xdr'ed data (RPC client XDR)
     142                 :            :  */
     143                 :            : static inline int
     144                 :            : xdr_adjust_iovec(struct kvec *iov, __be32 *p)
     145                 :            : {
     146                 :            :         return iov->iov_len = ((u8 *) p - (u8 *) iov->iov_base);
     147                 :            : }
     148                 :            : 
     149                 :            : /*
     150                 :            :  * XDR buffer helper functions
     151                 :            :  */
     152                 :            : extern void xdr_shift_buf(struct xdr_buf *, size_t);
     153                 :            : extern void xdr_buf_from_iov(struct kvec *, struct xdr_buf *);
     154                 :            : extern int xdr_buf_subsegment(struct xdr_buf *, struct xdr_buf *, unsigned int, unsigned int);
     155                 :            : extern void xdr_buf_trim(struct xdr_buf *, unsigned int);
     156                 :            : extern int xdr_buf_read_netobj(struct xdr_buf *, struct xdr_netobj *, unsigned int);
     157                 :            : extern int read_bytes_from_xdr_buf(struct xdr_buf *, unsigned int, void *, unsigned int);
     158                 :            : extern int write_bytes_to_xdr_buf(struct xdr_buf *, unsigned int, void *, unsigned int);
     159                 :            : 
     160                 :            : /*
     161                 :            :  * Helper structure for copying from an sk_buff.
     162                 :            :  */
     163                 :            : struct xdr_skb_reader {
     164                 :            :         struct sk_buff  *skb;
     165                 :            :         unsigned int    offset;
     166                 :            :         size_t          count;
     167                 :            :         __wsum          csum;
     168                 :            : };
     169                 :            : 
     170                 :            : typedef size_t (*xdr_skb_read_actor)(struct xdr_skb_reader *desc, void *to, size_t len);
     171                 :            : 
     172                 :            : size_t xdr_skb_read_bits(struct xdr_skb_reader *desc, void *to, size_t len);
     173                 :            : extern int csum_partial_copy_to_xdr(struct xdr_buf *, struct sk_buff *);
     174                 :            : extern ssize_t xdr_partial_copy_from_skb(struct xdr_buf *, unsigned int,
     175                 :            :                 struct xdr_skb_reader *, xdr_skb_read_actor);
     176                 :            : 
     177                 :            : extern int xdr_encode_word(struct xdr_buf *, unsigned int, u32);
     178                 :            : extern int xdr_decode_word(struct xdr_buf *, unsigned int, u32 *);
     179                 :            : 
     180                 :            : struct xdr_array2_desc;
     181                 :            : typedef int (*xdr_xcode_elem_t)(struct xdr_array2_desc *desc, void *elem);
     182                 :            : struct xdr_array2_desc {
     183                 :            :         unsigned int elem_size;
     184                 :            :         unsigned int array_len;
     185                 :            :         unsigned int array_maxlen;
     186                 :            :         xdr_xcode_elem_t xcode;
     187                 :            : };
     188                 :            : 
     189                 :            : extern int xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
     190                 :            :                              struct xdr_array2_desc *desc);
     191                 :            : extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
     192                 :            :                              struct xdr_array2_desc *desc);
     193                 :            : extern void _copy_from_pages(char *p, struct page **pages, size_t pgbase,
     194                 :            :                              size_t len);
     195                 :            : 
     196                 :            : /*
     197                 :            :  * Provide some simple tools for XDR buffer overflow-checking etc.
     198                 :            :  */
     199                 :            : struct xdr_stream {
     200                 :            :         __be32 *p;              /* start of available buffer */
     201                 :            :         struct xdr_buf *buf;    /* XDR buffer to read/write */
     202                 :            : 
     203                 :            :         __be32 *end;            /* end of available buffer space */
     204                 :            :         struct kvec *iov;       /* pointer to the current kvec */
     205                 :            :         struct kvec scratch;    /* Scratch buffer */
     206                 :            :         struct page **page_ptr; /* pointer to the current page */
     207                 :            :         unsigned int nwords;    /* Remaining decode buffer length */
     208                 :            : };
     209                 :            : 
     210                 :            : /*
     211                 :            :  * These are the xdr_stream style generic XDR encode and decode functions.
     212                 :            :  */
     213                 :            : typedef void    (*kxdreproc_t)(void *rqstp, struct xdr_stream *xdr, void *obj);
     214                 :            : typedef int     (*kxdrdproc_t)(void *rqstp, struct xdr_stream *xdr, void *obj);
     215                 :            : 
     216                 :            : extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
     217                 :            : extern __be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
     218                 :            : extern void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,
     219                 :            :                 unsigned int base, unsigned int len);
     220                 :            : extern unsigned int xdr_stream_pos(const struct xdr_stream *xdr);
     221                 :            : extern void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
     222                 :            : extern void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
     223                 :            :                 struct page **pages, unsigned int len);
     224                 :            : extern void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen);
     225                 :            : extern __be32 *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes);
     226                 :            : extern unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len);
     227                 :            : extern void xdr_enter_page(struct xdr_stream *xdr, unsigned int len);
     228                 :            : extern int xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len, int (*actor)(struct scatterlist *, void *), void *data);
     229                 :            : 
     230                 :            : #endif /* __KERNEL__ */
     231                 :            : 
     232                 :            : #endif /* _SUNRPC_XDR_H_ */

Generated by: LCOV version 1.9