1355da1ebSSage Weil #include "ceph_debug.h" 2355da1ebSSage Weil #include "super.h" 3355da1ebSSage Weil #include "decode.h" 4355da1ebSSage Weil 5355da1ebSSage Weil #include <linux/xattr.h> 6355da1ebSSage Weil 7355da1ebSSage Weil static bool ceph_is_valid_xattr(const char *name) 8355da1ebSSage Weil { 9355da1ebSSage Weil return !strncmp(name, XATTR_SECURITY_PREFIX, 10355da1ebSSage Weil XATTR_SECURITY_PREFIX_LEN) || 11355da1ebSSage Weil !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) || 12355da1ebSSage Weil !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN); 13355da1ebSSage Weil } 14355da1ebSSage Weil 15355da1ebSSage Weil /* 16355da1ebSSage Weil * These define virtual xattrs exposing the recursive directory 17355da1ebSSage Weil * statistics and layout metadata. 18355da1ebSSage Weil */ 19355da1ebSSage Weil struct ceph_vxattr_cb { 20355da1ebSSage Weil bool readonly; 21355da1ebSSage Weil char *name; 22355da1ebSSage Weil size_t (*getxattr_cb)(struct ceph_inode_info *ci, char *val, 23355da1ebSSage Weil size_t size); 24355da1ebSSage Weil }; 25355da1ebSSage Weil 26355da1ebSSage Weil /* directories */ 27355da1ebSSage Weil 28355da1ebSSage Weil static size_t ceph_vxattrcb_entries(struct ceph_inode_info *ci, char *val, 29355da1ebSSage Weil size_t size) 30355da1ebSSage Weil { 31355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs); 32355da1ebSSage Weil } 33355da1ebSSage Weil 34355da1ebSSage Weil static size_t ceph_vxattrcb_files(struct ceph_inode_info *ci, char *val, 35355da1ebSSage Weil size_t size) 36355da1ebSSage Weil { 37355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_files); 38355da1ebSSage Weil } 39355da1ebSSage Weil 40355da1ebSSage Weil static size_t ceph_vxattrcb_subdirs(struct ceph_inode_info *ci, char *val, 41355da1ebSSage Weil size_t size) 42355da1ebSSage Weil { 43355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_subdirs); 44355da1ebSSage Weil } 45355da1ebSSage Weil 46355da1ebSSage Weil static size_t ceph_vxattrcb_rentries(struct ceph_inode_info *ci, char *val, 47355da1ebSSage Weil size_t size) 48355da1ebSSage Weil { 49355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs); 50355da1ebSSage Weil } 51355da1ebSSage Weil 52355da1ebSSage Weil static size_t ceph_vxattrcb_rfiles(struct ceph_inode_info *ci, char *val, 53355da1ebSSage Weil size_t size) 54355da1ebSSage Weil { 55355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rfiles); 56355da1ebSSage Weil } 57355da1ebSSage Weil 58355da1ebSSage Weil static size_t ceph_vxattrcb_rsubdirs(struct ceph_inode_info *ci, char *val, 59355da1ebSSage Weil size_t size) 60355da1ebSSage Weil { 61355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rsubdirs); 62355da1ebSSage Weil } 63355da1ebSSage Weil 64355da1ebSSage Weil static size_t ceph_vxattrcb_rbytes(struct ceph_inode_info *ci, char *val, 65355da1ebSSage Weil size_t size) 66355da1ebSSage Weil { 67355da1ebSSage Weil return snprintf(val, size, "%lld", ci->i_rbytes); 68355da1ebSSage Weil } 69355da1ebSSage Weil 70355da1ebSSage Weil static size_t ceph_vxattrcb_rctime(struct ceph_inode_info *ci, char *val, 71355da1ebSSage Weil size_t size) 72355da1ebSSage Weil { 73355da1ebSSage Weil return snprintf(val, size, "%ld.%ld", (long)ci->i_rctime.tv_sec, 74355da1ebSSage Weil (long)ci->i_rctime.tv_nsec); 75355da1ebSSage Weil } 76355da1ebSSage Weil 77355da1ebSSage Weil static struct ceph_vxattr_cb ceph_dir_vxattrs[] = { 78355da1ebSSage Weil { true, "user.ceph.dir.entries", ceph_vxattrcb_entries}, 79355da1ebSSage Weil { true, "user.ceph.dir.files", ceph_vxattrcb_files}, 80355da1ebSSage Weil { true, "user.ceph.dir.subdirs", ceph_vxattrcb_subdirs}, 81355da1ebSSage Weil { true, "user.ceph.dir.rentries", ceph_vxattrcb_rentries}, 82355da1ebSSage Weil { true, "user.ceph.dir.rfiles", ceph_vxattrcb_rfiles}, 83355da1ebSSage Weil { true, "user.ceph.dir.rsubdirs", ceph_vxattrcb_rsubdirs}, 84355da1ebSSage Weil { true, "user.ceph.dir.rbytes", ceph_vxattrcb_rbytes}, 85355da1ebSSage Weil { true, "user.ceph.dir.rctime", ceph_vxattrcb_rctime}, 86355da1ebSSage Weil { true, NULL, NULL } 87355da1ebSSage Weil }; 88355da1ebSSage Weil 89355da1ebSSage Weil /* files */ 90355da1ebSSage Weil 91355da1ebSSage Weil static size_t ceph_vxattrcb_layout(struct ceph_inode_info *ci, char *val, 92355da1ebSSage Weil size_t size) 93355da1ebSSage Weil { 94*b195befdSSage Weil int ret; 95*b195befdSSage Weil 96*b195befdSSage Weil ret = snprintf(val, size, 97355da1ebSSage Weil "chunk_bytes=%lld\nstripe_count=%lld\nobject_size=%lld\n", 98355da1ebSSage Weil (unsigned long long)ceph_file_layout_su(ci->i_layout), 99355da1ebSSage Weil (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout), 100355da1ebSSage Weil (unsigned long long)ceph_file_layout_object_size(ci->i_layout)); 101*b195befdSSage Weil if (ceph_file_layout_pg_preferred(ci->i_layout)) 102*b195befdSSage Weil ret += snprintf(val + ret, size, "preferred_osd=%lld\n", 103*b195befdSSage Weil (unsigned long long)ceph_file_layout_pg_preferred( 104*b195befdSSage Weil ci->i_layout)); 105*b195befdSSage Weil return ret; 106355da1ebSSage Weil } 107355da1ebSSage Weil 108355da1ebSSage Weil static struct ceph_vxattr_cb ceph_file_vxattrs[] = { 109355da1ebSSage Weil { true, "user.ceph.layout", ceph_vxattrcb_layout}, 110355da1ebSSage Weil { NULL, NULL } 111355da1ebSSage Weil }; 112355da1ebSSage Weil 113355da1ebSSage Weil static struct ceph_vxattr_cb *ceph_inode_vxattrs(struct inode *inode) 114355da1ebSSage Weil { 115355da1ebSSage Weil if (S_ISDIR(inode->i_mode)) 116355da1ebSSage Weil return ceph_dir_vxattrs; 117355da1ebSSage Weil else if (S_ISREG(inode->i_mode)) 118355da1ebSSage Weil return ceph_file_vxattrs; 119355da1ebSSage Weil return NULL; 120355da1ebSSage Weil } 121355da1ebSSage Weil 122355da1ebSSage Weil static struct ceph_vxattr_cb *ceph_match_vxattr(struct ceph_vxattr_cb *vxattr, 123355da1ebSSage Weil const char *name) 124355da1ebSSage Weil { 125355da1ebSSage Weil do { 126355da1ebSSage Weil if (strcmp(vxattr->name, name) == 0) 127355da1ebSSage Weil return vxattr; 128355da1ebSSage Weil vxattr++; 129355da1ebSSage Weil } while (vxattr->name); 130355da1ebSSage Weil return NULL; 131355da1ebSSage Weil } 132355da1ebSSage Weil 133355da1ebSSage Weil static int __set_xattr(struct ceph_inode_info *ci, 134355da1ebSSage Weil const char *name, int name_len, 135355da1ebSSage Weil const char *val, int val_len, 136355da1ebSSage Weil int dirty, 137355da1ebSSage Weil int should_free_name, int should_free_val, 138355da1ebSSage Weil struct ceph_inode_xattr **newxattr) 139355da1ebSSage Weil { 140355da1ebSSage Weil struct rb_node **p; 141355da1ebSSage Weil struct rb_node *parent = NULL; 142355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 143355da1ebSSage Weil int c; 144355da1ebSSage Weil int new = 0; 145355da1ebSSage Weil 146355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 147355da1ebSSage Weil while (*p) { 148355da1ebSSage Weil parent = *p; 149355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 150355da1ebSSage Weil c = strncmp(name, xattr->name, min(name_len, xattr->name_len)); 151355da1ebSSage Weil if (c < 0) 152355da1ebSSage Weil p = &(*p)->rb_left; 153355da1ebSSage Weil else if (c > 0) 154355da1ebSSage Weil p = &(*p)->rb_right; 155355da1ebSSage Weil else { 156355da1ebSSage Weil if (name_len == xattr->name_len) 157355da1ebSSage Weil break; 158355da1ebSSage Weil else if (name_len < xattr->name_len) 159355da1ebSSage Weil p = &(*p)->rb_left; 160355da1ebSSage Weil else 161355da1ebSSage Weil p = &(*p)->rb_right; 162355da1ebSSage Weil } 163355da1ebSSage Weil xattr = NULL; 164355da1ebSSage Weil } 165355da1ebSSage Weil 166355da1ebSSage Weil if (!xattr) { 167355da1ebSSage Weil new = 1; 168355da1ebSSage Weil xattr = *newxattr; 169355da1ebSSage Weil xattr->name = name; 170355da1ebSSage Weil xattr->name_len = name_len; 171355da1ebSSage Weil xattr->should_free_name = should_free_name; 172355da1ebSSage Weil 173355da1ebSSage Weil ci->i_xattrs.count++; 174355da1ebSSage Weil dout("__set_xattr count=%d\n", ci->i_xattrs.count); 175355da1ebSSage Weil } else { 176355da1ebSSage Weil kfree(*newxattr); 177355da1ebSSage Weil *newxattr = NULL; 178355da1ebSSage Weil if (xattr->should_free_val) 179355da1ebSSage Weil kfree((void *)xattr->val); 180355da1ebSSage Weil 181355da1ebSSage Weil if (should_free_name) { 182355da1ebSSage Weil kfree((void *)name); 183355da1ebSSage Weil name = xattr->name; 184355da1ebSSage Weil } 185355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 186355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 187355da1ebSSage Weil } 188355da1ebSSage Weil if (!xattr) { 189355da1ebSSage Weil pr_err("__set_xattr ENOMEM on %p %llx.%llx xattr %s=%s\n", 190355da1ebSSage Weil &ci->vfs_inode, ceph_vinop(&ci->vfs_inode), name, 191355da1ebSSage Weil xattr->val); 192355da1ebSSage Weil return -ENOMEM; 193355da1ebSSage Weil } 194355da1ebSSage Weil ci->i_xattrs.names_size += name_len; 195355da1ebSSage Weil ci->i_xattrs.vals_size += val_len; 196355da1ebSSage Weil if (val) 197355da1ebSSage Weil xattr->val = val; 198355da1ebSSage Weil else 199355da1ebSSage Weil xattr->val = ""; 200355da1ebSSage Weil 201355da1ebSSage Weil xattr->val_len = val_len; 202355da1ebSSage Weil xattr->dirty = dirty; 203355da1ebSSage Weil xattr->should_free_val = (val && should_free_val); 204355da1ebSSage Weil 205355da1ebSSage Weil if (new) { 206355da1ebSSage Weil rb_link_node(&xattr->node, parent, p); 207355da1ebSSage Weil rb_insert_color(&xattr->node, &ci->i_xattrs.index); 208355da1ebSSage Weil dout("__set_xattr_val p=%p\n", p); 209355da1ebSSage Weil } 210355da1ebSSage Weil 211355da1ebSSage Weil dout("__set_xattr_val added %llx.%llx xattr %p %s=%.*s\n", 212355da1ebSSage Weil ceph_vinop(&ci->vfs_inode), xattr, name, val_len, val); 213355da1ebSSage Weil 214355da1ebSSage Weil return 0; 215355da1ebSSage Weil } 216355da1ebSSage Weil 217355da1ebSSage Weil static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci, 218355da1ebSSage Weil const char *name) 219355da1ebSSage Weil { 220355da1ebSSage Weil struct rb_node **p; 221355da1ebSSage Weil struct rb_node *parent = NULL; 222355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 223355da1ebSSage Weil int c; 224355da1ebSSage Weil 225355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 226355da1ebSSage Weil while (*p) { 227355da1ebSSage Weil parent = *p; 228355da1ebSSage Weil xattr = rb_entry(parent, struct ceph_inode_xattr, node); 229355da1ebSSage Weil c = strncmp(name, xattr->name, xattr->name_len); 230355da1ebSSage Weil if (c < 0) 231355da1ebSSage Weil p = &(*p)->rb_left; 232355da1ebSSage Weil else if (c > 0) 233355da1ebSSage Weil p = &(*p)->rb_right; 234355da1ebSSage Weil else { 235355da1ebSSage Weil dout("__get_xattr %s: found %.*s\n", name, 236355da1ebSSage Weil xattr->val_len, xattr->val); 237355da1ebSSage Weil return xattr; 238355da1ebSSage Weil } 239355da1ebSSage Weil } 240355da1ebSSage Weil 241355da1ebSSage Weil dout("__get_xattr %s: not found\n", name); 242355da1ebSSage Weil 243355da1ebSSage Weil return NULL; 244355da1ebSSage Weil } 245355da1ebSSage Weil 246355da1ebSSage Weil static void __free_xattr(struct ceph_inode_xattr *xattr) 247355da1ebSSage Weil { 248355da1ebSSage Weil BUG_ON(!xattr); 249355da1ebSSage Weil 250355da1ebSSage Weil if (xattr->should_free_name) 251355da1ebSSage Weil kfree((void *)xattr->name); 252355da1ebSSage Weil if (xattr->should_free_val) 253355da1ebSSage Weil kfree((void *)xattr->val); 254355da1ebSSage Weil 255355da1ebSSage Weil kfree(xattr); 256355da1ebSSage Weil } 257355da1ebSSage Weil 258355da1ebSSage Weil static int __remove_xattr(struct ceph_inode_info *ci, 259355da1ebSSage Weil struct ceph_inode_xattr *xattr) 260355da1ebSSage Weil { 261355da1ebSSage Weil if (!xattr) 262355da1ebSSage Weil return -EOPNOTSUPP; 263355da1ebSSage Weil 264355da1ebSSage Weil rb_erase(&xattr->node, &ci->i_xattrs.index); 265355da1ebSSage Weil 266355da1ebSSage Weil if (xattr->should_free_name) 267355da1ebSSage Weil kfree((void *)xattr->name); 268355da1ebSSage Weil if (xattr->should_free_val) 269355da1ebSSage Weil kfree((void *)xattr->val); 270355da1ebSSage Weil 271355da1ebSSage Weil ci->i_xattrs.names_size -= xattr->name_len; 272355da1ebSSage Weil ci->i_xattrs.vals_size -= xattr->val_len; 273355da1ebSSage Weil ci->i_xattrs.count--; 274355da1ebSSage Weil kfree(xattr); 275355da1ebSSage Weil 276355da1ebSSage Weil return 0; 277355da1ebSSage Weil } 278355da1ebSSage Weil 279355da1ebSSage Weil static int __remove_xattr_by_name(struct ceph_inode_info *ci, 280355da1ebSSage Weil const char *name) 281355da1ebSSage Weil { 282355da1ebSSage Weil struct rb_node **p; 283355da1ebSSage Weil struct ceph_inode_xattr *xattr; 284355da1ebSSage Weil int err; 285355da1ebSSage Weil 286355da1ebSSage Weil p = &ci->i_xattrs.index.rb_node; 287355da1ebSSage Weil xattr = __get_xattr(ci, name); 288355da1ebSSage Weil err = __remove_xattr(ci, xattr); 289355da1ebSSage Weil return err; 290355da1ebSSage Weil } 291355da1ebSSage Weil 292355da1ebSSage Weil static char *__copy_xattr_names(struct ceph_inode_info *ci, 293355da1ebSSage Weil char *dest) 294355da1ebSSage Weil { 295355da1ebSSage Weil struct rb_node *p; 296355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 297355da1ebSSage Weil 298355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 299355da1ebSSage Weil dout("__copy_xattr_names count=%d\n", ci->i_xattrs.count); 300355da1ebSSage Weil 301355da1ebSSage Weil while (p) { 302355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 303355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 304355da1ebSSage Weil dest[xattr->name_len] = '\0'; 305355da1ebSSage Weil 306355da1ebSSage Weil dout("dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name, 307355da1ebSSage Weil xattr->name_len, ci->i_xattrs.names_size); 308355da1ebSSage Weil 309355da1ebSSage Weil dest += xattr->name_len + 1; 310355da1ebSSage Weil p = rb_next(p); 311355da1ebSSage Weil } 312355da1ebSSage Weil 313355da1ebSSage Weil return dest; 314355da1ebSSage Weil } 315355da1ebSSage Weil 316355da1ebSSage Weil void __ceph_destroy_xattrs(struct ceph_inode_info *ci) 317355da1ebSSage Weil { 318355da1ebSSage Weil struct rb_node *p, *tmp; 319355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 320355da1ebSSage Weil 321355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 322355da1ebSSage Weil 323355da1ebSSage Weil dout("__ceph_destroy_xattrs p=%p\n", p); 324355da1ebSSage Weil 325355da1ebSSage Weil while (p) { 326355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 327355da1ebSSage Weil tmp = p; 328355da1ebSSage Weil p = rb_next(tmp); 329355da1ebSSage Weil dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p, 330355da1ebSSage Weil xattr->name_len, xattr->name); 331355da1ebSSage Weil rb_erase(tmp, &ci->i_xattrs.index); 332355da1ebSSage Weil 333355da1ebSSage Weil __free_xattr(xattr); 334355da1ebSSage Weil } 335355da1ebSSage Weil 336355da1ebSSage Weil ci->i_xattrs.names_size = 0; 337355da1ebSSage Weil ci->i_xattrs.vals_size = 0; 338355da1ebSSage Weil ci->i_xattrs.index_version = 0; 339355da1ebSSage Weil ci->i_xattrs.count = 0; 340355da1ebSSage Weil ci->i_xattrs.index = RB_ROOT; 341355da1ebSSage Weil } 342355da1ebSSage Weil 343355da1ebSSage Weil static int __build_xattrs(struct inode *inode) 344355da1ebSSage Weil { 345355da1ebSSage Weil u32 namelen; 346355da1ebSSage Weil u32 numattr = 0; 347355da1ebSSage Weil void *p, *end; 348355da1ebSSage Weil u32 len; 349355da1ebSSage Weil const char *name, *val; 350355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 351355da1ebSSage Weil int xattr_version; 352355da1ebSSage Weil struct ceph_inode_xattr **xattrs = NULL; 353355da1ebSSage Weil int err; 354355da1ebSSage Weil int i; 355355da1ebSSage Weil 356355da1ebSSage Weil dout("__build_xattrs() len=%d\n", 357355da1ebSSage Weil ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0); 358355da1ebSSage Weil 359355da1ebSSage Weil if (ci->i_xattrs.index_version >= ci->i_xattrs.version) 360355da1ebSSage Weil return 0; /* already built */ 361355da1ebSSage Weil 362355da1ebSSage Weil __ceph_destroy_xattrs(ci); 363355da1ebSSage Weil 364355da1ebSSage Weil start: 365355da1ebSSage Weil /* updated internal xattr rb tree */ 366355da1ebSSage Weil if (ci->i_xattrs.blob && ci->i_xattrs.blob->vec.iov_len > 4) { 367355da1ebSSage Weil p = ci->i_xattrs.blob->vec.iov_base; 368355da1ebSSage Weil end = p + ci->i_xattrs.blob->vec.iov_len; 369355da1ebSSage Weil ceph_decode_32_safe(&p, end, numattr, bad); 370355da1ebSSage Weil xattr_version = ci->i_xattrs.version; 371355da1ebSSage Weil spin_unlock(&inode->i_lock); 372355da1ebSSage Weil 373355da1ebSSage Weil xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *), 374355da1ebSSage Weil GFP_NOFS); 375355da1ebSSage Weil err = -ENOMEM; 376355da1ebSSage Weil if (!xattrs) 377355da1ebSSage Weil goto bad_lock; 378355da1ebSSage Weil memset(xattrs, 0, numattr*sizeof(struct ceph_xattr *)); 379355da1ebSSage Weil for (i = 0; i < numattr; i++) { 380355da1ebSSage Weil xattrs[i] = kmalloc(sizeof(struct ceph_inode_xattr), 381355da1ebSSage Weil GFP_NOFS); 382355da1ebSSage Weil if (!xattrs[i]) 383355da1ebSSage Weil goto bad_lock; 384355da1ebSSage Weil } 385355da1ebSSage Weil 386355da1ebSSage Weil spin_lock(&inode->i_lock); 387355da1ebSSage Weil if (ci->i_xattrs.version != xattr_version) { 388355da1ebSSage Weil /* lost a race, retry */ 389355da1ebSSage Weil for (i = 0; i < numattr; i++) 390355da1ebSSage Weil kfree(xattrs[i]); 391355da1ebSSage Weil kfree(xattrs); 392355da1ebSSage Weil goto start; 393355da1ebSSage Weil } 394355da1ebSSage Weil err = -EIO; 395355da1ebSSage Weil while (numattr--) { 396355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 397355da1ebSSage Weil namelen = len; 398355da1ebSSage Weil name = p; 399355da1ebSSage Weil p += len; 400355da1ebSSage Weil ceph_decode_32_safe(&p, end, len, bad); 401355da1ebSSage Weil val = p; 402355da1ebSSage Weil p += len; 403355da1ebSSage Weil 404355da1ebSSage Weil err = __set_xattr(ci, name, namelen, val, len, 405355da1ebSSage Weil 0, 0, 0, &xattrs[numattr]); 406355da1ebSSage Weil 407355da1ebSSage Weil if (err < 0) 408355da1ebSSage Weil goto bad; 409355da1ebSSage Weil } 410355da1ebSSage Weil kfree(xattrs); 411355da1ebSSage Weil } 412355da1ebSSage Weil ci->i_xattrs.index_version = ci->i_xattrs.version; 413355da1ebSSage Weil ci->i_xattrs.dirty = false; 414355da1ebSSage Weil 415355da1ebSSage Weil return err; 416355da1ebSSage Weil bad_lock: 417355da1ebSSage Weil spin_lock(&inode->i_lock); 418355da1ebSSage Weil bad: 419355da1ebSSage Weil if (xattrs) { 420355da1ebSSage Weil for (i = 0; i < numattr; i++) 421355da1ebSSage Weil kfree(xattrs[i]); 422355da1ebSSage Weil kfree(xattrs); 423355da1ebSSage Weil } 424355da1ebSSage Weil ci->i_xattrs.names_size = 0; 425355da1ebSSage Weil return err; 426355da1ebSSage Weil } 427355da1ebSSage Weil 428355da1ebSSage Weil static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size, 429355da1ebSSage Weil int val_size) 430355da1ebSSage Weil { 431355da1ebSSage Weil /* 432355da1ebSSage Weil * 4 bytes for the length, and additional 4 bytes per each xattr name, 433355da1ebSSage Weil * 4 bytes per each value 434355da1ebSSage Weil */ 435355da1ebSSage Weil int size = 4 + ci->i_xattrs.count*(4 + 4) + 436355da1ebSSage Weil ci->i_xattrs.names_size + 437355da1ebSSage Weil ci->i_xattrs.vals_size; 438355da1ebSSage Weil dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n", 439355da1ebSSage Weil ci->i_xattrs.count, ci->i_xattrs.names_size, 440355da1ebSSage Weil ci->i_xattrs.vals_size); 441355da1ebSSage Weil 442355da1ebSSage Weil if (name_size) 443355da1ebSSage Weil size += 4 + 4 + name_size + val_size; 444355da1ebSSage Weil 445355da1ebSSage Weil return size; 446355da1ebSSage Weil } 447355da1ebSSage Weil 448355da1ebSSage Weil /* 449355da1ebSSage Weil * If there are dirty xattrs, reencode xattrs into the prealloc_blob 450355da1ebSSage Weil * and swap into place. 451355da1ebSSage Weil */ 452355da1ebSSage Weil void __ceph_build_xattrs_blob(struct ceph_inode_info *ci) 453355da1ebSSage Weil { 454355da1ebSSage Weil struct rb_node *p; 455355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 456355da1ebSSage Weil void *dest; 457355da1ebSSage Weil 458355da1ebSSage Weil dout("__build_xattrs_blob %p\n", &ci->vfs_inode); 459355da1ebSSage Weil if (ci->i_xattrs.dirty) { 460355da1ebSSage Weil int need = __get_required_blob_size(ci, 0, 0); 461355da1ebSSage Weil 462355da1ebSSage Weil BUG_ON(need > ci->i_xattrs.prealloc_blob->alloc_len); 463355da1ebSSage Weil 464355da1ebSSage Weil p = rb_first(&ci->i_xattrs.index); 465355da1ebSSage Weil dest = ci->i_xattrs.prealloc_blob->vec.iov_base; 466355da1ebSSage Weil 467355da1ebSSage Weil ceph_encode_32(&dest, ci->i_xattrs.count); 468355da1ebSSage Weil while (p) { 469355da1ebSSage Weil xattr = rb_entry(p, struct ceph_inode_xattr, node); 470355da1ebSSage Weil 471355da1ebSSage Weil ceph_encode_32(&dest, xattr->name_len); 472355da1ebSSage Weil memcpy(dest, xattr->name, xattr->name_len); 473355da1ebSSage Weil dest += xattr->name_len; 474355da1ebSSage Weil ceph_encode_32(&dest, xattr->val_len); 475355da1ebSSage Weil memcpy(dest, xattr->val, xattr->val_len); 476355da1ebSSage Weil dest += xattr->val_len; 477355da1ebSSage Weil 478355da1ebSSage Weil p = rb_next(p); 479355da1ebSSage Weil } 480355da1ebSSage Weil 481355da1ebSSage Weil /* adjust buffer len; it may be larger than we need */ 482355da1ebSSage Weil ci->i_xattrs.prealloc_blob->vec.iov_len = 483355da1ebSSage Weil dest - ci->i_xattrs.prealloc_blob->vec.iov_base; 484355da1ebSSage Weil 485355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.blob); 486355da1ebSSage Weil ci->i_xattrs.blob = ci->i_xattrs.prealloc_blob; 487355da1ebSSage Weil ci->i_xattrs.prealloc_blob = NULL; 488355da1ebSSage Weil ci->i_xattrs.dirty = false; 489355da1ebSSage Weil } 490355da1ebSSage Weil } 491355da1ebSSage Weil 492355da1ebSSage Weil ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value, 493355da1ebSSage Weil size_t size) 494355da1ebSSage Weil { 495355da1ebSSage Weil struct inode *inode = dentry->d_inode; 496355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 497355da1ebSSage Weil struct ceph_vxattr_cb *vxattrs = ceph_inode_vxattrs(inode); 498355da1ebSSage Weil int err; 499355da1ebSSage Weil struct ceph_inode_xattr *xattr; 500355da1ebSSage Weil struct ceph_vxattr_cb *vxattr = NULL; 501355da1ebSSage Weil 502355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 503355da1ebSSage Weil return -ENODATA; 504355da1ebSSage Weil 505355da1ebSSage Weil /* let's see if a virtual xattr was requested */ 506355da1ebSSage Weil if (vxattrs) 507355da1ebSSage Weil vxattr = ceph_match_vxattr(vxattrs, name); 508355da1ebSSage Weil 509355da1ebSSage Weil spin_lock(&inode->i_lock); 510355da1ebSSage Weil dout("getxattr %p ver=%lld index_ver=%lld\n", inode, 511355da1ebSSage Weil ci->i_xattrs.version, ci->i_xattrs.index_version); 512355da1ebSSage Weil 513355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 514355da1ebSSage Weil (ci->i_xattrs.index_version >= ci->i_xattrs.version)) { 515355da1ebSSage Weil goto get_xattr; 516355da1ebSSage Weil } else { 517355da1ebSSage Weil spin_unlock(&inode->i_lock); 518355da1ebSSage Weil /* get xattrs from mds (if we don't already have them) */ 519355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 520355da1ebSSage Weil if (err) 521355da1ebSSage Weil return err; 522355da1ebSSage Weil } 523355da1ebSSage Weil 524355da1ebSSage Weil spin_lock(&inode->i_lock); 525355da1ebSSage Weil 526355da1ebSSage Weil if (vxattr && vxattr->readonly) { 527355da1ebSSage Weil err = vxattr->getxattr_cb(ci, value, size); 528355da1ebSSage Weil goto out; 529355da1ebSSage Weil } 530355da1ebSSage Weil 531355da1ebSSage Weil err = __build_xattrs(inode); 532355da1ebSSage Weil if (err < 0) 533355da1ebSSage Weil goto out; 534355da1ebSSage Weil 535355da1ebSSage Weil get_xattr: 536355da1ebSSage Weil err = -ENODATA; /* == ENOATTR */ 537355da1ebSSage Weil xattr = __get_xattr(ci, name); 538355da1ebSSage Weil if (!xattr) { 539355da1ebSSage Weil if (vxattr) 540355da1ebSSage Weil err = vxattr->getxattr_cb(ci, value, size); 541355da1ebSSage Weil goto out; 542355da1ebSSage Weil } 543355da1ebSSage Weil 544355da1ebSSage Weil err = -ERANGE; 545355da1ebSSage Weil if (size && size < xattr->val_len) 546355da1ebSSage Weil goto out; 547355da1ebSSage Weil 548355da1ebSSage Weil err = xattr->val_len; 549355da1ebSSage Weil if (size == 0) 550355da1ebSSage Weil goto out; 551355da1ebSSage Weil 552355da1ebSSage Weil memcpy(value, xattr->val, xattr->val_len); 553355da1ebSSage Weil 554355da1ebSSage Weil out: 555355da1ebSSage Weil spin_unlock(&inode->i_lock); 556355da1ebSSage Weil return err; 557355da1ebSSage Weil } 558355da1ebSSage Weil 559355da1ebSSage Weil ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size) 560355da1ebSSage Weil { 561355da1ebSSage Weil struct inode *inode = dentry->d_inode; 562355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 563355da1ebSSage Weil struct ceph_vxattr_cb *vxattrs = ceph_inode_vxattrs(inode); 564355da1ebSSage Weil u32 vir_namelen = 0; 565355da1ebSSage Weil u32 namelen; 566355da1ebSSage Weil int err; 567355da1ebSSage Weil u32 len; 568355da1ebSSage Weil int i; 569355da1ebSSage Weil 570355da1ebSSage Weil spin_lock(&inode->i_lock); 571355da1ebSSage Weil dout("listxattr %p ver=%lld index_ver=%lld\n", inode, 572355da1ebSSage Weil ci->i_xattrs.version, ci->i_xattrs.index_version); 573355da1ebSSage Weil 574355da1ebSSage Weil if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) && 575355da1ebSSage Weil (ci->i_xattrs.index_version > ci->i_xattrs.version)) { 576355da1ebSSage Weil goto list_xattr; 577355da1ebSSage Weil } else { 578355da1ebSSage Weil spin_unlock(&inode->i_lock); 579355da1ebSSage Weil err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR); 580355da1ebSSage Weil if (err) 581355da1ebSSage Weil return err; 582355da1ebSSage Weil } 583355da1ebSSage Weil 584355da1ebSSage Weil spin_lock(&inode->i_lock); 585355da1ebSSage Weil 586355da1ebSSage Weil err = __build_xattrs(inode); 587355da1ebSSage Weil if (err < 0) 588355da1ebSSage Weil goto out; 589355da1ebSSage Weil 590355da1ebSSage Weil list_xattr: 591355da1ebSSage Weil vir_namelen = 0; 592355da1ebSSage Weil /* include virtual dir xattrs */ 593355da1ebSSage Weil if (vxattrs) 594355da1ebSSage Weil for (i = 0; vxattrs[i].name; i++) 595355da1ebSSage Weil vir_namelen += strlen(vxattrs[i].name) + 1; 596355da1ebSSage Weil /* adding 1 byte per each variable due to the null termination */ 597355da1ebSSage Weil namelen = vir_namelen + ci->i_xattrs.names_size + ci->i_xattrs.count; 598355da1ebSSage Weil err = -ERANGE; 599355da1ebSSage Weil if (size && namelen > size) 600355da1ebSSage Weil goto out; 601355da1ebSSage Weil 602355da1ebSSage Weil err = namelen; 603355da1ebSSage Weil if (size == 0) 604355da1ebSSage Weil goto out; 605355da1ebSSage Weil 606355da1ebSSage Weil names = __copy_xattr_names(ci, names); 607355da1ebSSage Weil 608355da1ebSSage Weil /* virtual xattr names, too */ 609355da1ebSSage Weil if (vxattrs) 610355da1ebSSage Weil for (i = 0; vxattrs[i].name; i++) { 611355da1ebSSage Weil len = sprintf(names, "%s", vxattrs[i].name); 612355da1ebSSage Weil names += len + 1; 613355da1ebSSage Weil } 614355da1ebSSage Weil 615355da1ebSSage Weil out: 616355da1ebSSage Weil spin_unlock(&inode->i_lock); 617355da1ebSSage Weil return err; 618355da1ebSSage Weil } 619355da1ebSSage Weil 620355da1ebSSage Weil static int ceph_sync_setxattr(struct dentry *dentry, const char *name, 621355da1ebSSage Weil const char *value, size_t size, int flags) 622355da1ebSSage Weil { 623355da1ebSSage Weil struct ceph_client *client = ceph_client(dentry->d_sb); 624355da1ebSSage Weil struct inode *inode = dentry->d_inode; 625355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 626355da1ebSSage Weil struct inode *parent_inode = dentry->d_parent->d_inode; 627355da1ebSSage Weil struct ceph_mds_request *req; 628355da1ebSSage Weil struct ceph_mds_client *mdsc = &client->mdsc; 629355da1ebSSage Weil int err; 630355da1ebSSage Weil int i, nr_pages; 631355da1ebSSage Weil struct page **pages = NULL; 632355da1ebSSage Weil void *kaddr; 633355da1ebSSage Weil 634355da1ebSSage Weil /* copy value into some pages */ 635355da1ebSSage Weil nr_pages = calc_pages_for(0, size); 636355da1ebSSage Weil if (nr_pages) { 637355da1ebSSage Weil pages = kmalloc(sizeof(pages[0])*nr_pages, GFP_NOFS); 638355da1ebSSage Weil if (!pages) 639355da1ebSSage Weil return -ENOMEM; 640355da1ebSSage Weil err = -ENOMEM; 641355da1ebSSage Weil for (i = 0; i < nr_pages; i++) { 642355da1ebSSage Weil pages[i] = alloc_page(GFP_NOFS); 643355da1ebSSage Weil if (!pages[i]) { 644355da1ebSSage Weil nr_pages = i; 645355da1ebSSage Weil goto out; 646355da1ebSSage Weil } 647355da1ebSSage Weil kaddr = kmap(pages[i]); 648355da1ebSSage Weil memcpy(kaddr, value + i*PAGE_CACHE_SIZE, 649355da1ebSSage Weil min(PAGE_CACHE_SIZE, size-i*PAGE_CACHE_SIZE)); 650355da1ebSSage Weil } 651355da1ebSSage Weil } 652355da1ebSSage Weil 653355da1ebSSage Weil dout("setxattr value=%.*s\n", (int)size, value); 654355da1ebSSage Weil 655355da1ebSSage Weil /* do request */ 656355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETXATTR, 657355da1ebSSage Weil USE_AUTH_MDS); 658355da1ebSSage Weil if (IS_ERR(req)) 659355da1ebSSage Weil return PTR_ERR(req); 660355da1ebSSage Weil req->r_inode = igrab(inode); 661355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 662355da1ebSSage Weil req->r_num_caps = 1; 663355da1ebSSage Weil req->r_args.setxattr.flags = cpu_to_le32(flags); 664355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 665355da1ebSSage Weil 666355da1ebSSage Weil req->r_pages = pages; 667355da1ebSSage Weil req->r_num_pages = nr_pages; 668355da1ebSSage Weil req->r_data_len = size; 669355da1ebSSage Weil 670355da1ebSSage Weil dout("xattr.ver (before): %lld\n", ci->i_xattrs.version); 671355da1ebSSage Weil err = ceph_mdsc_do_request(mdsc, parent_inode, req); 672355da1ebSSage Weil ceph_mdsc_put_request(req); 673355da1ebSSage Weil dout("xattr.ver (after): %lld\n", ci->i_xattrs.version); 674355da1ebSSage Weil 675355da1ebSSage Weil out: 676355da1ebSSage Weil if (pages) { 677355da1ebSSage Weil for (i = 0; i < nr_pages; i++) 678355da1ebSSage Weil __free_page(pages[i]); 679355da1ebSSage Weil kfree(pages); 680355da1ebSSage Weil } 681355da1ebSSage Weil return err; 682355da1ebSSage Weil } 683355da1ebSSage Weil 684355da1ebSSage Weil int ceph_setxattr(struct dentry *dentry, const char *name, 685355da1ebSSage Weil const void *value, size_t size, int flags) 686355da1ebSSage Weil { 687355da1ebSSage Weil struct inode *inode = dentry->d_inode; 688355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 689355da1ebSSage Weil struct ceph_vxattr_cb *vxattrs = ceph_inode_vxattrs(inode); 690355da1ebSSage Weil int err; 691355da1ebSSage Weil int name_len = strlen(name); 692355da1ebSSage Weil int val_len = size; 693355da1ebSSage Weil char *newname = NULL; 694355da1ebSSage Weil char *newval = NULL; 695355da1ebSSage Weil struct ceph_inode_xattr *xattr = NULL; 696355da1ebSSage Weil int issued; 697355da1ebSSage Weil int required_blob_size; 698355da1ebSSage Weil 699355da1ebSSage Weil if (ceph_snap(inode) != CEPH_NOSNAP) 700355da1ebSSage Weil return -EROFS; 701355da1ebSSage Weil 702355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 703355da1ebSSage Weil return -EOPNOTSUPP; 704355da1ebSSage Weil 705355da1ebSSage Weil if (vxattrs) { 706355da1ebSSage Weil struct ceph_vxattr_cb *vxattr = 707355da1ebSSage Weil ceph_match_vxattr(vxattrs, name); 708355da1ebSSage Weil if (vxattr && vxattr->readonly) 709355da1ebSSage Weil return -EOPNOTSUPP; 710355da1ebSSage Weil } 711355da1ebSSage Weil 712355da1ebSSage Weil /* preallocate memory for xattr name, value, index node */ 713355da1ebSSage Weil err = -ENOMEM; 714355da1ebSSage Weil newname = kmalloc(name_len + 1, GFP_NOFS); 715355da1ebSSage Weil if (!newname) 716355da1ebSSage Weil goto out; 717355da1ebSSage Weil memcpy(newname, name, name_len + 1); 718355da1ebSSage Weil 719355da1ebSSage Weil if (val_len) { 720355da1ebSSage Weil newval = kmalloc(val_len + 1, GFP_NOFS); 721355da1ebSSage Weil if (!newval) 722355da1ebSSage Weil goto out; 723355da1ebSSage Weil memcpy(newval, value, val_len); 724355da1ebSSage Weil newval[val_len] = '\0'; 725355da1ebSSage Weil } 726355da1ebSSage Weil 727355da1ebSSage Weil xattr = kmalloc(sizeof(struct ceph_inode_xattr), GFP_NOFS); 728355da1ebSSage Weil if (!xattr) 729355da1ebSSage Weil goto out; 730355da1ebSSage Weil 731355da1ebSSage Weil spin_lock(&inode->i_lock); 732355da1ebSSage Weil retry: 733355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 734355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 735355da1ebSSage Weil goto do_sync; 736355da1ebSSage Weil __build_xattrs(inode); 737355da1ebSSage Weil 738355da1ebSSage Weil required_blob_size = __get_required_blob_size(ci, name_len, val_len); 739355da1ebSSage Weil 740355da1ebSSage Weil if (!ci->i_xattrs.prealloc_blob || 741355da1ebSSage Weil required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) { 742355da1ebSSage Weil struct ceph_buffer *blob = NULL; 743355da1ebSSage Weil 744355da1ebSSage Weil spin_unlock(&inode->i_lock); 745355da1ebSSage Weil dout(" preaallocating new blob size=%d\n", required_blob_size); 746355da1ebSSage Weil blob = ceph_buffer_new_alloc(required_blob_size, GFP_NOFS); 747355da1ebSSage Weil if (!blob) 748355da1ebSSage Weil goto out; 749355da1ebSSage Weil spin_lock(&inode->i_lock); 750355da1ebSSage Weil ceph_buffer_put(ci->i_xattrs.prealloc_blob); 751355da1ebSSage Weil ci->i_xattrs.prealloc_blob = blob; 752355da1ebSSage Weil goto retry; 753355da1ebSSage Weil } 754355da1ebSSage Weil 755355da1ebSSage Weil dout("setxattr %p issued %s\n", inode, ceph_cap_string(issued)); 756355da1ebSSage Weil err = __set_xattr(ci, newname, name_len, newval, 757355da1ebSSage Weil val_len, 1, 1, 1, &xattr); 758355da1ebSSage Weil __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 759355da1ebSSage Weil ci->i_xattrs.dirty = true; 760355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 761355da1ebSSage Weil spin_unlock(&inode->i_lock); 762355da1ebSSage Weil 763355da1ebSSage Weil return err; 764355da1ebSSage Weil 765355da1ebSSage Weil do_sync: 766355da1ebSSage Weil spin_unlock(&inode->i_lock); 767355da1ebSSage Weil err = ceph_sync_setxattr(dentry, name, value, size, flags); 768355da1ebSSage Weil out: 769355da1ebSSage Weil kfree(newname); 770355da1ebSSage Weil kfree(newval); 771355da1ebSSage Weil kfree(xattr); 772355da1ebSSage Weil return err; 773355da1ebSSage Weil } 774355da1ebSSage Weil 775355da1ebSSage Weil static int ceph_send_removexattr(struct dentry *dentry, const char *name) 776355da1ebSSage Weil { 777355da1ebSSage Weil struct ceph_client *client = ceph_client(dentry->d_sb); 778355da1ebSSage Weil struct ceph_mds_client *mdsc = &client->mdsc; 779355da1ebSSage Weil struct inode *inode = dentry->d_inode; 780355da1ebSSage Weil struct inode *parent_inode = dentry->d_parent->d_inode; 781355da1ebSSage Weil struct ceph_mds_request *req; 782355da1ebSSage Weil int err; 783355da1ebSSage Weil 784355da1ebSSage Weil req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RMXATTR, 785355da1ebSSage Weil USE_AUTH_MDS); 786355da1ebSSage Weil if (IS_ERR(req)) 787355da1ebSSage Weil return PTR_ERR(req); 788355da1ebSSage Weil req->r_inode = igrab(inode); 789355da1ebSSage Weil req->r_inode_drop = CEPH_CAP_XATTR_SHARED; 790355da1ebSSage Weil req->r_num_caps = 1; 791355da1ebSSage Weil req->r_path2 = kstrdup(name, GFP_NOFS); 792355da1ebSSage Weil 793355da1ebSSage Weil err = ceph_mdsc_do_request(mdsc, parent_inode, req); 794355da1ebSSage Weil ceph_mdsc_put_request(req); 795355da1ebSSage Weil return err; 796355da1ebSSage Weil } 797355da1ebSSage Weil 798355da1ebSSage Weil int ceph_removexattr(struct dentry *dentry, const char *name) 799355da1ebSSage Weil { 800355da1ebSSage Weil struct inode *inode = dentry->d_inode; 801355da1ebSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 802355da1ebSSage Weil struct ceph_vxattr_cb *vxattrs = ceph_inode_vxattrs(inode); 803355da1ebSSage Weil int issued; 804355da1ebSSage Weil int err; 805355da1ebSSage Weil 806355da1ebSSage Weil if (ceph_snap(inode) != CEPH_NOSNAP) 807355da1ebSSage Weil return -EROFS; 808355da1ebSSage Weil 809355da1ebSSage Weil if (!ceph_is_valid_xattr(name)) 810355da1ebSSage Weil return -EOPNOTSUPP; 811355da1ebSSage Weil 812355da1ebSSage Weil if (vxattrs) { 813355da1ebSSage Weil struct ceph_vxattr_cb *vxattr = 814355da1ebSSage Weil ceph_match_vxattr(vxattrs, name); 815355da1ebSSage Weil if (vxattr && vxattr->readonly) 816355da1ebSSage Weil return -EOPNOTSUPP; 817355da1ebSSage Weil } 818355da1ebSSage Weil 819355da1ebSSage Weil spin_lock(&inode->i_lock); 820355da1ebSSage Weil __build_xattrs(inode); 821355da1ebSSage Weil issued = __ceph_caps_issued(ci, NULL); 822355da1ebSSage Weil dout("removexattr %p issued %s\n", inode, ceph_cap_string(issued)); 823355da1ebSSage Weil 824355da1ebSSage Weil if (!(issued & CEPH_CAP_XATTR_EXCL)) 825355da1ebSSage Weil goto do_sync; 826355da1ebSSage Weil 827355da1ebSSage Weil err = __remove_xattr_by_name(ceph_inode(inode), name); 828355da1ebSSage Weil __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL); 829355da1ebSSage Weil ci->i_xattrs.dirty = true; 830355da1ebSSage Weil inode->i_ctime = CURRENT_TIME; 831355da1ebSSage Weil 832355da1ebSSage Weil spin_unlock(&inode->i_lock); 833355da1ebSSage Weil 834355da1ebSSage Weil return err; 835355da1ebSSage Weil do_sync: 836355da1ebSSage Weil spin_unlock(&inode->i_lock); 837355da1ebSSage Weil err = ceph_send_removexattr(dentry, name); 838355da1ebSSage Weil return err; 839355da1ebSSage Weil } 840355da1ebSSage Weil 841