fs/ceph/xattr.c

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