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         ssize_t 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         ret = total_len;
 102         if (size >= total_len) {
 103                 memcpy(val, buf, len);
 104                 ret = len;
 105                 if (pool_name) {
 106                         len = strlen(pool_name);
 107                         memcpy(val + ret, pool_name, len);
 108                         ret += len;
 109                 }
 110                 if (pool_ns) {
 111                         len = strlen(ns_field);
 112                         memcpy(val + ret, ns_field, len);
 113                         ret += len;
 114                         memcpy(val + ret, pool_ns->str, pool_ns->len);
 115                         ret += pool_ns->len;
 116                 }
 117         }
 118         up_read(&osdc->lock);
 119         ceph_put_string(pool_ns);
 120         return ret;
 121 }
 122
 123 static size_t ceph_vxattrcb_layout_stripe_unit(struct ceph_inode_info *ci,
 124                                                char *val, size_t size)
 125 {
 126         return snprintf(val, size, "%u", ci->i_layout.stripe_unit);
 127 }
 128
 129 static size_t ceph_vxattrcb_layout_stripe_count(struct ceph_inode_info *ci,
 130                                                 char *val, size_t size)
 131 {
 132         return snprintf(val, size, "%u", ci->i_layout.stripe_count);
 133 }
 134
 135 static size_t ceph_vxattrcb_layout_object_size(struct ceph_inode_info *ci,
 136                                                char *val, size_t size)
 137 {
 138         return snprintf(val, size, "%u", ci->i_layout.object_size);
 139 }
 140
 141 static size_t ceph_vxattrcb_layout_pool(struct ceph_inode_info *ci,
 142                                         char *val, size_t size)
 143 {
 144         int ret;
 145         struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb);
 146         struct ceph_osd_client *osdc = &fsc->client->osdc;
 147         s64 pool = ci->i_layout.pool_id;
 148         const char *pool_name;
 149
 150         down_read(&osdc->lock);
 151         pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, pool);
 152         if (pool_name)
 153                 ret = snprintf(val, size, "%s", pool_name);
 154         else
 155                 ret = snprintf(val, size, "%lld", (unsigned long long)pool);
 156         up_read(&osdc->lock);
 157         return ret;
 158 }
 159
 160 static size_t ceph_vxattrcb_layout_pool_namespace(struct ceph_inode_info *ci,
 161                                                   char *val, size_t size)
 162 {
 163         int ret = 0;
 164         struct ceph_string *ns = ceph_try_get_string(ci->i_layout.pool_ns);
 165         if (ns) {
 166                 ret = snprintf(val, size, "%.*s", (int)ns->len, ns->str);
 167                 ceph_put_string(ns);
 168         }
 169         return ret;
 170 }
 171
 172 /* directories */
 173
 174 static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info *ci, char *val,
 175                                         size_t size)
 176 {
 177         return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs);
 178 }
 179
 180 static size_t ceph_vxattrcb_dir_files(struct ceph_inode_info *ci, char *val,
 181                                       size_t size)
 182 {
 183         return snprintf(val, size, "%lld", ci->i_files);
 184 }
 185
 186 static size_t ceph_vxattrcb_dir_subdirs(struct ceph_inode_info *ci, char *val,
 187                                         size_t size)
 188 {
 189         return snprintf(val, size, "%lld", ci->i_subdirs);
 190 }
 191
 192 static size_t ceph_vxattrcb_dir_rentries(struct ceph_inode_info *ci, char *val,
 193                                          size_t size)
 194 {
 195         return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs);
 196 }
 197
 198 static size_t ceph_vxattrcb_dir_rfiles(struct ceph_inode_info *ci, char *val,
 199                                        size_t size)
 200 {
 201         return snprintf(val, size, "%lld", ci->i_rfiles);
 202 }
 203
 204 static size_t ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info *ci, char *val,
 205                                          size_t size)
 206 {
 207         return snprintf(val, size, "%lld", ci->i_rsubdirs);
 208 }
 209
 210 static size_t ceph_vxattrcb_dir_rbytes(struct ceph_inode_info *ci, char *val,
 211                                        size_t size)
 212 {
 213         return snprintf(val, size, "%lld", ci->i_rbytes);
 214 }
 215
 216 static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info *ci, char *val,
 217                                        size_t size)
 218 {
 219         return snprintf(val, size, "%ld.09%ld", (long)ci->i_rctime.tv_sec,
 220                         (long)ci->i_rctime.tv_nsec);
 221 }
 222
 223
 224 #define CEPH_XATTR_NAME(_type, _name)   XATTR_CEPH_PREFIX #_type "." #_name
 225 #define CEPH_XATTR_NAME2(_type, _name, _name2)  \
 226         XATTR_CEPH_PREFIX #_type "." #_name "." #_name2
 227
 228 #define XATTR_NAME_CEPH(_type, _name)                                   \
 229         {                                                               \
 230                 .name = CEPH_XATTR_NAME(_type, _name),                  \
 231                 .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \
 232                 .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
 233                 .readonly = true,                               \
 234                 .hidden = false,                                \
 235                 .exists_cb = NULL,                      \
 236         }
 237 #define XATTR_LAYOUT_FIELD(_type, _name, _field)                        \
 238         {                                                               \
 239                 .name = CEPH_XATTR_NAME2(_type, _name, _field), \
 240                 .name_size = sizeof (CEPH_XATTR_NAME2(_type, _name, _field)), \
 241                 .getxattr_cb = ceph_vxattrcb_ ## _name ## _ ## _field, \
 242                 .readonly = false,                              \
 243                 .hidden = true,                 \
 244                 .exists_cb = ceph_vxattrcb_layout_exists,       \
 245         }
 246
 247 static struct ceph_vxattr ceph_dir_vxattrs[] = {
 248         {
 249                 .name = "ceph.dir.layout",
 250                 .name_size = sizeof("ceph.dir.layout"),
 251                 .getxattr_cb = ceph_vxattrcb_layout,
 252                 .readonly = false,
 253                 .hidden = true,
 254                 .exists_cb = ceph_vxattrcb_layout_exists,
 255         },
 256         XATTR_LAYOUT_FIELD(dir, layout, stripe_unit),
 257         XATTR_LAYOUT_FIELD(dir, layout, stripe_count),
 258         XATTR_LAYOUT_FIELD(dir, layout, object_size),
 259         XATTR_LAYOUT_FIELD(dir, layout, pool),
 260         XATTR_LAYOUT_FIELD(dir, layout, pool_namespace),
 261         XATTR_NAME_CEPH(dir, entries),
 262         XATTR_NAME_CEPH(dir, files),
 263         XATTR_NAME_CEPH(dir, subdirs),
 264         XATTR_NAME_CEPH(dir, rentries),
 265         XATTR_NAME_CEPH(dir, rfiles),
 266         XATTR_NAME_CEPH(dir, rsubdirs),
 267         XATTR_NAME_CEPH(dir, rbytes),
 268         XATTR_NAME_CEPH(dir, rctime),
 269         { .name = NULL, 0 }     /* Required table terminator */
 270 };
 271 static size_t ceph_dir_vxattrs_name_size;       /* total size of all names */
 272
 273 /* files */
 274
 275 static struct ceph_vxattr ceph_file_vxattrs[] = {
 276         {
 277                 .name = "ceph.file.layout",
 278                 .name_size = sizeof("ceph.file.layout"),
 279                 .getxattr_cb = ceph_vxattrcb_layout,
 280                 .readonly = false,
 281                 .hidden = true,
 282                 .exists_cb = ceph_vxattrcb_layout_exists,
 283         },
 284         XATTR_LAYOUT_FIELD(file, layout, stripe_unit),
 285         XATTR_LAYOUT_FIELD(file, layout, stripe_count),
 286         XATTR_LAYOUT_FIELD(file, layout, object_size),
 287         XATTR_LAYOUT_FIELD(file, layout, pool),
 288         XATTR_LAYOUT_FIELD(file, layout, pool_namespace),
 289         { .name = NULL, 0 }     /* Required table terminator */
 290 };
 291 static size_t ceph_file_vxattrs_name_size;      /* total size of all names */
 292
 293 static struct ceph_vxattr *ceph_inode_vxattrs(struct inode *inode)
 294 {
 295         if (S_ISDIR(inode->i_mode))
 296                 return ceph_dir_vxattrs;
 297         else if (S_ISREG(inode->i_mode))
 298                 return ceph_file_vxattrs;
 299         return NULL;
 300 }
 301
 302 static size_t ceph_vxattrs_name_size(struct ceph_vxattr *vxattrs)
 303 {
 304         if (vxattrs == ceph_dir_vxattrs)
 305                 return ceph_dir_vxattrs_name_size;
 306         if (vxattrs == ceph_file_vxattrs)
 307                 return ceph_file_vxattrs_name_size;
 308         BUG_ON(vxattrs);
 309         return 0;
 310 }
 311
 312 /*
 313  * Compute the aggregate size (including terminating '\0') of all
 314  * virtual extended attribute names in the given vxattr table.
 315  */
 316 static size_t __init vxattrs_name_size(struct ceph_vxattr *vxattrs)
 317 {
 318         struct ceph_vxattr *vxattr;
 319         size_t size = 0;
 320
 321         for (vxattr = vxattrs; vxattr->name; vxattr++)
 322                 if (!vxattr->hidden)
 323                         size += vxattr->name_size;
 324
 325         return size;
 326 }
 327
 328 /* Routines called at initialization and exit time */
 329
 330 void __init ceph_xattr_init(void)
 331 {
 332         ceph_dir_vxattrs_name_size = vxattrs_name_size(ceph_dir_vxattrs);
 333         ceph_file_vxattrs_name_size = vxattrs_name_size(ceph_file_vxattrs);
 334 }
 335
 336 void ceph_xattr_exit(void)
 337 {
 338         ceph_dir_vxattrs_name_size = 0;
 339         ceph_file_vxattrs_name_size = 0;
 340 }
 341
 342 static struct ceph_vxattr *ceph_match_vxattr(struct inode *inode,
 343                                                 const char *name)
 344 {
 345         struct ceph_vxattr *vxattr = ceph_inode_vxattrs(inode);
 346
 347         if (vxattr) {
 348                 while (vxattr->name) {
 349                         if (!strcmp(vxattr->name, name))
 350                                 return vxattr;
 351                         vxattr++;
 352                 }
 353         }
 354
 355         return NULL;
 356 }
 357
 358 static int __set_xattr(struct ceph_inode_info *ci,
 359                            const char *name, int name_len,
 360                            const char *val, int val_len,
 361                            int flags, int update_xattr,
 362                            struct ceph_inode_xattr **newxattr)
 363 {
 364         struct rb_node **p;
 365         struct rb_node *parent = NULL;
 366         struct ceph_inode_xattr *xattr = NULL;
 367         int c;
 368         int new = 0;
 369
 370         p = &ci->i_xattrs.index.rb_node;
 371         while (*p) {
 372                 parent = *p;
 373                 xattr = rb_entry(parent, struct ceph_inode_xattr, node);
 374                 c = strncmp(name, xattr->name, min(name_len, xattr->name_len));
 375                 if (c < 0)
 376                         p = &(*p)->rb_left;
 377                 else if (c > 0)
 378                         p = &(*p)->rb_right;
 379                 else {
 380                         if (name_len == xattr->name_len)
 381                                 break;
 382                         else if (name_len < xattr->name_len)
 383                                 p = &(*p)->rb_left;
 384                         else
 385                                 p = &(*p)->rb_right;
 386                 }
 387                 xattr = NULL;
 388         }
 389
 390         if (update_xattr) {
 391                 int err = 0;
 392
 393                 if (xattr && (flags & XATTR_CREATE))
 394                         err = -EEXIST;
 395                 else if (!xattr && (flags & XATTR_REPLACE))
 396                         err = -ENODATA;
 397                 if (err) {
 398                         kfree(name);
 399                         kfree(val);
 400                         kfree(*newxattr);
 401                         return err;
 402                 }
 403                 if (update_xattr < 0) {
 404                         if (xattr)
 405                                 __remove_xattr(ci, xattr);
 406                         kfree(name);
 407                         kfree(*newxattr);
 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                         if (size && size < err)
 760                                 err = -ERANGE;
 761                 }
 762                 return err;
 763         }
 764
 765         req_mask = __get_request_mask(inode);
 766
 767         spin_lock(&ci->i_ceph_lock);
 768         dout("getxattr %p ver=%lld index_ver=%lld\n", inode,
 769              ci->i_xattrs.version, ci->i_xattrs.index_version);
 770
 771         if (ci->i_xattrs.version == 0 ||
 772             !((req_mask & CEPH_CAP_XATTR_SHARED) ||
 773               __ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1))) {
 774                 spin_unlock(&ci->i_ceph_lock);
 775
 776                 /* security module gets xattr while filling trace */
 777                 if (current->journal_info != NULL) {
 778                         pr_warn_ratelimited("sync getxattr %p "
 779                                             "during filling trace\n", inode);
 780                         return -EBUSY;
 781                 }
 782
 783                 /* get xattrs from mds (if we don't already have them) */
 784                 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR, true);
 785                 if (err)
 786                         return err;
 787                 spin_lock(&ci->i_ceph_lock);
 788         }
 789
 790         err = __build_xattrs(inode);
 791         if (err < 0)
 792                 goto out;
 793
 794         err = -ENODATA;  /* == ENOATTR */
 795         xattr = __get_xattr(ci, name);
 796         if (!xattr)
 797                 goto out;
 798
 799         err = -ERANGE;
 800         if (size && size < xattr->val_len)
 801                 goto out;
 802
 803         err = xattr->val_len;
 804         if (size == 0)
 805                 goto out;
 806
 807         memcpy(value, xattr->val, xattr->val_len);
 808
 809         if (current->journal_info != NULL &&
 810             !strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN))
 811                 ci->i_ceph_flags |= CEPH_I_SEC_INITED;
 812 out:
 813         spin_unlock(&ci->i_ceph_lock);
 814         return err;
 815 }
 816
 817 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
 818 {
 819         struct inode *inode = d_inode(dentry);
 820         struct ceph_inode_info *ci = ceph_inode(inode);
 821         struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode);
 822         u32 vir_namelen = 0;
 823         u32 namelen;
 824         int err;
 825         u32 len;
 826         int i;
 827
 828         spin_lock(&ci->i_ceph_lock);
 829         dout("listxattr %p ver=%lld index_ver=%lld\n", inode,
 830              ci->i_xattrs.version, ci->i_xattrs.index_version);
 831
 832         if (ci->i_xattrs.version == 0 ||
 833             !__ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 1)) {
 834                 spin_unlock(&ci->i_ceph_lock);
 835                 err = ceph_do_getattr(inode, CEPH_STAT_CAP_XATTR, true);
 836                 if (err)
 837                         return err;
 838                 spin_lock(&ci->i_ceph_lock);
 839         }
 840
 841         err = __build_xattrs(inode);
 842         if (err < 0)
 843                 goto out;
 844         /*
 845          * Start with virtual dir xattr names (if any) (including
 846          * terminating '\0' characters for each).
 847          */
 848         vir_namelen = ceph_vxattrs_name_size(vxattrs);
 849
 850         /* adding 1 byte per each variable due to the null termination */
 851         namelen = ci->i_xattrs.names_size + ci->i_xattrs.count;
 852         err = -ERANGE;
 853         if (size && vir_namelen + namelen > size)
 854                 goto out;
 855
 856         err = namelen + vir_namelen;
 857         if (size == 0)
 858                 goto out;
 859
 860         names = __copy_xattr_names(ci, names);
 861
 862         /* virtual xattr names, too */
 863         err = namelen;
 864         if (vxattrs) {
 865                 for (i = 0; vxattrs[i].name; i++) {
 866                         if (!vxattrs[i].hidden &&
 867                             !(vxattrs[i].exists_cb &&
 868                               !vxattrs[i].exists_cb(ci))) {
 869                                 len = sprintf(names, "%s", vxattrs[i].name);
 870                                 names += len + 1;
 871                                 err += len + 1;
 872                         }
 873                 }
 874         }
 875
 876 out:
 877         spin_unlock(&ci->i_ceph_lock);
 878         return err;
 879 }
 880
 881 static int ceph_sync_setxattr(struct inode *inode, const char *name,
 882                               const char *value, size_t size, int flags)
 883 {
 884         struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
 885         struct ceph_inode_info *ci = ceph_inode(inode);
 886         struct ceph_mds_request *req;
 887         struct ceph_mds_client *mdsc = fsc->mdsc;
 888         struct ceph_pagelist *pagelist = NULL;
 889         int op = CEPH_MDS_OP_SETXATTR;
 890         int err;
 891
 892         if (size > 0) {
 893                 /* copy value into pagelist */
 894                 pagelist = kmalloc(sizeof(*pagelist), GFP_NOFS);
 895                 if (!pagelist)
 896                         return -ENOMEM;
 897
 898                 ceph_pagelist_init(pagelist);
 899                 err = ceph_pagelist_append(pagelist, value, size);
 900                 if (err)
 901                         goto out;
 902         } else if (!value) {
 903                 if (flags & CEPH_XATTR_REPLACE)
 904                         op = CEPH_MDS_OP_RMXATTR;
 905                 else
 906                         flags |= CEPH_XATTR_REMOVE;
 907         }
 908
 909         dout("setxattr value=%.*s\n", (int)size, value);
 910
 911         /* do request */
 912         req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
 913         if (IS_ERR(req)) {
 914                 err = PTR_ERR(req);
 915                 goto out;
 916         }
 917
 918         req->r_path2 = kstrdup(name, GFP_NOFS);
 919         if (!req->r_path2) {
 920                 ceph_mdsc_put_request(req);
 921                 err = -ENOMEM;
 922                 goto out;
 923         }
 924
 925         if (op == CEPH_MDS_OP_SETXATTR) {
 926                 req->r_args.setxattr.flags = cpu_to_le32(flags);
 927                 req->r_pagelist = pagelist;
 928                 pagelist = NULL;
 929         }
 930
 931         req->r_inode = inode;
 932         ihold(inode);
 933         req->r_num_caps = 1;
 934         req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
 935
 936         dout("xattr.ver (before): %lld\n", ci->i_xattrs.version);
 937         err = ceph_mdsc_do_request(mdsc, NULL, req);
 938         ceph_mdsc_put_request(req);
 939         dout("xattr.ver (after): %lld\n", ci->i_xattrs.version);
 940
 941 out:
 942         if (pagelist)
 943                 ceph_pagelist_release(pagelist);
 944         return err;
 945 }
 946
 947 int __ceph_setxattr(struct inode *inode, const char *name,
 948                         const void *value, size_t size, int flags)
 949 {
 950         struct ceph_vxattr *vxattr;
 951         struct ceph_inode_info *ci = ceph_inode(inode);
 952         struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
 953         struct ceph_cap_flush *prealloc_cf = NULL;
 954         struct ceph_buffer *old_blob = NULL;
 955         int issued;
 956         int err;
 957         int dirty = 0;
 958         int name_len = strlen(name);
 959         int val_len = size;
 960         char *newname = NULL;
 961         char *newval = NULL;
 962         struct ceph_inode_xattr *xattr = NULL;
 963         int required_blob_size;
 964         bool lock_snap_rwsem = false;
 965
 966         if (ceph_snap(inode) != CEPH_NOSNAP)
 967                 return -EROFS;
 968
 969         vxattr = ceph_match_vxattr(inode, name);
 970         if (vxattr && vxattr->readonly)
 971                 return -EOPNOTSUPP;
 972
 973         /* pass any unhandled ceph.* xattrs through to the MDS */
 974         if (!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN))
 975                 goto do_sync_unlocked;
 976
 977         /* preallocate memory for xattr name, value, index node */
 978         err = -ENOMEM;
 979         newname = kmemdup(name, name_len + 1, GFP_NOFS);
 980         if (!newname)
 981                 goto out;
 982
 983         if (val_len) {
 984                 newval = kmemdup(value, val_len, GFP_NOFS);
 985                 if (!newval)
 986                         goto out;
 987         }
 988
 989         xattr = kmalloc(sizeof(struct ceph_inode_xattr), GFP_NOFS);
 990         if (!xattr)
 991                 goto out;
 992
 993         prealloc_cf = ceph_alloc_cap_flush();
 994         if (!prealloc_cf)
 995                 goto out;
 996
 997         spin_lock(&ci->i_ceph_lock);
 998 retry:
 999         issued = __ceph_caps_issued(ci, NULL);
