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 int
 133 nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p)
 134 {
 135         return 1;
 136 }
 137
 138 int
 139 nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p)
 140 {
 141         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 142         struct nlm_args *argp = rqstp->rq_argp;
 143         u32 exclusive;
 144
 145         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 146                 return 0;
 147         if (xdr_stream_decode_bool(xdr, &exclusive) < 0)
 148                 return 0;
 149         if (!svcxdr_decode_lock(xdr, &argp->lock))
 150                 return 0;
 151         if (exclusive)
 152                 argp->lock.fl.fl_type = F_WRLCK;
 153
 154         return 1;
 155 }
 156
 157 int
 158 nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p)
 159 {
 160         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 161         struct nlm_args *argp = rqstp->rq_argp;
 162         u32 exclusive;
 163
 164         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 165                 return 0;
 166         if (xdr_stream_decode_bool(xdr, &argp->block) < 0)
 167                 return 0;
 168         if (xdr_stream_decode_bool(xdr, &exclusive) < 0)
 169                 return 0;
 170         if (!svcxdr_decode_lock(xdr, &argp->lock))
 171                 return 0;
 172         if (exclusive)
 173                 argp->lock.fl.fl_type = F_WRLCK;
 174         if (xdr_stream_decode_bool(xdr, &argp->reclaim) < 0)
 175                 return 0;
 176         if (xdr_stream_decode_u32(xdr, &argp->state) < 0)
 177                 return 0;
 178         argp->monitor = 1;              /* monitor client by default */
 179
 180         return 1;
 181 }
 182
 183 int
 184 nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p)
 185 {
 186         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 187         struct nlm_args *argp = rqstp->rq_argp;
 188         u32 exclusive;
 189
 190         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 191                 return 0;
 192         if (xdr_stream_decode_bool(xdr, &argp->block) < 0)
 193                 return 0;
 194         if (xdr_stream_decode_bool(xdr, &exclusive) < 0)
 195                 return 0;
 196         if (!svcxdr_decode_lock(xdr, &argp->lock))
 197                 return 0;
 198         if (exclusive)
 199                 argp->lock.fl.fl_type = F_WRLCK;
 200         return 1;
 201 }
 202
 203 int
 204 nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p)
 205 {
 206         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 207         struct nlm_args *argp = rqstp->rq_argp;
 208
 209         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 210                 return 0;
 211         if (!svcxdr_decode_lock(xdr, &argp->lock))
 212                 return 0;
 213         argp->lock.fl.fl_type = F_UNLCK;
 214
 215         return 1;
 216 }
 217
 218 int
 219 nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p)
 220 {
 221         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 222         struct nlm_res *resp = rqstp->rq_argp;
 223
 224         if (!svcxdr_decode_cookie(xdr, &resp->cookie))
 225                 return 0;
 226         if (!svcxdr_decode_stats(xdr, &resp->status))
 227                 return 0;
 228
 229         return 1;
 230 }
 231
 232 int
 233 nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p)
 234 {
 235         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 236         struct nlm_reboot *argp = rqstp->rq_argp;
 237         u32 len;
 238
 239         if (xdr_stream_decode_u32(xdr, &len) < 0)
 240                 return 0;
 241         if (len > SM_MAXSTRLEN)
 242                 return 0;
 243         p = xdr_inline_decode(xdr, len);
 244         if (!p)
 245                 return 0;
 246         argp->len = len;
 247         argp->mon = (char *)p;
 248         if (xdr_stream_decode_u32(xdr, &argp->state) < 0)
 249                 return 0;
 250         p = xdr_inline_decode(xdr, SM_PRIV_SIZE);
 251         if (!p)
 252                 return 0;
 253         memcpy(&argp->priv.data, p, sizeof(argp->priv.data));
 254
 255         return 1;
 256 }
 257
 258 int
 259 nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p)
 260 {
 261         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 262         struct nlm_args *argp = rqstp->rq_argp;
 263         struct nlm_lock *lock = &argp->lock;
 264
 265         memset(lock, 0, sizeof(*lock));
 266         locks_init_lock(&lock->fl);
 267         lock->svid = ~(u32)0;
 268
 269         if (!svcxdr_decode_cookie(xdr, &argp->cookie))
 270                 return 0;
 271         if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))
 272                 return 0;
 273         if (!svcxdr_decode_fhandle(xdr, &lock->fh))
 274                 return 0;
 275         if (!svcxdr_decode_owner(xdr, &lock->oh))
 276                 return 0;
 277         /* XXX: Range checks are missing in the original code */
 278         if (xdr_stream_decode_u32(xdr, &argp->fsm_mode) < 0)
 279                 return 0;
 280         if (xdr_stream_decode_u32(xdr, &argp->fsm_access) < 0)
 281                 return 0;
 282
 283         return 1;
 284 }
 285
 286 int
 287 nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p)
 288 {
 289         struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 290         struct nlm_args *argp = rqstp->rq_argp;
 291         struct nlm_lock *lock = &argp->lock;
 292
 293         if (!svcxdr_decode_string(xdr, &lock->caller, &lock->len))
 294                 return 0;
 295         if (xdr_stream_decode_u32(xdr, &argp->state) < 0)
 296                 return 0;
 297
 298         return 1;
 299 }
 300
 301
 302 /*
 303  * Encode Reply results
 304  */
 305
 306 int
 307 nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p)
 308 {
 309         return 1;
 310 }
 311
 312 int
 313 nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p)
 314 {
 315         struct xdr_stream *xdr = &rqstp->rq_res_stream;
 316         struct nlm_res *resp = rqstp->rq_resp;
 317
 318         return svcxdr_encode_cookie(xdr, &resp->cookie) &&
 319                 svcxdr_encode_testrply(xdr, resp);
 320 }
 321
 322 int
 323 nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p)
 324 {
 325         struct xdr_stream *xdr = &rqstp->rq_res_stream;
 326         struct nlm_res *resp = rqstp->rq_resp;
 327
 328         return svcxdr_encode_cookie(xdr, &resp->cookie) &&
 329                 svcxdr_encode_stats(xdr, resp->status);
 330 }
 331
 332 int
 333 nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p)
 334 {
 335         struct xdr_stream *xdr = &rqstp->rq_res_stream;
 336         struct nlm_res *resp = rqstp->rq_resp;
 337
 338         if (!svcxdr_encode_cookie(xdr, &resp->cookie))
 339                 return 0;
 340         if (!svcxdr_encode_stats(xdr, resp->status))
 341                 return 0;
 342         /* sequence */
 343         if (xdr_stream_encode_u32(xdr, 0) < 0)
 344                 return 0;
 345
 346         return 1;
 347 }