lustre/ptlrpc/sec_plain.c

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