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 } 348