13d14c5d2SYehuda Sadeh #include <linux/ceph/ceph_debug.h> 23d14c5d2SYehuda Sadeh 3355da1ebSSage Weil #include "super.h" 43d14c5d2SYehuda Sadeh #include "mds_client.h" 53d14c5d2SYehuda Sadeh 63d14c5d2SYehuda Sadeh #include <linux/ceph/decode.h> 7355da1ebSSage Weil 8355da1ebSSage Weil #include <linux/xattr.h> 94db658eaSLinus Torvalds #include <linux/posix_acl_xattr.h> 105a0e3ad6STejun Heo #include <linux/slab.h> 11355da1ebSSage Weil 1222891907SAlex Elder #define XATTR_CEPH_PREFIX "ceph." 1322891907SAlex Elder #define XATTR_CEPH_PREFIX_LEN (sizeof (XATTR_CEPH_PREFIX) - 1) 1422891907SAlex Elder 15bcdfeb2eSYan, Zheng static int __remove_xattr(struct ceph_inode_info *ci, 16bcdfeb2eSYan, Zheng struct ceph_inode_xattr *xattr); 17bcdfeb2eSYan, Zheng 187221fe4cSGuangliang Zhao /* 197221fe4cSGuangliang Zhao * List of handlers for synthetic system.* attributes. Other 207221fe4cSGuangliang Zhao * attributes are handled directly. 217221fe4cSGuangliang Zhao */ 227221fe4cSGuangliang Zhao const struct xattr_handler *ceph_xattr_handlers[] = { 237221fe4cSGuangliang Zhao #ifdef CONFIG_CEPH_FS_POSIX_ACL 244db658eaSLinus Torvalds &posix_acl_access_xattr_handler, 254db658eaSLinus Torvalds &posix_acl_default_xattr_handler, 267221fe4cSGuangliang Zhao #endif 277221fe4cSGuangliang Zhao NULL, 287221fe4cSGuangliang Zhao }; 297221fe4cSGuangliang Zhao 30355da1ebSSage Weil static bool ceph_is_valid_xattr(const char *name) 31355da1ebSSage Weil { 3222891907SAlex Elder return !strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN) || 331a756278SSage Weil !strncmp(name, XATTR_SECURITY_PREFIX, 34355da1ebSSage Weil XATTR_SECURITY_PREFIX_LEN) || 357221fe4cSGuangliang Zhao !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) || 36355da1ebSSage Weil !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) || 37355da1ebSSage Weil !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN); 38355da1ebSSage Weil } 39355da1ebSSage Weil 40355da1ebSSage Weil /* 41355da1ebSSage Weil * These define virtual xattrs exposing the recursive directory 42355da1ebSSage Weil * statistics and layout metadata. 43355da1ebSSage Weil */ 44881a5fa2SAlex Elder struct ceph_vxattr { 45355da1ebSSage Weil char *name; 463ce6cd12SAlex Elder size_t name_size; /* strlen(name) + 1 (for '\0') */ 47355da1ebSSage Weil size_t (*getxattr_cb)(struct ceph_inode_info *ci, char *val, 48355da1ebSSage Weil size_t size); 498860147aSSage Weil bool readonly, hidden; 50f36e4472SSage Weil bool (*exists_cb)(struct ceph_inode_info *ci); 51355da1ebSSage Weil }; 52355da1ebSSage Weil 5332ab0bd7SSage Weil /* layouts */ 5432ab0bd7SSage Weil 5532ab0bd7SSage Weil static bool ceph_vxattrcb_layout_exists(struct ceph_inode_info *ci) 5632ab0bd7SSage Weil { 5732ab0bd7SSage Weil size_t s; 5832ab0bd7SSage Weil char *p = (char *)&ci->i_layout; 5932ab0bd7SSage Weil 6032ab0bd7SSage Weil for (s = 0; s < sizeof(ci->i_layout); s++, p++) 6132ab0bd7SSage Weil if (*p) 6232ab0bd7SSage Weil return true; 6332ab0bd7SSage Weil return false; 6432ab0bd7SSage Weil } 6532ab0bd7SSage Weil 6632ab0bd7SSage Weil static size_t ceph_vxattrcb_layout(struct ceph_inode_info *ci, char *val, 6732ab0bd7SSage Weil size_t size) 6832ab0bd7SSage Weil { 6932ab0bd7SSage Weil int ret; 7032ab0bd7SSage Weil struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb); 7132ab0bd7SSage Weil struct ceph_osd_client *osdc = &fsc->client->osdc; 7232ab0bd7SSage Weil s64 pool = ceph_file_layout_pg_pool(ci->i_layout); 7332ab0bd7SSage Weil const char *pool_name; 7432ab0bd7SSage Weil 7532ab0bd7SSage Weil dout("ceph_vxattrcb_layout %p\n", &ci->vfs_inode); 7632ab0bd7SSage Weil down_read(&osdc->map_sem); 7732ab0bd7SSage Weil pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool); 7832ab0bd7SSage Weil if (pool_name) 7932ab0bd7SSage Weil ret = snprintf(val, size, 8032ab0bd7SSage Weil "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%s", 8132ab0bd7SSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout), 8232ab0bd7SSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout), 8332ab0bd7SSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout), 8432ab0bd7SSage Weil pool_name); 8532ab0bd7SSage Weil else 8632ab0bd7SSage Weil ret = snprintf(val, size, 8732ab0bd7SSage Weil "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%lld", 8832ab0bd7SSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout), 8932ab0bd7SSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout), 9032ab0bd7SSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout), 9132ab0bd7SSage Weil (unsigned long long)pool); 9232ab0bd7SSage Weil 9332ab0bd7SSage Weil up_read(&osdc->map_sem); 9432ab0bd7SSage Weil return ret; 9532ab0bd7SSage Weil } 9632ab0bd7SSage Weil 97695b7119SSage Weil static size_t ceph_vxattrcb_layout_stripe_unit(struct ceph_inode_info *ci, 98695b7119SSage Weil char *val, size_t size) 99695b7119SSage Weil { 100695b7119SSage Weil return snprintf(val, size, "%lld", 101695b7119SSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout)); 102695b7119SSage Weil } 103695b7119SSage Weil 104695b7119SSage Weil static size_t ceph_vxattrcb_layout_stripe_count(struct ceph_inode_info *ci, 105695b7119SSage Weil char *val, size_t size) 106695b7119SSage Weil { 107695b7119SSage Weil return snprintf(val, size, "%lld", 108695b7119SSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout)); 109695b7119SSage Weil } 110695b7119SSage Weil 111695b7119SSage Weil static size_t ceph_vxattrcb_layout_object_size(struct ceph_inode_info *ci, 112695b7119SSage Weil char *val, size_t size) 113695b7119SSage Weil { 114695b7119SSage Weil return snprintf(val, size, "%lld", 115695b7119SSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout)); 116695b7119SSage Weil } 117695b7119SSage Weil 118695b7119SSage Weil static size_t ceph_vxattrcb_layout_pool(struct ceph_inode_info *ci, 119695b7119SSage Weil char *val, size_t size) 120695b7119SSage Weil { 121695b7119SSage Weil int ret; 122695b7119SSage Weil struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb); 123695b7119SSage Weil struct ceph_osd_client *osdc = &fsc->client->osdc; 124695b7119SSage Weil s64 pool = ceph_file_layout_pg_pool(ci->i_layout); 125695b7119SSage Weil const char *pool_name; 126695b7119SSage Weil 127695b7119SSage Weil down_read(&osdc->map_sem); 128695b7119SSage Weil pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool); 129695b7119SSage Weil if (pool_name) 130695b7119SSage Weil ret = snprintf(val, size, "%s", pool_name); 131695b7119SSage Weil else 132695b7119SSage Weil ret = snprintf(val, size, "%lld", (unsigned long long)pool); 133695b7119SSage Weil up_read(&osdc->map_sem); 134695b7119SSage Weil return ret; 135695b7119SSage Weil } 136695b7119SSage Weil 137355da1ebSSage Weil /* directories */ 138355da1ebSSage Weil 139aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info *ci, char *val, 140355da1ebSSage Weil size_t size) 141355da1ebSSage Weil { 142355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs); 143355da1ebSSage Weil } 144355da1ebSSage Weil 145aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_files(struct ceph_inode_info *ci, char *val, 146355da1ebSSage Weil size_t size) 147355da1ebSSage Weil { 148355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files); 149355da1ebSSage Weil } 150355da1ebSSage Weil 151aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_subdirs(struct ceph_inode_info *ci, char *val, 152355da1ebSSage Weil size_t size) 153355da1ebSSage Weil { 154355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_subdirs); 155355da1ebSSage Weil } 156355da1ebSSage Weil 157aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rentries(struct ceph_inode_info *ci, char *val, 158355da1ebSSage Weil size_t size) 159355da1ebSSage Weil { 160355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs); 161355da1ebSSage Weil } 162355da1ebSSage Weil 163aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rfiles(struct ceph_inode_info *ci, char *val, 164355da1ebSSage Weil size_t size) 165355da1ebSSage Weil { 166355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles); 167355da1ebSSage Weil } 168355da1ebSSage Weil 169aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info *ci, char *val, 170355da1ebSSage Weil size_t size) 171355da1ebSSage Weil { 172355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rsubdirs); 173355da1ebSSage Weil } 174355da1ebSSage Weil 175aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rbytes(struct ceph_inode_info *ci, char *val, 176355da1ebSSage Weil size_t size) 177355da1ebSSage Weil { 178355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rbytes); 179355da1ebSSage Weil } 180355da1ebSSage Weil 181aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info *ci, char *val, 182355da1ebSSage Weil size_t size) 183355da1ebSSage Weil { 1843489b42aSAlex Elder return snprintf(val, size, "%ld.09%ld", (long)ci->i_rctime.tv_sec, 185355da1ebSSage Weil (long)ci->i_rctime.tv_nsec); 186355da1ebSSage Weil } 187355da1ebSSage Weil 18832ab0bd7SSage Weil 189eb788084SAlex Elder #define CEPH_XATTR_NAME(_type, _name) XATTR_CEPH_PREFIX #_type "." #_name 190695b7119SSage Weil #define CEPH_XATTR_NAME2(_type, _name, _name2) \ 191695b7119SSage Weil XATTR_CEPH_PREFIX #_type "." #_name "." #_name2 192eb788084SAlex Elder 193eb788084SAlex Elder #define XATTR_NAME_CEPH(_type, _name) \ 194eb788084SAlex Elder { \ 195eb788084SAlex Elder .name = CEPH_XATTR_NAME(_type, _name), \ 1963ce6cd12SAlex Elder .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \ 197aa4066edSAlex Elder .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \ 198eb788084SAlex Elder .readonly = true, \ 1998860147aSSage Weil .hidden = false, \ 200f36e4472SSage Weil .exists_cb = NULL, \ 201eb788084SAlex Elder } 202695b7119SSage Weil #define XATTR_LAYOUT_FIELD(_type, _name, _field) \ 203695b7119SSage Weil { \ 204695b7119SSage Weil .name = CEPH_XATTR_NAME2(_type, _name, _field), \ 205695b7119SSage Weil .name_size = sizeof (CEPH_XATTR_NAME2(_type, _name, _field)), \ 206695b7119SSage Weil .getxattr_cb = ceph_vxattrcb_ ## _name ## _ ## _field, \ 207695b7119SSage Weil .readonly = false, \ 208695b7119SSage Weil .hidden = true, \ 209695b7119SSage Weil .exists_cb = ceph_vxattrcb_layout_exists, \ 210695b7119SSage Weil } 211eb788084SAlex Elder 212881a5fa2SAlex Elder static struct ceph_vxattr ceph_dir_vxattrs[] = { 2131f08f2b0SSage Weil { 2141f08f2b0SSage Weil .name = "ceph.dir.layout", 2151f08f2b0SSage Weil .name_size = sizeof("ceph.dir.layout"), 2161f08f2b0SSage Weil .getxattr_cb = ceph_vxattrcb_layout, 2171f08f2b0SSage Weil .readonly = false, 2181f08f2b0SSage Weil .hidden = false, 2191f08f2b0SSage Weil .exists_cb = ceph_vxattrcb_layout_exists, 2201f08f2b0SSage Weil }, 221695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, stripe_unit), 222695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, stripe_count), 223695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, object_size), 224695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, pool), 225eb788084SAlex Elder XATTR_NAME_CEPH(dir, entries), 226eb788084SAlex Elder XATTR_NAME_CEPH(dir, files), 227eb788084SAlex Elder XATTR_NAME_CEPH(dir, subdirs), 228eb788084SAlex Elder XATTR_NAME_CEPH(dir, rentries), 229eb788084SAlex Elder XATTR_NAME_CEPH(dir, rfiles), 230eb788084SAlex Elder XATTR_NAME_CEPH(dir, rsubdirs), 231eb788084SAlex Elder XATTR_NAME_CEPH(dir, rbytes), 232eb788084SAlex Elder XATTR_NAME_CEPH(dir, rctime), 2332c3dd4ffSAlex Elder { .name = NULL, 0 } /* Required table terminator */ 234355da1ebSSage Weil }; 2353ce6cd12SAlex Elder static size_t ceph_dir_vxattrs_name_size; /* total size of all names */ 236355da1ebSSage Weil 237355da1ebSSage Weil /* files */ 238355da1ebSSage Weil 239881a5fa2SAlex Elder static struct ceph_vxattr ceph_file_vxattrs[] = { 24032ab0bd7SSage Weil { 24132ab0bd7SSage Weil .name = "ceph.file.layout", 24232ab0bd7SSage Weil .name_size = sizeof("ceph.file.layout"), 24332ab0bd7SSage Weil .getxattr_cb = ceph_vxattrcb_layout, 24432ab0bd7SSage Weil .readonly = false, 24532ab0bd7SSage Weil .hidden = false, 24632ab0bd7SSage Weil .exists_cb = ceph_vxattrcb_layout_exists, 24732ab0bd7SSage Weil }, 248695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, stripe_unit), 249695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, stripe_count), 250695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, object_size), 251695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, pool), 2522c3dd4ffSAlex Elder { .name = NULL, 0 } /* Required table terminator */ 253355da1ebSSage Weil }; 2543ce6cd12SAlex Elder static size_t ceph_file_vxattrs_name_size; /* total size of all names */ 255355da1ebSSage Weil 256881a5fa2SAlex Elder static struct ceph_vxattr *ceph_inode_vxattrs(struct inode *inode) 257355da1ebSSage Weil { 258355da1ebSSage Weil if (S_ISDIR(inode->i_mode)) 259355da1ebSSage Weil return ceph_dir_vxattrs; 260355da1ebSSage Weil else if (S_ISREG(inode->i_mode)) 261355da1ebSSage Weil return ceph_file_vxattrs; 262355da1ebSSage Weil return NULL; 263355da1ebSSage Weil } 264355da1ebSSage Weil 2653ce6cd12SAlex Elder static size_t ceph_vxattrs_name_size(struct ceph_vxattr *vxattrs) 2663ce6cd12SAlex Elder { 2673ce6cd12SAlex Elder if (vxattrs == ceph_dir_vxattrs) 2683ce6cd12SAlex Elder return ceph_dir_vxattrs_name_size; 2693ce6cd12SAlex Elder if (vxattrs == ceph_file_vxattrs) 2703ce6cd12SAlex Elder return ceph_file_vxattrs_name_size; 2713ce6cd12SAlex Elder BUG(); 2723ce6cd12SAlex Elder 2733ce6cd12SAlex Elder return 0; 2743ce6cd12SAlex Elder } 2753ce6cd12SAlex Elder 2763ce6cd12SAlex Elder /* 2773ce6cd12SAlex Elder * Compute the aggregate size (including terminating '\0') of all 2783ce6cd12SAlex Elder * virtual extended attribute names in the given vxattr table. 2793ce6cd12SAlex Elder */ 2803ce6cd12SAlex Elder static size_t __init vxattrs_name_size(struct ceph_vxattr *vxattrs) 2813ce6cd12SAlex Elder { 2823ce6cd12SAlex Elder struct ceph_vxattr *vxattr; 2833ce6cd12SAlex Elder size_t size = 0; 2843ce6cd12SAlex Elder 2853ce6cd12SAlex Elder for (vxattr = vxattrs; vxattr->name; vxattr++) 2868860147aSSage Weil if (!vxattr->hidden) 2873ce6cd12SAlex Elder size += vxattr->name_size; 2883ce6cd12SAlex Elder 2893ce6cd12SAlex Elder return size; 2903ce6cd12SAlex Elder } 2913ce6cd12SAlex Elder 2923ce6cd12SAlex Elder /* Routines called at initialization and exit time */ 2933ce6cd12SAlex Elder 2943ce6cd12SAlex Elder void __init ceph_xattr_init(void) 2953ce6cd12SAlex Elder { 2963ce6cd12SAlex Elder ceph_dir_vxattrs_name_size = vxattrs_name_size(ceph_dir_vxattrs); 2973ce6cd12SAlex Elder ceph_file_vxattrs_name_size = vxattrs_name_size(ceph_file_vxattrs); 2983ce6cd12SAlex Elder } 2993ce6cd12SAlex Elder 3003ce6cd12SAlex Elder void ceph_xattr_exit(void) 3013ce6cd12SAlex Elder { 3023ce6cd12SAlex Elder ceph_dir_vxattrs_name_size = 0; 3033ce6cd12SAlex Elder ceph_file_vxattrs_name_size = 0; 3043ce6cd12SAlex Elder } 3053ce6cd12SAlex Elder 306881a5fa2SAlex Elder static struct ceph_vxattr *ceph_match_vxattr(struct inode *inode, 307355da1ebSSage Weil const char *name) 308355da1ebSSage Weil { 309881a5fa2SAlex Elder struct ceph_vxattr *vxattr = ceph_inode_vxattrs(inode); 31006476a69SAlex Elder 31106476a69SAlex Elder if (vxattr) { 31206476a69SAlex Elder while (vxattr->name) { 31306476a69SAlex Elder if (!strcmp(vxattr->name, name)) 314355da1ebSSage Weil return vxattr; 315355da1ebSSage Weil vxattr++; 31606476a69SAlex Elder } 31706476a69SAlex Elder } 31806476a69SAlex Elder 319355da1ebSSage Weil return NULL; 320355da1ebSSage Weil } 321355da1ebSSage Weil 322355da1ebSSage Weil static int __set_xattr(struct ceph_inode_info *ci, 323355da1ebSSage Weil const char *name, int name_len, 324355da1ebSSage Weil const char *val, int val_len, 325fbc0b970SYan, Zheng int flags, int update_xattr, 326355da1ebSSage Weil struct ceph_inode_xattr **newxattr) 327355da1ebSSage Weil { 328355da1ebSSage Weil struct rb_node **p; 329355da1ebSSage Weil struct rb_node *parent = NULL; 330355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 331355da1ebSSage Weil int c; 332355da1ebSSage Weil int new = 0; 333355da1ebSSage Weil 334355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 335355da1ebSSage Weil while (*p) { 336355da1ebSSage Weil parent = *p; 337355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 338355da1ebSSage Weil c = strncmp(name, xattr->name, min(name_len, xattr->name_len)); 339355da1ebSSage Weil if (c < 0) 340355da1ebSSage Weil p = &(*p)->rb_left; 341355da1ebSSage Weil else if (c > 0) 342355da1ebSSage Weil p = &(*p)->rb_right; 343355da1ebSSage Weil else { 344355da1ebSSage Weil if (name_len == xattr->name_len) 345355da1ebSSage Weil break; 346355da1ebSSage Weil else if (name_len < xattr->name_len) 347355da1ebSSage Weil p = &(*p)->rb_left; 348355da1ebSSage Weil else 349355da1ebSSage Weil p = &(*p)->rb_right; 350355da1ebSSage Weil } 351355da1ebSSage Weil xattr = NULL; 352355da1ebSSage Weil } 353355da1ebSSage Weil 354fbc0b970SYan, Zheng if (update_xattr) { 355fbc0b970SYan, Zheng int err = 0; 356fbc0b970SYan, Zheng if (xattr && (flags & XATTR_CREATE)) 357fbc0b970SYan, Zheng err = -EEXIST; 358fbc0b970SYan, Zheng else if (!xattr && (flags & XATTR_REPLACE)) 359fbc0b970SYan, Zheng err = -ENODATA; 360fbc0b970SYan, Zheng if (err) { 361fbc0b970SYan, Zheng kfree(name); 362fbc0b970SYan, Zheng kfree(val); 363fbc0b970SYan, Zheng return err; 364fbc0b970SYan, Zheng } 365bcdfeb2eSYan, Zheng if (update_xattr < 0) { 366bcdfeb2eSYan, Zheng if (xattr) 367bcdfeb2eSYan, Zheng __remove_xattr(ci, xattr); 368bcdfeb2eSYan, Zheng kfree(name); 369bcdfeb2eSYan, Zheng return 0; 370bcdfeb2eSYan, Zheng } 371fbc0b970SYan, Zheng } 372fbc0b970SYan, Zheng 373355da1ebSSage Weil if (!xattr) { 374355da1ebSSage Weil new = 1; 375355da1ebSSage Weil xattr = *newxattr; 376355da1ebSSage Weil xattr->name = name; 377355da1ebSSage Weil xattr->name_len = name_len; 378fbc0b970SYan, Zheng xattr->should_free_name = update_xattr; 379355da1ebSSage Weil 380355da1ebSSage Weil ci->i_xattrs.count++; 381355da1ebSSage Weil dout("__set_xattr count=%d\n", ci->i_xattrs.count); 382355da1ebSSage Weil } else { 383355da1ebSSage Weil kfree(*newxattr); 384355da1ebSSage Weil *newxattr = NULL; 385355da1ebSSage Weil if (xattr->should_free_val) 386355da1ebSSage Weil kfree((void *)xattr->val); 387355da1ebSSage Weil 388fbc0b970SYan, Zheng if (update_xattr) { 389355da1ebSSage Weil kfree((void *)name); 390355da1ebSSage Weil name = xattr->name; 391355da1ebSSage Weil } 392355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 393355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 394355da1ebSSage Weil } 395355da1ebSSage Weil ci->i_xattrs.names_size += name_len; 396355da1ebSSage Weil ci->i_xattrs.vals_size += val_len; 397355da1ebSSage Weil if (val) 398355da1ebSSage Weil xattr->val = val; 399355da1ebSSage Weil else 400355da1ebSSage Weil xattr->val = ""; 401355da1ebSSage Weil 402355da1ebSSage Weil xattr->val_len = val_len; 403fbc0b970SYan, Zheng xattr->dirty = update_xattr; 404fbc0b970SYan, Zheng xattr->should_free_val = (val && update_xattr); 405355da1ebSSage Weil 406355da1ebSSage Weil if (new) { 407355da1ebSSage Weil rb_link_node(&xattr->node, parent, p); 408355da1ebSSage Weil rb_insert_color(&xattr->node, &ci->i_xattrs.index); 409355da1ebSSage Weil dout("__set_xattr_val p=%p\n", p); 410355da1ebSSage Weil } 411355da1ebSSage Weil 412355da1ebSSage Weil dout("__set_xattr_val added %llx.%llx xattr %p %s=%.*s\n", 413355da1ebSSage Weil ceph_vinop(&ci->vfs_inode), xattr, name, val_len, val); 414355da1ebSSage Weil 415355da1ebSSage Weil return 0; 416355da1ebSSage Weil } 417355da1ebSSage Weil 418355da1ebSSage Weil static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci, 419355da1ebSSage Weil const char *name) 420355da1ebSSage Weil { 421355da1ebSSage Weil struct rb_node **p; 422355da1ebSSage Weil struct rb_node *parent = NULL; 423355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 42417db143fSSage Weil int name_len = strlen(name); 425355da1ebSSage Weil int c; 426355da1ebSSage Weil 427355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 428355da1ebSSage Weil while (*p) { 429355da1ebSSage Weil parent = *p; 430355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 431355da1ebSSage Weil c = strncmp(name, xattr->name, xattr->name_len); 43217db143fSSage Weil if (c == 0 && name_len > xattr->name_len) 43317db143fSSage Weil c = 1; 434355da1ebSSage Weil if (c < 0) 435355da1ebSSage Weil p = &(*p)->rb_left; 436355da1ebSSage Weil else if (c > 0) 437355da1ebSSage Weil p = &(*p)->rb_right; 438355da1ebSSage Weil else { 439355da1ebSSage Weil dout("__get_xattr %s: found %.*s\n", name, 440355da1ebSSage Weil xattr->val_len, xattr->val); 441355da1ebSSage Weil return xattr; 442355da1ebSSage Weil } 443355da1ebSSage Weil } 444355da1ebSSage Weil 445355da1ebSSage Weil dout("__get_xattr %s: not found\n", name); 446355da1ebSSage Weil 447355da1ebSSage Weil return NULL; 448355da1ebSSage Weil } 449355da1ebSSage Weil 450355da1ebSSage Weil static void __free_xattr(struct ceph_inode_xattr *xattr) 451355da1ebSSage Weil { 452355da1ebSSage Weil BUG_ON(!xattr); 453355da1ebSSage Weil 454355da1ebSSage Weil if (xattr->should_free_name) 455355da1ebSSage Weil kfree((void *)xattr->name); 456355da1ebSSage Weil if (xattr->should_free_val) 457355da1ebSSage Weil kfree((void *)xattr->val); 458355da1ebSSage Weil 459355da1ebSSage Weil kfree(xattr); 460355da1ebSSage Weil } 461355da1ebSSage Weil 462355da1ebSSage Weil static int __remove_xattr(struct ceph_inode_info *ci, 463355da1ebSSage Weil struct ceph_inode_xattr *xattr) 464355da1ebSSage Weil { 465355da1ebSSage Weil if (!xattr) 466524186acSYan, Zheng return -ENODATA; 467355da1ebSSage Weil 468355da1ebSSage Weil rb_erase(&xattr->node, &ci->i_xattrs.index); 469355da1ebSSage Weil 470355da1ebSSage Weil if (xattr->should_free_name) 471355da1ebSSage Weil kfree((void *)xattr->name); 472355da1ebSSage Weil if (xattr->should_free_val) 473355da1ebSSage Weil kfree((void *)xattr->val); 474355da1ebSSage Weil 475355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 476355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 477355da1ebSSage Weil ci->i_xattrs.count--; 478355da1ebSSage Weil kfree(xattr); 479355da1ebSSage Weil 480355da1ebSSage Weil return 0; 481355da1ebSSage Weil } 482355da1ebSSage Weil 483355da1ebSSage Weil static int __remove_xattr_by_name(struct ceph_inode_info *ci, 484355da1ebSSage Weil const char *name) 485355da1ebSSage Weil { 486355da1ebSSage Weil struct rb_node **p; 487355da1ebSSage Weil struct ceph_inode_xattr *xattr; 488355da1ebSSage Weil int err; 489355da1ebSSage Weil 490355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 491355da1ebSSage Weil xattr = __get_xattr(ci, name); 492355da1ebSSage Weil err = __remove_xattr(ci, xattr); 493355da1ebSSage Weil return err; 494355da1ebSSage Weil } 495355da1ebSSage Weil 496355da1ebSSage Weil static char *__copy_xattr_names(struct ceph_inode_info *ci, 497355da1ebSSage Weil char *dest) 498355da1ebSSage Weil { 499355da1ebSSage Weil struct rb_node *p; 500355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 501355da1ebSSage Weil 502355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 503355da1ebSSage Weil dout("__copy_xattr_names count=%d\n", ci->i_xattrs.count); 504355da1ebSSage Weil 505355da1ebSSage Weil while (p) { 506355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 507355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 508355da1ebSSage Weil dest[xattr->name_len] = '\0'; 509355da1ebSSage Weil 510355da1ebSSage Weil dout("dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name, 511355da1ebSSage Weil xattr->name_len, ci->i_xattrs.names_size); 512355da1ebSSage Weil 513355da1ebSSage Weil dest += xattr->name_len + 1; 514355da1ebSSage Weil p = rb_next(p); 515355da1ebSSage Weil } 516355da1ebSSage Weil 517355da1ebSSage Weil return dest; 518355da1ebSSage Weil } 519355da1ebSSage Weil 520355da1ebSSage Weil void __ceph_destroy_xattrs(struct ceph_inode_info *ci) 521355da1ebSSage Weil { 522355da1ebSSage Weil struct rb_node *p, *tmp; 523355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 524355da1ebSSage Weil 525355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 526355da1ebSSage Weil 527355da1ebSSage Weil dout("__ceph_destroy_xattrs p=%p\n", p); 528355da1ebSSage Weil 529355da1ebSSage Weil while (p) { 530355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 531355da1ebSSage Weil tmp = p; 532355da1ebSSage Weil p = rb_next(tmp); 533355da1ebSSage Weil dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p, 534355da1ebSSage Weil xattr->name_len, xattr->name); 535355da1ebSSage Weil rb_erase(tmp, &ci->i_xattrs.index); 536355da1ebSSage Weil 537355da1ebSSage Weil __free_xattr(xattr); 538355da1ebSSage Weil } 539355da1ebSSage Weil 540355da1ebSSage Weil ci->i_xattrs.names_size = 0; 541355da1ebSSage Weil ci->i_xattrs.vals_size = 0; 542355da1ebSSage Weil ci->i_xattrs.index_version = 0; 543355da1ebSSage Weil ci->i_xattrs.count = 0; 544355da1ebSSage Weil ci->i_xattrs.index = RB_ROOT; 545355da1ebSSage Weil } 546355da1ebSSage Weil 547355da1ebSSage Weil static int __build_xattrs(struct inode *inode) 548be655596SSage Weil __releases(ci->i_ceph_lock) 549be655596SSage Weil __acquires(ci->i_ceph_lock) 550355da1ebSSage Weil { 551355da1ebSSage Weil u32 namelen; 552355da1ebSSage Weil u32 numattr = 0; 553355da1ebSSage Weil void *p, *end; 554355da1ebSSage Weil u32 len; 555355da1ebSSage Weil const char *name, *val; 556355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 557355da1ebSSage Weil int xattr_version; 558355da1ebSSage Weil struct ceph_inode_xattr **xattrs = NULL; 55963ff78b2SSage Weil int err = 0; 560355da1ebSSage Weil int i; 561355da1ebSSage Weil 562355da1ebSSage Weil dout("__build_xattrs() len=%d\n", 563355da1ebSSage Weil ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0); 564355da1ebSSage Weil 565355da1ebSSage Weil if (ci->i_xattrs.index_version >= ci->i_xattrs.version) 566355da1ebSSage Weil return 0; /* already built */ 567355da1ebSSage Weil 568355da1ebSSage Weil __ceph_destroy_xattrs(ci); 569355da1ebSSage Weil 570355da1ebSSage Weil start: 571355da1ebSSage Weil /* updated internal xattr rb tree */ 572355da1ebSSage Weil if (ci->i_xattrs.blob && ci->i_xattrs.blob->vec.iov_len > 4) { 573355da1ebSSage Weil p = ci->i_xattrs.blob->vec.iov_base; 574355da1ebSSage Weil end = p + ci->i_xattrs.blob->vec.iov_len; 575355da1ebSSage Weil ceph_decode_32_safe(&p, end, numattr, bad); 576355da1ebSSage Weil xattr_version = ci->i_xattrs.version; 577be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 578355da1ebSSage Weil 579355da1ebSSage Weil xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *), 580355da1ebSSage Weil GFP_NOFS); 581355da1ebSSage Weil err = -ENOMEM; 582355da1ebSSage Weil if (!xattrs) 583355da1ebSSage Weil goto bad_lock; 584355da1ebSSage Weil memset(xattrs, 0, numattr*sizeof(struct ceph_xattr *)); 585355da1ebSSage Weil for (i = 0; i < numattr; i++) { 586355da1ebSSage Weil xattrs[i] = kmalloc(sizeof(struct ceph_inode_xattr), 587355da1ebSSage Weil GFP_NOFS); 588355da1ebSSage Weil if (!xattrs[i]) 589355da1ebSSage Weil goto bad_lock; 590355da1ebSSage Weil } 591355da1ebSSage Weil 592be655596SSage Weil spin_lock(&ci->i_ceph_lock); 593355da1ebSSage Weil if (ci->i_xattrs.version != xattr_version) { 594355da1ebSSage Weil /* lost a race, retry */ 595355da1ebSSage Weil for (i = 0; i < numattr; i++) 596355da1ebSSage Weil kfree(xattrs[i]); 597355da1ebSSage Weil kfree(xattrs); 59821ec6ffaSAlan Cox xattrs = NULL; 599355da1ebSSage Weil goto start; 600355da1ebSSage Weil } 601355da1ebSSage Weil err = -EIO; 602355da1ebSSage Weil while (numattr--) { 603355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 604355da1ebSSage Weil namelen = len; 605355da1ebSSage Weil name = p; 606355da1ebSSage Weil p += len; 607355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 608355da1ebSSage Weil val = p; 609355da1ebSSage Weil p += len; 610355da1ebSSage Weil 611355da1ebSSage Weil err = __set_xattr(ci, name, namelen, val, len, 612fbc0b970SYan, Zheng 0, 0, &xattrs[numattr]); 613355da1ebSSage Weil 614355da1ebSSage Weil if (err < 0) 615355da1ebSSage Weil goto bad; 616355da1ebSSage Weil } 617355da1ebSSage Weil kfree(xattrs); 618355da1ebSSage Weil } 619355da1ebSSage Weil ci->i_xattrs.index_version = ci->i_xattrs.version; 620355da1ebSSage Weil ci->i_xattrs.dirty = false; 621355da1ebSSage Weil 622355da1ebSSage Weil return err; 623355da1ebSSage Weil bad_lock: 624be655596SSage Weil spin_lock(&ci->i_ceph_lock); 625355da1ebSSage Weil bad: 626355da1ebSSage Weil if (xattrs) { 627355da1ebSSage Weil for (i = 0; i < numattr; i++) 628355da1ebSSage Weil kfree(xattrs[i]); 629355da1ebSSage Weil kfree(xattrs); 630355da1ebSSage Weil } 631355da1ebSSage Weil ci->i_xattrs.names_size = 0; 632355da1ebSSage Weil return err; 633355da1ebSSage Weil } 634355da1ebSSage Weil 635355da1ebSSage Weil static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size, 636355da1ebSSage Weil int val_size) 637355da1ebSSage Weil { 638355da1ebSSage Weil /* 639355da1ebSSage Weil * 4 bytes for the length, and additional 4 bytes per each xattr name, 640355da1ebSSage Weil * 4 bytes per each value 641355da1ebSSage Weil */ 642355da1ebSSage Weil int size = 4 + ci->i_xattrs.count*(4 + 4) + 643355da1ebSSage Weil ci->i_xattrs.names_size + 644355da1ebSSage Weil ci->i_xattrs.vals_size; 645355da1ebSSage Weil dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n", 646355da1ebSSage Weil ci->i_xattrs.count, ci->i_xattrs.names_size, 647355da1ebSSage Weil ci->i_xattrs.vals_size); 648355da1ebSSage Weil 649355da1ebSSage Weil if (name_size) 650355da1ebSSage Weil size += 4 + 4 + name_size + val_size; 651355da1ebSSage Weil 652355da1ebSSage Weil return size; 653355da1ebSSage Weil } 654355da1ebSSage Weil 655355da1ebSSage Weil /* 656355da1ebSSage Weil * If there are dirty xattrs, reencode xattrs into the prealloc_blob 657355da1ebSSage Weil * and swap into place. 658355da1ebSSage Weil */ 659355da1ebSSage Weil void __ceph_build_xattrs_blob(struct ceph_inode_info *ci) 660355da1ebSSage Weil { 661355da1ebSSage Weil struct rb_node *p; 662355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 663355da1ebSSage Weil void *dest; 664355da1ebSSage Weil 665355da1ebSSage Weil dout("__build_xattrs_blob %p\n", &ci->vfs_inode); 666355da1ebSSage Weil if (ci->i_xattrs.dirty) { 667355da1ebSSage Weil int need = __get_required_blob_size(ci, 0, 0); 668355da1ebSSage Weil 669355da1ebSSage Weil BUG_ON(need > ci->i_xattrs.prealloc_blob->alloc_len); 670355da1ebSSage Weil 671355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 672355da1ebSSage Weil dest = ci->i_xattrs.prealloc_blob->vec.iov_base; 673355da1ebSSage Weil 674355da1ebSSage Weil ceph_encode_32(&dest, ci->i_xattrs.count); 675355da1ebSSage Weil while (p) { 676355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 677355da1ebSSage Weil 678355da1ebSSage Weil ceph_encode_32(&dest, xattr->name_len); 679355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 680355da1ebSSage Weil dest += xattr->name_len; 681355da1ebSSage Weil ceph_encode_32(&dest, xattr->val_len); 682355da1ebSSage Weil memcpy(dest, xattr->val, xattr->val_len); 683355da1ebSSage Weil dest += xattr->val_len; 684355da1ebSSage Weil 685355da1ebSSage Weil p = rb_next(p); 686355da1ebSSage Weil } 687355da1ebSSage Weil 688355da1ebSSage Weil /* adjust buffer len; it may be larger than we need */ 689355da1ebSSage Weil ci->i_xattrs.prealloc_blob->vec.iov_len = 690355da1ebSSage Weil dest - ci->i_xattrs.prealloc_blob->vec.iov_base; 691355da1ebSSage Weil 692b6c1d5b8SSage Weil if (ci->i_xattrs.blob) 693355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.blob); 694355da1ebSSage Weil ci->i_xattrs.blob = ci->i_xattrs.prealloc_blob; 695355da1ebSSage Weil ci->i_xattrs.prealloc_blob = NULL; 696355da1ebSSage Weil ci->i_xattrs.dirty = false; 6974a625be4SSage Weil ci->i_xattrs.version++; 698355da1ebSSage Weil } 699355da1ebSSage Weil } 700355da1ebSSage Weil 7017221fe4cSGuangliang Zhao ssize_t __ceph_getxattr(struct inode *inode, const char *name, void *value, 702355da1ebSSage Weil size_t size) 703355da1ebSSage Weil { 704355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 705355da1ebSSage Weil int err; 706355da1ebSSage Weil struct ceph_inode_xattr *xattr; 707881a5fa2SAlex Elder struct ceph_vxattr *vxattr = NULL; 708355da1ebSSage Weil 709355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 710355da1ebSSage Weil return -ENODATA; 711355da1ebSSage Weil 7120bee82fbSSage Weil /* let's see if a virtual xattr was requested */ 7130bee82fbSSage Weil vxattr = ceph_match_vxattr(inode, name); 7140bee82fbSSage Weil if (vxattr && !(vxattr->exists_cb && !vxattr->exists_cb(ci))) { 7150bee82fbSSage Weil err = vxattr->getxattr_cb(ci, value, size); 716a1dc1937Smajianpeng return err; 7170bee82fbSSage Weil } 7180bee82fbSSage Weil 719a1dc1937Smajianpeng spin_lock(&ci->i_ceph_lock); 720a1dc1937Smajianpeng dout("getxattr %p ver=%lld index_ver=%lld\n", inode, 721a1dc1937Smajianpeng ci->i_xattrs.version, ci->i_xattrs.index_version); 722a1dc1937Smajianpeng 723355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 724355da1ebSSage Weil (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 725355da1ebSSage Weil goto get_xattr; 726355da1ebSSage Weil } else { 727be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 728355da1ebSSage Weil /* get xattrs from mds (if we don't already have them) */ 729355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 730355da1ebSSage Weil if (err) 731355da1ebSSage Weil return err; 732355da1ebSSage Weil } 733355da1ebSSage Weil 734be655596SSage Weil spin_lock(&ci->i_ceph_lock); 735355da1ebSSage Weil 736355da1ebSSage Weil err = __build_xattrs(inode); 737355da1ebSSage Weil if (err < 0) 738355da1ebSSage Weil goto out; 739355da1ebSSage Weil 740355da1ebSSage Weil get_xattr: 741355da1ebSSage Weil err = -ENODATA; /* == ENOATTR */ 742355da1ebSSage Weil xattr = __get_xattr(ci, name); 7430bee82fbSSage Weil if (!xattr) 744355da1ebSSage Weil goto out; 745355da1ebSSage Weil 746355da1ebSSage Weil err = -ERANGE; 747355da1ebSSage Weil if (size && size < xattr->val_len) 748355da1ebSSage Weil goto out; 749355da1ebSSage Weil 750355da1ebSSage Weil err = xattr->val_len; 751355da1ebSSage Weil if (size == 0) 752355da1ebSSage Weil goto out; 753355da1ebSSage Weil 754355da1ebSSage Weil memcpy(value, xattr->val, xattr->val_len); 755355da1ebSSage Weil 756355da1ebSSage Weil out: 757be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 758355da1ebSSage Weil return err; 759355da1ebSSage Weil } 760355da1ebSSage Weil 7617221fe4cSGuangliang Zhao ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value, 7627221fe4cSGuangliang Zhao size_t size) 7637221fe4cSGuangliang Zhao { 7647221fe4cSGuangliang Zhao if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) 7657221fe4cSGuangliang Zhao return generic_getxattr(dentry, name, value, size); 7667221fe4cSGuangliang Zhao 7677221fe4cSGuangliang Zhao return __ceph_getxattr(dentry->d_inode, name, value, size); 7687221fe4cSGuangliang Zhao } 7697221fe4cSGuangliang Zhao 770355da1ebSSage Weil ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size) 771355da1ebSSage Weil { 772355da1ebSSage Weil struct inode *inode = dentry->d_inode; 773355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 774881a5fa2SAlex Elder struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode); 775355da1ebSSage Weil u32 vir_namelen = 0; 776355da1ebSSage Weil u32 namelen; 777355da1ebSSage Weil int err; 778355da1ebSSage Weil u32 len; 779355da1ebSSage Weil int i; 780355da1ebSSage Weil 781be655596SSage Weil spin_lock(&ci->i_ceph_lock); 782355da1ebSSage Weil dout("listxattr %p ver=%lld index_ver=%lld\n", inode, 783355da1ebSSage Weil ci->i_xattrs.version, ci->i_xattrs.index_version); 784355da1ebSSage Weil 785355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 786bddfa3ccSHenry C Chang (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 787355da1ebSSage Weil goto list_xattr; 788355da1ebSSage Weil } else { 789be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 790355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 791355da1ebSSage Weil if (err) 792355da1ebSSage Weil return err; 793355da1ebSSage Weil } 794355da1ebSSage Weil 795be655596SSage Weil spin_lock(&ci->i_ceph_lock); 796355da1ebSSage Weil 797355da1ebSSage Weil err = __build_xattrs(inode); 798355da1ebSSage Weil if (err < 0) 799355da1ebSSage Weil goto out; 800355da1ebSSage Weil 801355da1ebSSage Weil list_xattr: 8023ce6cd12SAlex Elder /* 8033ce6cd12SAlex Elder * Start with virtual dir xattr names (if any) (including 8043ce6cd12SAlex Elder * terminating '\0' characters for each). 8053ce6cd12SAlex Elder */ 8063ce6cd12SAlex Elder vir_namelen = ceph_vxattrs_name_size(vxattrs); 8073ce6cd12SAlex Elder 808355da1ebSSage Weil /* adding 1 byte per each variable due to the null termination */ 809b65917ddSSage Weil namelen = ci->i_xattrs.names_size + ci->i_xattrs.count; 810355da1ebSSage Weil err = -ERANGE; 811b65917ddSSage Weil if (size && vir_namelen + namelen > size) 812355da1ebSSage Weil goto out; 813355da1ebSSage Weil 814b65917ddSSage Weil err = namelen + vir_namelen; 815355da1ebSSage Weil if (size == 0) 816355da1ebSSage Weil goto out; 817355da1ebSSage Weil 818355da1ebSSage Weil names = __copy_xattr_names(ci, names); 819355da1ebSSage Weil 820355da1ebSSage Weil /* virtual xattr names, too */ 821b65917ddSSage Weil err = namelen; 822b65917ddSSage Weil if (vxattrs) { 823355da1ebSSage Weil for (i = 0; vxattrs[i].name; i++) { 824b65917ddSSage Weil if (!vxattrs[i].hidden && 825b65917ddSSage Weil !(vxattrs[i].exists_cb && 826b65917ddSSage Weil !vxattrs[i].exists_cb(ci))) { 827355da1ebSSage Weil len = sprintf(names, "%s", vxattrs[i].name); 828355da1ebSSage Weil names += len + 1; 829b65917ddSSage Weil err += len + 1; 830b65917ddSSage Weil } 831b65917ddSSage Weil } 832355da1ebSSage Weil } 833355da1ebSSage Weil 834355da1ebSSage Weil out: 835be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 836355da1ebSSage Weil return err; 837355da1ebSSage Weil } 838355da1ebSSage Weil 839355da1ebSSage Weil static int ceph_sync_setxattr(struct dentry *dentry, const char *name, 840355da1ebSSage Weil const char *value, size_t size, int flags) 841355da1ebSSage Weil { 8423d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 843355da1ebSSage Weil struct inode *inode = dentry->d_inode; 844355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 845355da1ebSSage Weil struct ceph_mds_request *req; 8463d14c5d2SYehuda Sadeh struct ceph_mds_client *mdsc = fsc->mdsc; 847355da1ebSSage Weil int err; 848355da1ebSSage Weil int i, nr_pages; 849355da1ebSSage Weil struct page **pages = NULL; 850355da1ebSSage Weil void *kaddr; 851355da1ebSSage Weil 852355da1ebSSage Weil /* copy value into some pages */ 853355da1ebSSage Weil nr_pages = calc_pages_for(0, size); 854355da1ebSSage Weil if (nr_pages) { 855355da1ebSSage Weil pages = kmalloc(sizeof(pages[0])*nr_pages, GFP_NOFS); 856355da1ebSSage Weil if (!pages) 857355da1ebSSage Weil return -ENOMEM; 858355da1ebSSage Weil err = -ENOMEM; 859355da1ebSSage Weil for (i = 0; i < nr_pages; i++) { 86031459fe4SYehuda Sadeh pages[i] = __page_cache_alloc(GFP_NOFS); 861355da1ebSSage Weil if (!pages[i]) { 862355da1ebSSage Weil nr_pages = i; 863355da1ebSSage Weil goto out; 864355da1ebSSage Weil } 865355da1ebSSage Weil kaddr = kmap(pages[i]); 866355da1ebSSage Weil memcpy(kaddr, value + i*PAGE_CACHE_SIZE, 867355da1ebSSage Weil min(PAGE_CACHE_SIZE, size-i*PAGE_CACHE_SIZE)); 868355da1ebSSage Weil } 869355da1ebSSage Weil } 870355da1ebSSage Weil 871355da1ebSSage Weil dout("setxattr value=%.*s\n", (int)size, value); 872355da1ebSSage Weil 873bcdfeb2eSYan, Zheng if (!value) 874bcdfeb2eSYan, Zheng flags |= CEPH_XATTR_REMOVE; 875bcdfeb2eSYan, Zheng 876355da1ebSSage Weil /* do request */ 877355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETXATTR, 878355da1ebSSage Weil USE_AUTH_MDS); 87960d87733SJulia Lawall if (IS_ERR(req)) { 88060d87733SJulia Lawall err = PTR_ERR(req); 88160d87733SJulia Lawall goto out; 88260d87733SJulia Lawall } 88370b666c3SSage Weil req->r_inode = inode; 88470b666c3SSage Weil ihold(inode); 885355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 886355da1ebSSage Weil req->r_num_caps = 1; 887355da1ebSSage Weil req->r_args.setxattr.flags = cpu_to_le32(flags); 888355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 889355da1ebSSage Weil 890355da1ebSSage Weil req->r_pages = pages; 891355da1ebSSage Weil req->r_num_pages = nr_pages; 892355da1ebSSage Weil req->r_data_len = size; 893355da1ebSSage Weil 894355da1ebSSage Weil dout("xattr.ver (before): %lld\n", ci->i_xattrs.version); 895*752c8bdcSSage Weil err = ceph_mdsc_do_request(mdsc, NULL, req); 896355da1ebSSage Weil ceph_mdsc_put_request(req); 897355da1ebSSage Weil dout("xattr.ver (after): %lld\n", ci->i_xattrs.version); 898355da1ebSSage Weil 899355da1ebSSage Weil out: 900355da1ebSSage Weil if (pages) { 901355da1ebSSage Weil for (i = 0; i < nr_pages; i++) 902355da1ebSSage Weil __free_page(pages[i]); 903355da1ebSSage Weil kfree(pages); 904355da1ebSSage Weil } 905355da1ebSSage Weil return err; 906355da1ebSSage Weil } 907355da1ebSSage Weil 9087221fe4cSGuangliang Zhao int __ceph_setxattr(struct dentry *dentry, const char *name, 909355da1ebSSage Weil const void *value, size_t size, int flags) 910355da1ebSSage Weil { 911355da1ebSSage Weil struct inode *inode = dentry->d_inode; 912881a5fa2SAlex Elder struct ceph_vxattr *vxattr; 913355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 91418fa8b3fSAlex Elder int issued; 915355da1ebSSage Weil int err; 916fbc0b970SYan, Zheng int dirty = 0; 917355da1ebSSage Weil int name_len = strlen(name); 918355da1ebSSage Weil int val_len = size; 919355da1ebSSage Weil char *newname = NULL; 920355da1ebSSage Weil char *newval = NULL; 921355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 922355da1ebSSage Weil int required_blob_size; 923355da1ebSSage Weil 924355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 925355da1ebSSage Weil return -EOPNOTSUPP; 926355da1ebSSage Weil 92706476a69SAlex Elder vxattr = ceph_match_vxattr(inode, name); 928355da1ebSSage Weil if (vxattr && vxattr->readonly) 929355da1ebSSage Weil return -EOPNOTSUPP; 930355da1ebSSage Weil 9313adf654dSSage Weil /* pass any unhandled ceph.* xattrs through to the MDS */ 9323adf654dSSage Weil if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN)) 9333adf654dSSage Weil goto do_sync_unlocked; 9343adf654dSSage Weil 935355da1ebSSage Weil /* preallocate memory for xattr name, value, index node */ 936355da1ebSSage Weil err = -ENOMEM; 93761413c2fSJulia Lawall newname = kmemdup(name, name_len + 1, GFP_NOFS); 938355da1ebSSage Weil if (!newname) 939355da1ebSSage Weil goto out; 940355da1ebSSage Weil 941355da1ebSSage Weil if (val_len) { 942b829c195SAlex Elder newval = kmemdup(value, val_len, GFP_NOFS); 943355da1ebSSage Weil if (!newval) 944355da1ebSSage Weil goto out; 945355da1ebSSage Weil } 946355da1ebSSage Weil 947355da1ebSSage Weil xattr = kmalloc(sizeof(struct ceph_inode_xattr), GFP_NOFS); 948355da1ebSSage Weil if (!xattr) 949355da1ebSSage Weil goto out; 950355da1ebSSage Weil 951be655596SSage Weil spin_lock(&ci->i_ceph_lock); 952355da1ebSSage Weil retry: 953355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 95418fa8b3fSAlex Elder dout("setxattr %p issued %s\n", inode, ceph_cap_string(issued)); 955355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 956355da1ebSSage Weil goto do_sync; 957355da1ebSSage Weil __build_xattrs(inode); 958355da1ebSSage Weil 959355da1ebSSage Weil required_blob_size = __get_required_blob_size(ci, name_len, val_len); 960355da1ebSSage Weil 961355da1ebSSage Weil if (!ci->i_xattrs.prealloc_blob || 962355da1ebSSage Weil required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 96318fa8b3fSAlex Elder struct ceph_buffer *blob; 964355da1ebSSage Weil 965be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 966355da1ebSSage Weil dout(" preaallocating new blob size=%d\n", required_blob_size); 967b6c1d5b8SSage Weil blob = ceph_buffer_new(required_blob_size, GFP_NOFS); 968355da1ebSSage Weil if (!blob) 969355da1ebSSage Weil goto out; 970be655596SSage Weil spin_lock(&ci->i_ceph_lock); 971b6c1d5b8SSage Weil if (ci->i_xattrs.prealloc_blob) 972355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.prealloc_blob); 973355da1ebSSage Weil ci->i_xattrs.prealloc_blob = blob; 974355da1ebSSage Weil goto retry; 975355da1ebSSage Weil } 976355da1ebSSage Weil 977bcdfeb2eSYan, Zheng err = __set_xattr(ci, newname, name_len, newval, val_len, 978bcdfeb2eSYan, Zheng flags, value ? 1 : -1, &xattr); 97918fa8b3fSAlex Elder 980fbc0b970SYan, Zheng if (!err) { 981fca65b4aSSage Weil dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 982355da1ebSSage Weil ci->i_xattrs.dirty = true; 983355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 984fbc0b970SYan, Zheng } 98518fa8b3fSAlex Elder 986be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 987fca65b4aSSage Weil if (dirty) 988fca65b4aSSage Weil __mark_inode_dirty(inode, dirty); 989355da1ebSSage Weil return err; 990355da1ebSSage Weil 991355da1ebSSage Weil do_sync: 992be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 9933adf654dSSage Weil do_sync_unlocked: 994355da1ebSSage Weil err = ceph_sync_setxattr(dentry, name, value, size, flags); 995355da1ebSSage Weil out: 996355da1ebSSage Weil kfree(newname); 997355da1ebSSage Weil kfree(newval); 998355da1ebSSage Weil kfree(xattr); 999355da1ebSSage Weil return err; 1000355da1ebSSage Weil } 1001355da1ebSSage Weil 10027221fe4cSGuangliang Zhao int ceph_setxattr(struct dentry *dentry, const char *name, 10037221fe4cSGuangliang Zhao const void *value, size_t size, int flags) 10047221fe4cSGuangliang Zhao { 10057221fe4cSGuangliang Zhao if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP) 10067221fe4cSGuangliang Zhao return -EROFS; 10077221fe4cSGuangliang Zhao 10087221fe4cSGuangliang Zhao if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) 10097221fe4cSGuangliang Zhao return generic_setxattr(dentry, name, value, size, flags); 10107221fe4cSGuangliang Zhao 10117221fe4cSGuangliang Zhao return __ceph_setxattr(dentry, name, value, size, flags); 10127221fe4cSGuangliang Zhao } 10137221fe4cSGuangliang Zhao 1014355da1ebSSage Weil static int ceph_send_removexattr(struct dentry *dentry, const char *name) 1015355da1ebSSage Weil { 10163d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 10173d14c5d2SYehuda Sadeh struct ceph_mds_client *mdsc = fsc->mdsc; 1018355da1ebSSage Weil struct inode *inode = dentry->d_inode; 1019355da1ebSSage Weil struct ceph_mds_request *req; 1020355da1ebSSage Weil int err; 1021355da1ebSSage Weil 1022355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RMXATTR, 1023355da1ebSSage Weil USE_AUTH_MDS); 1024355da1ebSSage Weil if (IS_ERR(req)) 1025355da1ebSSage Weil return PTR_ERR(req); 102670b666c3SSage Weil req->r_inode = inode; 102770b666c3SSage Weil ihold(inode); 1028355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 1029355da1ebSSage Weil req->r_num_caps = 1; 1030355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 1031355da1ebSSage Weil 1032*752c8bdcSSage Weil err = ceph_mdsc_do_request(mdsc, NULL, req); 1033355da1ebSSage Weil ceph_mdsc_put_request(req); 1034355da1ebSSage Weil return err; 1035355da1ebSSage Weil } 1036355da1ebSSage Weil 10377221fe4cSGuangliang Zhao int __ceph_removexattr(struct dentry *dentry, const char *name) 1038355da1ebSSage Weil { 1039355da1ebSSage Weil struct inode *inode = dentry->d_inode; 1040881a5fa2SAlex Elder struct ceph_vxattr *vxattr; 1041355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 1042355da1ebSSage Weil int issued; 1043355da1ebSSage Weil int err; 104483eb26afSAlex Elder int required_blob_size; 1045fca65b4aSSage Weil int dirty; 1046355da1ebSSage Weil 1047355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 1048355da1ebSSage Weil return -EOPNOTSUPP; 1049355da1ebSSage Weil 105006476a69SAlex Elder vxattr = ceph_match_vxattr(inode, name); 1051355da1ebSSage Weil if (vxattr && vxattr->readonly) 1052355da1ebSSage Weil return -EOPNOTSUPP; 1053355da1ebSSage Weil 1054d421acb1SSage Weil /* pass any unhandled ceph.* xattrs through to the MDS */ 1055d421acb1SSage Weil if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN)) 1056d421acb1SSage Weil goto do_sync_unlocked; 1057d421acb1SSage Weil 105883eb26afSAlex Elder err = -ENOMEM; 1059be655596SSage Weil spin_lock(&ci->i_ceph_lock); 106083eb26afSAlex Elder retry: 1061355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 1062355da1ebSSage Weil dout("removexattr %p issued %s\n", inode, ceph_cap_string(issued)); 1063355da1ebSSage Weil 1064355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 1065355da1ebSSage Weil goto do_sync; 106618fa8b3fSAlex Elder __build_xattrs(inode); 1067355da1ebSSage Weil 106883eb26afSAlex Elder required_blob_size = __get_required_blob_size(ci, 0, 0); 106983eb26afSAlex Elder 107083eb26afSAlex Elder if (!ci->i_xattrs.prealloc_blob || 107183eb26afSAlex Elder required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 107283eb26afSAlex Elder struct ceph_buffer *blob; 107383eb26afSAlex Elder 107483eb26afSAlex Elder spin_unlock(&ci->i_ceph_lock); 107583eb26afSAlex Elder dout(" preaallocating new blob size=%d\n", required_blob_size); 107683eb26afSAlex Elder blob = ceph_buffer_new(required_blob_size, GFP_NOFS); 107783eb26afSAlex Elder if (!blob) 107883eb26afSAlex Elder goto out; 107983eb26afSAlex Elder spin_lock(&ci->i_ceph_lock); 108083eb26afSAlex Elder if (ci->i_xattrs.prealloc_blob) 108183eb26afSAlex Elder ceph_buffer_put(ci->i_xattrs.prealloc_blob); 108283eb26afSAlex Elder ci->i_xattrs.prealloc_blob = blob; 108383eb26afSAlex Elder goto retry; 108483eb26afSAlex Elder } 108583eb26afSAlex Elder 1086355da1ebSSage Weil err = __remove_xattr_by_name(ceph_inode(inode), name); 108718fa8b3fSAlex Elder 1088fca65b4aSSage Weil dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 1089355da1ebSSage Weil ci->i_xattrs.dirty = true; 1090355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 1091be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 1092fca65b4aSSage Weil if (dirty) 1093fca65b4aSSage Weil __mark_inode_dirty(inode, dirty); 1094355da1ebSSage Weil return err; 1095355da1ebSSage Weil do_sync: 1096be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 1097d421acb1SSage Weil do_sync_unlocked: 1098355da1ebSSage Weil err = ceph_send_removexattr(dentry, name); 109983eb26afSAlex Elder out: 1100355da1ebSSage Weil return err; 1101355da1ebSSage Weil } 1102355da1ebSSage Weil 11037221fe4cSGuangliang Zhao int ceph_removexattr(struct dentry *dentry, const char *name) 11047221fe4cSGuangliang Zhao { 11057221fe4cSGuangliang Zhao if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP) 11067221fe4cSGuangliang Zhao return -EROFS; 11077221fe4cSGuangliang Zhao 11087221fe4cSGuangliang Zhao if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) 11097221fe4cSGuangliang Zhao return generic_removexattr(dentry, name); 11107221fe4cSGuangliang Zhao 11117221fe4cSGuangliang Zhao return __ceph_removexattr(dentry, name); 11127221fe4cSGuangliang Zhao } 1113