lustre/obdclass/md_attrs.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 021110-1307, USA
  20  *
  21  * GPL HEADER END
  22  */
  23 /*
  24  * Copyright (c) 2012, 2017, Intel Corporation.
  25  * Use is subject to license terms.
  26  *
  27  * Author: Johann Lombardi <johann.lombardi@intel.com>
  28  */
  29 #include <llog_swab.h>
  30 #include <lustre_swab.h>
  31 #include <obd.h>
  32 #include <md_object.h>
  33
  34 /**
  35  * Initialize new \a lma. Only fid is stored.
  36  *
  37  * \param lma - is the new LMA structure to be initialized
  38  * \param fid - is the FID of the object this LMA belongs to
  39  * \param incompat - features that MDS must understand to access object
  40  */
  41 void lustre_lma_init(struct lustre_mdt_attrs *lma, const struct lu_fid *fid,
  42                      __u32 compat, __u32 incompat)
  43 {
  44         lma->lma_compat   = compat;
  45         lma->lma_incompat = incompat;
  46         lma->lma_self_fid = *fid;
  47
  48         /* If a field is added in struct lustre_mdt_attrs, zero it explicitly
  49          * and change the test below. */
  50         CLASSERT(sizeof(*lma) ==
  51                  (offsetof(struct lustre_mdt_attrs, lma_self_fid) +
  52                   sizeof(lma->lma_self_fid)));
  53 }
  54 EXPORT_SYMBOL(lustre_lma_init);
  55
  56 /**
  57  * Swab, if needed, LMA structure which is stored on-disk in little-endian order.
  58  *
  59  * \param lma - is a pointer to the LMA structure to be swabbed.
  60  */
  61 void lustre_lma_swab(struct lustre_mdt_attrs *lma)
  62 {
  63 #ifdef __BIG_ENDIAN
  64         __swab32s(&lma->lma_compat);
  65         __swab32s(&lma->lma_incompat);
  66         lustre_swab_lu_fid(&lma->lma_self_fid);
  67 #endif
  68 }
  69 EXPORT_SYMBOL(lustre_lma_swab);
  70
  71 void lustre_loa_init(struct lustre_ost_attrs *loa, const struct lu_fid *fid,
  72                      __u32 compat, __u32 incompat)
  73 {
  74         CLASSERT(sizeof(*loa) == LMA_OLD_SIZE);
  75
  76         memset(&loa->loa_parent_fid, 0,
  77                sizeof(*loa) - offsetof(typeof(*loa), loa_parent_fid));
  78         lustre_lma_init(&loa->loa_lma, fid, compat, incompat);
  79 }
  80 EXPORT_SYMBOL(lustre_loa_init);
  81
  82 /**
  83  * Swab, if needed, LOA (for OST-object only) structure with LMA EA and PFID EA
  84  * combined together are stored on-disk in little-endian order.
  85  *
  86  * \param[in] loa       - the pointer to the LOA structure to be swabbed.
  87  * \param[in] to_cpu    - to indicate swab for CPU order or not.
  88  */
  89 void lustre_loa_swab(struct lustre_ost_attrs *loa, bool to_cpu)
  90 {
  91         struct lustre_mdt_attrs *lma = &loa->loa_lma;
  92 #ifdef __BIG_ENDIAN
  93         __u32 compat = lma->lma_compat;
  94 #endif
  95
  96         lustre_lma_swab(lma);
  97 #ifdef __BIG_ENDIAN
  98         if (to_cpu)
  99                 compat = lma->lma_compat;
 100
 101         if (compat & LMAC_STRIPE_INFO) {
 102                 lustre_swab_lu_fid(&loa->loa_parent_fid);
 103                 __swab32s(&loa->loa_stripe_size);
 104         }
 105         if (compat & LMAC_COMP_INFO) {
 106                 __swab32s(&loa->loa_comp_id);
 107                 __swab64s(&loa->loa_comp_start);
 108                 __swab64s(&loa->loa_comp_end);
 109         }
 110 #endif
 111 }
 112 EXPORT_SYMBOL(lustre_loa_swab);
 113
 114 /**
 115  * Swab, if needed, SOM structure which is stored on-disk in little-endian
 116  * order.
 117  *
 118  * \param attrs - is a pointer to the SOM structure to be swabbed.
 119  */
 120 void lustre_som_swab(struct lustre_som_attrs *attrs)
 121 {
 122 #ifdef __BIG_ENDIAN
 123         __swab16s(&attrs->lsa_valid);
 124         __swab64s(&attrs->lsa_size);
 125         __swab64s(&attrs->lsa_blocks);
 126 #endif
 127 }
 128 EXPORT_SYMBOL(lustre_som_swab);
 129
 130 /**
 131  * Swab, if needed, HSM structure which is stored on-disk in little-endian
 132  * order.
 133  *
 134  * \param attrs - is a pointer to the HSM structure to be swabbed.
 135  */
 136 void lustre_hsm_swab(struct hsm_attrs *attrs)
 137 {
 138 #ifdef __BIG_ENDIAN
 139         __swab32s(&attrs->hsm_compat);
 140         __swab32s(&attrs->hsm_flags);
 141         __swab64s(&attrs->hsm_arch_id);
 142         __swab64s(&attrs->hsm_arch_ver);
 143 #endif
 144 }
 145
 146 /*
 147  * Swab and extract HSM attributes from on-disk xattr.
 148  *
 149  * \param buf - is a buffer containing the on-disk HSM extended attribute.
 150  * \param rc  - is the HSM xattr stored in \a buf
 151  * \param mh  - is the md_hsm structure where to extract HSM attributes.
 152  */
 153 int lustre_buf2hsm(void *buf, int rc, struct md_hsm *mh)
 154 {
 155         struct hsm_attrs *attrs = (struct hsm_attrs *)buf;
 156         ENTRY;
 157
 158         if (rc == 0 ||  rc == -ENODATA)
 159                 /* no HSM attributes */
 160                 RETURN(-ENODATA);
 161
 162         if (rc < 0)
 163                 /* error hit while fetching xattr */
 164                 RETURN(rc);
 165
 166         /* unpack HSM attributes */
 167         lustre_hsm_swab(attrs);
 168
 169         /* fill md_hsm structure */
 170         mh->mh_compat   = attrs->hsm_compat;
 171         mh->mh_flags    = attrs->hsm_flags;
 172         mh->mh_arch_id  = attrs->hsm_arch_id;
 173         mh->mh_arch_ver = attrs->hsm_arch_ver;
 174
 175         RETURN(0);
 176 }
 177 EXPORT_SYMBOL(lustre_buf2hsm);
 178
 179 /*
 180  * Pack HSM attributes.
 181  *
 182  * \param buf - is the output buffer where to pack the on-disk HSM xattr.
 183  * \param mh  - is the md_hsm structure to pack.
 184  */
 185 void lustre_hsm2buf(void *buf, const struct md_hsm *mh)
 186 {
 187         struct hsm_attrs *attrs = (struct hsm_attrs *)buf;
 188         ENTRY;
 189
 190         /* copy HSM attributes */
 191         attrs->hsm_compat   = mh->mh_compat;
 192         attrs->hsm_flags    = mh->mh_flags;
 193         attrs->hsm_arch_id  = mh->mh_arch_id;
 194         attrs->hsm_arch_ver = mh->mh_arch_ver;
 195
 196         /* pack xattr */
 197         lustre_hsm_swab(attrs);
 198 }
 199 EXPORT_SYMBOL(lustre_hsm2buf);