nilfs2: avoid bare use of 'unsigned'

This fixes checkpatch.pl warning "WARNING: Prefer 'unsigned int' to
bare use of 'unsigned'".

Link: http://lkml.kernel.org/r/1462886671-3521-5-git-send-email-konishi.ryusuke@lab.ntt.co.jp
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/fs/nilfs2/alloc.c b/fs/nilfs2/alloc.c
index bdd5ac522904aa32677c40360f7f5c6743b45fe3..698f582d69afa28360aad32584e3fe87a03de2d5 100644 (file)
--- a/fs/nilfs2/alloc.c
+++ b/fs/nilfs2/alloc.c
@@ -53,7 +53,7 @@ nilfs_palloc_groups_count(const struct inode *inode)
  * @inode: inode of metadata file using this allocator
  * @entry_size: size of the persistent object
  */
-int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned entry_size)
+int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned int entry_size)
 {
        struct nilfs_mdt_info *mi = NILFS_MDT(inode);
 
@@ -384,7 +384,7 @@ void *nilfs_palloc_block_get_entry(const struct inode *inode, __u64 nr,
  */
 static int nilfs_palloc_find_available_slot(unsigned char *bitmap,
                                            unsigned long target,
-                                           unsigned bsize,
+                                           unsigned int bsize,
                                            spinlock_t *lock)
 {
        int pos, end = bsize;
@@ -735,8 +735,8 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
        unsigned long group, group_offset;
        __u64 group_min_nr, last_nrs[8];
        const unsigned long epg = nilfs_palloc_entries_per_group(inode);
-       const unsigned epb = NILFS_MDT(inode)->mi_entries_per_block;
-       unsigned entry_start, end, pos;
+       const unsigned int epb = NILFS_MDT(inode)->mi_entries_per_block;
+       unsigned int entry_start, end, pos;
        spinlock_t *lock;
        int i, j, k, ret;
        u32 nfree;

diff --git a/fs/nilfs2/alloc.h b/fs/nilfs2/alloc.h
index 2bd567d98bc66edab94ab1ab3f961a24a4cf6ffa..05149e606a78a8dfd8f4a701863eccddb0e4979e 100644 (file)
--- a/fs/nilfs2/alloc.h
+++ b/fs/nilfs2/alloc.h
@@ -37,7 +37,7 @@ nilfs_palloc_entries_per_group(const struct inode *inode)
        return 1UL << (inode->i_blkbits + 3 /* log2(8 = CHAR_BITS) */);
 }
 
-int nilfs_palloc_init_blockgroup(struct inode *, unsigned);
+int nilfs_palloc_init_blockgroup(struct inode *, unsigned int);
 int nilfs_palloc_get_entry_block(struct inode *, __u64, int,
                                 struct buffer_head **);
 void *nilfs_palloc_block_get_entry(const struct inode *, __u64,

diff --git a/fs/nilfs2/bmap.c b/fs/nilfs2/bmap.c
index 4976fe3be4a5a3a9063801a0fa13a180014c50d6..f2a7877e0c8c98a0b830d04495a9f8dcf156f79f 100644 (file)
--- a/fs/nilfs2/bmap.c
+++ b/fs/nilfs2/bmap.c
@@ -93,7 +93,7 @@ int nilfs_bmap_lookup_at_level(struct nilfs_bmap *bmap, __u64 key, int level,
 }
 
 int nilfs_bmap_lookup_contig(struct nilfs_bmap *bmap, __u64 key, __u64 *ptrp,
-                            unsigned maxblocks)
+                            unsigned int maxblocks)
 {
        int ret;
 

diff --git a/fs/nilfs2/bmap.h b/fs/nilfs2/bmap.h
index c14f822682daee0a8899c9ac950f5010c34a38fa..a6852807b22c73d017efe4f4d9c89a28a8c8acc9 100644 (file)
--- a/fs/nilfs2/bmap.h
+++ b/fs/nilfs2/bmap.h
@@ -57,7 +57,7 @@ struct nilfs_bmap_stats {
 struct nilfs_bmap_operations {
        int (*bop_lookup)(const struct nilfs_bmap *, __u64, int, __u64 *);
        int (*bop_lookup_contig)(const struct nilfs_bmap *, __u64, __u64 *,
-                                unsigned);
+                                unsigned int);
        int (*bop_insert)(struct nilfs_bmap *, __u64, __u64);
        int (*bop_delete)(struct nilfs_bmap *, __u64);
        void (*bop_clear)(struct nilfs_bmap *);
@@ -150,7 +150,7 @@ struct nilfs_bmap_store {
 int nilfs_bmap_test_and_clear_dirty(struct nilfs_bmap *);
 int nilfs_bmap_read(struct nilfs_bmap *, struct nilfs_inode *);
 void nilfs_bmap_write(struct nilfs_bmap *, struct nilfs_inode *);
-int nilfs_bmap_lookup_contig(struct nilfs_bmap *, __u64, __u64 *, unsigned);
+int nilfs_bmap_lookup_contig(struct nilfs_bmap *, __u64, __u64 *, unsigned int);
 int nilfs_bmap_insert(struct nilfs_bmap *bmap, __u64 key, unsigned long rec);
 int nilfs_bmap_delete(struct nilfs_bmap *bmap, __u64 key);
 int nilfs_bmap_seek_key(struct nilfs_bmap *bmap, __u64 start, __u64 *keyp);

diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c
index 8fc73d0a923ca4816208dfb9dc36ec1036ae5545..57ec6af28b4985e9383450f228aaa45234ca29bd 100644 (file)
--- a/fs/nilfs2/btree.c
+++ b/fs/nilfs2/btree.c
@@ -685,7 +685,8 @@ static int nilfs_btree_lookup(const struct nilfs_bmap *btree,
 }
 
 static int nilfs_btree_lookup_contig(const struct nilfs_bmap *btree,
-                                    __u64 key, __u64 *ptrp, unsigned maxblocks)
+                                    __u64 key, __u64 *ptrp,
+                                    unsigned int maxblocks)
 {
        struct nilfs_btree_path *path;
        struct nilfs_btree_node *node;

diff --git a/fs/nilfs2/cpfile.c b/fs/nilfs2/cpfile.c
index 16f884bd857c2d2cc203220658e85f8356cabf3e..b61c3e0eb342c6ff7ed846240b4571094433f2c9 100644 (file)
--- a/fs/nilfs2/cpfile.c
+++ b/fs/nilfs2/cpfile.c
@@ -431,7 +431,8 @@ static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode *cpfile,
 }
 
 static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop,
-                                         void *buf, unsigned cisz, size_t nci)
+                                         void *buf, unsigned int cisz,
+                                         size_t nci)
 {
        struct nilfs_checkpoint *cp;
        struct nilfs_cpinfo *ci = buf;
@@ -482,7 +483,8 @@ static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop,
 }
 
 static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
-                                         void *buf, unsigned cisz, size_t nci)
+                                         void *buf, unsigned int cisz,
+                                         size_t nci)
 {
        struct buffer_head *bh;
        struct nilfs_cpfile_header *header;
@@ -568,7 +570,7 @@ static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
  */
 
 ssize_t nilfs_cpfile_get_cpinfo(struct inode *cpfile, __u64 *cnop, int mode,
-                               void *buf, unsigned cisz, size_t nci)
+                               void *buf, unsigned int cisz, size_t nci)
 {
        switch (mode) {
        case NILFS_CHECKPOINT:

diff --git a/fs/nilfs2/cpfile.h b/fs/nilfs2/cpfile.h
index 5bdb8262928b4f598796af8657e7d01e7ef5bb16..0249744ae2344c6acfd0c839eebbc0972fa170b3 100644 (file)
--- a/fs/nilfs2/cpfile.h
+++ b/fs/nilfs2/cpfile.h
@@ -33,8 +33,8 @@ int nilfs_cpfile_delete_checkpoint(struct inode *, __u64);
 int nilfs_cpfile_change_cpmode(struct inode *, __u64, int);
 int nilfs_cpfile_is_snapshot(struct inode *, __u64);
 int nilfs_cpfile_get_stat(struct inode *, struct nilfs_cpstat *);
-ssize_t nilfs_cpfile_get_cpinfo(struct inode *, __u64 *, int, void *, unsigned,
-                               size_t);
+ssize_t nilfs_cpfile_get_cpinfo(struct inode *, __u64 *, int, void *,
+                               unsigned int, size_t);
 
 int nilfs_cpfile_read(struct super_block *sb, size_t cpsize,
                      struct nilfs_inode *raw_inode, struct inode **inodep);

diff --git a/fs/nilfs2/dat.c b/fs/nilfs2/dat.c
index e92257bc42eea5f6da7ff26ad7dcd7d1cdb13d1f..7367610ea8079d38badb619845f2cf5d19bcf95f 100644 (file)
--- a/fs/nilfs2/dat.c
+++ b/fs/nilfs2/dat.c
@@ -424,7 +424,7 @@ int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
        return ret;
 }
 
-ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz,
+ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned int visz,
                            size_t nvi)
 {
        struct buffer_head *entry_bh;

diff --git a/fs/nilfs2/dat.h b/fs/nilfs2/dat.h
index c7035b5b1aeda30c336bcadf128300988a9fa954..abbfdabcabea193307e66bcb48cca471b80486ba 100644 (file)
--- a/fs/nilfs2/dat.h
+++ b/fs/nilfs2/dat.h
@@ -47,7 +47,7 @@ void nilfs_dat_abort_update(struct inode *, struct nilfs_palloc_req *,
 int nilfs_dat_mark_dirty(struct inode *, __u64);
 int nilfs_dat_freev(struct inode *, __u64 *, size_t);
 int nilfs_dat_move(struct inode *, __u64, sector_t);
-ssize_t nilfs_dat_get_vinfo(struct inode *, void *, unsigned, size_t);
+ssize_t nilfs_dat_get_vinfo(struct inode *, void *, unsigned int, size_t);
 
 int nilfs_dat_read(struct super_block *sb, size_t entry_size,
                   struct nilfs_inode *raw_inode, struct inode **inodep);

diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index bbcc03de1e74e438385c0110f8baf10595624243..e506f4f7120a4272587e3231f327d7277b6a2ffa 100644 (file)
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -46,7 +46,7 @@
  * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
  * more robust, but we have what we have
  */
-static inline unsigned nilfs_chunk_size(struct inode *inode)
+static inline unsigned int nilfs_chunk_size(struct inode *inode)
 {
        return inode->i_sb->s_blocksize;
 }
@@ -61,9 +61,9 @@ static inline void nilfs_put_page(struct page *page)
  * Return the offset into page `page_nr' of the last valid
  * byte in that page, plus one.
  */
-static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr)
+static unsigned int nilfs_last_byte(struct inode *inode, unsigned long page_nr)
 {
-       unsigned last_byte = inode->i_size;
+       unsigned int last_byte = inode->i_size;
 
        last_byte -= page_nr << PAGE_SHIFT;
        if (last_byte > PAGE_SIZE)
@@ -71,7 +71,8 @@ static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr)
        return last_byte;
 }
 
-static int nilfs_prepare_chunk(struct page *page, unsigned from, unsigned to)
+static int nilfs_prepare_chunk(struct page *page, unsigned int from,
+                              unsigned int to)
 {
        loff_t pos = page_offset(page) + from;
 
@@ -80,12 +81,12 @@ static int nilfs_prepare_chunk(struct page *page, unsigned from, unsigned to)
 
 static void nilfs_commit_chunk(struct page *page,
                               struct address_space *mapping,
-                              unsigned from, unsigned to)
+                              unsigned int from, unsigned int to)
 {
        struct inode *dir = mapping->host;
        loff_t pos = page_offset(page) + from;
-       unsigned len = to - from;
-       unsigned nr_dirty, copied;
+       unsigned int len = to - from;
+       unsigned int nr_dirty, copied;
        int err;
 
        nr_dirty = nilfs_page_count_clean_buffers(page, from, to);
@@ -103,10 +104,10 @@ static bool nilfs_check_page(struct page *page)
 {
        struct inode *dir = page->mapping->host;
        struct super_block *sb = dir->i_sb;
-       unsigned chunk_size = nilfs_chunk_size(dir);
+       unsigned int chunk_size = nilfs_chunk_size(dir);
        char *kaddr = page_address(page);
-       unsigned offs, rec_len;
-       unsigned limit = PAGE_SIZE;
+       unsigned int offs, rec_len;
+       unsigned int limit = PAGE_SIZE;
        struct nilfs_dir_entry *p;
        char *error;
 
@@ -256,7 +257,6 @@ static int nilfs_readdir(struct file *file, struct dir_context *ctx)
        unsigned int offset = pos & ~PAGE_MASK;
        unsigned long n = pos >> PAGE_SHIFT;
        unsigned long npages = dir_pages(inode);
-/*     unsigned chunk_mask = ~(nilfs_chunk_size(inode)-1); */
 
        if (pos > inode->i_size - NILFS_DIR_REC_LEN(1))
                return 0;
@@ -318,7 +318,7 @@ nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
 {
        const unsigned char *name = qstr->name;
        int namelen = qstr->len;
-       unsigned reclen = NILFS_DIR_REC_LEN(namelen);
+       unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
        unsigned long start, n;
        unsigned long npages = dir_pages(dir);
        struct page *page = NULL;
@@ -408,8 +408,8 @@ ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr)
 void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
                    struct page *page, struct inode *inode)
 {
-       unsigned from = (char *) de - (char *) page_address(page);
-       unsigned to = from + nilfs_rec_len_from_disk(de->rec_len);
+       unsigned int from = (char *)de - (char *)page_address(page);
+       unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len);
        struct address_space *mapping = page->mapping;
        int err;
 
@@ -431,15 +431,15 @@ int nilfs_add_link(struct dentry *dentry, struct inode *inode)
        struct inode *dir = d_inode(dentry->d_parent);
        const unsigned char *name = dentry->d_name.name;
        int namelen = dentry->d_name.len;
-       unsigned chunk_size = nilfs_chunk_size(dir);
-       unsigned reclen = NILFS_DIR_REC_LEN(namelen);
+       unsigned int chunk_size = nilfs_chunk_size(dir);
+       unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
        unsigned short rec_len, name_len;
        struct page *page = NULL;
        struct nilfs_dir_entry *de;
        unsigned long npages = dir_pages(dir);
        unsigned long n;
        char *kaddr;
-       unsigned from, to;
+       unsigned int from, to;
        int err;
 
        /*
@@ -531,13 +531,14 @@ int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
        struct address_space *mapping = page->mapping;
        struct inode *inode = mapping->host;
        char *kaddr = page_address(page);
-       unsigned from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
-       unsigned to = ((char *)dir - kaddr) +
-               nilfs_rec_len_from_disk(dir->rec_len);
-       struct nilfs_dir_entry *pde = NULL;
-       struct nilfs_dir_entry *de = (struct nilfs_dir_entry *)(kaddr + from);
+       unsigned int from, to;
+       struct nilfs_dir_entry *de, *pde = NULL;
        int err;
 
+       from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
+       to = ((char *)dir - kaddr) + nilfs_rec_len_from_disk(dir->rec_len);
+       de = (struct nilfs_dir_entry *)(kaddr + from);
+
        while ((char *)de < (char *)dir) {
                if (de->rec_len == 0) {
                        nilfs_error(inode->i_sb, __func__,
@@ -570,7 +571,7 @@ int nilfs_make_empty(struct inode *inode, struct inode *parent)
 {
        struct address_space *mapping = inode->i_mapping;
        struct page *page = grab_cache_page(mapping, 0);
-       unsigned chunk_size = nilfs_chunk_size(inode);
+       unsigned int chunk_size = nilfs_chunk_size(inode);
        struct nilfs_dir_entry *de;
        int err;
        void *kaddr;

diff --git a/fs/nilfs2/direct.c b/fs/nilfs2/direct.c
index 22058d0b36e921160efdb6f61970c036c3d54696..00106863006364ae06aca5b7d2631e08d1146f1b 100644 (file)
--- a/fs/nilfs2/direct.c
+++ b/fs/nilfs2/direct.c
@@ -58,7 +58,7 @@ static int nilfs_direct_lookup(const struct nilfs_bmap *direct,
 
 static int nilfs_direct_lookup_contig(const struct nilfs_bmap *direct,
                                      __u64 key, __u64 *ptrp,
-                                     unsigned maxblocks)
+                                     unsigned int maxblocks)
 {
        struct inode *dat = NULL;
        __u64 ptr, ptr2;
@@ -79,7 +79,8 @@ static int nilfs_direct_lookup_contig(const struct nilfs_bmap *direct,
                ptr = blocknr;
        }
 
-       maxblocks = min_t(unsigned, maxblocks, NILFS_DIRECT_KEY_MAX - key + 1);
+       maxblocks = min_t(unsigned int, maxblocks,
+                         NILFS_DIRECT_KEY_MAX - key + 1);
        for (cnt = 1; cnt < maxblocks &&
                     (ptr2 = nilfs_direct_get_ptr(direct, key + cnt)) !=
                     NILFS_BMAP_INVALID_PTR;

diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index bbb47e8bde3e01ecf8b0e6d535861a50a36c9ee1..83d2c485efba17ca637707a0003dd4f1764248cf 100644 (file)
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -83,7 +83,7 @@ int nilfs_get_block(struct inode *inode, sector_t blkoff,
        struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
        __u64 blknum = 0;
        int err = 0, ret;
-       unsigned maxblocks = bh_result->b_size >> inode->i_blkbits;
+       unsigned int maxblocks = bh_result->b_size >> inode->i_blkbits;
 
        down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
        ret = nilfs_bmap_lookup_contig(ii->i_bmap, blkoff, &blknum, maxblocks);
@@ -163,7 +163,7 @@ static int nilfs_readpage(struct file *file, struct page *page)
  * @nr_pages - number of pages to be read
  */
 static int nilfs_readpages(struct file *file, struct address_space *mapping,
-                          struct list_head *pages, unsigned nr_pages)
+                          struct list_head *pages, unsigned int nr_pages)
 {
        return mpage_readpages(mapping, pages, nr_pages, nilfs_get_block);
 }
@@ -222,7 +222,7 @@ static int nilfs_set_page_dirty(struct page *page)
        int ret = __set_page_dirty_nobuffers(page);
 
        if (page_has_buffers(page)) {
-               unsigned nr_dirty = 0;
+               unsigned int nr_dirty = 0;
                struct buffer_head *bh, *head;
 
                /*
@@ -245,7 +245,7 @@ static int nilfs_set_page_dirty(struct page *page)
                if (nr_dirty)
                        nilfs_set_file_dirty(inode, nr_dirty);
        } else if (ret) {
-               unsigned nr_dirty = 1 << (PAGE_SHIFT - inode->i_blkbits);
+               unsigned int nr_dirty = 1 << (PAGE_SHIFT - inode->i_blkbits);
 
                nilfs_set_file_dirty(inode, nr_dirty);
        }
@@ -287,8 +287,8 @@ static int nilfs_write_end(struct file *file, struct address_space *mapping,
                           struct page *page, void *fsdata)
 {
        struct inode *inode = mapping->host;
-       unsigned start = pos & (PAGE_SIZE - 1);
-       unsigned nr_dirty;
+       unsigned int start = pos & (PAGE_SIZE - 1);
+       unsigned int nr_dirty;
        int err;
 
        nr_dirty = nilfs_page_count_clean_buffers(page, start,
@@ -902,7 +902,7 @@ int nilfs_inode_dirty(struct inode *inode)
        return ret;
 }
 
-int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty)
+int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty)
 {
        struct nilfs_inode_info *ii = NILFS_I(inode);
        struct the_nilfs *nilfs = inode->i_sb->s_fs_info;

diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index 8a2f8b240f253354f5e1e3943fe8806cbf400b52..3417d859a03cec6cc0d4455d2eaabbae08967e9a 100644 (file)
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -490,8 +490,8 @@ void nilfs_mdt_destroy(struct inode *inode)
        kfree(mdi);
 }
 
-void nilfs_mdt_set_entry_size(struct inode *inode, unsigned entry_size,
-                             unsigned header_size)
+void nilfs_mdt_set_entry_size(struct inode *inode, unsigned int entry_size,
+                             unsigned int header_size)
 {
        struct nilfs_mdt_info *mi = NILFS_MDT(inode);
 

diff --git a/fs/nilfs2/mdt.h b/fs/nilfs2/mdt.h
index ffb876e6efed99319dc4485f70bb49946445c81d..3f67f3932097b408fd6d7161a90e62170992a71a 100644 (file)
--- a/fs/nilfs2/mdt.h
+++ b/fs/nilfs2/mdt.h
@@ -53,8 +53,8 @@ struct nilfs_shadow_map {
 struct nilfs_mdt_info {
        struct rw_semaphore     mi_sem;
        struct blockgroup_lock *mi_bgl;
-       unsigned                mi_entry_size;
-       unsigned                mi_first_entry_offset;
+       unsigned int            mi_entry_size;
+       unsigned int            mi_first_entry_offset;
        unsigned long           mi_entries_per_block;
        struct nilfs_palloc_cache *mi_palloc_cache;
        struct nilfs_shadow_map *mi_shadow;
@@ -90,7 +90,7 @@ int nilfs_mdt_init(struct inode *inode, gfp_t gfp_mask, size_t objsz);
 void nilfs_mdt_clear(struct inode *inode);
 void nilfs_mdt_destroy(struct inode *inode);
 
-void nilfs_mdt_set_entry_size(struct inode *, unsigned, unsigned);
+void nilfs_mdt_set_entry_size(struct inode *, unsigned int, unsigned int);
 
 int nilfs_mdt_setup_shadow_map(struct inode *inode,
                               struct nilfs_shadow_map *shadow);

diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 8f8070cffa58cffd49e6fc20732097269a54ebe6..1ec8ae5995a59c94d4dd5b6f1f41054b461b7c59 100644 (file)
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -139,7 +139,7 @@ static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
 {
        struct nilfs_transaction_info ti;
        struct super_block *sb = dir->i_sb;
-       unsigned l = strlen(symname)+1;
+       unsigned int l = strlen(symname) + 1;
        struct inode *inode;
        int err;
 

diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index fa179d4e5dba57e0a218adc26939a9375cb1991c..ea320315d557536b6da0245458aa4e7853c4f48e 100644 (file)
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -274,7 +274,7 @@ extern void nilfs_write_failed(struct address_space *mapping, loff_t to);
 int nilfs_permission(struct inode *inode, int mask);
 int nilfs_load_inode_block(struct inode *inode, struct buffer_head **pbh);
 extern int nilfs_inode_dirty(struct inode *);
-int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty);
+int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty);
 extern int __nilfs_mark_inode_dirty(struct inode *, int);
 extern void nilfs_dirty_inode(struct inode *, int flags);
 int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,

diff --git a/fs/nilfs2/page.c b/fs/nilfs2/page.c
index 19687139f1975f456f9f97084e77d3b19859f173..d97ba5f11b77260d7e11390c849227fd6ea184e7 100644 (file)
--- a/fs/nilfs2/page.c
+++ b/fs/nilfs2/page.c
@@ -435,12 +435,12 @@ void nilfs_clear_dirty_page(struct page *page, bool silent)
        __nilfs_clear_page_dirty(page);
 }
 
-unsigned nilfs_page_count_clean_buffers(struct page *page,
-                                       unsigned from, unsigned to)
+unsigned int nilfs_page_count_clean_buffers(struct page *page,
+                                           unsigned int from, unsigned int to)
 {
-       unsigned block_start, block_end;
+       unsigned int block_start, block_end;
        struct buffer_head *bh, *head;
-       unsigned nc = 0;
+       unsigned int nc = 0;
 
        for (bh = head = page_buffers(page), block_start = 0;
             bh != head || !block_start;

diff --git a/fs/nilfs2/page.h b/fs/nilfs2/page.h
index 041f2dc5e6343712b10cbcdb0ad9977d4f9d678a..f3687c958fa848c20a3d17cab71b5a0da77de5d1 100644 (file)
--- a/fs/nilfs2/page.h
+++ b/fs/nilfs2/page.h
@@ -53,7 +53,8 @@ void nilfs_copy_back_pages(struct address_space *, struct address_space *);
 void nilfs_clear_dirty_page(struct page *, bool);
 void nilfs_clear_dirty_pages(struct address_space *, bool);
 void nilfs_mapping_init(struct address_space *mapping, struct inode *inode);
-unsigned nilfs_page_count_clean_buffers(struct page *, unsigned, unsigned);
+unsigned int nilfs_page_count_clean_buffers(struct page *, unsigned int,
+                                           unsigned int);
 unsigned long nilfs_find_uncommitted_extent(struct inode *inode,
                                            sector_t start_blk,
                                            sector_t *blkoff);

diff --git a/fs/nilfs2/recovery.c b/fs/nilfs2/recovery.c
index 685fa73cecd08d95db5f4b29060096fe8bcb197d..db156a199149b1c1e740b740376671092308e460 100644 (file)
--- a/fs/nilfs2/recovery.c
+++ b/fs/nilfs2/recovery.c
@@ -152,7 +152,7 @@ int nilfs_read_super_root_block(struct the_nilfs *nilfs, sector_t sr_block,
 
        sr = (struct nilfs_super_root *)bh_sr->b_data;
        if (check) {
-               unsigned bytes = le16_to_cpu(sr->sr_bytes);
+               unsigned int bytes = le16_to_cpu(sr->sr_bytes);
 
                if (bytes == 0 || bytes > nilfs->ns_blocksize) {
                        ret = NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT;
@@ -504,7 +504,7 @@ static int nilfs_recover_dsync_blocks(struct the_nilfs *nilfs,
 {
        struct inode *inode;
        struct nilfs_recovery_block *rb, *n;
-       unsigned blocksize = nilfs->ns_blocksize;
+       unsigned int blocksize = nilfs->ns_blocksize;
        struct page *page;
        loff_t pos;
        int err = 0, err2 = 0;

diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c
index 52f6a6c8bab17881587a2987337c9859fd8f12c5..bf36df10540b692dc2eee698a07296edcbd0267b 100644 (file)
--- a/fs/nilfs2/segbuf.c
+++ b/fs/nilfs2/segbuf.c
@@ -129,7 +129,7 @@ int nilfs_segbuf_extend_payload(struct nilfs_segment_buffer *segbuf,
        return 0;
 }
 
-int nilfs_segbuf_reset(struct nilfs_segment_buffer *segbuf, unsigned flags,
+int nilfs_segbuf_reset(struct nilfs_segment_buffer *segbuf, unsigned int flags,
                       time_t ctime, __u64 cno)
 {
        int err;
@@ -236,7 +236,7 @@ nilfs_segbuf_fill_in_super_root_crc(struct nilfs_segment_buffer *segbuf,
 {
        struct nilfs_super_root *raw_sr;
        struct the_nilfs *nilfs = segbuf->sb_super->s_fs_info;
-       unsigned srsize;
+       unsigned int srsize;
        u32 crc;
 
        raw_sr = (struct nilfs_super_root *)segbuf->sb_super_root->b_data;

diff --git a/fs/nilfs2/segbuf.h b/fs/nilfs2/segbuf.h
index fc3a0fe3119c86c30456c710fa089f62ae2b00c7..7bbccc099709ad7a442b89cbbc8538dc3e61026a 100644 (file)
--- a/fs/nilfs2/segbuf.h
+++ b/fs/nilfs2/segbuf.h
@@ -78,7 +78,7 @@ struct nilfs_segment_buffer {
        __u64                   sb_nextnum;
        sector_t                sb_fseg_start, sb_fseg_end;
        sector_t                sb_pseg_start;
-       unsigned                sb_rest_blocks;
+       unsigned int            sb_rest_blocks;
 
        /* Buffers */
        struct list_head        sb_segsum_buffers;
@@ -120,7 +120,8 @@ void nilfs_segbuf_map_cont(struct nilfs_segment_buffer *segbuf,
                           struct nilfs_segment_buffer *prev);
 void nilfs_segbuf_set_next_segnum(struct nilfs_segment_buffer *, __u64,
                                  struct the_nilfs *);
-int nilfs_segbuf_reset(struct nilfs_segment_buffer *, unsigned, time_t, __u64);
+int nilfs_segbuf_reset(struct nilfs_segment_buffer *, unsigned int, time_t,
+                      __u64);
 int nilfs_segbuf_extend_segsum(struct nilfs_segment_buffer *);
 int nilfs_segbuf_extend_payload(struct nilfs_segment_buffer *,
                                struct buffer_head **);

diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index a6ef1eb15edb0b42226e093f1d9a05e2c6010724..97dee069be8322244f92851be48f55f61f706c19 100644 (file)
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -393,10 +393,10 @@ static void nilfs_transaction_unlock(struct super_block *sb)
 
 static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info *sci,
                                            struct nilfs_segsum_pointer *ssp,
-                                           unsigned bytes)
+                                           unsigned int bytes)
 {
        struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
-       unsigned blocksize = sci->sc_super->s_blocksize;
+       unsigned int blocksize = sci->sc_super->s_blocksize;
        void *p;
 
        if (unlikely(ssp->offset + bytes > blocksize)) {
@@ -418,8 +418,8 @@ static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci)
 {
        struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
        struct buffer_head *sumbh;
-       unsigned sumbytes;
-       unsigned flags = 0;
+       unsigned int sumbytes;
+       unsigned int flags = 0;
        int err;
 
        if (nilfs_doing_gc())
@@ -468,9 +468,9 @@ static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci)
  */
 static int nilfs_segctor_segsum_block_required(
        struct nilfs_sc_info *sci, const struct nilfs_segsum_pointer *ssp,
-       unsigned binfo_size)
+       unsigned int binfo_size)
 {
-       unsigned blocksize = sci->sc_super->s_blocksize;
+       unsigned int blocksize = sci->sc_super->s_blocksize;
        /* Size of finfo and binfo is enough small against blocksize */
 
        return ssp->offset + binfo_size +
@@ -529,7 +529,7 @@ static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci,
 static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci,
                                        struct buffer_head *bh,
                                        struct inode *inode,
-                                       unsigned binfo_size)
+                                       unsigned int binfo_size)
 {
        struct nilfs_segment_buffer *segbuf;
        int required, err = 0;
@@ -773,7 +773,7 @@ static void nilfs_dispose_list(struct the_nilfs *nilfs,
 {
        struct nilfs_inode_info *ii, *n;
        struct nilfs_inode_info *ivec[SC_N_INODEVEC], **pii;
-       unsigned nv = 0;
+       unsigned int nv = 0;
 
        while (!list_empty(head)) {
                spin_lock(&nilfs->ns_inode_lock);
@@ -954,7 +954,7 @@ static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci,
 {
        struct buffer_head *bh_sr;
        struct nilfs_super_root *raw_sr;
-       unsigned isz, srsz;
+       unsigned int isz, srsz;
 
        bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root;
        raw_sr = (struct nilfs_super_root *)bh_sr->b_data;

diff --git a/fs/nilfs2/segment.h b/fs/nilfs2/segment.h
index 6cb12dbee7c175f87355ac1ddd21b532845d6c33..27822e760d3f96d5756fea8bbbc84be5706730c5 100644 (file)
--- a/fs/nilfs2/segment.h
+++ b/fs/nilfs2/segment.h
@@ -71,7 +71,7 @@ struct nilfs_recovery_info {
  */
 struct nilfs_cstage {
        int                     scnt;
-       unsigned                flags;
+       unsigned int            flags;
        struct nilfs_inode_info *dirty_file_ptr;
        struct nilfs_inode_info *gc_inode_ptr;
 };
@@ -80,7 +80,7 @@ struct nilfs_segment_buffer;
 
 struct nilfs_segsum_pointer {
        struct buffer_head     *bh;
-       unsigned                offset; /* offset in bytes */
+       unsigned int            offset; /* offset in bytes */
 };
 
 /**

diff --git a/fs/nilfs2/sysfs.c b/fs/nilfs2/sysfs.c
index 3e7d85335adfdd8e3ecf070d445be35c8112e3ba..8ffa42b704d8fc564137ba3fd81bddcedf45036f 100644 (file)
--- a/fs/nilfs2/sysfs.c
+++ b/fs/nilfs2/sysfs.c
@@ -756,7 +756,7 @@ nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr,
                                      struct the_nilfs *nilfs,
                                      char *buf)
 {
-       unsigned sbwcount;
+       unsigned int sbwcount;
 
        down_read(&nilfs->ns_sem);
        sbwcount = nilfs->ns_sbwcount;
@@ -770,7 +770,7 @@ nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr,
                                            struct the_nilfs *nilfs,
                                            char *buf)
 {
-       unsigned sb_update_freq;
+       unsigned int sb_update_freq;
 
        down_read(&nilfs->ns_sem);
        sb_update_freq = nilfs->ns_sb_update_freq;
@@ -784,7 +784,7 @@ nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr,
                                            struct the_nilfs *nilfs,
                                            const char *buf, size_t count)
 {
-       unsigned val;
+       unsigned int val;
        int err;
 
        err = kstrtouint(skip_spaces(buf), 0, &val);

diff --git a/fs/nilfs2/the_nilfs.c b/fs/nilfs2/the_nilfs.c
index ba4b8189c3420136bdfffca255d7080961a54e40..b9e19ca3c96e862bb902965031ca1573fe0d90cf 100644 (file)
--- a/fs/nilfs2/the_nilfs.c
+++ b/fs/nilfs2/the_nilfs.c
@@ -108,8 +108,8 @@ static int nilfs_load_super_root(struct the_nilfs *nilfs,
        struct nilfs_super_root *raw_sr;
        struct nilfs_super_block **sbp = nilfs->ns_sbp;
        struct nilfs_inode *rawi;
-       unsigned dat_entry_size, segment_usage_size, checkpoint_size;
-       unsigned inode_size;
+       unsigned int dat_entry_size, segment_usage_size, checkpoint_size;
+       unsigned int inode_size;
        int err;
 
        err = nilfs_read_super_root_block(nilfs, sr_block, &bh_sr, 1);

diff --git a/fs/nilfs2/the_nilfs.h b/fs/nilfs2/the_nilfs.h
index 62bd7b10fe436c3c03afb7634eda6bf50eec85ab..06d2548d436d093602b808c48f21aa074c6d429c 100644 (file)
--- a/fs/nilfs2/the_nilfs.h
+++ b/fs/nilfs2/the_nilfs.h
@@ -114,10 +114,10 @@ struct the_nilfs {
        struct buffer_head     *ns_sbh[2];
        struct nilfs_super_block *ns_sbp[2];
        time_t                  ns_sbwtime;
-       unsigned                ns_sbwcount;
-       unsigned                ns_sbsize;
-       unsigned                ns_mount_state;
-       unsigned                ns_sb_update_freq;
+       unsigned int            ns_sbwcount;
+       unsigned int            ns_sbsize;
+       unsigned int            ns_mount_state;
+       unsigned int            ns_sb_update_freq;
 
        /*
         * Following fields are dedicated to a writable FS-instance.
@@ -306,7 +306,7 @@ static inline void nilfs_get_root(struct nilfs_root *root)
 
 static inline int nilfs_valid_fs(struct the_nilfs *nilfs)
 {
-       unsigned valid_fs;
+       unsigned int valid_fs;
 
        down_read(&nilfs->ns_sem);
        valid_fs = (nilfs->ns_mount_state & NILFS_VALID_FS);

diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
index 823d63d61081737435b3172986151a1bebb702f4..3b584925d0e8332dc4cf221e65bf134411064e19 100644 (file)
--- a/include/linux/nilfs2_fs.h
+++ b/include/linux/nilfs2_fs.h
@@ -322,9 +322,9 @@ enum {
                                        ~NILFS_DIR_ROUND)
 #define NILFS_MAX_REC_LEN              ((1<<16)-1)
 
-static inline unsigned nilfs_rec_len_from_disk(__le16 dlen)
+static inline unsigned int nilfs_rec_len_from_disk(__le16 dlen)
 {
-       unsigned len = le16_to_cpu(dlen);
+       unsigned int len = le16_to_cpu(dlen);
 
 #if !defined(__KERNEL__) || (PAGE_SIZE >= 65536)
        if (len == NILFS_MAX_REC_LEN)
@@ -333,7 +333,7 @@ static inline unsigned nilfs_rec_len_from_disk(__le16 dlen)
        return len;
 }
 
-static inline __le16 nilfs_rec_len_to_disk(unsigned len)
+static inline __le16 nilfs_rec_len_to_disk(unsigned int len)
 {
 #if !defined(__KERNEL__) || (PAGE_SIZE >= 65536)
        if (len == (1 << 16))