fs/lockd/xdr4.c

   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 #include "svcxdr.h"
  22
  23 static inline s64
  24 loff_t_to_s64(loff_t offset)
  25 {
  26         s64 res;
  27         if (offset > NLM4_OFFSET_MAX)
  28                 res = NLM4_OFFSET_MAX;
  29         else if (offset < -NLM4_OFFSET_MAX)
  30                 res = -NLM4_OFFSET_MAX;
  31         else
  32                 res = offset;
  33         return res;
  34 }
  35
  36 /*
  37  * NLM file handles are defined by specification to be a variable-length
  38  * XDR opaque no longer than 1024 bytes. However, this implementation
  39  * limits their length to the size of an NFSv3 file handle.
  40  */
  41 static bool
  42 svcxdr_decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh)
  43 {
  44         __be32 *p;
  45         u32 len;
  46
  47         if (xdr_stream_decode_u32(xdr, &len) < 0)
  48                 return false;
  49         if (len > NFS_MAXFHSIZE)
  50                 return false;
  51
  52         p = xdr_inline_decode(xdr, len);
  53         if (!p)
  54                 return false;
  55         fh->size = len;
  56         memcpy(fh->data, p, len);
  57         memset(fh->data + len, 0, sizeof(fh->data) - len);
  58
  59         return true;
  60 }
  61
  62 static bool
  63 svcxdr_decode_lock(struct xdr_stream *xdr, struct nlm_lock *lock)
  64 {
  65         struct file_lock *fl = &lock->fl;
  66
  67         if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))
  68                 return false;
  69         if (!svcxdr_decode_fhandle(xdr, &lock->fh))
  70                 return false;
  71         if (!svcxdr_decode_owner(xdr, &lock->oh))
  72                 return false;
  73         if (xdr_stream_decode_u32(xdr, &lock->svid) < 0)
  74                 return false;
  75         if (xdr_stream_decode_u64(xdr, &lock->lock_start) < 0)
  76                 return false;
  77         if (xdr_stream_decode_u64(xdr, &lock->lock_len) < 0)
  78                 return false;
  79
  80         locks_init_lock(fl);
  81         fl->fl_flags = FL_POSIX;
  82         fl->fl_type  = F_RDLCK;
  83
  84         return true;
  85 }
  86
  87 static bool
  88 svcxdr_encode_holder(struct xdr_stream *xdr, const struct nlm_lock *lock)
  89 {
  90         const struct file_lock *fl = &lock->fl;
  91         s64 start, len;
  92
  93         /* exclusive */
  94         if (xdr_stream_encode_bool(xdr, fl->fl_type != F_RDLCK) < 0)
  95                 return false;
  96         if (xdr_stream_encode_u32(xdr, lock->svid) < 0)
  97                 return false;
  98         if (!svcxdr_encode_owner(xdr, &lock->oh))
  99                 return false;
 100         start = loff_t_to_s64(fl->fl_start);
 101         if (fl->fl_end == OFFSET_MAX)
 102                 len = 0;
 103         else
 104                 len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
 105         if (xdr_stream_encode_u64(xdr, start) < 0)
 106                 return false;
 107         if (xdr_stream_encode_u64(xdr, len) < 0)
 108                 return false;
 109
 110         return true;
 111 }
 112
 113 static bool
 114 svcxdr_encode_testrply(struct xdr_stream *xdr, const struct nlm_res *resp)
 115 {
 116         if (!svcxdr_encode_stats(xdr, resp->status))
 117                 return false;
 118         switch (resp->status) {
 119         case nlm_lck_denied:
 120                 if (!svcxdr_encode_holder(xdr, &resp->lock))
 121                         return false;
 122         }
 123
 124         return true;
 125 }
 126
 127
 128 /*
 129  * Decode Call arguments
 130  */
 131
 132 bool
 133 nlm4svc_decode_void(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 134 {
 135         return true;
 136 }
 137
 138 bool
 139 nlm4svc_decode_testargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 140 {
 141         struct nlm_args *argp = rqstp->rq_argp;
 142         u32 exclusive;
 143
 144         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 145                 return false;
 146         if (xdr_stream_decode_bool(xdr, &exclusive) < 0)
 147                 return false;
 148         if (!svcxdr_decode_lock(xdr, &argp->lock))
 149                 return false;
 150         if (exclusive)
 151                 argp->lock.fl.fl_type = F_WRLCK;
 152
 153         return true;
 154 }
 155
 156 bool
 157 nlm4svc_decode_lockargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 158 {
 159         struct nlm_args *argp = rqstp->rq_argp;
 160         u32 exclusive;
 161
 162         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 163                 return false;
 164         if (xdr_stream_decode_bool(xdr, &argp->block) < 0)
 165                 return false;
 166         if (xdr_stream_decode_bool(xdr, &exclusive) < 0)
 167                 return false;
 168         if (!svcxdr_decode_lock(xdr, &argp->lock))
 169                 return false;
 170         if (exclusive)
 171                 argp->lock.fl.fl_type = F_WRLCK;
 172         if (xdr_stream_decode_bool(xdr, &argp->reclaim) < 0)
 173                 return false;
 174         if (xdr_stream_decode_u32(xdr, &argp->state) < 0)
 175                 return false;
 176         argp->monitor = 1;              /* monitor client by default */
 177
 178         return true;
 179 }
 180
 181 bool
 182 nlm4svc_decode_cancargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 183 {
 184         struct nlm_args *argp = rqstp->rq_argp;
 185         u32 exclusive;
 186
 187         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 188                 return false;
 189         if (xdr_stream_decode_bool(xdr, &argp->block) < 0)
 190                 return false;
 191         if (xdr_stream_decode_bool(xdr, &exclusive) < 0)
 192                 return false;
 193         if (!svcxdr_decode_lock(xdr, &argp->lock))
 194                 return false;
 195         if (exclusive)
 196                 argp->lock.fl.fl_type = F_WRLCK;
 197
 198         return true;
 199 }
 200
 201 bool
 202 nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 203 {
 204         struct nlm_args *argp = rqstp->rq_argp;
 205
 206         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 207                 return false;
 208         if (!svcxdr_decode_lock(xdr, &argp->lock))
 209                 return false;
 210         argp->lock.fl.fl_type = F_UNLCK;
 211
 212         return true;
 213 }
 214
 215 bool
 216 nlm4svc_decode_res(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 217 {
 218         struct nlm_res *resp = rqstp->rq_argp;
 219
 220         if (!svcxdr_decode_cookie(xdr, &resp->cookie))
 221                 return false;
 222         if (!svcxdr_decode_stats(xdr, &resp->status))
 223                 return false;
 224
 225         return true;
 226 }
 227
 228 bool
 229 nlm4svc_decode_reboot(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 230 {
 231         struct nlm_reboot *argp = rqstp->rq_argp;
 232         __be32 *p;
 233         u32 len;
 234
 235         if (xdr_stream_decode_u32(xdr, &len) < 0)
 236                 return false;
 237         if (len > SM_MAXSTRLEN)
 238                 return false;
 239         p = xdr_inline_decode(xdr, len);
 240         if (!p)
 241                 return false;
 242         argp->len = len;
 243         argp->mon = (char *)p;
 244         if (xdr_stream_decode_u32(xdr, &argp->state) < 0)
 245                 return false;
 246         p = xdr_inline_decode(xdr, SM_PRIV_SIZE);
 247         if (!p)
 248                 return false;
 249         memcpy(&argp->priv.data, p, sizeof(argp->priv.data));
 250
 251         return true;
 252 }
 253
 254 bool
 255 nlm4svc_decode_shareargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 256 {
 257         struct nlm_args *argp = rqstp->rq_argp;
 258         struct nlm_lock *lock = &argp->lock;
 259
 260         memset(lock, 0, sizeof(*lock));
 261         locks_init_lock(&lock->fl);
 262         lock->svid = ~(u32)0;
 263
 264         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 265                 return false;
 266         if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))
 267                 return false;
 268         if (!svcxdr_decode_fhandle(xdr, &lock->fh))
 269                 return false;
 270         if (!svcxdr_decode_owner(xdr, &lock->oh))
 271                 return false;
 272         /* XXX: Range checks are missing in the original code */
 273         if (xdr_stream_decode_u32(xdr, &argp->fsm_mode) < 0)
 274                 return false;
 275         if (xdr_stream_decode_u32(xdr, &argp->fsm_access) < 0)
 276                 return false;
 277
 278         return true;
 279 }
 280
 281 bool
 282 nlm4svc_decode_notify(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 283 {
 284         struct nlm_args *argp = rqstp->rq_argp;
 285         struct nlm_lock *lock = &argp->lock;
 286
 287         if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))
 288                 return false;
 289         if (xdr_stream_decode_u32(xdr, &argp->state) < 0)
 290                 return false;
 291
 292         return true;
 293 }
 294
 295
 296 /*
 297  * Encode Reply results
 298  */
 299
 300 bool
 301 nlm4svc_encode_void(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 302 {
 303         return true;
 304 }
 305
 306 bool
 307 nlm4svc_encode_testres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 308 {
 309         struct nlm_res *resp = rqstp->rq_resp;
 310
 311         return svcxdr_encode_cookie(xdr, &resp->cookie) &&
 312                 svcxdr_encode_testrply(xdr, resp);
 313 }
 314
 315 bool
 316 nlm4svc_encode_res(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 317 {
 318         struct nlm_res *resp = rqstp->rq_resp;
 319
 320         return svcxdr_encode_cookie(xdr, &resp->cookie) &&
 321                 svcxdr_encode_stats(xdr, resp->status);
 322 }
 323
 324 bool
 325 nlm4svc_encode_shareres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 326 {
 327         struct nlm_res *resp = rqstp->rq_resp;
 328
 329         if (!svcxdr_encode_cookie(xdr, &resp->cookie))
 330                 return false;
 331         if (!svcxdr_encode_stats(xdr, resp->status))
 332                 return false;
 333         /* sequence */
 334         if (xdr_stream_encode_u32(xdr, 0) < 0)
 335                 return false;
 336
 337         return true;
 338 }