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 #define NLMDBG_FACILITY NLMDBG_XDR 22 23 static inline loff_t 24 s64_to_loff_t(__s64 offset) 25 { 26 return (loff_t)offset; 27 } 28 29 30 static inline s64 31 loff_t_to_s64(loff_t offset) 32 { 33 s64 res; 34 if (offset > NLM4_OFFSET_MAX) 35 res = NLM4_OFFSET_MAX; 36 else if (offset < -NLM4_OFFSET_MAX) 37 res = -NLM4_OFFSET_MAX; 38 else 39 res = offset; 40 return res; 41 } 42 43 /* 44 * XDR functions for basic NLM types 45 */ 46 static __be32 * 47 nlm4_decode_cookie(__be32 *p, struct nlm_cookie *c) 48 { 49 unsigned int len; 50 51 len = ntohl(*p++); 52 53 if(len==0) 54 { 55 c->len=4; 56 memset(c->data, 0, 4); /* hockeypux brain damage */ 57 } 58 else if(len<=NLM_MAXCOOKIELEN) 59 { 60 c->len=len; 61 memcpy(c->data, p, len); 62 p+=XDR_QUADLEN(len); 63 } 64 else 65 { 66 dprintk("lockd: bad cookie size %d (only cookies under " 67 "%d bytes are supported.)\n", 68 len, NLM_MAXCOOKIELEN); 69 return NULL; 70 } 71 return p; 72 } 73 74 static __be32 * 75 nlm4_encode_cookie(__be32 *p, struct nlm_cookie *c) 76 { 77 *p++ = htonl(c->len); 78 memcpy(p, c->data, c->len); 79 p+=XDR_QUADLEN(c->len); 80 return p; 81 } 82 83 static __be32 * 84 nlm4_decode_fh(__be32 *p, struct nfs_fh *f) 85 { 86 memset(f->data, 0, sizeof(f->data)); 87 f->size = ntohl(*p++); 88 if (f->size > NFS_MAXFHSIZE) { 89 dprintk("lockd: bad fhandle size %d (should be <=%d)\n", 90 f->size, NFS_MAXFHSIZE); 91 return NULL; 92 } 93 memcpy(f->data, p, f->size); 94 return p + XDR_QUADLEN(f->size); 95 } 96 97 /* 98 * Encode and decode owner handle 99 */ 100 static __be32 * 101 nlm4_decode_oh(__be32 *p, struct xdr_netobj *oh) 102 { 103 return xdr_decode_netobj(p, oh); 104 } 105 106 static __be32 * 107 nlm4_decode_lock(__be32 *p, struct nlm_lock *lock) 108 { 109 struct file_lock *fl = &lock->fl; 110 __u64 len, start; 111 __s64 end; 112 113 if (!(p = xdr_decode_string_inplace(p, &lock->caller, 114 &lock->len, NLM_MAXSTRLEN)) 115 || !(p = nlm4_decode_fh(p, &lock->fh)) 116 || !(p = nlm4_decode_oh(p, &lock->oh))) 117 return NULL; 118 lock->svid = ntohl(*p++); 119 120 locks_init_lock(fl); 121 fl->fl_owner = current->files; 122 fl->fl_pid = current->tgid; 123 fl->fl_flags = FL_POSIX; 124 fl->fl_type = F_RDLCK; /* as good as anything else */ 125 p = xdr_decode_hyper(p, &start); 126 p = xdr_decode_hyper(p, &len); 127 end = start + len - 1; 128 129 fl->fl_start = s64_to_loff_t(start); 130 131 if (len == 0 || end < 0) 132 fl->fl_end = OFFSET_MAX; 133 else 134 fl->fl_end = s64_to_loff_t(end); 135 return p; 136 } 137 138 /* 139 * Encode result of a TEST/TEST_MSG call 140 */ 141 static __be32 * 142 nlm4_encode_testres(__be32 *p, struct nlm_res *resp) 143 { 144 s64 start, len; 145 146 dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp); 147 if (!(p = nlm4_encode_cookie(p, &resp->cookie))) 148 return NULL; 149 *p++ = resp->status; 150 151 if (resp->status == nlm_lck_denied) { 152 struct file_lock *fl = &resp->lock.fl; 153 154 *p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one; 155 *p++ = htonl(resp->lock.svid); 156 157 /* Encode owner handle. */ 158 if (!(p = xdr_encode_netobj(p, &resp->lock.oh))) 159 return NULL; 160 161 start = loff_t_to_s64(fl->fl_start); 162 if (fl->fl_end == OFFSET_MAX) 163 len = 0; 164 else 165 len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1); 166 167 p = xdr_encode_hyper(p, start); 168 p = xdr_encode_hyper(p, len); 169 dprintk("xdr: encode_testres (status %u pid %d type %d start %Ld end %Ld)\n", 170 resp->status, (int)resp->lock.svid, fl->fl_type, 171 (long long)fl->fl_start, (long long)fl->fl_end); 172 } 173 174 dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp); 175 return p; 176 } 177 178 179 /* 180 * First, the server side XDR functions 181 */ 182 int 183 nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p) 184 { 185 struct nlm_args *argp = rqstp->rq_argp; 186 u32 exclusive; 187 188 if (!(p = nlm4_decode_cookie(p, &argp->cookie))) 189 return 0; 190 191 exclusive = ntohl(*p++); 192 if (!(p = nlm4_decode_lock(p, &argp->lock))) 193 return 0; 194 if (exclusive) 195 argp->lock.fl.fl_type = F_WRLCK; 196 197 return xdr_argsize_check(rqstp, p); 198 } 199 200 int 201 nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p) 202 { 203 struct nlm_res *resp = rqstp->rq_resp; 204 205 if (!(p = nlm4_encode_testres(p, resp))) 206 return 0; 207 return xdr_ressize_check(rqstp, p); 208 } 209 210 int 211 nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p) 212 { 213 struct nlm_args *argp = rqstp->rq_argp; 214 u32 exclusive; 215 216 if (!(p = nlm4_decode_cookie(p, &argp->cookie))) 217 return 0; 218 argp->block = ntohl(*p++); 219 exclusive = ntohl(*p++); 220 if (!(p = nlm4_decode_lock(p, &argp->lock))) 221 return 0; 222 if (exclusive) 223 argp->lock.fl.fl_type = F_WRLCK; 224 argp->reclaim = ntohl(*p++); 225 argp->state = ntohl(*p++); 226 argp->monitor = 1; /* monitor client by default */ 227 228 return xdr_argsize_check(rqstp, p); 229 } 230 231 int 232 nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p) 233 { 234 struct nlm_args *argp = rqstp->rq_argp; 235 u32 exclusive; 236 237 if (!(p = nlm4_decode_cookie(p, &argp->cookie))) 238 return 0; 239 argp->block = ntohl(*p++); 240 exclusive = ntohl(*p++); 241 if (!(p = nlm4_decode_lock(p, &argp->lock))) 242 return 0; 243 if (exclusive) 244 argp->lock.fl.fl_type = F_WRLCK; 245 return xdr_argsize_check(rqstp, p); 246 } 247 248 int 249 nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p) 250 { 251 struct nlm_args *argp = rqstp->rq_argp; 252 253 if (!(p = nlm4_decode_cookie(p, &argp->cookie)) 254 || !(p = nlm4_decode_lock(p, &argp->lock))) 255 return 0; 256 argp->lock.fl.fl_type = F_UNLCK; 257 return xdr_argsize_check(rqstp, p); 258 } 259 260 int 261 nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p) 262 { 263 struct nlm_args *argp = rqstp->rq_argp; 264 struct nlm_lock *lock = &argp->lock; 265 266 memset(lock, 0, sizeof(*lock)); 267 locks_init_lock(&lock->fl); 268 lock->svid = ~(u32) 0; 269 lock->fl.fl_pid = current->tgid; 270 271 if (!(p = nlm4_decode_cookie(p, &argp->cookie)) 272 || !(p = xdr_decode_string_inplace(p, &lock->caller, 273 &lock->len, NLM_MAXSTRLEN)) 274 || !(p = nlm4_decode_fh(p, &lock->fh)) 275 || !(p = nlm4_decode_oh(p, &lock->oh))) 276 return 0; 277 argp->fsm_mode = ntohl(*p++); 278 argp->fsm_access = ntohl(*p++); 279 return xdr_argsize_check(rqstp, p); 280 } 281 282 int 283 nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p) 284 { 285 struct nlm_res *resp = rqstp->rq_resp; 286 287 if (!(p = nlm4_encode_cookie(p, &resp->cookie))) 288 return 0; 289 *p++ = resp->status; 290 *p++ = xdr_zero; /* sequence argument */ 291 return xdr_ressize_check(rqstp, p); 292 } 293 294 int 295 nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p) 296 { 297 struct nlm_res *resp = rqstp->rq_resp; 298 299 if (!(p = nlm4_encode_cookie(p, &resp->cookie))) 300 return 0; 301 *p++ = resp->status; 302 return xdr_ressize_check(rqstp, p); 303 } 304 305 int 306 nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p) 307 { 308 struct nlm_args *argp = rqstp->rq_argp; 309 struct nlm_lock *lock = &argp->lock; 310 311 if (!(p = xdr_decode_string_inplace(p, &lock->caller, 312 &lock->len, NLM_MAXSTRLEN))) 313 return 0; 314 argp->state = ntohl(*p++); 315 return xdr_argsize_check(rqstp, p); 316 } 317 318 int 319 nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p) 320 { 321 struct nlm_reboot *argp = rqstp->rq_argp; 322 323 if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN))) 324 return 0; 325 argp->state = ntohl(*p++); 326 memcpy(&argp->priv.data, p, sizeof(argp->priv.data)); 327 p += XDR_QUADLEN(SM_PRIV_SIZE); 328 return xdr_argsize_check(rqstp, p); 329 } 330 331 int 332 nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p) 333 { 334 struct nlm_res *resp = rqstp->rq_argp; 335 336 if (!(p = nlm4_decode_cookie(p, &resp->cookie))) 337 return 0; 338 resp->status = *p++; 339 return xdr_argsize_check(rqstp, p); 340 } 341 342 int 343 nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p) 344 { 345 return xdr_argsize_check(rqstp, p); 346 } 347 348 int 349 nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p) 350 { 351 return xdr_ressize_check(rqstp, p); 352 } 353