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, const char *name, int namelen, __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(namelen + 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 = namelen;
  53         LOGL(name, namelen, tmp);
  54         *tmp = '\0';
  55 }
  56
  57
  58 void mds_setattr_pack(struct mds_rec_setattr *rec, struct inode *inode, struct iattr *iattr)
  59 {
  60         rec->sa_reclen = HTON__u32(sizeof(*rec));
  61         rec->sa_opcode = HTON__u32(REINT_SETATTR);
  62
  63         ll_inode2fid(&rec->sa_fid, inode);
  64         rec->sa_valid = HTON__u32(iattr->ia_valid);
  65         rec->sa_mode = HTON__u32(iattr->ia_mode);
  66         rec->sa_uid = HTON__u32(iattr->ia_uid);
  67         rec->sa_gid = HTON__u32(iattr->ia_gid);
  68         rec->sa_size = HTON__u64(iattr->ia_size);
  69         rec->sa_atime = HTON__u64(iattr->ia_atime);
  70         rec->sa_mtime = HTON__u64(iattr->ia_mtime);
  71         rec->sa_ctime = HTON__u64(iattr->ia_ctime);
  72         rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
  73 }
  74
  75 /* unpacking */
  76
  77 static int mds_update_hdr_unpack(char *buf, int len, struct mds_update_record *r)
  78 {
  79         struct mds_update_record_hdr *hdr = (struct mds_update_record_hdr *)buf;
  80
  81         r->ur_reclen = NTOH__u32(hdr->ur_reclen);
  82         if (len < sizeof(*hdr) || len != r->ur_reclen) {
  83                 printk(__FUNCTION__ ": invalid buffer length\n");
  84                 return -EFAULT;
  85         }
  86         r->ur_opcode = NTOH__u32(hdr->ur_opcode);
  87         return 0;
  88 }
  89
  90 static int mds_setattr_unpack(char *buf, int len, struct mds_update_record *r)
  91 {
  92
  93         struct iattr *attr = &r->ur_iattr;
  94         struct mds_rec_setattr *rec = (struct mds_rec_setattr *)buf;
  95
  96         if (len < sizeof(*rec)) {
  97                 printk(__FUNCTION__ "invalid buffer length\n");
  98                 return -EFAULT;
  99         }
 100
 101         r->ur_fid1 = &rec->sa_fid;
 102         attr->ia_valid = NTOH__u32(rec->sa_valid);
 103         attr->ia_mode = NTOH__u32(rec->sa_mode);
 104         attr->ia_uid = NTOH__u32(rec->sa_uid);
 105         attr->ia_gid = NTOH__u32(rec->sa_gid);
 106         attr->ia_size = NTOH__u64(rec->sa_size);
 107         attr->ia_atime = NTOH__u64(rec->sa_atime);
 108         attr->ia_mtime = NTOH__u64(rec->sa_mtime);
 109         attr->ia_ctime = NTOH__u64(rec->sa_ctime);
 110         attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
 111         return 0;
 112 }
 113
 114 static int mds_create_unpack(char *buf, int len, struct mds_update_record *r)
 115 {
 116         struct mds_rec_create *rec = (struct mds_rec_create *)buf;
 117         char *ptr, *end;
 118
 119         if (len < sizeof(*rec)) {
 120                 printk(__FUNCTION__ "invalid buffer length\n");
 121                 return -EFAULT;
 122         }
 123
 124         ptr = (char *)rec + sizeof(*rec);
 125         end = ptr + len - sizeof(*rec);
 126
 127         r->ur_fid1 = &rec->cr_fid;
 128         r->ur_mode = NTOH__u32(rec->cr_mode);
 129         r->ur_id = NTOH__u64(rec->cr_id);
 130         r->ur_uid = NTOH__u32(rec->cr_uid);
 131         r->ur_gid = NTOH__u32(rec->cr_gid);
 132         r->ur_time = NTOH__u64(rec->cr_time);
 133         r->ur_namelen = NTOH__u64(rec->cr_namelen);
 134
 135         UNLOGL(r->ur_name, char, r->ur_namelen, ptr, end);
 136         return 0;
 137 }
 138
 139 typedef int (*update_unpacker)(char *, int , struct mds_update_record *);
 140
 141 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 142         [REINT_SETATTR] mds_setattr_unpack,
 143         [REINT_CREATE] mds_create_unpack
 144 };
 145
 146 int mds_update_unpack(char *buf, int len, struct mds_update_record *r)
 147 {
 148         int rc;
 149         ENTRY;
 150
 151         rc = mds_update_hdr_unpack(buf, len, r);
 152
 153         if (rc) {
 154                 EXIT;
 155                 return -EFAULT;
 156         }
 157
 158         if ( r->ur_opcode<0 || r->ur_opcode > REINT_MAX) {
 159                 EXIT;
 160                 return EFAULT;
 161         }
 162
 163         rc = mds_unpackers[r->ur_opcode](buf, len, r);
 164         EXIT;
 165         return rc;
 166 }