GFS2: global conversion to pr_foo() · tjh.dev/kernel@fc554ed

+4 -4

fs/gfs2/dir.c

··· 507 507 goto error; 508 508 return 0; 509 509 error: 510 - printk(KERN_WARNING "gfs2_check_dirent: %s (%s)\n", msg, 510 + pr_warn("gfs2_check_dirent: %s (%s)\n", msg, 511 511 first ? "first in block" : "not first in block"); 512 512 return -EIO; 513 513 } ··· 531 531 } 532 532 return offset; 533 533 wrong_type: 534 - printk(KERN_WARNING "gfs2_scan_dirent: wrong block type %u\n", 535 - be32_to_cpu(h->mh_type)); 534 + pr_warn("gfs2_scan_dirent: wrong block type %u\n", 535 + be32_to_cpu(h->mh_type)); 536 536 return -1; 537 537 } 538 538 ··· 1006 1006 len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth)); 1007 1007 half_len = len >> 1; 1008 1008 if (!half_len) { 1009 - printk(KERN_WARNING "i_depth %u lf_depth %u index %u\n", dip->i_depth, be16_to_cpu(oleaf->lf_depth), index); 1009 + pr_warn("i_depth %u lf_depth %u index %u\n", dip->i_depth, be16_to_cpu(oleaf->lf_depth), index); 1010 1010 gfs2_consist_inode(dip); 1011 1011 error = -EIO; 1012 1012 goto fail_brelse;

+9 -9

fs/gfs2/glock.c

··· 468 468 do_xmote(gl, gh, LM_ST_UNLOCKED); 469 469 break; 470 470 default: /* Everything else */ 471 - printk(KERN_ERR "GFS2: wanted %u got %u\n", gl->gl_target, state); 471 + pr_err("GFS2: wanted %u got %u\n", gl->gl_target, state); 472 472 GLOCK_BUG_ON(gl, 1); 473 473 } 474 474 spin_unlock(&gl->gl_spin); ··· 542 542 /* lock_dlm */ 543 543 ret = sdp->sd_lockstruct.ls_ops->lm_lock(gl, target, lck_flags); 544 544 if (ret) { 545 - printk(KERN_ERR "GFS2: lm_lock ret %d\n", ret); 545 + pr_err("GFS2: lm_lock ret %d\n", ret); 546 546 GLOCK_BUG_ON(gl, 1); 547 547 } 548 548 } else { /* lock_nolock */ ··· 935 935 vaf.fmt = fmt; 936 936 vaf.va = &args; 937 937 938 - printk(KERN_ERR " %pV", &vaf); 938 + pr_err(" %pV", &vaf); 939 939 } 940 940 941 941 va_end(args); ··· 1010 1010 return; 1011 1011 1012 1012 trap_recursive: 1013 - printk(KERN_ERR "original: %pSR\n", (void *)gh2->gh_ip); 1014 - printk(KERN_ERR "pid: %d\n", pid_nr(gh2->gh_owner_pid)); 1015 - printk(KERN_ERR "lock type: %d req lock state : %d\n", 1013 + pr_err("original: %pSR\n", (void *)gh2->gh_ip); 1014 + pr_err("pid: %d\n", pid_nr(gh2->gh_owner_pid)); 1015 + pr_err("lock type: %d req lock state : %d\n", 1016 1016 gh2->gh_gl->gl_name.ln_type, gh2->gh_state); 1017 - printk(KERN_ERR "new: %pSR\n", (void *)gh->gh_ip); 1018 - printk(KERN_ERR "pid: %d\n", pid_nr(gh->gh_owner_pid)); 1019 - printk(KERN_ERR "lock type: %d req lock state : %d\n", 1017 + pr_err("new: %pSR\n", (void *)gh->gh_ip); 1018 + pr_err("pid: %d\n", pid_nr(gh->gh_owner_pid)); 1019 + pr_err("lock type: %d req lock state : %d\n", 1020 1020 gh->gh_gl->gl_name.ln_type, gh->gh_state); 1021 1021 gfs2_dump_glock(NULL, gl); 1022 1022 BUG();

+3 -4

fs/gfs2/lock_dlm.c

··· 176 176 gfs2_glock_cb(gl, LM_ST_SHARED); 177 177 break; 178 178 default: 179 - printk(KERN_ERR "unknown bast mode %d", mode); 179 + pr_err("unknown bast mode %d", mode); 180 180 BUG(); 181 181 } 182 182 } ··· 195 195 case LM_ST_SHARED: 196 196 return DLM_LOCK_PR; 197 197 } 198 - printk(KERN_ERR "unknown LM state %d", lmstate); 198 + pr_err("unknown LM state %d", lmstate); 199 199 BUG(); 200 200 return -1; 201 201 } ··· 308 308 error = dlm_unlock(ls->ls_dlm, gl->gl_lksb.sb_lkid, DLM_LKF_VALBLK, 309 309 NULL, gl); 310 310 if (error) { 311 - printk(KERN_ERR "gdlm_unlock %x,%llx err=%d\n", 312 - gl->gl_name.ln_type, 311 + pr_err("gdlm_unlock %x,%llx err=%d\n", gl->gl_name.ln_type, 313 312 (unsigned long long)gl->gl_name.ln_number, error); 314 313 return; 315 314 }

+1 -1

fs/gfs2/main.c

··· 165 165 166 166 gfs2_register_debugfs(); 167 167 168 - printk("GFS2 installed\n"); 168 + pr_info("GFS2 installed\n"); 169 169 170 170 return 0; 171 171

+7 -7

fs/gfs2/ops_fstype.c

··· 152 152 if (sb->sb_magic != GFS2_MAGIC || 153 153 sb->sb_type != GFS2_METATYPE_SB) { 154 154 if (!silent) 155 - printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n"); 155 + pr_warn("GFS2: not a GFS2 filesystem\n"); 156 156 return -EINVAL; 157 157 } 158 158 ··· 174 174 if (!error) 175 175 SetPageUptodate(page); 176 176 else 177 - printk(KERN_WARNING "gfs2: error %d reading superblock\n", error); 177 + pr_warn("gfs2: error %d reading superblock\n", error); 178 178 unlock_page(page); 179 179 } 180 180 ··· 945 945 lm = &gfs2_dlm_ops; 946 946 #endif 947 947 } else { 948 - printk(KERN_INFO "GFS2: can't find protocol %s\n", proto); 948 + pr_info("GFS2: can't find protocol %s\n", proto); 949 949 return -ENOENT; 950 950 } 951 951 ··· 1052 1052 1053 1053 sdp = init_sbd(sb); 1054 1054 if (!sdp) { 1055 - printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n"); 1055 + pr_warn("GFS2: can't alloc struct gfs2_sbd\n"); 1056 1056 return -ENOMEM; 1057 1057 } 1058 1058 sdp->sd_args = *args; ··· 1300 1300 1301 1301 error = gfs2_mount_args(&args, data); 1302 1302 if (error) { 1303 - printk(KERN_WARNING "GFS2: can't parse mount arguments\n"); 1303 + pr_warn("GFS2: can't parse mount arguments\n"); 1304 1304 goto error_super; 1305 1305 } 1306 1306 ··· 1350 1350 1351 1351 error = kern_path(dev_name, LOOKUP_FOLLOW, &path); 1352 1352 if (error) { 1353 - printk(KERN_WARNING "GFS2: path_lookup on %s returned error %d\n", 1353 + pr_warn("GFS2: path_lookup on %s returned error %d\n", 1354 1354 dev_name, error); 1355 1355 return ERR_PTR(error); 1356 1356 } ··· 1358 1358 path.dentry->d_inode->i_sb->s_bdev); 1359 1359 path_put(&path); 1360 1360 if (IS_ERR(s)) { 1361 - printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n"); 1361 + pr_warn("GFS2: gfs2 mount does not exist\n"); 1362 1362 return ERR_CAST(s); 1363 1363 } 1364 1364 if ((flags ^ s->s_flags) & MS_RDONLY) {

+1 -1

fs/gfs2/quota.c

··· 1081 1081 { 1082 1082 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd; 1083 1083 1084 - printk(KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\n", 1084 + pr_info("GFS2: fsid=%s: quota %s for %s %u\n", 1085 1085 sdp->sd_fsname, type, 1086 1086 (qd->qd_id.type == USRQUOTA) ? "user" : "group", 1087 1087 from_kqid(&init_user_ns, qd->qd_id));

+9 -9

fs/gfs2/rgrp.c

··· 99 99 cur_state = (*byte1 >> bit) & GFS2_BIT_MASK; 100 100 101 101 if (unlikely(!valid_change[new_state * 4 + cur_state])) { 102 - printk(KERN_WARNING "GFS2: buf_blk = 0x%x old_state=%d, " 102 + pr_warn("GFS2: buf_blk = 0x%x old_state=%d, " 103 103 "new_state=%d\n", rbm->offset, cur_state, new_state); 104 - printk(KERN_WARNING "GFS2: rgrp=0x%llx bi_start=0x%x\n", 104 + pr_warn("GFS2: rgrp=0x%llx bi_start=0x%x\n", 105 105 (unsigned long long)rbm->rgd->rd_addr, bi->bi_start); 106 - printk(KERN_WARNING "GFS2: bi_offset=0x%x bi_len=0x%x\n", 106 + pr_warn("GFS2: bi_offset=0x%x bi_len=0x%x\n", 107 107 bi->bi_offset, bi->bi_len); 108 108 dump_stack(); 109 109 gfs2_consist_rgrpd(rbm->rgd); ··· 736 736 737 737 static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd) 738 738 { 739 - printk(KERN_INFO " ri_addr = %llu\n", (unsigned long long)rgd->rd_addr); 740 - printk(KERN_INFO " ri_length = %u\n", rgd->rd_length); 741 - printk(KERN_INFO " ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0); 742 - printk(KERN_INFO " ri_data = %u\n", rgd->rd_data); 743 - printk(KERN_INFO " ri_bitbytes = %u\n", rgd->rd_bitbytes); 739 + pr_info(" ri_addr = %llu\n", (unsigned long long)rgd->rd_addr); 740 + pr_info(" ri_length = %u\n", rgd->rd_length); 741 + pr_info(" ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0); 742 + pr_info(" ri_data = %u\n", rgd->rd_data); 743 + pr_info(" ri_bitbytes = %u\n", rgd->rd_bitbytes); 744 744 } 745 745 746 746 /** ··· 2278 2278 } 2279 2279 } 2280 2280 if (rbm.rgd->rd_free < *nblocks) { 2281 - printk(KERN_WARNING "nblocks=%u\n", *nblocks); 2281 + pr_warn("nblocks=%u\n", *nblocks); 2282 2282 goto rgrp_error; 2283 2283 } 2284 2284

+7 -7

fs/gfs2/super.c

··· 175 175 break; 176 176 case Opt_debug: 177 177 if (args->ar_errors == GFS2_ERRORS_PANIC) { 178 - printk(KERN_WARNING "GFS2: -o debug and -o errors=panic " 178 + pr_warn("GFS2: -o debug and -o errors=panic " 179 179 "are mutually exclusive.\n"); 180 180 return -EINVAL; 181 181 } ··· 228 228 case Opt_commit: 229 229 rv = match_int(&tmp[0], &args->ar_commit); 230 230 if (rv || args->ar_commit <= 0) { 231 - printk(KERN_WARNING "GFS2: commit mount option requires a positive numeric argument\n"); 231 + pr_warn("GFS2: commit mount option requires a positive numeric argument\n"); 232 232 return rv ? rv : -EINVAL; 233 233 } 234 234 break; 235 235 case Opt_statfs_quantum: 236 236 rv = match_int(&tmp[0], &args->ar_statfs_quantum); 237 237 if (rv || args->ar_statfs_quantum < 0) { 238 - printk(KERN_WARNING "GFS2: statfs_quantum mount option requires a non-negative numeric argument\n"); 238 + pr_warn("GFS2: statfs_quantum mount option requires a non-negative numeric argument\n"); 239 239 return rv ? rv : -EINVAL; 240 240 } 241 241 break; 242 242 case Opt_quota_quantum: 243 243 rv = match_int(&tmp[0], &args->ar_quota_quantum); 244 244 if (rv || args->ar_quota_quantum <= 0) { 245 - printk(KERN_WARNING "GFS2: quota_quantum mount option requires a positive numeric argument\n"); 245 + pr_warn("GFS2: quota_quantum mount option requires a positive numeric argument\n"); 246 246 return rv ? rv : -EINVAL; 247 247 } 248 248 break; ··· 250 250 rv = match_int(&tmp[0], &args->ar_statfs_percent); 251 251 if (rv || args->ar_statfs_percent < 0 || 252 252 args->ar_statfs_percent > 100) { 253 - printk(KERN_WARNING "statfs_percent mount option requires a numeric argument between 0 and 100\n"); 253 + pr_warn("statfs_percent mount option requires a numeric argument between 0 and 100\n"); 254 254 return rv ? rv : -EINVAL; 255 255 } 256 256 break; ··· 259 259 break; 260 260 case Opt_err_panic: 261 261 if (args->ar_debug) { 262 - printk(KERN_WARNING "GFS2: -o debug and -o errors=panic " 262 + pr_warn("GFS2: -o debug and -o errors=panic " 263 263 "are mutually exclusive.\n"); 264 264 return -EINVAL; 265 265 } ··· 279 279 break; 280 280 case Opt_error: 281 281 default: 282 - printk(KERN_WARNING "GFS2: invalid mount option: %s\n", o); 282 + pr_warn("GFS2: invalid mount option: %s\n", o); 283 283 return -EINVAL; 284 284 } 285 285 }

+5 -6

fs/gfs2/trans.c

··· 99 99 100 100 static void gfs2_print_trans(const struct gfs2_trans *tr) 101 101 { 102 - printk(KERN_WARNING "GFS2: Transaction created at: %pSR\n", 103 - (void *)tr->tr_ip); 104 - printk(KERN_WARNING "GFS2: blocks=%u revokes=%u reserved=%u touched=%u\n", 102 + pr_warn("GFS2: Transaction created at: %pSR\n", (void *)tr->tr_ip); 103 + pr_warn("GFS2: blocks=%u revokes=%u reserved=%u touched=%u\n", 105 104 tr->tr_blocks, tr->tr_revokes, tr->tr_reserved, tr->tr_touched); 106 - printk(KERN_WARNING "GFS2: Buf %u/%u Databuf %u/%u Revoke %u/%u\n", 105 + pr_warn("GFS2: Buf %u/%u Databuf %u/%u Revoke %u/%u\n", 107 106 tr->tr_num_buf_new, tr->tr_num_buf_rm, 108 107 tr->tr_num_databuf_new, tr->tr_num_databuf_rm, 109 108 tr->tr_num_revoke, tr->tr_num_revoke_rm); ··· 231 232 set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags); 232 233 mh = (struct gfs2_meta_header *)bd->bd_bh->b_data; 233 234 if (unlikely(mh->mh_magic != cpu_to_be32(GFS2_MAGIC))) { 234 - printk(KERN_ERR 235 - "Attempting to add uninitialised block to journal (inplace block=%lld)\n", 235 + pr_err("Attempting to add uninitialised block to journal " 236 + "(inplace block=%lld)\n", 236 237 (unsigned long long)bd->bd_bh->b_blocknr); 237 238 BUG(); 238 239 }

+2 -4

fs/gfs2/util.c

··· 30 30 31 31 void gfs2_assert_i(struct gfs2_sbd *sdp) 32 32 { 33 - printk(KERN_EMERG "GFS2: fsid=%s: fatal assertion failed\n", 34 - sdp->sd_fsname); 33 + pr_emerg("GFS2: fsid=%s: fatal assertion failed\n", sdp->sd_fsname); 35 34 } 36 35 37 36 int gfs2_lm_withdraw(struct gfs2_sbd *sdp, char *fmt, ...) ··· 104 105 return -2; 105 106 106 107 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW) 107 - printk(KERN_WARNING 108 - "GFS2: fsid=%s: warning: assertion \"%s\" failed\n" 108 + pr_warn("GFS2: fsid=%s: warning: assertion \"%s\" failed\n" 109 109 "GFS2: fsid=%s: function = %s, file = %s, line = %u\n", 110 110 sdp->sd_fsname, assertion, 111 111 sdp->sd_fsname, function, file, line);