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 <linux/lustre_audit.h>
  56 #include "mds_internal.h"
  57
  58 int mds_audit_stat(struct ptlrpc_request *req, struct lustre_id * id,
  59                    struct dentry * dentry, int ret)
  60 {
  61         struct obd_device *obd = req->rq_export->exp_obd;
  62         struct inode * inode = dentry->d_inode;
  63         ptl_nid_t nid = req->rq_peer.peer_id.nid;
  64         struct audit_info info;
  65         int rc = 0, len = sizeof(info);
  66         ENTRY;
  67
  68         LASSERT(inode);
  69         LASSERT(id);
  70         memcpy(&info.m.id, id, sizeof(*id));
  71         info.m.nid = nid;
  72         info.m.uid = current->uid;
  73         info.m.gid = current->gid;
  74         info.m.result = ret;
  75         info.m.code = AUDIT_STAT;
  76
  77         //send info to local fs
  78         fsfilt_set_info(obd, inode->i_sb, inode,
  79                         10, "audit_info", len, (void*)&info);
  80
  81         RETURN(rc);
  82 }
  83
  84 int mds_audit_open(struct ptlrpc_request *req, struct mds_update_record * rec,
  85                    int ret)
  86 {
  87         struct obd_device *obd = req->rq_export->exp_obd;
  88         struct inode * inode = NULL;
  89         ptl_nid_t nid = req->rq_peer.peer_id.nid;
  90         struct audit_info info;
  91         int rc = 0, len = sizeof(info);
  92
  93         struct dentry * dparent = NULL;
  94
  95         dparent = mds_id2dentry(obd, rec->ur_id1, NULL);
  96         if (IS_ERR(dparent)) {
  97                 rc = PTR_ERR(dparent);
  98                 RETURN(rc);
  99         }
 100         inode = dparent->d_inode;
 101
 102         info.m.id = *(rec->ur_id1);
 103         info.m.nid = nid;
 104         info.m.uid = rec->ur_uc.luc_uid;
 105         info.m.gid = rec->ur_uc.luc_gid;
 106         info.m.result = ret;
 107         info.m.code = AUDIT_OPEN;
 108         info.name = rec->ur_name;
 109         info.namelen = rec->ur_namelen;
 110
 111         //send info to local fs
 112         fsfilt_set_info(obd, inode->i_sb, inode,
 113                         10, "audit_info", len, (void*)&info);
 114
 115         l_dput(dparent);
 116
 117         RETURN(rc);
 118 }
 119
 120 int mds_audit_auth(struct ptlrpc_request *req, struct lvfs_ucred * uc,
 121                    audit_op op, struct lustre_id * id,
 122                    char * name, int namelen)
 123 {
 124         struct obd_device *obd = req->rq_export->exp_obd;
 125         ptl_nid_t nid = req->rq_peer.peer_id.nid;
 126         int rc = 0;
 127         struct dentry * dparent;
 128         struct inode * inode;
 129         struct audit_info info;
 130
 131         ENTRY;
 132
 133         dparent = mds_id2dentry(obd, id, NULL);
 134         if (IS_ERR(dparent)) {
 135                 rc = PTR_ERR(dparent);
 136                 GOTO(out, rc);
 137         }
 138         inode = dparent->d_inode;
 139
 140         info.m.nid = nid;
 141         info.m.uid = uc->luc_uid;
 142         info.m.gid = uc->luc_gid;
 143         info.m.id = (*id);
 144         info.m.result = -EPERM;
 145         info.m.code = op;
 146         info.name = name;
 147         info.namelen = namelen;
 148
 149         fsfilt_set_info(obd, inode->i_sb, inode,
 150                         10, "audit_info", sizeof(info), &info);
 151         l_dput(dparent);
 152
 153         EXIT;
 154  out:
 155         return rc;
 156 }
 157
 158 static int mds_set_obj_audit(struct obd_device * obd, struct inode * inode,
 159                       __u64 * mask)
 160 {
 161         struct audit_lov_msg msg = {
 162                 .mask = *mask,
 163                 .lsm = NULL,
 164                 .uid = inode->i_uid,
 165                 .gid = inode->i_gid,
 166         };
 167         int len, rc = 0;
 168         void *lmm = NULL;
 169
 170         down(&inode->i_sem);
 171         len = fsfilt_get_md(obd, inode, NULL, 0, EA_LOV);
 172         up(&inode->i_sem);
 173
 174         if (len < 0) {
 175                 CERROR("error getting inode %lu LOV: %d\n", inode->i_ino, len);
 176                 GOTO(out, rc = len);
 177         } else if (len == 0) {
 178                 CDEBUG(D_INODE, "no LOV in inode %lu\n", inode->i_ino);
 179                 GOTO(out, rc = 0);
 180         }
 181
 182         OBD_ALLOC(lmm, len);
 183         if (lmm == NULL) {
 184                 CERROR("can't allocate memory\n");
 185                 GOTO(out, rc = -ENOMEM);
 186         }
 187
 188         down(&inode->i_sem);
 189         rc = fsfilt_get_md(obd, inode, lmm, len, EA_LOV);
 190         up(&inode->i_sem);
 191
 192         if (rc < 0) {
 193                 CERROR("error getting inode %lu MD: %d\n", inode->i_ino, rc);
 194                 GOTO(out, rc);
 195         }
 196
 197         rc = obd_unpackmd(obd->u.mds.mds_dt_exp, &msg.lsm, lmm, len);
 198         if (rc < 0) {
 199                 CERROR("error unpacking inode %lu MD: %d\n", inode->i_ino, rc);
 200                 GOTO(out, rc);
 201         }
 202
 203         obd_set_info(obd->u.mds.mds_dt_exp, 9, "audit_obj", sizeof(msg), &msg);
 204
 205 out:
 206         if (msg.lsm != NULL)
 207                 obd_free_memmd(obd->u.mds.mds_dt_exp, &msg.lsm);
 208
 209         if (lmm != NULL)
 210                 OBD_FREE(lmm, len);
 211
 212         RETURN(rc);
 213 }
 214
 215 //set audit attributes for directory/file
 216 int mds_set_audit(struct obd_device * obd, void * val)
 217 {
 218         struct inode * inode = NULL;
 219         struct dentry * dentry = NULL;
 220         //struct lvfs_run_ctxt saved;
 221         struct audit_attr_msg * msg = val;
 222
 223         ENTRY;
 224
 225         //push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
 226
 227         dentry = mds_id2dentry(obd, &msg->id, NULL);
 228         if (IS_ERR(dentry)) {
 229                 CERROR("Cannot get dentry\n");
 230                 RETURN(PTR_ERR(dentry));
 231         }
 232
 233         inode = dentry->d_inode;
 234         fsfilt_set_info(obd, inode->i_sb, inode,
 235                         5, "audit", sizeof(msg->attr), &msg->attr);
 236
 237         if (S_ISREG(inode->i_mode) && !IS_AUDIT_OP(msg->attr, AUDIT_FS))
 238                 mds_set_obj_audit(obd, inode, &msg->attr);
 239
 240         l_dput(dentry);
 241
 242         //pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
 243
 244         RETURN(0);
 245 }
 246
 247 int mds_pack_audit(struct obd_device * obd, struct inode * inode,
 248                   struct mds_body * body)
 249 {
 250         __u64 mask = 0;
 251         int len = sizeof(mask);
 252         int rc = 0;
 253
 254         rc = fsfilt_get_info(obd, inode->i_sb, inode,
 255                              5, "audit", &len, &mask);
 256         if (!rc) {
 257                 body->audit = mask;
 258                 body->valid |= OBD_MD_FLAUDIT;
 259         }
 260         return rc;
 261 }