lustre/lib/mds_updates.c

   1 /*
   2  * Lustre Light Update Records
   3  *
   4  * This code is issued under the GNU General Public License.
   5  * See the file COPYING in this distribution
   6  *
   7  * Copryright (C) 2002 Cluster File Systems, Inc.
   8  *
   9  */
  10
  11 #include <linux/config.h>
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/mm.h>
  15 #include <linux/string.h>
  16 #include <linux/stat.h>
  17 #include <linux/errno.h>
  18 #include <linux/locks.h>
  19 #include <linux/unistd.h>
  20
  21 #include <asm/system.h>
  22 #include <asm/uaccess.h>
  23
  24 #include <linux/fs.h>
  25 #include <linux/stat.h>
  26 #include <asm/uaccess.h>
  27 #include <linux/slab.h>
  28 #include <asm/segment.h>
  29
  30 #define DEBUG_SUBSYSTEM S_MDS
  31
  32 #include <linux/obd_support.h>
  33 #include <linux/lustre_lib.h>
  34 #include <linux/lustre_mds.h>
  35
  36 /* packing of MDS records */
  37 void mds_create_pack(struct mds_rec_create *rec, struct inode *inode,
  38                      const char *name, int namelen, __u32 mode, __u64 id,
  39                      __u32 uid, __u32 gid, __u64 time, const char *tgt,
  40                      int tgtlen)
  41 {
  42         char *tmp = (char *)rec + sizeof(*rec);
  43         /* XXX do something about time, uid, gid */
  44         rec->cr_reclen =
  45                 HTON__u32(sizeof(*rec) + size_round0(namelen) +
  46                           size_round0(tgtlen));
  47         rec->cr_opcode = HTON__u32(REINT_CREATE);
  48
  49         ll_inode2fid(&rec->cr_fid, inode);
  50         rec->cr_mode = HTON__u32(mode);
  51         rec->cr_id = HTON__u64(id);
  52         rec->cr_uid = HTON__u32(uid);
  53         rec->cr_gid = HTON__u32(gid);
  54         rec->cr_time = HTON__u64(time);
  55         rec->cr_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
  56         LOGL0(name, namelen, tmp);
  57         if (tgt) {
  58                 rec->cr_tgtlen = HTON__u32(tgtlen + 1);
  59                 LOGL0(tgt, tgtlen, tmp);
  60         }
  61 }
  62
  63 void mds_setattr_pack(struct mds_rec_setattr *rec, struct inode *inode,
  64                       struct iattr *iattr)
  65 {
  66         rec->sa_reclen = HTON__u32(sizeof(*rec));
  67         rec->sa_opcode = HTON__u32(REINT_SETATTR);
  68
  69         ll_inode2fid(&rec->sa_fid, inode);
  70         rec->sa_valid = HTON__u32(iattr->ia_valid);
  71         rec->sa_mode = HTON__u32(iattr->ia_mode);
  72         rec->sa_uid = HTON__u32(iattr->ia_uid);
  73         rec->sa_gid = HTON__u32(iattr->ia_gid);
  74         rec->sa_size = HTON__u64(iattr->ia_size);
  75         rec->sa_atime = HTON__u64(iattr->ia_atime);
  76         rec->sa_mtime = HTON__u64(iattr->ia_mtime);
  77         rec->sa_ctime = HTON__u64(iattr->ia_ctime);
  78         rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
  79 }
  80
  81 void mds_unlink_pack(struct mds_rec_unlink *rec, struct inode *inode,
  82                      struct inode *child, const char *name, int namelen)
  83 {
  84         char *tmp = (char *)rec + sizeof(*rec);
  85
  86         rec->ul_reclen = HTON__u32(sizeof(*rec)) + size_round0(namelen);
  87         rec->ul_opcode = HTON__u32(REINT_UNLINK);
  88
  89         ll_inode2fid(&rec->ul_fid1, inode);
  90         ll_inode2fid(&rec->ul_fid2, child);
  91         rec->ul_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
  92         LOGL0(name, namelen, tmp);
  93 }
  94
  95 void mds_link_pack(struct mds_rec_link *rec,
  96                      struct inode *inode, struct inode *dir,
  97                      const char *name, int namelen)
  98 {
  99         char *tmp = (char *)rec + sizeof(*rec);
 100         rec->lk_reclen = HTON__u32(sizeof(*rec)) + size_round0(namelen);
 101         rec->lk_opcode = HTON__u32(REINT_LINK);
 102
 103         ll_inode2fid(&rec->lk_fid1, inode);
 104         ll_inode2fid(&rec->lk_fid2, dir);
 105         rec->lk_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
 106         LOGL0(name, namelen, tmp);
 107 }
 108
 109 void mds_rename_pack(struct mds_rec_rename *rec, struct inode *srcdir, struct inode *tgtdir, const char *name, int namelen, const char *tgt, int tgtlen)
 110 {
 111         char *tmp = (char *)rec + sizeof(*rec);
 112         /* XXX do something about time, uid, gid */
 113         rec->rn_reclen =
 114                 HTON__u32(sizeof(*rec) + size_round0(namelen) +
 115                           size_round0(tgtlen));
 116         rec->rn_opcode = HTON__u32(REINT_RENAME);
 117
 118         ll_inode2fid(&rec->rn_fid1, srcdir);
 119         ll_inode2fid(&rec->rn_fid2, tgtdir);
 120         rec->rn_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
 121         LOGL0(name, namelen, tmp);
 122         if (tgt) {
 123                 rec->rn_tgtlen = HTON__u32(tgtlen + 1);
 124                 LOGL0(tgt, tgtlen, tmp);
 125         }
 126 }
 127
 128 /* unpacking */
 129
 130 static int mds_update_hdr_unpack(char *buf, int len,
 131                                  struct mds_update_record *r)
 132 {
 133         struct mds_update_record_hdr *hdr = (struct mds_update_record_hdr *)buf;
 134
 135         r->ur_reclen = NTOH__u32(hdr->ur_reclen);
 136         if (len < sizeof(*hdr) || len != r->ur_reclen) {
 137                 CERROR("invalid buffer length\n");
 138                 return -EFAULT;
 139         }
 140         r->ur_opcode = NTOH__u32(hdr->ur_opcode);
 141         return 0;
 142 }
 143
 144 static int mds_setattr_unpack(char *buf, int len, struct mds_update_record *r)
 145 {
 146
 147         struct iattr *attr = &r->ur_iattr;
 148         struct mds_rec_setattr *rec = (struct mds_rec_setattr *)buf;
 149
 150         if (len < sizeof(*rec)) {
 151                 CERROR("invalid buffer length\n");
 152                 return -EFAULT;
 153         }
 154
 155         r->ur_fid1 = &rec->sa_fid;
 156         attr->ia_valid = NTOH__u32(rec->sa_valid);
 157         attr->ia_mode = NTOH__u32(rec->sa_mode);
 158         attr->ia_uid = NTOH__u32(rec->sa_uid);
 159         attr->ia_gid = NTOH__u32(rec->sa_gid);
 160         attr->ia_size = NTOH__u64(rec->sa_size);
 161         attr->ia_atime = NTOH__u64(rec->sa_atime);
 162         attr->ia_mtime = NTOH__u64(rec->sa_mtime);
 163         attr->ia_ctime = NTOH__u64(rec->sa_ctime);
 164         attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
 165         return 0;
 166 }
 167
 168 static int mds_create_unpack(char *buf, int len, struct mds_update_record *r)
 169 {
 170         struct mds_rec_create *rec = (struct mds_rec_create *)buf;
 171         char *ptr, *end;
 172
 173         if (len < sizeof(*rec)) {
 174                 CERROR("invalid buffer length\n");
 175                 return -EFAULT;
 176         }
 177
 178         ptr = (char *)rec + sizeof(*rec);
 179         end = ptr + len - sizeof(*rec);
 180
 181         r->ur_fid1 = &rec->cr_fid;
 182         r->ur_mode = NTOH__u32(rec->cr_mode);
 183         r->ur_id = NTOH__u64(rec->cr_id);
 184         r->ur_uid = NTOH__u32(rec->cr_uid);
 185         r->ur_gid = NTOH__u32(rec->cr_gid);
 186         r->ur_time = NTOH__u64(rec->cr_time);
 187         r->ur_namelen = NTOH__u32(rec->cr_namelen);
 188         r->ur_tgtlen = NTOH__u32(rec->cr_tgtlen);
 189
 190         UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
 191         UNLOGL0(r->ur_tgt, char, r->ur_tgtlen, ptr, end);
 192         return 0;
 193 }
 194
 195 static int mds_link_unpack(char *buf, int len, struct mds_update_record *r)
 196 {
 197         struct mds_rec_link *rec = (struct mds_rec_link *)buf;
 198         char *ptr, *end;
 199
 200         if (len < sizeof(*rec)) {
 201                 CERROR("invalid buffer length\n");
 202                 return -EFAULT;
 203         }
 204
 205         ptr = (char *)rec + sizeof(*rec);
 206         end = ptr + len - sizeof(*rec);
 207
 208         r->ur_fid1 = &rec->lk_fid1;
 209         r->ur_fid2 = &rec->lk_fid2;
 210         r->ur_namelen = NTOH__u32(rec->lk_namelen);
 211         UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
 212         return 0;
 213 }
 214
 215 static int mds_unlink_unpack(char *buf, int len, struct mds_update_record *r)
 216 {
 217         struct mds_rec_unlink *rec = (struct mds_rec_unlink *)buf;
 218         char *ptr, *end;
 219         ENTRY;
 220
 221         if (len < sizeof(*rec)) {
 222                 CERROR("invalid buffer length\n");
 223                 return -EFAULT;
 224         }
 225
 226         ptr = (char *)rec + sizeof(*rec);
 227         end = ptr + len - sizeof(*rec);
 228
 229         r->ur_fid1 = &rec->ul_fid1;
 230         r->ur_fid2 = &rec->ul_fid2;
 231         r->ur_namelen = NTOH__u32(rec->ul_namelen);
 232         UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
 233         EXIT;
 234         return 0;
 235 }
 236
 237 static int mds_rename_unpack(char *buf, int len, struct mds_update_record *r)
 238 {
 239         struct mds_rec_rename *rec = (struct mds_rec_rename *)buf;
 240         char *ptr, *end;
 241
 242         if (len < sizeof(*rec)) {
 243                 CERROR("invalid buffer length\n");
 244                 return -EFAULT;
 245         }
 246
 247         ptr = (char *)rec + sizeof(*rec);
 248         end = ptr + len - sizeof(*rec);
 249
 250         r->ur_fid1 = &rec->rn_fid1;
 251         r->ur_fid2 = &rec->rn_fid2;
 252         r->ur_namelen = NTOH__u32(rec->rn_namelen);
 253         r->ur_tgtlen = NTOH__u32(rec->rn_tgtlen);
 254
 255         UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
 256         UNLOGL0(r->ur_tgt, char, r->ur_tgtlen, ptr, end);
 257         return 0;
 258 }
 259
 260 typedef int (*update_unpacker)(char *, int , struct mds_update_record *);
 261
 262 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 263         [REINT_SETATTR] mds_setattr_unpack,
 264         [REINT_CREATE] mds_create_unpack,
 265         [REINT_LINK] mds_link_unpack,
 266         [REINT_UNLINK] mds_unlink_unpack,
 267         [REINT_RENAME] mds_rename_unpack,
 268 };
 269
 270 int mds_update_unpack(char *buf, int len, struct mds_update_record *r)
 271 {
 272         int rc;
 273         ENTRY;
 274
 275         rc = mds_update_hdr_unpack(buf, len, r);
 276
 277         if (rc) {
 278                 EXIT;
 279                 return -EFAULT;
 280         }
 281
 282         if ( r->ur_opcode<0 || r->ur_opcode > REINT_MAX) {
 283                 EXIT;
 284                 return EFAULT;
 285         }
 286
 287         rc = mds_unpackers[r->ur_opcode](buf, len, r);
 288         EXIT;
 289         return rc;
 290 }