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