Merge tag 'ceph-for-6.7-rc1' of https://github.com/ceph/ceph-client

[sfrench/cifs-2.6.git] / fs / ceph / xattr.c

diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index 097ce7f74073d4f4ce01b6e7187bce4121a8f050..e066a556eccbfe370afdbf6f4aade3e26df80bb9 100644 (file)
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -57,7 +57,8 @@ static bool ceph_vxattrcb_layout_exists(struct ceph_inode_info *ci)
 static ssize_t ceph_vxattrcb_layout(struct ceph_inode_info *ci, char *val,
                                    size_t size)
 {
-       struct ceph_fs_client *fsc = ceph_sb_to_client(ci->netfs.inode.i_sb);
+       struct ceph_fs_client *fsc = ceph_sb_to_fs_client(ci->netfs.inode.i_sb);
+       struct ceph_client *cl = fsc->client;
        struct ceph_osd_client *osdc = &fsc->client->osdc;
        struct ceph_string *pool_ns;
        s64 pool = ci->i_layout.pool_id;
@@ -69,7 +70,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);
 
-       dout("ceph_vxattrcb_layout %p\n", &ci->netfs.inode);
+       doutc(cl, "%p\n", &ci->netfs.inode);
        down_read(&osdc->lock);
        pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool);
        if (pool_name) {
@@ -161,7 +162,7 @@ static ssize_t ceph_vxattrcb_layout_pool(struct ceph_inode_info *ci,
                                         char *val, size_t size)
 {
        ssize_t ret;
-       struct ceph_fs_client *fsc = ceph_sb_to_client(ci->netfs.inode.i_sb);
+       struct ceph_fs_client *fsc = ceph_sb_to_fs_client(ci->netfs.inode.i_sb);
        struct ceph_osd_client *osdc = &fsc->client->osdc;
        s64 pool = ci->i_layout.pool_id;
        const char *pool_name;
@@ -313,7 +314,7 @@ static ssize_t ceph_vxattrcb_snap_btime(struct ceph_inode_info *ci, char *val,
 static ssize_t ceph_vxattrcb_cluster_fsid(struct ceph_inode_info *ci,
                                          char *val, size_t size)
 {
-       struct ceph_fs_client *fsc = ceph_sb_to_client(ci->netfs.inode.i_sb);
+       struct ceph_fs_client *fsc = ceph_sb_to_fs_client(ci->netfs.inode.i_sb);
 
        return ceph_fmt_xattr(val, size, "%pU", &fsc->client->fsid);
 }
@@ -321,7 +322,7 @@ static ssize_t ceph_vxattrcb_cluster_fsid(struct ceph_inode_info *ci,
 static ssize_t ceph_vxattrcb_client_id(struct ceph_inode_info *ci,
                                       char *val, size_t size)
 {
-       struct ceph_fs_client *fsc = ceph_sb_to_client(ci->netfs.inode.i_sb);
+       struct ceph_fs_client *fsc = ceph_sb_to_fs_client(ci->netfs.inode.i_sb);
 
        return ceph_fmt_xattr(val, size, "client%lld",
                              ceph_client_gid(fsc->client));
@@ -570,6 +571,8 @@ static int __set_xattr(struct ceph_inode_info *ci,
                           int flags, int update_xattr,
                           struct ceph_inode_xattr **newxattr)
 {
+       struct inode *inode = &ci->netfs.inode;
+       struct ceph_client *cl = ceph_inode_to_client(inode);
        struct rb_node **p;
        struct rb_node *parent = NULL;
        struct ceph_inode_xattr *xattr = NULL;
@@ -626,7 +629,7 @@ static int __set_xattr(struct ceph_inode_info *ci,
                xattr->should_free_name = update_xattr;
 
                ci->i_xattrs.count++;
-               dout("%s count=%d\n", __func__, ci->i_xattrs.count);
+               doutc(cl, "count=%d\n", ci->i_xattrs.count);
        } else {
                kfree(*newxattr);
                *newxattr = NULL;
@@ -654,13 +657,13 @@ static int __set_xattr(struct ceph_inode_info *ci,
        if (new) {
                rb_link_node(&xattr->node, parent, p);
                rb_insert_color(&xattr->node, &ci->i_xattrs.index);
-               dout("%s p=%p\n", __func__, p);
+               doutc(cl, "p=%p\n", p);
        }
 
-       dout("%s added %llx.%llx xattr %p %.*s=%.*s%s\n", __func__,
-            ceph_vinop(&ci->netfs.inode), xattr, name_len, name,
-            min(val_len, MAX_XATTR_VAL_PRINT_LEN), val,
-            val_len > MAX_XATTR_VAL_PRINT_LEN ? "..." : "");
+       doutc(cl, "added %p %llx.%llx xattr %p %.*s=%.*s%s\n", inode,
+             ceph_vinop(inode), xattr, name_len, name, min(val_len,
+             MAX_XATTR_VAL_PRINT_LEN), val,
+             val_len > MAX_XATTR_VAL_PRINT_LEN ? "..." : "");
 
        return 0;
 }
@@ -668,6 +671,7 @@ static int __set_xattr(struct ceph_inode_info *ci,
 static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci,
                           const char *name)
 {
+       struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);
        struct rb_node **p;
        struct rb_node *parent = NULL;
        struct ceph_inode_xattr *xattr = NULL;
@@ -688,13 +692,13 @@ static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci,
                else {
                        int len = min(xattr->val_len, MAX_XATTR_VAL_PRINT_LEN);
 
-                       dout("%s %s: found %.*s%s\n", __func__, name, len,
-                            xattr->val, xattr->val_len > len ? "..." : "");
+                       doutc(cl, "%s found %.*s%s\n", name, len, xattr->val,
+                             xattr->val_len > len ? "..." : "");
                        return xattr;
                }
        }
 
-       dout("%s %s: not found\n", __func__, name);
+       doutc(cl, "%s not found\n", name);
 
        return NULL;
 }
@@ -735,19 +739,20 @@ static int __remove_xattr(struct ceph_inode_info *ci,
 static char *__copy_xattr_names(struct ceph_inode_info *ci,
                                char *dest)
 {
+       struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);
        struct rb_node *p;
        struct ceph_inode_xattr *xattr = NULL;
 
        p = rb_first(&ci->i_xattrs.index);
-       dout("__copy_xattr_names count=%d\n", ci->i_xattrs.count);
+       doutc(cl, "count=%d\n", ci->i_xattrs.count);
 
        while (p) {
                xattr = rb_entry(p, struct ceph_inode_xattr, node);
                memcpy(dest, xattr->name, xattr->name_len);
                dest[xattr->name_len] = '\0';
 
-               dout("dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name,
-                    xattr->name_len, ci->i_xattrs.names_size);
+               doutc(cl, "dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name,
+                     xattr->name_len, ci->i_xattrs.names_size);
 
                dest += xattr->name_len + 1;
                p = rb_next(p);
@@ -758,19 +763,19 @@ static char *__copy_xattr_names(struct ceph_inode_info *ci,
 
 void __ceph_destroy_xattrs(struct ceph_inode_info *ci)
 {
+       struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);
        struct rb_node *p, *tmp;
        struct ceph_inode_xattr *xattr = NULL;
 
        p = rb_first(&ci->i_xattrs.index);
 
-       dout("__ceph_destroy_xattrs p=%p\n", p);
+       doutc(cl, "p=%p\n", p);
 
        while (p) {
                xattr = rb_entry(p, struct ceph_inode_xattr, node);
                tmp = p;
                p = rb_next(tmp);
-               dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p,
-                    xattr->name_len, xattr->name);
+               doutc(cl, "next p=%p (%.*s)\n", p, xattr->name_len, xattr->name);
                rb_erase(tmp, &ci->i_xattrs.index);
 
                __free_xattr(xattr);
@@ -787,6 +792,7 @@ static int __build_xattrs(struct inode *inode)
        __releases(ci->i_ceph_lock)
        __acquires(ci->i_ceph_lock)
 {
+       struct ceph_client *cl = ceph_inode_to_client(inode);
        u32 namelen;
        u32 numattr = 0;
        void *p, *end;
@@ -798,8 +804,8 @@ static int __build_xattrs(struct inode *inode)
        int err = 0;
        int i;
 
-       dout("__build_xattrs() len=%d\n",
-            ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0);
+       doutc(cl, "len=%d\n",
+             ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0);
 
        if (ci->i_xattrs.index_version >= ci->i_xattrs.version)
                return 0; /* already built */
@@ -874,6 +880,8 @@ bad:
 static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size,
                                    int val_size)
 {
+       struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);
+
        /*
         * 4 bytes for the length, and additional 4 bytes per each xattr name,
         * 4 bytes per each value
@@ -881,9 +889,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;
-       dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n",
-            ci->i_xattrs.count, ci->i_xattrs.names_size,
-            ci->i_xattrs.vals_size);
+       doutc(cl, "c=%d names.size=%d vals.size=%d\n", ci->i_xattrs.count,
+             ci->i_xattrs.names_size, ci->i_xattrs.vals_size);
 
        if (name_size)
                size += 4 + 4 + name_size + val_size;
@@ -899,12 +906,14 @@ static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size,
  */
 struct ceph_buffer *__ceph_build_xattrs_blob(struct ceph_inode_info *ci)
 {
+       struct inode *inode = &ci->netfs.inode;
+       struct ceph_client *cl = ceph_inode_to_client(inode);
        struct rb_node *p;
        struct ceph_inode_xattr *xattr = NULL;
        struct ceph_buffer *old_blob = NULL;
        void *dest;
 
-       dout("__build_xattrs_blob %p\n", &ci->netfs.inode);
+       doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));
        if (ci->i_xattrs.dirty) {
                int need = __get_required_blob_size(ci, 0, 0);
 
@@ -962,6 +971,7 @@ static inline int __get_request_mask(struct inode *in) {
 ssize_t __ceph_getxattr(struct inode *inode, const char *name, void *value,
                      size_t size)
 {
+       struct ceph_client *cl = ceph_inode_to_client(inode);
        struct ceph_inode_info *ci = ceph_inode(inode);
        struct ceph_inode_xattr *xattr;
        struct ceph_vxattr *vxattr;
@@ -1000,8 +1010,9 @@ handle_non_vxattrs:
        req_mask = __get_request_mask(inode);
 
        spin_lock(&ci->i_ceph_lock);
-       dout("getxattr %p name '%s' ver=%lld index_ver=%lld\n", inode, name,
-            ci->i_xattrs.version, ci->i_xattrs.index_version);
+       doutc(cl, "%p %llx.%llx name '%s' ver=%lld index_ver=%lld\n", inode,
+             ceph_vinop(inode), name, ci->i_xattrs.version,
+             ci->i_xattrs.index_version);
 
        if (ci->i_xattrs.version == 0 ||
            !((req_mask & CEPH_CAP_XATTR_SHARED) ||
@@ -1010,8 +1021,9 @@ handle_non_vxattrs:
 
                /* security module gets xattr while filling trace */
                if (current->journal_info) {
-                       pr_warn_ratelimited("sync getxattr %p "
-                                           "during filling trace\n", inode);
+                       pr_warn_ratelimited_client(cl,
+                               "sync %p %llx.%llx during filling trace\n",
+                               inode, ceph_vinop(inode));
                        return -EBUSY;
                }
 
@@ -1053,14 +1065,16 @@ out:
 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
 {
        struct inode *inode = d_inode(dentry);
+       struct ceph_client *cl = ceph_inode_to_client(inode);
        struct ceph_inode_info *ci = ceph_inode(inode);
        bool len_only = (size == 0);
        u32 namelen;
        int err;
 
        spin_lock(&ci->i_ceph_lock);
-       dout("listxattr %p ver=%lld index_ver=%lld\n", inode,
-            ci->i_xattrs.version, ci->i_xattrs.index_version);
+       doutc(cl, "%p %llx.%llx ver=%lld index_ver=%lld\n", inode,
+             ceph_vinop(inode), ci->i_xattrs.version,
+             ci->i_xattrs.index_version);
 
        if (ci->i_xattrs.version == 0 ||
            !__ceph_caps_issued_mask_metric(ci, CEPH_CAP_XATTR_SHARED, 1)) {
@@ -1094,7 +1108,8 @@ out:
 static int ceph_sync_setxattr(struct inode *inode, const char *name,
                              const char *value, size_t size, int flags)
 {
-       struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
+       struct ceph_fs_client *fsc = ceph_sb_to_fs_client(inode->i_sb);
+       struct ceph_client *cl = ceph_inode_to_client(inode);
        struct ceph_inode_info *ci = ceph_inode(inode);
        struct ceph_mds_request *req;
        struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -1119,7 +1134,7 @@ static int ceph_sync_setxattr(struct inode *inode, const char *name,
                        flags |= CEPH_XATTR_REMOVE;
        }
 
-       dout("setxattr value size: %zu\n", size);
+       doutc(cl, "name %s value size %zu\n", name, size);
 
        /* do request */
        req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
@@ -1148,10 +1163,10 @@ static int ceph_sync_setxattr(struct inode *inode, const char *name,
        req->r_num_caps = 1;
        req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
 
-       dout("xattr.ver (before): %lld\n", ci->i_xattrs.version);
+       doutc(cl, "xattr.ver (before): %lld\n", ci->i_xattrs.version);
        err = ceph_mdsc_do_request(mdsc, NULL, req);
        ceph_mdsc_put_request(req);
-       dout("xattr.ver (after): %lld\n", ci->i_xattrs.version);
+       doutc(cl, "xattr.ver (after): %lld\n", ci->i_xattrs.version);
 
 out:
        if (pagelist)
@@ -1162,9 +1177,10 @@ out:
 int __ceph_setxattr(struct inode *inode, const char *name,
                        const void *value, size_t size, int flags)
 {
+       struct ceph_client *cl = ceph_inode_to_client(inode);
        struct ceph_vxattr *vxattr;
        struct ceph_inode_info *ci = ceph_inode(inode);
-       struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
+       struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
        struct ceph_cap_flush *prealloc_cf = NULL;
        struct ceph_buffer *old_blob = NULL;
        int issued;
@@ -1220,9 +1236,9 @@ retry:
        required_blob_size = __get_required_blob_size(ci, name_len, val_len);
        if ((ci->i_xattrs.version == 0) || !(issued & CEPH_CAP_XATTR_EXCL) ||
            (required_blob_size > mdsc->mdsmap->m_max_xattr_size)) {
-               dout("%s do sync setxattr: version: %llu size: %d max: %llu\n",
-                    __func__, ci->i_xattrs.version, required_blob_size,
-                    mdsc->mdsmap->m_max_xattr_size);
+               doutc(cl, "sync version: %llu size: %d max: %llu\n",
+                     ci->i_xattrs.version, required_blob_size,
+                     mdsc->mdsmap->m_max_xattr_size);
                goto do_sync;
        }
 
@@ -1236,8 +1252,8 @@ retry:
                }
        }
 
-       dout("setxattr %p name '%s' issued %s\n", inode, name,
-            ceph_cap_string(issued));
+       doutc(cl, "%p %llx.%llx name '%s' issued %s\n", inode,
+             ceph_vinop(inode), name, ceph_cap_string(issued));
        __build_xattrs(inode);
 
        if (!ci->i_xattrs.prealloc_blob ||
@@ -1246,7 +1262,8 @@ retry:
 
                spin_unlock(&ci->i_ceph_lock);
                ceph_buffer_put(old_blob); /* Shouldn't be required */
-               dout(" pre-allocating new blob size=%d\n", required_blob_size);
+               doutc(cl, " pre-allocating new blob size=%d\n",
+                     required_blob_size);
                blob = ceph_buffer_new(required_blob_size, GFP_NOFS);
                if (!blob)
                        goto do_sync_unlocked;
@@ -1285,8 +1302,9 @@ do_sync_unlocked:
 
        /* security module set xattr while filling trace */
        if (current->journal_info) {
-               pr_warn_ratelimited("sync setxattr %p "
-                                   "during filling trace\n", inode);
+               pr_warn_ratelimited_client(cl,
+                               "sync %p %llx.%llx during filling trace\n",
+                               inode, ceph_vinop(inode));
                err = -EBUSY;
        } else {
                err = ceph_sync_setxattr(inode, name, value, size, flags);