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> 95a0e3ad6STejun Heo #include <linux/slab.h> 10355da1ebSSage Weil 1122891907SAlex Elder #define XATTR_CEPH_PREFIX "ceph." 1222891907SAlex Elder #define XATTR_CEPH_PREFIX_LEN (sizeof (XATTR_CEPH_PREFIX) - 1) 1322891907SAlex Elder 14355da1ebSSage Weil static bool ceph_is_valid_xattr(const char *name) 15355da1ebSSage Weil { 1622891907SAlex Elder return !strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN) || 171a756278SSage Weil !strncmp(name, XATTR_SECURITY_PREFIX, 18355da1ebSSage Weil XATTR_SECURITY_PREFIX_LEN) || 19355da1ebSSage Weil !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) || 20355da1ebSSage Weil !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN); 21355da1ebSSage Weil } 22355da1ebSSage Weil 23355da1ebSSage Weil /* 24355da1ebSSage Weil * These define virtual xattrs exposing the recursive directory 25355da1ebSSage Weil * statistics and layout metadata. 26355da1ebSSage Weil */ 27881a5fa2SAlex Elder struct ceph_vxattr { 28355da1ebSSage Weil char *name; 293ce6cd12SAlex Elder size_t name_size; /* strlen(name) + 1 (for '\0') */ 30355da1ebSSage Weil size_t (*getxattr_cb)(struct ceph_inode_info *ci, char *val, 31355da1ebSSage Weil size_t size); 328860147aSSage Weil bool readonly, hidden; 33f36e4472SSage Weil bool (*exists_cb)(struct ceph_inode_info *ci); 34355da1ebSSage Weil }; 35355da1ebSSage Weil 3632ab0bd7SSage Weil /* layouts */ 3732ab0bd7SSage Weil 3832ab0bd7SSage Weil static bool ceph_vxattrcb_layout_exists(struct ceph_inode_info *ci) 3932ab0bd7SSage Weil { 4032ab0bd7SSage Weil size_t s; 4132ab0bd7SSage Weil char *p = (char *)&ci->i_layout; 4232ab0bd7SSage Weil 4332ab0bd7SSage Weil for (s = 0; s < sizeof(ci->i_layout); s++, p++) 4432ab0bd7SSage Weil if (*p) 4532ab0bd7SSage Weil return true; 4632ab0bd7SSage Weil return false; 4732ab0bd7SSage Weil } 4832ab0bd7SSage Weil 4932ab0bd7SSage Weil static size_t ceph_vxattrcb_layout(struct ceph_inode_info *ci, char *val, 5032ab0bd7SSage Weil size_t size) 5132ab0bd7SSage Weil { 5232ab0bd7SSage Weil int ret; 5332ab0bd7SSage Weil struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb); 5432ab0bd7SSage Weil struct ceph_osd_client *osdc = &fsc->client->osdc; 5532ab0bd7SSage Weil s64 pool = ceph_file_layout_pg_pool(ci->i_layout); 5632ab0bd7SSage Weil const char *pool_name; 5732ab0bd7SSage Weil 5832ab0bd7SSage Weil dout("ceph_vxattrcb_layout %p\n", &ci->vfs_inode); 5932ab0bd7SSage Weil down_read(&osdc->map_sem); 6032ab0bd7SSage Weil pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool); 6132ab0bd7SSage Weil if (pool_name) 6232ab0bd7SSage Weil ret = snprintf(val, size, 6332ab0bd7SSage Weil "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%s", 6432ab0bd7SSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout), 6532ab0bd7SSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout), 6632ab0bd7SSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout), 6732ab0bd7SSage Weil pool_name); 6832ab0bd7SSage Weil else 6932ab0bd7SSage Weil ret = snprintf(val, size, 7032ab0bd7SSage Weil "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%lld", 7132ab0bd7SSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout), 7232ab0bd7SSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout), 7332ab0bd7SSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout), 7432ab0bd7SSage Weil (unsigned long long)pool); 7532ab0bd7SSage Weil 7632ab0bd7SSage Weil up_read(&osdc->map_sem); 7732ab0bd7SSage Weil return ret; 7832ab0bd7SSage Weil } 7932ab0bd7SSage Weil 80695b7119SSage Weil static size_t ceph_vxattrcb_layout_stripe_unit(struct ceph_inode_info *ci, 81695b7119SSage Weil char *val, size_t size) 82695b7119SSage Weil { 83695b7119SSage Weil return snprintf(val, size, "%lld", 84695b7119SSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout)); 85695b7119SSage Weil } 86695b7119SSage Weil 87695b7119SSage Weil static size_t ceph_vxattrcb_layout_stripe_count(struct ceph_inode_info *ci, 88695b7119SSage Weil char *val, size_t size) 89695b7119SSage Weil { 90695b7119SSage Weil return snprintf(val, size, "%lld", 91695b7119SSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout)); 92695b7119SSage Weil } 93695b7119SSage Weil 94695b7119SSage Weil static size_t ceph_vxattrcb_layout_object_size(struct ceph_inode_info *ci, 95695b7119SSage Weil char *val, size_t size) 96695b7119SSage Weil { 97695b7119SSage Weil return snprintf(val, size, "%lld", 98695b7119SSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout)); 99695b7119SSage Weil } 100695b7119SSage Weil 101695b7119SSage Weil static size_t ceph_vxattrcb_layout_pool(struct ceph_inode_info *ci, 102695b7119SSage Weil char *val, size_t size) 103695b7119SSage Weil { 104695b7119SSage Weil int ret; 105695b7119SSage Weil struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb); 106695b7119SSage Weil struct ceph_osd_client *osdc = &fsc->client->osdc; 107695b7119SSage Weil s64 pool = ceph_file_layout_pg_pool(ci->i_layout); 108695b7119SSage Weil const char *pool_name; 109695b7119SSage Weil 110695b7119SSage Weil down_read(&osdc->map_sem); 111695b7119SSage Weil pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool); 112695b7119SSage Weil if (pool_name) 113695b7119SSage Weil ret = snprintf(val, size, "%s", pool_name); 114695b7119SSage Weil else 115695b7119SSage Weil ret = snprintf(val, size, "%lld", (unsigned long long)pool); 116695b7119SSage Weil up_read(&osdc->map_sem); 117695b7119SSage Weil return ret; 118695b7119SSage Weil } 119695b7119SSage Weil 120355da1ebSSage Weil /* directories */ 121355da1ebSSage Weil 122aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info *ci, char *val, 123355da1ebSSage Weil size_t size) 124355da1ebSSage Weil { 125355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs); 126355da1ebSSage Weil } 127355da1ebSSage Weil 128aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_files(struct ceph_inode_info *ci, char *val, 129355da1ebSSage Weil size_t size) 130355da1ebSSage Weil { 131355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files); 132355da1ebSSage Weil } 133355da1ebSSage Weil 134aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_subdirs(struct ceph_inode_info *ci, char *val, 135355da1ebSSage Weil size_t size) 136355da1ebSSage Weil { 137355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_subdirs); 138355da1ebSSage Weil } 139355da1ebSSage Weil 140aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rentries(struct ceph_inode_info *ci, char *val, 141355da1ebSSage Weil size_t size) 142355da1ebSSage Weil { 143355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs); 144355da1ebSSage Weil } 145355da1ebSSage Weil 146aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rfiles(struct ceph_inode_info *ci, char *val, 147355da1ebSSage Weil size_t size) 148355da1ebSSage Weil { 149355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles); 150355da1ebSSage Weil } 151355da1ebSSage Weil 152aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info *ci, char *val, 153355da1ebSSage Weil size_t size) 154355da1ebSSage Weil { 155355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rsubdirs); 156355da1ebSSage Weil } 157355da1ebSSage Weil 158aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rbytes(struct ceph_inode_info *ci, char *val, 159355da1ebSSage Weil size_t size) 160355da1ebSSage Weil { 161355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rbytes); 162355da1ebSSage Weil } 163355da1ebSSage Weil 164aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info *ci, char *val, 165355da1ebSSage Weil size_t size) 166355da1ebSSage Weil { 1673489b42aSAlex Elder return snprintf(val, size, "%ld.09%ld", (long)ci->i_rctime.tv_sec, 168355da1ebSSage Weil (long)ci->i_rctime.tv_nsec); 169355da1ebSSage Weil } 170355da1ebSSage Weil 17132ab0bd7SSage Weil 172eb788084SAlex Elder #define CEPH_XATTR_NAME(_type, _name) XATTR_CEPH_PREFIX #_type "." #_name 173695b7119SSage Weil #define CEPH_XATTR_NAME2(_type, _name, _name2) \ 174695b7119SSage Weil XATTR_CEPH_PREFIX #_type "." #_name "." #_name2 175eb788084SAlex Elder 176eb788084SAlex Elder #define XATTR_NAME_CEPH(_type, _name) \ 177eb788084SAlex Elder { \ 178eb788084SAlex Elder .name = CEPH_XATTR_NAME(_type, _name), \ 1793ce6cd12SAlex Elder .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \ 180aa4066edSAlex Elder .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \ 181eb788084SAlex Elder .readonly = true, \ 1828860147aSSage Weil .hidden = false, \ 183f36e4472SSage Weil .exists_cb = NULL, \ 184eb788084SAlex Elder } 185695b7119SSage Weil #define XATTR_LAYOUT_FIELD(_type, _name, _field) \ 186695b7119SSage Weil { \ 187695b7119SSage Weil .name = CEPH_XATTR_NAME2(_type, _name, _field), \ 188695b7119SSage Weil .name_size = sizeof (CEPH_XATTR_NAME2(_type, _name, _field)), \ 189695b7119SSage Weil .getxattr_cb = ceph_vxattrcb_ ## _name ## _ ## _field, \ 190695b7119SSage Weil .readonly = false, \ 191695b7119SSage Weil .hidden = true, \ 192695b7119SSage Weil .exists_cb = ceph_vxattrcb_layout_exists, \ 193695b7119SSage Weil } 194eb788084SAlex Elder 195881a5fa2SAlex Elder static struct ceph_vxattr ceph_dir_vxattrs[] = { 1961f08f2b0SSage Weil { 1971f08f2b0SSage Weil .name = "ceph.dir.layout", 1981f08f2b0SSage Weil .name_size = sizeof("ceph.dir.layout"), 1991f08f2b0SSage Weil .getxattr_cb = ceph_vxattrcb_layout, 2001f08f2b0SSage Weil .readonly = false, 2011f08f2b0SSage Weil .hidden = false, 2021f08f2b0SSage Weil .exists_cb = ceph_vxattrcb_layout_exists, 2031f08f2b0SSage Weil }, 204695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, stripe_unit), 205695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, stripe_count), 206695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, object_size), 207695b7119SSage Weil XATTR_LAYOUT_FIELD(dir, layout, pool), 208eb788084SAlex Elder XATTR_NAME_CEPH(dir, entries), 209eb788084SAlex Elder XATTR_NAME_CEPH(dir, files), 210eb788084SAlex Elder XATTR_NAME_CEPH(dir, subdirs), 211eb788084SAlex Elder XATTR_NAME_CEPH(dir, rentries), 212eb788084SAlex Elder XATTR_NAME_CEPH(dir, rfiles), 213eb788084SAlex Elder XATTR_NAME_CEPH(dir, rsubdirs), 214eb788084SAlex Elder XATTR_NAME_CEPH(dir, rbytes), 215eb788084SAlex Elder XATTR_NAME_CEPH(dir, rctime), 216*2c3dd4ffSAlex Elder { .name = NULL, 0 } /* Required table terminator */ 217355da1ebSSage Weil }; 2183ce6cd12SAlex Elder static size_t ceph_dir_vxattrs_name_size; /* total size of all names */ 219355da1ebSSage Weil 220355da1ebSSage Weil /* files */ 221355da1ebSSage Weil 222881a5fa2SAlex Elder static struct ceph_vxattr ceph_file_vxattrs[] = { 22332ab0bd7SSage Weil { 22432ab0bd7SSage Weil .name = "ceph.file.layout", 22532ab0bd7SSage Weil .name_size = sizeof("ceph.file.layout"), 22632ab0bd7SSage Weil .getxattr_cb = ceph_vxattrcb_layout, 22732ab0bd7SSage Weil .readonly = false, 22832ab0bd7SSage Weil .hidden = false, 22932ab0bd7SSage Weil .exists_cb = ceph_vxattrcb_layout_exists, 23032ab0bd7SSage Weil }, 231695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, stripe_unit), 232695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, stripe_count), 233695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, object_size), 234695b7119SSage Weil XATTR_LAYOUT_FIELD(file, layout, pool), 235*2c3dd4ffSAlex Elder { .name = NULL, 0 } /* Required table terminator */ 236355da1ebSSage Weil }; 2373ce6cd12SAlex Elder static size_t ceph_file_vxattrs_name_size; /* total size of all names */ 238355da1ebSSage Weil 239881a5fa2SAlex Elder static struct ceph_vxattr *ceph_inode_vxattrs(struct inode *inode) 240355da1ebSSage Weil { 241355da1ebSSage Weil if (S_ISDIR(inode->i_mode)) 242355da1ebSSage Weil return ceph_dir_vxattrs; 243355da1ebSSage Weil else if (S_ISREG(inode->i_mode)) 244355da1ebSSage Weil return ceph_file_vxattrs; 245355da1ebSSage Weil return NULL; 246355da1ebSSage Weil } 247355da1ebSSage Weil 2483ce6cd12SAlex Elder static size_t ceph_vxattrs_name_size(struct ceph_vxattr *vxattrs) 2493ce6cd12SAlex Elder { 2503ce6cd12SAlex Elder if (vxattrs == ceph_dir_vxattrs) 2513ce6cd12SAlex Elder return ceph_dir_vxattrs_name_size; 2523ce6cd12SAlex Elder if (vxattrs == ceph_file_vxattrs) 2533ce6cd12SAlex Elder return ceph_file_vxattrs_name_size; 2543ce6cd12SAlex Elder BUG(); 2553ce6cd12SAlex Elder 2563ce6cd12SAlex Elder return 0; 2573ce6cd12SAlex Elder } 2583ce6cd12SAlex Elder 2593ce6cd12SAlex Elder /* 2603ce6cd12SAlex Elder * Compute the aggregate size (including terminating '\0') of all 2613ce6cd12SAlex Elder * virtual extended attribute names in the given vxattr table. 2623ce6cd12SAlex Elder */ 2633ce6cd12SAlex Elder static size_t __init vxattrs_name_size(struct ceph_vxattr *vxattrs) 2643ce6cd12SAlex Elder { 2653ce6cd12SAlex Elder struct ceph_vxattr *vxattr; 2663ce6cd12SAlex Elder size_t size = 0; 2673ce6cd12SAlex Elder 2683ce6cd12SAlex Elder for (vxattr = vxattrs; vxattr->name; vxattr++) 2698860147aSSage Weil if (!vxattr->hidden) 2703ce6cd12SAlex Elder size += vxattr->name_size; 2713ce6cd12SAlex Elder 2723ce6cd12SAlex Elder return size; 2733ce6cd12SAlex Elder } 2743ce6cd12SAlex Elder 2753ce6cd12SAlex Elder /* Routines called at initialization and exit time */ 2763ce6cd12SAlex Elder 2773ce6cd12SAlex Elder void __init ceph_xattr_init(void) 2783ce6cd12SAlex Elder { 2793ce6cd12SAlex Elder ceph_dir_vxattrs_name_size = vxattrs_name_size(ceph_dir_vxattrs); 2803ce6cd12SAlex Elder ceph_file_vxattrs_name_size = vxattrs_name_size(ceph_file_vxattrs); 2813ce6cd12SAlex Elder } 2823ce6cd12SAlex Elder 2833ce6cd12SAlex Elder void ceph_xattr_exit(void) 2843ce6cd12SAlex Elder { 2853ce6cd12SAlex Elder ceph_dir_vxattrs_name_size = 0; 2863ce6cd12SAlex Elder ceph_file_vxattrs_name_size = 0; 2873ce6cd12SAlex Elder } 2883ce6cd12SAlex Elder 289881a5fa2SAlex Elder static struct ceph_vxattr *ceph_match_vxattr(struct inode *inode, 290355da1ebSSage Weil const char *name) 291355da1ebSSage Weil { 292881a5fa2SAlex Elder struct ceph_vxattr *vxattr = ceph_inode_vxattrs(inode); 29306476a69SAlex Elder 29406476a69SAlex Elder if (vxattr) { 29506476a69SAlex Elder while (vxattr->name) { 29606476a69SAlex Elder if (!strcmp(vxattr->name, name)) 297355da1ebSSage Weil return vxattr; 298355da1ebSSage Weil vxattr++; 29906476a69SAlex Elder } 30006476a69SAlex Elder } 30106476a69SAlex Elder 302355da1ebSSage Weil return NULL; 303355da1ebSSage Weil } 304355da1ebSSage Weil 305355da1ebSSage Weil static int __set_xattr(struct ceph_inode_info *ci, 306355da1ebSSage Weil const char *name, int name_len, 307355da1ebSSage Weil const char *val, int val_len, 308355da1ebSSage Weil int dirty, 309355da1ebSSage Weil int should_free_name, int should_free_val, 310355da1ebSSage Weil struct ceph_inode_xattr **newxattr) 311355da1ebSSage Weil { 312355da1ebSSage Weil struct rb_node **p; 313355da1ebSSage Weil struct rb_node *parent = NULL; 314355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 315355da1ebSSage Weil int c; 316355da1ebSSage Weil int new = 0; 317355da1ebSSage Weil 318355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 319355da1ebSSage Weil while (*p) { 320355da1ebSSage Weil parent = *p; 321355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 322355da1ebSSage Weil c = strncmp(name, xattr->name, min(name_len, xattr->name_len)); 323355da1ebSSage Weil if (c < 0) 324355da1ebSSage Weil p = &(*p)->rb_left; 325355da1ebSSage Weil else if (c > 0) 326355da1ebSSage Weil p = &(*p)->rb_right; 327355da1ebSSage Weil else { 328355da1ebSSage Weil if (name_len == xattr->name_len) 329355da1ebSSage Weil break; 330355da1ebSSage Weil else if (name_len < xattr->name_len) 331355da1ebSSage Weil p = &(*p)->rb_left; 332355da1ebSSage Weil else 333355da1ebSSage Weil p = &(*p)->rb_right; 334355da1ebSSage Weil } 335355da1ebSSage Weil xattr = NULL; 336355da1ebSSage Weil } 337355da1ebSSage Weil 338355da1ebSSage Weil if (!xattr) { 339355da1ebSSage Weil new = 1; 340355da1ebSSage Weil xattr = *newxattr; 341355da1ebSSage Weil xattr->name = name; 342355da1ebSSage Weil xattr->name_len = name_len; 343355da1ebSSage Weil xattr->should_free_name = should_free_name; 344355da1ebSSage Weil 345355da1ebSSage Weil ci->i_xattrs.count++; 346355da1ebSSage Weil dout("__set_xattr count=%d\n", ci->i_xattrs.count); 347355da1ebSSage Weil } else { 348355da1ebSSage Weil kfree(*newxattr); 349355da1ebSSage Weil *newxattr = NULL; 350355da1ebSSage Weil if (xattr->should_free_val) 351355da1ebSSage Weil kfree((void *)xattr->val); 352355da1ebSSage Weil 353355da1ebSSage Weil if (should_free_name) { 354355da1ebSSage Weil kfree((void *)name); 355355da1ebSSage Weil name = xattr->name; 356355da1ebSSage Weil } 357355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 358355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 359355da1ebSSage Weil } 360355da1ebSSage Weil ci->i_xattrs.names_size += name_len; 361355da1ebSSage Weil ci->i_xattrs.vals_size += val_len; 362355da1ebSSage Weil if (val) 363355da1ebSSage Weil xattr->val = val; 364355da1ebSSage Weil else 365355da1ebSSage Weil xattr->val = ""; 366355da1ebSSage Weil 367355da1ebSSage Weil xattr->val_len = val_len; 368355da1ebSSage Weil xattr->dirty = dirty; 369355da1ebSSage Weil xattr->should_free_val = (val && should_free_val); 370355da1ebSSage Weil 371355da1ebSSage Weil if (new) { 372355da1ebSSage Weil rb_link_node(&xattr->node, parent, p); 373355da1ebSSage Weil rb_insert_color(&xattr->node, &ci->i_xattrs.index); 374355da1ebSSage Weil dout("__set_xattr_val p=%p\n", p); 375355da1ebSSage Weil } 376355da1ebSSage Weil 377355da1ebSSage Weil dout("__set_xattr_val added %llx.%llx xattr %p %s=%.*s\n", 378355da1ebSSage Weil ceph_vinop(&ci->vfs_inode), xattr, name, val_len, val); 379355da1ebSSage Weil 380355da1ebSSage Weil return 0; 381355da1ebSSage Weil } 382355da1ebSSage Weil 383355da1ebSSage Weil static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci, 384355da1ebSSage Weil const char *name) 385355da1ebSSage Weil { 386355da1ebSSage Weil struct rb_node **p; 387355da1ebSSage Weil struct rb_node *parent = NULL; 388355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 38917db143fSSage Weil int name_len = strlen(name); 390355da1ebSSage Weil int c; 391355da1ebSSage Weil 392355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 393355da1ebSSage Weil while (*p) { 394355da1ebSSage Weil parent = *p; 395355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 396355da1ebSSage Weil c = strncmp(name, xattr->name, xattr->name_len); 39717db143fSSage Weil if (c == 0 && name_len > xattr->name_len) 39817db143fSSage Weil c = 1; 399355da1ebSSage Weil if (c < 0) 400355da1ebSSage Weil p = &(*p)->rb_left; 401355da1ebSSage Weil else if (c > 0) 402355da1ebSSage Weil p = &(*p)->rb_right; 403355da1ebSSage Weil else { 404355da1ebSSage Weil dout("__get_xattr %s: found %.*s\n", name, 405355da1ebSSage Weil xattr->val_len, xattr->val); 406355da1ebSSage Weil return xattr; 407355da1ebSSage Weil } 408355da1ebSSage Weil } 409355da1ebSSage Weil 410355da1ebSSage Weil dout("__get_xattr %s: not found\n", name); 411355da1ebSSage Weil 412355da1ebSSage Weil return NULL; 413355da1ebSSage Weil } 414355da1ebSSage Weil 415355da1ebSSage Weil static void __free_xattr(struct ceph_inode_xattr *xattr) 416355da1ebSSage Weil { 417355da1ebSSage Weil BUG_ON(!xattr); 418355da1ebSSage Weil 419355da1ebSSage Weil if (xattr->should_free_name) 420355da1ebSSage Weil kfree((void *)xattr->name); 421355da1ebSSage Weil if (xattr->should_free_val) 422355da1ebSSage Weil kfree((void *)xattr->val); 423355da1ebSSage Weil 424355da1ebSSage Weil kfree(xattr); 425355da1ebSSage Weil } 426355da1ebSSage Weil 427355da1ebSSage Weil static int __remove_xattr(struct ceph_inode_info *ci, 428355da1ebSSage Weil struct ceph_inode_xattr *xattr) 429355da1ebSSage Weil { 430355da1ebSSage Weil if (!xattr) 431355da1ebSSage Weil return -EOPNOTSUPP; 432355da1ebSSage Weil 433355da1ebSSage Weil rb_erase(&xattr->node, &ci->i_xattrs.index); 434355da1ebSSage Weil 435355da1ebSSage Weil if (xattr->should_free_name) 436355da1ebSSage Weil kfree((void *)xattr->name); 437355da1ebSSage Weil if (xattr->should_free_val) 438355da1ebSSage Weil kfree((void *)xattr->val); 439355da1ebSSage Weil 440355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 441355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 442355da1ebSSage Weil ci->i_xattrs.count--; 443355da1ebSSage Weil kfree(xattr); 444355da1ebSSage Weil 445355da1ebSSage Weil return 0; 446355da1ebSSage Weil } 447355da1ebSSage Weil 448355da1ebSSage Weil static int __remove_xattr_by_name(struct ceph_inode_info *ci, 449355da1ebSSage Weil const char *name) 450355da1ebSSage Weil { 451355da1ebSSage Weil struct rb_node **p; 452355da1ebSSage Weil struct ceph_inode_xattr *xattr; 453355da1ebSSage Weil int err; 454355da1ebSSage Weil 455355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 456355da1ebSSage Weil xattr = __get_xattr(ci, name); 457355da1ebSSage Weil err = __remove_xattr(ci, xattr); 458355da1ebSSage Weil return err; 459355da1ebSSage Weil } 460355da1ebSSage Weil 461355da1ebSSage Weil static char *__copy_xattr_names(struct ceph_inode_info *ci, 462355da1ebSSage Weil char *dest) 463355da1ebSSage Weil { 464355da1ebSSage Weil struct rb_node *p; 465355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 466355da1ebSSage Weil 467355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 468355da1ebSSage Weil dout("__copy_xattr_names count=%d\n", ci->i_xattrs.count); 469355da1ebSSage Weil 470355da1ebSSage Weil while (p) { 471355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 472355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 473355da1ebSSage Weil dest[xattr->name_len] = '\0'; 474355da1ebSSage Weil 475355da1ebSSage Weil dout("dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name, 476355da1ebSSage Weil xattr->name_len, ci->i_xattrs.names_size); 477355da1ebSSage Weil 478355da1ebSSage Weil dest += xattr->name_len + 1; 479355da1ebSSage Weil p = rb_next(p); 480355da1ebSSage Weil } 481355da1ebSSage Weil 482355da1ebSSage Weil return dest; 483355da1ebSSage Weil } 484355da1ebSSage Weil 485355da1ebSSage Weil void __ceph_destroy_xattrs(struct ceph_inode_info *ci) 486355da1ebSSage Weil { 487355da1ebSSage Weil struct rb_node *p, *tmp; 488355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 489355da1ebSSage Weil 490355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 491355da1ebSSage Weil 492355da1ebSSage Weil dout("__ceph_destroy_xattrs p=%p\n", p); 493355da1ebSSage Weil 494355da1ebSSage Weil while (p) { 495355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 496355da1ebSSage Weil tmp = p; 497355da1ebSSage Weil p = rb_next(tmp); 498355da1ebSSage Weil dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p, 499355da1ebSSage Weil xattr->name_len, xattr->name); 500355da1ebSSage Weil rb_erase(tmp, &ci->i_xattrs.index); 501355da1ebSSage Weil 502355da1ebSSage Weil __free_xattr(xattr); 503355da1ebSSage Weil } 504355da1ebSSage Weil 505355da1ebSSage Weil ci->i_xattrs.names_size = 0; 506355da1ebSSage Weil ci->i_xattrs.vals_size = 0; 507355da1ebSSage Weil ci->i_xattrs.index_version = 0; 508355da1ebSSage Weil ci->i_xattrs.count = 0; 509355da1ebSSage Weil ci->i_xattrs.index = RB_ROOT; 510355da1ebSSage Weil } 511355da1ebSSage Weil 512355da1ebSSage Weil static int __build_xattrs(struct inode *inode) 513be655596SSage Weil __releases(ci->i_ceph_lock) 514be655596SSage Weil __acquires(ci->i_ceph_lock) 515355da1ebSSage Weil { 516355da1ebSSage Weil u32 namelen; 517355da1ebSSage Weil u32 numattr = 0; 518355da1ebSSage Weil void *p, *end; 519355da1ebSSage Weil u32 len; 520355da1ebSSage Weil const char *name, *val; 521355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 522355da1ebSSage Weil int xattr_version; 523355da1ebSSage Weil struct ceph_inode_xattr **xattrs = NULL; 52463ff78b2SSage Weil int err = 0; 525355da1ebSSage Weil int i; 526355da1ebSSage Weil 527355da1ebSSage Weil dout("__build_xattrs() len=%d\n", 528355da1ebSSage Weil ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0); 529355da1ebSSage Weil 530355da1ebSSage Weil if (ci->i_xattrs.index_version >= ci->i_xattrs.version) 531355da1ebSSage Weil return 0; /* already built */ 532355da1ebSSage Weil 533355da1ebSSage Weil __ceph_destroy_xattrs(ci); 534355da1ebSSage Weil 535355da1ebSSage Weil start: 536355da1ebSSage Weil /* updated internal xattr rb tree */ 537355da1ebSSage Weil if (ci->i_xattrs.blob && ci->i_xattrs.blob->vec.iov_len > 4) { 538355da1ebSSage Weil p = ci->i_xattrs.blob->vec.iov_base; 539355da1ebSSage Weil end = p + ci->i_xattrs.blob->vec.iov_len; 540355da1ebSSage Weil ceph_decode_32_safe(&p, end, numattr, bad); 541355da1ebSSage Weil xattr_version = ci->i_xattrs.version; 542be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 543355da1ebSSage Weil 544355da1ebSSage Weil xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *), 545355da1ebSSage Weil GFP_NOFS); 546355da1ebSSage Weil err = -ENOMEM; 547355da1ebSSage Weil if (!xattrs) 548355da1ebSSage Weil goto bad_lock; 549355da1ebSSage Weil memset(xattrs, 0, numattr*sizeof(struct ceph_xattr *)); 550355da1ebSSage Weil for (i = 0; i < numattr; i++) { 551355da1ebSSage Weil xattrs[i] = kmalloc(sizeof(struct ceph_inode_xattr), 552355da1ebSSage Weil GFP_NOFS); 553355da1ebSSage Weil if (!xattrs[i]) 554355da1ebSSage Weil goto bad_lock; 555355da1ebSSage Weil } 556355da1ebSSage Weil 557be655596SSage Weil spin_lock(&ci->i_ceph_lock); 558355da1ebSSage Weil if (ci->i_xattrs.version != xattr_version) { 559355da1ebSSage Weil /* lost a race, retry */ 560355da1ebSSage Weil for (i = 0; i < numattr; i++) 561355da1ebSSage Weil kfree(xattrs[i]); 562355da1ebSSage Weil kfree(xattrs); 56321ec6ffaSAlan Cox xattrs = NULL; 564355da1ebSSage Weil goto start; 565355da1ebSSage Weil } 566355da1ebSSage Weil err = -EIO; 567355da1ebSSage Weil while (numattr--) { 568355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 569355da1ebSSage Weil namelen = len; 570355da1ebSSage Weil name = p; 571355da1ebSSage Weil p += len; 572355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 573355da1ebSSage Weil val = p; 574355da1ebSSage Weil p += len; 575355da1ebSSage Weil 576355da1ebSSage Weil err = __set_xattr(ci, name, namelen, val, len, 577355da1ebSSage Weil 0, 0, 0, &xattrs[numattr]); 578355da1ebSSage Weil 579355da1ebSSage Weil if (err < 0) 580355da1ebSSage Weil goto bad; 581355da1ebSSage Weil } 582355da1ebSSage Weil kfree(xattrs); 583355da1ebSSage Weil } 584355da1ebSSage Weil ci->i_xattrs.index_version = ci->i_xattrs.version; 585355da1ebSSage Weil ci->i_xattrs.dirty = false; 586355da1ebSSage Weil 587355da1ebSSage Weil return err; 588355da1ebSSage Weil bad_lock: 589be655596SSage Weil spin_lock(&ci->i_ceph_lock); 590355da1ebSSage Weil bad: 591355da1ebSSage Weil if (xattrs) { 592355da1ebSSage Weil for (i = 0; i < numattr; i++) 593355da1ebSSage Weil kfree(xattrs[i]); 594355da1ebSSage Weil kfree(xattrs); 595355da1ebSSage Weil } 596355da1ebSSage Weil ci->i_xattrs.names_size = 0; 597355da1ebSSage Weil return err; 598355da1ebSSage Weil } 599355da1ebSSage Weil 600355da1ebSSage Weil static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size, 601355da1ebSSage Weil int val_size) 602355da1ebSSage Weil { 603355da1ebSSage Weil /* 604355da1ebSSage Weil * 4 bytes for the length, and additional 4 bytes per each xattr name, 605355da1ebSSage Weil * 4 bytes per each value 606355da1ebSSage Weil */ 607355da1ebSSage Weil int size = 4 + ci->i_xattrs.count*(4 + 4) + 608355da1ebSSage Weil ci->i_xattrs.names_size + 609355da1ebSSage Weil ci->i_xattrs.vals_size; 610355da1ebSSage Weil dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n", 611355da1ebSSage Weil ci->i_xattrs.count, ci->i_xattrs.names_size, 612355da1ebSSage Weil ci->i_xattrs.vals_size); 613355da1ebSSage Weil 614355da1ebSSage Weil if (name_size) 615355da1ebSSage Weil size += 4 + 4 + name_size + val_size; 616355da1ebSSage Weil 617355da1ebSSage Weil return size; 618355da1ebSSage Weil } 619355da1ebSSage Weil 620355da1ebSSage Weil /* 621355da1ebSSage Weil * If there are dirty xattrs, reencode xattrs into the prealloc_blob 622355da1ebSSage Weil * and swap into place. 623355da1ebSSage Weil */ 624355da1ebSSage Weil void __ceph_build_xattrs_blob(struct ceph_inode_info *ci) 625355da1ebSSage Weil { 626355da1ebSSage Weil struct rb_node *p; 627355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 628355da1ebSSage Weil void *dest; 629355da1ebSSage Weil 630355da1ebSSage Weil dout("__build_xattrs_blob %p\n", &ci->vfs_inode); 631355da1ebSSage Weil if (ci->i_xattrs.dirty) { 632355da1ebSSage Weil int need = __get_required_blob_size(ci, 0, 0); 633355da1ebSSage Weil 634355da1ebSSage Weil BUG_ON(need > ci->i_xattrs.prealloc_blob->alloc_len); 635355da1ebSSage Weil 636355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 637355da1ebSSage Weil dest = ci->i_xattrs.prealloc_blob->vec.iov_base; 638355da1ebSSage Weil 639355da1ebSSage Weil ceph_encode_32(&dest, ci->i_xattrs.count); 640355da1ebSSage Weil while (p) { 641355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 642355da1ebSSage Weil 643355da1ebSSage Weil ceph_encode_32(&dest, xattr->name_len); 644355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 645355da1ebSSage Weil dest += xattr->name_len; 646355da1ebSSage Weil ceph_encode_32(&dest, xattr->val_len); 647355da1ebSSage Weil memcpy(dest, xattr->val, xattr->val_len); 648355da1ebSSage Weil dest += xattr->val_len; 649355da1ebSSage Weil 650355da1ebSSage Weil p = rb_next(p); 651355da1ebSSage Weil } 652355da1ebSSage Weil 653355da1ebSSage Weil /* adjust buffer len; it may be larger than we need */ 654355da1ebSSage Weil ci->i_xattrs.prealloc_blob->vec.iov_len = 655355da1ebSSage Weil dest - ci->i_xattrs.prealloc_blob->vec.iov_base; 656355da1ebSSage Weil 657b6c1d5b8SSage Weil if (ci->i_xattrs.blob) 658355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.blob); 659355da1ebSSage Weil ci->i_xattrs.blob = ci->i_xattrs.prealloc_blob; 660355da1ebSSage Weil ci->i_xattrs.prealloc_blob = NULL; 661355da1ebSSage Weil ci->i_xattrs.dirty = false; 6624a625be4SSage Weil ci->i_xattrs.version++; 663355da1ebSSage Weil } 664355da1ebSSage Weil } 665355da1ebSSage Weil 666355da1ebSSage Weil ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value, 667355da1ebSSage Weil size_t size) 668355da1ebSSage Weil { 669355da1ebSSage Weil struct inode *inode = dentry->d_inode; 670355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 671355da1ebSSage Weil int err; 672355da1ebSSage Weil struct ceph_inode_xattr *xattr; 673881a5fa2SAlex Elder struct ceph_vxattr *vxattr = NULL; 674355da1ebSSage Weil 675355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 676355da1ebSSage Weil return -ENODATA; 677355da1ebSSage Weil 678be655596SSage Weil spin_lock(&ci->i_ceph_lock); 679355da1ebSSage Weil dout("getxattr %p ver=%lld index_ver=%lld\n", inode, 680355da1ebSSage Weil ci->i_xattrs.version, ci->i_xattrs.index_version); 681355da1ebSSage Weil 6820bee82fbSSage Weil /* let's see if a virtual xattr was requested */ 6830bee82fbSSage Weil vxattr = ceph_match_vxattr(inode, name); 6840bee82fbSSage Weil if (vxattr && !(vxattr->exists_cb && !vxattr->exists_cb(ci))) { 6850bee82fbSSage Weil err = vxattr->getxattr_cb(ci, value, size); 6860bee82fbSSage Weil goto out; 6870bee82fbSSage Weil } 6880bee82fbSSage Weil 689355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 690355da1ebSSage Weil (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 691355da1ebSSage Weil goto get_xattr; 692355da1ebSSage Weil } else { 693be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 694355da1ebSSage Weil /* get xattrs from mds (if we don't already have them) */ 695355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 696355da1ebSSage Weil if (err) 697355da1ebSSage Weil return err; 698355da1ebSSage Weil } 699355da1ebSSage Weil 700be655596SSage Weil spin_lock(&ci->i_ceph_lock); 701355da1ebSSage Weil 702355da1ebSSage Weil err = __build_xattrs(inode); 703355da1ebSSage Weil if (err < 0) 704355da1ebSSage Weil goto out; 705355da1ebSSage Weil 706355da1ebSSage Weil get_xattr: 707355da1ebSSage Weil err = -ENODATA; /* == ENOATTR */ 708355da1ebSSage Weil xattr = __get_xattr(ci, name); 7090bee82fbSSage Weil if (!xattr) 710355da1ebSSage Weil goto out; 711355da1ebSSage Weil 712355da1ebSSage Weil err = -ERANGE; 713355da1ebSSage Weil if (size && size < xattr->val_len) 714355da1ebSSage Weil goto out; 715355da1ebSSage Weil 716355da1ebSSage Weil err = xattr->val_len; 717355da1ebSSage Weil if (size == 0) 718355da1ebSSage Weil goto out; 719355da1ebSSage Weil 720355da1ebSSage Weil memcpy(value, xattr->val, xattr->val_len); 721355da1ebSSage Weil 722355da1ebSSage Weil out: 723be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 724355da1ebSSage Weil return err; 725355da1ebSSage Weil } 726355da1ebSSage Weil 727355da1ebSSage Weil ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size) 728355da1ebSSage Weil { 729355da1ebSSage Weil struct inode *inode = dentry->d_inode; 730355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 731881a5fa2SAlex Elder struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode); 732355da1ebSSage Weil u32 vir_namelen = 0; 733355da1ebSSage Weil u32 namelen; 734355da1ebSSage Weil int err; 735355da1ebSSage Weil u32 len; 736355da1ebSSage Weil int i; 737355da1ebSSage Weil 738be655596SSage Weil spin_lock(&ci->i_ceph_lock); 739355da1ebSSage Weil dout("listxattr %p ver=%lld index_ver=%lld\n", inode, 740355da1ebSSage Weil ci->i_xattrs.version, ci->i_xattrs.index_version); 741355da1ebSSage Weil 742355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 743bddfa3ccSHenry C Chang (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 744355da1ebSSage Weil goto list_xattr; 745355da1ebSSage Weil } else { 746be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 747355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 748355da1ebSSage Weil if (err) 749355da1ebSSage Weil return err; 750355da1ebSSage Weil } 751355da1ebSSage Weil 752be655596SSage Weil spin_lock(&ci->i_ceph_lock); 753355da1ebSSage Weil 754355da1ebSSage Weil err = __build_xattrs(inode); 755355da1ebSSage Weil if (err < 0) 756355da1ebSSage Weil goto out; 757355da1ebSSage Weil 758355da1ebSSage Weil list_xattr: 7593ce6cd12SAlex Elder /* 7603ce6cd12SAlex Elder * Start with virtual dir xattr names (if any) (including 7613ce6cd12SAlex Elder * terminating '\0' characters for each). 7623ce6cd12SAlex Elder */ 7633ce6cd12SAlex Elder vir_namelen = ceph_vxattrs_name_size(vxattrs); 7643ce6cd12SAlex Elder 765355da1ebSSage Weil /* adding 1 byte per each variable due to the null termination */ 766b65917ddSSage Weil namelen = ci->i_xattrs.names_size + ci->i_xattrs.count; 767355da1ebSSage Weil err = -ERANGE; 768b65917ddSSage Weil if (size && vir_namelen + namelen > size) 769355da1ebSSage Weil goto out; 770355da1ebSSage Weil 771b65917ddSSage Weil err = namelen + vir_namelen; 772355da1ebSSage Weil if (size == 0) 773355da1ebSSage Weil goto out; 774355da1ebSSage Weil 775355da1ebSSage Weil names = __copy_xattr_names(ci, names); 776355da1ebSSage Weil 777355da1ebSSage Weil /* virtual xattr names, too */ 778b65917ddSSage Weil err = namelen; 779b65917ddSSage Weil if (vxattrs) { 780355da1ebSSage Weil for (i = 0; vxattrs[i].name; i++) { 781b65917ddSSage Weil if (!vxattrs[i].hidden && 782b65917ddSSage Weil !(vxattrs[i].exists_cb && 783b65917ddSSage Weil !vxattrs[i].exists_cb(ci))) { 784355da1ebSSage Weil len = sprintf(names, "%s", vxattrs[i].name); 785355da1ebSSage Weil names += len + 1; 786b65917ddSSage Weil err += len + 1; 787b65917ddSSage Weil } 788b65917ddSSage Weil } 789355da1ebSSage Weil } 790355da1ebSSage Weil 791355da1ebSSage Weil out: 792be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 793355da1ebSSage Weil return err; 794355da1ebSSage Weil } 795355da1ebSSage Weil 796355da1ebSSage Weil static int ceph_sync_setxattr(struct dentry *dentry, const char *name, 797355da1ebSSage Weil const char *value, size_t size, int flags) 798355da1ebSSage Weil { 7993d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 800355da1ebSSage Weil struct inode *inode = dentry->d_inode; 801355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 8025f21c96dSSage Weil struct inode *parent_inode; 803355da1ebSSage Weil struct ceph_mds_request *req; 8043d14c5d2SYehuda Sadeh struct ceph_mds_client *mdsc = fsc->mdsc; 805355da1ebSSage Weil int err; 806355da1ebSSage Weil int i, nr_pages; 807355da1ebSSage Weil struct page **pages = NULL; 808355da1ebSSage Weil void *kaddr; 809355da1ebSSage Weil 810355da1ebSSage Weil /* copy value into some pages */ 811355da1ebSSage Weil nr_pages = calc_pages_for(0, size); 812355da1ebSSage Weil if (nr_pages) { 813355da1ebSSage Weil pages = kmalloc(sizeof(pages[0])*nr_pages, GFP_NOFS); 814355da1ebSSage Weil if (!pages) 815355da1ebSSage Weil return -ENOMEM; 816355da1ebSSage Weil err = -ENOMEM; 817355da1ebSSage Weil for (i = 0; i < nr_pages; i++) { 81831459fe4SYehuda Sadeh pages[i] = __page_cache_alloc(GFP_NOFS); 819355da1ebSSage Weil if (!pages[i]) { 820355da1ebSSage Weil nr_pages = i; 821355da1ebSSage Weil goto out; 822355da1ebSSage Weil } 823355da1ebSSage Weil kaddr = kmap(pages[i]); 824355da1ebSSage Weil memcpy(kaddr, value + i*PAGE_CACHE_SIZE, 825355da1ebSSage Weil min(PAGE_CACHE_SIZE, size-i*PAGE_CACHE_SIZE)); 826355da1ebSSage Weil } 827355da1ebSSage Weil } 828355da1ebSSage Weil 829355da1ebSSage Weil dout("setxattr value=%.*s\n", (int)size, value); 830355da1ebSSage Weil 831355da1ebSSage Weil /* do request */ 832355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETXATTR, 833355da1ebSSage Weil USE_AUTH_MDS); 83460d87733SJulia Lawall if (IS_ERR(req)) { 83560d87733SJulia Lawall err = PTR_ERR(req); 83660d87733SJulia Lawall goto out; 83760d87733SJulia Lawall } 83870b666c3SSage Weil req->r_inode = inode; 83970b666c3SSage Weil ihold(inode); 840355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 841355da1ebSSage Weil req->r_num_caps = 1; 842355da1ebSSage Weil req->r_args.setxattr.flags = cpu_to_le32(flags); 843355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 844355da1ebSSage Weil 845355da1ebSSage Weil req->r_pages = pages; 846355da1ebSSage Weil req->r_num_pages = nr_pages; 847355da1ebSSage Weil req->r_data_len = size; 848355da1ebSSage Weil 849355da1ebSSage Weil dout("xattr.ver (before): %lld\n", ci->i_xattrs.version); 8505f21c96dSSage Weil parent_inode = ceph_get_dentry_parent_inode(dentry); 851355da1ebSSage Weil err = ceph_mdsc_do_request(mdsc, parent_inode, req); 8525f21c96dSSage Weil iput(parent_inode); 853355da1ebSSage Weil ceph_mdsc_put_request(req); 854355da1ebSSage Weil dout("xattr.ver (after): %lld\n", ci->i_xattrs.version); 855355da1ebSSage Weil 856355da1ebSSage Weil out: 857355da1ebSSage Weil if (pages) { 858355da1ebSSage Weil for (i = 0; i < nr_pages; i++) 859355da1ebSSage Weil __free_page(pages[i]); 860355da1ebSSage Weil kfree(pages); 861355da1ebSSage Weil } 862355da1ebSSage Weil return err; 863355da1ebSSage Weil } 864355da1ebSSage Weil 865355da1ebSSage Weil int ceph_setxattr(struct dentry *dentry, const char *name, 866355da1ebSSage Weil const void *value, size_t size, int flags) 867355da1ebSSage Weil { 868355da1ebSSage Weil struct inode *inode = dentry->d_inode; 869881a5fa2SAlex Elder struct ceph_vxattr *vxattr; 870355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 87118fa8b3fSAlex Elder int issued; 872355da1ebSSage Weil int err; 87318fa8b3fSAlex Elder int dirty; 874355da1ebSSage Weil int name_len = strlen(name); 875355da1ebSSage Weil int val_len = size; 876355da1ebSSage Weil char *newname = NULL; 877355da1ebSSage Weil char *newval = NULL; 878355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 879355da1ebSSage Weil int required_blob_size; 880355da1ebSSage Weil 881355da1ebSSage Weil if (ceph_snap(inode) != CEPH_NOSNAP) 882355da1ebSSage Weil return -EROFS; 883355da1ebSSage Weil 884355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 885355da1ebSSage Weil return -EOPNOTSUPP; 886355da1ebSSage Weil 88706476a69SAlex Elder vxattr = ceph_match_vxattr(inode, name); 888355da1ebSSage Weil if (vxattr && vxattr->readonly) 889355da1ebSSage Weil return -EOPNOTSUPP; 890355da1ebSSage Weil 8913adf654dSSage Weil /* pass any unhandled ceph.* xattrs through to the MDS */ 8923adf654dSSage Weil if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN)) 8933adf654dSSage Weil goto do_sync_unlocked; 8943adf654dSSage Weil 895355da1ebSSage Weil /* preallocate memory for xattr name, value, index node */ 896355da1ebSSage Weil err = -ENOMEM; 89761413c2fSJulia Lawall newname = kmemdup(name, name_len + 1, GFP_NOFS); 898355da1ebSSage Weil if (!newname) 899355da1ebSSage Weil goto out; 900355da1ebSSage Weil 901355da1ebSSage Weil if (val_len) { 902b829c195SAlex Elder newval = kmemdup(value, val_len, GFP_NOFS); 903355da1ebSSage Weil if (!newval) 904355da1ebSSage Weil goto out; 905355da1ebSSage Weil } 906355da1ebSSage Weil 907355da1ebSSage Weil xattr = kmalloc(sizeof(struct ceph_inode_xattr), GFP_NOFS); 908355da1ebSSage Weil if (!xattr) 909355da1ebSSage Weil goto out; 910355da1ebSSage Weil 911be655596SSage Weil spin_lock(&ci->i_ceph_lock); 912355da1ebSSage Weil retry: 913355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 91418fa8b3fSAlex Elder dout("setxattr %p issued %s\n", inode, ceph_cap_string(issued)); 915355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 916355da1ebSSage Weil goto do_sync; 917355da1ebSSage Weil __build_xattrs(inode); 918355da1ebSSage Weil 919355da1ebSSage Weil required_blob_size = __get_required_blob_size(ci, name_len, val_len); 920355da1ebSSage Weil 921355da1ebSSage Weil if (!ci->i_xattrs.prealloc_blob || 922355da1ebSSage Weil required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 92318fa8b3fSAlex Elder struct ceph_buffer *blob; 924355da1ebSSage Weil 925be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 926355da1ebSSage Weil dout(" preaallocating new blob size=%d\n", required_blob_size); 927b6c1d5b8SSage Weil blob = ceph_buffer_new(required_blob_size, GFP_NOFS); 928355da1ebSSage Weil if (!blob) 929355da1ebSSage Weil goto out; 930be655596SSage Weil spin_lock(&ci->i_ceph_lock); 931b6c1d5b8SSage Weil if (ci->i_xattrs.prealloc_blob) 932355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.prealloc_blob); 933355da1ebSSage Weil ci->i_xattrs.prealloc_blob = blob; 934355da1ebSSage Weil goto retry; 935355da1ebSSage Weil } 936355da1ebSSage Weil 937355da1ebSSage Weil err = __set_xattr(ci, newname, name_len, newval, 938355da1ebSSage Weil val_len, 1, 1, 1, &xattr); 93918fa8b3fSAlex Elder 940fca65b4aSSage Weil dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 941355da1ebSSage Weil ci->i_xattrs.dirty = true; 942355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 94318fa8b3fSAlex Elder 944be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 945fca65b4aSSage Weil if (dirty) 946fca65b4aSSage Weil __mark_inode_dirty(inode, dirty); 947355da1ebSSage Weil return err; 948355da1ebSSage Weil 949355da1ebSSage Weil do_sync: 950be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 9513adf654dSSage Weil do_sync_unlocked: 952355da1ebSSage Weil err = ceph_sync_setxattr(dentry, name, value, size, flags); 953355da1ebSSage Weil out: 954355da1ebSSage Weil kfree(newname); 955355da1ebSSage Weil kfree(newval); 956355da1ebSSage Weil kfree(xattr); 957355da1ebSSage Weil return err; 958355da1ebSSage Weil } 959355da1ebSSage Weil 960355da1ebSSage Weil static int ceph_send_removexattr(struct dentry *dentry, const char *name) 961355da1ebSSage Weil { 9623d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 9633d14c5d2SYehuda Sadeh struct ceph_mds_client *mdsc = fsc->mdsc; 964355da1ebSSage Weil struct inode *inode = dentry->d_inode; 9655f21c96dSSage Weil struct inode *parent_inode; 966355da1ebSSage Weil struct ceph_mds_request *req; 967355da1ebSSage Weil int err; 968355da1ebSSage Weil 969355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RMXATTR, 970355da1ebSSage Weil USE_AUTH_MDS); 971355da1ebSSage Weil if (IS_ERR(req)) 972355da1ebSSage Weil return PTR_ERR(req); 97370b666c3SSage Weil req->r_inode = inode; 97470b666c3SSage Weil ihold(inode); 975355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 976355da1ebSSage Weil req->r_num_caps = 1; 977355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 978355da1ebSSage Weil 9795f21c96dSSage Weil parent_inode = ceph_get_dentry_parent_inode(dentry); 980355da1ebSSage Weil err = ceph_mdsc_do_request(mdsc, parent_inode, req); 9815f21c96dSSage Weil iput(parent_inode); 982355da1ebSSage Weil ceph_mdsc_put_request(req); 983355da1ebSSage Weil return err; 984355da1ebSSage Weil } 985355da1ebSSage Weil 986355da1ebSSage Weil int ceph_removexattr(struct dentry *dentry, const char *name) 987355da1ebSSage Weil { 988355da1ebSSage Weil struct inode *inode = dentry->d_inode; 989881a5fa2SAlex Elder struct ceph_vxattr *vxattr; 990355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 991355da1ebSSage Weil int issued; 992355da1ebSSage Weil int err; 99383eb26afSAlex Elder int required_blob_size; 994fca65b4aSSage Weil int dirty; 995355da1ebSSage Weil 996355da1ebSSage Weil if (ceph_snap(inode) != CEPH_NOSNAP) 997355da1ebSSage Weil return -EROFS; 998355da1ebSSage Weil 999355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 1000355da1ebSSage Weil return -EOPNOTSUPP; 1001355da1ebSSage Weil 100206476a69SAlex Elder vxattr = ceph_match_vxattr(inode, name); 1003355da1ebSSage Weil if (vxattr && vxattr->readonly) 1004355da1ebSSage Weil return -EOPNOTSUPP; 1005355da1ebSSage Weil 1006d421acb1SSage Weil /* pass any unhandled ceph.* xattrs through to the MDS */ 1007d421acb1SSage Weil if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN)) 1008d421acb1SSage Weil goto do_sync_unlocked; 1009d421acb1SSage Weil 101083eb26afSAlex Elder err = -ENOMEM; 1011be655596SSage Weil spin_lock(&ci->i_ceph_lock); 101283eb26afSAlex Elder retry: 1013355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 1014355da1ebSSage Weil dout("removexattr %p issued %s\n", inode, ceph_cap_string(issued)); 1015355da1ebSSage Weil 1016355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 1017355da1ebSSage Weil goto do_sync; 101818fa8b3fSAlex Elder __build_xattrs(inode); 1019355da1ebSSage Weil 102083eb26afSAlex Elder required_blob_size = __get_required_blob_size(ci, 0, 0); 102183eb26afSAlex Elder 102283eb26afSAlex Elder if (!ci->i_xattrs.prealloc_blob || 102383eb26afSAlex Elder required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 102483eb26afSAlex Elder struct ceph_buffer *blob; 102583eb26afSAlex Elder 102683eb26afSAlex Elder spin_unlock(&ci->i_ceph_lock); 102783eb26afSAlex Elder dout(" preaallocating new blob size=%d\n", required_blob_size); 102883eb26afSAlex Elder blob = ceph_buffer_new(required_blob_size, GFP_NOFS); 102983eb26afSAlex Elder if (!blob) 103083eb26afSAlex Elder goto out; 103183eb26afSAlex Elder spin_lock(&ci->i_ceph_lock); 103283eb26afSAlex Elder if (ci->i_xattrs.prealloc_blob) 103383eb26afSAlex Elder ceph_buffer_put(ci->i_xattrs.prealloc_blob); 103483eb26afSAlex Elder ci->i_xattrs.prealloc_blob = blob; 103583eb26afSAlex Elder goto retry; 103683eb26afSAlex Elder } 103783eb26afSAlex Elder 1038355da1ebSSage Weil err = __remove_xattr_by_name(ceph_inode(inode), name); 103918fa8b3fSAlex Elder 1040fca65b4aSSage Weil dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 1041355da1ebSSage Weil ci->i_xattrs.dirty = true; 1042355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 1043be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 1044fca65b4aSSage Weil if (dirty) 1045fca65b4aSSage Weil __mark_inode_dirty(inode, dirty); 1046355da1ebSSage Weil return err; 1047355da1ebSSage Weil do_sync: 1048be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 1049d421acb1SSage Weil do_sync_unlocked: 1050355da1ebSSage Weil err = ceph_send_removexattr(dentry, name); 105183eb26afSAlex Elder out: 1052355da1ebSSage Weil return err; 1053355da1ebSSage Weil } 1054355da1ebSSage Weil 1055