{
        struct zram *zram = dev_to_zram(dev);
 
-       return sprintf(buf, "%u\n", atomic_read(&zram->stats.pages_zero));
+       return sprintf(buf, "%llu\n", (u64)atomic64_read(&zram->stats.zero_pages));
 }
 
 static ssize_t orig_data_size_show(struct device *dev,
        struct zram *zram = dev_to_zram(dev);
 
        return sprintf(buf, "%llu\n",
-               (u64)(atomic_read(&zram->stats.pages_stored)) << PAGE_SHIFT);
+               (u64)(atomic64_read(&zram->stats.pages_stored)) << PAGE_SHIFT);
 }
 
 static ssize_t compr_data_size_show(struct device *dev,
        struct zram *zram = dev_to_zram(dev);
 
        return sprintf(buf, "%llu\n",
-                       (u64)atomic64_read(&zram->stats.compr_size));
+                       (u64)atomic64_read(&zram->stats.compr_data_size));
 }
 
 static ssize_t mem_used_total_show(struct device *dev,
                 */
                if (zram_test_flag(meta, index, ZRAM_ZERO)) {
                        zram_clear_flag(meta, index, ZRAM_ZERO);
-                       atomic_dec(&zram->stats.pages_zero);
+                       atomic64_dec(&zram->stats.zero_pages);
                }
                return;
        }
 
        zs_free(meta->mem_pool, handle);
 
-       atomic64_sub(meta->table[index].size, &zram->stats.compr_size);
-       atomic_dec(&zram->stats.pages_stored);
+       atomic64_sub(meta->table[index].size, &zram->stats.compr_data_size);
+       atomic64_dec(&zram->stats.pages_stored);
 
        meta->table[index].handle = 0;
        meta->table[index].size = 0;
                zram_set_flag(meta, index, ZRAM_ZERO);
                write_unlock(&zram->meta->tb_lock);
 
-               atomic_inc(&zram->stats.pages_zero);
+               atomic64_inc(&zram->stats.zero_pages);
                ret = 0;
                goto out;
        }
        write_unlock(&zram->meta->tb_lock);
 
        /* Update stats */
-       atomic64_add(clen, &zram->stats.compr_size);
-       atomic_inc(&zram->stats.pages_stored);
+       atomic64_add(clen, &zram->stats.compr_data_size);
+       atomic64_inc(&zram->stats.pages_stored);
 out:
        if (locked)
                mutex_unlock(&meta->buffer_lock);
 
 } __aligned(4);
 
 struct zram_stats {
-       atomic64_t compr_size;  /* compressed size of pages stored */
+       atomic64_t compr_data_size;     /* compressed size of pages stored */
        atomic64_t num_reads;   /* failed + successful */
        atomic64_t num_writes;  /* --do-- */
        atomic64_t failed_reads;        /* should NEVER! happen */
        atomic64_t failed_writes;       /* can happen when memory is too low */
        atomic64_t invalid_io;  /* non-page-aligned I/O requests */
        atomic64_t notify_free; /* no. of swap slot free notifications */
-       atomic_t pages_zero;            /* no. of zero filled pages */
-       atomic_t pages_stored;  /* no. of pages currently stored */
+       atomic64_t zero_pages;          /* no. of zero filled pages */
+       atomic64_t pages_stored;        /* no. of pages currently stored */
 };
 
 struct zram_meta {