seqno_t is u64 and mdsno_t is u32 so just use them as such.
Signed-off-by: Oleg Drokin <green@linuxhacker.ru>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
 
 /* Allocate new sequence for client. */
 static int seq_client_alloc_seq(const struct lu_env *env,
-                               struct lu_client_seq *seq, seqno_t *seqnr)
+                               struct lu_client_seq *seq, u64 *seqnr)
 {
        int rc;
 
  * Allocate the whole seq to the caller.
  **/
 int seq_client_get_seq(const struct lu_env *env,
-                      struct lu_client_seq *seq, seqno_t *seqnr)
+                      struct lu_client_seq *seq, u64 *seqnr)
 {
        wait_queue_t link;
        int rc;
                seq->lcs_fid.f_oid = seq->lcs_width;
 
        while (1) {
-               seqno_t seqnr;
+               u64 seqnr;
 
                if (!fid_is_zero(&seq->lcs_fid) &&
                    fid_oid(&seq->lcs_fid) < seq->lcs_width) {
 
                          struct fld_cache_entry *f_new)
 {
        const struct lu_seq_range *range = &f_new->fce_range;
-       const seqno_t new_start  = range->lsr_start;
-       const seqno_t new_end  = range->lsr_end;
+       const u64 new_start  = range->lsr_start;
+       const u64 new_end  = range->lsr_end;
        struct fld_cache_entry *fldt;
 
        OBD_ALLOC_GFP(fldt, sizeof(*fldt), GFP_ATOMIC);
                                struct fld_cache_entry *f_new)
 {
        const struct lu_seq_range *range = &f_new->fce_range;
-       const seqno_t new_start  = range->lsr_start;
-       const seqno_t new_end  = range->lsr_end;
-       const mdsno_t mdt = range->lsr_index;
+       const u64 new_start  = range->lsr_start;
+       const u64 new_end  = range->lsr_end;
+       const u32 mdt = range->lsr_index;
 
        /* this is overlap case, these case are checking overlapping with
         * prev range only. fixup will handle overlapping with next range. */
        struct fld_cache_entry *n;
        struct list_head *head;
        struct list_head *prev = NULL;
-       const seqno_t new_start  = f_new->fce_range.lsr_start;
-       const seqno_t new_end  = f_new->fce_range.lsr_end;
+       const u64 new_start  = f_new->fce_range.lsr_start;
+       const u64 new_end  = f_new->fce_range.lsr_end;
        __u32 new_flags  = f_new->fce_range.lsr_flags;
 
        /*
  * lookup \a seq sequence for range in fld cache.
  */
 int fld_cache_lookup(struct fld_cache *cache,
-                    const seqno_t seq, struct lu_seq_range *range)
+                    const u64 seq, struct lu_seq_range *range)
 {
        struct fld_cache_entry *flde;
        struct fld_cache_entry *prev = NULL;
 
 void fld_cache_delete_nolock(struct fld_cache *cache,
                             const struct lu_seq_range *range);
 int fld_cache_lookup(struct fld_cache *cache,
-                    const seqno_t seq, struct lu_seq_range *range);
+                    const u64 seq, struct lu_seq_range *range);
 
 struct fld_cache_entry*
 fld_cache_entry_lookup(struct fld_cache *cache, struct lu_seq_range *range);
 
        client_obd_list_unlock(&cli->cl_loi_list_lock);
 }
 
-static int fld_rrb_hash(struct lu_client_fld *fld,
-                       seqno_t seq)
+static int fld_rrb_hash(struct lu_client_fld *fld, u64 seq)
 {
        LASSERT(fld->lcf_count > 0);
        return do_div(seq, fld->lcf_count);
 }
 
 static struct lu_fld_target *
-fld_rrb_scan(struct lu_client_fld *fld, seqno_t seq)
+fld_rrb_scan(struct lu_client_fld *fld, u64 seq)
 {
        struct lu_fld_target *target;
        int hash;
 };
 
 static struct lu_fld_target *
-fld_client_get_target(struct lu_client_fld *fld, seqno_t seq)
+fld_client_get_target(struct lu_client_fld *fld, u64 seq)
 {
        struct lu_fld_target *target;
 
        return rc;
 }
 
-int fld_client_lookup(struct lu_client_fld *fld, seqno_t seq, mdsno_t *mds,
+int fld_client_lookup(struct lu_client_fld *fld, u64 seq, u32 *mds,
                      __u32 flags, const struct lu_env *env)
 {
        struct lu_seq_range res = { 0 };
 
 #define LUSTRE_LOG_VERSION  0x00050000
 #define LUSTRE_MGS_VERSION  0x00060000
 
-typedef __u32 mdsno_t;
-typedef __u64 seqno_t;
 typedef __u64 obd_id;
 typedef __u64 obd_seq;
 typedef __s64 obd_time;
 
 int seq_client_alloc_fid(const struct lu_env *env, struct lu_client_seq *seq,
                         struct lu_fid *fid);
 int seq_client_get_seq(const struct lu_env *env, struct lu_client_seq *seq,
-                      seqno_t *seqnr);
+                      u64 *seqnr);
 int seq_site_fini(const struct lu_env *env, struct seq_server_site *ss);
 /* Fids common stuff */
 int fid_is_local(const struct lu_env *env,
 
 
 void fld_client_flush(struct lu_client_fld *fld);
 
-int fld_client_lookup(struct lu_client_fld *fld, seqno_t seq, mdsno_t *mds,
+int fld_client_lookup(struct lu_client_fld *fld, u64 seq, u32 *mds,
                      __u32 flags, const struct lu_env *env);
 
 int fld_client_create(struct lu_client_fld *fld,
                      struct lu_seq_range *range,
                      const struct lu_env *env);
 
-int fld_client_delete(struct lu_client_fld *fld,
-                     seqno_t seq,
+int fld_client_delete(struct lu_client_fld *fld, u64 seq,
                      const struct lu_env *env);
 
 int fld_client_add_target(struct lu_client_fld *fld,
 
        /**
         * mds number of this site.
         */
-       mdsno_t        ss_node_id;
+       u32                   ss_node_id;
        /**
         * Fid location database
         */
 
        struct lu_fid      op_fid2; /* operation fid2 (usually child) */
        struct lu_fid      op_fid3; /* 2 extra fids to find conflicting */
        struct lu_fid      op_fid4; /* to the operation locks. */
-       mdsno_t          op_mds;  /* what mds server open will go to */
+       u32                     op_mds;  /* what mds server open will go to */
        struct lustre_handle    op_handle;
        obd_time                op_mod_time;
        const char           *op_name;
 
 
 int lmv_fld_lookup(struct lmv_obd *lmv,
                   const struct lu_fid *fid,
-                  mdsno_t *mds)
+                  u32 *mds)
 {
        int rc;
 
 
 
 int lmv_blocking_ast(struct ldlm_lock *, struct ldlm_lock_desc *,
                     void *, int);
-int lmv_fld_lookup(struct lmv_obd *lmv, const struct lu_fid *fid,
-                  mdsno_t *mds);
-int __lmv_fid_alloc(struct lmv_obd *lmv, struct lu_fid *fid,
-                   mdsno_t mds);
+int lmv_fld_lookup(struct lmv_obd *lmv, const struct lu_fid *fid, u32 *mds);
+int __lmv_fid_alloc(struct lmv_obd *lmv, struct lu_fid *fid, u32 mds);
 int lmv_fid_alloc(struct obd_export *exp, struct lu_fid *fid,
                  struct md_op_data *op_data);
 
 }
 
 static inline struct lmv_tgt_desc *
-lmv_get_target(struct lmv_obd *lmv, mdsno_t mds)
+lmv_get_target(struct lmv_obd *lmv, u32 mds)
 {
        int count = lmv->desc.ld_tgt_count;
        int i;
 static inline struct lmv_tgt_desc *
 lmv_find_target(struct lmv_obd *lmv, const struct lu_fid *fid)
 {
-       mdsno_t mds = 0;
+       u32 mds = 0;
        int rc;
 
        if (lmv->desc.ld_tgt_count > 1) {
 
  * This is _inode_ placement policy function (not name).
  */
 static int lmv_placement_policy(struct obd_device *obd,
-                               struct md_op_data *op_data,
-                               mdsno_t *mds)
+                               struct md_op_data *op_data, u32 *mds)
 {
        struct lmv_obd    *lmv = &obd->u.lmv;
 
        return 0;
 }
 
-int __lmv_fid_alloc(struct lmv_obd *lmv, struct lu_fid *fid,
-                   mdsno_t mds)
+int __lmv_fid_alloc(struct lmv_obd *lmv, struct lu_fid *fid, u32 mds)
 {
        struct lmv_tgt_desc     *tgt;
        int                      rc;
 {
        struct obd_device     *obd = class_exp2obd(exp);
        struct lmv_obd  *lmv = &obd->u.lmv;
-       mdsno_t         mds = 0;
+       u32                    mds = 0;
        int                 rc;
 
        LASSERT(op_data != NULL);