lustre/mdc/mdc_lib.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #define DEBUG_SUBSYSTEM S_MDS
  23 #ifndef __KERNEL__
  24 # include <fcntl.h>
  25 # include <liblustre.h>
  26 #endif
  27 #include <linux/lustre_idl.h>
  28 #include <linux/lustre_net.h>
  29 #include <linux/lustre_mds.h>
  30 #include "mdc_internal.h"
  31
  32 #ifndef __KERNEL__
  33 /* some liblustre hackings here */
  34 #ifndef O_DIRECTORY
  35 #define O_DIRECTORY     0
  36 #endif
  37 #endif
  38
  39 void mdc_readdir_pack(struct ptlrpc_request *req, __u64 offset, __u32 size,
  40                       struct ll_fid *mdc_fid)
  41 {
  42         struct mds_body *b;
  43
  44         b = lustre_msg_buf(req->rq_reqmsg, 0, sizeof (*b));
  45         b->fsuid = current->fsuid;
  46         b->fsgid = current->fsgid;
  47         b->capability = current->cap_effective;
  48         b->fid1 = *mdc_fid;
  49         b->size = offset;                       /* !! */
  50         b->suppgid = -1;
  51         b->nlink = size;                        /* !! */
  52 }
  53
  54 static void mdc_pack_body(struct mds_body *b)
  55 {
  56         LASSERT (b != NULL);
  57
  58         b->fsuid = current->fsuid;
  59         b->fsgid = current->fsgid;
  60         b->capability = current->cap_effective;
  61 }
  62
  63 void mdc_pack_req_body(struct ptlrpc_request *req)
  64 {
  65         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0, sizeof (*b));
  66         mdc_pack_body(b);
  67 }
  68
  69 /* packing of MDS records */
  70 void mdc_create_pack(struct ptlrpc_request *req, int offset,
  71                      struct mdc_op_data *op_data, __u32 mode, __u64 rdev,
  72                      const void *data, int datalen)
  73 {
  74         struct mds_rec_create *rec;
  75         char *tmp;
  76         rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
  77
  78         rec->cr_opcode = REINT_CREATE;
  79         rec->cr_fsuid = current->fsuid;
  80         rec->cr_fsgid = current->fsgid;
  81         rec->cr_cap = current->cap_effective;
  82         rec->cr_fid = op_data->fid1;
  83         memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
  84         rec->cr_mode = mode;
  85         rec->cr_rdev = rdev;
  86         rec->cr_time = op_data->mod_time;
  87         rec->cr_suppgid = op_data->ctxt.gid1;
  88
  89         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, op_data->namelen + 1);
  90         LOGL0(op_data->name, op_data->namelen, tmp);
  91
  92         if (data) {
  93                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, datalen);
  94                 memcpy (tmp, data, datalen);
  95         }
  96 }
  97
  98 static __u32 mds_pack_open_flags(__u32 flags)
  99 {
 100         return
 101                 (flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC |
 102                           MDS_OPEN_DELAY_CREATE | MDS_OPEN_HAS_EA)) |
 103                 ((flags & O_CREAT) ? MDS_OPEN_CREAT : 0) |
 104                 ((flags & O_EXCL) ? MDS_OPEN_EXCL : 0) |
 105                 ((flags & O_TRUNC) ? MDS_OPEN_TRUNC : 0) |
 106                 ((flags & O_APPEND) ? MDS_OPEN_APPEND : 0) |
 107                 ((flags & O_SYNC) ? MDS_OPEN_SYNC : 0) |
 108                 ((flags & O_DIRECTORY) ? MDS_OPEN_DIRECTORY : 0) |
 109                 0;
 110 }
 111
 112 /* packing of MDS records */
 113 void mdc_open_pack(struct ptlrpc_request *req, int offset,
 114                    struct mdc_op_data *op_data, __u32 mode, __u64 rdev,
 115                    __u32 flags, const void *lmm, int lmmlen)
 116 {
 117         struct mds_rec_create *rec;
 118         char *tmp;
 119         rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
 120
 121         /* XXX do something about time, uid, gid */
 122         rec->cr_opcode = REINT_OPEN;
 123         rec->cr_fsuid = current->fsuid;
 124         rec->cr_fsgid = current->fsgid;
 125         rec->cr_cap = current->cap_effective;
 126         if (op_data != NULL)
 127                 rec->cr_fid = op_data->fid1;
 128         memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
 129         rec->cr_mode = mode;
 130         rec->cr_flags = mds_pack_open_flags(flags);
 131         rec->cr_rdev = rdev;
 132         rec->cr_time = op_data->mod_time;
 133         rec->cr_suppgid = op_data->ctxt.gid1;
 134
 135         if (op_data->name) {
 136                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1,
 137                                      op_data->namelen + 1);
 138                 LOGL0(op_data->name, op_data->namelen, tmp);
 139         }
 140
 141         if (lmm) {
 142                 rec->cr_flags |= MDS_OPEN_HAS_EA;
 143                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, lmmlen);
 144                 memcpy (tmp, lmm, lmmlen);
 145         }
 146 }
 147
 148 void mdc_setattr_pack(struct ptlrpc_request *req, struct mdc_op_data *data,
 149                       struct iattr *iattr, void *ea, int ealen,
 150                       void *ea2, int ea2len)
 151 {
 152         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, 0,
 153                                                      sizeof (*rec));
 154         rec->sa_opcode = REINT_SETATTR;
 155         rec->sa_fsuid = current->fsuid;
 156         rec->sa_fsgid = current->fsgid;
 157         rec->sa_cap = current->cap_effective;
 158         rec->sa_fid = data->fid1;
 159
 160         if (iattr) {
 161                 rec->sa_valid = iattr->ia_valid;
 162                 rec->sa_mode = iattr->ia_mode;
 163                 rec->sa_uid = iattr->ia_uid;
 164                 rec->sa_gid = iattr->ia_gid;
 165                 rec->sa_size = iattr->ia_size;
 166                 rec->sa_atime = LTIME_S(iattr->ia_atime);
 167                 rec->sa_mtime = LTIME_S(iattr->ia_mtime);
 168                 rec->sa_ctime = LTIME_S(iattr->ia_ctime);
 169                 rec->sa_attr_flags = iattr->ia_attr_flags;
 170                 if ((iattr->ia_valid & ATTR_GID) && in_group_p(iattr->ia_gid))
 171                         rec->sa_suppgid = iattr->ia_gid;
 172                 else if ((iattr->ia_valid & ATTR_MODE) &&
 173                          in_group_p(iattr->ia_gid))
 174                         rec->sa_suppgid = data->ctxt.gid1;
 175                 else if ((iattr->ia_valid & (ATTR_MTIME|ATTR_CTIME)) &&
 176                          data->ctxt.gid1 != -1)
 177                         rec->sa_suppgid = data->ctxt.gid1;
 178         }
 179
 180         if (ealen == 0)
 181                 return;
 182
 183         memcpy(lustre_msg_buf(req->rq_reqmsg, 1, ealen), ea, ealen);
 184
 185         if (ea2len == 0)
 186                 return;
 187
 188         memcpy(lustre_msg_buf(req->rq_reqmsg, 2, ea2len), ea2, ea2len);
 189 }
 190
 191 void mdc_unlink_pack(struct ptlrpc_request *req, int offset,
 192                      struct mdc_op_data *data)
 193 {
 194         struct mds_rec_unlink *rec;
 195         char *tmp;
 196
 197         rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
 198         LASSERT (rec != NULL);
 199
 200         rec->ul_opcode = REINT_UNLINK;
 201         rec->ul_fsuid = current->fsuid;
 202         rec->ul_fsgid = current->fsgid;
 203         rec->ul_cap = current->cap_effective;
 204         rec->ul_mode = data->create_mode;
 205         rec->ul_suppgid = data->ctxt.gid1;
 206         rec->ul_fid1 = data->fid1;
 207         rec->ul_fid2 = data->fid2;
 208         rec->ul_time = data->mod_time;
 209
 210         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, data->namelen + 1);
 211         LASSERT (tmp != NULL);
 212         LOGL0(data->name, data->namelen, tmp);
 213 }
 214
 215 void mdc_link_pack(struct ptlrpc_request *req, int offset,
 216                    struct mdc_op_data *data)
 217 {
 218         struct mds_rec_link *rec;
 219         char *tmp;
 220
 221         rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
 222
 223         rec->lk_opcode = REINT_LINK;
 224         rec->lk_fsuid = current->fsuid;
 225         rec->lk_fsgid = current->fsgid;
 226         rec->lk_cap = current->cap_effective;
 227         rec->lk_suppgid1 = data->ctxt.gid1;
 228         rec->lk_suppgid2 = data->ctxt.gid2;
 229         rec->lk_fid1 = data->fid1;
 230         rec->lk_fid2 = data->fid2;
 231         rec->lk_time = data->mod_time;
 232
 233         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, data->namelen + 1);
 234         LOGL0(data->name, data->namelen, tmp);
 235 }
 236
 237 void mdc_rename_pack(struct ptlrpc_request *req, int offset,
 238                      struct mdc_op_data *data,
 239                      const char *old, int oldlen, const char *new, int newlen)
 240 {
 241         struct mds_rec_rename *rec;
 242         char *tmp;
 243
 244         rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
 245
 246         /* XXX do something about time, uid, gid */
 247         rec->rn_opcode = REINT_RENAME;
 248         rec->rn_fsuid = current->fsuid;
 249         rec->rn_fsgid = current->fsgid;
 250         rec->rn_cap = current->cap_effective;
 251         if (in_group_p(data->ctxt.gid1))
 252                 rec->rn_suppgid1 = data->ctxt.gid1;
 253         else
 254                 rec->rn_suppgid1 = -1;
 255         if (in_group_p(data->ctxt.gid2))
 256                 rec->rn_suppgid2 = data->ctxt.gid2;
 257         else
 258                 rec->rn_suppgid2 = -1;
 259         rec->rn_fid1 = data->fid1;
 260         rec->rn_fid2 = data->fid2;
 261         rec->rn_time = data->mod_time;
 262
 263         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, oldlen + 1);
 264         LOGL0(old, oldlen, tmp);
 265
 266         if (new) {
 267                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, newlen + 1);
 268                 LOGL0(new, newlen, tmp);
 269         }
 270 }
 271
 272 void mdc_getattr_pack(struct ptlrpc_request *req, int valid, int offset,
 273                       int flags, struct mdc_op_data *data)
 274 {
 275         struct mds_body *b;
 276         b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*b));
 277
 278         b->fsuid = current->fsuid;
 279         b->fsgid = current->fsgid;
 280         b->capability = current->cap_effective;
 281         b->valid = valid;
 282         b->flags = flags;
 283         b->suppgid = data->ctxt.gid1;
 284
 285         b->fid1 = data->fid1;
 286         if (data->name) {
 287                 char *tmp;
 288                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1,
 289                                      data->namelen + 1);
 290                 LOGL0(data->name, data->namelen, tmp);
 291         }
 292 }
 293