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_enlarge_reqbuf(struct ptlrpc_sec *sec,
 262                          struct ptlrpc_request *req,
 263                          int segment, int newsize, int move_data)
 264 {
 265         LBUG();
 266         return 0;
 267 }
 268
 269 static
 270 int plain_accept(struct ptlrpc_request *req)
 271 {
 272         struct lustre_msg *msg = req->rq_reqbuf;
 273         int                bufcnt = 1;
 274         ENTRY;
 275
 276         LASSERT(SEC_FLAVOR_POLICY(req->rq_sec_flavor) == SPTLRPC_POLICY_PLAIN);
 277
 278         if (SEC_FLAVOR_RPC(req->rq_sec_flavor) != SPTLRPC_FLVR_PLAIN) {
 279                 CERROR("Invalid flavor 0x%x\n", req->rq_sec_flavor);
 280                 return SECSVC_DROP;
 281         }
 282
 283         if (SEC_FLAVOR_HAS_USER(req->rq_sec_flavor)) {
 284                 if (msg->lm_bufcount < ++bufcnt) {
 285                         CERROR("Protocal error: too small buf count %d\n",
 286                                msg->lm_bufcount);
 287                         RETURN(SECSVC_DROP);
 288                 }
 289
 290                 if (sptlrpc_unpack_user_desc(msg, bufcnt - 1)) {
 291                         CERROR("Mal-formed user descriptor\n");
 292                         RETURN(SECSVC_DROP);
 293                 }
 294
 295                 req->rq_user_desc = lustre_msg_buf(msg, bufcnt - 1, 0);
 296         }
 297
 298         if (SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor)) {
 299                 if (msg->lm_bufcount != ++bufcnt) {
 300                         CERROR("Protocal error: invalid buf count %d\n",
 301                                msg->lm_bufcount);
 302                         RETURN(SECSVC_DROP);
 303                 }
 304
 305                 if (bulk_sec_desc_unpack(msg, bufcnt - 1)) {
 306                         CERROR("Mal-formed bulk checksum request\n");
 307                         RETURN(SECSVC_DROP);
 308                 }
 309         }
 310
 311         req->rq_reqmsg = lustre_msg_buf(msg, 0, 0);
 312         req->rq_reqlen = msg->lm_buflens[0];
 313
 314         req->rq_svc_ctx = &plain_svc_ctx;
 315         atomic_inc(&req->rq_svc_ctx->sc_refcount);
 316
 317         RETURN(SECSVC_OK);
 318 }
 319
 320 static
 321 int plain_alloc_rs(struct ptlrpc_request *req, int msgsize)
 322 {
 323         struct ptlrpc_reply_state *rs;
 324         struct ptlrpc_bulk_sec_desc *bsd;
 325         int bufcnt = 1, buflens[2];
 326         int rs_size = sizeof(*rs);
 327         ENTRY;
 328
 329         LASSERT(msgsize % 8 == 0);
 330
 331         buflens[0] = msgsize;
 332         if (SEC_FLAVOR_HAS_BULK(req->rq_sec_flavor) &&
 333             (req->rq_bulk_read || req->rq_bulk_write)) {
 334                 bsd = lustre_msg_buf(req->rq_reqbuf,
 335                                      req->rq_reqbuf->lm_bufcount - 1,
 336                                      sizeof(*bsd));
 337                 LASSERT(bsd);
 338
 339                 buflens[bufcnt++] = bulk_sec_desc_size(bsd->bsd_csum_alg, 0,
 340                                                        req->rq_bulk_read);
 341         }
 342         rs_size += lustre_msg_size_v2(bufcnt, buflens);
 343
 344         rs = req->rq_reply_state;
 345
 346         if (rs) {
 347                 /* pre-allocated */
 348                 LASSERT(rs->rs_size >= rs_size);
 349         } else {
 350                 OBD_ALLOC(rs, rs_size);
 351                 if (rs == NULL)
 352                         RETURN(-ENOMEM);
 353
 354                 rs->rs_size = rs_size;
 355         }
 356
 357         rs->rs_svc_ctx = req->rq_svc_ctx;
 358         atomic_inc(&req->rq_svc_ctx->sc_refcount);
 359         rs->rs_repbuf = (struct lustre_msg *) (rs + 1);
 360         rs->rs_repbuf_len = rs_size - sizeof(*rs);
 361
 362         lustre_init_msg_v2(rs->rs_repbuf, bufcnt, buflens, NULL);
 363         rs->rs_msg = lustre_msg_buf_v2(rs->rs_repbuf, 0, 0);
 364
 365         req->rq_reply_state = rs;
 366         RETURN(0);
 367 }
 368
 369 static
 370 void plain_free_rs(struct ptlrpc_reply_state *rs)
 371 {
 372         ENTRY;
 373
 374         LASSERT(atomic_read(&rs->rs_svc_ctx->sc_refcount) > 1);
 375         atomic_dec(&rs->rs_svc_ctx->sc_refcount);
 376
 377         if (!rs->rs_prealloc)
 378                 OBD_FREE(rs, rs->rs_size);
 379         EXIT;
 380 }
 381
 382 static
 383 int plain_authorize(struct ptlrpc_request *req)
 384 {
 385         struct ptlrpc_reply_state *rs = req->rq_reply_state;
 386         struct lustre_msg_v2      *msg = rs->rs_repbuf;
 387         int                        len;
 388         ENTRY;
 389
 390         LASSERT(rs);
 391         LASSERT(msg);
 392
 393         if (req->rq_replen != msg->lm_buflens[0])
 394                 len = lustre_shrink_msg(msg, 0, req->rq_replen, 1);
 395         else
 396                 len = lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
 397
 398         msg->lm_secflvr = req->rq_sec_flavor;
 399         rs->rs_repdata_len = len;
 400         RETURN(0);
 401 }
 402
 403 static
 404 int plain_svc_unwrap_bulk(struct ptlrpc_request *req,
 405                           struct ptlrpc_bulk_desc *desc)
 406 {
 407         struct ptlrpc_reply_state *rs = req->rq_reply_state;
 408
 409         LASSERT(rs);
 410
 411         return bulk_csum_svc(desc, req->rq_bulk_read,
 412                              req->rq_reqbuf, req->rq_reqbuf->lm_bufcount - 1,
 413                              rs->rs_repbuf, rs->rs_repbuf->lm_bufcount - 1);
 414 }
 415
 416 static
 417 int plain_svc_wrap_bulk(struct ptlrpc_request *req,
 418                         struct ptlrpc_bulk_desc *desc)
 419 {
 420         struct ptlrpc_reply_state *rs = req->rq_reply_state;
 421
 422         LASSERT(rs);
 423
 424         return bulk_csum_svc(desc, req->rq_bulk_read,
 425                              req->rq_reqbuf, req->rq_reqbuf->lm_bufcount - 1,
 426                              rs->rs_repbuf, rs->rs_repbuf->lm_bufcount - 1);
 427 }
 428
 429 static struct ptlrpc_sec_cops plain_sec_cops = {
 430         .create_sec             = plain_create_sec,
 431         .destroy_sec            = plain_destroy_sec,
 432         .lookup_ctx             = plain_lookup_ctx,
 433         .alloc_reqbuf           = plain_alloc_reqbuf,
 434         .alloc_repbuf           = plain_alloc_repbuf,
 435         .free_reqbuf            = plain_free_reqbuf,
 436         .free_repbuf            = plain_free_repbuf,
 437         .enlarge_reqbuf         = plain_enlarge_reqbuf,
 438 };
 439
 440 static struct ptlrpc_sec_sops plain_sec_sops = {
 441         .accept                 = plain_accept,
 442         .alloc_rs               = plain_alloc_rs,
 443         .authorize              = plain_authorize,
 444         .free_rs                = plain_free_rs,
 445         .unwrap_bulk            = plain_svc_unwrap_bulk,
 446         .wrap_bulk              = plain_svc_wrap_bulk,
 447 };
 448
 449 static struct ptlrpc_sec_policy plain_policy = {
 450         .sp_owner               = THIS_MODULE,
 451         .sp_name                = "sec.plain",
 452         .sp_policy              = SPTLRPC_POLICY_PLAIN,
 453         .sp_cops                = &plain_sec_cops,
 454         .sp_sops                = &plain_sec_sops,
 455 };
 456
 457 static
 458 void plain_init_internal(void)
 459 {
 460         static HLIST_HEAD(__list);
 461
 462         plain_sec.ps_policy = &plain_policy;
 463         atomic_set(&plain_sec.ps_refcount, 1);     /* always busy */
 464         plain_sec.ps_import = NULL;
 465         plain_sec.ps_flavor = SPTLRPC_FLVR_PLAIN;
 466         plain_sec.ps_flags = 0;
 467         plain_sec.ps_gc_interval = 0;
 468         plain_sec.ps_gc_next = 0;
 469         spin_lock_init(&plain_sec.ps_lock);
 470         plain_sec.ps_ccache_size = 1;
 471         plain_sec.ps_ccache = &__list;
 472         atomic_set(&plain_sec.ps_busy, 1);         /* for "plain_cli_ctx" */
 473
 474         hlist_add_head(&plain_cli_ctx.cc_hash, &__list);
 475         atomic_set(&plain_cli_ctx.cc_refcount, 1);    /* for hash */
 476         plain_cli_ctx.cc_sec = &plain_sec;
 477         plain_cli_ctx.cc_ops = &plain_ctx_ops;
 478         plain_cli_ctx.cc_expire = 0;
 479         plain_cli_ctx.cc_flags = PTLRPC_CTX_HASHED | PTLRPC_CTX_ETERNAL |
 480                                  PTLRPC_CTX_UPTODATE;
 481         plain_cli_ctx.cc_vcred.vc_uid = 0;
 482         spin_lock_init(&plain_cli_ctx.cc_lock);
 483         INIT_LIST_HEAD(&plain_cli_ctx.cc_req_list);
 484 }
 485
 486 int sptlrpc_plain_init(void)
 487 {
 488         int rc;
 489
 490         plain_init_internal();
 491
 492         rc = sptlrpc_register_policy(&plain_policy);
 493         if (rc)
 494                 CERROR("failed to register sec.plain: %d\n", rc);
 495
 496         return rc;
 497 }
 498
 499 void sptlrpc_plain_fini(void)
 500 {
 501         int rc;
 502
 503         rc = sptlrpc_unregister_policy(&plain_policy);
 504         if (rc)
 505                 CERROR("cannot unregister sec.plain: %d\n", rc);
 506 }