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