1000         if (ci->i_xattrs.version == 0 || !(issued & CEPH_CAP_XATTR_EXCL))
1001                 goto do_sync;
1002
1003         if (!lock_snap_rwsem && !ci->i_head_snapc) {
1004                 lock_snap_rwsem = true;
1005                 if (!down_read_trylock(&mdsc->snap_rwsem)) {
1006                         spin_unlock(&ci->i_ceph_lock);
1007                         down_read(&mdsc->snap_rwsem);
1008                         spin_lock(&ci->i_ceph_lock);
1009                         goto retry;
1010                 }
1011         }
1012
1013         dout("setxattr %p issued %s\n", inode, ceph_cap_string(issued));
1014         __build_xattrs(inode);
1015
1016         required_blob_size = __get_required_blob_size(ci, name_len, val_len);
1017
1018         if (!ci->i_xattrs.prealloc_blob ||
1019             required_blob_size > ci->i_xattrs.prealloc_blob->alloc_len) {
1020                 struct ceph_buffer *blob;
1021
1022                 spin_unlock(&ci->i_ceph_lock);
1023                 ceph_buffer_put(old_blob); /* Shouldn't be required */
1024                 dout(" pre-allocating new blob size=%d\n", required_blob_size);
1025                 blob = ceph_buffer_new(required_blob_size, GFP_NOFS);
1026                 if (!blob)
1027                         goto do_sync_unlocked;
1028                 spin_lock(&ci->i_ceph_lock);
1029                 /* prealloc_blob can't be released while holding i_ceph_lock */
1030                 if (ci->i_xattrs.prealloc_blob)
1031                         old_blob = ci->i_xattrs.prealloc_blob;
1032                 ci->i_xattrs.prealloc_blob = blob;
1033                 goto retry;
1034         }
1035
1036         err = __set_xattr(ci, newname, name_len, newval, val_len,
1037                           flags, value ? 1 : -1, &xattr);
1038
1039         if (!err) {
1040                 dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL,
1041                                                &prealloc_cf);
1042                 ci->i_xattrs.dirty = true;
1043                 inode->i_ctime = current_time(inode);
1044         }
1045
1046         spin_unlock(&ci->i_ceph_lock);
1047         ceph_buffer_put(old_blob);
1048         if (lock_snap_rwsem)
1049                 up_read(&mdsc->snap_rwsem);
1050         if (dirty)
1051                 __mark_inode_dirty(inode, dirty);
1052         ceph_free_cap_flush(prealloc_cf);
1053         return err;
1054
1055 do_sync:
1056         spin_unlock(&ci->i_ceph_lock);
1057 do_sync_unlocked:
1058         if (lock_snap_rwsem)
1059                 up_read(&mdsc->snap_rwsem);
1060
1061         /* security module set xattr while filling trace */
1062         if (current->journal_info != NULL) {
1063                 pr_warn_ratelimited("sync setxattr %p "
1064                                     "during filling trace\n", inode);
1065                 err = -EBUSY;
1066         } else {
1067                 err = ceph_sync_setxattr(inode, name, value, size, flags);
1068         }
1069 out:
1070         ceph_free_cap_flush(prealloc_cf);
1071         kfree(newname);
1072         kfree(newval);
1073         kfree(xattr);
1074         return err;
1075 }
1076
1077 static int ceph_get_xattr_handler(const struct xattr_handler *handler,
1078                                   struct dentry *dentry, struct inode *inode,
1079                                   const char *name, void *value, size_t size)
1080 {
1081         if (!ceph_is_valid_xattr(name))
1082                 return -EOPNOTSUPP;
1083         return __ceph_getxattr(inode, name, value, size);
1084 }
1085
1086 static int ceph_set_xattr_handler(const struct xattr_handler *handler,
1087                                   struct dentry *unused, struct inode *inode,
1088                                   const char *name, const void *value,
1089                                   size_t size, int flags)
1090 {
1091         if (!ceph_is_valid_xattr(name))
1092                 return -EOPNOTSUPP;
1093         return __ceph_setxattr(inode, name, value, size, flags);
1094 }
1095
1096 static const struct xattr_handler ceph_other_xattr_handler = {
1097         .prefix = "",  /* match any name => handlers called with full name */
1098         .get = ceph_get_xattr_handler,
1099         .set = ceph_set_xattr_handler,
1100 };
1101
1102 #ifdef CONFIG_SECURITY
1103 bool ceph_security_xattr_wanted(struct inode *in)
1104 {
1105         return in->i_security != NULL;
1106 }
1107
1108 bool ceph_security_xattr_deadlock(struct inode *in)
1109 {
1110         struct ceph_inode_info *ci;
1111         bool ret;
1112         if (in->i_security == NULL)
1113                 return false;
1114         ci = ceph_inode(in);
1115         spin_lock(&ci->i_ceph_lock);
1116         ret = !(ci->i_ceph_flags & CEPH_I_SEC_INITED) &&
1117               !(ci->i_xattrs.version > 0 &&
1118                 __ceph_caps_issued_mask(ci, CEPH_CAP_XATTR_SHARED, 0));
1119         spin_unlock(&ci->i_ceph_lock);
1120         return ret;
1121 }
1122 #endif