1
2
3
4
5
6
7
8
9
10
11#include <linux/types.h>
12#include <linux/sunrpc/xdr.h>
13#include <linux/sunrpc/clnt.h>
14#include <linux/sunrpc/stats.h>
15#include <linux/lockd/lockd.h>
16
17#include <uapi/linux/nfs3.h>
18
19#define NLMDBG_FACILITY NLMDBG_XDR
20
21#if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
22# error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"
23#endif
24
25#if (NLMCLNT_OHSIZE > NLM_MAXSTRLEN)
26# error "NLM host name cannot be larger than NLM's maximum string length!"
27#endif
28
29
30
31
32
33#define NLM4_void_sz (0)
34#define NLM4_cookie_sz (1+(NLM_MAXCOOKIELEN>>2))
35#define NLM4_caller_sz (1+(NLMCLNT_OHSIZE>>2))
36#define NLM4_owner_sz (1+(NLMCLNT_OHSIZE>>2))
37#define NLM4_fhandle_sz (1+(NFS3_FHSIZE>>2))
38#define NLM4_lock_sz (5+NLM4_caller_sz+NLM4_owner_sz+NLM4_fhandle_sz)
39#define NLM4_holder_sz (6+NLM4_owner_sz)
40
41#define NLM4_testargs_sz (NLM4_cookie_sz+1+NLM4_lock_sz)
42#define NLM4_lockargs_sz (NLM4_cookie_sz+4+NLM4_lock_sz)
43#define NLM4_cancargs_sz (NLM4_cookie_sz+2+NLM4_lock_sz)
44#define NLM4_unlockargs_sz (NLM4_cookie_sz+NLM4_lock_sz)
45
46#define NLM4_testres_sz (NLM4_cookie_sz+1+NLM4_holder_sz)
47#define NLM4_res_sz (NLM4_cookie_sz+1)
48#define NLM4_norep_sz (0)
49
50
51static s64 loff_t_to_s64(loff_t offset)
52{
53 s64 res;
54
55 if (offset >= NLM4_OFFSET_MAX)
56 res = NLM4_OFFSET_MAX;
57 else if (offset <= -NLM4_OFFSET_MAX)
58 res = -NLM4_OFFSET_MAX;
59 else
60 res = offset;
61 return res;
62}
63
64static void nlm4_compute_offsets(const struct nlm_lock *lock,
65 u64 *l_offset, u64 *l_len)
66{
67 const struct file_lock *fl = &lock->fl;
68
69 *l_offset = loff_t_to_s64(fl->fl_start);
70 if (fl->fl_end == OFFSET_MAX)
71 *l_len = 0;
72 else
73 *l_len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
74}
75
76
77
78
79static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
80{
81 dprintk("lockd: %s prematurely hit the end of our receive buffer. "
82 "Remaining buffer length is %tu words.\n",
83 func, xdr->end - xdr->p);
84}
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99static void encode_bool(struct xdr_stream *xdr, const int value)
100{
101 __be32 *p;
102
103 p = xdr_reserve_space(xdr, 4);
104 *p = value ? xdr_one : xdr_zero;
105}
106
107static void encode_int32(struct xdr_stream *xdr, const s32 value)
108{
109 __be32 *p;
110
111 p = xdr_reserve_space(xdr, 4);
112 *p = cpu_to_be32(value);
113}
114
115
116
117
118static void encode_netobj(struct xdr_stream *xdr,
119 const u8 *data, const unsigned int length)
120{
121 __be32 *p;
122
123 p = xdr_reserve_space(xdr, 4 + length);
124 xdr_encode_opaque(p, data, length);
125}
126
127static int decode_netobj(struct xdr_stream *xdr,
128 struct xdr_netobj *obj)
129{
130 u32 length;
131 __be32 *p;
132
133 p = xdr_inline_decode(xdr, 4);
134 if (unlikely(p == NULL))
135 goto out_overflow;
136 length = be32_to_cpup(p++);
137 if (unlikely(length > XDR_MAX_NETOBJ))
138 goto out_size;
139 obj->len = length;
140 obj->data = (u8 *)p;
141 return 0;
142out_size:
143 dprintk("NFS: returned netobj was too long: %u\n", length);
144 return -EIO;
145out_overflow:
146 print_overflow_msg(__func__, xdr);
147 return -EIO;
148}
149
150
151
152
153static void encode_cookie(struct xdr_stream *xdr,
154 const struct nlm_cookie *cookie)
155{
156 encode_netobj(xdr, (u8 *)&cookie->data, cookie->len);
157}
158
159static int decode_cookie(struct xdr_stream *xdr,
160 struct nlm_cookie *cookie)
161{
162 u32 length;
163 __be32 *p;
164
165 p = xdr_inline_decode(xdr, 4);
166 if (unlikely(p == NULL))
167 goto out_overflow;
168 length = be32_to_cpup(p++);
169
170 if (length == 0)
171 goto out_hpux;
172 if (length > NLM_MAXCOOKIELEN)
173 goto out_size;
174 p = xdr_inline_decode(xdr, length);
175 if (unlikely(p == NULL))
176 goto out_overflow;
177 cookie->len = length;
178 memcpy(cookie->data, p, length);
179 return 0;
180out_hpux:
181 cookie->len = 4;
182 memset(cookie->data, 0, 4);
183 return 0;
184out_size:
185 dprintk("NFS: returned cookie was too long: %u\n", length);
186 return -EIO;
187out_overflow:
188 print_overflow_msg(__func__, xdr);
189 return -EIO;
190}
191
192
193
194
195static void encode_fh(struct xdr_stream *xdr, const struct nfs_fh *fh)
196{
197 encode_netobj(xdr, (u8 *)&fh->data, fh->size);
198}
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222static void encode_nlm4_stat(struct xdr_stream *xdr,
223 const __be32 stat)
224{
225 __be32 *p;
226
227 BUG_ON(be32_to_cpu(stat) > NLM_FAILED);
228 p = xdr_reserve_space(xdr, 4);
229 *p = stat;
230}
231
232static int decode_nlm4_stat(struct xdr_stream *xdr, __be32 *stat)
233{
234 __be32 *p;
235
236 p = xdr_inline_decode(xdr, 4);
237 if (unlikely(p == NULL))
238 goto out_overflow;
239 if (unlikely(ntohl(*p) > ntohl(nlm4_failed)))
240 goto out_bad_xdr;
241 *stat = *p;
242 return 0;
243out_bad_xdr:
244 dprintk("%s: server returned invalid nlm4_stats value: %u\n",
245 __func__, be32_to_cpup(p));
246 return -EIO;
247out_overflow:
248 print_overflow_msg(__func__, xdr);
249 return -EIO;
250}
251
252
253
254
255
256
257
258
259
260
261static void encode_nlm4_holder(struct xdr_stream *xdr,
262 const struct nlm_res *result)
263{
264 const struct nlm_lock *lock = &result->lock;
265 u64 l_offset, l_len;
266 __be32 *p;
267
268 encode_bool(xdr, lock->fl.fl_type == F_RDLCK);
269 encode_int32(xdr, lock->svid);
270 encode_netobj(xdr, lock->oh.data, lock->oh.len);
271
272 p = xdr_reserve_space(xdr, 4 + 4);
273 nlm4_compute_offsets(lock, &l_offset, &l_len);
274 p = xdr_encode_hyper(p, l_offset);
275 xdr_encode_hyper(p, l_len);
276}
277
278static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result)
279{
280 struct nlm_lock *lock = &result->lock;
281 struct file_lock *fl = &lock->fl;
282 u64 l_offset, l_len;
283 u32 exclusive;
284 int error;
285 __be32 *p;
286 s32 end;
287
288 memset(lock, 0, sizeof(*lock));
289 locks_init_lock(fl);
290
291 p = xdr_inline_decode(xdr, 4 + 4);
292 if (unlikely(p == NULL))
293 goto out_overflow;
294 exclusive = be32_to_cpup(p++);
295 lock->svid = be32_to_cpup(p);
296 fl->fl_pid = (pid_t)lock->svid;
297
298 error = decode_netobj(xdr, &lock->oh);
299 if (unlikely(error))
300 goto out;
301
302 p = xdr_inline_decode(xdr, 8 + 8);
303 if (unlikely(p == NULL))
304 goto out_overflow;
305
306 fl->fl_flags = FL_POSIX;
307 fl->fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK;
308 p = xdr_decode_hyper(p, &l_offset);
309 xdr_decode_hyper(p, &l_len);
310 end = l_offset + l_len - 1;
311
312 fl->fl_start = (loff_t)l_offset;
313 if (l_len == 0 || end < 0)
314 fl->fl_end = OFFSET_MAX;
315 else
316 fl->fl_end = (loff_t)end;
317 error = 0;
318out:
319 return error;
320out_overflow:
321 print_overflow_msg(__func__, xdr);
322 return -EIO;
323}
324
325
326
327
328static void encode_caller_name(struct xdr_stream *xdr, const char *name)
329{
330
331 u32 length = strlen(name);
332 __be32 *p;
333
334 p = xdr_reserve_space(xdr, 4 + length);
335 xdr_encode_opaque(p, name, length);
336}
337
338
339
340
341
342
343
344
345
346
347
348static void encode_nlm4_lock(struct xdr_stream *xdr,
349 const struct nlm_lock *lock)
350{
351 u64 l_offset, l_len;
352 __be32 *p;
353
354 encode_caller_name(xdr, lock->caller);
355 encode_fh(xdr, &lock->fh);
356 encode_netobj(xdr, lock->oh.data, lock->oh.len);
357
358 p = xdr_reserve_space(xdr, 4 + 8 + 8);
359 *p++ = cpu_to_be32(lock->svid);
360
361 nlm4_compute_offsets(lock, &l_offset, &l_len);
362 p = xdr_encode_hyper(p, l_offset);
363 xdr_encode_hyper(p, l_len);
364}
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382static void nlm4_xdr_enc_testargs(struct rpc_rqst *req,
383 struct xdr_stream *xdr,
384 const void *data)
385{
386 const struct nlm_args *args = data;
387 const struct nlm_lock *lock = &args->lock;
388
389 encode_cookie(xdr, &args->cookie);
390 encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
391 encode_nlm4_lock(xdr, lock);
392}
393
394
395
396
397
398
399
400
401
402
403
404static void nlm4_xdr_enc_lockargs(struct rpc_rqst *req,
405 struct xdr_stream *xdr,
406 const void *data)
407{
408 const struct nlm_args *args = data;
409 const struct nlm_lock *lock = &args->lock;
410
411 encode_cookie(xdr, &args->cookie);
412 encode_bool(xdr, args->block);
413 encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
414 encode_nlm4_lock(xdr, lock);
415 encode_bool(xdr, args->reclaim);
416 encode_int32(xdr, args->state);
417}
418
419
420
421
422
423
424
425
426
427static void nlm4_xdr_enc_cancargs(struct rpc_rqst *req,
428 struct xdr_stream *xdr,
429 const void *data)
430{
431 const struct nlm_args *args = data;
432 const struct nlm_lock *lock = &args->lock;
433
434 encode_cookie(xdr, &args->cookie);
435 encode_bool(xdr, args->block);
436 encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
437 encode_nlm4_lock(xdr, lock);
438}
439
440
441
442
443
444
445
446static void nlm4_xdr_enc_unlockargs(struct rpc_rqst *req,
447 struct xdr_stream *xdr,
448 const void *data)
449{
450 const struct nlm_args *args = data;
451 const struct nlm_lock *lock = &args->lock;
452
453 encode_cookie(xdr, &args->cookie);
454 encode_nlm4_lock(xdr, lock);
455}
456
457
458
459
460
461
462
463static void nlm4_xdr_enc_res(struct rpc_rqst *req,
464 struct xdr_stream *xdr,
465 const void *data)
466{
467 const struct nlm_res *result = data;
468
469 encode_cookie(xdr, &result->cookie);
470 encode_nlm4_stat(xdr, result->status);
471}
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486static void nlm4_xdr_enc_testres(struct rpc_rqst *req,
487 struct xdr_stream *xdr,
488 const void *data)
489{
490 const struct nlm_res *result = data;
491
492 encode_cookie(xdr, &result->cookie);
493 encode_nlm4_stat(xdr, result->status);
494 if (result->status == nlm_lck_denied)
495 encode_nlm4_holder(xdr, result);
496}
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520static int decode_nlm4_testrply(struct xdr_stream *xdr,
521 struct nlm_res *result)
522{
523 int error;
524
525 error = decode_nlm4_stat(xdr, &result->status);
526 if (unlikely(error))
527 goto out;
528 if (result->status == nlm_lck_denied)
529 error = decode_nlm4_holder(xdr, result);
530out:
531 return error;
532}
533
534static int nlm4_xdr_dec_testres(struct rpc_rqst *req,
535 struct xdr_stream *xdr,
536 void *data)
537{
538 struct nlm_res *result = data;
539 int error;
540
541 error = decode_cookie(xdr, &result->cookie);
542 if (unlikely(error))
543 goto out;
544 error = decode_nlm4_testrply(xdr, result);
545out:
546 return error;
547}
548
549
550
551
552
553
554
555static int nlm4_xdr_dec_res(struct rpc_rqst *req,
556 struct xdr_stream *xdr,
557 void *data)
558{
559 struct nlm_res *result = data;
560 int error;
561
562 error = decode_cookie(xdr, &result->cookie);
563 if (unlikely(error))
564 goto out;
565 error = decode_nlm4_stat(xdr, &result->status);
566out:
567 return error;
568}
569
570
571
572
573
574#define nlm4_xdr_dec_norep NULL
575
576#define PROC(proc, argtype, restype) \
577[NLMPROC_##proc] = { \
578 .p_proc = NLMPROC_##proc, \
579 .p_encode = nlm4_xdr_enc_##argtype, \
580 .p_decode = nlm4_xdr_dec_##restype, \
581 .p_arglen = NLM4_##argtype##_sz, \
582 .p_replen = NLM4_##restype##_sz, \
583 .p_statidx = NLMPROC_##proc, \
584 .p_name = #proc, \
585 }
586
587static const struct rpc_procinfo nlm4_procedures[] = {
588 PROC(TEST, testargs, testres),
589 PROC(LOCK, lockargs, res),
590 PROC(CANCEL, cancargs, res),
591 PROC(UNLOCK, unlockargs, res),
592 PROC(GRANTED, testargs, res),
593 PROC(TEST_MSG, testargs, norep),
594 PROC(LOCK_MSG, lockargs, norep),
595 PROC(CANCEL_MSG, cancargs, norep),
596 PROC(UNLOCK_MSG, unlockargs, norep),
597 PROC(GRANTED_MSG, testargs, norep),
598 PROC(TEST_RES, testres, norep),
599 PROC(LOCK_RES, res, norep),
600 PROC(CANCEL_RES, res, norep),
601 PROC(UNLOCK_RES, res, norep),
602 PROC(GRANTED_RES, res, norep),
603};
604
605static unsigned int nlm_version4_counts[ARRAY_SIZE(nlm4_procedures)];
606const struct rpc_version nlm_version4 = {
607 .number = 4,
608 .nrprocs = ARRAY_SIZE(nlm4_procedures),
609 .procs = nlm4_procedures,
610 .counts = nlm_version4_counts,
611};
612