return (size + 7) & ~7;
 }
 
-static inline int lu_dirent_size(struct lu_dirent *ent)
+static inline int lu_dirent_size(const struct lu_dirent *ent)
 {
        if (le16_to_cpu(ent->lde_reclen) == 0) {
                return lu_dirent_calc_size(le16_to_cpu(ent->lde_namelen),
 
 #define DEAD_HANDLE_MAGIC 0xdeadbeefcafebabeULL
 
-static inline int lustre_handle_is_used(struct lustre_handle *lh)
+static inline int lustre_handle_is_used(const struct lustre_handle *lh)
 {
        return lh->cookie != 0ull;
 }
 }
 
 static inline void lustre_handle_copy(struct lustre_handle *tgt,
-                                     struct lustre_handle *src)
+                                     const struct lustre_handle *src)
 {
        tgt->cookie = src->cookie;
 }
        oi->oi.oi_id = oid;
 }
 
-static inline __u64 lmm_oi_id(struct ost_id *oi)
+static inline __u64 lmm_oi_id(const struct ost_id *oi)
 {
        return oi->oi.oi_id;
 }
 
-static inline __u64 lmm_oi_seq(struct ost_id *oi)
+static inline __u64 lmm_oi_seq(const struct ost_id *oi)
 {
        return oi->oi.oi_seq;
 }
 
 static inline void lmm_oi_le_to_cpu(struct ost_id *dst_oi,
-                                   struct ost_id *src_oi)
+                                   const struct ost_id *src_oi)
 {
        dst_oi->oi.oi_id = le64_to_cpu(src_oi->oi.oi_id);
        dst_oi->oi.oi_seq = le64_to_cpu(src_oi->oi.oi_seq);
 }
 
 static inline void lmm_oi_cpu_to_le(struct ost_id *dst_oi,
-                                   struct ost_id *src_oi)
+                                   const struct ost_id *src_oi)
 {
        dst_oi->oi.oi_id = cpu_to_le64(src_oi->oi.oi_id);
        dst_oi->oi.oi_seq = cpu_to_le64(src_oi->oi.oi_seq);
 
 #define LDLM_GID_ANY ((__u64)-1)
 
-static inline int ldlm_extent_overlap(struct ldlm_extent *ex1,
-                                     struct ldlm_extent *ex2)
+static inline int ldlm_extent_overlap(const struct ldlm_extent *ex1,
+                                     const struct ldlm_extent *ex2)
 {
        return (ex1->start <= ex2->end) && (ex2->start <= ex1->end);
 }
 
 /* check if @ex1 contains @ex2 */
-static inline int ldlm_extent_contain(struct ldlm_extent *ex1,
-                                     struct ldlm_extent *ex2)
+static inline int ldlm_extent_contain(const struct ldlm_extent *ex1,
+                                     const struct ldlm_extent *ex2)
 {
        return (ex1->start <= ex2->start) && (ex1->end >= ex2->end);
 }
        ARS_SUCCEED,
 };
 
-static inline char *agent_req_status2name(enum agent_req_status ars)
+static inline const char *agent_req_status2name(const enum agent_req_status ars)
 {
        switch (ars) {
        case ARS_WAITING:
 #define o_cksum   o_nlink
 #define o_grant_used o_data_version
 
-static inline void lustre_set_wire_obdo(struct obd_connect_data *ocd,
+static inline void lustre_set_wire_obdo(const struct obd_connect_data *ocd,
                                        struct obdo *wobdo,
                                        const struct obdo *lobdo)
 {
        }
 }
 
-static inline void lustre_get_wire_obdo(struct obd_connect_data *ocd,
+static inline void lustre_get_wire_obdo(const struct obd_connect_data *ocd,
                                        struct obdo *lobdo,
                                        const struct obdo *wobdo)
 {
 
  *    res will be built from normal FID directly, i.e. res[0] = f_seq,
  *    res[1] = f_oid + f_ver.
  */
-static inline void ostid_build_res_name(struct ost_id *oi,
+static inline void ostid_build_res_name(const struct ost_id *oi,
                                        struct ldlm_res_id *name)
 {
        memset(name, 0, sizeof(*name));
 /**
  * Return true if the resource is for the object identified by this id & group.
  */
-static inline int ostid_res_name_eq(struct ost_id *oi,
-                                   struct ldlm_res_id *name)
+static inline int ostid_res_name_eq(const struct ost_id *oi,
+                                   const struct ldlm_res_id *name)
 {
        /* Note: it is just a trick here to save some effort, probably the
         * correct way would be turn them into the FID and compare
        return ino ? ino : fid_oid(fid);
 }
 
-static inline int lu_fid_diff(struct lu_fid *fid1, struct lu_fid *fid2)
+static inline int lu_fid_diff(const struct lu_fid *fid1,
+                             const struct lu_fid *fid2)
 {
        LASSERTF(fid_seq(fid1) == fid_seq(fid2), "fid1:"DFID", fid2:"DFID"\n",
                 PFID(fid1), PFID(fid2));