lustre/ptlrpc/sec_ctx.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  *
  19  * http://www.gnu.org/licenses/gpl-2.0.html
  20  *
  21  * GPL HEADER END
  22  */
  23 #ifdef __KERNEL__
  24
  25 #define DEBUG_SUBSYSTEM S_FILTER
  26
  27 #include <linux/version.h>
  28 #include <linux/fs.h>
  29 #include <asm/unistd.h>
  30 #include <linux/slab.h>
  31 #include <linux/pagemap.h>
  32 #include <linux/quotaops.h>
  33 #include <linux/version.h>
  34 #include <libcfs/libcfs.h>
  35 #include <obd.h>
  36 #include <linux/module.h>
  37 #include <linux/init.h>
  38 #include <linux/lustre_compat25.h>
  39 #include <lvfs.h>
  40
  41 #include <obd.h>
  42 #include <lustre_lib.h>
  43
  44 /* refine later and change to seqlock or simlar from libcfs */
  45 /* Debugging check only needed during development */
  46 #ifdef OBD_CTXT_DEBUG
  47 # define ASSERT_CTXT_MAGIC(magic) LASSERT((magic) == OBD_RUN_CTXT_MAGIC)
  48 # define ASSERT_NOT_KERNEL_CTXT(msg) LASSERTF(!segment_eq(get_fs(), get_ds()),\
  49                                               msg)
  50 # define ASSERT_KERNEL_CTXT(msg) LASSERTF(segment_eq(get_fs(), get_ds()), msg)
  51 #else
  52 # define ASSERT_CTXT_MAGIC(magic) do {} while(0)
  53 # define ASSERT_NOT_KERNEL_CTXT(msg) do {} while(0)
  54 # define ASSERT_KERNEL_CTXT(msg) do {} while(0)
  55 #endif
  56
  57 static void push_group_info(struct lvfs_run_ctxt *save,
  58                             struct group_info *ginfo)
  59 {
  60         if (!ginfo) {
  61                 save->ngroups = current_ngroups;
  62                 current_ngroups = 0;
  63         } else {
  64                 struct cred *cred;
  65                 task_lock(current);
  66                 save->group_info = current_cred()->group_info;
  67                 if ((cred = prepare_creds())) {
  68                         cred->group_info = ginfo;
  69                         commit_creds(cred);
  70                 }
  71                 task_unlock(current);
  72         }
  73 }
  74
  75 static void pop_group_info(struct lvfs_run_ctxt *save,
  76                            struct group_info *ginfo)
  77 {
  78         if (!ginfo) {
  79                 current_ngroups = save->ngroups;
  80         } else {
  81                 struct cred *cred;
  82                 task_lock(current);
  83                 if ((cred = prepare_creds())) {
  84                         cred->group_info = save->group_info;
  85                         commit_creds(cred);
  86                 }
  87                 task_unlock(current);
  88         }
  89 }
  90
  91 /* push / pop to root of obd store */
  92 void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx,
  93                struct lvfs_ucred *uc)
  94 {
  95         /* if there is underlaying dt_device then push_ctxt is not needed */
  96         if (new_ctx->dt != NULL)
  97                 return;
  98
  99         //ASSERT_NOT_KERNEL_CTXT("already in kernel context!\n");
 100         ASSERT_CTXT_MAGIC(new_ctx->magic);
 101         OBD_SET_CTXT_MAGIC(save);
 102
 103         save->fs = get_fs();
 104         LASSERT(d_refcount(current->fs->pwd.dentry));
 105         LASSERT(d_refcount(new_ctx->pwd));
 106         save->pwd = dget(current->fs->pwd.dentry);
 107         save->pwdmnt = mntget(current->fs->pwd.mnt);
 108         save->luc.luc_umask = current_umask();
 109         save->ngroups = current_cred()->group_info->ngroups;
 110
 111         LASSERT(save->pwd);
 112         LASSERT(save->pwdmnt);
 113         LASSERT(new_ctx->pwd);
 114         LASSERT(new_ctx->pwdmnt);
 115
 116         if (uc) {
 117                 struct cred *cred;
 118                 save->luc.luc_uid = current_uid();
 119                 save->luc.luc_gid = current_gid();
 120                 save->luc.luc_fsuid = current_fsuid();
 121                 save->luc.luc_fsgid = current_fsgid();
 122                 save->luc.luc_cap = current_cap();
 123
 124                 if ((cred = prepare_creds())) {
 125                         cred->uid = uc->luc_uid;
 126                         cred->gid = uc->luc_gid;
 127                         cred->fsuid = uc->luc_fsuid;
 128                         cred->fsgid = uc->luc_fsgid;
 129                         cred->cap_effective = uc->luc_cap;
 130                         commit_creds(cred);
 131                 }
 132
 133                 push_group_info(save,
 134                                 uc->luc_ginfo ?:
 135                                 uc->luc_identity ? uc->luc_identity->mi_ginfo :
 136                                                    NULL);
 137         }
 138         current->fs->umask = 0; /* umask already applied on client */
 139         set_fs(new_ctx->fs);
 140         ll_set_fs_pwd(current->fs, new_ctx->pwdmnt, new_ctx->pwd);
 141 }
 142 EXPORT_SYMBOL(push_ctxt);
 143
 144 void pop_ctxt(struct lvfs_run_ctxt *saved, struct lvfs_run_ctxt *new_ctx,
 145               struct lvfs_ucred *uc)
 146 {
 147         /* if there is underlaying dt_device then pop_ctxt is not needed */
 148         if (new_ctx->dt != NULL)
 149                 return;
 150
 151         ASSERT_CTXT_MAGIC(saved->magic);
 152         ASSERT_KERNEL_CTXT("popping non-kernel context!\n");
 153
 154         LASSERTF(current->fs->pwd.dentry == new_ctx->pwd, "%p != %p\n",
 155                  current->fs->pwd.dentry, new_ctx->pwd);
 156         LASSERTF(current->fs->pwd.mnt == new_ctx->pwdmnt, "%p != %p\n",
 157                  current->fs->pwd.mnt, new_ctx->pwdmnt);
 158
 159         set_fs(saved->fs);
 160         ll_set_fs_pwd(current->fs, saved->pwdmnt, saved->pwd);
 161
 162         dput(saved->pwd);
 163         mntput(saved->pwdmnt);
 164         current->fs->umask = saved->luc.luc_umask;
 165         if (uc) {
 166                 struct cred *cred;
 167                 if ((cred = prepare_creds())) {
 168                         cred->uid = saved->luc.luc_uid;
 169                         cred->gid = saved->luc.luc_gid;
 170                         cred->fsuid = saved->luc.luc_fsuid;
 171                         cred->fsgid = saved->luc.luc_fsgid;
 172                         cred->cap_effective = saved->luc.luc_cap;
 173                         commit_creds(cred);
 174                 }
 175
 176                 pop_group_info(saved,
 177                                uc->luc_ginfo ?:
 178                                uc->luc_identity ? uc->luc_identity->mi_ginfo :
 179                                                   NULL);
 180         }
 181 }
 182 EXPORT_SYMBOL(pop_ctxt);
 183
 184 /* utility to rename a file */
 185 int lustre_rename(struct dentry *dir, struct vfsmount *mnt,
 186                   char *oldname, char *newname)
 187 {
 188         struct dentry *dchild_old, *dchild_new;
 189         int err = 0;
 190         ENTRY;
 191
 192         ASSERT_KERNEL_CTXT("kernel doing rename outside kernel context\n");
 193         CDEBUG(D_INODE, "renaming file %.*s to %.*s\n",
 194                (int)strlen(oldname), oldname, (int)strlen(newname), newname);
 195
 196         dchild_old = ll_lookup_one_len(oldname, dir, strlen(oldname));
 197         if (IS_ERR(dchild_old))
 198                 RETURN(PTR_ERR(dchild_old));
 199
 200         if (!dchild_old->d_inode)
 201                 GOTO(put_old, err = -ENOENT);
 202
 203         dchild_new = ll_lookup_one_len(newname, dir, strlen(newname));
 204         if (IS_ERR(dchild_new))
 205                 GOTO(put_old, err = PTR_ERR(dchild_new));
 206
 207         err = vfs_rename(dir->d_inode, dchild_old, dir->d_inode, dchild_new);
 208
 209         dput(dchild_new);
 210 put_old:
 211         dput(dchild_old);
 212         RETURN(err);
 213 }
 214 EXPORT_SYMBOL(lustre_rename);
 215 #endif /* __KERNEL__ */