lustre/smfs/mds_kml.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Lustre filesystem abstraction routines
   5  *
   6  *  Copyright (C) 2004 Cluster File Systems, Inc.
   7  *
   8  *   This file is part of Lustre, http://www.lustre.org.
   9  *
  10  *   Lustre is free software; you can redistribute it and/or
  11  *   modify it under the terms of version 2 of the GNU General Public
  12  *   License as published by the Free Software Foundation.
  13  *
  14  *   Lustre is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with Lustre; if not, write to the Free Software
  21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #define DEBUG_SUBSYSTEM S_SM
  25
  26 #include <linux/kmod.h>
  27 #include <linux/init.h>
  28 #include <linux/fs.h>
  29 #include <linux/slab.h>
  30 #include <linux/obd_class.h>
  31 #include <linux/obd_support.h>
  32 #include <linux/lustre_lib.h>
  33 #include <linux/lustre_idl.h>
  34 #include <linux/lustre_fsfilt.h>
  35 #include <linux/lustre_lite.h>
  36 #include <linux/lustre_mds.h>
  37 #include <linux/lustre_smfs.h>
  38 #include "smfs_internal.h"
  39
  40 static int mds_rec_link_pack(char *buffer, struct dentry *dentry,
  41                              struct inode *dir, void *data1, void *data2)
  42 {
  43         struct mdc_op_data op_data;
  44         struct mds_kml_pack_info *mkpi;
  45         struct dentry *tgt = (struct dentry *)data1;
  46         struct dentry *src = (struct dentry *)data2;
  47         void   *tmp = NULL;
  48         struct lustre_msg *msg = NULL;
  49         int    rc = 0;
  50
  51         ll_prepare_mdc_op_data(&op_data, src->d_inode, dir, tgt->d_name.name,
  52                                tgt->d_name.len, 0);
  53
  54         PACK_KML_REC_INIT(buffer, MDS_REINT);
  55
  56         mkpi = (struct mds_kml_pack_info*)buffer;
  57
  58         mkpi->mpi_bufcount = 2;
  59         mkpi->mpi_size[0] = sizeof(struct mds_rec_link);
  60         mkpi->mpi_size[1] = op_data.namelen + 1;
  61
  62         /*the mds reint log format
  63          *opcode + mkpi + request
  64          */
  65         msg = (struct lustre_msg *)(buffer + sizeof(*mkpi));
  66         lustre_init_msg(msg, mkpi->mpi_bufcount, mkpi->mpi_size, NULL);
  67
  68         tmp = mdc_link_pack(msg, 0, &op_data);
  69         mkpi->mpi_total_size = tmp - (void*)msg;
  70         rc = mkpi->mpi_total_size + sizeof(*mkpi) + sizeof(int);
  71         return rc;
  72 }
  73
  74 static int mds_rec_setattr_pack(char *buffer, struct dentry *dentry,
  75                                 struct inode *dir, void *data1, void *data2)
  76 {
  77         struct mds_rec_setattr *rec = NULL;
  78         struct mdc_op_data op_data;
  79         struct mds_kml_pack_info *mkpi;
  80         struct iattr *iattr = (struct iattr *)data1;
  81         struct lustre_msg *msg = NULL;
  82         char   *ea = NULL;
  83         void   *tmp = NULL;
  84         int    rc = 0, ealen = 0;
  85
  86         ll_prepare_mdc_op_data(&op_data, dir, NULL, NULL, 0, 0);
  87
  88         PACK_KML_REC_INIT(buffer, MDS_REINT);
  89
  90         mkpi = (struct mds_kml_pack_info*)buffer;
  91
  92         /*FIXME later, did not think about EA situation*/
  93
  94         mkpi->mpi_bufcount = 1;
  95         mkpi->mpi_size[0] = sizeof(struct mds_rec_setattr);
  96         if (data2) {
  97                 mkpi->mpi_bufcount ++;
  98                 mkpi->mpi_size[1] = *(int *)data2;
  99                 ealen = *(int *)data2;
 100                 ea = data2 + sizeof(ealen);
 101         }
 102
 103         msg = (struct lustre_msg *)(buffer + sizeof(*mkpi));
 104         lustre_init_msg(msg, mkpi->mpi_bufcount, mkpi->mpi_size, NULL);
 105
 106         tmp = mdc_setattr_pack(msg, &op_data, iattr, ea, ealen, NULL, 0);
 107
 108         /*There are maybe some better ways
 109          *to set the time attr FIXME WANGDI later
 110          */
 111         rec = (struct mds_rec_setattr *)lustre_msg_buf(msg, 0, 0);
 112         if (rec->sa_valid & ATTR_CTIME)
 113                 rec->sa_valid |= ATTR_CTIME_SET;
 114         if (rec->sa_valid & ATTR_MTIME)
 115                 rec->sa_valid |= ATTR_MTIME_SET;
 116         if (rec->sa_valid & ATTR_ATIME)
 117                 rec->sa_valid |= ATTR_ATIME_SET;
 118
 119         mkpi->mpi_total_size = tmp - (void*)msg;
 120         rc = mkpi->mpi_total_size + sizeof(*mkpi) + sizeof(int);
 121
 122         return rc;
 123 }
 124
 125 static int mds_rec_create_pack(char *buffer, struct dentry *dentry,
 126                                struct inode *dir, void *data1, void *data2)
 127 {
 128         struct lustre_msg *msg = NULL;
 129         struct mdc_op_data op_data;
 130         struct mds_rec_create *rec;
 131         struct mds_kml_pack_info *mkpi;
 132         void   *tmp = NULL;
 133         int    rc = 0, tgt_len = 0;
 134
 135         ll_prepare_mdc_op_data(&op_data, dir, dentry->d_inode,
 136                                dentry->d_name.name, dentry->d_name.len, 0);
 137         PACK_KML_REC_INIT(buffer, MDS_REINT);
 138
 139         mkpi = (struct mds_kml_pack_info*)buffer;
 140         mkpi->mpi_bufcount = 2;
 141         mkpi->mpi_size[0] = sizeof(struct mds_rec_create);
 142         mkpi->mpi_size[1] = op_data.namelen + 1;
 143         if (data1 && data2) {
 144                 mkpi->mpi_size[2] = *(int *)data2;
 145                 mkpi->mpi_bufcount++;
 146         }
 147
 148         if (data1) {
 149                 /*for symlink, data1 will be the tgt name */
 150                 tgt_len = *(int*)data2;
 151         }
 152         msg = (struct lustre_msg *)(buffer + sizeof(*mkpi));
 153         lustre_init_msg(msg, mkpi->mpi_bufcount, mkpi->mpi_size, NULL);
 154
 155         tmp = mdc_create_pack(msg, 0, &op_data, dentry->d_inode->i_mode,
 156                               dentry->d_inode->i_mode, data1, tgt_len);
 157
 158         rec = (struct mds_rec_create *)lustre_msg_buf(msg, 0, 0);
 159
 160         rec->cr_replayfid = op_data.fid2;
 161         rec->cr_flags |= REC_REINT_CREATE;
 162         mkpi->mpi_total_size = tmp - (void*)msg;
 163         rc = mkpi->mpi_total_size + sizeof(*mkpi) + sizeof(int);
 164
 165         return rc;
 166 }
 167
 168 static int mds_rec_unlink_pack(char *buffer, struct dentry *dentry,
 169                                struct inode *dir, void *data1, void *data2)
 170 {
 171         struct lustre_msg *msg = NULL;
 172         struct mdc_op_data op_data;
 173         struct mds_kml_pack_info *mkpi;
 174         int    mode = *(int*)data1;
 175         void   *tmp = NULL;
 176         int    rc = 0;
 177
 178         ll_prepare_mdc_op_data(&op_data, dir, NULL, dentry->d_name.name,
 179                                dentry->d_name.len, mode);
 180
 181         PACK_KML_REC_INIT(buffer, MDS_REINT);
 182
 183         mkpi = (struct mds_kml_pack_info*)buffer;
 184         mkpi->mpi_bufcount = 2;
 185         mkpi->mpi_size[0] = sizeof(struct mds_rec_unlink);
 186         mkpi->mpi_size[1] = op_data.namelen + 1;
 187
 188         msg = (struct lustre_msg *)(buffer + sizeof(*mkpi));
 189         lustre_init_msg(msg, mkpi->mpi_bufcount, mkpi->mpi_size, NULL);
 190
 191         tmp = mdc_unlink_pack(msg, 0, &op_data);
 192
 193         mkpi->mpi_total_size = tmp - (void*)msg;
 194         rc = mkpi->mpi_total_size + sizeof(*mkpi) + sizeof(int);
 195
 196         return rc;
 197 }
 198
 199 static int mds_rec_rename_pack(char *buffer, struct dentry *dentry,
 200                                struct inode *dir, void *data1, void *data2)
 201 {
 202         struct lustre_msg *msg = NULL;
 203         struct dentry *new_dir = (struct dentry *)data1;
 204         struct dentry *new_dentry = (struct dentry *)data2;
 205         struct mdc_op_data op_data;
 206         struct mds_kml_pack_info *mkpi;
 207         struct mds_rec_rename *rec;
 208         void   *tmp = NULL;
 209         int    rc = 0;
 210
 211         ll_prepare_mdc_op_data(&op_data, dir, new_dir->d_inode, NULL, 0, 0);
 212
 213         PACK_KML_REC_INIT(buffer, MDS_REINT);
 214
 215         mkpi = (struct mds_kml_pack_info*)buffer;
 216         mkpi->mpi_bufcount = 3;
 217         mkpi->mpi_size[0] = sizeof(struct mds_rec_rename);
 218         mkpi->mpi_size[1] = dentry->d_name.len + 1;
 219         mkpi->mpi_size[2] = new_dentry->d_name.len + 1;
 220
 221         rec = (struct mds_rec_rename *)(buffer + sizeof(*mkpi));
 222
 223         msg = (struct lustre_msg *)(buffer + sizeof(*mkpi));
 224         lustre_init_msg(msg, mkpi->mpi_bufcount, mkpi->mpi_size, NULL);
 225
 226         tmp = mdc_rename_pack(msg, 0, &op_data, dentry->d_name.name,
 227                               dentry->d_name.len, new_dentry->d_name.name,
 228                               new_dentry->d_name.len);
 229
 230         mkpi->mpi_total_size = tmp - (void*)msg;
 231         rc = mkpi->mpi_total_size + sizeof(*mkpi) + sizeof(int);
 232         return rc;
 233 }
 234
 235 typedef int (*mds_pack_rec_func)(char *buffer, struct dentry *dentry,
 236                                  struct inode *dir, void *data1, void *data2);
 237 static mds_pack_rec_func mds_kml_pack[REINT_MAX + 1] = {
 238         [REINT_LINK]    mds_rec_link_pack,
 239         [REINT_SETATTR] mds_rec_setattr_pack,
 240         [REINT_CREATE]  mds_rec_create_pack,
 241         [REINT_UNLINK]  mds_rec_unlink_pack,
 242         [REINT_RENAME]  mds_rec_rename_pack,
 243 };
 244
 245 int mds_rec_pack(char *buffer, struct dentry *dentry, struct inode *dir,
 246                  void *data1, void *data2, int op)
 247 {
 248         return mds_kml_pack[op](buffer, dentry, dir, data1, data2);
 249 }
 250
 251 int mds_rec_pack_init(struct super_block *sb)
 252 {
 253         struct smfs_super_info *smsi = S2SMI(sb);
 254
 255         smsi->smsi_pack_rec[PACK_MDS] = mds_rec_pack;
 256
 257         return 0;
 258 }
 259