LCOV - code coverage report
Current view: top level - fs/lockd - xdr4.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 135 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 18 0.0 %
Branches: 0 72 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * linux/fs/lockd/xdr4.c
       4                 :            :  *
       5                 :            :  * XDR support for lockd and the lock client.
       6                 :            :  *
       7                 :            :  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
       8                 :            :  * Copyright (C) 1999, Trond Myklebust <trond.myklebust@fys.uio.no>
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/types.h>
      12                 :            : #include <linux/sched.h>
      13                 :            : #include <linux/nfs.h>
      14                 :            : 
      15                 :            : #include <linux/sunrpc/xdr.h>
      16                 :            : #include <linux/sunrpc/clnt.h>
      17                 :            : #include <linux/sunrpc/svc.h>
      18                 :            : #include <linux/sunrpc/stats.h>
      19                 :            : #include <linux/lockd/lockd.h>
      20                 :            : 
      21                 :            : #define NLMDBG_FACILITY         NLMDBG_XDR
      22                 :            : 
      23                 :            : static inline loff_t
      24                 :            : s64_to_loff_t(__s64 offset)
      25                 :            : {
      26                 :            :         return (loff_t)offset;
      27                 :            : }
      28                 :            : 
      29                 :            : 
      30                 :            : static inline s64
      31                 :            : loff_t_to_s64(loff_t offset)
      32                 :            : {
      33                 :            :         s64 res;
      34                 :            :         if (offset > NLM4_OFFSET_MAX)
      35                 :            :                 res = NLM4_OFFSET_MAX;
      36   [ #  #  #  # ]:          0 :         else if (offset < -NLM4_OFFSET_MAX)
      37                 :            :                 res = -NLM4_OFFSET_MAX;
      38                 :            :         else
      39                 :            :                 res = offset;
      40                 :            :         return res;
      41                 :            : }
      42                 :            : 
      43                 :            : /*
      44                 :            :  * XDR functions for basic NLM types
      45                 :            :  */
      46                 :            : static __be32 *
      47                 :          0 : nlm4_decode_cookie(__be32 *p, struct nlm_cookie *c)
      48                 :            : {
      49                 :            :         unsigned int    len;
      50                 :            : 
      51                 :          0 :         len = ntohl(*p++);
      52                 :            :         
      53         [ #  # ]:          0 :         if(len==0)
      54                 :            :         {
      55                 :          0 :                 c->len=4;
      56                 :          0 :                 memset(c->data, 0, 4);       /* hockeypux brain damage */
      57                 :            :         }
      58         [ #  # ]:          0 :         else if(len<=NLM_MAXCOOKIELEN)
      59                 :            :         {
      60                 :          0 :                 c->len=len;
      61                 :          0 :                 memcpy(c->data, p, len);
      62                 :          0 :                 p+=XDR_QUADLEN(len);
      63                 :            :         }
      64                 :            :         else 
      65                 :            :         {
      66                 :            :                 dprintk("lockd: bad cookie size %d (only cookies under "
      67                 :            :                         "%d bytes are supported.)\n",
      68                 :            :                                 len, NLM_MAXCOOKIELEN);
      69                 :            :                 return NULL;
      70                 :            :         }
      71                 :          0 :         return p;
      72                 :            : }
      73                 :            : 
      74                 :            : static __be32 *
      75                 :          0 : nlm4_encode_cookie(__be32 *p, struct nlm_cookie *c)
      76                 :            : {
      77                 :          0 :         *p++ = htonl(c->len);
      78                 :          0 :         memcpy(p, c->data, c->len);
      79                 :          0 :         p+=XDR_QUADLEN(c->len);
      80                 :          0 :         return p;
      81                 :            : }
      82                 :            : 
      83                 :            : static __be32 *
      84                 :          0 : nlm4_decode_fh(__be32 *p, struct nfs_fh *f)
      85                 :            : {
      86                 :          0 :         memset(f->data, 0, sizeof(f->data));
      87                 :          0 :         f->size = ntohl(*p++);
      88         [ #  # ]:          0 :         if (f->size > NFS_MAXFHSIZE) {
      89                 :            :                 dprintk("lockd: bad fhandle size %d (should be <=%d)\n",
      90                 :            :                         f->size, NFS_MAXFHSIZE);
      91                 :            :                 return NULL;
      92                 :            :         }
      93                 :          0 :         memcpy(f->data, p, f->size);
      94                 :          0 :         return p + XDR_QUADLEN(f->size);
      95                 :            : }
      96                 :            : 
      97                 :            : /*
      98                 :            :  * Encode and decode owner handle
      99                 :            :  */
     100                 :            : static __be32 *
     101                 :            : nlm4_decode_oh(__be32 *p, struct xdr_netobj *oh)
     102                 :            : {
     103                 :          0 :         return xdr_decode_netobj(p, oh);
     104                 :            : }
     105                 :            : 
     106                 :            : static __be32 *
     107                 :          0 : nlm4_decode_lock(__be32 *p, struct nlm_lock *lock)
     108                 :            : {
     109                 :          0 :         struct file_lock        *fl = &lock->fl;
     110                 :            :         __u64                   len, start;
     111                 :            :         __s64                   end;
     112                 :            : 
     113         [ #  # ]:          0 :         if (!(p = xdr_decode_string_inplace(p, &lock->caller,
     114                 :            :                                             &lock->len, NLM_MAXSTRLEN))
     115         [ #  # ]:          0 :          || !(p = nlm4_decode_fh(p, &lock->fh))
     116         [ #  # ]:          0 :          || !(p = nlm4_decode_oh(p, &lock->oh)))
     117                 :            :                 return NULL;
     118                 :          0 :         lock->svid  = ntohl(*p++);
     119                 :            : 
     120                 :          0 :         locks_init_lock(fl);
     121                 :          0 :         fl->fl_flags = FL_POSIX;
     122                 :          0 :         fl->fl_type  = F_RDLCK;              /* as good as anything else */
     123                 :            :         p = xdr_decode_hyper(p, &start);
     124                 :            :         p = xdr_decode_hyper(p, &len);
     125                 :          0 :         end = start + len - 1;
     126                 :            : 
     127                 :          0 :         fl->fl_start = s64_to_loff_t(start);
     128                 :            : 
     129   [ #  #  #  # ]:          0 :         if (len == 0 || end < 0)
     130                 :          0 :                 fl->fl_end = OFFSET_MAX;
     131                 :            :         else
     132                 :          0 :                 fl->fl_end = s64_to_loff_t(end);
     133                 :          0 :         return p;
     134                 :            : }
     135                 :            : 
     136                 :            : /*
     137                 :            :  * Encode result of a TEST/TEST_MSG call
     138                 :            :  */
     139                 :            : static __be32 *
     140                 :          0 : nlm4_encode_testres(__be32 *p, struct nlm_res *resp)
     141                 :            : {
     142                 :            :         s64             start, len;
     143                 :            : 
     144                 :            :         dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp);
     145         [ #  # ]:          0 :         if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
     146                 :            :                 return NULL;
     147                 :          0 :         *p++ = resp->status;
     148                 :            : 
     149         [ #  # ]:          0 :         if (resp->status == nlm_lck_denied) {
     150                 :            :                 struct file_lock        *fl = &resp->lock.fl;
     151                 :            : 
     152         [ #  # ]:          0 :                 *p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one;
     153                 :          0 :                 *p++ = htonl(resp->lock.svid);
     154                 :            : 
     155                 :            :                 /* Encode owner handle. */
     156         [ #  # ]:          0 :                 if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
     157                 :            :                         return NULL;
     158                 :            : 
     159                 :          0 :                 start = loff_t_to_s64(fl->fl_start);
     160         [ #  # ]:          0 :                 if (fl->fl_end == OFFSET_MAX)
     161                 :            :                         len = 0;
     162                 :            :                 else
     163                 :          0 :                         len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
     164                 :            :                 
     165                 :          0 :                 p = xdr_encode_hyper(p, start);
     166                 :          0 :                 p = xdr_encode_hyper(p, len);
     167                 :            :                 dprintk("xdr: encode_testres (status %u pid %d type %d start %Ld end %Ld)\n",
     168                 :            :                         resp->status, (int)resp->lock.svid, fl->fl_type,
     169                 :            :                         (long long)fl->fl_start,  (long long)fl->fl_end);
     170                 :            :         }
     171                 :            : 
     172                 :            :         dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp);
     173                 :          0 :         return p;
     174                 :            : }
     175                 :            : 
     176                 :            : 
     177                 :            : /*
     178                 :            :  * First, the server side XDR functions
     179                 :            :  */
     180                 :            : int
     181                 :          0 : nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p)
     182                 :            : {
     183                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     184                 :            :         u32     exclusive;
     185                 :            : 
     186         [ #  # ]:          0 :         if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
     187                 :            :                 return 0;
     188                 :            : 
     189                 :          0 :         exclusive = ntohl(*p++);
     190         [ #  # ]:          0 :         if (!(p = nlm4_decode_lock(p, &argp->lock)))
     191                 :            :                 return 0;
     192         [ #  # ]:          0 :         if (exclusive)
     193                 :          0 :                 argp->lock.fl.fl_type = F_WRLCK;
     194                 :            : 
     195                 :          0 :         return xdr_argsize_check(rqstp, p);
     196                 :            : }
     197                 :            : 
     198                 :            : int
     199                 :          0 : nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p)
     200                 :            : {
     201                 :          0 :         struct nlm_res *resp = rqstp->rq_resp;
     202                 :            : 
     203         [ #  # ]:          0 :         if (!(p = nlm4_encode_testres(p, resp)))
     204                 :            :                 return 0;
     205                 :          0 :         return xdr_ressize_check(rqstp, p);
     206                 :            : }
     207                 :            : 
     208                 :            : int
     209                 :          0 : nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p)
     210                 :            : {
     211                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     212                 :            :         u32     exclusive;
     213                 :            : 
     214         [ #  # ]:          0 :         if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
     215                 :            :                 return 0;
     216                 :          0 :         argp->block  = ntohl(*p++);
     217                 :          0 :         exclusive    = ntohl(*p++);
     218         [ #  # ]:          0 :         if (!(p = nlm4_decode_lock(p, &argp->lock)))
     219                 :            :                 return 0;
     220         [ #  # ]:          0 :         if (exclusive)
     221                 :          0 :                 argp->lock.fl.fl_type = F_WRLCK;
     222                 :          0 :         argp->reclaim = ntohl(*p++);
     223                 :          0 :         argp->state   = ntohl(*p++);
     224                 :          0 :         argp->monitor = 1;           /* monitor client by default */
     225                 :            : 
     226                 :          0 :         return xdr_argsize_check(rqstp, p);
     227                 :            : }
     228                 :            : 
     229                 :            : int
     230                 :          0 : nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p)
     231                 :            : {
     232                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     233                 :            :         u32     exclusive;
     234                 :            : 
     235         [ #  # ]:          0 :         if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
     236                 :            :                 return 0;
     237                 :          0 :         argp->block = ntohl(*p++);
     238                 :          0 :         exclusive = ntohl(*p++);
     239         [ #  # ]:          0 :         if (!(p = nlm4_decode_lock(p, &argp->lock)))
     240                 :            :                 return 0;
     241         [ #  # ]:          0 :         if (exclusive)
     242                 :          0 :                 argp->lock.fl.fl_type = F_WRLCK;
     243                 :          0 :         return xdr_argsize_check(rqstp, p);
     244                 :            : }
     245                 :            : 
     246                 :            : int
     247                 :          0 : nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p)
     248                 :            : {
     249                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     250                 :            : 
     251         [ #  # ]:          0 :         if (!(p = nlm4_decode_cookie(p, &argp->cookie))
     252         [ #  # ]:          0 :          || !(p = nlm4_decode_lock(p, &argp->lock)))
     253                 :            :                 return 0;
     254                 :          0 :         argp->lock.fl.fl_type = F_UNLCK;
     255                 :          0 :         return xdr_argsize_check(rqstp, p);
     256                 :            : }
     257                 :            : 
     258                 :            : int
     259                 :          0 : nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p)
     260                 :            : {
     261                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     262                 :          0 :         struct nlm_lock *lock = &argp->lock;
     263                 :            : 
     264                 :          0 :         memset(lock, 0, sizeof(*lock));
     265                 :          0 :         locks_init_lock(&lock->fl);
     266                 :          0 :         lock->svid = ~(u32) 0;
     267                 :            : 
     268         [ #  # ]:          0 :         if (!(p = nlm4_decode_cookie(p, &argp->cookie))
     269         [ #  # ]:          0 :          || !(p = xdr_decode_string_inplace(p, &lock->caller,
     270                 :            :                                             &lock->len, NLM_MAXSTRLEN))
     271         [ #  # ]:          0 :          || !(p = nlm4_decode_fh(p, &lock->fh))
     272         [ #  # ]:          0 :          || !(p = nlm4_decode_oh(p, &lock->oh)))
     273                 :            :                 return 0;
     274                 :          0 :         argp->fsm_mode = ntohl(*p++);
     275                 :          0 :         argp->fsm_access = ntohl(*p++);
     276                 :          0 :         return xdr_argsize_check(rqstp, p);
     277                 :            : }
     278                 :            : 
     279                 :            : int
     280                 :          0 : nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p)
     281                 :            : {
     282                 :          0 :         struct nlm_res *resp = rqstp->rq_resp;
     283                 :            : 
     284         [ #  # ]:          0 :         if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
     285                 :            :                 return 0;
     286                 :          0 :         *p++ = resp->status;
     287                 :          0 :         *p++ = xdr_zero;                /* sequence argument */
     288                 :          0 :         return xdr_ressize_check(rqstp, p);
     289                 :            : }
     290                 :            : 
     291                 :            : int
     292                 :          0 : nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p)
     293                 :            : {
     294                 :          0 :         struct nlm_res *resp = rqstp->rq_resp;
     295                 :            : 
     296         [ #  # ]:          0 :         if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
     297                 :            :                 return 0;
     298                 :          0 :         *p++ = resp->status;
     299                 :          0 :         return xdr_ressize_check(rqstp, p);
     300                 :            : }
     301                 :            : 
     302                 :            : int
     303                 :          0 : nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p)
     304                 :            : {
     305                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     306                 :            :         struct nlm_lock *lock = &argp->lock;
     307                 :            : 
     308         [ #  # ]:          0 :         if (!(p = xdr_decode_string_inplace(p, &lock->caller,
     309                 :            :                                             &lock->len, NLM_MAXSTRLEN)))
     310                 :            :                 return 0;
     311                 :          0 :         argp->state = ntohl(*p++);
     312                 :          0 :         return xdr_argsize_check(rqstp, p);
     313                 :            : }
     314                 :            : 
     315                 :            : int
     316                 :          0 : nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p)
     317                 :            : {
     318                 :          0 :         struct nlm_reboot *argp = rqstp->rq_argp;
     319                 :            : 
     320         [ #  # ]:          0 :         if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
     321                 :            :                 return 0;
     322                 :          0 :         argp->state = ntohl(*p++);
     323                 :          0 :         memcpy(&argp->priv.data, p, sizeof(argp->priv.data));
     324                 :          0 :         p += XDR_QUADLEN(SM_PRIV_SIZE);
     325                 :          0 :         return xdr_argsize_check(rqstp, p);
     326                 :            : }
     327                 :            : 
     328                 :            : int
     329                 :          0 : nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p)
     330                 :            : {
     331                 :          0 :         struct nlm_res *resp = rqstp->rq_argp;
     332                 :            : 
     333         [ #  # ]:          0 :         if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
     334                 :            :                 return 0;
     335                 :          0 :         resp->status = *p++;
     336                 :          0 :         return xdr_argsize_check(rqstp, p);
     337                 :            : }
     338                 :            : 
     339                 :            : int
     340                 :          0 : nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p)
     341                 :            : {
     342                 :          0 :         return xdr_argsize_check(rqstp, p);
     343                 :            : }
     344                 :            : 
     345                 :            : int
     346                 :          0 : nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p)
     347                 :            : {
     348                 :          0 :         return xdr_ressize_check(rqstp, p);
     349                 :            : }

Generated by: LCOV version 1.14