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_stat(struct ptlrpc_request *req, struct lustre_id * id,
  58                    struct inode *inode, char *name, int namelen, 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 audit_info info = {
  63                 .name = NULL,
  64                 .namelen = 0,
  65         };
  66         int rc = 0, len = sizeof(info);
  67
  68         ENTRY;
  69
  70         LASSERT(inode);
  71         LASSERT(id);
  72         info.m.id = *id;
  73         info.m.nid = nid;
  74         info.m.uid = current->uid;
  75         info.m.gid = current->gid;
  76         info.m.result = ret;
  77         info.m.code = AUDIT_STAT;
  78         if (ret) {
  79                 info.name = name;
  80                 info.namelen = namelen;
  81         }
  82         // send info to local fs
  83         fsfilt_set_info(obd, inode->i_sb, inode,
  84                         10, "audit_info", len, (void*)&info);
  85
  86         RETURN(rc);
  87 }
  88
  89 int mds_audit_perm(struct ptlrpc_request *req, struct inode *inode, audit_op op)
  90 {
  91         struct obd_device *obd = req->rq_export->exp_obd;
  92         ptl_nid_t nid = req->rq_peer.peer_id.nid;
  93         struct audit_info info = {
  94                 .name = NULL,
  95                 .namelen = 0,
  96         };
  97         int rc = 0;
  98
  99         ENTRY;
 100
 101         LASSERT(inode);
 102         info.m.nid = nid;
 103         info.m.uid = current->uid;
 104         info.m.gid = current->gid;
 105         info.m.result = -EACCES;
 106         info.m.code = op;
 107
 108         /* failed access, log child id only */
 109         mds_pack_inode2id(obd, &info.m.id, inode, 1);
 110
 111         fsfilt_set_info(obd, inode->i_sb, inode,
 112                         10, "audit_info", sizeof(info), (void*)&info);
 113
 114         RETURN(rc);
 115 }
 116
 117 int mds_audit_open(struct ptlrpc_request *req, struct lustre_id * id,
 118                    struct inode *inode, char *name, int namelen, int ret)
 119 {
 120         struct obd_device *obd = req->rq_export->exp_obd;
 121         ptl_nid_t nid = req->rq_peer.peer_id.nid;
 122         struct audit_info info = {
 123                 .name = NULL,
 124                 .namelen = 0,
 125         };
 126         int rc = 0, len = sizeof(info);
 127
 128         ENTRY;
 129
 130         LASSERT(inode);
 131         info.m.id = (*id);
 132         info.m.nid = nid;
 133         info.m.uid = current->uid;
 134         info.m.gid = current->gid;
 135         info.m.result = ret;
 136         info.m.code = AUDIT_OPEN;
 137         if (ret) {
 138                 info.name = name;
 139                 info.namelen = namelen;
 140         }
 141
 142         fsfilt_set_info(obd, inode->i_sb, inode,
 143                         10, "audit_info", len, (void*)&info);
 144
 145         RETURN(rc);
 146 }
 147
 148 int mds_audit_auth(struct ptlrpc_request *req, struct lvfs_ucred * uc,
 149                    audit_op op, struct lustre_id * id,
 150                    char * name, int namelen)
 151 {
 152         struct obd_device *obd = req->rq_export->exp_obd;
 153         ptl_nid_t nid = req->rq_peer.peer_id.nid;
 154         int rc = 0;
 155         struct dentry * dparent, *dchild = NULL;
 156         struct inode * inode;
 157         struct audit_info info;
 158
 159         ENTRY;
 160
 161         dparent = mds_id2dentry(obd, id, NULL);
 162         if (IS_ERR(dparent) || !dparent->d_inode) {
 163                 CERROR("can't find inode "LPU64"\n", id_ino(id));
 164                 if (!IS_ERR(dparent))
 165                         l_dput(dparent);
 166                 RETURN(-ENOENT);
 167         }
 168         inode = dparent->d_inode;
 169
 170         info.m.nid = nid;
 171         info.m.uid = uc->luc_uid;
 172         info.m.gid = uc->luc_gid;
 173         info.m.result = -EPERM;
 174         info.m.code = op;
 175         info.name = name;
 176         info.namelen = namelen;
 177
 178         if (name && namelen > 0) {
 179                 dchild = ll_lookup_one_len(name, dparent, namelen);
 180                 if (!IS_ERR(dchild)) {
 181                         if (dchild->d_flags & DCACHE_CROSS_REF) {
 182                                 //TODO: we should know audit setting for this
 183                                 //so remote call is needed
 184                         } else {
 185                                 inode = dchild->d_inode;
 186                                 info.name = NULL;
 187                                 info.namelen = 0;
 188                         }
 189                 }
 190         }
 191
 192         mds_pack_inode2id(obd, &info.m.id, inode, 1);
 193
 194         fsfilt_set_info(obd, inode->i_sb, inode,
 195                         10, "audit_info", sizeof(info), &info);
 196         l_dput(dparent);
 197
 198         EXIT;
 199
 200         return rc;
 201 }
 202
 203 int mds_audit_reint(struct ptlrpc_request *req,
 204                     struct mds_update_record *rec)
 205 {
 206         audit_op code = AUDIT_UNKNOWN;
 207         int rc = 0;
 208
 209         switch (rec->ur_opcode) {
 210                 case REINT_SETATTR:
 211                         code = AUDIT_SETATTR;
 212                         break;
 213                 case REINT_CREATE:
 214                         code = AUDIT_CREATE;
 215                         break;
 216                 case REINT_LINK:
 217                         code = AUDIT_LINK;
 218                         break;
 219                 case REINT_UNLINK:
 220                         code = AUDIT_UNLINK;
 221                         break;
 222                 case REINT_RENAME:
 223                         code = AUDIT_RENAME;
 224                         break;
 225                 case REINT_OPEN:
 226                         code = AUDIT_OPEN;
 227                         break;
 228                 default:
 229                         CERROR("Wrong opcode in reint\n");
 230                         LBUG();
 231         }
 232
 233         rc = mds_audit_auth(req, &rec->ur_uc, code, rec->ur_id1,
 234                             rec->ur_name, rec->ur_namelen - 1);
 235         return rc;
 236 }
 237
 238 static int mds_set_obj_audit(struct obd_device * obd, struct inode * inode,
 239                       __u64 * mask)
 240 {
 241         struct audit_lov_msg msg = {
 242                 .mask = *mask,
 243                 .lsm = NULL,
 244                 .uid = inode->i_uid,
 245                 .gid = inode->i_gid,
 246         };
 247         int len, rc = 0;
 248         void *lmm = NULL;
 249         ENTRY;
 250
 251         down(&inode->i_sem);
 252         len = fsfilt_get_md(obd, inode, NULL, 0, EA_LOV);
 253         up(&inode->i_sem);
 254
 255         if (len < 0) {
 256                 CERROR("error getting inode %lu LOV: %d\n", inode->i_ino, len);
 257                 GOTO(out, rc = len);
 258         } else if (len == 0) {
 259                 CDEBUG(D_INODE, "no LOV in inode %lu\n", inode->i_ino);
 260                 GOTO(out, rc = 0);
 261         }
 262
 263         OBD_ALLOC(lmm, len);
 264         if (lmm == NULL) {
 265                 CERROR("can't allocate memory\n");
 266                 GOTO(out, rc = -ENOMEM);
 267         }
 268
 269         down(&inode->i_sem);
 270         rc = fsfilt_get_md(obd, inode, lmm, len, EA_LOV);
 271         up(&inode->i_sem);
 272
 273         if (rc < 0) {
 274                 CERROR("error getting inode %lu MD: %d\n", inode->i_ino, rc);
 275                 GOTO(out, rc);
 276         }
 277
 278         rc = obd_unpackmd(obd->u.mds.mds_dt_exp, &msg.lsm, lmm, len);
 279         if (rc < 0) {
 280                 CERROR("error unpacking inode %lu MD: %d\n", inode->i_ino, rc);
 281                 GOTO(out, rc);
 282         }
 283
 284         obd_set_info(obd->u.mds.mds_dt_exp, 9, "audit_obj", sizeof(msg), &msg);
 285
 286 out:
 287         if (msg.lsm != NULL)
 288                 obd_free_memmd(obd->u.mds.mds_dt_exp, &msg.lsm);
 289
 290         if (lmm != NULL)
 291                 OBD_FREE(lmm, len);
 292
 293         RETURN(rc);
 294 }
 295
 296 //set audit attributes for directory/file
 297 int mds_set_audit(struct obd_device * obd, void * val)
 298 {
 299         struct inode * inode = NULL;
 300         struct dentry * dentry = NULL;
 301         //struct lvfs_run_ctxt saved;
 302         struct audit_attr_msg * msg = val;
 303
 304         ENTRY;
 305
 306         //push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
 307
 308         dentry = mds_id2dentry(obd, &msg->id, NULL);
 309         if (IS_ERR(dentry)) {
 310                 CERROR("Cannot get dentry\n");
 311                 RETURN(PTR_ERR(dentry));
 312         }
 313
 314         inode = dentry->d_inode;
 315         fsfilt_set_info(obd, inode->i_sb, inode,
 316                         5, "audit", sizeof(msg->attr), &msg->attr);
 317
 318         if (S_ISREG(inode->i_mode) && !IS_AUDIT_OP(msg->attr, AUDIT_FS))
 319                 mds_set_obj_audit(obd, inode, &msg->attr);
 320
 321         l_dput(dentry);
 322
 323         //pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
 324
 325         RETURN(0);
 326 }
 327
 328 int mds_pack_audit(struct obd_device * obd, struct inode * inode,
 329                   struct mds_body * body)
 330 {
 331         __u64 mask = 0;
 332         int len = sizeof(mask);
 333         int rc = 0;
 334
 335         rc = fsfilt_get_info(obd, inode->i_sb, inode,
 336                              5, "audit", &len, &mask);
 337         if (!rc) {
 338                 body->audit = mask;
 339                 body->valid |= OBD_MD_FLAUDIT;
 340         }
 341         return rc;
 342 }