lustre/mds/mds_audit.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/mds/mds_audit.c
   5  *  Lustre Metadata Server (mds) audit stuff
   6  *
   7  *  Copyright (c) 2001-2003 Cluster File Systems, Inc.
   8  *
   9  *   This file is part of Lustre, http://www.lustre.org.
  10  *
  11  *   Lustre is free software; you can redistribute it and/or
  12  *   modify it under the terms of version 2 of the GNU General Public
  13  *   License as published by the Free Software Foundation.
  14  *
  15  *   Lustre is distributed in the hope that it will be useful,
  16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *   GNU General Public License for more details.
  19  *
  20  *   You should have received a copy of the GNU General Public License
  21  *   along with Lustre; if not, write to the Free Software
  22  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #ifndef EXPORT_SYMTAB
  26 # define EXPORT_SYMTAB
  27 #endif
  28 #define DEBUG_SUBSYSTEM S_MDS
  29
  30 #include <linux/module.h>
  31 #include <linux/lustre_mds.h>
  32 #include <linux/lustre_dlm.h>
  33 #include <linux/init.h>
  34 #include <linux/obd_class.h>
  35 #include <linux/random.h>
  36 #include <linux/fs.h>
  37 #include <linux/jbd.h>
  38 #include <linux/namei.h>
  39 #include <linux/ext3_fs.h>
  40 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
  41 # include <linux/smp_lock.h>
  42 # include <linux/buffer_head.h>
  43 # include <linux/workqueue.h>
  44 # include <linux/mount.h>
  45 #else
  46 # include <linux/locks.h>
  47 #endif
  48 #include <linux/obd_lov.h>
  49 #include <linux/obd_ost.h>
  50 #include <linux/lustre_mds.h>
  51 #include <linux/lustre_fsfilt.h>
  52 #include <linux/lprocfs_status.h>
  53 #include <linux/lustre_commit_confd.h>
  54 #include <linux/lustre_acl.h>
  55 #include "mds_internal.h"
  56
  57 int mds_audit(struct ptlrpc_request *req, struct dentry *dentry,
  58               char *name, int namelen, audit_op op, int ret)
  59 {
  60         struct obd_device *obd = req->rq_export->exp_obd;
  61         ptl_nid_t nid = req->rq_peer.peer_id.nid;
  62         struct inode *inode = dentry->d_inode;
  63         struct inode *parent = dentry->d_parent->d_inode;
  64         struct audit_info info = {
  65                 .child = inode,
  66                 .name = NULL,
  67                 .namelen = 0,
  68         };
  69         int rc = 0;
  70         ENTRY;
  71
  72         /* don't catch request to cross-ref */
  73         if (dentry->d_flags & DCACHE_CROSS_REF)
  74                 RETURN(0);
  75
  76         info.m.nid = nid;
  77         info.m.uid = current->uid;
  78         info.m.gid = current->gid;
  79         info.m.result = ret;
  80         info.m.code = op;
  81
  82         if (!inode) {
  83                 inode = parent;
  84                 info.name = name;
  85                 info.namelen = namelen;
  86         }
  87         mds_pack_inode2id(obd, &info.m.id, inode, 1);
  88
  89         fsfilt_set_info(obd, parent->i_sb, parent,
  90                         10, "audit_info", sizeof(info), (void*)&info);
  91
  92         RETURN(rc);
  93 }
  94
  95 int mds_audit_auth(struct ptlrpc_request *req, struct lvfs_ucred * uc,
  96                    audit_op op, struct lustre_id * id,
  97                    char * name, int namelen)
  98 {
  99         struct obd_device *obd = req->rq_export->exp_obd;
 100         ptl_nid_t nid = req->rq_peer.peer_id.nid;
 101         int rc = 0;
 102         struct dentry * dparent, *dchild = NULL;
 103         struct inode * inode;
 104         struct audit_info info;
 105
 106         ENTRY;
 107
 108         dparent = mds_id2dentry(obd, id, NULL);
 109         if (IS_ERR(dparent) || !dparent->d_inode) {
 110                 CERROR("can't find inode "LPU64"\n", id_ino(id));
 111                 if (!IS_ERR(dparent))
 112                         l_dput(dparent);
 113                 RETURN(-ENOENT);
 114         }
 115         inode = dparent->d_inode;
 116
 117         info.m.nid = nid;
 118         info.m.uid = uc->luc_uid;
 119         info.m.gid = uc->luc_gid;
 120         info.m.result = -EPERM;
 121         info.m.code = op;
 122         info.name = name;
 123         info.namelen = namelen;
 124
 125         if (name && namelen > 0) {
 126                 dchild = ll_lookup_one_len(name, dparent, namelen);
 127                 if (!IS_ERR(dchild)) {
 128                         if (!dchild->d_flags & DCACHE_CROSS_REF) {
 129                                 inode = dchild->d_inode;
 130                                 info.name = NULL;
 131                                 info.namelen = 0;
 132                         }
 133                 }
 134         }
 135
 136         mds_pack_inode2id(obd, &info.m.id, inode, 1);
 137
 138         fsfilt_set_info(obd, inode->i_sb, inode,
 139                         10, "audit_info", sizeof(info), &info);
 140         l_dput(dparent);
 141
 142         EXIT;
 143
 144         return rc;
 145 }
 146
 147 int mds_audit_reint(struct ptlrpc_request *req,
 148                     struct mds_update_record *rec)
 149 {
 150         audit_op code = AUDIT_UNKNOWN;
 151         int rc = 0;
 152
 153         switch (rec->ur_opcode) {
 154                 case REINT_SETATTR:
 155                         code = AUDIT_SETATTR;
 156                         break;
 157                 case REINT_CREATE:
 158                         code = AUDIT_CREATE;
 159                         break;
 160                 case REINT_LINK:
 161                         code = AUDIT_LINK;
 162                         break;
 163                 case REINT_UNLINK:
 164                         code = AUDIT_UNLINK;
 165                         break;
 166                 case REINT_RENAME:
 167                         code = AUDIT_RENAME;
 168                         break;
 169                 case REINT_OPEN:
 170                         code = AUDIT_OPEN;
 171                         break;
 172                 default:
 173                         CERROR("Wrong opcode in reint\n");
 174                         LBUG();
 175         }
 176
 177         rc = mds_audit_auth(req, &rec->ur_uc, code, rec->ur_id1,
 178                             rec->ur_name, rec->ur_namelen - 1);
 179         return rc;
 180 }
 181
 182 static int mds_set_obj_audit(struct obd_device * obd, struct inode * inode,
 183                       __u64 * mask)
 184 {
 185         struct audit_lov_msg msg = {
 186                 .mask = *mask,
 187                 .lsm = NULL,
 188                 .uid = inode->i_uid,
 189                 .gid = inode->i_gid,
 190         };
 191         int len, rc = 0;
 192         void *lmm = NULL;
 193         ENTRY;
 194
 195         down(&inode->i_sem);
 196         len = fsfilt_get_md(obd, inode, NULL, 0, EA_LOV);
 197         up(&inode->i_sem);
 198
 199         if (len < 0) {
 200                 CERROR("error getting inode %lu LOV: %d\n", inode->i_ino, len);
 201                 GOTO(out, rc = len);
 202         } else if (len == 0) {
 203                 CDEBUG(D_INODE, "no LOV in inode %lu\n", inode->i_ino);
 204                 GOTO(out, rc = 0);
 205         }
 206
 207         OBD_ALLOC(lmm, len);
 208         if (lmm == NULL) {
 209                 CERROR("can't allocate memory\n");
 210                 GOTO(out, rc = -ENOMEM);
 211         }
 212
 213         down(&inode->i_sem);
 214         rc = fsfilt_get_md(obd, inode, lmm, len, EA_LOV);
 215         up(&inode->i_sem);
 216
 217         if (rc < 0) {
 218                 CERROR("error getting inode %lu MD: %d\n", inode->i_ino, rc);
 219                 GOTO(out, rc);
 220         }
 221
 222         rc = obd_unpackmd(obd->u.mds.mds_dt_exp, &msg.lsm, lmm, len);
 223         if (rc < 0) {
 224                 CERROR("error unpacking inode %lu MD: %d\n", inode->i_ino, rc);
 225                 GOTO(out, rc);
 226         }
 227
 228         obd_set_info(obd->u.mds.mds_dt_exp, 9, "audit_obj", sizeof(msg), &msg);
 229
 230 out:
 231         if (msg.lsm != NULL)
 232                 obd_free_memmd(obd->u.mds.mds_dt_exp, &msg.lsm);
 233
 234         if (lmm != NULL)
 235                 OBD_FREE(lmm, len);
 236
 237         RETURN(rc);
 238 }
 239
 240 //set audit attributes for directory/file
 241 int mds_set_audit(struct obd_device * obd, void * val)
 242 {
 243         struct inode * inode = NULL;
 244         struct dentry * dentry = NULL;
 245         //struct lvfs_run_ctxt saved;
 246         struct audit_attr_msg * msg = val;
 247
 248         ENTRY;
 249
 250         //push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
 251         if (IS_AUDIT_OP(msg->attr, AUDIT_FS) == 0) {
 252                 dentry = mds_id2dentry(obd, &msg->id, NULL);
 253                 if (IS_ERR(dentry)) {
 254                         CERROR("Cannot get dentry "DLID4" err=%li\n", OLID4(&msg->id),
 255                                 PTR_ERR(dentry));
 256                         RETURN(PTR_ERR(dentry));
 257                 }
 258                 inode = dentry->d_inode;
 259         }
 260         fsfilt_set_info(obd, obd->u.mds.mds_sb, inode,
 261                         5, "audit", sizeof(msg->attr), &msg->attr);
 262
 263         if (inode && S_ISREG(inode->i_mode))
 264                 mds_set_obj_audit(obd, inode, &msg->attr);
 265
 266         if (dentry)
 267                 l_dput(dentry);
 268
 269         //pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
 270
 271         RETURN(0);
 272 }
 273
 274 int mds_pack_audit(struct obd_device * obd, struct inode * inode,
 275                   struct mds_body * body)
 276 {
 277         __u64 mask = 0;
 278         int len = sizeof(mask);
 279         int rc = 0;
 280
 281         rc = fsfilt_get_info(obd, inode->i_sb, inode,
 282                              5, "audit", &len, &mask);
 283         if (!rc) {
 284                 body->audit = mask;
 285                 body->valid |= OBD_MD_FLAUDIT;
 286         }
 287         return rc;
 288 }