ceph: Neaten debugging

index 12ae6f7874fb..4f0f177428c7 100644
@@ -311,8 +311,8 @@ static void finish_read(struct ceph_osd_request *req)
 	int num_pages;
 	int i;
 
-	pr_debug("finish_read %p req %p rc %d bytes %d\n",
-		 inode, req, rc, bytes);
+	pr_debug("%s: %p req %p rc %d bytes %d\n",
+		 __func__, inode, req, rc, bytes);
 	if (rc == -EBLACKLISTED)
 		ceph_inode_to_client(inode)->blacklisted = true;
 

@@ -333,8 +333,8 @@ static void finish_read(struct ceph_osd_request *req)
 			int s = bytes < 0 ? 0 : bytes;
 			zero_user_segment(page, s, PAGE_SIZE);
 		}
-		pr_debug("finish_read %p uptodate %p idx %lu\n",
-			 inode, page, page->index);
+		pr_debug("%s: %p uptodate %p idx %lu\n",
+			 __func__, inode, page, page->index);
 		flush_dcache_page(page);
 		SetPageUptodate(page);
 		ceph_readpage_to_fscache(inode, page);

@@ -379,9 +379,10 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 		ret = ceph_try_get_caps(inode, CEPH_CAP_FILE_RD, want,
 					true, &got);
 		if (ret < 0) {
-			pr_debug("start_read %p, error getting cap\n", inode);
+			pr_debug("%s: %p, error getting cap\n",
+				 __func__, inode);
 		} else if (!(got & want)) {
-			pr_debug("start_read %p, no cache cap\n", inode);
+			pr_debug("%s: %p, no cache cap\n", __func__, inode);
 			ret = 0;
 		}
 		if (ret <= 0) {

@@ -409,8 +410,8 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 			break;
 	}
 	len = nr_pages << PAGE_SHIFT;
