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); 32eb788084SAlex Elder bool readonly; 33355da1ebSSage Weil }; 34355da1ebSSage Weil 35355da1ebSSage Weil /* directories */ 36355da1ebSSage Weil 37aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info *ci, char *val, 38355da1ebSSage Weil size_t size) 39355da1ebSSage Weil { 40355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs); 41355da1ebSSage Weil } 42355da1ebSSage Weil 43aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_files(struct ceph_inode_info *ci, char *val, 44355da1ebSSage Weil size_t size) 45355da1ebSSage Weil { 46355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files); 47355da1ebSSage Weil } 48355da1ebSSage Weil 49aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_subdirs(struct ceph_inode_info *ci, char *val, 50355da1ebSSage Weil size_t size) 51355da1ebSSage Weil { 52355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_subdirs); 53355da1ebSSage Weil } 54355da1ebSSage Weil 55aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rentries(struct ceph_inode_info *ci, char *val, 56355da1ebSSage Weil size_t size) 57355da1ebSSage Weil { 58355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs); 59355da1ebSSage Weil } 60355da1ebSSage Weil 61aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rfiles(struct ceph_inode_info *ci, char *val, 62355da1ebSSage Weil size_t size) 63355da1ebSSage Weil { 64355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles); 65355da1ebSSage Weil } 66355da1ebSSage Weil 67aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info *ci, char *val, 68355da1ebSSage Weil size_t size) 69355da1ebSSage Weil { 70355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rsubdirs); 71355da1ebSSage Weil } 72355da1ebSSage Weil 73aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rbytes(struct ceph_inode_info *ci, char *val, 74355da1ebSSage Weil size_t size) 75355da1ebSSage Weil { 76355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rbytes); 77355da1ebSSage Weil } 78355da1ebSSage Weil 79aa4066edSAlex Elder static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info *ci, char *val, 80355da1ebSSage Weil size_t size) 81355da1ebSSage Weil { 823489b42aSAlex Elder return snprintf(val, size, "%ld.09%ld", (long)ci->i_rctime.tv_sec, 83355da1ebSSage Weil (long)ci->i_rctime.tv_nsec); 84355da1ebSSage Weil } 85355da1ebSSage Weil 86eb788084SAlex Elder #define CEPH_XATTR_NAME(_type, _name) XATTR_CEPH_PREFIX #_type "." #_name 87eb788084SAlex Elder 88eb788084SAlex Elder #define XATTR_NAME_CEPH(_type, _name) \ 89eb788084SAlex Elder { \ 90eb788084SAlex Elder .name = CEPH_XATTR_NAME(_type, _name), \ 913ce6cd12SAlex Elder .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \ 92aa4066edSAlex Elder .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \ 93eb788084SAlex Elder .readonly = true, \ 94eb788084SAlex Elder } 95eb788084SAlex Elder 96881a5fa2SAlex Elder static struct ceph_vxattr ceph_dir_vxattrs[] = { 97eb788084SAlex Elder XATTR_NAME_CEPH(dir, entries), 98eb788084SAlex Elder XATTR_NAME_CEPH(dir, files), 99eb788084SAlex Elder XATTR_NAME_CEPH(dir, subdirs), 100eb788084SAlex Elder XATTR_NAME_CEPH(dir, rentries), 101eb788084SAlex Elder XATTR_NAME_CEPH(dir, rfiles), 102eb788084SAlex Elder XATTR_NAME_CEPH(dir, rsubdirs), 103eb788084SAlex Elder XATTR_NAME_CEPH(dir, rbytes), 104eb788084SAlex Elder XATTR_NAME_CEPH(dir, rctime), 105eb788084SAlex Elder { 0 } /* Required table terminator */ 106355da1ebSSage Weil }; 1073ce6cd12SAlex Elder static size_t ceph_dir_vxattrs_name_size; /* total size of all names */ 108355da1ebSSage Weil 109355da1ebSSage Weil /* files */ 110355da1ebSSage Weil 111aa4066edSAlex Elder static size_t ceph_vxattrcb_file_layout(struct ceph_inode_info *ci, char *val, 112355da1ebSSage Weil size_t size) 113355da1ebSSage Weil { 114b195befdSSage Weil int ret; 115b195befdSSage Weil 116b195befdSSage Weil ret = snprintf(val, size, 117355da1ebSSage Weil "chunk_bytes=%lld\nstripe_count=%lld\nobject_size=%lld\n", 118355da1ebSSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout), 119355da1ebSSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout), 120355da1ebSSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout)); 121b195befdSSage Weil return ret; 122355da1ebSSage Weil } 123355da1ebSSage Weil 124881a5fa2SAlex Elder static struct ceph_vxattr ceph_file_vxattrs[] = { 125eb788084SAlex Elder XATTR_NAME_CEPH(file, layout), 126114fc474SAlex Elder /* The following extended attribute name is deprecated */ 127eb788084SAlex Elder { 128eb788084SAlex Elder .name = XATTR_CEPH_PREFIX "layout", 1293ce6cd12SAlex Elder .name_size = sizeof (XATTR_CEPH_PREFIX "layout"), 130aa4066edSAlex Elder .getxattr_cb = ceph_vxattrcb_file_layout, 131eb788084SAlex Elder .readonly = true, 132eb788084SAlex Elder }, 133eb788084SAlex Elder { 0 } /* Required table terminator */ 134355da1ebSSage Weil }; 1353ce6cd12SAlex Elder static size_t ceph_file_vxattrs_name_size; /* total size of all names */ 136355da1ebSSage Weil 137881a5fa2SAlex Elder static struct ceph_vxattr *ceph_inode_vxattrs(struct inode *inode) 138355da1ebSSage Weil { 139355da1ebSSage Weil if (S_ISDIR(inode->i_mode)) 140355da1ebSSage Weil return ceph_dir_vxattrs; 141355da1ebSSage Weil else if (S_ISREG(inode->i_mode)) 142355da1ebSSage Weil return ceph_file_vxattrs; 143355da1ebSSage Weil return NULL; 144355da1ebSSage Weil } 145355da1ebSSage Weil 1463ce6cd12SAlex Elder static size_t ceph_vxattrs_name_size(struct ceph_vxattr *vxattrs) 1473ce6cd12SAlex Elder { 1483ce6cd12SAlex Elder if (vxattrs == ceph_dir_vxattrs) 1493ce6cd12SAlex Elder return ceph_dir_vxattrs_name_size; 1503ce6cd12SAlex Elder if (vxattrs == ceph_file_vxattrs) 1513ce6cd12SAlex Elder return ceph_file_vxattrs_name_size; 1523ce6cd12SAlex Elder BUG(); 1533ce6cd12SAlex Elder 1543ce6cd12SAlex Elder return 0; 1553ce6cd12SAlex Elder } 1563ce6cd12SAlex Elder 1573ce6cd12SAlex Elder /* 1583ce6cd12SAlex Elder * Compute the aggregate size (including terminating '\0') of all 1593ce6cd12SAlex Elder * virtual extended attribute names in the given vxattr table. 1603ce6cd12SAlex Elder */ 1613ce6cd12SAlex Elder static size_t __init vxattrs_name_size(struct ceph_vxattr *vxattrs) 1623ce6cd12SAlex Elder { 1633ce6cd12SAlex Elder struct ceph_vxattr *vxattr; 1643ce6cd12SAlex Elder size_t size = 0; 1653ce6cd12SAlex Elder 1663ce6cd12SAlex Elder for (vxattr = vxattrs; vxattr->name; vxattr++) 1673ce6cd12SAlex Elder size += vxattr->name_size; 1683ce6cd12SAlex Elder 1693ce6cd12SAlex Elder return size; 1703ce6cd12SAlex Elder } 1713ce6cd12SAlex Elder 1723ce6cd12SAlex Elder /* Routines called at initialization and exit time */ 1733ce6cd12SAlex Elder 1743ce6cd12SAlex Elder void __init ceph_xattr_init(void) 1753ce6cd12SAlex Elder { 1763ce6cd12SAlex Elder ceph_dir_vxattrs_name_size = vxattrs_name_size(ceph_dir_vxattrs); 1773ce6cd12SAlex Elder ceph_file_vxattrs_name_size = vxattrs_name_size(ceph_file_vxattrs); 1783ce6cd12SAlex Elder } 1793ce6cd12SAlex Elder 1803ce6cd12SAlex Elder void ceph_xattr_exit(void) 1813ce6cd12SAlex Elder { 1823ce6cd12SAlex Elder ceph_dir_vxattrs_name_size = 0; 1833ce6cd12SAlex Elder ceph_file_vxattrs_name_size = 0; 1843ce6cd12SAlex Elder } 1853ce6cd12SAlex Elder 186881a5fa2SAlex Elder static struct ceph_vxattr *ceph_match_vxattr(struct inode *inode, 187355da1ebSSage Weil const char *name) 188355da1ebSSage Weil { 189881a5fa2SAlex Elder struct ceph_vxattr *vxattr = ceph_inode_vxattrs(inode); 19006476a69SAlex Elder 19106476a69SAlex Elder if (vxattr) { 19206476a69SAlex Elder while (vxattr->name) { 19306476a69SAlex Elder if (!strcmp(vxattr->name, name)) 194355da1ebSSage Weil return vxattr; 195355da1ebSSage Weil vxattr++; 19606476a69SAlex Elder } 19706476a69SAlex Elder } 19806476a69SAlex Elder 199355da1ebSSage Weil return NULL; 200355da1ebSSage Weil } 201355da1ebSSage Weil 202355da1ebSSage Weil static int __set_xattr(struct ceph_inode_info *ci, 203355da1ebSSage Weil const char *name, int name_len, 204355da1ebSSage Weil const char *val, int val_len, 205355da1ebSSage Weil int dirty, 206355da1ebSSage Weil int should_free_name, int should_free_val, 207355da1ebSSage Weil struct ceph_inode_xattr **newxattr) 208355da1ebSSage Weil { 209355da1ebSSage Weil struct rb_node **p; 210355da1ebSSage Weil struct rb_node *parent = NULL; 211355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 212355da1ebSSage Weil int c; 213355da1ebSSage Weil int new = 0; 214355da1ebSSage Weil 215355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 216355da1ebSSage Weil while (*p) { 217355da1ebSSage Weil parent = *p; 218355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 219355da1ebSSage Weil c = strncmp(name, xattr->name, min(name_len, xattr->name_len)); 220355da1ebSSage Weil if (c < 0) 221355da1ebSSage Weil p = &(*p)->rb_left; 222355da1ebSSage Weil else if (c > 0) 223355da1ebSSage Weil p = &(*p)->rb_right; 224355da1ebSSage Weil else { 225355da1ebSSage Weil if (name_len == xattr->name_len) 226355da1ebSSage Weil break; 227355da1ebSSage Weil else if (name_len < xattr->name_len) 228355da1ebSSage Weil p = &(*p)->rb_left; 229355da1ebSSage Weil else 230355da1ebSSage Weil p = &(*p)->rb_right; 231355da1ebSSage Weil } 232355da1ebSSage Weil xattr = NULL; 233355da1ebSSage Weil } 234355da1ebSSage Weil 235355da1ebSSage Weil if (!xattr) { 236355da1ebSSage Weil new = 1; 237355da1ebSSage Weil xattr = *newxattr; 238355da1ebSSage Weil xattr->name = name; 239355da1ebSSage Weil xattr->name_len = name_len; 240355da1ebSSage Weil xattr->should_free_name = should_free_name; 241355da1ebSSage Weil 242355da1ebSSage Weil ci->i_xattrs.count++; 243355da1ebSSage Weil dout("__set_xattr count=%d\n", ci->i_xattrs.count); 244355da1ebSSage Weil } else { 245355da1ebSSage Weil kfree(*newxattr); 246355da1ebSSage Weil *newxattr = NULL; 247355da1ebSSage Weil if (xattr->should_free_val) 248355da1ebSSage Weil kfree((void *)xattr->val); 249355da1ebSSage Weil 250355da1ebSSage Weil if (should_free_name) { 251355da1ebSSage Weil kfree((void *)name); 252355da1ebSSage Weil name = xattr->name; 253355da1ebSSage Weil } 254355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 255355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 256355da1ebSSage Weil } 257355da1ebSSage Weil ci->i_xattrs.names_size += name_len; 258355da1ebSSage Weil ci->i_xattrs.vals_size += val_len; 259355da1ebSSage Weil if (val) 260355da1ebSSage Weil xattr->val = val; 261355da1ebSSage Weil else 262355da1ebSSage Weil xattr->val = ""; 263355da1ebSSage Weil 264355da1ebSSage Weil xattr->val_len = val_len; 265355da1ebSSage Weil xattr->dirty = dirty; 266355da1ebSSage Weil xattr->should_free_val = (val && should_free_val); 267355da1ebSSage Weil 268355da1ebSSage Weil if (new) { 269355da1ebSSage Weil rb_link_node(&xattr->node, parent, p); 270355da1ebSSage Weil rb_insert_color(&xattr->node, &ci->i_xattrs.index); 271355da1ebSSage Weil dout("__set_xattr_val p=%p\n", p); 272355da1ebSSage Weil } 273355da1ebSSage Weil 274355da1ebSSage Weil dout("__set_xattr_val added %llx.%llx xattr %p %s=%.*s\n", 275355da1ebSSage Weil ceph_vinop(&ci->vfs_inode), xattr, name, val_len, val); 276355da1ebSSage Weil 277355da1ebSSage Weil return 0; 278355da1ebSSage Weil } 279355da1ebSSage Weil 280355da1ebSSage Weil static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci, 281355da1ebSSage Weil const char *name) 282355da1ebSSage Weil { 283355da1ebSSage Weil struct rb_node **p; 284355da1ebSSage Weil struct rb_node *parent = NULL; 285355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 28617db143fSSage Weil int name_len = strlen(name); 287355da1ebSSage Weil int c; 288355da1ebSSage Weil 289355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 290355da1ebSSage Weil while (*p) { 291355da1ebSSage Weil parent = *p; 292355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 293355da1ebSSage Weil c = strncmp(name, xattr->name, xattr->name_len); 29417db143fSSage Weil if (c == 0 && name_len > xattr->name_len) 29517db143fSSage Weil c = 1; 296355da1ebSSage Weil if (c < 0) 297355da1ebSSage Weil p = &(*p)->rb_left; 298355da1ebSSage Weil else if (c > 0) 299355da1ebSSage Weil p = &(*p)->rb_right; 300355da1ebSSage Weil else { 301355da1ebSSage Weil dout("__get_xattr %s: found %.*s\n", name, 302355da1ebSSage Weil xattr->val_len, xattr->val); 303355da1ebSSage Weil return xattr; 304355da1ebSSage Weil } 305355da1ebSSage Weil } 306355da1ebSSage Weil 307355da1ebSSage Weil dout("__get_xattr %s: not found\n", name); 308355da1ebSSage Weil 309355da1ebSSage Weil return NULL; 310355da1ebSSage Weil } 311355da1ebSSage Weil 312355da1ebSSage Weil static void __free_xattr(struct ceph_inode_xattr *xattr) 313355da1ebSSage Weil { 314355da1ebSSage Weil BUG_ON(!xattr); 315355da1ebSSage Weil 316355da1ebSSage Weil if (xattr->should_free_name) 317355da1ebSSage Weil kfree((void *)xattr->name); 318355da1ebSSage Weil if (xattr->should_free_val) 319355da1ebSSage Weil kfree((void *)xattr->val); 320355da1ebSSage Weil 321355da1ebSSage Weil kfree(xattr); 322355da1ebSSage Weil } 323355da1ebSSage Weil 324355da1ebSSage Weil static int __remove_xattr(struct ceph_inode_info *ci, 325355da1ebSSage Weil struct ceph_inode_xattr *xattr) 326355da1ebSSage Weil { 327355da1ebSSage Weil if (!xattr) 328355da1ebSSage Weil return -EOPNOTSUPP; 329355da1ebSSage Weil 330355da1ebSSage Weil rb_erase(&xattr->node, &ci->i_xattrs.index); 331355da1ebSSage Weil 332355da1ebSSage Weil if (xattr->should_free_name) 333355da1ebSSage Weil kfree((void *)xattr->name); 334355da1ebSSage Weil if (xattr->should_free_val) 335355da1ebSSage Weil kfree((void *)xattr->val); 336355da1ebSSage Weil 337355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 338355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 339355da1ebSSage Weil ci->i_xattrs.count--; 340355da1ebSSage Weil kfree(xattr); 341355da1ebSSage Weil 342355da1ebSSage Weil return 0; 343355da1ebSSage Weil } 344355da1ebSSage Weil 345355da1ebSSage Weil static int __remove_xattr_by_name(struct ceph_inode_info *ci, 346355da1ebSSage Weil const char *name) 347355da1ebSSage Weil { 348355da1ebSSage Weil struct rb_node **p; 349355da1ebSSage Weil struct ceph_inode_xattr *xattr; 350355da1ebSSage Weil int err; 351355da1ebSSage Weil 352355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 353355da1ebSSage Weil xattr = __get_xattr(ci, name); 354355da1ebSSage Weil err = __remove_xattr(ci, xattr); 355355da1ebSSage Weil return err; 356355da1ebSSage Weil } 357355da1ebSSage Weil 358355da1ebSSage Weil static char *__copy_xattr_names(struct ceph_inode_info *ci, 359355da1ebSSage Weil char *dest) 360355da1ebSSage Weil { 361355da1ebSSage Weil struct rb_node *p; 362355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 363355da1ebSSage Weil 364355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 365355da1ebSSage Weil dout("__copy_xattr_names count=%d\n", ci->i_xattrs.count); 366355da1ebSSage Weil 367355da1ebSSage Weil while (p) { 368355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 369355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 370355da1ebSSage Weil dest[xattr->name_len] = '\0'; 371355da1ebSSage Weil 372355da1ebSSage Weil dout("dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name, 373355da1ebSSage Weil xattr->name_len, ci->i_xattrs.names_size); 374355da1ebSSage Weil 375355da1ebSSage Weil dest += xattr->name_len + 1; 376355da1ebSSage Weil p = rb_next(p); 377355da1ebSSage Weil } 378355da1ebSSage Weil 379355da1ebSSage Weil return dest; 380355da1ebSSage Weil } 381355da1ebSSage Weil 382355da1ebSSage Weil void __ceph_destroy_xattrs(struct ceph_inode_info *ci) 383355da1ebSSage Weil { 384355da1ebSSage Weil struct rb_node *p, *tmp; 385355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 386355da1ebSSage Weil 387355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 388355da1ebSSage Weil 389355da1ebSSage Weil dout("__ceph_destroy_xattrs p=%p\n", p); 390355da1ebSSage Weil 391355da1ebSSage Weil while (p) { 392355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 393355da1ebSSage Weil tmp = p; 394355da1ebSSage Weil p = rb_next(tmp); 395355da1ebSSage Weil dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p, 396355da1ebSSage Weil xattr->name_len, xattr->name); 397355da1ebSSage Weil rb_erase(tmp, &ci->i_xattrs.index); 398355da1ebSSage Weil 399355da1ebSSage Weil __free_xattr(xattr); 400355da1ebSSage Weil } 401355da1ebSSage Weil 402355da1ebSSage Weil ci->i_xattrs.names_size = 0; 403355da1ebSSage Weil ci->i_xattrs.vals_size = 0; 404355da1ebSSage Weil ci->i_xattrs.index_version = 0; 405355da1ebSSage Weil ci->i_xattrs.count = 0; 406355da1ebSSage Weil ci->i_xattrs.index = RB_ROOT; 407355da1ebSSage Weil } 408355da1ebSSage Weil 409355da1ebSSage Weil static int __build_xattrs(struct inode *inode) 410be655596SSage Weil __releases(ci->i_ceph_lock) 411be655596SSage Weil __acquires(ci->i_ceph_lock) 412355da1ebSSage Weil { 413355da1ebSSage Weil u32 namelen; 414355da1ebSSage Weil u32 numattr = 0; 415355da1ebSSage Weil void *p, *end; 416355da1ebSSage Weil u32 len; 417355da1ebSSage Weil const char *name, *val; 418355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 419355da1ebSSage Weil int xattr_version; 420355da1ebSSage Weil struct ceph_inode_xattr **xattrs = NULL; 42163ff78b2SSage Weil int err = 0; 422355da1ebSSage Weil int i; 423355da1ebSSage Weil 424355da1ebSSage Weil dout("__build_xattrs() len=%d\n", 425355da1ebSSage Weil ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0); 426355da1ebSSage Weil 427355da1ebSSage Weil if (ci->i_xattrs.index_version >= ci->i_xattrs.version) 428355da1ebSSage Weil return 0; /* already built */ 429355da1ebSSage Weil 430355da1ebSSage Weil __ceph_destroy_xattrs(ci); 431355da1ebSSage Weil 432355da1ebSSage Weil start: 433355da1ebSSage Weil /* updated internal xattr rb tree */ 434355da1ebSSage Weil if (ci->i_xattrs.blob && ci->i_xattrs.blob->vec.iov_len > 4) { 435355da1ebSSage Weil p = ci->i_xattrs.blob->vec.iov_base; 436355da1ebSSage Weil end = p + ci->i_xattrs.blob->vec.iov_len; 437355da1ebSSage Weil ceph_decode_32_safe(&p, end, numattr, bad); 438355da1ebSSage Weil xattr_version = ci->i_xattrs.version; 439be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 440355da1ebSSage Weil 441355da1ebSSage Weil xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *), 442355da1ebSSage Weil GFP_NOFS); 443355da1ebSSage Weil err = -ENOMEM; 444355da1ebSSage Weil if (!xattrs) 445355da1ebSSage Weil goto bad_lock; 446355da1ebSSage Weil memset(xattrs, 0, numattr*sizeof(struct ceph_xattr *)); 447355da1ebSSage Weil for (i = 0; i < numattr; i++) { 448355da1ebSSage Weil xattrs[i] = kmalloc(sizeof(struct ceph_inode_xattr), 449355da1ebSSage Weil GFP_NOFS); 450355da1ebSSage Weil if (!xattrs[i]) 451355da1ebSSage Weil goto bad_lock; 452355da1ebSSage Weil } 453355da1ebSSage Weil 454be655596SSage Weil spin_lock(&ci->i_ceph_lock); 455355da1ebSSage Weil if (ci->i_xattrs.version != xattr_version) { 456355da1ebSSage Weil /* lost a race, retry */ 457355da1ebSSage Weil for (i = 0; i < numattr; i++) 458355da1ebSSage Weil kfree(xattrs[i]); 459355da1ebSSage Weil kfree(xattrs); 460*21ec6ffaSAlan Cox xattrs = NULL; 461355da1ebSSage Weil goto start; 462355da1ebSSage Weil } 463355da1ebSSage Weil err = -EIO; 464355da1ebSSage Weil while (numattr--) { 465355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 466355da1ebSSage Weil namelen = len; 467355da1ebSSage Weil name = p; 468355da1ebSSage Weil p += len; 469355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 470355da1ebSSage Weil val = p; 471355da1ebSSage Weil p += len; 472355da1ebSSage Weil 473355da1ebSSage Weil err = __set_xattr(ci, name, namelen, val, len, 474355da1ebSSage Weil 0, 0, 0, &xattrs[numattr]); 475355da1ebSSage Weil 476355da1ebSSage Weil if (err < 0) 477355da1ebSSage Weil goto bad; 478355da1ebSSage Weil } 479355da1ebSSage Weil kfree(xattrs); 480355da1ebSSage Weil } 481355da1ebSSage Weil ci->i_xattrs.index_version = ci->i_xattrs.version; 482355da1ebSSage Weil ci->i_xattrs.dirty = false; 483355da1ebSSage Weil 484355da1ebSSage Weil return err; 485355da1ebSSage Weil bad_lock: 486be655596SSage Weil spin_lock(&ci->i_ceph_lock); 487355da1ebSSage Weil bad: 488355da1ebSSage Weil if (xattrs) { 489355da1ebSSage Weil for (i = 0; i < numattr; i++) 490355da1ebSSage Weil kfree(xattrs[i]); 491355da1ebSSage Weil kfree(xattrs); 492355da1ebSSage Weil } 493355da1ebSSage Weil ci->i_xattrs.names_size = 0; 494355da1ebSSage Weil return err; 495355da1ebSSage Weil } 496355da1ebSSage Weil 497355da1ebSSage Weil static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size, 498355da1ebSSage Weil int val_size) 499355da1ebSSage Weil { 500355da1ebSSage Weil /* 501355da1ebSSage Weil * 4 bytes for the length, and additional 4 bytes per each xattr name, 502355da1ebSSage Weil * 4 bytes per each value 503355da1ebSSage Weil */ 504355da1ebSSage Weil int size = 4 + ci->i_xattrs.count*(4 + 4) + 505355da1ebSSage Weil ci->i_xattrs.names_size + 506355da1ebSSage Weil ci->i_xattrs.vals_size; 507355da1ebSSage Weil dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n", 508355da1ebSSage Weil ci->i_xattrs.count, ci->i_xattrs.names_size, 509355da1ebSSage Weil ci->i_xattrs.vals_size); 510355da1ebSSage Weil 511355da1ebSSage Weil if (name_size) 512355da1ebSSage Weil size += 4 + 4 + name_size + val_size; 513355da1ebSSage Weil 514355da1ebSSage Weil return size; 515355da1ebSSage Weil } 516355da1ebSSage Weil 517355da1ebSSage Weil /* 518355da1ebSSage Weil * If there are dirty xattrs, reencode xattrs into the prealloc_blob 519355da1ebSSage Weil * and swap into place. 520355da1ebSSage Weil */ 521355da1ebSSage Weil void __ceph_build_xattrs_blob(struct ceph_inode_info *ci) 522355da1ebSSage Weil { 523355da1ebSSage Weil struct rb_node *p; 524355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 525355da1ebSSage Weil void *dest; 526355da1ebSSage Weil 527355da1ebSSage Weil dout("__build_xattrs_blob %p\n", &ci->vfs_inode); 528355da1ebSSage Weil if (ci->i_xattrs.dirty) { 529355da1ebSSage Weil int need = __get_required_blob_size(ci, 0, 0); 530355da1ebSSage Weil 531355da1ebSSage Weil BUG_ON(need > ci->i_xattrs.prealloc_blob->alloc_len); 532355da1ebSSage Weil 533355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 534355da1ebSSage Weil dest = ci->i_xattrs.prealloc_blob->vec.iov_base; 535355da1ebSSage Weil 536355da1ebSSage Weil ceph_encode_32(&dest, ci->i_xattrs.count); 537355da1ebSSage Weil while (p) { 538355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 539355da1ebSSage Weil 540355da1ebSSage Weil ceph_encode_32(&dest, xattr->name_len); 541355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 542355da1ebSSage Weil dest += xattr->name_len; 543355da1ebSSage Weil ceph_encode_32(&dest, xattr->val_len); 544355da1ebSSage Weil memcpy(dest, xattr->val, xattr->val_len); 545355da1ebSSage Weil dest += xattr->val_len; 546355da1ebSSage Weil 547355da1ebSSage Weil p = rb_next(p); 548355da1ebSSage Weil } 549355da1ebSSage Weil 550355da1ebSSage Weil /* adjust buffer len; it may be larger than we need */ 551355da1ebSSage Weil ci->i_xattrs.prealloc_blob->vec.iov_len = 552355da1ebSSage Weil dest - ci->i_xattrs.prealloc_blob->vec.iov_base; 553355da1ebSSage Weil 554b6c1d5b8SSage Weil if (ci->i_xattrs.blob) 555355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.blob); 556355da1ebSSage Weil ci->i_xattrs.blob = ci->i_xattrs.prealloc_blob; 557355da1ebSSage Weil ci->i_xattrs.prealloc_blob = NULL; 558355da1ebSSage Weil ci->i_xattrs.dirty = false; 5594a625be4SSage Weil ci->i_xattrs.version++; 560355da1ebSSage Weil } 561355da1ebSSage Weil } 562355da1ebSSage Weil 563355da1ebSSage Weil ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value, 564355da1ebSSage Weil size_t size) 565355da1ebSSage Weil { 566355da1ebSSage Weil struct inode *inode = dentry->d_inode; 567355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 568355da1ebSSage Weil int err; 569355da1ebSSage Weil struct ceph_inode_xattr *xattr; 570881a5fa2SAlex Elder struct ceph_vxattr *vxattr = NULL; 571355da1ebSSage Weil 572355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 573355da1ebSSage Weil return -ENODATA; 574355da1ebSSage Weil 575355da1ebSSage Weil /* let's see if a virtual xattr was requested */ 57606476a69SAlex Elder vxattr = ceph_match_vxattr(inode, name); 577355da1ebSSage Weil 578be655596SSage Weil spin_lock(&ci->i_ceph_lock); 579355da1ebSSage Weil dout("getxattr %p ver=%lld index_ver=%lld\n", inode, 580355da1ebSSage Weil ci->i_xattrs.version, ci->i_xattrs.index_version); 581355da1ebSSage Weil 582355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 583355da1ebSSage Weil (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 584355da1ebSSage Weil goto get_xattr; 585355da1ebSSage Weil } else { 586be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 587355da1ebSSage Weil /* get xattrs from mds (if we don't already have them) */ 588355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 589355da1ebSSage Weil if (err) 590355da1ebSSage Weil return err; 591355da1ebSSage Weil } 592355da1ebSSage Weil 593be655596SSage Weil spin_lock(&ci->i_ceph_lock); 594355da1ebSSage Weil 595355da1ebSSage Weil if (vxattr && vxattr->readonly) { 596355da1ebSSage Weil err = vxattr->getxattr_cb(ci, value, size); 597355da1ebSSage Weil goto out; 598355da1ebSSage Weil } 599355da1ebSSage Weil 600355da1ebSSage Weil err = __build_xattrs(inode); 601355da1ebSSage Weil if (err < 0) 602355da1ebSSage Weil goto out; 603355da1ebSSage Weil 604355da1ebSSage Weil get_xattr: 605355da1ebSSage Weil err = -ENODATA; /* == ENOATTR */ 606355da1ebSSage Weil xattr = __get_xattr(ci, name); 607355da1ebSSage Weil if (!xattr) { 608355da1ebSSage Weil if (vxattr) 609355da1ebSSage Weil err = vxattr->getxattr_cb(ci, value, size); 610355da1ebSSage Weil goto out; 611355da1ebSSage Weil } 612355da1ebSSage Weil 613355da1ebSSage Weil err = -ERANGE; 614355da1ebSSage Weil if (size && size < xattr->val_len) 615355da1ebSSage Weil goto out; 616355da1ebSSage Weil 617355da1ebSSage Weil err = xattr->val_len; 618355da1ebSSage Weil if (size == 0) 619355da1ebSSage Weil goto out; 620355da1ebSSage Weil 621355da1ebSSage Weil memcpy(value, xattr->val, xattr->val_len); 622355da1ebSSage Weil 623355da1ebSSage Weil out: 624be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 625355da1ebSSage Weil return err; 626355da1ebSSage Weil } 627355da1ebSSage Weil 628355da1ebSSage Weil ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size) 629355da1ebSSage Weil { 630355da1ebSSage Weil struct inode *inode = dentry->d_inode; 631355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 632881a5fa2SAlex Elder struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode); 633355da1ebSSage Weil u32 vir_namelen = 0; 634355da1ebSSage Weil u32 namelen; 635355da1ebSSage Weil int err; 636355da1ebSSage Weil u32 len; 637355da1ebSSage Weil int i; 638355da1ebSSage Weil 639be655596SSage Weil spin_lock(&ci->i_ceph_lock); 640355da1ebSSage Weil dout("listxattr %p ver=%lld index_ver=%lld\n", inode, 641355da1ebSSage Weil ci->i_xattrs.version, ci->i_xattrs.index_version); 642355da1ebSSage Weil 643355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 644bddfa3ccSHenry C Chang (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 645355da1ebSSage Weil goto list_xattr; 646355da1ebSSage Weil } else { 647be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 648355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 649355da1ebSSage Weil if (err) 650355da1ebSSage Weil return err; 651355da1ebSSage Weil } 652355da1ebSSage Weil 653be655596SSage Weil spin_lock(&ci->i_ceph_lock); 654355da1ebSSage Weil 655355da1ebSSage Weil err = __build_xattrs(inode); 656355da1ebSSage Weil if (err < 0) 657355da1ebSSage Weil goto out; 658355da1ebSSage Weil 659355da1ebSSage Weil list_xattr: 6603ce6cd12SAlex Elder /* 6613ce6cd12SAlex Elder * Start with virtual dir xattr names (if any) (including 6623ce6cd12SAlex Elder * terminating '\0' characters for each). 6633ce6cd12SAlex Elder */ 6643ce6cd12SAlex Elder vir_namelen = ceph_vxattrs_name_size(vxattrs); 6653ce6cd12SAlex Elder 666355da1ebSSage Weil /* adding 1 byte per each variable due to the null termination */ 667355da1ebSSage Weil namelen = vir_namelen + ci->i_xattrs.names_size + ci->i_xattrs.count; 668355da1ebSSage Weil err = -ERANGE; 669355da1ebSSage Weil if (size && namelen > size) 670355da1ebSSage Weil goto out; 671355da1ebSSage Weil 672355da1ebSSage Weil err = namelen; 673355da1ebSSage Weil if (size == 0) 674355da1ebSSage Weil goto out; 675355da1ebSSage Weil 676355da1ebSSage Weil names = __copy_xattr_names(ci, names); 677355da1ebSSage Weil 678355da1ebSSage Weil /* virtual xattr names, too */ 679355da1ebSSage Weil if (vxattrs) 680355da1ebSSage Weil for (i = 0; vxattrs[i].name; i++) { 681355da1ebSSage Weil len = sprintf(names, "%s", vxattrs[i].name); 682355da1ebSSage Weil names += len + 1; 683355da1ebSSage Weil } 684355da1ebSSage Weil 685355da1ebSSage Weil out: 686be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 687355da1ebSSage Weil return err; 688355da1ebSSage Weil } 689355da1ebSSage Weil 690355da1ebSSage Weil static int ceph_sync_setxattr(struct dentry *dentry, const char *name, 691355da1ebSSage Weil const char *value, size_t size, int flags) 692355da1ebSSage Weil { 6933d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 694355da1ebSSage Weil struct inode *inode = dentry->d_inode; 695355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 6965f21c96dSSage Weil struct inode *parent_inode; 697355da1ebSSage Weil struct ceph_mds_request *req; 6983d14c5d2SYehuda Sadeh struct ceph_mds_client *mdsc = fsc->mdsc; 699355da1ebSSage Weil int err; 700355da1ebSSage Weil int i, nr_pages; 701355da1ebSSage Weil struct page **pages = NULL; 702355da1ebSSage Weil void *kaddr; 703355da1ebSSage Weil 704355da1ebSSage Weil /* copy value into some pages */ 705355da1ebSSage Weil nr_pages = calc_pages_for(0, size); 706355da1ebSSage Weil if (nr_pages) { 707355da1ebSSage Weil pages = kmalloc(sizeof(pages[0])*nr_pages, GFP_NOFS); 708355da1ebSSage Weil if (!pages) 709355da1ebSSage Weil return -ENOMEM; 710355da1ebSSage Weil err = -ENOMEM; 711355da1ebSSage Weil for (i = 0; i < nr_pages; i++) { 71231459fe4SYehuda Sadeh pages[i] = __page_cache_alloc(GFP_NOFS); 713355da1ebSSage Weil if (!pages[i]) { 714355da1ebSSage Weil nr_pages = i; 715355da1ebSSage Weil goto out; 716355da1ebSSage Weil } 717355da1ebSSage Weil kaddr = kmap(pages[i]); 718355da1ebSSage Weil memcpy(kaddr, value + i*PAGE_CACHE_SIZE, 719355da1ebSSage Weil min(PAGE_CACHE_SIZE, size-i*PAGE_CACHE_SIZE)); 720355da1ebSSage Weil } 721355da1ebSSage Weil } 722355da1ebSSage Weil 723355da1ebSSage Weil dout("setxattr value=%.*s\n", (int)size, value); 724355da1ebSSage Weil 725355da1ebSSage Weil /* do request */ 726355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETXATTR, 727355da1ebSSage Weil USE_AUTH_MDS); 72860d87733SJulia Lawall if (IS_ERR(req)) { 72960d87733SJulia Lawall err = PTR_ERR(req); 73060d87733SJulia Lawall goto out; 73160d87733SJulia Lawall } 73270b666c3SSage Weil req->r_inode = inode; 73370b666c3SSage Weil ihold(inode); 734355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 735355da1ebSSage Weil req->r_num_caps = 1; 736355da1ebSSage Weil req->r_args.setxattr.flags = cpu_to_le32(flags); 737355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 738355da1ebSSage Weil 739355da1ebSSage Weil req->r_pages = pages; 740355da1ebSSage Weil req->r_num_pages = nr_pages; 741355da1ebSSage Weil req->r_data_len = size; 742355da1ebSSage Weil 743355da1ebSSage Weil dout("xattr.ver (before): %lld\n", ci->i_xattrs.version); 7445f21c96dSSage Weil parent_inode = ceph_get_dentry_parent_inode(dentry); 745355da1ebSSage Weil err = ceph_mdsc_do_request(mdsc, parent_inode, req); 7465f21c96dSSage Weil iput(parent_inode); 747355da1ebSSage Weil ceph_mdsc_put_request(req); 748355da1ebSSage Weil dout("xattr.ver (after): %lld\n", ci->i_xattrs.version); 749355da1ebSSage Weil 750355da1ebSSage Weil out: 751355da1ebSSage Weil if (pages) { 752355da1ebSSage Weil for (i = 0; i < nr_pages; i++) 753355da1ebSSage Weil __free_page(pages[i]); 754355da1ebSSage Weil kfree(pages); 755355da1ebSSage Weil } 756355da1ebSSage Weil return err; 757355da1ebSSage Weil } 758355da1ebSSage Weil 759355da1ebSSage Weil int ceph_setxattr(struct dentry *dentry, const char *name, 760355da1ebSSage Weil const void *value, size_t size, int flags) 761355da1ebSSage Weil { 762355da1ebSSage Weil struct inode *inode = dentry->d_inode; 763881a5fa2SAlex Elder struct ceph_vxattr *vxattr; 764355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 76518fa8b3fSAlex Elder int issued; 766355da1ebSSage Weil int err; 76718fa8b3fSAlex Elder int dirty; 768355da1ebSSage Weil int name_len = strlen(name); 769355da1ebSSage Weil int val_len = size; 770355da1ebSSage Weil char *newname = NULL; 771355da1ebSSage Weil char *newval = NULL; 772355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 773355da1ebSSage Weil int required_blob_size; 774355da1ebSSage Weil 775355da1ebSSage Weil if (ceph_snap(inode) != CEPH_NOSNAP) 776355da1ebSSage Weil return -EROFS; 777355da1ebSSage Weil 778355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 779355da1ebSSage Weil return -EOPNOTSUPP; 780355da1ebSSage Weil 78106476a69SAlex Elder vxattr = ceph_match_vxattr(inode, name); 782355da1ebSSage Weil if (vxattr && vxattr->readonly) 783355da1ebSSage Weil return -EOPNOTSUPP; 784355da1ebSSage Weil 785355da1ebSSage Weil /* preallocate memory for xattr name, value, index node */ 786355da1ebSSage Weil err = -ENOMEM; 78761413c2fSJulia Lawall newname = kmemdup(name, name_len + 1, GFP_NOFS); 788355da1ebSSage Weil if (!newname) 789355da1ebSSage Weil goto out; 790355da1ebSSage Weil 791355da1ebSSage Weil if (val_len) { 792b829c195SAlex Elder newval = kmemdup(value, val_len, GFP_NOFS); 793355da1ebSSage Weil if (!newval) 794355da1ebSSage Weil goto out; 795355da1ebSSage Weil } 796355da1ebSSage Weil 797355da1ebSSage Weil xattr = kmalloc(sizeof(struct ceph_inode_xattr), GFP_NOFS); 798355da1ebSSage Weil if (!xattr) 799355da1ebSSage Weil goto out; 800355da1ebSSage Weil 801be655596SSage Weil spin_lock(&ci->i_ceph_lock); 802355da1ebSSage Weil retry: 803355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 80418fa8b3fSAlex Elder dout("setxattr %p issued %s\n", inode, ceph_cap_string(issued)); 805355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 806355da1ebSSage Weil goto do_sync; 807355da1ebSSage Weil __build_xattrs(inode); 808355da1ebSSage Weil 809355da1ebSSage Weil required_blob_size = __get_required_blob_size(ci, name_len, val_len); 810355da1ebSSage Weil 811355da1ebSSage Weil if (!ci->i_xattrs.prealloc_blob || 812355da1ebSSage Weil required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 81318fa8b3fSAlex Elder struct ceph_buffer *blob; 814355da1ebSSage Weil 815be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 816355da1ebSSage Weil dout(" preaallocating new blob size=%d\n", required_blob_size); 817b6c1d5b8SSage Weil blob = ceph_buffer_new(required_blob_size, GFP_NOFS); 818355da1ebSSage Weil if (!blob) 819355da1ebSSage Weil goto out; 820be655596SSage Weil spin_lock(&ci->i_ceph_lock); 821b6c1d5b8SSage Weil if (ci->i_xattrs.prealloc_blob) 822355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.prealloc_blob); 823355da1ebSSage Weil ci->i_xattrs.prealloc_blob = blob; 824355da1ebSSage Weil goto retry; 825355da1ebSSage Weil } 826355da1ebSSage Weil 827355da1ebSSage Weil err = __set_xattr(ci, newname, name_len, newval, 828355da1ebSSage Weil val_len, 1, 1, 1, &xattr); 82918fa8b3fSAlex Elder 830fca65b4aSSage Weil dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 831355da1ebSSage Weil ci->i_xattrs.dirty = true; 832355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 83318fa8b3fSAlex Elder 834be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 835fca65b4aSSage Weil if (dirty) 836fca65b4aSSage Weil __mark_inode_dirty(inode, dirty); 837355da1ebSSage Weil return err; 838355da1ebSSage Weil 839355da1ebSSage Weil do_sync: 840be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 841355da1ebSSage Weil err = ceph_sync_setxattr(dentry, name, value, size, flags); 842355da1ebSSage Weil out: 843355da1ebSSage Weil kfree(newname); 844355da1ebSSage Weil kfree(newval); 845355da1ebSSage Weil kfree(xattr); 846355da1ebSSage Weil return err; 847355da1ebSSage Weil } 848355da1ebSSage Weil 849355da1ebSSage Weil static int ceph_send_removexattr(struct dentry *dentry, const char *name) 850355da1ebSSage Weil { 8513d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 8523d14c5d2SYehuda Sadeh struct ceph_mds_client *mdsc = fsc->mdsc; 853355da1ebSSage Weil struct inode *inode = dentry->d_inode; 8545f21c96dSSage Weil struct inode *parent_inode; 855355da1ebSSage Weil struct ceph_mds_request *req; 856355da1ebSSage Weil int err; 857355da1ebSSage Weil 858355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RMXATTR, 859355da1ebSSage Weil USE_AUTH_MDS); 860355da1ebSSage Weil if (IS_ERR(req)) 861355da1ebSSage Weil return PTR_ERR(req); 86270b666c3SSage Weil req->r_inode = inode; 86370b666c3SSage Weil ihold(inode); 864355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 865355da1ebSSage Weil req->r_num_caps = 1; 866355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 867355da1ebSSage Weil 8685f21c96dSSage Weil parent_inode = ceph_get_dentry_parent_inode(dentry); 869355da1ebSSage Weil err = ceph_mdsc_do_request(mdsc, parent_inode, req); 8705f21c96dSSage Weil iput(parent_inode); 871355da1ebSSage Weil ceph_mdsc_put_request(req); 872355da1ebSSage Weil return err; 873355da1ebSSage Weil } 874355da1ebSSage Weil 875355da1ebSSage Weil int ceph_removexattr(struct dentry *dentry, const char *name) 876355da1ebSSage Weil { 877355da1ebSSage Weil struct inode *inode = dentry->d_inode; 878881a5fa2SAlex Elder struct ceph_vxattr *vxattr; 879355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 880355da1ebSSage Weil int issued; 881355da1ebSSage Weil int err; 88283eb26afSAlex Elder int required_blob_size; 883fca65b4aSSage Weil int dirty; 884355da1ebSSage Weil 885355da1ebSSage Weil if (ceph_snap(inode) != CEPH_NOSNAP) 886355da1ebSSage Weil return -EROFS; 887355da1ebSSage Weil 888355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 889355da1ebSSage Weil return -EOPNOTSUPP; 890355da1ebSSage Weil 89106476a69SAlex Elder vxattr = ceph_match_vxattr(inode, name); 892355da1ebSSage Weil if (vxattr && vxattr->readonly) 893355da1ebSSage Weil return -EOPNOTSUPP; 894355da1ebSSage Weil 89583eb26afSAlex Elder err = -ENOMEM; 896be655596SSage Weil spin_lock(&ci->i_ceph_lock); 89783eb26afSAlex Elder retry: 898355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 899355da1ebSSage Weil dout("removexattr %p issued %s\n", inode, ceph_cap_string(issued)); 900355da1ebSSage Weil 901355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 902355da1ebSSage Weil goto do_sync; 90318fa8b3fSAlex Elder __build_xattrs(inode); 904355da1ebSSage Weil 90583eb26afSAlex Elder required_blob_size = __get_required_blob_size(ci, 0, 0); 90683eb26afSAlex Elder 90783eb26afSAlex Elder if (!ci->i_xattrs.prealloc_blob || 90883eb26afSAlex Elder required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 90983eb26afSAlex Elder struct ceph_buffer *blob; 91083eb26afSAlex Elder 91183eb26afSAlex Elder spin_unlock(&ci->i_ceph_lock); 91283eb26afSAlex Elder dout(" preaallocating new blob size=%d\n", required_blob_size); 91383eb26afSAlex Elder blob = ceph_buffer_new(required_blob_size, GFP_NOFS); 91483eb26afSAlex Elder if (!blob) 91583eb26afSAlex Elder goto out; 91683eb26afSAlex Elder spin_lock(&ci->i_ceph_lock); 91783eb26afSAlex Elder if (ci->i_xattrs.prealloc_blob) 91883eb26afSAlex Elder ceph_buffer_put(ci->i_xattrs.prealloc_blob); 91983eb26afSAlex Elder ci->i_xattrs.prealloc_blob = blob; 92083eb26afSAlex Elder goto retry; 92183eb26afSAlex Elder } 92283eb26afSAlex Elder 923355da1ebSSage Weil err = __remove_xattr_by_name(ceph_inode(inode), name); 92418fa8b3fSAlex Elder 925fca65b4aSSage Weil dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 926355da1ebSSage Weil ci->i_xattrs.dirty = true; 927355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 928be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 929fca65b4aSSage Weil if (dirty) 930fca65b4aSSage Weil __mark_inode_dirty(inode, dirty); 931355da1ebSSage Weil return err; 932355da1ebSSage Weil do_sync: 933be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 934355da1ebSSage Weil err = ceph_send_removexattr(dentry, name); 93583eb26afSAlex Elder out: 936355da1ebSSage Weil return err; 937355da1ebSSage Weil } 938355da1ebSSage Weil 939