lustre/mdt/mdt_identity.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, 2016, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/mdt/mdt_identity.c
  33  *
  34  * Author: Lai Siyao <lsy@clusterfs.com>
  35  * Author: Fan Yong <fanyong@clusterfs.com>
  36  */
  37
  38 #define DEBUG_SUBSYSTEM S_MDS
  39
  40 #include "mdt_internal.h"
  41
  42 static void mdt_identity_entry_init(struct upcall_cache_entry *entry,
  43                                     void *unused)
  44 {
  45         entry->u.identity.mi_uc_entry = entry;
  46 }
  47
  48 static void mdt_identity_entry_free(struct upcall_cache *cache,
  49                                     struct upcall_cache_entry *entry)
  50 {
  51         struct md_identity *identity = &entry->u.identity;
  52
  53         if (identity->mi_ginfo) {
  54                 put_group_info(identity->mi_ginfo);
  55                 identity->mi_ginfo = NULL;
  56         }
  57
  58         if (identity->mi_nperms) {
  59                 LASSERT(identity->mi_perms);
  60                 OBD_FREE_PTR_ARRAY(identity->mi_perms, identity->mi_nperms);
  61                 identity->mi_nperms = 0;
  62         }
  63 }
  64
  65 static int mdt_identity_do_upcall(struct upcall_cache *cache,
  66                                   struct upcall_cache_entry *entry)
  67 {
  68         char keystr[16];
  69         char *argv[] = {
  70                 [0] = cache->uc_upcall,
  71                 [1] = cache->uc_name,
  72                 [2] = keystr,
  73                 [3] = NULL
  74         };
  75         char *envp[] = {
  76                 [0] = "HOME=/",
  77                 [1] = "PATH=/sbin:/usr/sbin",
  78                 [2] = NULL
  79         };
  80         ktime_t start, end;
  81         int rc;
  82
  83         ENTRY;
  84         /* There is race condition:
  85          * "uc_upcall" was changed just after "is_identity_get_disabled" check.
  86          */
  87         down_read(&cache->uc_upcall_rwsem);
  88         CDEBUG(D_INFO, "The upcall is: '%s'\n", cache->uc_upcall);
  89
  90         if (unlikely(!strcmp(cache->uc_upcall, "NONE"))) {
  91                 rc = -EREMCHG;
  92                 CERROR("%s: extended identity requested for user '%llu' called with 'NONE' upcall: rc = %d\n",
  93                        cache->uc_name, entry->ue_key, rc);
  94                 GOTO(out, rc);
  95         }
  96
  97         if (unlikely(cache->uc_upcall[0] == '\0')) {
  98                 rc = -EREMCHG;
  99                 CERROR("%s: extended identity requested for user '%llu' called with empty upcall: rc = %d\n",
 100                        cache->uc_name, entry->ue_key, rc);
 101                 GOTO(out, rc);
 102         }
 103
 104         argv[0] = cache->uc_upcall;
 105         snprintf(keystr, sizeof(keystr), "%llu", entry->ue_key);
 106
 107         start = ktime_get();
 108         rc = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
 109         end = ktime_get();
 110         if (rc < 0) {
 111                 CERROR("%s: error invoking upcall %s %s %s: rc %d; check /proc/fs/lustre/mdt/%s/identity_upcall, time %ldus: rc = %d\n",
 112                        cache->uc_name, argv[0], argv[1], argv[2], rc,
 113                        cache->uc_name, (long)ktime_us_delta(end, start), rc);
 114         } else {
 115                 CDEBUG(D_HA, "%s: invoked upcall %s %s %s, time %ldus\n",
 116                        cache->uc_name, argv[0], argv[1], argv[2],
 117                        (long)ktime_us_delta(end, start));
 118                 rc = 0;
 119         }
 120         EXIT;
 121 out:
 122         up_read(&cache->uc_upcall_rwsem);
 123         return rc;
 124 }
 125
 126 static int mdt_identity_parse_downcall(struct upcall_cache *cache,
 127                                        struct upcall_cache_entry *entry,
 128                                        void *args)
 129 {
 130         struct md_identity *identity = &entry->u.identity;
 131         struct identity_downcall_data *data = args;
 132         struct group_info *ginfo = NULL;
 133         struct md_perm *perms = NULL;
 134         int size, i, rc = 0;
 135
 136         ENTRY;
 137         LASSERT(data);
 138         if (data->idd_ngroups > NGROUPS_MAX) {
 139                 rc = -E2BIG;
 140                 CERROR("%s: UID %u groups %u > maximum %u: rc = %d\n",
 141                        cache->uc_name, data->idd_uid, data->idd_ngroups, NGROUPS_MAX, rc);
 142                 goto out;
 143         }
 144
 145         if (data->idd_ngroups > 0) {
 146                 ginfo = groups_alloc(data->idd_ngroups);
 147                 if (!ginfo) {
 148                         rc = -ENOMEM;
 149                         CERROR("%s: failed to alloc %d groups: rc = %d\n",
 150                                cache->uc_name, data->idd_ngroups, rc);
 151                         goto out;
 152                 }
 153
 154                 lustre_groups_from_list(ginfo, data->idd_groups);
 155                 lustre_groups_sort(ginfo);
 156         }
 157
 158         if (data->idd_nperms) {
 159                 size = data->idd_nperms * sizeof(*perms);
 160                 OBD_ALLOC(perms, size);
 161                 if (!perms) {
 162                         rc = -ENOMEM;
 163                         CERROR("%s: failed to alloc %d permissions: rc = %d\n",
 164                                cache->uc_name, data->idd_nperms, rc);
 165                         if (ginfo)
 166                                 put_group_info(ginfo);
 167                         goto out;
 168                 }
 169
 170                 for (i = 0; i < data->idd_nperms; i++) {
 171                         perms[i].mp_nid = data->idd_perms[i].pdd_nid;
 172                         perms[i].mp_perm = data->idd_perms[i].pdd_perm;
 173                 }
 174         }
 175
 176         identity->mi_uid = data->idd_uid;
 177         identity->mi_gid = data->idd_gid;
 178         identity->mi_ginfo = ginfo;
 179         identity->mi_nperms = data->idd_nperms;
 180         identity->mi_perms = perms;
 181
 182         CDEBUG(D_OTHER, "parse mdt identity@%p: %d:%d, ngroups %u, nperms %u\n",
 183                identity, identity->mi_uid, identity->mi_gid,
 184                data->idd_ngroups, data->idd_nperms);
 185
 186 out:
 187         RETURN(rc);
 188 }
 189
 190 struct md_identity *mdt_identity_get(struct upcall_cache *cache, __u32 uid)
 191 {
 192         struct upcall_cache_entry *entry;
 193
 194         if (!cache)
 195                 return ERR_PTR(-ENOENT);
 196
 197         entry = upcall_cache_get_entry(cache, (__u64)uid, NULL);
 198         if (unlikely(!entry))
 199                 return ERR_PTR(-ENOENT);
 200         if (IS_ERR(entry))
 201                 return ERR_CAST(entry);
 202
 203         return &entry->u.identity;
 204 }
 205
 206 void mdt_identity_put(struct upcall_cache *cache, struct md_identity *identity)
 207 {
 208         if (!cache)
 209                 return;
 210
 211         LASSERT(identity);
 212         upcall_cache_put_entry(cache, identity->mi_uc_entry);
 213 }
 214
 215 struct upcall_cache_ops mdt_identity_upcall_cache_ops = {
 216         .init_entry     = mdt_identity_entry_init,
 217         .free_entry     = mdt_identity_entry_free,
 218         .do_upcall      = mdt_identity_do_upcall,
 219         .parse_downcall = mdt_identity_parse_downcall,
 220 };
 221
 222 void mdt_flush_identity(struct upcall_cache *cache, int uid)
 223 {
 224         if (uid < 0)
 225                 upcall_cache_flush_idle(cache);
 226         else
 227                 upcall_cache_flush_one(cache, (__u64)uid, NULL);
 228 }
 229
 230 /*
 231  * If there is LNET_NID_ANY in perm[i].mp_nid,
 232  * it must be perm[0].mp_nid, and act as default perm.
 233  */
 234 __u32 mdt_identity_get_perm(struct md_identity *identity, lnet_nid_t nid)
 235 {
 236         struct md_perm *perm;
 237         int i;
 238
 239         if (!identity)
 240                 return CFS_SETGRP_PERM;
 241
 242         perm = identity->mi_perms;
 243         /* check exactly matched nid first */
 244         for (i = identity->mi_nperms - 1; i > 0; i--) {
 245                 if (perm[i].mp_nid != nid)
 246                         continue;
 247                 return perm[i].mp_perm;
 248         }
 249
 250         /* check LNET_NID_ANY then */
 251         if ((identity->mi_nperms > 0) &&
 252             ((perm[0].mp_nid == nid) || (perm[0].mp_nid == LNET_NID_ANY)))
 253                 return perm[0].mp_perm;
 254
 255         /* return default last */
 256         return CFS_SETGRP_PERM;
 257 }