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/vmalloc.h>
  28 #include <linux/slab.h>
  29 #include <asm/segment.h>
  30
  31 #include <linux/obd_support.h>
  32 #include <linux/lustre_lib.h>
  33 #include <linux/lustre_idl.h>
  34 #include <linux/lustre_light.h>
  35
  36 /* packing of MDS records */
  37
  38 void mds_create_pack(struct mds_rec_create *rec, struct inode *inode, char *name, __u32 mode, __u64 id, __u32 uid, __u32 gid, __u64 time)
  39 {
  40         char *tmp = (char *)rec + sizeof(*rec);
  41         /* XXX do something about time, uid, gid */
  42         rec->cr_reclen =
  43                 HTON__u32(sizeof(*rec)) + size_round(strlen(name) + 1);
  44         rec->cr_opcode = HTON__u32(REINT_CREATE);
  45
  46         ll_inode2fid(&rec->cr_fid, inode);
  47         rec->cr_mode = HTON__u32(mode);
  48         rec->cr_id = HTON__u64(id);
  49         rec->cr_uid = HTON__u32(uid);
  50         rec->cr_gid = HTON__u32(gid);
  51         rec->cr_time = HTON__u64(time);
  52         rec->cr_namelen = strlen(name);
  53         LOGL(name, rec->cr_namelen + 1, tmp);
  54 }
  55
  56
  57 void mds_setattr_pack(struct mds_rec_setattr *rec, struct inode *inode, struct iattr *iattr)
  58 {
  59         rec->sa_reclen = HTON__u32(sizeof(*rec));
  60         rec->sa_opcode = HTON__u32(REINT_SETATTR);
  61
  62         ll_inode2fid(&rec->sa_fid, inode);
  63         rec->sa_valid = HTON__u32(iattr->ia_valid);
  64         rec->sa_mode = HTON__u32(iattr->ia_mode);
  65         rec->sa_uid = HTON__u32(iattr->ia_uid);
  66         rec->sa_gid = HTON__u32(iattr->ia_gid);
  67         rec->sa_size = HTON__u64(iattr->ia_size);
  68         rec->sa_atime = HTON__u64(iattr->ia_atime);
  69         rec->sa_mtime = HTON__u64(iattr->ia_mtime);
  70         rec->sa_ctime = HTON__u64(iattr->ia_ctime);
  71         rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
  72 }
  73
  74 /* unpacking */
  75
  76 static int mds_update_hdr_unpack(char *buf, int len, struct mds_update_record *r)
  77 {
  78         struct mds_update_record_hdr *hdr = (struct mds_update_record_hdr *)buf;
  79
  80         r->ur_reclen = NTOH__u32(hdr->ur_reclen);
  81         if (len < sizeof(*hdr) || len != r->ur_reclen) {
  82                 printk(__FUNCTION__ "invalid buffer length\n");
  83                 return -EFAULT;
  84         }
  85         r->ur_opcode = NTOH__u32(hdr->ur_opcode);
  86         return 0;
  87 }
  88
  89 static int mds_setattr_unpack(char *buf, int len, struct mds_update_record *r)
  90 {
  91
  92         struct iattr *attr = &r->ur_iattr;
  93         struct mds_rec_setattr *rec = (struct mds_rec_setattr *)buf;
  94
  95         if (len < sizeof(*rec)) {
  96                 printk(__FUNCTION__ "invalid buffer length\n");
  97                 return -EFAULT;
  98         }
  99
 100         r->ur_fid1 = &rec->sa_fid;
 101         attr->ia_valid = NTOH__u32(rec->sa_valid);
 102         attr->ia_mode = NTOH__u32(rec->sa_mode);
 103         attr->ia_uid = NTOH__u32(rec->sa_uid);
 104         attr->ia_gid = NTOH__u32(rec->sa_gid);
 105         attr->ia_size = NTOH__u64(rec->sa_size);
 106         attr->ia_atime = NTOH__u64(rec->sa_atime);
 107         attr->ia_mtime = NTOH__u64(rec->sa_mtime);
 108         attr->ia_ctime = NTOH__u64(rec->sa_ctime);
 109         attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
 110         return 0;
 111 }
 112
 113 static int mds_create_unpack(char *buf, int len, struct mds_update_record *r)
 114 {
 115         struct mds_rec_create *rec = (struct mds_rec_create *)buf;
 116         char *ptr, *end;
 117
 118         if (len < sizeof(*rec)) {
 119                 printk(__FUNCTION__ "invalid buffer length\n");
 120                 return -EFAULT;
 121         }
 122
 123         ptr = (char *)rec + sizeof(*rec);
 124         end = ptr + len - sizeof(*rec);
 125
 126         r->ur_fid1 = &rec->cr_fid;
 127         r->ur_mode = NTOH__u32(rec->cr_mode);
 128         r->ur_id = NTOH__u64(rec->cr_id);
 129         r->ur_uid = NTOH__u32(rec->cr_uid);
 130         r->ur_gid = NTOH__u32(rec->cr_gid);
 131         r->ur_time = NTOH__u64(rec->cr_time);
 132         r->ur_namelen = NTOH__u64(rec->cr_namelen);
 133
 134         UNLOGL(r->ur_name, char, r->ur_namelen, ptr, end);
 135         return 0;
 136 }
 137
 138 typedef int (*update_unpacker)(char *, int , struct mds_update_record *);
 139
 140 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 141         [REINT_SETATTR] mds_setattr_unpack,
 142         [REINT_CREATE] mds_create_unpack
 143 };
 144
 145 int mds_update_unpack(char *buf, int len, struct mds_update_record *r)
 146 {
 147         int rc;
 148         ENTRY;
 149
 150         rc = mds_update_hdr_unpack(buf, len, r);
 151
 152         if (rc) {
 153                 EXIT;
 154                 return -EFAULT;
 155         }
 156
 157         if ( r->ur_opcode<0 || r->ur_opcode > REINT_MAX) {
 158                 EXIT;
 159                 return EFAULT;
 160         }
 161
 162         rc = mds_unpackers[r->ur_opcode](buf, len, r);
 163         EXIT;
 164         return rc;
 165 }