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  * Copyright (C) 2006 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #ifndef EXPORT_SYMTAB
  23 # define EXPORT_SYMTAB
  24 #endif
  25 #define DEBUG_SUBSYSTEM S_SEC
  26
  27 #ifndef __KERNEL__
  28 #include <liblustre.h>
  29 #endif
  30
  31 #include <obd_support.h>
  32 #include <obd_class.h>
  33 #include <lustre_net.h>
  34 #include <lustre_sec.h>
  35
  36 static struct ptlrpc_sec_policy plain_policy;
  37 static struct ptlrpc_sec        plain_sec;
  38 static struct ptlrpc_cli_ctx    plain_cli_ctx;
  39 static struct ptlrpc_svc_ctx    plain_svc_ctx;
  40
  41 static
  42 int plain_ctx_refresh(struct ptlrpc_cli_ctx *ctx)
  43 {
  44         /* should never reach here */
  45         LBUG();
  46         return 0;
  47 }
  48
  49 static
  50 int plain_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
  51 {
  52         struct lustre_msg_v2 *msg = req->rq_reqbuf;
  53         ENTRY;
  54
  55         msg->lm_secflvr = req->rq_sec_flavor;
  56         req->rq_reqdata_len = lustre_msg_size_v2(msg->lm_bufcount,
  57                                                  msg->lm_buflens);
  58         RETURN(0);
  59 }
  60
  61 static
  62 int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req)
  63 {
  64         struct lustre_msg *msg = req->rq_repbuf;
  65         ENTRY;
  66
  67         if (SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor)) {
  68                 if (msg->lm_bufcount != 2) {
  69                         CERROR("Protocol error: invalid buf count %d\n",
  70                                msg->lm_bufcount);
  71                         RETURN(-EPROTO);
  72                 }
  73
  74                 if (bulk_sec_desc_unpack(msg, 1)) {
  75                         CERROR("Mal-formed bulk checksum reply\n");
  76                         RETURN(-EINVAL);
  77                 }
  78         }
  79
  80         req->rq_repmsg = lustre_msg_buf(msg, 0, 0);
  81         req->rq_replen = msg->lm_buflens[0];
  82         RETURN(0);
  83 }
  84
  85 static
  86 int plain_cli_wrap_bulk(struct ptlrpc_cli_ctx *ctx,
  87                         struct ptlrpc_request *req,
  88                         struct ptlrpc_bulk_desc *desc)
  89 {
  90         struct sec_flavor_config *conf;
  91
  92         LASSERT(req->rq_import);
  93         LASSERT(SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor));
  94         LASSERT(req->rq_reqbuf->lm_bufcount >= 2);
  95
  96         conf = &req->rq_import->imp_obd->u.cli.cl_sec_conf;
  97         return bulk_csum_cli_request(desc, req->rq_bulk_read,
  98                                      conf->sfc_bulk_csum,
  99                                      req->rq_reqbuf,
 100                                      req->rq_reqbuf->lm_bufcount - 1);
 101 }
 102
 103 static
 104 int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
 105                           struct ptlrpc_request *req,
 106                           struct ptlrpc_bulk_desc *desc)
 107 {
 108         LASSERT(SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor));
 109         LASSERT(req->rq_reqbuf->lm_bufcount >= 2);
 110         LASSERT(req->rq_repbuf->lm_bufcount >= 2);
 111
 112         return bulk_csum_cli_reply(desc, req->rq_bulk_read,
 113                                    req->rq_reqbuf,
 114                                    req->rq_reqbuf->lm_bufcount - 1,
 115                                    req->rq_repbuf,
 116                                    req->rq_repbuf->lm_bufcount - 1);
 117 }
 118
 119 static struct ptlrpc_ctx_ops plain_ctx_ops = {
 120         .refresh        = plain_ctx_refresh,
 121         .sign           = plain_ctx_sign,
 122         .verify         = plain_ctx_verify,
 123         .wrap_bulk      = plain_cli_wrap_bulk,
 124         .unwrap_bulk    = plain_cli_unwrap_bulk,
 125 };
 126
 127 static struct ptlrpc_svc_ctx plain_svc_ctx = {
 128         .sc_refcount    = ATOMIC_INIT(1),
 129         .sc_policy      = &plain_policy,
 130 };
 131
 132 static
 133 struct ptlrpc_sec* plain_create_sec(struct obd_import *imp,
 134                                     struct ptlrpc_svc_ctx *ctx,
 135                                     __u32 flavor,
 136                                     unsigned long flags)
 137 {
 138         ENTRY;
 139         LASSERT(SEC_FLAVOR_POLICY(flavor) == SPTLRPC_POLICY_PLAIN);
 140         RETURN(&plain_sec);
 141 }
 142
 143 static
 144 void plain_destroy_sec(struct ptlrpc_sec *sec)
 145 {
 146         ENTRY;
 147         LASSERT(sec == &plain_sec);
 148         EXIT;
 149 }
 150
 151 static
 152 struct ptlrpc_cli_ctx *plain_lookup_ctx(struct ptlrpc_sec *sec,
 153                                         struct vfs_cred *vcred)
 154 {
 155         ENTRY;
 156         atomic_inc(&plain_cli_ctx.cc_refcount);
 157         RETURN(&plain_cli_ctx);
 158 }
 159
 160 static
 161 int plain_alloc_reqbuf(struct ptlrpc_sec *sec,
 162                        struct ptlrpc_request *req,
 163                        int msgsize)
 164 {
 165         struct sec_flavor_config *conf;
 166         int bufcnt = 1, buflens[2], alloc_len;
 167         ENTRY;
 168
 169         buflens[0] = msgsize;
 170
 171         if (SEC_FLAVOR_HAS_USER(req->rq_sec_flavor))
 172                 buflens[bufcnt++] = sptlrpc_user_desc_size();
 173
 174         if (SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor)) {
 175                 LASSERT(req->rq_bulk_read || req->rq_bulk_write);
 176
 177                 conf = &req->rq_import->imp_obd->u.cli.cl_sec_conf;
 178                 buflens[bufcnt++] = bulk_sec_desc_size(conf->sfc_bulk_csum, 1,
 179                                                        req->rq_bulk_read);
 180         }
 181
 182         alloc_len = lustre_msg_size_v2(bufcnt, buflens);
 183
 184
 185         if (!req->rq_reqbuf) {
 186                 LASSERT(!req->rq_pool);
 187                 OBD_ALLOC(req->rq_reqbuf, alloc_len);
 188                 if (!req->rq_reqbuf)
 189                         RETURN(-ENOMEM);
 190
 191                 req->rq_reqbuf_len = alloc_len;
 192         } else {
 193                 LASSERT(req->rq_pool);
 194                 LASSERT(req->rq_reqbuf_len >= alloc_len);
 195                 memset(req->rq_reqbuf, 0, alloc_len);
 196         }
 197
 198         lustre_init_msg_v2(req->rq_reqbuf, bufcnt, buflens, NULL);
 199         req->rq_reqmsg = lustre_msg_buf_v2(req->rq_reqbuf, 0, 0);
 200
 201         if (SEC_FLAVOR_HAS_USER(req->rq_sec_flavor))
 202                 sptlrpc_pack_user_desc(req->rq_reqbuf, 1);
 203
 204         RETURN(0);
 205 }
 206
 207 static
 208 void plain_free_reqbuf(struct ptlrpc_sec *sec,
 209                        struct ptlrpc_request *req)
 210 {
 211         ENTRY;
 212         if (!req->rq_pool) {
 213                 OBD_FREE(req->rq_reqbuf, req->rq_reqbuf_len);
 214                 req->rq_reqbuf = NULL;
 215                 req->rq_reqbuf_len = 0;
 216         }
 217         EXIT;
 218 }
 219
 220 static
 221 int plain_alloc_repbuf(struct ptlrpc_sec *sec,
 222                        struct ptlrpc_request *req,
 223                        int msgsize)
 224 {
 225         struct sec_flavor_config *conf;
 226         int bufcnt = 1, buflens[2], alloc_len;
 227         ENTRY;
 228
 229         buflens[0] = msgsize;
 230
 231         if (SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor)) {
 232                 LASSERT(req->rq_bulk_read || req->rq_bulk_write);
 233
 234                 conf = &req->rq_import->imp_obd->u.cli.cl_sec_conf;
 235                 buflens[bufcnt++] = bulk_sec_desc_size(conf->sfc_bulk_csum, 0,
 236                                                        req->rq_bulk_read);
 237         }
 238
 239         alloc_len = lustre_msg_size_v2(bufcnt, buflens);
 240
 241         OBD_ALLOC(req->rq_repbuf, alloc_len);
 242         if (!req->rq_repbuf)
 243                 RETURN(-ENOMEM);
 244
 245         req->rq_repbuf_len = alloc_len;
 246         RETURN(0);
 247 }
 248
 249 static
 250 void plain_free_repbuf(struct ptlrpc_sec *sec,
 251                        struct ptlrpc_request *req)
 252 {
 253         ENTRY;
 254         OBD_FREE(req->rq_repbuf, req->rq_repbuf_len);
 255         req->rq_repbuf = NULL;
 256         req->rq_repbuf_len = 0;
 257         EXIT;
 258 }
 259
 260 static
 261 int plain_accept(struct ptlrpc_request *req)
 262 {
 263         struct lustre_msg *msg = req->rq_reqbuf;
 264         int                bufcnt = 1;
 265         ENTRY;
 266
 267         LASSERT(SEC_FLAVOR_POLICY(req->rq_sec_flavor) == SPTLRPC_POLICY_PLAIN);
 268
 269         if (SEC_FLAVOR_RPC(req->rq_sec_flavor) != SPTLRPC_FLVR_PLAIN) {
 270                 CERROR("Invalid flavor 0x%x\n", req->rq_sec_flavor);
 271                 return SECSVC_DROP;
 272         }
 273
 274         if (SEC_FLAVOR_HAS_USER(req->rq_sec_flavor)) {
 275                 if (msg->lm_bufcount < ++bufcnt) {
 276                         CERROR("Protocal error: too small buf count %d\n",
 277                                msg->lm_bufcount);
 278                         RETURN(SECSVC_DROP);
 279                 }
 280
 281                 if (sptlrpc_unpack_user_desc(msg, bufcnt - 1)) {
 282                         CERROR("Mal-formed user descriptor\n");
 283                         RETURN(SECSVC_DROP);
 284                 }
 285
 286                 req->rq_user_desc = lustre_msg_buf(msg, bufcnt - 1, 0);
 287         }
 288
 289         if (SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor)) {
 290                 if (msg->lm_bufcount != ++bufcnt) {
 291                         CERROR("Protocal error: invalid buf count %d\n",
 292                                msg->lm_bufcount);
 293                         RETURN(SECSVC_DROP);
 294                 }
 295
 296                 if (bulk_sec_desc_unpack(msg, bufcnt - 1)) {
 297                         CERROR("Mal-formed bulk checksum request\n");
 298                         RETURN(SECSVC_DROP);
 299                 }
 300         }
 301
 302         req->rq_reqmsg = lustre_msg_buf(msg, 0, 0);
 303         req->rq_reqlen = msg->lm_buflens[0];
 304
 305         req->rq_svc_ctx = &plain_svc_ctx;
 306         atomic_inc(&req->rq_svc_ctx->sc_refcount);
 307
 308         RETURN(SECSVC_OK);
 309 }
 310
 311 static
 312 int plain_alloc_rs(struct ptlrpc_request *req, int msgsize)
 313 {
 314         struct ptlrpc_reply_state *rs;
 315         struct ptlrpc_bulk_sec_desc *bsd;
 316         int bufcnt = 1, buflens[2];
 317         int rs_size = sizeof(*rs);
 318         ENTRY;
 319
 320         LASSERT(msgsize % 8 == 0);
 321
 322         buflens[0] = msgsize;
 323         if (SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor) &&
 324             (req->rq_bulk_read || req->rq_bulk_write)) {
 325                 bsd = lustre_msg_buf(req->rq_reqbuf,
 326                                      req->rq_reqbuf->lm_bufcount - 1,
 327                                      sizeof(*bsd));
 328                 LASSERT(bsd);
 329
 330                 buflens[bufcnt++] = bulk_sec_desc_size(bsd->bsd_csum_alg, 0,
 331                                                        req->rq_bulk_read);
 332         }
 333         rs_size += lustre_msg_size_v2(bufcnt, buflens);
 334
 335         rs = req->rq_reply_state;
 336
 337         if (rs) {
 338                 /* pre-allocated */
 339                 LASSERT(rs->rs_size >= rs_size);
 340         } else {
 341                 OBD_ALLOC(rs, rs_size);
 342                 if (rs == NULL)
 343                         RETURN(-ENOMEM);
 344
 345                 rs->rs_size = rs_size;
 346         }
 347
 348         rs->rs_svc_ctx = req->rq_svc_ctx;
 349         atomic_inc(&req->rq_svc_ctx->sc_refcount);
 350         rs->rs_repbuf = (struct lustre_msg *) (rs + 1);
 351         rs->rs_repbuf_len = rs_size - sizeof(*rs);
 352
 353         lustre_init_msg_v2(rs->rs_repbuf, bufcnt, buflens, NULL);
 354         rs->rs_msg = lustre_msg_buf_v2(rs->rs_repbuf, 0, 0);
 355
 356         req->rq_reply_state = rs;
 357         RETURN(0);
 358 }
 359
 360 static
 361 void plain_free_rs(struct ptlrpc_reply_state *rs)
 362 {
 363         ENTRY;
 364
 365         LASSERT(atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1);
 366         atomic_dec(&rs->rs_svc_ctx->sc_refcount);
 367
 368         if (!rs->rs_prealloc)
 369                 OBD_FREE(rs, rs->rs_size);
 370         EXIT;
 371 }
 372
 373 static
 374 int plain_authorize(struct ptlrpc_request *req)
 375 {
 376         struct ptlrpc_reply_state *rs = req->rq_reply_state;
 377         struct lustre_msg_v2      *msg = rs->rs_repbuf;
 378         int                        len;
 379         ENTRY;
 380
 381         LASSERT(rs);
 382         LASSERT(msg);
 383
 384         if (req->rq_replen != msg->lm_buflens[0])
 385                 len = lustre_shrink_msg(msg, 0, req->rq_replen, 1);
 386         else
 387                 len = lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
 388
 389         msg->lm_secflvr = req->rq_sec_flavor;
 390         rs->rs_repdata_len = len;
 391         RETURN(0);
 392 }
 393
 394 static
 395 int plain_svc_unwrap_bulk(struct ptlrpc_request *req,
 396                           struct ptlrpc_bulk_desc *desc)
 397 {
 398         struct ptlrpc_reply_state *rs = req->rq_reply_state;
 399
 400         LASSERT(rs);
 401
 402         return bulk_csum_svc(desc, req->rq_bulk_read,
 403                              req->rq_reqbuf, req->rq_reqbuf->lm_bufcount - 1,
 404                              rs->rs_repbuf, rs->rs_repbuf->lm_bufcount - 1);
 405 }
 406
 407 static
 408 int plain_svc_wrap_bulk(struct ptlrpc_request *req,
 409                         struct ptlrpc_bulk_desc *desc)
 410 {
 411         struct ptlrpc_reply_state *rs = req->rq_reply_state;
 412
 413         LASSERT(rs);
 414
 415         return bulk_csum_svc(desc, req->rq_bulk_read,
 416                              req->rq_reqbuf, req->rq_reqbuf->lm_bufcount - 1,
 417                              rs->rs_repbuf, rs->rs_repbuf->lm_bufcount - 1);
 418 }
 419
 420 static struct ptlrpc_sec_cops plain_sec_cops = {
 421         .create_sec             = plain_create_sec,
 422         .destroy_sec            = plain_destroy_sec,
 423         .lookup_ctx             = plain_lookup_ctx,
 424         .alloc_reqbuf           = plain_alloc_reqbuf,
 425         .alloc_repbuf           = plain_alloc_repbuf,
 426         .free_reqbuf            = plain_free_reqbuf,
 427         .free_repbuf            = plain_free_repbuf,
 428 };
 429
 430 static struct ptlrpc_sec_sops plain_sec_sops = {
 431         .accept                 = plain_accept,
 432         .alloc_rs               = plain_alloc_rs,
 433         .authorize              = plain_authorize,
 434         .free_rs                = plain_free_rs,
 435         .unwrap_bulk            = plain_svc_unwrap_bulk,
 436         .wrap_bulk              = plain_svc_wrap_bulk,
 437 };
 438
 439 static struct ptlrpc_sec_policy plain_policy = {
 440         .sp_owner               = THIS_MODULE,
 441         .sp_name                = "sec.plain",
 442         .sp_policy              = SPTLRPC_POLICY_PLAIN,
 443         .sp_cops                = &plain_sec_cops,
 444         .sp_sops                = &plain_sec_sops,
 445 };
 446
 447 static
 448 void plain_init_internal(void)
 449 {
 450         static HLIST_HEAD(__list);
 451
 452         plain_sec.ps_policy = &plain_policy;
 453         atomic_set(&plain_sec.ps_refcount, 1);     /* always busy */
 454         plain_sec.ps_import = NULL;
 455         plain_sec.ps_flavor = SPTLRPC_FLVR_PLAIN;
 456         plain_sec.ps_flags = 0;
 457         plain_sec.ps_gc_interval = 0;
 458         plain_sec.ps_gc_next = 0;
 459         spin_lock_init(&plain_sec.ps_lock);
 460         plain_sec.ps_ccache_size = 1;
 461         plain_sec.ps_ccache = &__list;
 462         atomic_set(&plain_sec.ps_busy, 1);         /* for "plain_cli_ctx" */
 463
 464         hlist_add_head(&plain_cli_ctx.cc_hash, &__list);
 465         atomic_set(&plain_cli_ctx.cc_refcount, 1);    /* for hash */
 466         plain_cli_ctx.cc_sec = &plain_sec;
 467         plain_cli_ctx.cc_ops = &plain_ctx_ops;
 468         plain_cli_ctx.cc_expire = 0;
 469         plain_cli_ctx.cc_flags = PTLRPC_CTX_HASHED | PTLRPC_CTX_ETERNAL |
 470                                  PTLRPC_CTX_UPTODATE;
 471         plain_cli_ctx.cc_vcred.vc_uid = 0;
 472         spin_lock_init(&plain_cli_ctx.cc_lock);
 473         INIT_LIST_HEAD(&plain_cli_ctx.cc_req_list);
 474 }
 475
 476 int sptlrpc_plain_init(void)
 477 {
 478         int rc;
 479
 480         plain_init_internal();
 481
 482         rc = sptlrpc_register_policy(&plain_policy);
 483         if (rc)
 484                 CERROR("failed to register sec.plain: %d\n", rc);
 485
 486         return rc;
 487 }
 488
 489 int sptlrpc_plain_exit(void)
 490 {
 491         int rc;
 492
 493         rc = sptlrpc_unregister_policy(&plain_policy);
 494         if (rc)
 495                 CERROR("cannot unregister sec.plain: %d\n", rc);
 496
 497         return rc;
 498 }