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