-	pr_debug("start_read %p nr_pages %d is %lld~%lld\n",
-		 inode, nr_pages, off, len);
+	pr_debug("%s: %p nr_pages %d is %lld~%lld\n",
+		 __func__, inode, nr_pages, off, len);
 	vino = ceph_vino(inode);
 	req = ceph_osdc_new_request(osdc, &ci->i_layout, vino, off, &len,
 				    0, 1, CEPH_OSD_OP_READ,

@@ -434,14 +435,14 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 		BUG_ON(PageLocked(page));
 		list_del(&page->lru);
 
-		pr_debug("start_read %p adding %p idx %lu\n",
-			 inode, page, page->index);
+		pr_debug("%s: %p adding %p idx %lu\n",
+			 __func__, inode, page, page->index);
 		if (add_to_page_cache_lru(page, &inode->i_data, page->index,
 					  GFP_KERNEL)) {
 			ceph_fscache_uncache_page(inode, page);
 			put_page(page);
-			pr_debug("start_read %p add_to_page_cache failed %p\n",
-				 inode, page);
+			pr_debug("%s: %p add_to_page_cache failed %p\n",
+				 __func__, inode, page);
 			nr_pages = i;
 			if (nr_pages > 0) {
 				len = nr_pages << PAGE_SHIFT;

@@ -456,7 +457,8 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 	req->r_callback = finish_read;
 	req->r_inode = inode;
 
-	pr_debug("start_read %p starting %p %lld~%lld\n", inode, req, off, len);
+	pr_debug("%s: %p starting %p %lld~%lld\n",
+		 __func__, inode, req, off, len);
 	ret = ceph_osdc_start_request(osdc, req, false);
 	if (ret < 0)
 		goto out_pages;

@@ -798,7 +800,7 @@ static void writepages_finish(struct ceph_osd_request *req)
 	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
 	bool remove_page;
 
-	pr_debug("writepages_finish %p rc %d\n", inode, rc);
+	pr_debug("%s: %p rc %d\n", __func__, inode, rc);
 	if (rc < 0) {
 		mapping_set_error(mapping, rc);
 		ceph_set_error_write(ci);

@@ -853,8 +855,9 @@ static void writepages_finish(struct ceph_osd_request *req)
 
 			unlock_page(page);
 		}
-		pr_debug("writepages_finish %p wrote %llu bytes cleaned %d pages\n",
-			 inode, osd_data->length, rc >= 0 ? num_pages : 0);
+		pr_debug("%s: %p wrote %llu bytes cleaned %d pages\n",
+			 __func__, inode, osd_data->length,
+			 rc >= 0 ? num_pages : 0);
 
 		release_pages(osd_data->pages, num_pages);
 	}

@@ -1952,11 +1955,10 @@ static int __ceph_pool_perm_get(struct ceph_inode_info *ci,
 		goto out;
 
 	if (pool_ns)
-		pr_debug("__ceph_pool_perm_get pool %lld ns %.*s no perm cached\n",
-			 pool, (int)pool_ns->len, pool_ns->str);
+		pr_debug("%s: %lld ns %.*s no perm cached\n",
+			 __func__, pool, (int)pool_ns->len, pool_ns->str);
 	else
-		pr_debug("__ceph_pool_perm_get pool %lld no perm cached\n",
-			 pool);
+		pr_debug("%s: %lld no perm cached\n", __func__, pool);
 
 	down_write(&mdsc->pool_perm_rwsem);
 	p = &mdsc->pool_perm_tree.rb_node;

@@ -2083,11 +2085,10 @@ static int __ceph_pool_perm_get(struct ceph_inode_info *ci,
 	if (!err)
 		err = have;
 	if (pool_ns)
-		pr_debug("__ceph_pool_perm_get pool %lld ns %.*s result = %d\n",
-			 pool, (int)pool_ns->len, pool_ns->str, err);
+		pr_debug("%s: pool %lld ns %.*s result = %d\n",
+			 __func__, pool, (int)pool_ns->len, pool_ns->str, err);
 	else
-		pr_debug("__ceph_pool_perm_get pool %lld result = %d\n",
-			 pool, err);
+		pr_debug("%s: pool %lld result = %d\n", __func__, pool, err);
 	return err;
 }
 

@@ -2118,13 +2119,13 @@ int ceph_pool_perm_check(struct inode *inode, int need)
 check:
 	if (flags & CEPH_I_POOL_PERM) {
 		if ((need & CEPH_CAP_FILE_RD) && !(flags & CEPH_I_POOL_RD)) {
-			pr_debug("ceph_pool_perm_check pool %lld no read perm\n",
-				 pool);
+			pr_debug("%s: pool %lld no read perm\n",
+				 __func__, pool);
 			return -EPERM;
 		}
 		if ((need & CEPH_CAP_FILE_WR) && !(flags & CEPH_I_POOL_WR)) {
-			pr_debug("ceph_pool_perm_check pool %lld no write perm\n",
-				 pool);
+			pr_debug("%s: pool %lld no write perm\n",
+				 __func__, pool);
 			return -EPERM;
 		}
 		return 0;

236 lines not on this page · raw message

index 244428de3c4b..298b0df741cc 100644
@@ -338,7 +338,7 @@ void ceph_fs_debugfs_init(struct ceph_fs_client *fsc)
 {
 	char name[100];
 
-	pr_debug("ceph_fs_debugfs_init\n");
+	pr_debug("%s\n", __func__);
 	fsc->debugfs_congestion_kb =
 		debugfs_create_file("writeback_congestion_kb",
 				    0600,

index 911b905cc181..9178b19f93f9 100644
@@ -120,7 +120,7 @@ static int note_last_dentry(struct ceph_dir_file_info *dfi, const char *name,
 	memcpy(dfi->last_name, name, len);
 	dfi->last_name[len] = 0;
 	dfi->next_offset = next_offset;
-	pr_debug("note_last_dentry '%s'\n", dfi->last_name);
+	pr_debug("%s: '%s'\n", __func__, dfi->last_name);
 	return 0;
 }
 

@@ -191,8 +191,8 @@ static int __dcache_readdir(struct file *file,  struct dir_context *ctx,
 	u64 idx = 0;
 	int err = 0;
 
-	pr_debug("__dcache_readdir %p v%u at %llx\n",
-		 dir, (unsigned int)shared_gen, ctx->pos);
+	pr_debug("%s: %p v%u at %llx\n",
+		 __func__, dir, (unsigned int)shared_gen, ctx->pos);
 
 	/* search start position */
 	if (ctx->pos > 2) {

@@ -222,7 +222,7 @@ static int __dcache_readdir(struct file *file,  struct dir_context *ctx,
 			dput(dentry);
 		}
 
-		pr_debug("__dcache_readdir %p cache idx %llu\n", dir, idx);
+		pr_debug("%s: %p cache idx %llu\n", __func__, dir, idx);
 	}
 
 

@@ -1597,7 +1597,7 @@ static int dentry_lease_is_valid(struct dentry *dentry, unsigned int flags)
 					 CEPH_MDS_LEASE_RENEW, seq);
 		ceph_put_mds_session(session);
 	}
-	pr_debug("dentry_lease_is_valid - dentry %p = %d\n", dentry, valid);
+	pr_debug("%s: dentry %p = %d\n", __func__, dentry, valid);
 	return valid;
 }
 

@@ -1661,8 +1661,8 @@ static int dir_lease_is_valid(struct inode *dir, struct dentry *dentry,
 			valid = 0;
 		spin_unlock(&dentry->d_lock);
 	}
-	pr_debug("dir_lease_is_valid dir %p v%u dentry %p = %d\n",
-		 dir, (unsigned int)atomic_read(&ci->i_shared_gen),
+	pr_debug("%s: dir %p v%u dentry %p = %d\n",
+		 __func__, dir, (unsigned int)atomic_read(&ci->i_shared_gen),
 		 dentry, valid);
 	return valid;
 }

@@ -1825,7 +1825,7 @@ static void ceph_d_prune(struct dentry *dentry)
 	struct ceph_inode_info *dir_ci;
 	struct ceph_dentry_info *di;
 
-	pr_debug("ceph_d_prune %pd %p\n", dentry, dentry);
+	pr_debug("%s: %pd %p\n", __func__, dentry, dentry);
 
 	/* do we have a valid parent? */
 	if (IS_ROOT(dentry))

index 7d7644f8862c..d75b466780ca 100644
@@ -1020,7 +1020,7 @@ static void ceph_aio_complete(struct inode *inode,
 	if (!ret)
 		ret = aio_req->total_len;
 
-	pr_debug("ceph_aio_complete %p rc %d\n", inode, ret);
+	pr_debug("%s: %p rc %d\n", __func__, inode, ret);
 
 	if (ret >= 0 && aio_req->write) {
 		int dirty;

@@ -1062,8 +1062,8 @@ static void ceph_aio_complete_req(struct ceph_osd_request *req)
 	BUG_ON(osd_data->type != CEPH_OSD_DATA_TYPE_BVECS);
 	BUG_ON(!osd_data->num_bvecs);
 
-	pr_debug("ceph_aio_complete_req %p rc %d bytes %u\n",
-		 inode, rc, osd_data->bvec_pos.iter.bi_size);
+	pr_debug("%s: %p rc %d bytes %u\n",
+		 __func__, inode, rc, osd_data->bvec_pos.iter.bi_size);
 
 	/* r_start_latency == 0 means the request was not submitted */
 	if (req->r_start_latency) {

index b2ff9f03a46e..8658070c59ee 100644
@@ -1832,10 +1832,10 @@ void ceph_queue_writeback(struct inode *inode)
 	ihold(inode);
 	if (queue_work(ceph_inode_to_client(inode)->inode_wq,
 		       &ci->i_work)) {
-		pr_debug("ceph_queue_writeback %p\n", inode);
+		pr_debug("%s: %p\n", __func__, inode);
 	} else {
-		pr_debug("ceph_queue_writeback %p already queued, mask=%lx\n",
-			 inode, ci->i_work_mask);
+		pr_debug("%s: %p already queued, mask=%lx\n",
+			 __func__, inode, ci->i_work_mask);
 		iput(inode);
 	}
 }

@@ -1851,10 +1851,10 @@ void ceph_queue_invalidate(struct inode *inode)
 	ihold(inode);
 	if (queue_work(ceph_inode_to_client(inode)->inode_wq,
 		       &ceph_inode(inode)->i_work)) {
-		pr_debug("ceph_queue_invalidate %p\n", inode);
+		pr_debug("%s: %p\n", __func__, inode);
 	} else {
-		pr_debug("ceph_queue_invalidate %p already queued, mask=%lx\n",
-			 inode, ci->i_work_mask);
+		pr_debug("%s: %p already queued, mask=%lx\n",
+			 __func__, inode, ci->i_work_mask);
 		iput(inode);
 	}
 }

@@ -1871,10 +1871,10 @@ void ceph_queue_vmtruncate(struct inode *inode)
 	ihold(inode);
 	if (queue_work(ceph_inode_to_client(inode)->inode_wq,
 		       &ci->i_work)) {
-		pr_debug("ceph_queue_vmtruncate %p\n", inode);
+		pr_debug("%s: %p\n", __func__, inode);
 	} else {
-		pr_debug("ceph_queue_vmtruncate %p already queued, mask=%lx\n",
-			 inode, ci->i_work_mask);
+		pr_debug("%s: %p already queued, mask=%lx\n",
+			 __func__, inode, ci->i_work_mask);
 		iput(inode);
 	}
 }

index 8f6819d2dc99..a414b8d51c3d 100644
@@ -98,8 +98,8 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode,
 
 	owner = secure_addr(fl->fl_owner);
 
-	pr_debug("ceph_lock_message: rule: %d, op: %d, owner: %llx, pid: %llu, start: %llu, length: %llu, wait: %d, type: %d\n",
-		 (int)lock_type,
+	pr_debug("%s: rule: %d, op: %d, owner: %llx, pid: %llu, start: %llu, length: %llu, wait: %d, type: %d\n",
+		 __func__, (int)lock_type,
 		 (int)operation, owner, (u64)fl->fl_pid, fl->fl_start, length,
 		 wait, fl->fl_type);
 

@@ -134,8 +134,8 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode,
 
 	}
 	ceph_mdsc_put_request(req);
-	pr_debug("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, length: %llu, wait: %d, type: %d, err code %d\n",
-		 (int)lock_type,
+	pr_debug("%s: rule: %d, op: %d, pid: %llu, start: %llu, length: %llu, wait: %d, type: %d, err code %d\n",
+		 __func__, (int)lock_type,
 		 (int)operation, (u64)fl->fl_pid, fl->fl_start,
 		 length, wait, fl->fl_type, err);
 	return err;

@@ -161,8 +161,7 @@ static int ceph_lock_wait_for_completion(struct ceph_mds_client *mdsc,
 	if (!err)
 		return 0;
 
-	pr_debug("ceph_lock_wait_for_completion: request %llu was interrupted\n",
-		 req->r_tid);
+	pr_debug("%s: request %llu was interrupted\n", __func__, req->r_tid);
 
 	mutex_lock(&mdsc->mutex);
 	if (test_bit(CEPH_MDS_R_GOT_RESULT, &req->r_req_flags)) {

@@ -244,7 +243,7 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl)
 	if (__mandatory_lock(file->f_mapping->host) && fl->fl_type != F_UNLCK)
 		return -ENOLCK;
 
-	pr_debug("ceph_lock, fl_owner: %p\n", fl->fl_owner);
+	pr_debug("%s: fl_owner: %p\n", __func__, fl->fl_owner);
 
 	/* set wait bit as appropriate, then make command as Ceph expects it*/
 	if (IS_GETLK(cmd))

@@ -309,7 +308,7 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl)
 	if (fl->fl_type & LOCK_MAND)
 		return -EOPNOTSUPP;
 
-	pr_debug("ceph_flock, fl_file: %p\n", fl->fl_file);
+	pr_debug("%s: fl_file: %p\n", __func__, fl->fl_file);
 
 	spin_lock(&ci->i_ceph_lock);
 	if (ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) {

278 lines not on this page · raw message

index 73ccfd4172ac..5f22df095acd 100644
@@ -281,8 +281,8 @@ static int adjust_snap_realm_parent(struct ceph_mds_client *mdsc,
 		if (IS_ERR(parent))
 			return PTR_ERR(parent);
 	}
-	pr_debug("adjust_snap_realm_parent %llx %p: %llx %p -> %llx %p\n",
-		 realm->ino, realm, realm->parent_ino, realm->parent,
+	pr_debug("%s: %llx %p: %llx %p -> %llx %p\n",
+		 __func__, realm->ino, realm, realm->parent_ino, realm->parent,
 		 parentino, parent);
 	if (realm->parent) {
 		list_del_init(&realm->child_item);

@@ -338,8 +338,8 @@ static int build_snap_context(struct ceph_snap_realm *realm,
 	    realm->cached_context->seq == realm->seq &&
 	    (!parent ||
 	     realm->cached_context->seq >= parent->cached_context->seq)) {
-		pr_debug("build_snap_context %llx %p: %p seq %lld (%u snaps) (unchanged)\n",
-			 realm->ino, realm, realm->cached_context,
+		pr_debug("%s: %llx %p: %p seq %lld (%u snaps) (unchanged)\n",
+			 __func__, realm->ino, realm, realm->cached_context,
 			 realm->cached_context->seq,
 			 (unsigned int)realm->cached_context->num_snaps);
 		return 0;

@@ -378,8 +378,8 @@ static int build_snap_context(struct ceph_snap_realm *realm,
 
 	sort(snapc->snaps, num, sizeof(u64), cmpu64_rev, NULL);
 	snapc->num_snaps = num;
-	pr_debug("build_snap_context %llx %p: %p seq %lld (%u snaps)\n",
-		 realm->ino, realm, snapc, snapc->seq,
+	pr_debug("%s: %llx %p: %p seq %lld (%u snaps)\n",
+		 __func__, realm->ino, realm, snapc, snapc->seq,
 		 (unsigned int)snapc->num_snaps);
 
 	ceph_put_snap_context(realm->cached_context);

@@ -410,7 +410,7 @@ static void rebuild_snap_realms(struct ceph_snap_realm *realm,
 {
 	struct ceph_snap_realm *child;
 
-	pr_debug("rebuild_snap_realms %llx %p\n", realm->ino, realm);
+	pr_debug("%s: %llx %p\n", __func__, realm->ino, realm);
 	build_snap_context(realm, dirty_realms);
 
 	list_for_each_entry(child, &realm->children, child_item)

@@ -646,7 +646,7 @@ static void queue_realm_cap_snaps(struct ceph_snap_realm *realm)
 	struct ceph_inode_info *ci;
 	struct inode *lastinode = NULL;
 
-	pr_debug("queue_realm_cap_snaps %p %llx inodes\n", realm, realm->ino);
+	pr_debug("%s: %p %llx inodes\n", __func__, realm, realm->ino);
 
 	spin_lock(&realm->inodes_with_caps_lock);
 	list_for_each_entry(ci, &realm->inodes_with_caps, i_snap_realm_item) {

@@ -664,7 +664,7 @@ static void queue_realm_cap_snaps(struct ceph_snap_realm *realm)
 	spin_unlock(&realm->inodes_with_caps_lock);
 	ceph_async_iput(lastinode);
 
-	pr_debug("queue_realm_cap_snaps %p %llx done\n", realm, realm->ino);
+	pr_debug("%s: %p %llx done\n", __func__, realm, realm->ino);
 }
 
 /*

@@ -805,7 +805,7 @@ static void flush_snaps(struct ceph_mds_client *mdsc)
 	struct inode *inode;
 	struct ceph_mds_session *session = NULL;
 
-	pr_debug("flush_snaps\n");
+	pr_debug("%s\n", __func__);
 	spin_lock(&mdsc->snap_flush_lock);
 	while (!list_empty(&mdsc->snap_flush_list)) {
 		ci = list_first_entry(&mdsc->snap_flush_list,

@@ -825,7 +825,7 @@ static void flush_snaps(struct ceph_mds_client *mdsc)
 		mutex_unlock(&session->s_mutex);
 		ceph_put_mds_session(session);
 	}
-	pr_debug("flush_snaps done\n");
+	pr_debug("%s done\n", __func__);
 }
 
 

index 08dc6052d2b6..e7f079ebfbc4 100644
@@ -726,7 +726,7 @@ static void destroy_fs_client(struct ceph_fs_client *fsc)
 	ceph_destroy_client(fsc->client);
 
 	kfree(fsc);
-	pr_debug("destroy_fs_client %p done\n", fsc);
+	pr_debug("%s: %p done\n", __func__, fsc);
 }
 
 /*

@@ -841,7 +841,7 @@ static void ceph_umount_begin(struct super_block *sb)
 {
 	struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
 
-	pr_debug("ceph_umount_begin - starting forced umount\n");
+	pr_debug("%s: starting forced umount\n", __func__);
 	if (!fsc)
 		return;
 	fsc->mount_state = CEPH_MOUNT_SHUTDOWN;

@@ -1001,7 +1001,7 @@ static int ceph_compare_super(struct super_block *sb, struct fs_context *fc)
 	struct ceph_options *opt = new->client->options;
 	struct ceph_fs_client *other = ceph_sb_to_client(sb);
 
-	pr_debug("ceph_compare_super %p\n", sb);
+	pr_debug("%s: %p\n", __func__, sb);
 
 	if (compare_mount_options(fsopt, opt, other)) {
 		pr_debug("monitor(s)/mount options don't match\n");

@@ -1052,7 +1052,7 @@ static int ceph_get_tree(struct fs_context *fc)
 		ceph_compare_super;
 	int err;
 
-	pr_debug("ceph_get_tree\n");
+	pr_debug("%s\n", __func__);
 
 	if (!fc->source)
 		return invalfc(fc, "No source");

@@ -1115,7 +1115,7 @@ static int ceph_get_tree(struct fs_context *fc)
 out:
 	destroy_fs_client(fsc);
 out_final:
-	pr_debug("ceph_get_tree fail %d\n", err);
+	pr_debug("%s: fail %d\n", __func__, err);
 	return err;
 }
 

index 503d1edeb28d..6cdf6866c745 100644
@@ -68,7 +68,7 @@ static ssize_t ceph_vxattrcb_layout(struct ceph_inode_info *ci, char *val,
 
 	pool_ns = ceph_try_get_string(ci->i_layout.pool_ns);
 
-	pr_debug("ceph_vxattrcb_layout %p\n", &ci->vfs_inode);
+	pr_debug("%s: %p\n", __func__, &ci->vfs_inode);
 	down_read(&osdc->lock);
 	pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool);
 	if (pool_name) {

@@ -492,7 +492,7 @@ static int __set_xattr(struct ceph_inode_info *ci,
 		xattr->should_free_name = update_xattr;
 
 		ci->i_xattrs.count++;
-		pr_debug("__set_xattr count=%d\n", ci->i_xattrs.count);
+		pr_debug("%s: count=%d\n", __func__, ci->i_xattrs.count);
 	} else {
 		kfree(*newxattr);
 		*newxattr = NULL;

@@ -551,13 +551,13 @@ static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci,
 		else if (c > 0)
 			p = &(*p)->rb_right;
 		else {
-			pr_debug("__get_xattr %s: found %.*s\n",
-				 name, xattr->val_len, xattr->val);
+			pr_debug("%s: %s: found %.*s\n",
+				 __func__, name, xattr->val_len, xattr->val);
 			return xattr;
 		}
 	}
 
-	pr_debug("__get_xattr %s: not found\n", name);
+	pr_debug("%s: %s: not found\n", __func__, name);
 
 	return NULL;
 }

@@ -602,7 +602,7 @@ static char *__copy_xattr_names(struct ceph_inode_info *ci,
 	struct ceph_inode_xattr *xattr = NULL;
 
 	p = rb_first(&ci->i_xattrs.index);
-	pr_debug("__copy_xattr_names count=%d\n", ci->i_xattrs.count);
+	pr_debug("%s: count=%d\n", __func__, ci->i_xattrs.count);
 
 	while (p) {
 		xattr = rb_entry(p, struct ceph_inode_xattr, node);

@@ -627,14 +627,14 @@ void __ceph_destroy_xattrs(struct ceph_inode_info *ci)
 
 	p = rb_first(&ci->i_xattrs.index);
 
-	pr_debug("__ceph_destroy_xattrs p=%p\n", p);
+	pr_debug("%s: p=%p\n", __func__, p);
 
 	while (p) {
 		xattr = rb_entry(p, struct ceph_inode_xattr, node);
 		tmp = p;
 		p = rb_next(tmp);
-		pr_debug("__ceph_destroy_xattrs next p=%p (%.*s)\n",
-			 p, xattr->name_len, xattr->name);
+		pr_debug("%s: next p=%p (%.*s)\n",
+			 __func__, p, xattr->name_len, xattr->name);
 		rb_erase(tmp, &ci->i_xattrs.index);
 
 		__free_xattr(xattr);

@@ -662,7 +662,8 @@ static int __build_xattrs(struct inode *inode)
 	int err = 0;
 	int i;
 
-	pr_debug("__build_xattrs() len=%d\n",
+	pr_debug("%s: len=%d\n",
+		 __func__,
 		 ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0);
 
 	if (ci->i_xattrs.index_version >= ci->i_xattrs.version)

@@ -745,8 +746,8 @@ static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size,
 	int size = 4 + ci->i_xattrs.count*(4 + 4) +
 			     ci->i_xattrs.names_size +
 			     ci->i_xattrs.vals_size;
-	pr_debug("__get_required_blob_size c=%d names.size=%d vals.size=%d\n",
-		 ci->i_xattrs.count, ci->i_xattrs.names_size,
+	pr_debug("%s: c=%d names.size=%d vals.size=%d\n",
+		 __func__, ci->i_xattrs.count, ci->i_xattrs.names_size,
 		 ci->i_xattrs.vals_size);
 
 	if (name_size)

index 6ea761c84494..12ae6f7874fb 100644
@@ -84,8 +84,8 @@ static int ceph_set_page_dirty(struct page *page)
 		return !TestSetPageDirty(page);
 
 	if (PageDirty(page)) {
-		dout("%p set_page_dirty %p idx %lu -- already dirty\n",
-		     mapping->host, page, page->index);
+		pr_debug("%p set_page_dirty %p idx %lu -- already dirty\n",
+			 mapping->host, page, page->index);
 		BUG_ON(!PagePrivate(page));
 		return 0;
 	}

@@ -111,12 +111,11 @@ static int ceph_set_page_dirty(struct page *page)
 	if (ci->i_wrbuffer_ref == 0)
 		ihold(inode);
 	++ci->i_wrbuffer_ref;
-	dout("%p set_page_dirty %p idx %lu head %d/%d -> %d/%d "
-	     "snapc %p seq %lld (%d snaps)\n",
-	     mapping->host, page, page->index,
-	     ci->i_wrbuffer_ref-1, ci->i_wrbuffer_ref_head-1,
-	     ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head,
-	     snapc, snapc->seq, snapc->num_snaps);
+	pr_debug("%p set_page_dirty %p idx %lu head %d/%d -> %d/%d snapc %p seq %lld (%d snaps)\n",
+		 mapping->host, page, page->index,
+		 ci->i_wrbuffer_ref - 1, ci->i_wrbuffer_ref_head - 1,
+		 ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head,
+		 snapc, snapc->seq, snapc->num_snaps);
 	spin_unlock(&ci->i_ceph_lock);
 
 	/*

@@ -150,8 +149,8 @@ static void ceph_invalidatepage(struct page *page, unsigned int offset,
 	ci = ceph_inode(inode);
 
 	if (offset != 0 || length != PAGE_SIZE) {
-		dout("%p invalidatepage %p idx %lu partial dirty page %u~%u\n",
-		     inode, page, page->index, offset, length);
+		pr_debug("%p invalidatepage %p idx %lu partial dirty page %u~%u\n",
+			 inode, page, page->index, offset, length);
 		return;
 	}
 

@@ -161,8 +160,8 @@ static void ceph_invalidatepage(struct page *page, unsigned int offset,
 	if (!PagePrivate(page))
 		return;
 
-	dout("%p invalidatepage %p idx %lu full dirty page\n",
-	     inode, page, page->index);
+	pr_debug("%p invalidatepage %p idx %lu full dirty page\n",
+		 inode, page, page->index);
 
 	ceph_put_wrbuffer_cap_refs(ci, 1, snapc);
 	ceph_put_snap_context(snapc);

@@ -172,8 +171,9 @@ static void ceph_invalidatepage(struct page *page, unsigned int offset,
 
 static int ceph_releasepage(struct page *page, gfp_t g)
 {
-	dout("%p releasepage %p idx %lu (%sdirty)\n", page->mapping->host,
-	     page, page->index, PageDirty(page) ? "" : "not ");
+	pr_debug("%p releasepage %p idx %lu (%sdirty)\n",
+		 page->mapping->host, page, page->index,
+		 PageDirty(page) ? "" : "not ");
 
 	/* Can we release the page from the cache? */
 	if (!ceph_release_fscache_page(page, g))

@@ -198,8 +198,8 @@ static int ceph_sync_readpages(struct ceph_fs_client *fsc,
 	struct ceph_osd_request *req;
 	int rc = 0;
 
-	dout("readpages on ino %llx.%llx on %llu~%llu\n", vino.ino,
-	     vino.snap, off, *plen);
+	pr_debug("readpages on ino %llx.%llx on %llu~%llu\n",
+		 vino.ino, vino.snap, off, *plen);
 	req = ceph_osdc_new_request(osdc, layout, vino, off, plen, 0, 1,
 				    CEPH_OSD_OP_READ, CEPH_OSD_FLAG_READ,
 				    NULL, truncate_seq, truncate_size,

@@ -211,8 +211,8 @@ static int ceph_sync_readpages(struct ceph_fs_client *fsc,
 	osd_req_op_extent_osd_data_pages(req, 0,
 				pages, *plen, page_align, false, false);
 
-	dout("readpages  final extent is %llu~%llu (%llu bytes align %d)\n",
-	     off, *plen, *plen, page_align);
+	pr_debug("readpages final extent is %llu~%llu (%llu bytes align %d)\n",
+		 off, *plen, *plen, page_align);
 
 	rc = ceph_osdc_start_request(osdc, req, false);
 	if (!rc)

@@ -222,7 +222,7 @@ static int ceph_sync_readpages(struct ceph_fs_client *fsc,
 				 req->r_end_latency, rc);
 
 	ceph_osdc_put_request(req);
-	dout("readpages result %d\n", rc);
+	pr_debug("readpages result %d\n", rc);
 	return rc;
 }
 

@@ -260,8 +260,8 @@ static int ceph_do_readpage(struct file *filp, struct page *page)
 	if (err == 0)
 		return -EINPROGRESS;
 
-	dout("readpage inode %p file %p page %p index %lu\n",
-	     inode, filp, page, page->index);
+	pr_debug("readpage inode %p file %p page %p index %lu\n",
+		 inode, filp, page, page->index);
 	err = ceph_sync_readpages(fsc, ceph_vino(inode),
 				  &ci->i_layout, off, &len,
 				  ci->i_truncate_seq, ci->i_truncate_size,

@@ -311,7 +311,8 @@ static void finish_read(struct ceph_osd_request *req)
 	int num_pages;
 	int i;
 
-	dout("finish_read %p req %p rc %d bytes %d\n", inode, req, rc, bytes);
+	pr_debug("finish_read %p req %p rc %d bytes %d\n",
+		 inode, req, rc, bytes);
 	if (rc == -EBLACKLISTED)
 		ceph_inode_to_client(inode)->blacklisted = true;
 

@@ -332,8 +333,8 @@ static void finish_read(struct ceph_osd_request *req)
 			int s = bytes < 0 ? 0 : bytes;
 			zero_user_segment(page, s, PAGE_SIZE);
 		}
- 		dout("finish_read %p uptodate %p idx %lu\n", inode, page,
-		     page->index);
+		pr_debug("finish_read %p uptodate %p idx %lu\n",
+			 inode, page, page->index);
 		flush_dcache_page(page);
 		SetPageUptodate(page);
 		ceph_readpage_to_fscache(inode, page);

@@ -378,9 +379,9 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 		ret = ceph_try_get_caps(inode, CEPH_CAP_FILE_RD, want,
 					true, &got);
 		if (ret < 0) {
-			dout("start_read %p, error getting cap\n", inode);
+			pr_debug("start_read %p, error getting cap\n", inode);
 		} else if (!(got & want)) {
-			dout("start_read %p, no cache cap\n", inode);
+			pr_debug("start_read %p, no cache cap\n", inode);
 			ret = 0;
 		}
 		if (ret <= 0) {

@@ -408,8 +409,8 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 			break;
 	}
 	len = nr_pages << PAGE_SHIFT;
-	dout("start_read %p nr_pages %d is %lld~%lld\n", inode, nr_pages,
-	     off, len);
+	pr_debug("start_read %p nr_pages %d is %lld~%lld\n",
+		 inode, nr_pages, off, len);
 	vino = ceph_vino(inode);
 	req = ceph_osdc_new_request(osdc, &ci->i_layout, vino, off, &len,
 				    0, 1, CEPH_OSD_OP_READ,

@@ -433,14 +434,14 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 		BUG_ON(PageLocked(page));
 		list_del(&page->lru);
 
- 		dout("start_read %p adding %p idx %lu\n", inode, page,
-		     page->index);
+		pr_debug("start_read %p adding %p idx %lu\n",
+			 inode, page, page->index);
 		if (add_to_page_cache_lru(page, &inode->i_data, page->index,
 					  GFP_KERNEL)) {
 			ceph_fscache_uncache_page(inode, page);
 			put_page(page);
-			dout("start_read %p add_to_page_cache failed %p\n",
-			     inode, page);
+			pr_debug("start_read %p add_to_page_cache failed %p\n",
+				 inode, page);
 			nr_pages = i;
 			if (nr_pages > 0) {
 				len = nr_pages << PAGE_SHIFT;

@@ -455,7 +456,7 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx,
 	req->r_callback = finish_read;
 	req->r_inode = inode;
 
-	dout("start_read %p starting %p %lld~%lld\n", inode, req, off, len);
+	pr_debug("start_read %p starting %p %lld~%lld\n", inode, req, off, len);
 	ret = ceph_osdc_start_request(osdc, req, false);
 	if (ret < 0)
 		goto out_pages;

@@ -508,8 +509,8 @@ static int ceph_readpages(struct file *file, struct address_space *mapping,
 
 	rw_ctx = ceph_find_rw_context(fi);
 	max = fsc->mount_options->rsize >> PAGE_SHIFT;
-	dout("readpages %p file %p ctx %p nr_pages %d max %d\n",
-	     inode, file, rw_ctx, nr_pages, max);
+	pr_debug("readpages %p file %p ctx %p nr_pages %d max %d\n",
+		 inode, file, rw_ctx, nr_pages, max);
 	while (!list_empty(page_list)) {
 		rc = start_read(inode, rw_ctx, page_list, max);
 		if (rc < 0)

@@ -518,7 +519,7 @@ static int ceph_readpages(struct file *file, struct address_space *mapping,
 out:
 	ceph_fscache_readpages_cancel(inode, page_list);
 
-	dout("readpages %p file %p ret %d\n", inode, file, rc);
+	pr_debug("readpages %p file %p ret %d\n", inode, file, rc);
 	return rc;
 }
 

@@ -545,8 +546,8 @@ get_oldest_context(struct inode *inode, struct ceph_writeback_ctl *ctl,
 
 	spin_lock(&ci->i_ceph_lock);
 	list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
-		dout(" cap_snap %p snapc %p has %d dirty pages\n", capsnap,
-		     capsnap->context, capsnap->dirty_pages);
+		pr_debug("cap_snap %p snapc %p has %d dirty pages\n",
+			 capsnap, capsnap->context, capsnap->dirty_pages);
 		if (!capsnap->dirty_pages)
 			continue;
 

@@ -578,8 +579,8 @@ get_oldest_context(struct inode *inode, struct ceph_writeback_ctl *ctl,
 	}
 	if (!snapc && ci->i_wrbuffer_ref_head) {
 		snapc = ceph_get_snap_context(ci->i_head_snapc);
-		dout(" head snapc %p has %d dirty pages\n",
-		     snapc, ci->i_wrbuffer_ref_head);
+		pr_debug("head snapc %p has %d dirty pages\n",
+			 snapc, ci->i_wrbuffer_ref_head);
 		if (ctl) {
 			ctl->i_size = i_size_read(inode);
 			ctl->truncate_size = ci->i_truncate_size;

@@ -646,7 +647,7 @@ static int ceph_sync_writepages(struct ceph_fs_client *fsc,
 	/* it may be a short write due to an object boundary */
 	osd_req_op_extent_osd_data_pages(req, 0, pages, len, page_align,
 				false, false);
-	dout("writepages %llu~%llu (%llu bytes)\n", off, len, len);
+	pr_debug("writepages %llu~%llu (%llu bytes)\n", off, len, len);
 
 	req->r_mtime = *mtime;
 	rc = ceph_osdc_start_request(osdc, req, true);

@@ -659,7 +660,7 @@ static int ceph_sync_writepages(struct ceph_fs_client *fsc,
 	ceph_osdc_put_request(req);
 	if (rc == 0)
 		rc = len;
-	dout("writepages result %d\n", rc);
+	pr_debug("writepages result %d\n", rc);
 	return rc;
 }
 

@@ -679,7 +680,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 	int err, len = PAGE_SIZE;
 	struct ceph_writeback_ctl ceph_wbc;
 
-	dout("writepage %p idx %lu\n", page, page->index);
+	pr_debug("writepage %p idx %lu\n", page, page->index);
 
 	inode = page->mapping->host;
 	ci = ceph_inode(inode);

@@ -688,13 +689,13 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 	/* verify this is a writeable snap context */
 	snapc = page_snap_context(page);
 	if (!snapc) {
-		dout("writepage %p page %p not dirty?\n", inode, page);
+		pr_debug("writepage %p page %p not dirty?\n", inode, page);
 		return 0;
 	}
 	oldest = get_oldest_context(inode, &ceph_wbc, snapc);
 	if (snapc->seq > oldest->seq) {
-		dout("writepage %p page %p snapc %p not writeable - noop\n",
-		     inode, page, snapc);
+		pr_debug("writepage %p page %p snapc %p not writeable - noop\n",
+			 inode, page, snapc);
 		/* we should only noop if called by kswapd */
 		WARN_ON(!(current->flags & PF_MEMALLOC));
 		ceph_put_snap_context(oldest);

@@ -705,7 +706,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 
 	/* is this a partial page at end of file? */
 	if (page_off >= ceph_wbc.i_size) {
-		dout("%p page eof %llu\n", page, ceph_wbc.i_size);
+		pr_debug("%p page eof %llu\n", page, ceph_wbc.i_size);
 		page->mapping->a_ops->invalidatepage(page, 0, PAGE_SIZE);
 		return 0;
 	}

@@ -713,8 +714,8 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 	if (ceph_wbc.i_size < page_off + len)
 		len = ceph_wbc.i_size - page_off;
 
-	dout("writepage %p page %p index %lu on %llu~%u snapc %p seq %lld\n",
-	     inode, page, page->index, page_off, len, snapc, snapc->seq);
+	pr_debug("writepage %p page %p index %lu on %llu~%u snapc %p seq %lld\n",
+		 inode, page, page->index, page_off, len, snapc, snapc->seq);
 
 	if (atomic_long_inc_return(&fsc->writeback_count) >
 	    CONGESTION_ON_THRESH(fsc->mount_options->congestion_kb))

@@ -732,19 +733,19 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 			wbc = &tmp_wbc;
 		if (err == -ERESTARTSYS) {
 			/* killed by SIGKILL */
-			dout("writepage interrupted page %p\n", page);
+			pr_debug("writepage interrupted page %p\n", page);
 			redirty_page_for_writepage(wbc, page);
 			end_page_writeback(page);
 			return err;
 		}
 		if (err == -EBLACKLISTED)
 			fsc->blacklisted = true;
-		dout("writepage setting page/mapping error %d %p\n",
-		     err, page);
+		pr_debug("writepage setting page/mapping error %d %p\n",
+			 err, page);
 		mapping_set_error(&inode->i_data, err);
 		wbc->pages_skipped++;
 	} else {
-		dout("writepage cleaned page %p\n", page);
+		pr_debug("writepage cleaned page %p\n", page);
 		err = 0;  /* vfs expects us to return 0 */
 	}
 	page->private = 0;

@@ -797,7 +798,7 @@ static void writepages_finish(struct ceph_osd_request *req)
 	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
 	bool remove_page;
 
-	dout("writepages_finish %p rc %d\n", inode, rc);
+	pr_debug("writepages_finish %p rc %d\n", inode, rc);
 	if (rc < 0) {
 		mapping_set_error(mapping, rc);
 		ceph_set_error_write(ci);

@@ -843,7 +844,7 @@ static void writepages_finish(struct ceph_osd_request *req)
 			ceph_put_snap_context(page_snap_context(page));
 			page->private = 0;
 			ClearPagePrivate(page);
-			dout("unlocking %p\n", page);
+			pr_debug("unlocking %p\n", page);
 			end_page_writeback(page);
 
 			if (remove_page)

@@ -852,8 +853,8 @@ static void writepages_finish(struct ceph_osd_request *req)
 
 			unlock_page(page);
 		}
-		dout("writepages_finish %p wrote %llu bytes cleaned %d pages\n",
-		     inode, osd_data->length, rc >= 0 ? num_pages : 0);
+		pr_debug("writepages_finish %p wrote %llu bytes cleaned %d pages\n",
+			 inode, osd_data->length, rc >= 0 ? num_pages : 0);
 
 		release_pages(osd_data->pages, num_pages);
 	}

@@ -888,9 +889,10 @@ static int ceph_writepages_start(struct address_space *mapping,
 	bool should_loop, range_whole = false;
 	bool done = false;
 
-	dout("writepages_start %p (mode=%s)\n", inode,
-	     wbc->sync_mode == WB_SYNC_NONE ? "NONE" :
-	     (wbc->sync_mode == WB_SYNC_ALL ? "ALL" : "HOLD"));
+	pr_debug("writepages_start %p (mode=%s)\n",
+		 inode,
+		 wbc->sync_mode == WB_SYNC_NONE ? "NONE" :
+		 wbc->sync_mode == WB_SYNC_ALL ? "ALL" : "HOLD");
 
 	if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
 		if (ci->i_wrbuffer_ref > 0) {

@@ -915,11 +917,11 @@ static int ceph_writepages_start(struct address_space *mapping,
 	if (!snapc) {
 		/* hmm, why does writepages get called when there
 		   is no dirty data? */
-		dout(" no snap context with dirty data?\n");
+		pr_debug("no snap context with dirty data?\n");
 		goto out;
 	}
-	dout(" oldest snapc is %p seq %lld (%d snaps)\n",
-	     snapc, snapc->seq, snapc->num_snaps);
+	pr_debug("oldest snapc is %p seq %lld (%d snaps)\n",
+		 snapc, snapc->seq, snapc->num_snaps);
 
 	should_loop = false;
 	if (ceph_wbc.head_snapc && snapc != last_snapc) {

@@ -929,13 +931,13 @@ static int ceph_writepages_start(struct address_space *mapping,
 			end = -1;
 			if (index > 0)
 				should_loop = true;
-			dout(" cyclic, start at %lu\n", index);
+			pr_debug("cyclic, start at %lu\n", index);
 		} else {
 			index = wbc->range_start >> PAGE_SHIFT;
 			end = wbc->range_end >> PAGE_SHIFT;
 			if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
 				range_whole = true;
-			dout(" not cyclic, %lu to %lu\n", index, end);
+			pr_debug("not cyclic, %lu to %lu\n", index, end);
 		}
 	} else if (!ceph_wbc.head_snapc) {
 		/* Do not respect wbc->range_{start,end}. Dirty pages

@@ -944,7 +946,7 @@ static int ceph_writepages_start(struct address_space *mapping,
 		 * associated with 'snapc' get written */
 		if (index > 0)
 			should_loop = true;
-		dout(" non-head snapc, range whole\n");
+		pr_debug("non-head snapc, range whole\n");
 	}
 
 	ceph_put_snap_context(last_snapc);

@@ -965,12 +967,12 @@ static int ceph_writepages_start(struct address_space *mapping,
 		pvec_pages = pagevec_lookup_range_nr_tag(&pvec, mapping, &index,
 						end, PAGECACHE_TAG_DIRTY,
 						max_pages - locked_pages);
-		dout("pagevec_lookup_range_tag got %d\n", pvec_pages);
+		pr_debug("pagevec_lookup_range_tag got %d\n", pvec_pages);
 		if (!pvec_pages && !locked_pages)
 			break;
 		for (i = 0; i < pvec_pages && locked_pages < max_pages; i++) {
 			page = pvec.pages[i];
-			dout("? %p idx %lu\n", page, page->index);
+			pr_debug("? %p idx %lu\n", page, page->index);
 			if (locked_pages == 0)
 				lock_page(page);  /* first page */
 			else if (!trylock_page(page))

@@ -979,15 +981,16 @@ static int ceph_writepages_start(struct address_space *mapping,
 			/* only dirty pages, or our accounting breaks */
 			if (unlikely(!PageDirty(page)) ||
 			    unlikely(page->mapping != mapping)) {
-				dout("!dirty or !mapping %p\n", page);
+				pr_debug("!dirty or !mapping %p\n", page);
 				unlock_page(page);
 				continue;
 			}
 			/* only if matching snap context */
 			pgsnapc = page_snap_context(page);
 			if (pgsnapc != snapc) {
-				dout("page snapc %p %lld != oldest %p %lld\n",
-				     pgsnapc, pgsnapc->seq, snapc, snapc->seq);
+				pr_debug("page snapc %p %lld != oldest %p %lld\n",
+					 pgsnapc, pgsnapc->seq,
+					 snapc, snapc->seq);
 				if (!should_loop &&
 				    !ceph_wbc.head_snapc &&
 				    wbc->sync_mode != WB_SYNC_NONE)

@@ -996,8 +999,8 @@ static int ceph_writepages_start(struct address_space *mapping,
 				continue;
 			}
 			if (page_offset(page) >= ceph_wbc.i_size) {
-				dout("%p page eof %llu\n",
-				     page, ceph_wbc.i_size);
+				pr_debug("%p page eof %llu\n",
+					 page, ceph_wbc.i_size);
 				if ((ceph_wbc.size_stable ||
 				    page_offset(page) >= i_size_read(inode)) &&
 				    clear_page_dirty_for_io(page))

@@ -1007,22 +1010,22 @@ static int ceph_writepages_start(struct address_space *mapping,
 				continue;
 			}
 			if (strip_unit_end && (page->index > strip_unit_end)) {
-				dout("end of strip unit %p\n", page);
+				pr_debug("end of strip unit %p\n", page);
 				unlock_page(page);
 				break;
 			}
 			if (PageWriteback(page)) {
 				if (wbc->sync_mode == WB_SYNC_NONE) {
-					dout("%p under writeback\n", page);
+					pr_debug("%p under writeback\n", page);
 					unlock_page(page);
 					continue;
 				}
-				dout("waiting on writeback %p\n", page);
+				pr_debug("waiting on writeback %p\n", page);
 				wait_on_page_writeback(page);
 			}
 
 			if (!clear_page_dirty_for_io(page)) {
-				dout("%p !clear_page_dirty_for_io\n", page);
+				pr_debug("%p !clear_page_dirty_for_io\n", page);
 				unlock_page(page);
 				continue;
 			}

@@ -1077,8 +1080,8 @@ static int ceph_writepages_start(struct address_space *mapping,
 			}
 
 			/* note position of first page in pvec */
-			dout("%p will write page %p idx %lu\n",
-			     inode, page, page->index);
+			pr_debug("%p will write page %p idx %lu\n",
+				 inode, page, page->index);
 
 			if (atomic_long_inc_return(&fsc->writeback_count) >
 			    CONGESTION_ON_THRESH(

@@ -1111,7 +1114,7 @@ static int ceph_writepages_start(struct address_space *mapping,
 
 			if (pvec_pages && i == pvec_pages &&
 			    locked_pages < max_pages) {
-				dout("reached end pvec, trying for more\n");
+				pr_debug("reached end pvec, trying for more\n");
 				pagevec_release(&pvec);
 				goto get_more_pages;
 			}

@@ -1156,8 +1159,8 @@ static int ceph_writepages_start(struct address_space *mapping,
 					break;
 				osd_req_op_extent_dup_last(req, op_idx,
 							   cur_offset - offset);
-				dout("writepages got pages at %llu~%llu\n",
-				     offset, len);
+				pr_debug("writepages got pages at %llu~%llu\n",
+					 offset, len);
 				osd_req_op_extent_osd_data_pages(req, op_idx,
 							data_pages, len, 0,
 							from_pool, false);

@@ -1184,7 +1187,7 @@ static int ceph_writepages_start(struct address_space *mapping,
 							 offset);
 			len = max(len, min_len);
 		}
-		dout("writepages got pages at %llu~%llu\n", offset, len);
+		pr_debug("writepages got pages at %llu~%llu\n", offset, len);
 
 		osd_req_op_extent_osd_data_pages(req, op_idx, data_pages, len,
 						 0, from_pool, false);

@@ -1237,14 +1240,14 @@ static int ceph_writepages_start(struct address_space *mapping,
 			done = true;
 
 release_pvec_pages:
-		dout("pagevec_release on %d pages (%p)\n", (int)pvec.nr,
-		     pvec.nr ? pvec.pages[0] : NULL);
+		pr_debug("pagevec_release on %d pages (%p)\n",
+			 (int)pvec.nr, pvec.nr ? pvec.pages[0] : NULL);
 		pagevec_release(&pvec);
 	}
 
 	if (should_loop && !done) {
 		/* more to do; loop back to beginning of file */
-		dout("writepages looping back to beginning of file\n");
+		pr_debug("writepages looping back to beginning of file\n");
 		end = start_index - 1; /* OK even when start_index == 0 */
 
 		/* to write dirty pages associated with next snapc,

@@ -1280,7 +1283,7 @@ static int ceph_writepages_start(struct address_space *mapping,
 out:
 	ceph_osdc_put_request(req);
 	ceph_put_snap_context(last_snapc);
-	dout("writepages dend - startone, rc = %d\n", rc);
+	pr_debug("writepages dend - startone, rc = %d\n", rc);
 	return rc;
 }
 

@@ -1322,7 +1325,7 @@ static int ceph_update_writeable_page(struct file *file,
 	struct ceph_snap_context *snapc, *oldest;
 
 	if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
-		dout(" page %p forced umount\n", page);
+		pr_debug("page %p forced umount\n", page);
 		unlock_page(page);
 		return -EIO;
 	}

@@ -1340,8 +1343,8 @@ static int ceph_update_writeable_page(struct file *file,
 		oldest = get_oldest_context(inode, NULL, NULL);
 		if (snapc->seq > oldest->seq) {
 			ceph_put_snap_context(oldest);
-			dout(" page %p snapc %p not current or oldest\n",
-			     page, snapc);
+			pr_debug("page %p snapc %p not current or oldest\n",
+				 page, snapc);
 			/*
 			 * queue for writeback, and wait for snapc to
 			 * be writeable or written

@@ -1359,8 +1362,8 @@ static int ceph_update_writeable_page(struct file *file,
 		ceph_put_snap_context(oldest);
 
 		/* yay, writeable, do it now (without dropping page lock) */
-		dout(" page %p snapc %p not current, but oldest\n",
-		     page, snapc);
+		pr_debug("page %p snapc %p not current, but oldest\n",
+			 page, snapc);
 		if (!clear_page_dirty_for_io(page))
 			goto retry_locked;
 		r = writepage_nounlock(page, NULL);

@@ -1370,7 +1373,7 @@ static int ceph_update_writeable_page(struct file *file,
 	}
 
 	if (PageUptodate(page)) {
-		dout(" page %p already uptodate\n", page);
+		pr_debug("page %p already uptodate\n", page);
 		return 0;
 	}
 

@@ -1384,8 +1387,8 @@ static int ceph_update_writeable_page(struct file *file,
 	if (page_off >= i_size ||
 	    (pos_in_page == 0 && (pos+len) >= i_size &&
 	     end_in_page - pos_in_page != PAGE_SIZE)) {
-		dout(" zeroing %p 0 - %d and %d - %d\n",
-		     page, pos_in_page, end_in_page, (int)PAGE_SIZE);
+		pr_debug("zeroing %p 0 - %d and %d - %d\n",
+			 page, pos_in_page, end_in_page, (int)PAGE_SIZE);
 		zero_user_segments(page,
 				   0, pos_in_page,
 				   end_in_page, PAGE_SIZE);

@@ -1424,8 +1427,8 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping,
 		if (!page)
 			return -ENOMEM;
 
-		dout("write_begin file %p inode %p page %p %d~%d\n", file,
-		     inode, page, (int)pos, (int)len);
+		pr_debug("write_begin file %p inode %p page %p %d~%d\n",
+			 file, inode, page, (int)pos, (int)len);
 
 		r = ceph_update_writeable_page(file, pos, len, page);
 		if (r < 0)

@@ -1448,8 +1451,8 @@ static int ceph_write_end(struct file *file, struct address_space *mapping,
 	struct inode *inode = file_inode(file);
 	bool check_cap = false;
 
-	dout("write_end file %p inode %p page %p %d~%d (%d)\n", file,
-	     inode, page, (int)pos, (int)copied, (int)len);
+	pr_debug("write_end file %p inode %p page %p %d~%d (%d)\n",
+		 file, inode, page, (int)pos, (int)copied, (int)len);
 
 	/* zero the stale part of the page if we did a short copy */
 	if (!PageUptodate(page)) {

@@ -1529,8 +1532,8 @@ static vm_fault_t ceph_filemap_fault(struct vm_fault *vmf)
 
 	ceph_block_sigs(&oldset);
 
-	dout("filemap_fault %p %llx.%llx %llu~%zd trying to get caps\n",
-	     inode, ceph_vinop(inode), off, (size_t)PAGE_SIZE);
+	pr_debug("filemap_fault %p %llx.%llx %llu~%zd trying to get caps\n",
+		 inode, ceph_vinop(inode), off, (size_t)PAGE_SIZE);
 	if (fi->fmode & CEPH_FILE_MODE_LAZY)
 		want = CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO;
 	else

@@ -1542,8 +1545,8 @@ static vm_fault_t ceph_filemap_fault(struct vm_fault *vmf)
 	if (err < 0)
 		goto out_restore;
 
-	dout("filemap_fault %p %llu~%zd got cap refs on %s\n",
-	     inode, off, (size_t)PAGE_SIZE, ceph_cap_string(got));
+	pr_debug("filemap_fault %p %llu~%zd got cap refs on %s\n",
+		 inode, off, (size_t)PAGE_SIZE, ceph_cap_string(got));
 
 	if ((got & (CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO)) ||
 	    ci->i_inline_version == CEPH_INLINE_NONE) {

@@ -1551,9 +1554,9 @@ static vm_fault_t ceph_filemap_fault(struct vm_fault *vmf)
 		ceph_add_rw_context(fi, &rw_ctx);
 		ret = filemap_fault(vmf);
 		ceph_del_rw_context(fi, &rw_ctx);
-		dout("filemap_fault %p %llu~%zd drop cap refs %s ret %x\n",
-			inode, off, (size_t)PAGE_SIZE,
-				ceph_cap_string(got), ret);
+		pr_debug("filemap_fault %p %llu~%zd drop cap refs %s ret %x\n",
+			 inode, off, (size_t)PAGE_SIZE,
+			 ceph_cap_string(got), ret);
 	} else
 		err = -EAGAIN;
 

@@ -1593,8 +1596,8 @@ static vm_fault_t ceph_filemap_fault(struct vm_fault *vmf)
 		vmf->page = page;
 		ret = VM_FAULT_MAJOR | VM_FAULT_LOCKED;
 out_inline:
-		dout("filemap_fault %p %llu~%zd read inline data ret %x\n",
-		     inode, off, (size_t)PAGE_SIZE, ret);
+		pr_debug("filemap_fault %p %llu~%zd read inline data ret %x\n",
+			 inode, off, (size_t)PAGE_SIZE, ret);
 	}
 out_restore:
 	ceph_restore_sigs(&oldset);

@@ -1647,8 +1650,8 @@ static vm_fault_t ceph_page_mkwrite(struct vm_fault *vmf)
 	else
 		len = size & ~PAGE_MASK;
 
-	dout("page_mkwrite %p %llx.%llx %llu~%zd getting caps i_size %llu\n",
-	     inode, ceph_vinop(inode), off, len, size);
+	pr_debug("page_mkwrite %p %llx.%llx %llu~%zd getting caps i_size %llu\n",
+		 inode, ceph_vinop(inode), off, len, size);
 	if (fi->fmode & CEPH_FILE_MODE_LAZY)
 		want = CEPH_CAP_FILE_BUFFER | CEPH_CAP_FILE_LAZYIO;
 	else

@@ -1660,8 +1663,8 @@ static vm_fault_t ceph_page_mkwrite(struct vm_fault *vmf)
 	if (err < 0)
 		goto out_free;
 
-	dout("page_mkwrite %p %llu~%zd got cap refs on %s\n",
-	     inode, off, len, ceph_cap_string(got));
+	pr_debug("page_mkwrite %p %llu~%zd got cap refs on %s\n",
+		 inode, off, len, ceph_cap_string(got));
 
 	/* Update time before taking page lock */
 	file_update_time(vma->vm_file);

@@ -1696,8 +1699,8 @@ static vm_fault_t ceph_page_mkwrite(struct vm_fault *vmf)
 			__mark_inode_dirty(inode, dirty);
 	}
 
-	dout("page_mkwrite %p %llu~%zd dropping cap refs on %s ret %x\n",
-	     inode, off, len, ceph_cap_string(got), ret);
+	pr_debug("page_mkwrite %p %llu~%zd dropping cap refs on %s ret %x\n",
+		 inode, off, len, ceph_cap_string(got), ret);
 	ceph_put_cap_refs(ci, got);
 out_free:
 	ceph_restore_sigs(&oldset);

@@ -1731,8 +1734,8 @@ void ceph_fill_inline_data(struct inode *inode, struct page *locked_page,
 		}
 	}
 
-	dout("fill_inline_data %p %llx.%llx len %zu locked_page %p\n",
-	     inode, ceph_vinop(inode), len, locked_page);
+	pr_debug("fill_inline_data %p %llx.%llx len %zu locked_page %p\n",
+		 inode, ceph_vinop(inode), len, locked_page);
 
 	if (len > 0) {
 		void *kaddr = kmap_atomic(page);

@@ -1767,8 +1770,8 @@ int ceph_uninline_data(struct file *filp, struct page *locked_page)
 	inline_version = ci->i_inline_version;
 	spin_unlock(&ci->i_ceph_lock);
 
-	dout("uninline_data %p %llx.%llx inline_version %llu\n",
-	     inode, ceph_vinop(inode), inline_version);
+	pr_debug("uninline_data %p %llx.%llx inline_version %llu\n",
+		 inode, ceph_vinop(inode), inline_version);
 
 	if (inline_version == 1 || /* initial version, no data */
 	    inline_version == CEPH_INLINE_NONE)

@@ -1884,8 +1887,8 @@ int ceph_uninline_data(struct file *filp, struct page *locked_page)
 			__free_pages(page, 0);
 	}
 
-	dout("uninline_data %p %llx.%llx inline_version %llu = %d\n",
-	     inode, ceph_vinop(inode), inline_version, err);
+	pr_debug("uninline_data %p %llx.%llx inline_version %llu = %d\n",
+		 inode, ceph_vinop(inode), inline_version, err);
 	return err;
 }
 

@@ -1949,10 +1952,11 @@ static int __ceph_pool_perm_get(struct ceph_inode_info *ci,
 		goto out;
 
 	if (pool_ns)
-		dout("__ceph_pool_perm_get pool %lld ns %.*s no perm cached\n",
-		     pool, (int)pool_ns->len, pool_ns->str);
+		pr_debug("__ceph_pool_perm_get pool %lld ns %.*s no perm cached\n",
+			 pool, (int)pool_ns->len, pool_ns->str);
 	else
-		dout("__ceph_pool_perm_get pool %lld no perm cached\n", pool);
+		pr_debug("__ceph_pool_perm_get pool %lld no perm cached\n",
+			 pool);
 
 	down_write(&mdsc->pool_perm_rwsem);
 	p = &mdsc->pool_perm_tree.rb_node;

@@ -2079,10 +2083,11 @@ static int __ceph_pool_perm_get(struct ceph_inode_info *ci,
 	if (!err)
 		err = have;
 	if (pool_ns)
-		dout("__ceph_pool_perm_get pool %lld ns %.*s result = %d\n",
-		     pool, (int)pool_ns->len, pool_ns->str, err);
+		pr_debug("__ceph_pool_perm_get pool %lld ns %.*s result = %d\n",
+			 pool, (int)pool_ns->len, pool_ns->str, err);
 	else
-		dout("__ceph_pool_perm_get pool %lld result = %d\n", pool, err);
+		pr_debug("__ceph_pool_perm_get pool %lld result = %d\n",
+			 pool, err);
 	return err;
 }
 

@@ -2113,13 +2118,13 @@ int ceph_pool_perm_check(struct inode *inode, int need)
 check:
 	if (flags & CEPH_I_POOL_PERM) {
 		if ((need & CEPH_CAP_FILE_RD) && !(flags & CEPH_I_POOL_RD)) {
-			dout("ceph_pool_perm_check pool %lld no read perm\n",
-			     pool);
+			pr_debug("ceph_pool_perm_check pool %lld no read perm\n",
+				 pool);
 			return -EPERM;
 		}
 		if ((need & CEPH_CAP_FILE_WR) && !(flags & CEPH_I_POOL_WR)) {
-			dout("ceph_pool_perm_check pool %lld no write perm\n",
-			     pool);
+			pr_debug("ceph_pool_perm_check pool %lld no write perm\n",
+				 pool);
 			return -EPERM;
 		}
 		return 0;

index 2f5cb6bc78e1..59c1083d00dd 100644
@@ -125,7 +125,7 @@ static enum fscache_checkaux ceph_fscache_inode_check_aux(
 	if (memcmp(data, &aux, sizeof(aux)) != 0)
 		return FSCACHE_CHECKAUX_OBSOLETE;
 
-	dout("ceph inode 0x%p cached okay\n", ci);
+	pr_debug("ceph inode 0x%p cached okay\n", ci);
 	return FSCACHE_CHECKAUX_OKAY;
 }
 

@@ -191,16 +191,16 @@ void ceph_fscache_file_set_cookie(struct inode *inode, struct file *filp)
 		return;
 
 	if (inode_is_open_for_write(inode)) {
-		dout("fscache_file_set_cookie %p %p disabling cache\n",
-		     inode, filp);
+		pr_debug("fscache_file_set_cookie %p %p disabling cache\n",
+			 inode, filp);
 		fscache_disable_cookie(ci->fscache, &ci->i_vino, false);
 		fscache_uncache_all_inode_pages(ci->fscache, inode);
 	} else {
 		fscache_enable_cookie(ci->fscache, &ci->i_vino, i_size_read(inode),
 				      ceph_fscache_can_enable, inode);
 		if (fscache_cookie_enabled(ci->fscache)) {
-			dout("fscache_file_set_cookie %p %p enabling cache\n",
-			     inode, filp);
+			pr_debug("fscache_file_set_cookie %p %p enabling cache\n",
+				 inode, filp);
 		}
 	}
 }

@@ -238,14 +238,14 @@ int ceph_readpage_from_fscache(struct inode *inode, struct page *page)
 
 	switch (ret) {
 		case 0: /* Page found */
-			dout("page read submitted\n");
+			pr_debug("page read submitted\n");
 			return 0;
 		case -ENOBUFS: /* Pages were not found, and can't be */
 		case -ENODATA: /* Pages were not found */
-			dout("page/inode not in cache\n");
+			pr_debug("page/inode not in cache\n");
 			return ret;
 		default:
-			dout("%s: unknown error ret = %i\n", __func__, ret);
+			pr_debug("%s: unknown error ret = %i\n", __func__, ret);
 			return ret;
 	}
 }

@@ -267,14 +267,14 @@ int ceph_readpages_from_fscache(struct inode *inode,
 
 	switch (ret) {
 		case 0: /* All pages found */
-			dout("all-page read submitted\n");
+			pr_debug("all-page read submitted\n");
 			return 0;
 		case -ENOBUFS: /* Some pages were not found, and can't be */
 		case -ENODATA: /* some pages were not found */
-			dout("page/inode not in cache\n");
+			pr_debug("page/inode not in cache\n");
 			return ret;
 		default:
-			dout("%s: unknown error ret = %i\n", __func__, ret);
+			pr_debug("%s: unknown error ret = %i\n", __func__, ret);
 			return ret;
 	}
 }

1,180 lines not on this page · raw message

index 97539b497e4c..244428de3c4b 100644
@@ -324,7 +324,7 @@ DEFINE_SIMPLE_ATTRIBUTE(congestion_kb_fops, congestion_kb_get,
 
 void ceph_fs_debugfs_cleanup(struct ceph_fs_client *fsc)
 {
-	dout("ceph_fs_debugfs_cleanup\n");
+	pr_debug("ceph_fs_debugfs_cleanup\n");
 	debugfs_remove(fsc->debugfs_bdi);
 	debugfs_remove(fsc->debugfs_congestion_kb);
 	debugfs_remove(fsc->debugfs_mdsmap);

@@ -338,7 +338,7 @@ void ceph_fs_debugfs_init(struct ceph_fs_client *fsc)
 {
 	char name[100];
 
-	dout("ceph_fs_debugfs_init\n");
+	pr_debug("ceph_fs_debugfs_init\n");
 	fsc->debugfs_congestion_kb =
 		debugfs_create_file("writeback_congestion_kb",
 				    0600,

393 lines not on this page · raw message

index e088843a7734..fe5c0adb9cc2 100644
@@ -78,7 +78,7 @@ static int ceph_encode_snapfh(struct inode *inode, u32 *rawfh, int *max_len,
 	*max_len = snap_handle_length;
 	ret = FILEID_BTRFS_WITH_PARENT;
 out:
-	dout("encode_snapfh %llx.%llx ret=%d\n", ceph_vinop(inode), ret);
+	pr_debug("encode_snapfh %llx.%llx ret=%d\n", ceph_vinop(inode), ret);
 	return ret;
 }
 

@@ -104,15 +104,15 @@ static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
 
 	if (parent_inode) {
 		struct ceph_nfs_confh *cfh = (void *)rawfh;
-		dout("encode_fh %llx with parent %llx\n",
-		     ceph_ino(inode), ceph_ino(parent_inode));
+		pr_debug("encode_fh %llx with parent %llx\n",
+			 ceph_ino(inode), ceph_ino(parent_inode));
 		cfh->ino = ceph_ino(inode);
 		cfh->parent_ino = ceph_ino(parent_inode);
 		*max_len = connected_handle_length;
 		type = FILEID_INO32_GEN_PARENT;
 	} else {
 		struct ceph_nfs_fh *fh = (void *)rawfh;
-		dout("encode_fh %llx\n", ceph_ino(inode));
+		pr_debug("encode_fh %llx\n", ceph_ino(inode));
 		fh->ino = ceph_ino(inode);
 		*max_len = handle_length;
 		type = FILEID_INO32_GEN;

@@ -255,11 +255,11 @@ static struct dentry *__snapfh_to_dentry(struct super_block *sb,
 	ceph_mdsc_put_request(req);
 
 	if (want_parent) {
-		dout("snapfh_to_parent %llx.%llx\n err=%d\n",
-		     vino.ino, vino.snap, err);
+		pr_debug("snapfh_to_parent %llx.%llx\n err=%d\n",
+			 vino.ino, vino.snap, err);
 	} else {
-		dout("snapfh_to_dentry %llx.%llx parent %llx hash %x err=%d",
-		      vino.ino, vino.snap, sfh->parent_ino, sfh->hash, err);
+		pr_debug("snapfh_to_dentry %llx.%llx parent %llx hash %x err=%d\n",
+			 vino.ino, vino.snap, sfh->parent_ino, sfh->hash, err);
 	}
 	if (!inode)
 		return ERR_PTR(-ESTALE);

@@ -287,7 +287,7 @@ static struct dentry *ceph_fh_to_dentry(struct super_block *sb,
 	if (fh_len < sizeof(*fh) / 4)
 		return NULL;
 
-	dout("fh_to_dentry %llx\n", fh->ino);
+	pr_debug("fh_to_dentry %llx\n", fh->ino);
 	return __fh_to_dentry(sb, fh->ino);
 }
 

@@ -379,8 +379,8 @@ static struct dentry *ceph_get_parent(struct dentry *child)
 		dn = __get_parent(child->d_sb, child, 0);
 	}
 out:
-	dout("get_parent %p ino %llx.%llx err=%ld\n",
-	     child, ceph_vinop(inode), (long)PTR_ERR_OR_ZERO(dn));
+	pr_debug("get_parent %p ino %llx.%llx err=%ld\n",
+		 child, ceph_vinop(inode), (long)PTR_ERR_OR_ZERO(dn));
 	return dn;
 }
 

@@ -404,7 +404,7 @@ static struct dentry *ceph_fh_to_parent(struct super_block *sb,
 	if (fh_len < sizeof(*cfh) / 4)
 		return NULL;
 
-	dout("fh_to_parent %llx\n", cfh->parent_ino);
+	pr_debug("fh_to_parent %llx\n", cfh->parent_ino);
 	dentry = __get_parent(sb, NULL, cfh->ino);
 	if (unlikely(dentry == ERR_PTR(-ENOENT)))
 		dentry = __fh_to_dentry(sb, cfh->parent_ino);

@@ -503,8 +503,8 @@ static int __get_snap_name(struct dentry *parent, char *name,
 	if (req)
 		ceph_mdsc_put_request(req);
 	kfree(last_name);
-	dout("get_snap_name %p ino %llx.%llx err=%d\n",
-	     child, ceph_vinop(inode), err);
+	pr_debug("get_snap_name %p ino %llx.%llx err=%d\n",
+		 child, ceph_vinop(inode), err);
 	return err;
 }
 

@@ -541,11 +541,11 @@ static int ceph_get_name(struct dentry *parent, char *name,
 		struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
 		memcpy(name, rinfo->dname, rinfo->dname_len);
 		name[rinfo->dname_len] = 0;
-		dout("get_name %p ino %llx.%llx name %s\n",
-		     child, ceph_vinop(inode), name);
+		pr_debug("get_name %p ino %llx.%llx name %s\n",
+			 child, ceph_vinop(inode), name);
 	} else {
-		dout("get_name %p ino %llx.%llx err %d\n",
-		     child, ceph_vinop(inode), err);
+		pr_debug("get_name %p ino %llx.%llx err %d\n",
+			 child, ceph_vinop(inode), err);
 	}
 
 	ceph_mdsc_put_request(req);

462 lines not on this page · raw message

95 lines not on this page · raw message

index 6e061bf62ad4..177417c23962 100644

Lines of this file are not shown. View the raw message.

43 lines not on this page · raw message

373 lines not on this page · raw message

index e4aba6c6d3b5..50c3f7f60409 100644

Lines of this file are not shown. View the raw message.

index 2466b261fba2..cb257eee48f8 100644

Lines of this file are not shown. View the raw message.

index 198ddde5c1e6..55bd95f86444 100644

Lines of this file are not shown. View the raw message.

135 lines not on this page · raw message

67 lines not on this page · raw message

63 lines not on this page · raw message

index d5a5da838caf..81c0d7195f1e 100644

Lines of this file are not shown. View the raw message.

index 76371aaae2d1..0a69a4cb8583 100644

Lines of this file are not shown. View the raw message.