Whamcloud - gitweb
f1141a074ee682008412cef929f708015fe0b971
[fs/lustre-release.git] / lustre / ptlrpc / sec_plain.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2015, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  *
31  * lustre/ptlrpc/sec_plain.c
32  *
33  * Author: Eric Mei <ericm@clusterfs.com>
34  */
35
36 #define DEBUG_SUBSYSTEM S_SEC
37
38
39 #include <obd_support.h>
40 #include <obd_cksum.h>
41 #include <obd_class.h>
42 #include <lustre_net.h>
43 #include <lustre_sec.h>
44
45 #include "ptlrpc_internal.h"
46
47 struct plain_sec {
48         struct ptlrpc_sec pls_base;
49         rwlock_t pls_lock;
50         struct ptlrpc_cli_ctx *pls_ctx;
51 };
52
53 static inline struct plain_sec *sec2plsec(struct ptlrpc_sec *sec)
54 {
55         return container_of(sec, struct plain_sec, pls_base);
56 }
57
58 static struct ptlrpc_sec_policy plain_policy;
59 static struct ptlrpc_ctx_ops    plain_ctx_ops;
60 static struct ptlrpc_svc_ctx    plain_svc_ctx;
61
62 static unsigned int plain_at_offset;
63
64 /*
65  * for simplicity, plain policy rpc use fixed layout.
66  */
67 #define PLAIN_PACK_SEGMENTS             (4)
68
69 #define PLAIN_PACK_HDR_OFF              (0)
70 #define PLAIN_PACK_MSG_OFF              (1)
71 #define PLAIN_PACK_USER_OFF             (2)
72 #define PLAIN_PACK_BULK_OFF             (3)
73
74 #define PLAIN_FL_USER                   (0x01)
75 #define PLAIN_FL_BULK                   (0x02)
76
77 struct plain_header {
78         __u8 ph_ver;            /* 0 */
79         __u8 ph_flags;
80         __u8 ph_sp;             /* source */
81         __u8 ph_bulk_hash_alg;  /* complete flavor desc */
82         __u8 ph_pad[4];
83 };
84
85 struct plain_bulk_token {
86         __u8 pbt_hash[8];
87 };
88
89 #define PLAIN_BSD_SIZE \
90         (sizeof(struct ptlrpc_bulk_sec_desc) + sizeof(struct plain_bulk_token))
91
92 /*
93  * bulk checksum helpers
94  */
95
96 static int plain_unpack_bsd(struct lustre_msg *msg, int swabbed)
97 {
98         struct ptlrpc_bulk_sec_desc *bsd;
99
100         if (bulk_sec_desc_unpack(msg, PLAIN_PACK_BULK_OFF, swabbed))
101                 return -EPROTO;
102
103         bsd = lustre_msg_buf(msg, PLAIN_PACK_BULK_OFF, PLAIN_BSD_SIZE);
104         if (bsd == NULL) {
105                 CERROR("bulk sec desc has short size %d\n",
106                        lustre_msg_buflen(msg, PLAIN_PACK_BULK_OFF));
107                 return -EPROTO;
108         }
109
110         if (bsd->bsd_svc != SPTLRPC_BULK_SVC_NULL &&
111             bsd->bsd_svc != SPTLRPC_BULK_SVC_INTG) {
112                 CERROR("invalid bulk svc %u\n", bsd->bsd_svc);
113                 return -EPROTO;
114         }
115
116         return 0;
117 }
118
119 static int plain_generate_bulk_csum(struct ptlrpc_bulk_desc *desc,
120                                     __u8 hash_alg,
121                                     struct plain_bulk_token *token)
122 {
123         if (hash_alg == BULK_HASH_ALG_NULL)
124                 return 0;
125
126         memset(token->pbt_hash, 0, sizeof(token->pbt_hash));
127         return sptlrpc_get_bulk_checksum(desc, hash_alg, token->pbt_hash,
128                                          sizeof(token->pbt_hash));
129 }
130
131 static int plain_verify_bulk_csum(struct ptlrpc_bulk_desc *desc,
132                                   __u8 hash_alg,
133                                   struct plain_bulk_token *tokenr)
134 {
135         struct plain_bulk_token tokenv;
136         int rc;
137
138         if (hash_alg == BULK_HASH_ALG_NULL)
139                 return 0;
140
141         memset(&tokenv.pbt_hash, 0, sizeof(tokenv.pbt_hash));
142         rc = sptlrpc_get_bulk_checksum(desc, hash_alg, tokenv.pbt_hash,
143                                        sizeof(tokenv.pbt_hash));
144         if (rc)
145                 return rc;
146
147         if (memcmp(tokenr->pbt_hash, tokenv.pbt_hash, sizeof(tokenr->pbt_hash)))
148                 return -EACCES;
149         return 0;
150 }
151
152 static void corrupt_bulk_data(struct ptlrpc_bulk_desc *desc)
153 {
154         char *ptr;
155         unsigned int off, i;
156
157         for (i = 0; i < desc->bd_iov_count; i++) {
158                 if (desc->bd_vec[i].bv_len == 0)
159                         continue;
160
161                 ptr = kmap(desc->bd_vec[i].bv_page);
162                 off = desc->bd_vec[i].bv_offset & ~PAGE_MASK;
163                 ptr[off] ^= 0x1;
164                 kunmap(desc->bd_vec[i].bv_page);
165                 return;
166         }
167 }
168
169 /*
170  * cli_ctx apis
171  */
172
173 static
174 int plain_ctx_refresh(struct ptlrpc_cli_ctx *ctx)
175 {
176         /* should never reach here */
177         LBUG();
178         return 0;
179 }
180
181 static
182 int plain_ctx_validate(struct ptlrpc_cli_ctx *ctx)
183 {
184         return 0;
185 }
186
187 static
188 int plain_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
189 {
190         struct lustre_msg *msg = req->rq_reqbuf;
191         struct plain_header *phdr;
192
193         ENTRY;
194
195         msg->lm_secflvr = req->rq_flvr.sf_rpc;
196
197         phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, 0);
198         phdr->ph_ver = 0;
199         phdr->ph_flags = 0;
200         phdr->ph_sp = ctx->cc_sec->ps_part;
201         phdr->ph_bulk_hash_alg = req->rq_flvr.u_bulk.hash.hash_alg;
202
203         if (req->rq_pack_udesc)
204                 phdr->ph_flags |= PLAIN_FL_USER;
205         if (req->rq_pack_bulk)
206                 phdr->ph_flags |= PLAIN_FL_BULK;
207
208         req->rq_reqdata_len = lustre_msg_size_v2(msg->lm_bufcount,
209                                                  msg->lm_buflens);
210         RETURN(0);
211 }
212
213 static
214 int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
215 {
216         struct lustre_msg *msg = req->rq_repdata;
217         struct plain_header *phdr;
218         bool swabbed;
219
220         ENTRY;
221         if (msg->lm_bufcount != PLAIN_PACK_SEGMENTS) {
222                 CERROR("unexpected reply buf count %u\n", msg->lm_bufcount);
223                 RETURN(-EPROTO);
224         }
225
226         swabbed = req_capsule_rep_need_swab(&req->rq_pill);
227
228         phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, sizeof(*phdr));
229         if (phdr == NULL) {
230                 CERROR("missing plain header\n");
231                 RETURN(-EPROTO);
232         }
233
234         if (phdr->ph_ver != 0) {
235                 CERROR("Invalid header version\n");
236                 RETURN(-EPROTO);
237         }
238
239         /* expect no user desc in reply */
240         if (phdr->ph_flags & PLAIN_FL_USER) {
241                 CERROR("Unexpected udesc flag in reply\n");
242                 RETURN(-EPROTO);
243         }
244
245         if (phdr->ph_bulk_hash_alg != req->rq_flvr.u_bulk.hash.hash_alg) {
246                 CERROR("reply bulk flavor %u != %u\n", phdr->ph_bulk_hash_alg,
247                        req->rq_flvr.u_bulk.hash.hash_alg);
248                 RETURN(-EPROTO);
249         }
250
251         if (unlikely(req->rq_early)) {
252                 __u32 cksum = lustre_msg_calc_cksum(msg, PLAIN_PACK_MSG_OFF);
253
254                 if (cksum != msg->lm_cksum) {
255                         CDEBUG(D_SEC,
256                                "early reply checksum mismatch: %08x != %08x\n",
257                                cpu_to_le32(cksum), msg->lm_cksum);
258                         RETURN(-EINVAL);
259                 }
260         } else {
261                 /*
262                  * whether we sent with bulk or not, we expect the same
263                  * in reply, except for early reply
264                  */
265                 if (!req->rq_early &&
266                     !equi(req->rq_pack_bulk == 1,
267                         phdr->ph_flags & PLAIN_FL_BULK)) {
268                         CERROR("%s bulk checksum in reply\n",
269                                req->rq_pack_bulk ? "Missing" : "Unexpected");
270                         RETURN(-EPROTO);
271                 }
272
273                 if (phdr->ph_flags & PLAIN_FL_BULK) {
274                         if (plain_unpack_bsd(msg, swabbed))
275                                 RETURN(-EPROTO);
276                 }
277         }
278
279         req->rq_repmsg = lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0);
280         req->rq_replen = lustre_msg_buflen(msg, PLAIN_PACK_MSG_OFF);
281         RETURN(0);
282 }
283
284 static
285 int plain_cli_wrap_bulk(struct ptlrpc_cli_ctx *ctx,
286                         struct ptlrpc_request *req,
287                         struct ptlrpc_bulk_desc *desc)
288 {
289         struct ptlrpc_bulk_sec_desc *bsd;
290         struct plain_bulk_token *token;
291         int rc;
292
293         LASSERT(req->rq_pack_bulk);
294         LASSERT(req->rq_reqbuf->lm_bufcount == PLAIN_PACK_SEGMENTS);
295
296         bsd = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
297         token = (struct plain_bulk_token *) bsd->bsd_data;
298
299         bsd->bsd_version = 0;
300         bsd->bsd_flags = 0;
301         bsd->bsd_type = SPTLRPC_BULK_DEFAULT;
302         bsd->bsd_svc = SPTLRPC_FLVR_BULK_SVC(req->rq_flvr.sf_rpc);
303
304         if (bsd->bsd_svc == SPTLRPC_BULK_SVC_NULL)
305                 RETURN(0);
306
307         if (req->rq_bulk_read)
308                 RETURN(0);
309
310         rc = plain_generate_bulk_csum(desc, req->rq_flvr.u_bulk.hash.hash_alg,
311                                       token);
312         if (rc) {
313                 CERROR("bulk write: failed to compute checksum: %d\n", rc);
314         } else {
315                 /*
316                  * for sending we only compute the wrong checksum instead
317                  * of corrupting the data so it is still correct on a redo
318                  */
319                 if (OBD_FAIL_CHECK(OBD_FAIL_OSC_CHECKSUM_SEND) &&
320                     req->rq_flvr.u_bulk.hash.hash_alg != BULK_HASH_ALG_NULL)
321                         token->pbt_hash[0] ^= 0x1;
322         }
323
324         return rc;
325 }
326
327 static
328 int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
329                           struct ptlrpc_request *req,
330                           struct ptlrpc_bulk_desc *desc)
331 {
332         struct ptlrpc_bulk_sec_desc *bsdv;
333         struct plain_bulk_token *tokenv;
334         int rc;
335         int i, nob;
336
337         LASSERT(req->rq_pack_bulk);
338         LASSERT(req->rq_reqbuf->lm_bufcount == PLAIN_PACK_SEGMENTS);
339         LASSERT(req->rq_repdata->lm_bufcount == PLAIN_PACK_SEGMENTS);
340
341         bsdv = lustre_msg_buf(req->rq_repdata, PLAIN_PACK_BULK_OFF, 0);
342         tokenv = (struct plain_bulk_token *) bsdv->bsd_data;
343
344         if (req->rq_bulk_write) {
345                 if (bsdv->bsd_flags & BSD_FL_ERR)
346                         return -EIO;
347                 return 0;
348         }
349
350         /* fix the actual data size */
351         for (i = 0, nob = 0; i < desc->bd_iov_count; i++) {
352                 if (desc->bd_vec[i].bv_len +
353                     nob > desc->bd_nob_transferred) {
354                         desc->bd_vec[i].bv_len =
355                                 desc->bd_nob_transferred - nob;
356                 }
357                 nob += desc->bd_vec[i].bv_len;
358         }
359
360         rc = plain_verify_bulk_csum(desc, req->rq_flvr.u_bulk.hash.hash_alg,
361                                     tokenv);
362         if (rc)
363                 CERROR("bulk read: client verify failed: %d\n", rc);
364
365         return rc;
366 }
367
368 /*
369  * sec apis
370  */
371
372 static
373 struct ptlrpc_cli_ctx *plain_sec_install_ctx(struct plain_sec *plsec)
374 {
375         struct ptlrpc_cli_ctx  *ctx, *ctx_new;
376
377         OBD_ALLOC_PTR(ctx_new);
378
379         write_lock(&plsec->pls_lock);
380
381         ctx = plsec->pls_ctx;
382         if (ctx) {
383                 atomic_inc(&ctx->cc_refcount);
384
385                 if (ctx_new)
386                         OBD_FREE_PTR(ctx_new);
387         } else if (ctx_new) {
388                 ctx = ctx_new;
389
390                 atomic_set(&ctx->cc_refcount, 1);       /* for cache */
391                 ctx->cc_sec = &plsec->pls_base;
392                 ctx->cc_ops = &plain_ctx_ops;
393                 ctx->cc_expire = 0;
394                 ctx->cc_flags = PTLRPC_CTX_CACHED | PTLRPC_CTX_UPTODATE;
395                 ctx->cc_vcred.vc_uid = 0;
396                 spin_lock_init(&ctx->cc_lock);
397                 INIT_LIST_HEAD(&ctx->cc_req_list);
398                 INIT_LIST_HEAD(&ctx->cc_gc_chain);
399
400                 plsec->pls_ctx = ctx;
401                 atomic_inc(&plsec->pls_base.ps_nctx);
402                 atomic_inc(&plsec->pls_base.ps_refcount);
403
404                 atomic_inc(&ctx->cc_refcount);  /* for caller */
405         }
406
407         write_unlock(&plsec->pls_lock);
408
409         return ctx;
410 }
411
412 static
413 void plain_destroy_sec(struct ptlrpc_sec *sec)
414 {
415         struct plain_sec *plsec = sec2plsec(sec);
416
417         ENTRY;
418
419         LASSERT(sec->ps_policy == &plain_policy);
420         LASSERT(sec->ps_import);
421         LASSERT(atomic_read(&sec->ps_refcount) == 0);
422         LASSERT(atomic_read(&sec->ps_nctx) == 0);
423         LASSERT(plsec->pls_ctx == NULL);
424
425         class_import_put(sec->ps_import);
426
427         OBD_FREE_PTR(plsec);
428         EXIT;
429 }
430
431 static
432 void plain_kill_sec(struct ptlrpc_sec *sec)
433 {
434         sec->ps_dying = 1;
435 }
436
437 static
438 struct ptlrpc_sec *plain_create_sec(struct obd_import *imp,
439                                     struct ptlrpc_svc_ctx *svc_ctx,
440                                     struct sptlrpc_flavor *sf)
441 {
442         struct plain_sec *plsec;
443         struct ptlrpc_sec *sec;
444         struct ptlrpc_cli_ctx *ctx;
445
446         ENTRY;
447
448         LASSERT(SPTLRPC_FLVR_POLICY(sf->sf_rpc) == SPTLRPC_POLICY_PLAIN);
449
450         OBD_ALLOC_PTR(plsec);
451         if (plsec == NULL)
452                 RETURN(NULL);
453
454         /*
455          * initialize plain_sec
456          */
457         rwlock_init(&plsec->pls_lock);
458         plsec->pls_ctx = NULL;
459
460         sec = &plsec->pls_base;
461         sec->ps_policy = &plain_policy;
462         atomic_set(&sec->ps_refcount, 0);
463         atomic_set(&sec->ps_nctx, 0);
464         sec->ps_id = sptlrpc_get_next_secid();
465         sec->ps_import = class_import_get(imp);
466         sec->ps_flvr = *sf;
467         spin_lock_init(&sec->ps_lock);
468         INIT_LIST_HEAD(&sec->ps_gc_list);
469         sec->ps_gc_interval = 0;
470         sec->ps_gc_next = 0;
471
472         /* install ctx immediately if this is a reverse sec */
473         if (svc_ctx) {
474                 ctx = plain_sec_install_ctx(plsec);
475                 if (ctx == NULL) {
476                         plain_destroy_sec(sec);
477                         RETURN(NULL);
478                 }
479                 sptlrpc_cli_ctx_put(ctx, 1);
480         }
481
482         RETURN(sec);
483 }
484
485 static
486 struct ptlrpc_cli_ctx *plain_lookup_ctx(struct ptlrpc_sec *sec,
487                                         struct vfs_cred *vcred,
488                                         int create, int remove_dead)
489 {
490         struct plain_sec *plsec = sec2plsec(sec);
491         struct ptlrpc_cli_ctx *ctx;
492
493         ENTRY;
494
495         read_lock(&plsec->pls_lock);
496         ctx = plsec->pls_ctx;
497         if (ctx)
498                 atomic_inc(&ctx->cc_refcount);
499         read_unlock(&plsec->pls_lock);
500
501         if (unlikely(ctx == NULL))
502                 ctx = plain_sec_install_ctx(plsec);
503
504         RETURN(ctx);
505 }
506
507 static
508 void plain_release_ctx(struct ptlrpc_sec *sec,
509                        struct ptlrpc_cli_ctx *ctx, int sync)
510 {
511         LASSERT(atomic_read(&sec->ps_refcount) > 0);
512         LASSERT(atomic_read(&sec->ps_nctx) > 0);
513         LASSERT(atomic_read(&ctx->cc_refcount) == 0);
514         LASSERT(ctx->cc_sec == sec);
515
516         OBD_FREE_PTR(ctx);
517
518         atomic_dec(&sec->ps_nctx);
519         sptlrpc_sec_put(sec);
520 }
521
522 static
523 int plain_flush_ctx_cache(struct ptlrpc_sec *sec,
524                           uid_t uid, int grace, int force)
525 {
526         struct plain_sec *plsec = sec2plsec(sec);
527         struct ptlrpc_cli_ctx *ctx;
528
529         ENTRY;
530
531         /* do nothing unless caller want to flush for 'all' */
532         if (uid != -1)
533                 RETURN(0);
534
535         write_lock(&plsec->pls_lock);
536         ctx = plsec->pls_ctx;
537         plsec->pls_ctx = NULL;
538         write_unlock(&plsec->pls_lock);
539
540         if (ctx)
541                 sptlrpc_cli_ctx_put(ctx, 1);
542         RETURN(0);
543 }
544
545 static
546 int plain_alloc_reqbuf(struct ptlrpc_sec *sec,
547                        struct ptlrpc_request *req,
548                        int msgsize)
549 {
550         __u32 buflens[PLAIN_PACK_SEGMENTS] = { 0, };
551         int alloc_len;
552
553         ENTRY;
554
555         buflens[PLAIN_PACK_HDR_OFF] = sizeof(struct plain_header);
556         buflens[PLAIN_PACK_MSG_OFF] = msgsize;
557
558         if (req->rq_pack_udesc)
559                 buflens[PLAIN_PACK_USER_OFF] = sptlrpc_current_user_desc_size();
560
561         if (req->rq_pack_bulk) {
562                 LASSERT(req->rq_bulk_read || req->rq_bulk_write);
563                 buflens[PLAIN_PACK_BULK_OFF] = PLAIN_BSD_SIZE;
564         }
565
566         alloc_len = lustre_msg_size_v2(PLAIN_PACK_SEGMENTS, buflens);
567
568         if (!req->rq_reqbuf) {
569                 LASSERT(!req->rq_pool);
570
571                 alloc_len = size_roundup_power2(alloc_len);
572                 OBD_ALLOC_LARGE(req->rq_reqbuf, alloc_len);
573                 if (!req->rq_reqbuf)
574                         RETURN(-ENOMEM);
575
576                 req->rq_reqbuf_len = alloc_len;
577         } else {
578                 LASSERT(req->rq_pool);
579                 LASSERT(req->rq_reqbuf_len >= alloc_len);
580                 memset(req->rq_reqbuf, 0, alloc_len);
581         }
582
583         lustre_init_msg_v2(req->rq_reqbuf, PLAIN_PACK_SEGMENTS, buflens, NULL);
584         req->rq_reqmsg = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_MSG_OFF, 0);
585
586         if (req->rq_pack_udesc)
587                 sptlrpc_pack_user_desc(req->rq_reqbuf, PLAIN_PACK_USER_OFF);
588
589         RETURN(0);
590 }
591
592 static
593 void plain_free_reqbuf(struct ptlrpc_sec *sec,
594                        struct ptlrpc_request *req)
595 {
596         ENTRY;
597         if (!req->rq_pool) {
598                 OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
599                 req->rq_reqbuf = NULL;
600                 req->rq_reqbuf_len = 0;
601         }
602         EXIT;
603 }
604
605 static
606 int plain_alloc_repbuf(struct ptlrpc_sec *sec,
607                        struct ptlrpc_request *req,
608                        int msgsize)
609 {
610         __u32 buflens[PLAIN_PACK_SEGMENTS] = { 0, };
611         int alloc_len;
612
613         ENTRY;
614
615         buflens[PLAIN_PACK_HDR_OFF] = sizeof(struct plain_header);
616         buflens[PLAIN_PACK_MSG_OFF] = msgsize;
617
618         if (req->rq_pack_bulk) {
619                 LASSERT(req->rq_bulk_read || req->rq_bulk_write);
620                 buflens[PLAIN_PACK_BULK_OFF] = PLAIN_BSD_SIZE;
621         }
622
623         alloc_len = lustre_msg_size_v2(PLAIN_PACK_SEGMENTS, buflens);
624
625         /* add space for early reply */
626         alloc_len += plain_at_offset;
627
628         alloc_len = size_roundup_power2(alloc_len);
629
630         OBD_ALLOC_LARGE(req->rq_repbuf, alloc_len);
631         if (!req->rq_repbuf)
632                 RETURN(-ENOMEM);
633
634         req->rq_repbuf_len = alloc_len;
635         RETURN(0);
636 }
637
638 static
639 void plain_free_repbuf(struct ptlrpc_sec *sec,
640                        struct ptlrpc_request *req)
641 {
642         ENTRY;
643         OBD_FREE_LARGE(req->rq_repbuf, req->rq_repbuf_len);
644         req->rq_repbuf = NULL;
645         req->rq_repbuf_len = 0;
646         EXIT;
647 }
648
649 static
650 int plain_enlarge_reqbuf(struct ptlrpc_sec *sec,
651                          struct ptlrpc_request *req,
652                          int segment, int newsize)
653 {
654         struct lustre_msg *newbuf;
655         int oldsize;
656         int newmsg_size, newbuf_size;
657
658         ENTRY;
659
660         LASSERT(req->rq_reqbuf);
661         LASSERT(req->rq_reqbuf_len >= req->rq_reqlen);
662         LASSERT(lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_MSG_OFF, 0) ==
663                 req->rq_reqmsg);
664
665         /* compute new embedded msg size.  */
666         oldsize = req->rq_reqmsg->lm_buflens[segment];
667         req->rq_reqmsg->lm_buflens[segment] = newsize;
668         newmsg_size = lustre_msg_size_v2(req->rq_reqmsg->lm_bufcount,
669                                          req->rq_reqmsg->lm_buflens);
670         req->rq_reqmsg->lm_buflens[segment] = oldsize;
671
672         /* compute new wrapper msg size.  */
673         oldsize = req->rq_reqbuf->lm_buflens[PLAIN_PACK_MSG_OFF];
674         req->rq_reqbuf->lm_buflens[PLAIN_PACK_MSG_OFF] = newmsg_size;
675         newbuf_size = lustre_msg_size_v2(req->rq_reqbuf->lm_bufcount,
676                                          req->rq_reqbuf->lm_buflens);
677         req->rq_reqbuf->lm_buflens[PLAIN_PACK_MSG_OFF] = oldsize;
678
679         /* request from pool should always have enough buffer */
680         LASSERT(!req->rq_pool || req->rq_reqbuf_len >= newbuf_size);
681
682         if (req->rq_reqbuf_len < newbuf_size) {
683                 newbuf_size = size_roundup_power2(newbuf_size);
684
685                 OBD_ALLOC_LARGE(newbuf, newbuf_size);
686                 if (newbuf == NULL)
687                         RETURN(-ENOMEM);
688
689                 /*
690                  * Must lock this, so that otherwise unprotected change of
691                  * rq_reqmsg is not racing with parallel processing of
692                  * imp_replay_list traversing threads. See LU-3333
693                  * This is a bandaid at best, we really need to deal with this
694                  * in request enlarging code before unpacking that's already
695                  * there
696                  */
697                 if (req->rq_import)
698                         spin_lock(&req->rq_import->imp_lock);
699
700                 memcpy(newbuf, req->rq_reqbuf, req->rq_reqbuf_len);
701
702                 OBD_FREE_LARGE(req->rq_reqbuf, req->rq_reqbuf_len);
703                 req->rq_reqbuf = newbuf;
704                 req->rq_reqbuf_len = newbuf_size;
705                 req->rq_reqmsg = lustre_msg_buf(req->rq_reqbuf,
706                                                 PLAIN_PACK_MSG_OFF, 0);
707
708                 if (req->rq_import)
709                         spin_unlock(&req->rq_import->imp_lock);
710         }
711
712         _sptlrpc_enlarge_msg_inplace(req->rq_reqbuf, PLAIN_PACK_MSG_OFF,
713                                      newmsg_size);
714         _sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize);
715
716         req->rq_reqlen = newmsg_size;
717         RETURN(0);
718 }
719
720 /*
721  * service apis
722  */
723
724 static struct ptlrpc_svc_ctx plain_svc_ctx = {
725         .sc_refcount    = ATOMIC_INIT(1),
726         .sc_policy      = &plain_policy,
727 };
728
729 static int plain_accept(struct ptlrpc_request *req)
730 {
731         struct lustre_msg *msg = req->rq_reqbuf;
732         struct plain_header *phdr;
733         bool swabbed;
734
735         ENTRY;
736         LASSERT(SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) ==
737                 SPTLRPC_POLICY_PLAIN);
738
739         if (SPTLRPC_FLVR_BASE(req->rq_flvr.sf_rpc) !=
740             SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_PLAIN) ||
741             SPTLRPC_FLVR_BULK_TYPE(req->rq_flvr.sf_rpc) !=
742             SPTLRPC_FLVR_BULK_TYPE(SPTLRPC_FLVR_PLAIN)) {
743                 CERROR("Invalid rpc flavor %x\n", req->rq_flvr.sf_rpc);
744                 RETURN(SECSVC_DROP);
745         }
746
747         if (msg->lm_bufcount < PLAIN_PACK_SEGMENTS) {
748                 CERROR("unexpected request buf count %u\n", msg->lm_bufcount);
749                 RETURN(SECSVC_DROP);
750         }
751
752         swabbed = req_capsule_req_need_swab(&req->rq_pill);
753
754         phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, sizeof(*phdr));
755         if (phdr == NULL) {
756                 CERROR("missing plain header\n");
757                 RETURN(-EPROTO);
758         }
759
760         if (phdr->ph_ver != 0) {
761                 CERROR("Invalid header version\n");
762                 RETURN(-EPROTO);
763         }
764
765         if (phdr->ph_bulk_hash_alg >= BULK_HASH_ALG_MAX) {
766                 CERROR("invalid hash algorithm: %u\n", phdr->ph_bulk_hash_alg);
767                 RETURN(-EPROTO);
768         }
769
770         req->rq_sp_from = phdr->ph_sp;
771         req->rq_flvr.u_bulk.hash.hash_alg = phdr->ph_bulk_hash_alg;
772
773         if (phdr->ph_flags & PLAIN_FL_USER) {
774                 if (sptlrpc_unpack_user_desc(msg, PLAIN_PACK_USER_OFF,
775                                              swabbed)) {
776                         CERROR("Mal-formed user descriptor\n");
777                         RETURN(SECSVC_DROP);
778                 }
779
780                 req->rq_pack_udesc = 1;
781                 req->rq_user_desc = lustre_msg_buf(msg, PLAIN_PACK_USER_OFF, 0);
782         }
783
784         if (phdr->ph_flags & PLAIN_FL_BULK) {
785                 if (plain_unpack_bsd(msg, swabbed))
786                         RETURN(SECSVC_DROP);
787
788                 req->rq_pack_bulk = 1;
789         }
790
791         req->rq_reqmsg = lustre_msg_buf(msg, PLAIN_PACK_MSG_OFF, 0);
792         req->rq_reqlen = msg->lm_buflens[PLAIN_PACK_MSG_OFF];
793
794         req->rq_svc_ctx = &plain_svc_ctx;
795         atomic_inc(&req->rq_svc_ctx->sc_refcount);
796
797         RETURN(SECSVC_OK);
798 }
799
800 static
801 int plain_alloc_rs(struct ptlrpc_request *req, int msgsize)
802 {
803         struct ptlrpc_reply_state *rs;
804         __u32 buflens[PLAIN_PACK_SEGMENTS] = { 0, };
805         int rs_size = sizeof(*rs);
806
807         ENTRY;
808
809         LASSERT(msgsize % 8 == 0);
810
811         buflens[PLAIN_PACK_HDR_OFF] = sizeof(struct plain_header);
812         buflens[PLAIN_PACK_MSG_OFF] = msgsize;
813
814         if (req->rq_pack_bulk && (req->rq_bulk_read || req->rq_bulk_write))
815                 buflens[PLAIN_PACK_BULK_OFF] = PLAIN_BSD_SIZE;
816
817         rs_size += lustre_msg_size_v2(PLAIN_PACK_SEGMENTS, buflens);
818
819         rs = req->rq_reply_state;
820
821         if (rs) {
822                 /* pre-allocated */
823                 LASSERT(rs->rs_size >= rs_size);
824         } else {
825                 OBD_ALLOC_LARGE(rs, rs_size);
826                 if (rs == NULL)
827                         RETURN(-ENOMEM);
828
829                 rs->rs_size = rs_size;
830         }
831
832         rs->rs_svc_ctx = req->rq_svc_ctx;
833         atomic_inc(&req->rq_svc_ctx->sc_refcount);
834         rs->rs_repbuf = (struct lustre_msg *) (rs + 1);
835         rs->rs_repbuf_len = rs_size - sizeof(*rs);
836
837         lustre_init_msg_v2(rs->rs_repbuf, PLAIN_PACK_SEGMENTS, buflens, NULL);
838         rs->rs_msg = lustre_msg_buf_v2(rs->rs_repbuf, PLAIN_PACK_MSG_OFF, 0);
839
840         req->rq_reply_state = rs;
841         RETURN(0);
842 }
843
844 static
845 void plain_free_rs(struct ptlrpc_reply_state *rs)
846 {
847         ENTRY;
848
849         LASSERT(atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1);
850         atomic_dec(&rs->rs_svc_ctx->sc_refcount);
851
852         if (!rs->rs_prealloc)
853                 OBD_FREE_LARGE(rs, rs->rs_size);
854         EXIT;
855 }
856
857 static
858 int plain_authorize(struct ptlrpc_request *req)
859 {
860         struct ptlrpc_reply_state *rs = req->rq_reply_state;
861         struct lustre_msg_v2 *msg = rs->rs_repbuf;
862         struct plain_header *phdr;
863         int len;
864
865         ENTRY;
866
867         LASSERT(rs);
868         LASSERT(msg);
869
870         if (req->rq_replen != msg->lm_buflens[PLAIN_PACK_MSG_OFF])
871                 len = lustre_shrink_msg(msg, PLAIN_PACK_MSG_OFF,
872                                         req->rq_replen, 1);
873         else
874                 len = lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
875
876         msg->lm_secflvr = req->rq_flvr.sf_rpc;
877
878         phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, 0);
879         phdr->ph_ver = 0;
880         phdr->ph_flags = 0;
881         phdr->ph_bulk_hash_alg = req->rq_flvr.u_bulk.hash.hash_alg;
882
883         if (req->rq_pack_bulk)
884                 phdr->ph_flags |= PLAIN_FL_BULK;
885
886         rs->rs_repdata_len = len;
887         req->rq_reply_off = 0;
888
889         if (likely(req->rq_packed_final)) {
890                 if (lustre_msghdr_get_flags(req->rq_reqmsg) & MSGHDR_AT_SUPPORT)
891                         req->rq_reply_off = plain_at_offset;
892         } else {
893                 msg->lm_cksum = lustre_msg_calc_cksum(msg, PLAIN_PACK_MSG_OFF);
894         }
895
896         RETURN(0);
897 }
898
899 static
900 int plain_svc_unwrap_bulk(struct ptlrpc_request *req,
901                           struct ptlrpc_bulk_desc *desc)
902 {
903         struct ptlrpc_reply_state *rs = req->rq_reply_state;
904         struct ptlrpc_bulk_sec_desc *bsdr, *bsdv;
905         struct plain_bulk_token *tokenr;
906         int rc;
907
908         LASSERT(req->rq_bulk_write);
909         LASSERT(req->rq_pack_bulk);
910
911         bsdr = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
912         tokenr = (struct plain_bulk_token *) bsdr->bsd_data;
913         bsdv = lustre_msg_buf(rs->rs_repbuf, PLAIN_PACK_BULK_OFF, 0);
914
915         bsdv->bsd_version = 0;
916         bsdv->bsd_type = SPTLRPC_BULK_DEFAULT;
917         bsdv->bsd_svc = bsdr->bsd_svc;
918         bsdv->bsd_flags = 0;
919
920         if (bsdr->bsd_svc == SPTLRPC_BULK_SVC_NULL)
921                 return 0;
922
923         rc = plain_verify_bulk_csum(desc, req->rq_flvr.u_bulk.hash.hash_alg,
924                                     tokenr);
925         if (rc) {
926                 bsdv->bsd_flags |= BSD_FL_ERR;
927                 CERROR("bulk write: server verify failed: %d\n", rc);
928         }
929
930         return rc;
931 }
932
933 static
934 int plain_svc_wrap_bulk(struct ptlrpc_request *req,
935                         struct ptlrpc_bulk_desc *desc)
936 {
937         struct ptlrpc_reply_state *rs = req->rq_reply_state;
938         struct ptlrpc_bulk_sec_desc *bsdr, *bsdv;
939         struct plain_bulk_token *tokenv;
940         int rc;
941
942         LASSERT(req->rq_bulk_read);
943         LASSERT(req->rq_pack_bulk);
944
945         bsdr = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
946         bsdv = lustre_msg_buf(rs->rs_repbuf, PLAIN_PACK_BULK_OFF, 0);
947         tokenv = (struct plain_bulk_token *) bsdv->bsd_data;
948
949         bsdv->bsd_version = 0;
950         bsdv->bsd_type = SPTLRPC_BULK_DEFAULT;
951         bsdv->bsd_svc = bsdr->bsd_svc;
952         bsdv->bsd_flags = 0;
953
954         if (bsdr->bsd_svc == SPTLRPC_BULK_SVC_NULL)
955                 return 0;
956
957         rc = plain_generate_bulk_csum(desc, req->rq_flvr.u_bulk.hash.hash_alg,
958                                       tokenv);
959         if (rc) {
960                 CERROR("bulk read: server failed to compute checksum: %d\n",
961                        rc);
962         } else {
963                 if (OBD_FAIL_CHECK(OBD_FAIL_OSC_CHECKSUM_RECEIVE))
964                         corrupt_bulk_data(desc);
965         }
966
967         return rc;
968 }
969
970 static struct ptlrpc_ctx_ops plain_ctx_ops = {
971         .refresh                = plain_ctx_refresh,
972         .validate               = plain_ctx_validate,
973         .sign                   = plain_ctx_sign,
974         .verify                 = plain_ctx_verify,
975         .wrap_bulk              = plain_cli_wrap_bulk,
976         .unwrap_bulk            = plain_cli_unwrap_bulk,
977 };
978
979 static struct ptlrpc_sec_cops plain_sec_cops = {
980         .create_sec             = plain_create_sec,
981         .destroy_sec            = plain_destroy_sec,
982         .kill_sec               = plain_kill_sec,
983         .lookup_ctx             = plain_lookup_ctx,
984         .release_ctx            = plain_release_ctx,
985         .flush_ctx_cache        = plain_flush_ctx_cache,
986         .alloc_reqbuf           = plain_alloc_reqbuf,
987         .free_reqbuf            = plain_free_reqbuf,
988         .alloc_repbuf           = plain_alloc_repbuf,
989         .free_repbuf            = plain_free_repbuf,
990         .enlarge_reqbuf         = plain_enlarge_reqbuf,
991 };
992
993 static struct ptlrpc_sec_sops plain_sec_sops = {
994         .accept                 = plain_accept,
995         .alloc_rs               = plain_alloc_rs,
996         .authorize              = plain_authorize,
997         .free_rs                = plain_free_rs,
998         .unwrap_bulk            = plain_svc_unwrap_bulk,
999         .wrap_bulk              = plain_svc_wrap_bulk,
1000 };
1001
1002 static struct ptlrpc_sec_policy plain_policy = {
1003         .sp_owner               = THIS_MODULE,
1004         .sp_name                = "plain",
1005         .sp_policy              = SPTLRPC_POLICY_PLAIN,
1006         .sp_cops                = &plain_sec_cops,
1007         .sp_sops                = &plain_sec_sops,
1008 };
1009
1010 int sptlrpc_plain_init(void)
1011 {
1012         __u32 buflens[PLAIN_PACK_SEGMENTS] = { 0, };
1013         int rc;
1014
1015         buflens[PLAIN_PACK_MSG_OFF] = lustre_msg_early_size();
1016         plain_at_offset = lustre_msg_size_v2(PLAIN_PACK_SEGMENTS, buflens);
1017
1018         rc = sptlrpc_register_policy(&plain_policy);
1019         if (rc)
1020                 CERROR("failed to register: %d\n", rc);
1021
1022         return rc;
1023 }
1024
1025 void sptlrpc_plain_fini(void)
1026 {
1027         int rc;
1028
1029         rc = sptlrpc_unregister_policy(&plain_policy);
1030         if (rc)
1031                 CERROR("cannot unregister: %d\n", rc);
1032 }