kclient review
- andi
- - server-specified max file size
+/ - server-specified max file size
- pr_debug
- top of file comments
&realm->inodes_with_caps);
spin_unlock(&realm->inodes_with_caps_lock);
} else {
- derr(0, "couldn't find snap realm realmino=%llu\n",
- realmino);
+ pr_err("ceph_add_cap: couldn't find snap realm %llu\n",
+ realmino);
}
}
default:
spin_unlock(&inode->i_lock);
- derr(10, " unknown cap op %d %s\n", op, ceph_cap_op_name(op));
+ pr_err("ceph_handle_caps: unknown cap op %d %s\n", op,
+ ceph_cap_op_name(op));
}
done:
return;
bad:
- derr(10, "corrupt caps message\n");
+ pr_err("ceph_handle_caps: corrupt message\n");
return;
}
#define _dout(x, fmt, args...) dout_flag((x), DOUT_MASK, fmt FMT_SUFFIX, args)
-#define _derr(x, fmt, args...) do { \
- printk(KERN_ERR FMT_PREFIX fmt FMT_SUFFIX, LOG_ARGS, args); \
- } while (0)
-
#define dout(x, args...) _dout((x), args, TRAIL_PARAM)
-#define derr(x, args...) _derr((x), args, TRAIL_PARAM)
#endif
inode = ceph_find_inode(sb, fh->ino);
if (!inode) {
struct ceph_mds_request *req;
- derr(10, "fh_to_dentry %llx.%x -- no inode\n", fh->ino.ino,
- hash);
+ pr_err("ceph fh_to_dentry %llx.%x -- no inode\n", fh->ino.ino,
+ hash);
req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPHASH,
USE_ANY_MDS);
if (IS_ERR(req))
#endif
if (!dentry) {
- derr(10, "fh_to_dentry %llx.%x -- inode %p but ENOMEM\n",
- fh->ino.ino,
- hash, inode);
+ pr_err("ceph fh_to_dentry %llx.%x -- inode %p but ENOMEM\n",
+ fh->ino.ino, hash, inode);
iput(inode);
return ERR_PTR(-ENOMEM);
}
u64 ino = get_unaligned((u64 *)fh);
u32 hash = fh[2];
- derr(10, "fh_to_parent %llx.%x\n", (unsigned long long)ino, hash);
+ pr_debug("ceph_fh_to_parent %llx.%x\n", (unsigned long long)ino, hash);
if (fh_len < 6)
return ERR_PTR(-ESTALE);
frag = kmalloc(sizeof(*frag), GFP_NOFS);
if (!frag) {
- derr(0, "ENOMEM on %p %llx.%llx frag %x\n", &ci->vfs_inode,
- ceph_vinop(&ci->vfs_inode), f);
+ pr_err("ceph __get_or_create_frag ENOMEM on %p %llx.%llx "
+ "frag %x\n", &ci->vfs_inode,
+ ceph_vinop(&ci->vfs_inode), f);
return ERR_PTR(-ENOMEM);
}
frag->frag = f;
if (IS_ERR(frag)) {
/* this is not the end of the world; we can continue
with bad/inaccurate delegation info */
- derr(0, "fill_dirfrag ENOMEM on mds ref %llx.%llx frag %x\n",
- ceph_vinop(inode), le32_to_cpu(dirinfo->frag));
+ pr_err("ceph fill_dirfrag ENOMEM on mds ref %llx.%llx fg %x\n",
+ ceph_vinop(inode), le32_to_cpu(dirinfo->frag));
err = -ENOMEM;
goto out;
}
if (iinfo->xattr_len > 4 && iinfo->xattr_len != ci->i_xattrs.len) {
xattr_data = kmalloc(iinfo->xattr_len, GFP_NOFS);
if (!xattr_data)
- derr(10, "ENOMEM on xattr blob %d bytes\n",
- ci->i_xattrs.len);
+ pr_err("ceph fill_inode ENOMEM xattr blob %d bytes\n",
+ ci->i_xattrs.len);
}
spin_lock(&inode->i_lock);
}
break;
default:
- derr(0, "BAD mode 0%o S_IFMT 0%o\n", inode->i_mode,
- inode->i_mode & S_IFMT);
+ pr_err("ceph fill_inode %llx.%llx BAD mode 0%o\n",
+ ceph_vinop(inode), inode->i_mode);
err = -EINVAL;
goto out;
}
d_drop(dn);
realdn = d_materialise_unique(dn, in);
if (IS_ERR(realdn)) {
- derr(0, "error splicing %p (%d) inode %p ino %llx.%llx\n",
- dn, atomic_read(&dn->d_count), in, ceph_vinop(in));
+ pr_err("ceph splice_dentry error %p inode %p ino %llx.%llx\n",
+ dn, in, ceph_vinop(in));
if (prehash)
*prehash = false; /* don't rehash on error */
dn = realdn; /* note realdn contains the error */
if (!dn->d_inode) {
in = ceph_get_inode(sb, vino);
if (IS_ERR(in)) {
- derr(30, "get_inode badness\n");
+ pr_err("ceph fill_trace bad get_inode "
+ "%llx.%llx\n", vino.ino, vino.snap);
err = PTR_ERR(in);
d_delete(dn);
goto done;
vino.snap = le64_to_cpu(ininfo->snapid);
in = ceph_get_inode(sb, vino);
if (IS_ERR(in)) {
- derr(30, "get_inode badness\n");
+ pr_err("ceph fill_inode get_inode badness %llx.%llx\n",
+ vino.ino, vino.snap);
err = PTR_ERR(in);
d_delete(dn);
goto done;
req->r_fmode : -1,
&req->r_caps_reservation);
if (err < 0) {
- derr(30, "fill_inode badness\n");
+ pr_err("ceph fill_inode badness %p %llx.%llx\n",
+ in, ceph_vinop(in));
goto done;
}
}
ci->i_xattrs.vals_size -= xattr->val_len;
}
if (!xattr) {
- derr(0, "ENOMEM on %p %llx.%llx xattr %s=%s\n", &ci->vfs_inode,
- ceph_vinop(&ci->vfs_inode), name, xattr->val);
+ pr_err("ceph __set_xattr ENOMEM on %p %llx.%llx xattr %s=%s\n",
+ &ci->vfs_inode, ceph_vinop(&ci->vfs_inode), name,
+ xattr->val);
return -ENOMEM;
}
ci->i_xattrs.names_size += name_len;
bad:
err = -EIO;
out_bad:
- derr(1, "problem parsing trace %d\n", err);
+ pr_err("ceph problem parsing mds trace %d\n", err);
return err;
}
bad:
err = -EIO;
out_bad:
- derr(1, "problem parsing dir contents %d\n", err);
+ pr_err("ceph problem parsing dir contents %d\n", err);
return err;
}
bad:
err = -EIO;
out_bad:
- derr(1, "parse_reply err %d\n", err);
+ pr_err("ceph mds parse_reply err %d\n", err);
return err;
}
msg = ceph_msg_new(CEPH_MSG_CLIENT_SESSION, sizeof(*h), 0, 0, NULL);
if (IS_ERR(msg)) {
- derr("ENOMEM creating session msg\n");
+ pr_err("ceph create_session_msg ENOMEM creating msg\n");
return ERR_PTR(PTR_ERR(msg));
}
h = msg->front.iov_base;
len += 1 + temp->d_name.len;
temp = temp->d_parent;
if (temp == NULL) {
- derr(1, "corrupt dentry %p\n", dentry);
+ pr_err("ceph build_path_dentry corrupt dentry %p\n",
+ dentry);
return ERR_PTR(-EINVAL);
}
}
path[--pos] = '/';
temp = temp->d_parent;
if (temp == NULL) {
- derr(1, "corrupt dentry\n");
+ pr_err("ceph build_path_dentry corrupt dentry\n");
kfree(path);
return ERR_PTR(-EINVAL);
}
}
if (pos != 0) {
- derr(1, "did not end path lookup where expected, "
- "namelen is %d, pos is %d\n", len, pos);
+ pr_err("ceph build_path_dentry did not end path lookup where "
+ "expected, namelen is %d, pos is %d\n", len, pos);
/* presumably this is only possible if racing with a
rename of one of the parent directories (we can not
lock the dentries above us to prevent this, but
if (le32_to_cpu(msg->hdr.src.name.type) != CEPH_ENTITY_TYPE_MDS)
return;
if (msg->front.iov_len < sizeof(*head)) {
- derr(1, "handle_reply got corrupt (short) reply\n");
+ pr_err("ceph_mdsc_handle_reply got corrupt (short) reply\n");
return;
}
req->r_session = __ceph_lookup_mds_session(mdsc, mds);
}
if (req->r_session == NULL) {
- derr(1, "got reply on %llu, but no session for mds%d\n",
- tid, mds);
+ pr_err("ceph_mdsc_handle_reply got %llu, but no session for"
+ " mds%d\n", tid, mds);
mutex_unlock(&mdsc->mutex);
goto out;
}
rinfo = &req->r_reply_info;
err = parse_reply_info(msg, rinfo);
if (err < 0) {
- derr(0, "handle_reply got corrupt reply\n");
+ pr_err("ceph_mdsc_handle_reply got corrupt reply mds%d\n", mds);
goto out_err;
}
result = le32_to_cpu(rinfo->head->result);
return;
bad:
- derr(0, "problem decoding message, err=%d\n", err);
+ pr_err("ceph_mdsc_handle_forward decode error err=%d\n", err);
}
/*
break;
default:
- derr(0, "bad session op %d from mds%d\n", op, mds);
+ pr_err("ceph_mdsc_handle_session bad op %d mds%d\n", op, mds);
WARN_ON(1);
}
return;
bad:
- derr(1, "corrupt mds%d session message, len %d, expected %d\n", mds,
- (int)msg->front.iov_len, (int)sizeof(*h));
+ pr_err("ceph_mdsc_handle_session corrupt message mds%d len %d\n", mds,
+ (int)msg->front.iov_len);
return;
}
reply = ceph_msg_new(CEPH_MSG_CLIENT_RECONNECT, len, 0, 0, NULL);
if (IS_ERR(reply)) {
err = PTR_ERR(reply);
- derr(0, "ENOMEM trying to send mds reconnect to mds%d\n", mds);
+ pr_err("ceph send_mds_reconnect ENOMEM on %d for mds%d\n",
+ len, mds);
goto out;
}
p = reply->front.iov_base;
*/
void ceph_mdsc_handle_reset(struct ceph_mds_client *mdsc, int mds)
{
- derr(1, "mds%d gave us the boot. IMPLEMENT RECONNECT.\n", mds);
+ pr_err("ceph mds%d gave us the boot. IMPLEMENT RECONNECT.\n", mds);
}
session = __ceph_lookup_mds_session(mdsc, mds);
mutex_unlock(&mdsc->mutex);
if (!session) {
- derr(0, "WTF, got lease but no session for mds%d\n", mds);
+ pr_err("ceph handle_lease got lease but no session mds%d\n",
+ mds);
return;
}
continue;
}
if (s->s_ttl && time_after(jiffies, s->s_ttl)) {
- derr(1, "mds%d session probably timed out, "
- "requesting mds map\n", s->s_mds);
+ pr_info("ceph mds%d session probably timed out, "
+ "requesting mds map\n", s->s_mds);
want_map = mdsc->mdsmap->m_epoch + 1;
}
if (s->s_state < CEPH_MDS_SESSION_OPEN) {
ceph_decode_need(&p, end, sizeof(fsid)+2*sizeof(u32), bad);
ceph_decode_copy(&p, &fsid, sizeof(fsid));
if (ceph_fsid_compare(&fsid, &mdsc->client->monc.monmap->fsid)) {
- derr(0, "got mdsmap with wrong fsid\n");
+ pr_err("ceph got mdsmap with wrong fsid\n");
return;
}
ceph_decode_32(&p, epoch);
bad_unlock:
mutex_unlock(&mdsc->mutex);
bad:
- derr(1, "problem with mdsmap %d\n", err);
+ pr_err("ceph error decoding mdsmap %d\n", err);
return;
}
badmem:
err = -ENOMEM;
bad:
- derr(0, "corrupt mdsmap\n");
+ pr_err("ceph corrupt mdsmap\n");
ceph_mdsmap_destroy(m);
return ERR_PTR(-EINVAL);
}
ceph_msgr_wq = create_workqueue("ceph-msgr");
if (IS_ERR(ceph_msgr_wq)) {
int ret = PTR_ERR(ceph_msgr_wq);
- derr(0, "failed to create workqueue: %d\n", ret);
+ pr_err("ceph_msgr_init failed to create workqueue: %d\n", ret);
ceph_msgr_wq = NULL;
return ret;
}
ret = 0;
}
if (ret < 0) {
- derr(1, "connect %u.%u.%u.%u:%u error %d\n",
- IPQUADPORT(*(struct sockaddr_in *)paddr), ret);
+ pr_err("ceph connect %u.%u.%u.%u:%u error %d\n",
+ IPQUADPORT(*(struct sockaddr_in *)paddr), ret);
sock_release(sock);
con->sock = NULL;
con->error_msg = "connect error";
ret = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(char *)&optval, sizeof(optval));
if (ret < 0) {
- derr(0, "failed to set SO_REUSEADDR: %d\n", ret);
+ pr_err("ceph failed to set SO_REUSEADDR: %d\n", ret);
goto err;
}
ret = sock->ops->bind(sock, (struct sockaddr *)myaddr,
sizeof(*myaddr));
if (ret < 0) {
- derr(0, "Failed to bind: %d\n", ret);
+ pr_err("ceph failed to bind: %d\n", ret);
goto err;
}
ret = sock->ops->getname(sock, (struct sockaddr *)myaddr, &nlen,
0);
if (ret < 0) {
- derr(0, "failed to getsockname: %d\n", ret);
+ pr_err("ceph failed to getsockname: %d\n", ret);
goto err;
}
dout(0, "listening on %u.%u.%u.%u:%u\n", IPQUADPORT(*myaddr));
ret = lsock->ops->accept(lsock, sock, O_NONBLOCK);
if (ret < 0) {
- derr(0, "accept error: %d\n", ret);
+ pr_err("ceph accept error: %d\n", ret);
goto err;
}
static int verify_hello(struct ceph_connection *con)
{
if (memcmp(con->in_banner, CEPH_BANNER, strlen(CEPH_BANNER))) {
- derr(10, "connection to/from %u.%u.%u.%u:%u has bad banner\n",
- IPQUADPORT(con->peer_addr.ipaddr));
+ pr_err("ceph connect to/from %u.%u.%u.%u:%u has bad banner\n",
+ IPQUADPORT(con->peer_addr.ipaddr));
con->error_msg = "protocol error, bad banner";
return -1;
}
*/
static void reset_connection(struct ceph_connection *con)
{
- derr(1, "%s%d %u.%u.%u.%u:%u connection reset\n",
- ENTITY_NAME(con->peer_name),
- IPQUADPORT(con->peer_addr.ipaddr));
+ pr_err("ceph %s%d %u.%u.%u.%u:%u connection reset\n",
+ ENTITY_NAME(con->peer_name),
+ IPQUADPORT(con->peer_addr.ipaddr));
/* reset connection, out_queue, msg_ and connect_seq */
/* discard existing out_queue and msg_seq */
con->actual_peer_addr.ipaddr.sin_port ==
con->peer_addr.ipaddr.sin_port &&
con->actual_peer_addr.nonce == con->peer_addr.nonce)) {
- derr(1, "process_connect wrong peer, want %u.%u.%u.%u:%u/%d, "
- "got %u.%u.%u.%u:%u/%d, wtf\n",
- IPQUADPORT(con->peer_addr.ipaddr),
- con->peer_addr.nonce,
- IPQUADPORT(con->actual_peer_addr.ipaddr),
- con->actual_peer_addr.nonce);
+ pr_err("ceph wrong peer, want %u.%u.%u.%u:%u/%d, "
+ "got %u.%u.%u.%u:%u/%d, wtf\n",
+ IPQUADPORT(con->peer_addr.ipaddr),
+ con->peer_addr.nonce,
+ IPQUADPORT(con->actual_peer_addr.ipaddr),
+ con->actual_peer_addr.nonce);
con->error_msg = "protocol error, wrong peer";
return -1;
}
break;
default:
- derr(1, "process_connect protocol error, will retry\n");
+ pr_err("ceph connect protocol error, will retry\n");
con->error_msg = "protocol error, garbage tag during connect";
return -1;
}
/* do we have an existing connection for this peer? */
if (radix_tree_preload(GFP_NOFS) < 0) {
- derr(10, "ENOMEM in process_accept\n");
+ pr_err("ceph ENOMEM in process_accept\n");
con->error_msg = "out of memory";
return -1;
}
if (crc != le32_to_cpu(m->hdr.crc)) {
print_section("hdr", (u8 *)&m->hdr,
sizeof(m->hdr));
- derr(0, "read_partial_message %p bad hdr crc"
- " %u != expected %u\n",
- m, crc, m->hdr.crc);
+ pr_err("ceph read_partial_message %p bad hdr "
+ " crc %u != expected %u\n",
+ m, crc, m->hdr.crc);
return -EBADMSG;
}
}
/* crc ok? */
if (con->in_front_crc != le32_to_cpu(m->footer.front_crc)) {
- derr(0, "read_partial_message %p front crc %u != expected %u\n",
- con->in_msg,
- con->in_front_crc, m->footer.front_crc);
+ pr_err("ceph read_partial_message %p front crc %u != exp. %u\n",
+ con->in_msg,
+ con->in_front_crc, m->footer.front_crc);
print_section("front", (u8 *)&m->front.iov_base,
sizeof(m->front.iov_len));
return -EBADMSG;
(le32_to_cpu(m->footer.flags) & CEPH_MSG_FOOTER_NOCRC) == 0 &&
con->in_data_crc != le32_to_cpu(m->footer.data_crc)) {
int cur_page, data_pos;
- derr(0, "read_partial_message %p data crc %u != expected %u\n",
- con->in_msg,
- con->in_data_crc, m->footer.data_crc);
+ pr_err("ceph read_partial_message %p data crc %u != exp. %u\n",
+ con->in_msg,
+ con->in_data_crc, m->footer.data_crc);
for (data_pos = 0, cur_page = 0; data_pos < data_len;
data_pos += PAGE_SIZE, cur_page++) {
left = min((int)(data_len - data_pos),
mutex_lock(&m->page_mutex);
if (!m->pages) {
- derr(0, "m->pages == NULL\n");
mutex_unlock(&m->page_mutex);
break;
}
return ret;
bad_tag:
- derr(2, "try_read bad con->in_tag = %d\n", (int)con->in_tag);
+ pr_err("ceph try_read bad con->in_tag = %d\n", (int)con->in_tag);
con->error_msg = "protocol error, garbage tag";
ret = -1;
goto out;
*/
static void ceph_fault(struct ceph_connection *con)
{
- derr(1, "%s%d %u.%u.%u.%u:%u %s\n", ENTITY_NAME(con->peer_name),
- IPQUADPORT(con->peer_addr.ipaddr), con->error_msg);
+ pr_err("ceph %s%d %u.%u.%u.%u:%u %s\n", ENTITY_NAME(con->peer_name),
+ IPQUADPORT(con->peer_addr.ipaddr), con->error_msg);
dout(10, "fault %p state %lu to peer %u.%u.%u.%u:%u\n",
con, con->state, IPQUADPORT(con->peer_addr.ipaddr));
/* initialize the msgr connection */
newcon = new_connection(msgr);
if (newcon == NULL) {
- derr(1, "kmalloc failure accepting new connection\n");
+ pr_err("ceph ENOMEM accepting new connection\n");
return;
}
newcon->in_tag = CEPH_MSGR_TAG_READY; /* eventually, hopefully */
if (ceph_tcp_accept(msgr->listen_sock, newcon) < 0) {
- derr(1, "error accepting connection\n");
+ pr_err("ceph error accepting connection\n");
put_connection(newcon);
return;
}
ret = radix_tree_preload(GFP_NOFS);
if (ret < 0) {
- derr(10, "ENOMEM in ceph_msg_send\n");
+ pr_err("ceph ENOMEM in ceph_msg_send\n");
return ret;
}
m->front.iov_base = kmalloc(front_len, GFP_NOFS);
}
if (m->front.iov_base == NULL) {
- derr(0, "ceph_msg_new can't allocate %d bytes\n",
+ pr_err("ceph_msg_new can't allocate %d bytes\n",
front_len);
goto out2;
}
out2:
ceph_msg_put(m);
out:
- derr(0, "msg_new can't create msg type %d len %d\n", type, front_len);
+ pr_err("ceph_msg_new can't create type %d len %d\n", type, front_len);
return ERR_PTR(-ENOMEM);
}
dout(20, "ceph_msg_put %p %d -> %d\n", m, atomic_read(&m->nref),
atomic_read(&m->nref)-1);
if (atomic_read(&m->nref) <= 0) {
- derr(0, "bad ceph_msg_put on %p %llu %s%d->%s%d %d=%s %d+%d\n",
- m, le64_to_cpu(m->hdr.seq),
- ENTITY_NAME(m->hdr.src.name),
- ENTITY_NAME(m->hdr.dst.name),
- le16_to_cpu(m->hdr.type),
- ceph_msg_type_name(le16_to_cpu(m->hdr.type)),
- le32_to_cpu(m->hdr.front_len),
- le32_to_cpu(m->hdr.data_len));
+ pr_err("bad ceph_msg_put on %p %llu %s%d->%s%d %d=%s %d+%d\n",
+ m, le64_to_cpu(m->hdr.seq),
+ ENTITY_NAME(m->hdr.src.name),
+ ENTITY_NAME(m->hdr.dst.name),
+ le16_to_cpu(m->hdr.type),
+ ceph_msg_type_name(le16_to_cpu(m->hdr.type)),
+ le32_to_cpu(m->hdr.front_len),
+ le32_to_cpu(m->hdr.data_len));
WARN_ON(1);
}
if (atomic_dec_and_test(&m->nref)) {
return;
bad:
- derr(10, "corrupt statfs reply, no tid\n");
+ pr_err("ceph corrupt statfs reply, no tid\n");
}
/*
memset(&req.kobj, 0, sizeof(req.kobj));
if (radix_tree_insert(&monc->statfs_request_tree, req.tid, &req) < 0) {
mutex_unlock(&monc->statfs_mutex);
- derr(10, "ENOMEM in do_statfs\n");
+ pr_err("ceph ENOMEM in do_statfs\n");
return -ENOMEM;
}
if (monc->num_statfs_requests == 0)
ruleno = crush_find_rule(osdc->osdmap->crush, pool->v.crush_ruleset,
pool->v.type, pool->v.size);
if (ruleno < 0) {
- derr(0, "map_osds no crush rule for pool %d type %d size %d\n",
- pgid.pg.pool, pool->v.type, pool->v.size);
+ pr_err("ceph map_osds no crush rule pool %d type %d size %d\n",
+ pgid.pg.pool, pool->v.type, pool->v.size);
return -1;
}
return;
bad:
- derr(0, "got corrupt osd_op_reply got %d %d expected %d\n",
- (int)msg->front.iov_len, le32_to_cpu(msg->hdr.front_len),
- (int)sizeof(*rhead));
+ pr_err("ceph corrupt osd_op_reply got %d %d expected %d\n",
+ (int)msg->front.iov_len, le32_to_cpu(msg->hdr.front_len),
+ (int)sizeof(*rhead));
}
ceph_decode_need(&p, end, sizeof(fsid), bad);
ceph_decode_copy(&p, &fsid, sizeof(fsid));
if (ceph_fsid_compare(&fsid, &osdc->client->monc.monmap->fsid)) {
- derr(0, "got map with wrong fsid, ignoring\n");
+ pr_err("ceph got osdmap with wrong fsid, ignoring\n");
return;
}
return;
bad:
- derr(1, "handle_map corrupt msg\n");
+ pr_err("ceph osdc handle_map corrupt msg\n");
up_write(&osdc->map_sem);
return;
}
ceph_decode_need(p, end, 4*sizeof(u32), bad);
ceph_decode_32(p, magic);
if (magic != CRUSH_MAGIC) {
- derr(0, "crush_decode magic %x != current %x\n",
- (unsigned)magic, (unsigned)CRUSH_MAGIC);
+ pr_err("ceph crush_decode magic %x != current %x\n",
+ (unsigned)magic, (unsigned)CRUSH_MAGIC);
goto bad;
}
ceph_decode_32(p, c->max_buckets);
return map;
bad:
- derr(10, "corrupt incremental osdmap epoch %d off %d (%p of %p-%p)\n",
- epoch, (int)(*p - start), *p, start, end);
+ pr_err("ceph corrupt inc osdmap epoch %d off %d (%p of %p-%p)\n",
+ epoch, (int)(*p - start), *p, start, end);
if (newcrush)
crush_destroy(newcrush);
return ERR_PTR(err);
ceph_put_snap_context(realm->cached_context);
realm->cached_context = NULL;
}
- derr(0, "build_snap_context %llx %p fail %d\n", realm->ino,
- realm, err);
+ pr_err("ceph build_snap_context %llx %p fail %d\n", realm->ino,
+ realm, err);
return err;
}
capsnap = kzalloc(sizeof(*capsnap), GFP_NOFS);
if (!capsnap) {
- derr(10, "ENOMEM allocating ceph_cap_snap on %p\n", inode);
+ pr_err("ceph ENOMEM allocating ceph_cap_snap on %p\n", inode);
return;
}
atomic_set(&capsnap->nref, 1);
bad:
err = -EINVAL;
fail:
- derr(10, "update_snap_trace error %d\n", err);
+ pr_err("ceph update_snap_trace error %d\n", err);
return err;
}
return;
bad:
- derr(10, "corrupt snap message from mds%d\n", mds);
+ pr_err("ceph corrupt snap message from mds%d\n", mds);
out:
if (locked_rwsem)
up_write(&mdsc->snap_rwsem);
(cl->mount_state == CEPH_MOUNT_UNMOUNTED),
seconds*HZ);
if (rc == 0)
- derr(0, "umount timed out after %d seconds\n", seconds);
+ pr_err("ceph umount timedout after %d s\n", seconds);
}
return;
ceph_decode_need(&p, end, len, bad);
monmap = ceph_monmap_decode(p, p + len);
if (IS_ERR(monmap)) {
- derr(0, "problem decoding monmap, %d\n", (int)PTR_ERR(monmap));
+ pr_err("ceph problem decoding monmap, %d\n",
+ (int)PTR_ERR(monmap));
return -EINVAL;
}
p += len;
client->signed_ticket = kmalloc(len, GFP_KERNEL);
if (!client->signed_ticket) {
- derr(0, "problem allocating %d bytes for client ticket\n",
- len);
+ pr_err("ceph ENOMEM allocating %d bytes for client ticket\n",
+ len);
err = -ENOMEM;
goto out;
}
return 0;
bad:
- derr(0, "error decoding mount_ack message\n");
+ pr_err("ceph error decoding mount_ack message\n");
out:
kfree(monmap);
return err;
return 0;
bad:
- derr(1, "parse_ip bad ip '%s'\n", c);
+ pr_err("ceph parse_ip bad ip '%s'\n", c);
return -EINVAL;
}
continue;
token = match_token(c, arg_tokens, argstr);
if (token < 0) {
- derr(0, "bad mount option at '%s'\n", c);
+ pr_err("ceph bad mount option at '%s'\n", c);
return -EINVAL;
}
break;
default:
- derr(0, "received unknown message type %d %s\n", type,
- ceph_msg_type_name(type));
+ pr_err("ceph received unknown message type %d %s\n", type,
+ ceph_msg_type_name(type));
}
ceph_msg_put(msg);
projects / ceph.git / commitdiff