}
                        if (!ret) {
                                ret = ulist_add(parents, eb->start,
-                                               (unsigned long)eie, GFP_NOFS);
+                                               (u64)eie, GFP_NOFS);
                                if (ret < 0)
                                        break;
                                if (!extent_item_pos) {
                                free_extent_buffer(eb);
                        }
                        ret = ulist_add_merge(refs, ref->parent,
-                                             (unsigned long)ref->inode_list,
-                                             (unsigned long *)&eie, GFP_NOFS);
+                                             (u64)ref->inode_list,
+                                             (u64 *)&eie, GFP_NOFS);
                        if (!ret && extent_item_pos) {
                                /*
                                 * we've recorded that parent, so we must extend
                ULIST_ITER_INIT(&root_uiter);
                while (!ret && (root_node = ulist_next(roots, &root_uiter))) {
                        pr_debug("root %llu references leaf %llu, data list "
-                                "%#lx\n", root_node->val, ref_node->val,
+                                "%#llx\n", root_node->val, ref_node->val,
                                 ref_node->aux);
                        ret = iterate_leaf_refs(
                                (struct extent_inode_elem *)ref_node->aux,
 
 
                ulist_reinit(tmp);
                                                /* XXX id not needed */
-               ulist_add(tmp, qg->qgroupid, (unsigned long)qg, GFP_ATOMIC);
+               ulist_add(tmp, qg->qgroupid, (u64)qg, GFP_ATOMIC);
                ULIST_ITER_INIT(&tmp_uiter);
                while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
                        struct btrfs_qgroup_list *glist;
 
                        list_for_each_entry(glist, &qg->groups, next_group) {
                                ulist_add(tmp, glist->group->qgroupid,
-                                         (unsigned long)glist->group,
+                                         (u64)glist->group,
                                          GFP_ATOMIC);
                        }
                }
         * step 2: walk from the new root
         */
        ulist_reinit(tmp);
-       ulist_add(tmp, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+       ulist_add(tmp, qgroup->qgroupid, (u64)qgroup, GFP_ATOMIC);
        ULIST_ITER_INIT(&uiter);
        while ((unode = ulist_next(tmp, &uiter))) {
                struct btrfs_qgroup *qg;
 
                list_for_each_entry(glist, &qg->groups, next_group) {
                        ulist_add(tmp, glist->group->qgroupid,
-                                 (unsigned long)glist->group, GFP_ATOMIC);
+                                 (u64)glist->group, GFP_ATOMIC);
                }
        }
 
                        continue;
 
                ulist_reinit(tmp);
-               ulist_add(tmp, qg->qgroupid, (unsigned long)qg, GFP_ATOMIC);
+               ulist_add(tmp, qg->qgroupid, (u64)qg, GFP_ATOMIC);
                ULIST_ITER_INIT(&tmp_uiter);
                while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
                        struct btrfs_qgroup_list *glist;
 
                        list_for_each_entry(glist, &qg->groups, next_group) {
                                ulist_add(tmp, glist->group->qgroupid,
-                                         (unsigned long)glist->group,
+                                         (u64)glist->group,
                                          GFP_ATOMIC);
                        }
                }
         * be exceeded
         */
        ulist = ulist_alloc(GFP_ATOMIC);
-       ulist_add(ulist, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+       ulist_add(ulist, qgroup->qgroupid, (u64)qgroup, GFP_ATOMIC);
        ULIST_ITER_INIT(&uiter);
        while ((unode = ulist_next(ulist, &uiter))) {
                struct btrfs_qgroup *qg;
 
                list_for_each_entry(glist, &qg->groups, next_group) {
                        ulist_add(ulist, glist->group->qgroupid,
-                                 (unsigned long)glist->group, GFP_ATOMIC);
+                                 (u64)glist->group, GFP_ATOMIC);
                }
        }
        if (ret)
                goto out;
 
        ulist = ulist_alloc(GFP_ATOMIC);
-       ulist_add(ulist, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+       ulist_add(ulist, qgroup->qgroupid, (u64)qgroup, GFP_ATOMIC);
        ULIST_ITER_INIT(&uiter);
        while ((unode = ulist_next(ulist, &uiter))) {
                struct btrfs_qgroup *qg;
 
                list_for_each_entry(glist, &qg->groups, next_group) {
                        ulist_add(ulist, glist->group->qgroupid,
-                                 (unsigned long)glist->group, GFP_ATOMIC);
+                                 (u64)glist->group, GFP_ATOMIC);
                }
        }
 
 
  * In case of allocation failure -ENOMEM is returned and the ulist stays
  * unaltered.
  */
-int ulist_add(struct ulist *ulist, u64 val, unsigned long aux,
-             gfp_t gfp_mask)
+int ulist_add(struct ulist *ulist, u64 val, u64 aux, gfp_t gfp_mask)
 {
        return ulist_add_merge(ulist, val, aux, NULL, gfp_mask);
 }
 
-int ulist_add_merge(struct ulist *ulist, u64 val, unsigned long aux,
-                   unsigned long *old_aux, gfp_t gfp_mask)
+int ulist_add_merge(struct ulist *ulist, u64 val, u64 aux,
+                   u64 *old_aux, gfp_t gfp_mask)
 {
        int i;
 
 
  */
 struct ulist_node {
        u64 val;                /* value to store */
-       unsigned long aux;      /* auxiliary value saved along with the val */
+       u64 aux;                /* auxiliary value saved along with the val */
 };
 
 struct ulist {
 void ulist_reinit(struct ulist *ulist);
 struct ulist *ulist_alloc(gfp_t gfp_mask);
 void ulist_free(struct ulist *ulist);
-int ulist_add(struct ulist *ulist, u64 val, unsigned long aux,
-             gfp_t gfp_mask);
-int ulist_add_merge(struct ulist *ulist, u64 val, unsigned long aux,
-                   unsigned long *old_aux, gfp_t gfp_mask);
+int ulist_add(struct ulist *ulist, u64 val, u64 aux, gfp_t gfp_mask);
+int ulist_add_merge(struct ulist *ulist, u64 val, u64 aux,
+                   u64 *old_aux, gfp_t gfp_mask);
 struct ulist_node *ulist_next(struct ulist *ulist,
                              struct ulist_iterator *uiter);