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         ENTRY;
  83
  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                 CERROR("no upcall set\n");
  92                 GOTO(out, rc = -EREMCHG);
  93         }
  94
  95         argv[0] = cache->uc_upcall;
  96         snprintf(keystr, sizeof(keystr), "%llu", entry->ue_key);
  97
  98         start = ktime_get();
  99         rc = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
 100         end = ktime_get();
 101         if (rc < 0) {
 102                 CERROR("%s: error invoking upcall %s %s %s: rc %d; check /proc/fs/lustre/mdt/%s/identity_upcall, time %ldus\n",
 103                        cache->uc_name, argv[0], argv[1], argv[2], rc,
 104                        cache->uc_name, (long)ktime_us_delta(end, start));
 105         } else {
 106                 CDEBUG(D_HA, "%s: invoked upcall %s %s %s, time %ldus\n",
 107                        cache->uc_name, argv[0], argv[1], argv[2],
 108                        (long)ktime_us_delta(end, start));
 109                 rc = 0;
 110         }
 111         EXIT;
 112 out:
 113         up_read(&cache->uc_upcall_rwsem);
 114         return rc;
 115 }
 116
 117 static int mdt_identity_parse_downcall(struct upcall_cache *cache,
 118                                        struct upcall_cache_entry *entry,
 119                                        void *args)
 120 {
 121         struct md_identity *identity = &entry->u.identity;
 122         struct identity_downcall_data *data = args;
 123         struct group_info *ginfo = NULL;
 124         struct md_perm *perms = NULL;
 125         int size, i;
 126         ENTRY;
 127
 128         LASSERT(data);
 129         if (data->idd_ngroups > NGROUPS_MAX)
 130                 RETURN(-E2BIG);
 131
 132         if (data->idd_ngroups > 0) {
 133                 ginfo = groups_alloc(data->idd_ngroups);
 134                 if (!ginfo) {
 135                         CERROR("failed to alloc %d groups\n", data->idd_ngroups);
 136                         RETURN(-ENOMEM);
 137                 }
 138
 139                 lustre_groups_from_list(ginfo, data->idd_groups);
 140                 lustre_groups_sort(ginfo);
 141         }
 142
 143         if (data->idd_nperms) {
 144                 size = data->idd_nperms * sizeof(*perms);
 145                 OBD_ALLOC(perms, size);
 146                 if (!perms) {
 147                         CERROR("failed to alloc %d permissions\n",
 148                                data->idd_nperms);
 149                         if (ginfo != NULL)
 150                                 put_group_info(ginfo);
 151                         RETURN(-ENOMEM);
 152                 }
 153
 154                 for (i = 0; i < data->idd_nperms; i++) {
 155                         perms[i].mp_nid = data->idd_perms[i].pdd_nid;
 156                         perms[i].mp_perm = data->idd_perms[i].pdd_perm;
 157                 }
 158         }
 159
 160         identity->mi_uid = data->idd_uid;
 161         identity->mi_gid = data->idd_gid;
 162         identity->mi_ginfo = ginfo;
 163         identity->mi_nperms = data->idd_nperms;
 164         identity->mi_perms = perms;
 165
 166         CDEBUG(D_OTHER, "parse mdt identity@%p: %d:%d, ngroups %u, nperms %u\n",
 167                identity, identity->mi_uid, identity->mi_gid,
 168                data->idd_ngroups, data->idd_nperms);
 169
 170         RETURN(0);
 171 }
 172
 173 struct md_identity *mdt_identity_get(struct upcall_cache *cache, __u32 uid)
 174 {
 175         struct upcall_cache_entry *entry;
 176
 177         if (!cache)
 178                 return ERR_PTR(-ENOENT);
 179
 180         entry = upcall_cache_get_entry(cache, (__u64)uid, NULL);
 181         if (IS_ERR(entry))
 182                 return ERR_PTR(PTR_ERR(entry));
 183         else if (unlikely(!entry))
 184                 return ERR_PTR(-ENOENT);
 185         else
 186                 return &entry->u.identity;
 187 }
 188
 189 void mdt_identity_put(struct upcall_cache *cache, struct md_identity *identity)
 190 {
 191         if (!cache)
 192                 return;
 193
 194         LASSERT(identity);
 195         upcall_cache_put_entry(cache, identity->mi_uc_entry);
 196 }
 197
 198 struct upcall_cache_ops mdt_identity_upcall_cache_ops = {
 199         .init_entry     = mdt_identity_entry_init,
 200         .free_entry     = mdt_identity_entry_free,
 201         .do_upcall      = mdt_identity_do_upcall,
 202         .parse_downcall = mdt_identity_parse_downcall,
 203 };
 204
 205 void mdt_flush_identity(struct upcall_cache *cache, int uid)
 206 {
 207         if (uid < 0)
 208                 upcall_cache_flush_idle(cache);
 209         else
 210                 upcall_cache_flush_one(cache, (__u64)uid, NULL);
 211 }
 212
 213 /*
 214  * If there is LNET_NID_ANY in perm[i].mp_nid,
 215  * it must be perm[0].mp_nid, and act as default perm.
 216  */
 217 __u32 mdt_identity_get_perm(struct md_identity *identity, lnet_nid_t nid)
 218 {
 219
 220         struct md_perm *perm;
 221         int i;
 222
 223         if (!identity)
 224                 return CFS_SETGRP_PERM;
 225
 226         perm = identity->mi_perms;
 227         /* check exactly matched nid first */
 228         for (i = identity->mi_nperms - 1; i > 0; i--) {
 229                 if (perm[i].mp_nid != nid)
 230                         continue;
 231                 return perm[i].mp_perm;
 232         }
 233
 234         /* check LNET_NID_ANY then */
 235         if ((identity->mi_nperms > 0) &&
 236             ((perm[0].mp_nid == nid) || (perm[0].mp_nid == LNET_NID_ANY)))
 237                 return perm[0].mp_perm;
 238
 239         /* return default last */
 240         return CFS_SETGRP_PERM;
 241 }