usb: gadget: f_hid: add dev to configfs

[cascardo/linux.git] / fs / nilfs2 / sufile.c

diff --git a/fs/nilfs2/sufile.c b/fs/nilfs2/sufile.c
index 1963595..1541a1e 100644 (file)
--- a/fs/nilfs2/sufile.c
+++ b/fs/nilfs2/sufile.c
@@ -22,7 +22,6 @@
 #include <linux/string.h>
 #include <linux/buffer_head.h>
 #include <linux/errno.h>
-#include <linux/nilfs2_fs.h>
 #include "mdt.h"
 #include "sufile.h"
 
@@ -181,9 +180,9 @@ int nilfs_sufile_updatev(struct inode *sufile, __u64 *segnumv, size_t nsegs,
        down_write(&NILFS_MDT(sufile)->mi_sem);
        for (seg = segnumv; seg < segnumv + nsegs; seg++) {
                if (unlikely(*seg >= nilfs_sufile_get_nsegments(sufile))) {
-                       printk(KERN_WARNING
-                              "%s: invalid segment number: %llu\n", __func__,
-                              (unsigned long long)*seg);
+                       nilfs_msg(sufile->i_sb, KERN_WARNING,
+                                 "%s: invalid segment number: %llu",
+                                 __func__, (unsigned long long)*seg);
                        nerr++;
                }
        }
@@ -240,8 +239,9 @@ int nilfs_sufile_update(struct inode *sufile, __u64 segnum, int create,
        int ret;
 
        if (unlikely(segnum >= nilfs_sufile_get_nsegments(sufile))) {
-               printk(KERN_WARNING "%s: invalid segment number: %llu\n",
-                      __func__, (unsigned long long)segnum);
+               nilfs_msg(sufile->i_sb, KERN_WARNING,
+                         "%s: invalid segment number: %llu",
+                         __func__, (unsigned long long)segnum);
                return -EINVAL;
        }
        down_write(&NILFS_MDT(sufile)->mi_sem);
@@ -419,8 +419,9 @@ void nilfs_sufile_do_cancel_free(struct inode *sufile, __u64 segnum,
        kaddr = kmap_atomic(su_bh->b_page);
        su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
        if (unlikely(!nilfs_segment_usage_clean(su))) {
-               printk(KERN_WARNING "%s: segment %llu must be clean\n",
-                      __func__, (unsigned long long)segnum);
+               nilfs_msg(sufile->i_sb, KERN_WARNING,
+                         "%s: segment %llu must be clean", __func__,
+                         (unsigned long long)segnum);
                kunmap_atomic(kaddr);
                return;
        }
@@ -444,7 +445,7 @@ void nilfs_sufile_do_scrap(struct inode *sufile, __u64 segnum,
 
        kaddr = kmap_atomic(su_bh->b_page);
        su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
-       if (su->su_flags == cpu_to_le32(1UL << NILFS_SEGMENT_USAGE_DIRTY) &&
+       if (su->su_flags == cpu_to_le32(BIT(NILFS_SEGMENT_USAGE_DIRTY)) &&
            su->su_nblocks == cpu_to_le32(0)) {
                kunmap_atomic(kaddr);
                return;
@@ -455,7 +456,7 @@ void nilfs_sufile_do_scrap(struct inode *sufile, __u64 segnum,
        /* make the segment garbage */
        su->su_lastmod = cpu_to_le64(0);
        su->su_nblocks = cpu_to_le32(0);
-       su->su_flags = cpu_to_le32(1UL << NILFS_SEGMENT_USAGE_DIRTY);
+       su->su_flags = cpu_to_le32(BIT(NILFS_SEGMENT_USAGE_DIRTY));
        kunmap_atomic(kaddr);
 
        nilfs_sufile_mod_counter(header_bh, clean ? (u64)-1 : 0, dirty ? 0 : 1);
@@ -476,8 +477,9 @@ void nilfs_sufile_do_free(struct inode *sufile, __u64 segnum,
        kaddr = kmap_atomic(su_bh->b_page);
        su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
        if (nilfs_segment_usage_clean(su)) {
-               printk(KERN_WARNING "%s: segment %llu is already clean\n",
-                      __func__, (unsigned long long)segnum);
+               nilfs_msg(sufile->i_sb, KERN_WARNING,
+                         "%s: segment %llu is already clean",
+                         __func__, (unsigned long long)segnum);
                kunmap_atomic(kaddr);
                return;
        }
@@ -692,7 +694,7 @@ static int nilfs_sufile_truncate_range(struct inode *sufile,
                su2 = su;
                for (j = 0; j < n; j++, su = (void *)su + susz) {
                        if ((le32_to_cpu(su->su_flags) &
-                            ~(1UL << NILFS_SEGMENT_USAGE_ERROR)) ||
+                            ~BIT(NILFS_SEGMENT_USAGE_ERROR)) ||
                            nilfs_segment_is_active(nilfs, segnum + j)) {
                                ret = -EBUSY;
                                kunmap_atomic(kaddr);
@@ -859,10 +861,10 @@ ssize_t nilfs_sufile_get_suinfo(struct inode *sufile, __u64 segnum, void *buf,
                        si->sui_lastmod = le64_to_cpu(su->su_lastmod);
                        si->sui_nblocks = le32_to_cpu(su->su_nblocks);
                        si->sui_flags = le32_to_cpu(su->su_flags) &
-                               ~(1UL << NILFS_SEGMENT_USAGE_ACTIVE);
+                               ~BIT(NILFS_SEGMENT_USAGE_ACTIVE);
                        if (nilfs_segment_is_active(nilfs, segnum + j))
                                si->sui_flags |=
-                                       (1UL << NILFS_SEGMENT_USAGE_ACTIVE);
+                                       BIT(NILFS_SEGMENT_USAGE_ACTIVE);
                }
                kunmap_atomic(kaddr);
                brelse(su_bh);
@@ -950,7 +952,7 @@ ssize_t nilfs_sufile_set_suinfo(struct inode *sufile, void *buf,
                         * disk.
                         */
                        sup->sup_sui.sui_flags &=
-                                       ~(1UL << NILFS_SEGMENT_USAGE_ACTIVE);
+                                       ~BIT(NILFS_SEGMENT_USAGE_ACTIVE);
 
                        cleansi = nilfs_suinfo_clean(&sup->sup_sui);
                        cleansu = nilfs_segment_usage_clean(su);
@@ -1175,14 +1177,12 @@ int nilfs_sufile_read(struct super_block *sb, size_t susize,
        int err;
 
        if (susize > sb->s_blocksize) {
-               printk(KERN_ERR
-                      "NILFS: too large segment usage size: %zu bytes.\n",
-                      susize);
+               nilfs_msg(sb, KERN_ERR,
+                         "too large segment usage size: %zu bytes", susize);
                return -EINVAL;
        } else if (susize < NILFS_MIN_SEGMENT_USAGE_SIZE) {
-               printk(KERN_ERR
-                      "NILFS: too small segment usage size: %zu bytes.\n",
-                      susize);
+               nilfs_msg(sb, KERN_ERR,
+                         "too small segment usage size: %zu bytes", susize);
                return -EINVAL;
        }