Branch data Line data Source code
1 : : /*
2 : : * linux/fs/lockd/clntxdr.c
3 : : *
4 : : * XDR functions to encode/decode NLM version 3 RPC arguments and results.
5 : : * NLM version 3 is backwards compatible with NLM versions 1 and 2.
6 : : *
7 : : * NLM client-side only.
8 : : *
9 : : * Copyright (C) 2010, Oracle. All rights reserved.
10 : : */
11 : :
12 : : #include <linux/types.h>
13 : : #include <linux/sunrpc/xdr.h>
14 : : #include <linux/sunrpc/clnt.h>
15 : : #include <linux/sunrpc/stats.h>
16 : : #include <linux/lockd/lockd.h>
17 : :
18 : : #define NLMDBG_FACILITY NLMDBG_XDR
19 : :
20 : : #if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
21 : : # error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"
22 : : #endif
23 : :
24 : : /*
25 : : * Declare the space requirements for NLM arguments and replies as
26 : : * number of 32bit-words
27 : : */
28 : : #define NLM_cookie_sz (1+(NLM_MAXCOOKIELEN>>2))
29 : : #define NLM_caller_sz (1+(NLMCLNT_OHSIZE>>2))
30 : : #define NLM_owner_sz (1+(NLMCLNT_OHSIZE>>2))
31 : : #define NLM_fhandle_sz (1+(NFS2_FHSIZE>>2))
32 : : #define NLM_lock_sz (3+NLM_caller_sz+NLM_owner_sz+NLM_fhandle_sz)
33 : : #define NLM_holder_sz (4+NLM_owner_sz)
34 : :
35 : : #define NLM_testargs_sz (NLM_cookie_sz+1+NLM_lock_sz)
36 : : #define NLM_lockargs_sz (NLM_cookie_sz+4+NLM_lock_sz)
37 : : #define NLM_cancargs_sz (NLM_cookie_sz+2+NLM_lock_sz)
38 : : #define NLM_unlockargs_sz (NLM_cookie_sz+NLM_lock_sz)
39 : :
40 : : #define NLM_testres_sz (NLM_cookie_sz+1+NLM_holder_sz)
41 : : #define NLM_res_sz (NLM_cookie_sz+1)
42 : : #define NLM_norep_sz (0)
43 : :
44 : :
45 : : static s32 loff_t_to_s32(loff_t offset)
46 : : {
47 : : s32 res;
48 : :
49 [ # # ][ # # ]: 0 : if (offset >= NLM_OFFSET_MAX)
50 : : res = NLM_OFFSET_MAX;
51 [ # # ][ # # ]: 0 : else if (offset <= -NLM_OFFSET_MAX)
52 : : res = -NLM_OFFSET_MAX;
53 : : else
54 : 0 : res = offset;
55 : : return res;
56 : : }
57 : :
58 : 0 : static void nlm_compute_offsets(const struct nlm_lock *lock,
59 : : u32 *l_offset, u32 *l_len)
60 : : {
61 : : const struct file_lock *fl = &lock->fl;
62 : :
63 : 0 : *l_offset = loff_t_to_s32(fl->fl_start);
64 [ # # ]: 0 : if (fl->fl_end == OFFSET_MAX)
65 : 0 : *l_len = 0;
66 : : else
67 : 0 : *l_len = loff_t_to_s32(fl->fl_end - fl->fl_start + 1);
68 : 0 : }
69 : :
70 : : /*
71 : : * Handle decode buffer overflows out-of-line.
72 : : */
73 : : static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
74 : : {
75 : : dprintk("lockd: %s prematurely hit the end of our receive buffer. "
76 : : "Remaining buffer length is %tu words.\n",
77 : : func, xdr->end - xdr->p);
78 : : }
79 : :
80 : :
81 : : /*
82 : : * Encode/decode NLMv3 basic data types
83 : : *
84 : : * Basic NLMv3 data types are not defined in an IETF standards
85 : : * document. X/Open has a description of these data types that
86 : : * is useful. See Chapter 10 of "Protocols for Interworking:
87 : : * XNFS, Version 3W".
88 : : *
89 : : * Not all basic data types have their own encoding and decoding
90 : : * functions. For run-time efficiency, some data types are encoded
91 : : * or decoded inline.
92 : : */
93 : :
94 : : static void encode_bool(struct xdr_stream *xdr, const int value)
95 : : {
96 : : __be32 *p;
97 : :
98 : 0 : p = xdr_reserve_space(xdr, 4);
99 [ # # ][ # # ]: 0 : *p = value ? xdr_one : xdr_zero;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
100 : : }
101 : :
102 : 0 : static void encode_int32(struct xdr_stream *xdr, const s32 value)
103 : : {
104 : : __be32 *p;
105 : :
106 : 0 : p = xdr_reserve_space(xdr, 4);
107 [ # # ]: 0 : *p = cpu_to_be32(value);
108 : 0 : }
109 : :
110 : : /*
111 : : * typedef opaque netobj<MAXNETOBJ_SZ>
112 : : */
113 : 0 : static void encode_netobj(struct xdr_stream *xdr,
114 : : const u8 *data, const unsigned int length)
115 : : {
116 : : __be32 *p;
117 : :
118 : 0 : p = xdr_reserve_space(xdr, 4 + length);
119 : 0 : xdr_encode_opaque(p, data, length);
120 : 0 : }
121 : :
122 : 0 : static int decode_netobj(struct xdr_stream *xdr,
123 : : struct xdr_netobj *obj)
124 : : {
125 : : u32 length;
126 : : __be32 *p;
127 : :
128 : 0 : p = xdr_inline_decode(xdr, 4);
129 [ # # ]: 0 : if (unlikely(p == NULL))
130 : : goto out_overflow;
131 : 0 : length = be32_to_cpup(p++);
132 [ # # ]: 0 : if (unlikely(length > XDR_MAX_NETOBJ))
133 : : goto out_size;
134 : 0 : obj->len = length;
135 : 0 : obj->data = (u8 *)p;
136 : 0 : return 0;
137 : : out_size:
138 : : dprintk("NFS: returned netobj was too long: %u\n", length);
139 : : return -EIO;
140 : : out_overflow:
141 : : print_overflow_msg(__func__, xdr);
142 : : return -EIO;
143 : : }
144 : :
145 : : /*
146 : : * netobj cookie;
147 : : */
148 : : static void encode_cookie(struct xdr_stream *xdr,
149 : : const struct nlm_cookie *cookie)
150 : : {
151 : 0 : encode_netobj(xdr, (u8 *)&cookie->data, cookie->len);
152 : : }
153 : :
154 : 0 : static int decode_cookie(struct xdr_stream *xdr,
155 : : struct nlm_cookie *cookie)
156 : : {
157 : : u32 length;
158 : : __be32 *p;
159 : :
160 : 0 : p = xdr_inline_decode(xdr, 4);
161 [ # # ]: 0 : if (unlikely(p == NULL))
162 : : goto out_overflow;
163 : 0 : length = be32_to_cpup(p++);
164 : : /* apparently HPUX can return empty cookies */
165 [ # # ]: 0 : if (length == 0)
166 : : goto out_hpux;
167 [ # # ]: 0 : if (length > NLM_MAXCOOKIELEN)
168 : : goto out_size;
169 : 0 : p = xdr_inline_decode(xdr, length);
170 [ # # ]: 0 : if (unlikely(p == NULL))
171 : : goto out_overflow;
172 : 0 : cookie->len = length;
173 : 0 : memcpy(cookie->data, p, length);
174 : 0 : return 0;
175 : : out_hpux:
176 : 0 : cookie->len = 4;
177 : 0 : memset(cookie->data, 0, 4);
178 : 0 : return 0;
179 : : out_size:
180 : : dprintk("NFS: returned cookie was too long: %u\n", length);
181 : : return -EIO;
182 : : out_overflow:
183 : : print_overflow_msg(__func__, xdr);
184 : : return -EIO;
185 : : }
186 : :
187 : : /*
188 : : * netobj fh;
189 : : */
190 : : static void encode_fh(struct xdr_stream *xdr, const struct nfs_fh *fh)
191 : : {
192 : 0 : encode_netobj(xdr, (u8 *)&fh->data, NFS2_FHSIZE);
193 : : }
194 : :
195 : : /*
196 : : * enum nlm_stats {
197 : : * LCK_GRANTED = 0,
198 : : * LCK_DENIED = 1,
199 : : * LCK_DENIED_NOLOCKS = 2,
200 : : * LCK_BLOCKED = 3,
201 : : * LCK_DENIED_GRACE_PERIOD = 4
202 : : * };
203 : : *
204 : : *
205 : : * struct nlm_stat {
206 : : * nlm_stats stat;
207 : : * };
208 : : *
209 : : * NB: we don't swap bytes for the NLM status values. The upper
210 : : * layers deal directly with the status value in network byte
211 : : * order.
212 : : */
213 : :
214 : 0 : static void encode_nlm_stat(struct xdr_stream *xdr,
215 : : const __be32 stat)
216 : : {
217 : : __be32 *p;
218 : :
219 [ # # ][ # # ]: 0 : WARN_ON_ONCE(be32_to_cpu(stat) > NLM_LCK_DENIED_GRACE_PERIOD);
[ # # ][ # # ]
220 : 0 : p = xdr_reserve_space(xdr, 4);
221 : 0 : *p = stat;
222 : 0 : }
223 : :
224 : 0 : static int decode_nlm_stat(struct xdr_stream *xdr,
225 : : __be32 *stat)
226 : : {
227 : : __be32 *p;
228 : :
229 : 0 : p = xdr_inline_decode(xdr, 4);
230 [ # # ]: 0 : if (unlikely(p == NULL))
231 : : goto out_overflow;
232 [ # # ][ # # ]: 0 : if (unlikely(ntohl(*p) > ntohl(nlm_lck_denied_grace_period)))
233 : : goto out_enum;
234 : 0 : *stat = *p;
235 : 0 : return 0;
236 : : out_enum:
237 : : dprintk("%s: server returned invalid nlm_stats value: %u\n",
238 : : __func__, be32_to_cpup(p));
239 : : return -EIO;
240 : : out_overflow:
241 : : print_overflow_msg(__func__, xdr);
242 : : return -EIO;
243 : : }
244 : :
245 : : /*
246 : : * struct nlm_holder {
247 : : * bool exclusive;
248 : : * int uppid;
249 : : * netobj oh;
250 : : * unsigned l_offset;
251 : : * unsigned l_len;
252 : : * };
253 : : */
254 : 0 : static void encode_nlm_holder(struct xdr_stream *xdr,
255 : : const struct nlm_res *result)
256 : : {
257 : 0 : const struct nlm_lock *lock = &result->lock;
258 : : u32 l_offset, l_len;
259 : : __be32 *p;
260 : :
261 : 0 : encode_bool(xdr, lock->fl.fl_type == F_RDLCK);
262 : 0 : encode_int32(xdr, lock->svid);
263 : 0 : encode_netobj(xdr, lock->oh.data, lock->oh.len);
264 : :
265 : 0 : p = xdr_reserve_space(xdr, 4 + 4);
266 : 0 : nlm_compute_offsets(lock, &l_offset, &l_len);
267 [ # # ]: 0 : *p++ = cpu_to_be32(l_offset);
268 [ # # ]: 0 : *p = cpu_to_be32(l_len);
269 : 0 : }
270 : :
271 : 0 : static int decode_nlm_holder(struct xdr_stream *xdr, struct nlm_res *result)
272 : : {
273 : 0 : struct nlm_lock *lock = &result->lock;
274 : 0 : struct file_lock *fl = &lock->fl;
275 : : u32 exclusive, l_offset, l_len;
276 : : int error;
277 : 0 : __be32 *p;
278 : : s32 end;
279 : :
280 : 0 : memset(lock, 0, sizeof(*lock));
281 : 0 : locks_init_lock(fl);
282 : :
283 : 0 : p = xdr_inline_decode(xdr, 4 + 4);
284 [ # # ]: 0 : if (unlikely(p == NULL))
285 : : goto out_overflow;
286 : 0 : exclusive = be32_to_cpup(p++);
287 : 0 : lock->svid = be32_to_cpup(p);
288 : 0 : fl->fl_pid = (pid_t)lock->svid;
289 : :
290 : 0 : error = decode_netobj(xdr, &lock->oh);
291 [ # # ]: 0 : if (unlikely(error))
292 : : goto out;
293 : :
294 : 0 : p = xdr_inline_decode(xdr, 4 + 4);
295 [ # # ]: 0 : if (unlikely(p == NULL))
296 : : goto out_overflow;
297 : :
298 : 0 : fl->fl_flags = FL_POSIX;
299 : 0 : fl->fl_type = exclusive != 0 ? F_WRLCK : F_RDLCK;
300 : 0 : l_offset = be32_to_cpup(p++);
301 : : l_len = be32_to_cpup(p);
302 : 0 : end = l_offset + l_len - 1;
303 : :
304 : 0 : fl->fl_start = (loff_t)l_offset;
305 [ # # ]: 0 : if (l_len == 0 || end < 0)
306 : 0 : fl->fl_end = OFFSET_MAX;
307 : : else
308 : 0 : fl->fl_end = (loff_t)end;
309 : : error = 0;
310 : : out:
311 : 0 : return error;
312 : : out_overflow:
313 : : print_overflow_msg(__func__, xdr);
314 : : return -EIO;
315 : : }
316 : :
317 : : /*
318 : : * string caller_name<LM_MAXSTRLEN>;
319 : : */
320 : 0 : static void encode_caller_name(struct xdr_stream *xdr, const char *name)
321 : : {
322 : : /* NB: client-side does not set lock->len */
323 : 0 : u32 length = strlen(name);
324 : : __be32 *p;
325 : :
326 : 0 : p = xdr_reserve_space(xdr, 4 + length);
327 : 0 : xdr_encode_opaque(p, name, length);
328 : 0 : }
329 : :
330 : : /*
331 : : * struct nlm_lock {
332 : : * string caller_name<LM_MAXSTRLEN>;
333 : : * netobj fh;
334 : : * netobj oh;
335 : : * int uppid;
336 : : * unsigned l_offset;
337 : : * unsigned l_len;
338 : : * };
339 : : */
340 : 0 : static void encode_nlm_lock(struct xdr_stream *xdr,
341 : : const struct nlm_lock *lock)
342 : : {
343 : : u32 l_offset, l_len;
344 : : __be32 *p;
345 : :
346 : 0 : encode_caller_name(xdr, lock->caller);
347 : : encode_fh(xdr, &lock->fh);
348 : 0 : encode_netobj(xdr, lock->oh.data, lock->oh.len);
349 : :
350 : 0 : p = xdr_reserve_space(xdr, 4 + 4 + 4);
351 [ # # ]: 0 : *p++ = cpu_to_be32(lock->svid);
352 : :
353 : 0 : nlm_compute_offsets(lock, &l_offset, &l_len);
354 [ # # ]: 0 : *p++ = cpu_to_be32(l_offset);
355 [ # # ]: 0 : *p = cpu_to_be32(l_len);
356 : 0 : }
357 : :
358 : :
359 : : /*
360 : : * NLMv3 XDR encode functions
361 : : *
362 : : * NLMv3 argument types are defined in Chapter 10 of The Open Group's
363 : : * "Protocols for Interworking: XNFS, Version 3W".
364 : : */
365 : :
366 : : /*
367 : : * struct nlm_testargs {
368 : : * netobj cookie;
369 : : * bool exclusive;
370 : : * struct nlm_lock alock;
371 : : * };
372 : : */
373 : 0 : static void nlm_xdr_enc_testargs(struct rpc_rqst *req,
374 : : struct xdr_stream *xdr,
375 : : const struct nlm_args *args)
376 : : {
377 : 0 : const struct nlm_lock *lock = &args->lock;
378 : :
379 : : encode_cookie(xdr, &args->cookie);
380 : 0 : encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
381 : 0 : encode_nlm_lock(xdr, lock);
382 : 0 : }
383 : :
384 : : /*
385 : : * struct nlm_lockargs {
386 : : * netobj cookie;
387 : : * bool block;
388 : : * bool exclusive;
389 : : * struct nlm_lock alock;
390 : : * bool reclaim;
391 : : * int state;
392 : : * };
393 : : */
394 : 0 : static void nlm_xdr_enc_lockargs(struct rpc_rqst *req,
395 : : struct xdr_stream *xdr,
396 : : const struct nlm_args *args)
397 : : {
398 : 0 : const struct nlm_lock *lock = &args->lock;
399 : :
400 : : encode_cookie(xdr, &args->cookie);
401 : 0 : encode_bool(xdr, args->block);
402 : 0 : encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
403 : 0 : encode_nlm_lock(xdr, lock);
404 : 0 : encode_bool(xdr, args->reclaim);
405 : 0 : encode_int32(xdr, args->state);
406 : 0 : }
407 : :
408 : : /*
409 : : * struct nlm_cancargs {
410 : : * netobj cookie;
411 : : * bool block;
412 : : * bool exclusive;
413 : : * struct nlm_lock alock;
414 : : * };
415 : : */
416 : 0 : static void nlm_xdr_enc_cancargs(struct rpc_rqst *req,
417 : : struct xdr_stream *xdr,
418 : : const struct nlm_args *args)
419 : : {
420 : 0 : const struct nlm_lock *lock = &args->lock;
421 : :
422 : : encode_cookie(xdr, &args->cookie);
423 : 0 : encode_bool(xdr, args->block);
424 : 0 : encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
425 : 0 : encode_nlm_lock(xdr, lock);
426 : 0 : }
427 : :
428 : : /*
429 : : * struct nlm_unlockargs {
430 : : * netobj cookie;
431 : : * struct nlm_lock alock;
432 : : * };
433 : : */
434 : 0 : static void nlm_xdr_enc_unlockargs(struct rpc_rqst *req,
435 : : struct xdr_stream *xdr,
436 : : const struct nlm_args *args)
437 : : {
438 : 0 : const struct nlm_lock *lock = &args->lock;
439 : :
440 : : encode_cookie(xdr, &args->cookie);
441 : 0 : encode_nlm_lock(xdr, lock);
442 : 0 : }
443 : :
444 : : /*
445 : : * struct nlm_res {
446 : : * netobj cookie;
447 : : * nlm_stat stat;
448 : : * };
449 : : */
450 : 0 : static void nlm_xdr_enc_res(struct rpc_rqst *req,
451 : : struct xdr_stream *xdr,
452 : : const struct nlm_res *result)
453 : : {
454 : : encode_cookie(xdr, &result->cookie);
455 : 0 : encode_nlm_stat(xdr, result->status);
456 : 0 : }
457 : :
458 : : /*
459 : : * union nlm_testrply switch (nlm_stats stat) {
460 : : * case LCK_DENIED:
461 : : * struct nlm_holder holder;
462 : : * default:
463 : : * void;
464 : : * };
465 : : *
466 : : * struct nlm_testres {
467 : : * netobj cookie;
468 : : * nlm_testrply test_stat;
469 : : * };
470 : : */
471 : : static void encode_nlm_testrply(struct xdr_stream *xdr,
472 : : const struct nlm_res *result)
473 : : {
474 [ # # ]: 0 : if (result->status == nlm_lck_denied)
475 : 0 : encode_nlm_holder(xdr, result);
476 : : }
477 : :
478 : 0 : static void nlm_xdr_enc_testres(struct rpc_rqst *req,
479 : : struct xdr_stream *xdr,
480 : : const struct nlm_res *result)
481 : : {
482 : : encode_cookie(xdr, &result->cookie);
483 : 0 : encode_nlm_stat(xdr, result->status);
484 : : encode_nlm_testrply(xdr, result);
485 : 0 : }
486 : :
487 : :
488 : : /*
489 : : * NLMv3 XDR decode functions
490 : : *
491 : : * NLMv3 result types are defined in Chapter 10 of The Open Group's
492 : : * "Protocols for Interworking: XNFS, Version 3W".
493 : : */
494 : :
495 : : /*
496 : : * union nlm_testrply switch (nlm_stats stat) {
497 : : * case LCK_DENIED:
498 : : * struct nlm_holder holder;
499 : : * default:
500 : : * void;
501 : : * };
502 : : *
503 : : * struct nlm_testres {
504 : : * netobj cookie;
505 : : * nlm_testrply test_stat;
506 : : * };
507 : : */
508 : 0 : static int decode_nlm_testrply(struct xdr_stream *xdr,
509 : : struct nlm_res *result)
510 : : {
511 : : int error;
512 : :
513 : 0 : error = decode_nlm_stat(xdr, &result->status);
514 [ # # ]: 0 : if (unlikely(error))
515 : : goto out;
516 [ # # ]: 0 : if (result->status == nlm_lck_denied)
517 : 0 : error = decode_nlm_holder(xdr, result);
518 : : out:
519 : 0 : return error;
520 : : }
521 : :
522 : 0 : static int nlm_xdr_dec_testres(struct rpc_rqst *req,
523 : : struct xdr_stream *xdr,
524 : : struct nlm_res *result)
525 : : {
526 : : int error;
527 : :
528 : 0 : error = decode_cookie(xdr, &result->cookie);
529 [ # # ]: 0 : if (unlikely(error))
530 : : goto out;
531 : 0 : error = decode_nlm_testrply(xdr, result);
532 : : out:
533 : 0 : return error;
534 : : }
535 : :
536 : : /*
537 : : * struct nlm_res {
538 : : * netobj cookie;
539 : : * nlm_stat stat;
540 : : * };
541 : : */
542 : 0 : static int nlm_xdr_dec_res(struct rpc_rqst *req,
543 : : struct xdr_stream *xdr,
544 : : struct nlm_res *result)
545 : : {
546 : : int error;
547 : :
548 : 0 : error = decode_cookie(xdr, &result->cookie);
549 [ # # ]: 0 : if (unlikely(error))
550 : : goto out;
551 : 0 : error = decode_nlm_stat(xdr, &result->status);
552 : : out:
553 : 0 : return error;
554 : : }
555 : :
556 : :
557 : : /*
558 : : * For NLM, a void procedure really returns nothing
559 : : */
560 : : #define nlm_xdr_dec_norep NULL
561 : :
562 : : #define PROC(proc, argtype, restype) \
563 : : [NLMPROC_##proc] = { \
564 : : .p_proc = NLMPROC_##proc, \
565 : : .p_encode = (kxdreproc_t)nlm_xdr_enc_##argtype, \
566 : : .p_decode = (kxdrdproc_t)nlm_xdr_dec_##restype, \
567 : : .p_arglen = NLM_##argtype##_sz, \
568 : : .p_replen = NLM_##restype##_sz, \
569 : : .p_statidx = NLMPROC_##proc, \
570 : : .p_name = #proc, \
571 : : }
572 : :
573 : : static struct rpc_procinfo nlm_procedures[] = {
574 : : PROC(TEST, testargs, testres),
575 : : PROC(LOCK, lockargs, res),
576 : : PROC(CANCEL, cancargs, res),
577 : : PROC(UNLOCK, unlockargs, res),
578 : : PROC(GRANTED, testargs, res),
579 : : PROC(TEST_MSG, testargs, norep),
580 : : PROC(LOCK_MSG, lockargs, norep),
581 : : PROC(CANCEL_MSG, cancargs, norep),
582 : : PROC(UNLOCK_MSG, unlockargs, norep),
583 : : PROC(GRANTED_MSG, testargs, norep),
584 : : PROC(TEST_RES, testres, norep),
585 : : PROC(LOCK_RES, res, norep),
586 : : PROC(CANCEL_RES, res, norep),
587 : : PROC(UNLOCK_RES, res, norep),
588 : : PROC(GRANTED_RES, res, norep),
589 : : };
590 : :
591 : : static const struct rpc_version nlm_version1 = {
592 : : .number = 1,
593 : : .nrprocs = ARRAY_SIZE(nlm_procedures),
594 : : .procs = nlm_procedures,
595 : : };
596 : :
597 : : static const struct rpc_version nlm_version3 = {
598 : : .number = 3,
599 : : .nrprocs = ARRAY_SIZE(nlm_procedures),
600 : : .procs = nlm_procedures,
601 : : };
602 : :
603 : : static const struct rpc_version *nlm_versions[] = {
604 : : [1] = &nlm_version1,
605 : : [3] = &nlm_version3,
606 : : #ifdef CONFIG_LOCKD_V4
607 : : [4] = &nlm_version4,
608 : : #endif
609 : : };
610 : :
611 : : static struct rpc_stat nlm_rpc_stats;
612 : :
613 : : const struct rpc_program nlm_program = {
614 : : .name = "lockd",
615 : : .number = NLM_PROGRAM,
616 : : .nrvers = ARRAY_SIZE(nlm_versions),
617 : : .version = nlm_versions,
618 : : .stats = &nlm_rpc_stats,
619 : : };
|
