fs/ceph/xattr.c

   1 #include <linux/ceph/ceph_debug.h>
   2
   3 #include "super.h"
   4 #include "mds_client.h"
   5
   6 #include <linux/ceph/decode.h>
   7
   8 #include <linux/xattr.h>
   9 #include <linux/posix_acl_xattr.h>
  10 #include <linux/slab.h>
  11
  12 #define XATTR_CEPH_PREFIX "ceph."
  13 #define XATTR_CEPH_PREFIX_LEN (sizeof (XATTR_CEPH_PREFIX) - 1)
  14
  15 /*
  16  * List of handlers for synthetic system.* attributes. Other
  17  * attributes are handled directly.
  18  */
  19 const struct xattr_handler *ceph_xattr_handlers[] = {
  20 #ifdef CONFIG_CEPH_FS_POSIX_ACL
  21         &posix_acl_access_xattr_handler,
  22         &posix_acl_default_xattr_handler,
  23 #endif
  24         NULL,
  25 };
  26
  27 static bool ceph_is_valid_xattr(const char *name)
  28 {
  29         return !strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN) ||
  30                !strncmp(name, XATTR_SECURITY_PREFIX,
  31                         XATTR_SECURITY_PREFIX_LEN) ||
  32                !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) ||
  33                !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) ||
  34                !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
  35 }
  36
  37 /*
  38  * These define virtual xattrs exposing the recursive directory
  39  * statistics and layout metadata.
  40  */
  41 struct ceph_vxattr {
  42         char *name;
  43         size_t name_size;       /* strlen(name) + 1 (for '\0') */
  44         size_t (*getxattr_cb)(struct ceph_inode_info *ci, char *val,
  45                               size_t size);
  46         bool readonly, hidden;
  47         bool (*exists_cb)(struct ceph_inode_info *ci);
  48 };
  49
  50 /* layouts */
  51
  52 static bool ceph_vxattrcb_layout_exists(struct ceph_inode_info *ci)
  53 {
  54         size_t s;
  55         char *p = (char *)&ci->i_layout;
  56
  57         for (s = 0; s < sizeof(ci->i_layout); s++, p++)
  58                 if (*p)
  59                         return true;
  60         return false;
  61 }
  62
  63 static size_t ceph_vxattrcb_layout(struct ceph_inode_info *ci, char *val,
  64                                         size_t size)
  65 {
  66         int ret;
  67         struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb);
  68         struct ceph_osd_client *osdc = &fsc->client->osdc;
  69         s64 pool = ceph_file_layout_pg_pool(ci->i_layout);
  70         const char *pool_name;
  71
  72         dout("ceph_vxattrcb_layout %p\n", &ci->vfs_inode);
  73         down_read(&osdc->map_sem);
  74         pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool);
  75         if (pool_name)
  76                 ret = snprintf(val, size,
  77                 "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%s",
  78                 (unsigned long long)ceph_file_layout_su(ci->i_layout),
  79                 (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout),
  80                 (unsigned long long)ceph_file_layout_object_size(ci->i_layout),
  81                 pool_name);
  82         else
  83                 ret = snprintf(val, size,
  84                 "stripe_unit=%lld stripe_count=%lld object_size=%lld pool=%lld",
  85                 (unsigned long long)ceph_file_layout_su(ci->i_layout),
  86                 (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout),
  87                 (unsigned long long)ceph_file_layout_object_size(ci->i_layout),
  88                 (unsigned long long)pool);
  89
  90         up_read(&osdc->map_sem);
  91         return ret;
  92 }
  93
  94 static size_t ceph_vxattrcb_layout_stripe_unit(struct ceph_inode_info *ci,
  95                                                char *val, size_t size)
  96 {
  97         return snprintf(val, size, "%lld",
  98                         (unsigned long long)ceph_file_layout_su(ci->i_layout));
  99 }
 100
 101 static size_t ceph_vxattrcb_layout_stripe_count(struct ceph_inode_info *ci,
 102                                                 char *val, size_t size)
 103 {
 104         return snprintf(val, size, "%lld",
 105                (unsigned long long)ceph_file_layout_stripe_count(ci->i_layout));
 106 }
 107
 108 static size_t ceph_vxattrcb_layout_object_size(struct ceph_inode_info *ci,
 109                                                char *val, size_t size)
 110 {
 111         return snprintf(val, size, "%lld",
 112                (unsigned long long)ceph_file_layout_object_size(ci->i_layout));
 113 }
 114
 115 static size_t ceph_vxattrcb_layout_pool(struct ceph_inode_info *ci,
 116                                         char *val, size_t size)
 117 {
 118         int ret;
 119         struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb);
 120         struct ceph_osd_client *osdc = &fsc->client->osdc;
 121         s64 pool = ceph_file_layout_pg_pool(ci->i_layout);
 122         const char *pool_name;
 123
 124         down_read(&osdc->map_sem);
 125         pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool);
 126         if (pool_name)
 127                 ret = snprintf(val, size, "%s", pool_name);
 128         else
 129                 ret = snprintf(val, size, "%lld", (unsigned long long)pool);
 130         up_read(&osdc->map_sem);
 131         return ret;
 132 }
 133
 134 /* directories */
 135
 136 static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info *ci, char *val,
 137                                         size_t size)
 138 {
 139         return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs);
 140 }
 141
 142 static size_t ceph_vxattrcb_dir_files(struct ceph_inode_info *ci, char *val,
 143                                       size_t size)
 144 {
 145         return snprintf(val, size, "%lld", ci->i_files);
 146 }
 147
 148 static size_t ceph_vxattrcb_dir_subdirs(struct ceph_inode_info *ci, char *val,
 149                                         size_t size)
 150 {
 151         return snprintf(val, size, "%lld", ci->i_subdirs);
 152 }
 153
 154 static size_t ceph_vxattrcb_dir_rentries(struct ceph_inode_info *ci, char *val,
 155                                          size_t size)
 156 {
 157         return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs);
 158 }
 159
 160 static size_t ceph_vxattrcb_dir_rfiles(struct ceph_inode_info *ci, char *val,
 161                                        size_t size)
 162 {
 163         return snprintf(val, size, "%lld", ci->i_rfiles);
 164 }
 165
 166 static size_t ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info *ci, char *val,
 167                                          size_t size)
 168 {
 169         return snprintf(val, size, "%lld", ci->i_rsubdirs);
 170 }
 171
 172 static size_t ceph_vxattrcb_dir_rbytes(struct ceph_inode_info *ci, char *val,
 173                                        size_t size)
 174 {
 175         return snprintf(val, size, "%lld", ci->i_rbytes);
 176 }
 177
 178 static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info *ci, char *val,
 179                                        size_t size)
 180 {
 181         return snprintf(val, size, "%ld.09%ld", (long)ci->i_rctime.tv_sec,
 182                         (long)ci->i_rctime.tv_nsec);
 183 }
 184
 185
 186 #define CEPH_XATTR_NAME(_type, _name)   XATTR_CEPH_PREFIX #_type "." #_name
 187 #define CEPH_XATTR_NAME2(_type, _name, _name2)  \
 188         XATTR_CEPH_PREFIX #_type "." #_name "." #_name2
 189
 190 #define XATTR_NAME_CEPH(_type, _name)                                   \
 191         {                                                               \
 192                 .name = CEPH_XATTR_NAME(_type, _name),                  \
 193                 .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \
 194                 .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
 195                 .readonly = true,                               \
 196                 .hidden = false,                                \
 197                 .exists_cb = NULL,                      \
 198         }
 199 #define XATTR_LAYOUT_FIELD(_type, _name, _field)                        \
 200         {                                                               \
 201                 .name = CEPH_XATTR_NAME2(_type, _name, _field), \
 202                 .name_size = sizeof (CEPH_XATTR_NAME2(_type, _name, _field)), \
 203                 .getxattr_cb = ceph_vxattrcb_ ## _name ## _ ## _field, \
 204                 .readonly = false,                              \
 205                 .hidden = true,                 \
 206                 .exists_cb = ceph_vxattrcb_layout_exists,       \
 207         }
 208
 209 static struct ceph_vxattr ceph_dir_vxattrs[] = {
 210         {
 211                 .name = "ceph.dir.layout",
 212                 .name_size = sizeof("ceph.dir.layout"),
 213                 .getxattr_cb = ceph_vxattrcb_layout,
 214                 .readonly = false,
 215                 .hidden = false,
 216                 .exists_cb = ceph_vxattrcb_layout_exists,
 217         },
 218         XATTR_LAYOUT_FIELD(dir, layout, stripe_unit),
 219         XATTR_LAYOUT_FIELD(dir, layout, stripe_count),
 220         XATTR_LAYOUT_FIELD(dir, layout, object_size),
 221         XATTR_LAYOUT_FIELD(dir, layout, pool),
 222         XATTR_NAME_CEPH(dir, entries),
 223         XATTR_NAME_CEPH(dir, files),
 224         XATTR_NAME_CEPH(dir, subdirs),
 225         XATTR_NAME_CEPH(dir, rentries),
 226         XATTR_NAME_CEPH(dir, rfiles),
 227         XATTR_NAME_CEPH(dir, rsubdirs),
 228         XATTR_NAME_CEPH(dir, rbytes),
 229         XATTR_NAME_CEPH(dir, rctime),
 230         { .name = NULL, 0 }     /* Required table terminator */
 231 };
 232 static size_t ceph_dir_vxattrs_name_size;       /* total size of all names */
 233
 234 /* files */
 235
 236 static struct ceph_vxattr ceph_file_vxattrs[] = {
 237         {
 238                 .name = "ceph.file.layout",
 239                 .name_size = sizeof("ceph.file.layout"),
 240                 .getxattr_cb = ceph_vxattrcb_layout,
 241                 .readonly = false,
 242                 .hidden = false,
 243                 .exists_cb = ceph_vxattrcb_layout_exists,
 244         },
 245         XATTR_LAYOUT_FIELD(file, layout, stripe_unit),
 246         XATTR_LAYOUT_FIELD(file, layout, stripe_count),
 247         XATTR_LAYOUT_FIELD(file, layout, object_size),
 248         XATTR_LAYOUT_FIELD(file, layout, pool),
 249         { .name = NULL, 0 }     /* Required table terminator */
 250 };
 251 static size_t ceph_file_vxattrs_name_size;      /* total size of all names */
 252
 253 static struct ceph_vxattr *ceph_inode_vxattrs(struct inode *inode)
 254 {
 255         if (S_ISDIR(inode->i_mode))
 256                 return ceph_dir_vxattrs;
 257         else if (S_ISREG(inode->i_mode))
 258                 return ceph_file_vxattrs;
 259         return NULL;
 260 }
 261
 262 static size_t ceph_vxattrs_name_size(struct ceph_vxattr *vxattrs)
 263 {
 264         if (vxattrs == ceph_dir_vxattrs)
 265                 return ceph_dir_vxattrs_name_size;
 266         if (vxattrs == ceph_file_vxattrs)
 267                 return ceph_file_vxattrs_name_size;
 268         BUG();
 269
 270         return 0;
 271 }
 272
 273 /*
 274  * Compute the aggregate size (including terminating '\0') of all
 275  * virtual extended attribute names in the given vxattr table.
 276  */
 277 static size_t __init vxattrs_name_size(struct ceph_vxattr *vxattrs)
 278 {
 279         struct ceph_vxattr *vxattr;
 280         size_t size = 0;
 281
 282         for (vxattr = vxattrs; vxattr->name; vxattr++)
 283                 if (!vxattr->hidden)
 284                         size += vxattr->name_size;
 285
 286         return size;
 287 }
 288
 289 /* Routines called at initialization and exit time */
 290
 291 void __init ceph_xattr_init(void)
 292 {
 293         ceph_dir_vxattrs_name_size = vxattrs_name_size(ceph_dir_vxattrs);
 294         ceph_file_vxattrs_name_size = vxattrs_name_size(ceph_file_vxattrs);
 295 }
 296
 297 void ceph_xattr_exit(void)
 298 {
 299         ceph_dir_vxattrs_name_size = 0;
 300         ceph_file_vxattrs_name_size = 0;
 301 }
 302
 303 static struct ceph_vxattr *ceph_match_vxattr(struct inode *inode,
 304                                                 const char *name)
 305 {
 306         struct ceph_vxattr *vxattr = ceph_inode_vxattrs(inode);
 307
 308         if (vxattr) {
 309                 while (vxattr->name) {
 310                         if (!strcmp(vxattr->name, name))
 311                                 return vxattr;
 312                         vxattr++;
 313                 }
 314         }
 315
 316         return NULL;
 317 }
 318
 319 static int __set_xattr(struct ceph_inode_info *ci,
 320                            const char *name, int name_len,
 321                            const char *val, int val_len,
 322                            int flags, int update_xattr,
 323                            struct ceph_inode_xattr **newxattr)
 324 {
 325         struct rb_node **p;
 326         struct rb_node *parent = NULL;
 327         struct ceph_inode_xattr *xattr = NULL;
 328         int c;
 329         int new = 0;
 330
 331         p = &ci->i_xattrs.index.rb_node;
 332         while (*p) {
 333                 parent = *p;
 334                 xattr = rb_entry(parent, struct ceph_inode_xattr, node);
 335                 c = strncmp(name, xattr->name, min(name_len, xattr->name_len));
 336                 if (c < 0)
 337                         p = &(*p)->rb_left;
 338                 else if (c > 0)
 339                         p = &(*p)->rb_right;
 340                 else {
 341                         if (name_len == xattr->name_len)
 342                                 break;
 343                         else if (name_len < xattr->name_len)
 344                                 p = &(*p)->rb_left;
 345                         else
 346                                 p = &(*p)->rb_right;
 347                 }
 348                 xattr = NULL;
 349         }
 350
 351         if (update_xattr) {
 352                 int err = 0;
 353                 if (xattr && (flags & XATTR_CREATE))
 354                         err = -EEXIST;
 355                 else if (!xattr && (flags & XATTR_REPLACE))
 356                         err = -ENODATA;
 357                 if (err) {
 358                         kfree(name);
 359                         kfree(val);
 360                         return err;
 361                 }
 362         }
 363
 364         if (!xattr) {
 365                 new = 1;
 366                 xattr = *newxattr;
 367                 xattr->name = name;
 368                 xattr->name_len = name_len;
 369                 xattr->should_free_name = update_xattr;
 370
 371                 ci->i_xattrs.count++;
 372                 dout("__set_xattr count=%d\n", ci->i_xattrs.count);
 373         } else {
 374                 kfree(*newxattr);
 375                 *newxattr = NULL;
 376                 if (xattr->should_free_val)
 377                         kfree((void *)xattr->val);
 378
 379                 if (update_xattr) {
 380                         kfree((void *)name);
 381                         name = xattr->name;
 382                 }
 383                 ci->i_xattrs.names_size -= xattr->name_len;
 384                 ci->i_xattrs.vals_size -= xattr->val_len;
 385         }
 386         ci->i_xattrs.names_size += name_len;
 387         ci->i_xattrs.vals_size += val_len;
 388         if (val)
 389                 xattr->val = val;
 390         else
 391                 xattr->val = "";
 392
 393         xattr->val_len = val_len;
 394         xattr->dirty = update_xattr;
 395         xattr->should_free_val = (val && update_xattr);
 396
 397         if (new) {
 398                 rb_link_node(&xattr->node, parent, p);
 399                 rb_insert_color(&xattr->node, &ci->i_xattrs.index);
 400                 dout("__set_xattr_val p=%p\n", p);
 401         }
 402
 403         dout("__set_xattr_val added %llx.%llx xattr %p %s=%.*s\n",
 404              ceph_vinop(&ci->vfs_inode), xattr, name, val_len, val);
 405
 406         return 0;
 407 }
 408
 409 static struct ceph_inode_xattr *__get_xattr(struct ceph_inode_info *ci,
 410                            const char *name)
 411 {
 412         struct rb_node **p;
 413         struct rb_node *parent = NULL;
 414         struct ceph_inode_xattr *xattr = NULL;
 415         int name_len = strlen(name);
 416         int c;
 417
 418         p = &ci->i_xattrs.index.rb_node;
 419         while (*p) {
 420                 parent = *p;
 421                 xattr = rb_entry(parent, struct ceph_inode_xattr, node);
 422                 c = strncmp(name, xattr->name, xattr->name_len);
 423                 if (c == 0 && name_len > xattr->name_len)
 424                         c = 1;
 425                 if (c < 0)
 426                         p = &(*p)->rb_left;
 427                 else if (c > 0)
 428                         p = &(*p)->rb_right;
 429                 else {
 430                         dout("__get_xattr %s: found %.*s\n", name,
 431                              xattr->val_len, xattr->val);
 432                         return xattr;
 433                 }
 434         }
 435
 436         dout("__get_xattr %s: not found\n", name);
 437
 438         return NULL;
 439 }
 440
 441 static void __free_xattr(struct ceph_inode_xattr *xattr)
 442 {
 443         BUG_ON(!xattr);
 444
 445         if (xattr->should_free_name)
 446                 kfree((void *)xattr->name);
 447         if (xattr->should_free_val)
 448                 kfree((void *)xattr->val);
 449
 450         kfree(xattr);
 451 }
 452
 453 static int __remove_xattr(struct ceph_inode_info *ci,
 454                           struct ceph_inode_xattr *xattr)
 455 {
 456         if (!xattr)
 457                 return -EOPNOTSUPP;
 458
 459         rb_erase(&xattr->node, &ci->i_xattrs.index);
 460
 461         if (xattr->should_free_name)
 462                 kfree((void *)xattr->name);
 463         if (xattr->should_free_val)
 464                 kfree((void *)xattr->val);
 465
 466         ci->i_xattrs.names_size -= xattr->name_len;
 467         ci->i_xattrs.vals_size -= xattr->val_len;
 468         ci->i_xattrs.count--;
 469         kfree(xattr);
 470
 471         return 0;
 472 }
 473
 474 static int __remove_xattr_by_name(struct ceph_inode_info *ci,
 475                            const char *name)
 476 {
 477         struct rb_node **p;
 478         struct ceph_inode_xattr *xattr;
 479         int err;
 480
 481         p = &ci->i_xattrs.index.rb_node;
 482         xattr = __get_xattr(ci, name);
 483         err = __remove_xattr(ci, xattr);
 484         return err;
 485 }
 486
 487 static char *__copy_xattr_names(struct ceph_inode_info *ci,
 488                                 char *dest)
 489 {
 490         struct rb_node *p;
 491         struct ceph_inode_xattr *xattr = NULL;
 492
 493         p = rb_first(&ci->i_xattrs.index);
 494         dout("__copy_xattr_names count=%d\n", ci->i_xattrs.count);
 495
 496         while (p) {
 497                 xattr = rb_entry(p, struct ceph_inode_xattr, node);
 498                 memcpy(dest, xattr->name, xattr->name_len);
 499                 dest[xattr->name_len] = '\0';
 500
 501                 dout("dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name,
 502                      xattr->name_len, ci->i_xattrs.names_size);
 503
 504                 dest += xattr->name_len + 1;
 505                 p = rb_next(p);
 506         }
 507
 508         return dest;
 509 }
 510
 511 void __ceph_destroy_xattrs(struct ceph_inode_info *ci)
 512 {
 513         struct rb_node *p, *tmp;
 514         struct ceph_inode_xattr *xattr = NULL;
 515
 516         p = rb_first(&ci->i_xattrs.index);
 517
 518         dout("__ceph_destroy_xattrs p=%p\n", p);
 519
 520         while (p) {
 521                 xattr = rb_entry(p, struct ceph_inode_xattr, node);
 522                 tmp = p;
 523                 p = rb_next(tmp);
 524                 dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p,
 525                      xattr->name_len, xattr->name);
 526                 rb_erase(tmp, &ci->i_xattrs.index);
 527
 528                 __free_xattr(xattr);
 529         }
 530
 531         ci->i_xattrs.names_size = 0;
 532         ci->i_xattrs.vals_size = 0;
 533         ci->i_xattrs.index_version = 0;
 534         ci->i_xattrs.count = 0;
 535         ci->i_xattrs.index = RB_ROOT;
 536 }
 537
 538 static int __build_xattrs(struct inode *inode)
 539         __releases(ci->i_ceph_lock)
 540         __acquires(ci->i_ceph_lock)
 541 {
 542         u32 namelen;
 543         u32 numattr = 0;
 544         void *p, *end;
 545         u32 len;
 546         const char *name, *val;
 547         struct ceph_inode_info *ci = ceph_inode(inode);
 548         int xattr_version;
 549         struct ceph_inode_xattr **xattrs = NULL;
 550         int err = 0;
 551         int i;
 552
 553         dout("__build_xattrs() len=%d\n",
 554              ci->i_xattrs.blob ? (int)ci->i_xattrs.blob->vec.iov_len : 0);
 555
 556         if (ci->i_xattrs.index_version >= ci->i_xattrs.version)
 557                 return 0; /* already built */
 558
 559         __ceph_destroy_xattrs(ci);
 560
 561 start:
 562         /* updated internal xattr rb tree */
 563         if (ci->i_xattrs.blob && ci->i_xattrs.blob->vec.iov_len > 4) {
 564                 p = ci->i_xattrs.blob->vec.iov_base;
 565                 end = p + ci->i_xattrs.blob->vec.iov_len;
 566                 ceph_decode_32_safe(&p, end, numattr, bad);
 567                 xattr_version = ci->i_xattrs.version;
 568                 spin_unlock(&ci->i_ceph_lock);
 569
 570                 xattrs = kcalloc(numattr, sizeof(struct ceph_xattr *),
 571                                  GFP_NOFS);
 572                 err = -ENOMEM;
 573                 if (!xattrs)
 574                         goto bad_lock;
 575                 memset(xattrs, 0, numattr*sizeof(struct ceph_xattr *));
 576                 for (i = 0; i < numattr; i++) {
 577                         xattrs[i] = kmalloc(sizeof(struct ceph_inode_xattr),
 578                                             GFP_NOFS);
 579                         if (!xattrs[i])
 580                                 goto bad_lock;
 581                 }
 582
 583                 spin_lock(&ci->i_ceph_lock);
 584                 if (ci->i_xattrs.version != xattr_version) {
 585                         /* lost a race, retry */
 586                         for (i = 0; i < numattr; i++)
 587                                 kfree(xattrs[i]);
 588                         kfree(xattrs);
 589                         xattrs = NULL;
 590                         goto start;
 591                 }
 592                 err = -EIO;
 593                 while (numattr--) {
 594                         ceph_decode_32_safe(&p, end, len, bad);
 595                         namelen = len;
 596                         name = p;
 597                         p += len;
 598                         ceph_decode_32_safe(&p, end, len, bad);
 599                         val = p;
 600                         p += len;
 601
 602                         err = __set_xattr(ci, name, namelen, val, len,
 603                                           0, 0, &xattrs[numattr]);
 604
 605                         if (err < 0)
 606                                 goto bad;
 607                 }
 608                 kfree(xattrs);
 609         }
 610         ci->i_xattrs.index_version = ci->i_xattrs.version;
 611         ci->i_xattrs.dirty = false;
 612
 613         return err;
 614 bad_lock:
 615         spin_lock(&ci->i_ceph_lock);
 616 bad:
 617         if (xattrs) {
 618                 for (i = 0; i < numattr; i++)
 619                         kfree(xattrs[i]);
 620                 kfree(xattrs);
 621         }
 622         ci->i_xattrs.names_size = 0;
 623         return err;
 624 }
 625
 626 static int __get_required_blob_size(struct ceph_inode_info *ci, int name_size,
 627                                     int val_size)
 628 {
 629         /*
 630          * 4 bytes for the length, and additional 4 bytes per each xattr name,
 631          * 4 bytes per each value
 632          */
 633         int size = 4 + ci->i_xattrs.count*(4 + 4) +
 634                              ci->i_xattrs.names_size +
 635                              ci->i_xattrs.vals_size;
 636         dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n",
 637              ci->i_xattrs.count, ci->i_xattrs.names_size,
 638              ci->i_xattrs.vals_size);
 639
 640         if (name_size)
 641                 size += 4 + 4 + name_size + val_size;
 642
 643         return size;
 644 }
 645
 646 /*
 647  * If there are dirty xattrs, reencode xattrs into the prealloc_blob
 648  * and swap into place.
 649  */
 650 void __ceph_build_xattrs_blob(struct ceph_inode_info *ci)
 651 {
 652         struct rb_node *p;
 653         struct ceph_inode_xattr *xattr = NULL;
 654         void *dest;
 655
 656         dout("__build_xattrs_blob %p\n", &ci->vfs_inode);
 657         if (ci->i_xattrs.dirty) {
 658                 int need = __get_required_blob_size(ci, 0, 0);
 659
 660                 BUG_ON(need > ci->i_xattrs.prealloc_blob->alloc_len);
 661
 662                 p = rb_first(&ci->i_xattrs.index);
 663                 dest = ci->i_xattrs.prealloc_blob->vec.iov_base;
 664
 665                 ceph_encode_32(&dest, ci->i_xattrs.count);
 666                 while (p) {
 667                         xattr = rb_entry(p, struct ceph_inode_xattr, node);
 668
 669                         ceph_encode_32(&dest, xattr->name_len);
 670                         memcpy(dest, xattr->name, xattr->name_len);
 671                         dest += xattr->name_len;
 672                         ceph_encode_32(&dest, xattr->val_len);
 673                         memcpy(dest, xattr->val, xattr->val_len);
 674                         dest += xattr->val_len;
 675
 676                         p = rb_next(p);
 677                 }
 678
 679                 /* adjust buffer len; it may be larger than we need */
 680                 ci->i_xattrs.prealloc_blob->vec.iov_len =
 681                         dest - ci->i_xattrs.prealloc_blob->vec.iov_base;
 682
 683                 if (ci->i_xattrs.blob)
 684                         ceph_buffer_put(ci->i_xattrs.blob);
 685                 ci->i_xattrs.blob = ci->i_xattrs.prealloc_blob;
 686                 ci->i_xattrs.prealloc_blob = NULL;
 687                 ci->i_xattrs.dirty = false;
 688                 ci->i_xattrs.version++;
 689         }
 690 }
 691
 692 ssize_t __ceph_getxattr(struct inode *inode, const char *name, void *value,
 693                       size_t size)
 694 {
 695         struct ceph_inode_info *ci = ceph_inode(inode);
 696         int err;
 697         struct ceph_inode_xattr *xattr;
 698         struct ceph_vxattr *vxattr = NULL;
 699
 700         if (!ceph_is_valid_xattr(name))
 701                 return -ENODATA;
 702
 703         /* let's see if a virtual xattr was requested */
 704         vxattr = ceph_match_vxattr(inode, name);
 705         if (vxattr && !(vxattr->exists_cb && !vxattr->exists_cb(ci))) {
 706                 err = vxattr->getxattr_cb(ci, value, size);
 707                 return err;
 708         }
 709
 710         spin_lock(&ci->i_ceph_lock);
 711         dout("getxattr %p ver=%lld index_ver=%lld\n", inode,
 712              ci->i_xattrs.version, ci->i_xattrs.index_version);
 713
 714         if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) &&
 715             (ci->i_xattrs.index_version >= ci->i_xattrs.version)) {
 716                 goto get_xattr;
 717         } else {
 718                 spin_unlock(&ci->i_ceph_lock);
 719                 /* get xattrs from mds (if we don't already have them) */
 720                 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR);
 721                 if (err)
 722                         return err;
 723         }
 724
 725         spin_lock(&ci->i_ceph_lock);
 726
 727         err = __build_xattrs(inode);
 728         if (err < 0)
 729                 goto out;
 730
 731 get_xattr:
 732         err = -ENODATA;  /* == ENOATTR */
 733         xattr = __get_xattr(ci, name);
 734         if (!xattr)
 735                 goto out;
 736
 737         err = -ERANGE;
 738         if (size && size < xattr->val_len)
 739                 goto out;
 740
 741         err = xattr->val_len;
 742         if (size == 0)
 743                 goto out;
 744
 745         memcpy(value, xattr->val, xattr->val_len);
 746
 747 out:
 748         spin_unlock(&ci->i_ceph_lock);
 749         return err;
 750 }
 751
 752 ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
 753                       size_t size)
 754 {
 755         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
 756                 return generic_getxattr(dentry, name, value, size);
 757
 758         return __ceph_getxattr(dentry->d_inode, name, value, size);
 759 }
 760
 761 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
 762 {
 763         struct inode *inode = dentry->d_inode;
 764         struct ceph_inode_info *ci = ceph_inode(inode);
 765         struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode);
 766         u32 vir_namelen = 0;
 767         u32 namelen;
 768         int err;
 769         u32 len;
 770         int i;
 771
 772         spin_lock(&ci->i_ceph_lock);
 773         dout("listxattr %p ver=%lld index_ver=%lld\n", inode,
 774              ci->i_xattrs.version, ci->i_xattrs.index_version);
 775
 776         if (__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1) &&
 777             (ci->i_xattrs.index_version >= ci->i_xattrs.version)) {
 778                 goto list_xattr;
 779         } else {
 780                 spin_unlock(&ci->i_ceph_lock);
 781                 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR);
 782                 if (err)
 783                         return err;
 784         }
 785
 786         spin_lock(&ci->i_ceph_lock);
 787
 788         err = __build_xattrs(inode);
 789         if (err < 0)
 790                 goto out;
 791
 792 list_xattr:
 793         /*
 794          * Start with virtual dir xattr names (if any) (including
 795          * terminating '\0' characters for each).
 796          */
 797         vir_namelen = ceph_vxattrs_name_size(vxattrs);
 798
 799         /* adding 1 byte per each variable due to the null termination */
 800         namelen = ci->i_xattrs.names_size + ci->i_xattrs.count;
 801         err = -ERANGE;
 802         if (size && vir_namelen + namelen > size)
 803                 goto out;
 804
 805         err = namelen + vir_namelen;
 806         if (size == 0)
 807                 goto out;
 808
 809         names = __copy_xattr_names(ci, names);
 810
 811         /* virtual xattr names, too */
 812         err = namelen;
 813         if (vxattrs) {
 814                 for (i = 0; vxattrs[i].name; i++) {
 815                         if (!vxattrs[i].hidden &&
 816                             !(vxattrs[i].exists_cb &&
 817                               !vxattrs[i].exists_cb(ci))) {
 818                                 len = sprintf(names, "%s", vxattrs[i].name);
 819                                 names += len + 1;
 820                                 err += len + 1;
 821                         }
 822                 }
 823         }
 824
 825 out:
 826         spin_unlock(&ci->i_ceph_lock);
 827         return err;
 828 }
 829
 830 static int ceph_sync_setxattr(struct dentry *dentry, const char *name,
 831                               const char *value, size_t size, int flags)
 832 {
 833         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
 834         struct inode *inode = dentry->d_inode;
 835         struct ceph_inode_info *ci = ceph_inode(inode);
 836         struct inode *parent_inode;
 837         struct ceph_mds_request *req;
 838         struct ceph_mds_client *mdsc = fsc->mdsc;
 839         int err;
 840         int i, nr_pages;
 841         struct page **pages = NULL;
 842         void *kaddr;
 843
 844         /* copy value into some pages */
 845         nr_pages = calc_pages_for(0, size);
 846         if (nr_pages) {
 847                 pages = kmalloc(sizeof(pages[0])*nr_pages, GFP_NOFS);
 848                 if (!pages)
 849                         return -ENOMEM;
 850                 err = -ENOMEM;
 851                 for (i = 0; i < nr_pages; i++) {
 852                         pages[i] = __page_cache_alloc(GFP_NOFS);
 853                         if (!pages[i]) {
 854                                 nr_pages = i;
 855                                 goto out;
 856                         }
 857                         kaddr = kmap(pages[i]);
 858                         memcpy(kaddr, value + i*PAGE_CACHE_SIZE,
 859                                min(PAGE_CACHE_SIZE, size-i*PAGE_CACHE_SIZE));
 860                 }
 861         }
 862
 863         dout("setxattr value=%.*s\n", (int)size, value);
 864
 865         /* do request */
 866         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETXATTR,
 867                                        USE_AUTH_MDS);
 868         if (IS_ERR(req)) {
 869                 err = PTR_ERR(req);
 870                 goto out;
 871         }
 872         req->r_inode = inode;
 873         ihold(inode);
 874         req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
 875         req->r_num_caps = 1;
 876         req->r_args.setxattr.flags = cpu_to_le32(flags);
 877         req->r_path2 = kstrdup(name, GFP_NOFS);
 878
 879         req->r_pages = pages;
 880         req->r_num_pages = nr_pages;
 881         req->r_data_len = size;
 882
 883         dout("xattr.ver (before): %lld\n", ci->i_xattrs.version);
 884         parent_inode = ceph_get_dentry_parent_inode(dentry);
 885         err = ceph_mdsc_do_request(mdsc, parent_inode, req);
 886         iput(parent_inode);
 887         ceph_mdsc_put_request(req);
 888         dout("xattr.ver (after): %lld\n", ci->i_xattrs.version);
 889
 890 out:
 891         if (pages) {
 892                 for (i = 0; i < nr_pages; i++)
 893                         __free_page(pages[i]);
 894                 kfree(pages);
 895         }
 896         return err;
 897 }
 898
 899 int __ceph_setxattr(struct dentry *dentry, const char *name,
 900                         const void *value, size_t size, int flags)
 901 {
 902         struct inode *inode = dentry->d_inode;
 903         struct ceph_vxattr *vxattr;
 904         struct ceph_inode_info *ci = ceph_inode(inode);
 905         int issued;
 906         int err;
 907         int dirty = 0;
 908         int name_len = strlen(name);
 909         int val_len = size;
 910         char *newname = NULL;
 911         char *newval = NULL;
 912         struct ceph_inode_xattr *xattr = NULL;
 913         int required_blob_size;
 914
 915         if (!ceph_is_valid_xattr(name))
 916                 return -EOPNOTSUPP;
 917
 918         vxattr = ceph_match_vxattr(inode, name);
 919         if (vxattr && vxattr->readonly)
 920                 return -EOPNOTSUPP;
 921
 922         /* pass any unhandled ceph.* xattrs through to the MDS */
 923         if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN))
 924                 goto do_sync_unlocked;
 925
 926         /* preallocate memory for xattr name, value, index node */
 927         err = -ENOMEM;
 928         newname = kmemdup(name, name_len + 1, GFP_NOFS);
 929         if (!newname)
 930                 goto out;
 931
 932         if (val_len) {
 933                 newval = kmemdup(value, val_len, GFP_NOFS);
 934                 if (!newval)
 935                         goto out;
 936         }
 937
 938         xattr = kmalloc(sizeof(struct ceph_inode_xattr), GFP_NOFS);
 939         if (!xattr)
 940                 goto out;
 941
 942         spin_lock(&ci->i_ceph_lock);
 943 retry:
 944         issued = __ceph_caps_issued(ci, NULL);
 945         dout("setxattr %p issued %s\n", inode, ceph_cap_string(issued));
 946         if (!(issued & CEPH_CAP_XATTR_EXCL))
 947                 goto do_sync;
 948         __build_xattrs(inode);
 949
 950         required_blob_size = __get_required_blob_size(ci, name_len, val_len);
 951
 952         if (!ci->i_xattrs.prealloc_blob ||
 953             required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) {
 954                 struct ceph_buffer *blob;
 955
 956                 spin_unlock(&ci->i_ceph_lock);
 957                 dout(" preaallocating new blob size=%d\n", required_blob_size);
 958                 blob = ceph_buffer_new(required_blob_size, GFP_NOFS);
 959                 if (!blob)
 960                         goto out;
 961                 spin_lock(&ci->i_ceph_lock);
 962                 if (ci->i_xattrs.prealloc_blob)
 963                         ceph_buffer_put(ci->i_xattrs.prealloc_blob);
 964                 ci->i_xattrs.prealloc_blob = blob;
 965                 goto retry;
 966         }
 967
 968         err = __set_xattr(ci, newname, name_len, newval,
 969                           val_len, flags, 1, &xattr);
 970
 971         if (!err) {
 972                 dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL);
 973                 ci->i_xattrs.dirty = true;
 974                 inode->i_ctime = CURRENT_TIME;
 975         }
 976
 977         spin_unlock(&ci->i_ceph_lock);
 978         if (dirty)
 979                 __mark_inode_dirty(inode, dirty);
 980         return err;
 981
 982 do_sync:
 983         spin_unlock(&ci->i_ceph_lock);
 984 do_sync_unlocked:
 985         err = ceph_sync_setxattr(dentry, name, value, size, flags);
 986 out:
 987         kfree(newname);
 988         kfree(newval);
 989         kfree(xattr);
 990         return err;
 991 }
 992
 993 int ceph_setxattr(struct dentry *dentry, const char *name,
 994                   const void *value, size_t size, int flags)
 995 {
 996         if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
 997                 return -EROFS;
 998
 999         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
1000                 return generic_setxattr(dentry, name, value, size, flags);
1001
1002         return __ceph_setxattr(dentry, name, value, size, flags);
1003 }
1004
1005 static int ceph_send_removexattr(struct dentry *dentry, const char *name)
1006 {
1007         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
1008         struct ceph_mds_client *mdsc = fsc->mdsc;
1009         struct inode *inode = dentry->d_inode;
1010         struct inode *parent_inode;
1011         struct ceph_mds_request *req;
1012         int err;
1013
1014         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RMXATTR,
1015                                        USE_AUTH_MDS);
1016         if (IS_ERR(req))
1017                 return PTR_ERR(req);
1018         req->r_inode = inode;
1019         ihold(inode);
1020         req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
1021         req->r_num_caps = 1;
1022         req->r_path2 = kstrdup(name, GFP_NOFS);
1023
1024         parent_inode = ceph_get_dentry_parent_inode(dentry);
1025         err = ceph_mdsc_do_request(mdsc, parent_inode, req);
1026         iput(parent_inode);
1027         ceph_mdsc_put_request(req);
1028         return err;
1029 }
1030
1031 int __ceph_removexattr(struct dentry *dentry, const char *name)
1032 {
1033         struct inode *inode = dentry->d_inode;
1034         struct ceph_vxattr *vxattr;
1035         struct ceph_inode_info *ci = ceph_inode(inode);
1036         int issued;
1037         int err;
1038         int required_blob_size;
1039         int dirty;
1040
1041         if (!ceph_is_valid_xattr(name))
1042                 return -EOPNOTSUPP;
1043
1044         vxattr = ceph_match_vxattr(inode, name);
1045         if (vxattr && vxattr->readonly)
1046                 return -EOPNOTSUPP;
1047
1048         /* pass any unhandled ceph.* xattrs through to the MDS */
1049         if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN))
1050                 goto do_sync_unlocked;
1051
1052         err = -ENOMEM;
1053         spin_lock(&ci->i_ceph_lock);
1054 retry:
1055         issued = __ceph_caps_issued(ci, NULL);
1056         dout("removexattr %p issued %s\n", inode, ceph_cap_string(issued));
1057
1058         if (!(issued & CEPH_CAP_XATTR_EXCL))
1059                 goto do_sync;
1060         __build_xattrs(inode);
1061
1062         required_blob_size = __get_required_blob_size(ci, 0, 0);
1063
1064         if (!ci->i_xattrs.prealloc_blob ||
1065             required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) {
1066                 struct ceph_buffer *blob;
1067
1068                 spin_unlock(&ci->i_ceph_lock);
1069                 dout(" preaallocating new blob size=%d\n", required_blob_size);
1070                 blob = ceph_buffer_new(required_blob_size, GFP_NOFS);
1071                 if (!blob)
1072                         goto out;
1073                 spin_lock(&ci->i_ceph_lock);
1074                 if (ci->i_xattrs.prealloc_blob)
1075                         ceph_buffer_put(ci->i_xattrs.prealloc_blob);
1076                 ci->i_xattrs.prealloc_blob = blob;
1077                 goto retry;
1078         }
1079
1080         err = __remove_xattr_by_name(ceph_inode(inode), name);
1081
1082         dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL);
1083         ci->i_xattrs.dirty = true;
1084         inode->i_ctime = CURRENT_TIME;
1085         spin_unlock(&ci->i_ceph_lock);
1086         if (dirty)
1087                 __mark_inode_dirty(inode, dirty);
1088         return err;
1089 do_sync:
1090         spin_unlock(&ci->i_ceph_lock);
1091 do_sync_unlocked:
1092         err = ceph_send_removexattr(dentry, name);
1093 out:
1094         return err;
1095 }
1096
1097 int ceph_removexattr(struct dentry *dentry, const char *name)
1098 {
1099         if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
1100                 return -EROFS;
1101
1102         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
1103                 return generic_removexattr(dentry, name);
1104
1105         return __ceph_removexattr(dentry, name);
1106 }