1 #include <linux/ceph/ceph_debug.h>
4 #include "mds_client.h"
6 #include <linux/ceph/decode.h>
8 #include <linux/xattr.h>
9 #include <linux/posix_acl_xattr.h>
10 #include <linux/slab.h>
12 #define XATTR_CEPH_PREFIX "ceph."
13 #define XATTR_CEPH_PREFIX_LEN (sizeof (XATTR_CEPH_PREFIX) - 1)
16 * List of handlers for synthetic system.* attributes. Other
17 * attributes are handled directly.
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
,
27 static bool ceph_is_valid_xattr(const char *name
)
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
);
38 * These define virtual xattrs exposing the recursive directory
39 * statistics and layout metadata.
43 size_t name_size
; /* strlen(name) + 1 (for '\0') */
44 size_t (*getxattr_cb
)(struct ceph_inode_info
*ci
, char *val
,
46 bool readonly
, hidden
;
47 bool (*exists_cb
)(struct ceph_inode_info
*ci
);
52 static bool ceph_vxattrcb_layout_exists(struct ceph_inode_info
*ci
)
55 char *p
= (char *)&ci
->i_layout
;
57 for (s
= 0; s
< sizeof(ci
->i_layout
); s
++, p
++)
63 static size_t ceph_vxattrcb_layout(struct ceph_inode_info
*ci
, char *val
,
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
;
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
);
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
),
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
);
90 up_read(&osdc
->map_sem
);
94 static size_t ceph_vxattrcb_layout_stripe_unit(struct ceph_inode_info
*ci
,
95 char *val
, size_t size
)
97 return snprintf(val
, size
, "%lld",
98 (unsigned long long)ceph_file_layout_su(ci
->i_layout
));
101 static size_t ceph_vxattrcb_layout_stripe_count(struct ceph_inode_info
*ci
,
102 char *val
, size_t size
)
104 return snprintf(val
, size
, "%lld",
105 (unsigned long long)ceph_file_layout_stripe_count(ci
->i_layout
));
108 static size_t ceph_vxattrcb_layout_object_size(struct ceph_inode_info
*ci
,
109 char *val
, size_t size
)
111 return snprintf(val
, size
, "%lld",
112 (unsigned long long)ceph_file_layout_object_size(ci
->i_layout
));
115 static size_t ceph_vxattrcb_layout_pool(struct ceph_inode_info
*ci
,
116 char *val
, size_t size
)
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
;
124 down_read(&osdc
->map_sem
);
125 pool_name
= ceph_pg_pool_name_by_id(osdc
->osdmap
, pool
);
127 ret
= snprintf(val
, size
, "%s", pool_name
);
129 ret
= snprintf(val
, size
, "%lld", (unsigned long long)pool
);
130 up_read(&osdc
->map_sem
);
136 static size_t ceph_vxattrcb_dir_entries(struct ceph_inode_info
*ci
, char *val
,
139 return snprintf(val
, size
, "%lld", ci
->i_files
+ ci
->i_subdirs
);
142 static size_t ceph_vxattrcb_dir_files(struct ceph_inode_info
*ci
, char *val
,
145 return snprintf(val
, size
, "%lld", ci
->i_files
);
148 static size_t ceph_vxattrcb_dir_subdirs(struct ceph_inode_info
*ci
, char *val
,
151 return snprintf(val
, size
, "%lld", ci
->i_subdirs
);
154 static size_t ceph_vxattrcb_dir_rentries(struct ceph_inode_info
*ci
, char *val
,
157 return snprintf(val
, size
, "%lld", ci
->i_rfiles
+ ci
->i_rsubdirs
);
160 static size_t ceph_vxattrcb_dir_rfiles(struct ceph_inode_info
*ci
, char *val
,
163 return snprintf(val
, size
, "%lld", ci
->i_rfiles
);
166 static size_t ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info
*ci
, char *val
,
169 return snprintf(val
, size
, "%lld", ci
->i_rsubdirs
);
172 static size_t ceph_vxattrcb_dir_rbytes(struct ceph_inode_info
*ci
, char *val
,
175 return snprintf(val
, size
, "%lld", ci
->i_rbytes
);
178 static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info
*ci
, char *val
,
181 return snprintf(val
, size
, "%ld.09%ld", (long)ci
->i_rctime
.tv_sec
,
182 (long)ci
->i_rctime
.tv_nsec
);
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
190 #define XATTR_NAME_CEPH(_type, _name) \
192 .name = CEPH_XATTR_NAME(_type, _name), \
193 .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \
194 .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
199 #define XATTR_LAYOUT_FIELD(_type, _name, _field) \
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, \
206 .exists_cb = ceph_vxattrcb_layout_exists, \
209 static struct ceph_vxattr ceph_dir_vxattrs
[] = {
211 .name
= "ceph.dir.layout",
212 .name_size
= sizeof("ceph.dir.layout"),
213 .getxattr_cb
= ceph_vxattrcb_layout
,
216 .exists_cb
= ceph_vxattrcb_layout_exists
,
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 */
232 static size_t ceph_dir_vxattrs_name_size
; /* total size of all names */
236 static struct ceph_vxattr ceph_file_vxattrs
[] = {
238 .name
= "ceph.file.layout",
239 .name_size
= sizeof("ceph.file.layout"),
240 .getxattr_cb
= ceph_vxattrcb_layout
,
243 .exists_cb
= ceph_vxattrcb_layout_exists
,
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 */
251 static size_t ceph_file_vxattrs_name_size
; /* total size of all names */
253 static struct ceph_vxattr
*ceph_inode_vxattrs(struct inode
*inode
)
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
;
262 static size_t ceph_vxattrs_name_size(struct ceph_vxattr
*vxattrs
)
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
;
274 * Compute the aggregate size (including terminating '\0') of all
275 * virtual extended attribute names in the given vxattr table.
277 static size_t __init
vxattrs_name_size(struct ceph_vxattr
*vxattrs
)
279 struct ceph_vxattr
*vxattr
;
282 for (vxattr
= vxattrs
; vxattr
->name
; vxattr
++)
284 size
+= vxattr
->name_size
;
289 /* Routines called at initialization and exit time */
291 void __init
ceph_xattr_init(void)
293 ceph_dir_vxattrs_name_size
= vxattrs_name_size(ceph_dir_vxattrs
);
294 ceph_file_vxattrs_name_size
= vxattrs_name_size(ceph_file_vxattrs
);
297 void ceph_xattr_exit(void)
299 ceph_dir_vxattrs_name_size
= 0;
300 ceph_file_vxattrs_name_size
= 0;
303 static struct ceph_vxattr
*ceph_match_vxattr(struct inode
*inode
,
306 struct ceph_vxattr
*vxattr
= ceph_inode_vxattrs(inode
);
309 while (vxattr
->name
) {
310 if (!strcmp(vxattr
->name
, name
))
319 static int __set_xattr(struct ceph_inode_info
*ci
,
320 const char *name
, int name_len
,
321 const char *val
, int val_len
,
323 int should_free_name
, int should_free_val
,
324 struct ceph_inode_xattr
**newxattr
)
327 struct rb_node
*parent
= NULL
;
328 struct ceph_inode_xattr
*xattr
= NULL
;
332 p
= &ci
->i_xattrs
.index
.rb_node
;
335 xattr
= rb_entry(parent
, struct ceph_inode_xattr
, node
);
336 c
= strncmp(name
, xattr
->name
, min(name_len
, xattr
->name_len
));
342 if (name_len
== xattr
->name_len
)
344 else if (name_len
< xattr
->name_len
)
356 xattr
->name_len
= name_len
;
357 xattr
->should_free_name
= should_free_name
;
359 ci
->i_xattrs
.count
++;
360 dout("__set_xattr count=%d\n", ci
->i_xattrs
.count
);
364 if (xattr
->should_free_val
)
365 kfree((void *)xattr
->val
);
367 if (should_free_name
) {
371 ci
->i_xattrs
.names_size
-= xattr
->name_len
;
372 ci
->i_xattrs
.vals_size
-= xattr
->val_len
;
374 ci
->i_xattrs
.names_size
+= name_len
;
375 ci
->i_xattrs
.vals_size
+= val_len
;
381 xattr
->val_len
= val_len
;
382 xattr
->dirty
= dirty
;
383 xattr
->should_free_val
= (val
&& should_free_val
);
386 rb_link_node(&xattr
->node
, parent
, p
);
387 rb_insert_color(&xattr
->node
, &ci
->i_xattrs
.index
);
388 dout("__set_xattr_val p=%p\n", p
);
391 dout("__set_xattr_val added %llx.%llx xattr %p %s=%.*s\n",
392 ceph_vinop(&ci
->vfs_inode
), xattr
, name
, val_len
, val
);
397 static struct ceph_inode_xattr
*__get_xattr(struct ceph_inode_info
*ci
,
401 struct rb_node
*parent
= NULL
;
402 struct ceph_inode_xattr
*xattr
= NULL
;
403 int name_len
= strlen(name
);
406 p
= &ci
->i_xattrs
.index
.rb_node
;
409 xattr
= rb_entry(parent
, struct ceph_inode_xattr
, node
);
410 c
= strncmp(name
, xattr
->name
, xattr
->name_len
);
411 if (c
== 0 && name_len
> xattr
->name_len
)
418 dout("__get_xattr %s: found %.*s\n", name
,
419 xattr
->val_len
, xattr
->val
);
424 dout("__get_xattr %s: not found\n", name
);
429 static void __free_xattr(struct ceph_inode_xattr
*xattr
)
433 if (xattr
->should_free_name
)
434 kfree((void *)xattr
->name
);
435 if (xattr
->should_free_val
)
436 kfree((void *)xattr
->val
);
441 static int __remove_xattr(struct ceph_inode_info
*ci
,
442 struct ceph_inode_xattr
*xattr
)
447 rb_erase(&xattr
->node
, &ci
->i_xattrs
.index
);
449 if (xattr
->should_free_name
)
450 kfree((void *)xattr
->name
);
451 if (xattr
->should_free_val
)
452 kfree((void *)xattr
->val
);
454 ci
->i_xattrs
.names_size
-= xattr
->name_len
;
455 ci
->i_xattrs
.vals_size
-= xattr
->val_len
;
456 ci
->i_xattrs
.count
--;
462 static int __remove_xattr_by_name(struct ceph_inode_info
*ci
,
466 struct ceph_inode_xattr
*xattr
;
469 p
= &ci
->i_xattrs
.index
.rb_node
;
470 xattr
= __get_xattr(ci
, name
);
471 err
= __remove_xattr(ci
, xattr
);
475 static char *__copy_xattr_names(struct ceph_inode_info
*ci
,
479 struct ceph_inode_xattr
*xattr
= NULL
;
481 p
= rb_first(&ci
->i_xattrs
.index
);
482 dout("__copy_xattr_names count=%d\n", ci
->i_xattrs
.count
);
485 xattr
= rb_entry(p
, struct ceph_inode_xattr
, node
);
486 memcpy(dest
, xattr
->name
, xattr
->name_len
);
487 dest
[xattr
->name_len
] = '\0';
489 dout("dest=%s %p (%s) (%d/%d)\n", dest
, xattr
, xattr
->name
,
490 xattr
->name_len
, ci
->i_xattrs
.names_size
);
492 dest
+= xattr
->name_len
+ 1;
499 void __ceph_destroy_xattrs(struct ceph_inode_info
*ci
)
501 struct rb_node
*p
, *tmp
;
502 struct ceph_inode_xattr
*xattr
= NULL
;
504 p
= rb_first(&ci
->i_xattrs
.index
);
506 dout("__ceph_destroy_xattrs p=%p\n", p
);
509 xattr
= rb_entry(p
, struct ceph_inode_xattr
, node
);
512 dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p
,
513 xattr
->name_len
, xattr
->name
);
514 rb_erase(tmp
, &ci
->i_xattrs
.index
);
519 ci
->i_xattrs
.names_size
= 0;
520 ci
->i_xattrs
.vals_size
= 0;
521 ci
->i_xattrs
.index_version
= 0;
522 ci
->i_xattrs
.count
= 0;
523 ci
->i_xattrs
.index
= RB_ROOT
;
526 static int __build_xattrs(struct inode
*inode
)
527 __releases(ci
->i_ceph_lock
)
528 __acquires(ci
->i_ceph_lock
)
534 const char *name
, *val
;
535 struct ceph_inode_info
*ci
= ceph_inode(inode
);
537 struct ceph_inode_xattr
**xattrs
= NULL
;
541 dout("__build_xattrs() len=%d\n",
542 ci
->i_xattrs
.blob
? (int)ci
->i_xattrs
.blob
->vec
.iov_len
: 0);
544 if (ci
->i_xattrs
.index_version
>= ci
->i_xattrs
.version
)
545 return 0; /* already built */
547 __ceph_destroy_xattrs(ci
);
550 /* updated internal xattr rb tree */
551 if (ci
->i_xattrs
.blob
&& ci
->i_xattrs
.blob
->vec
.iov_len
> 4) {
552 p
= ci
->i_xattrs
.blob
->vec
.iov_base
;
553 end
= p
+ ci
->i_xattrs
.blob
->vec
.iov_len
;
554 ceph_decode_32_safe(&p
, end
, numattr
, bad
);
555 xattr_version
= ci
->i_xattrs
.version
;
556 spin_unlock(&ci
->i_ceph_lock
);
558 xattrs
= kcalloc(numattr
, sizeof(struct ceph_xattr
*),
563 memset(xattrs
, 0, numattr
*sizeof(struct ceph_xattr
*));
564 for (i
= 0; i
< numattr
; i
++) {
565 xattrs
[i
] = kmalloc(sizeof(struct ceph_inode_xattr
),
571 spin_lock(&ci
->i_ceph_lock
);
572 if (ci
->i_xattrs
.version
!= xattr_version
) {
573 /* lost a race, retry */
574 for (i
= 0; i
< numattr
; i
++)
582 ceph_decode_32_safe(&p
, end
, len
, bad
);
586 ceph_decode_32_safe(&p
, end
, len
, bad
);
590 err
= __set_xattr(ci
, name
, namelen
, val
, len
,
591 0, 0, 0, &xattrs
[numattr
]);
598 ci
->i_xattrs
.index_version
= ci
->i_xattrs
.version
;
599 ci
->i_xattrs
.dirty
= false;
603 spin_lock(&ci
->i_ceph_lock
);
606 for (i
= 0; i
< numattr
; i
++)
610 ci
->i_xattrs
.names_size
= 0;
614 static int __get_required_blob_size(struct ceph_inode_info
*ci
, int name_size
,
618 * 4 bytes for the length, and additional 4 bytes per each xattr name,
619 * 4 bytes per each value
621 int size
= 4 + ci
->i_xattrs
.count
*(4 + 4) +
622 ci
->i_xattrs
.names_size
+
623 ci
->i_xattrs
.vals_size
;
624 dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n",
625 ci
->i_xattrs
.count
, ci
->i_xattrs
.names_size
,
626 ci
->i_xattrs
.vals_size
);
629 size
+= 4 + 4 + name_size
+ val_size
;
635 * If there are dirty xattrs, reencode xattrs into the prealloc_blob
636 * and swap into place.
638 void __ceph_build_xattrs_blob(struct ceph_inode_info
*ci
)
641 struct ceph_inode_xattr
*xattr
= NULL
;
644 dout("__build_xattrs_blob %p\n", &ci
->vfs_inode
);
645 if (ci
->i_xattrs
.dirty
) {
646 int need
= __get_required_blob_size(ci
, 0, 0);
648 BUG_ON(need
> ci
->i_xattrs
.prealloc_blob
->alloc_len
);
650 p
= rb_first(&ci
->i_xattrs
.index
);
651 dest
= ci
->i_xattrs
.prealloc_blob
->vec
.iov_base
;
653 ceph_encode_32(&dest
, ci
->i_xattrs
.count
);
655 xattr
= rb_entry(p
, struct ceph_inode_xattr
, node
);
657 ceph_encode_32(&dest
, xattr
->name_len
);
658 memcpy(dest
, xattr
->name
, xattr
->name_len
);
659 dest
+= xattr
->name_len
;
660 ceph_encode_32(&dest
, xattr
->val_len
);
661 memcpy(dest
, xattr
->val
, xattr
->val_len
);
662 dest
+= xattr
->val_len
;
667 /* adjust buffer len; it may be larger than we need */
668 ci
->i_xattrs
.prealloc_blob
->vec
.iov_len
=
669 dest
- ci
->i_xattrs
.prealloc_blob
->vec
.iov_base
;
671 if (ci
->i_xattrs
.blob
)
672 ceph_buffer_put(ci
->i_xattrs
.blob
);
673 ci
->i_xattrs
.blob
= ci
->i_xattrs
.prealloc_blob
;
674 ci
->i_xattrs
.prealloc_blob
= NULL
;
675 ci
->i_xattrs
.dirty
= false;
676 ci
->i_xattrs
.version
++;
680 ssize_t
__ceph_getxattr(struct inode
*inode
, const char *name
, void *value
,
683 struct ceph_inode_info
*ci
= ceph_inode(inode
);
685 struct ceph_inode_xattr
*xattr
;
686 struct ceph_vxattr
*vxattr
= NULL
;
688 if (!ceph_is_valid_xattr(name
))
691 /* let's see if a virtual xattr was requested */
692 vxattr
= ceph_match_vxattr(inode
, name
);
693 if (vxattr
&& !(vxattr
->exists_cb
&& !vxattr
->exists_cb(ci
))) {
694 err
= vxattr
->getxattr_cb(ci
, value
, size
);
698 spin_lock(&ci
->i_ceph_lock
);
699 dout("getxattr %p ver=%lld index_ver=%lld\n", inode
,
700 ci
->i_xattrs
.version
, ci
->i_xattrs
.index_version
);
702 if (__ceph_caps_issued_mask(ci
, CEPH_CAP_XATTR_SHARED
, 1) &&
703 (ci
->i_xattrs
.index_version
>= ci
->i_xattrs
.version
)) {
706 spin_unlock(&ci
->i_ceph_lock
);
707 /* get xattrs from mds (if we don't already have them) */
708 err
= ceph_do_getattr(inode
, CEPH_STAT_CAP_XATTR
);
713 spin_lock(&ci
->i_ceph_lock
);
715 err
= __build_xattrs(inode
);
720 err
= -ENODATA
; /* == ENOATTR */
721 xattr
= __get_xattr(ci
, name
);
726 if (size
&& size
< xattr
->val_len
)
729 err
= xattr
->val_len
;
733 memcpy(value
, xattr
->val
, xattr
->val_len
);
736 spin_unlock(&ci
->i_ceph_lock
);
740 ssize_t
ceph_getxattr(struct dentry
*dentry
, const char *name
, void *value
,
743 if (!strncmp(name
, XATTR_SYSTEM_PREFIX
, XATTR_SYSTEM_PREFIX_LEN
))
744 return generic_getxattr(dentry
, name
, value
, size
);
746 return __ceph_getxattr(dentry
->d_inode
, name
, value
, size
);
749 ssize_t
ceph_listxattr(struct dentry
*dentry
, char *names
, size_t size
)
751 struct inode
*inode
= dentry
->d_inode
;
752 struct ceph_inode_info
*ci
= ceph_inode(inode
);
753 struct ceph_vxattr
*vxattrs
= ceph_inode_vxattrs(inode
);
760 spin_lock(&ci
->i_ceph_lock
);
761 dout("listxattr %p ver=%lld index_ver=%lld\n", inode
,
762 ci
->i_xattrs
.version
, ci
->i_xattrs
.index_version
);
764 if (__ceph_caps_issued_mask(ci
, CEPH_CAP_XATTR_SHARED
, 1) &&
765 (ci
->i_xattrs
.index_version
>= ci
->i_xattrs
.version
)) {
768 spin_unlock(&ci
->i_ceph_lock
);
769 err
= ceph_do_getattr(inode
, CEPH_STAT_CAP_XATTR
);
774 spin_lock(&ci
->i_ceph_lock
);
776 err
= __build_xattrs(inode
);
782 * Start with virtual dir xattr names (if any) (including
783 * terminating '\0' characters for each).
785 vir_namelen
= ceph_vxattrs_name_size(vxattrs
);
787 /* adding 1 byte per each variable due to the null termination */
788 namelen
= ci
->i_xattrs
.names_size
+ ci
->i_xattrs
.count
;
790 if (size
&& vir_namelen
+ namelen
> size
)
793 err
= namelen
+ vir_namelen
;
797 names
= __copy_xattr_names(ci
, names
);
799 /* virtual xattr names, too */
802 for (i
= 0; vxattrs
[i
].name
; i
++) {
803 if (!vxattrs
[i
].hidden
&&
804 !(vxattrs
[i
].exists_cb
&&
805 !vxattrs
[i
].exists_cb(ci
))) {
806 len
= sprintf(names
, "%s", vxattrs
[i
].name
);
814 spin_unlock(&ci
->i_ceph_lock
);
818 static int ceph_sync_setxattr(struct dentry
*dentry
, const char *name
,
819 const char *value
, size_t size
, int flags
)
821 struct ceph_fs_client
*fsc
= ceph_sb_to_client(dentry
->d_sb
);
822 struct inode
*inode
= dentry
->d_inode
;
823 struct ceph_inode_info
*ci
= ceph_inode(inode
);
824 struct inode
*parent_inode
;
825 struct ceph_mds_request
*req
;
826 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
829 struct page
**pages
= NULL
;
832 /* copy value into some pages */
833 nr_pages
= calc_pages_for(0, size
);
835 pages
= kmalloc(sizeof(pages
[0])*nr_pages
, GFP_NOFS
);
839 for (i
= 0; i
< nr_pages
; i
++) {
840 pages
[i
] = __page_cache_alloc(GFP_NOFS
);
845 kaddr
= kmap(pages
[i
]);
846 memcpy(kaddr
, value
+ i
*PAGE_CACHE_SIZE
,
847 min(PAGE_CACHE_SIZE
, size
-i
*PAGE_CACHE_SIZE
));
851 dout("setxattr value=%.*s\n", (int)size
, value
);
854 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_SETXATTR
,
860 req
->r_inode
= inode
;
862 req
->r_inode_drop
= CEPH_CAP_XATTR_SHARED
;
864 req
->r_args
.setxattr
.flags
= cpu_to_le32(flags
);
865 req
->r_path2
= kstrdup(name
, GFP_NOFS
);
867 req
->r_pages
= pages
;
868 req
->r_num_pages
= nr_pages
;
869 req
->r_data_len
= size
;
871 dout("xattr.ver (before): %lld\n", ci
->i_xattrs
.version
);
872 parent_inode
= ceph_get_dentry_parent_inode(dentry
);
873 err
= ceph_mdsc_do_request(mdsc
, parent_inode
, req
);
875 ceph_mdsc_put_request(req
);
876 dout("xattr.ver (after): %lld\n", ci
->i_xattrs
.version
);
880 for (i
= 0; i
< nr_pages
; i
++)
881 __free_page(pages
[i
]);
887 int __ceph_setxattr(struct dentry
*dentry
, const char *name
,
888 const void *value
, size_t size
, int flags
)
890 struct inode
*inode
= dentry
->d_inode
;
891 struct ceph_vxattr
*vxattr
;
892 struct ceph_inode_info
*ci
= ceph_inode(inode
);
896 int name_len
= strlen(name
);
898 char *newname
= NULL
;
900 struct ceph_inode_xattr
*xattr
= NULL
;
901 int required_blob_size
;
903 if (!ceph_is_valid_xattr(name
))
906 vxattr
= ceph_match_vxattr(inode
, name
);
907 if (vxattr
&& vxattr
->readonly
)
910 /* pass any unhandled ceph.* xattrs through to the MDS */
911 if (!strncmp(name
, XATTR_CEPH_PREFIX
, XATTR_CEPH_PREFIX_LEN
))
912 goto do_sync_unlocked
;
914 /* preallocate memory for xattr name, value, index node */
916 newname
= kmemdup(name
, name_len
+ 1, GFP_NOFS
);
921 newval
= kmemdup(value
, val_len
, GFP_NOFS
);
926 xattr
= kmalloc(sizeof(struct ceph_inode_xattr
), GFP_NOFS
);
930 spin_lock(&ci
->i_ceph_lock
);
932 issued
= __ceph_caps_issued(ci
, NULL
);
933 dout("setxattr %p issued %s\n", inode
, ceph_cap_string(issued
));
934 if (!(issued
& CEPH_CAP_XATTR_EXCL
))
936 __build_xattrs(inode
);
938 required_blob_size
= __get_required_blob_size(ci
, name_len
, val_len
);
940 if (!ci
->i_xattrs
.prealloc_blob
||
941 required_blob_size
> ci
->i_xattrs
.prealloc_blob
->alloc_len
) {
942 struct ceph_buffer
*blob
;
944 spin_unlock(&ci
->i_ceph_lock
);
945 dout(" preaallocating new blob size=%d\n", required_blob_size
);
946 blob
= ceph_buffer_new(required_blob_size
, GFP_NOFS
);
949 spin_lock(&ci
->i_ceph_lock
);
950 if (ci
->i_xattrs
.prealloc_blob
)
951 ceph_buffer_put(ci
->i_xattrs
.prealloc_blob
);
952 ci
->i_xattrs
.prealloc_blob
= blob
;
956 err
= __set_xattr(ci
, newname
, name_len
, newval
,
957 val_len
, 1, 1, 1, &xattr
);
959 dirty
= __ceph_mark_dirty_caps(ci
, CEPH_CAP_XATTR_EXCL
);
960 ci
->i_xattrs
.dirty
= true;
961 inode
->i_ctime
= CURRENT_TIME
;
963 spin_unlock(&ci
->i_ceph_lock
);
965 __mark_inode_dirty(inode
, dirty
);
969 spin_unlock(&ci
->i_ceph_lock
);
971 err
= ceph_sync_setxattr(dentry
, name
, value
, size
, flags
);
979 int ceph_setxattr(struct dentry
*dentry
, const char *name
,
980 const void *value
, size_t size
, int flags
)
982 if (ceph_snap(dentry
->d_inode
) != CEPH_NOSNAP
)
985 if (!strncmp(name
, XATTR_SYSTEM_PREFIX
, XATTR_SYSTEM_PREFIX_LEN
))
986 return generic_setxattr(dentry
, name
, value
, size
, flags
);
988 return __ceph_setxattr(dentry
, name
, value
, size
, flags
);
991 static int ceph_send_removexattr(struct dentry
*dentry
, const char *name
)
993 struct ceph_fs_client
*fsc
= ceph_sb_to_client(dentry
->d_sb
);
994 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
995 struct inode
*inode
= dentry
->d_inode
;
996 struct inode
*parent_inode
;
997 struct ceph_mds_request
*req
;
1000 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_RMXATTR
,
1003 return PTR_ERR(req
);
1004 req
->r_inode
= inode
;
1006 req
->r_inode_drop
= CEPH_CAP_XATTR_SHARED
;
1007 req
->r_num_caps
= 1;
1008 req
->r_path2
= kstrdup(name
, GFP_NOFS
);
1010 parent_inode
= ceph_get_dentry_parent_inode(dentry
);
1011 err
= ceph_mdsc_do_request(mdsc
, parent_inode
, req
);
1013 ceph_mdsc_put_request(req
);
1017 int __ceph_removexattr(struct dentry
*dentry
, const char *name
)
1019 struct inode
*inode
= dentry
->d_inode
;
1020 struct ceph_vxattr
*vxattr
;
1021 struct ceph_inode_info
*ci
= ceph_inode(inode
);
1024 int required_blob_size
;
1027 if (!ceph_is_valid_xattr(name
))
1030 vxattr
= ceph_match_vxattr(inode
, name
);
1031 if (vxattr
&& vxattr
->readonly
)
1034 /* pass any unhandled ceph.* xattrs through to the MDS */
1035 if (!strncmp(name
, XATTR_CEPH_PREFIX
, XATTR_CEPH_PREFIX_LEN
))
1036 goto do_sync_unlocked
;
1039 spin_lock(&ci
->i_ceph_lock
);
1041 issued
= __ceph_caps_issued(ci
, NULL
);
1042 dout("removexattr %p issued %s\n", inode
, ceph_cap_string(issued
));
1044 if (!(issued
& CEPH_CAP_XATTR_EXCL
))
1046 __build_xattrs(inode
);
1048 required_blob_size
= __get_required_blob_size(ci
, 0, 0);
1050 if (!ci
->i_xattrs
.prealloc_blob
||
1051 required_blob_size
> ci
->i_xattrs
.prealloc_blob
->alloc_len
) {
1052 struct ceph_buffer
*blob
;
1054 spin_unlock(&ci
->i_ceph_lock
);
1055 dout(" preaallocating new blob size=%d\n", required_blob_size
);
1056 blob
= ceph_buffer_new(required_blob_size
, GFP_NOFS
);
1059 spin_lock(&ci
->i_ceph_lock
);
1060 if (ci
->i_xattrs
.prealloc_blob
)
1061 ceph_buffer_put(ci
->i_xattrs
.prealloc_blob
);
1062 ci
->i_xattrs
.prealloc_blob
= blob
;
1066 err
= __remove_xattr_by_name(ceph_inode(inode
), name
);
1068 dirty
= __ceph_mark_dirty_caps(ci
, CEPH_CAP_XATTR_EXCL
);
1069 ci
->i_xattrs
.dirty
= true;
1070 inode
->i_ctime
= CURRENT_TIME
;
1071 spin_unlock(&ci
->i_ceph_lock
);
1073 __mark_inode_dirty(inode
, dirty
);
1076 spin_unlock(&ci
->i_ceph_lock
);
1078 err
= ceph_send_removexattr(dentry
, name
);
1083 int ceph_removexattr(struct dentry
*dentry
, const char *name
)
1085 if (ceph_snap(dentry
->d_inode
) != CEPH_NOSNAP
)
1088 if (!strncmp(name
, XATTR_SYSTEM_PREFIX
, XATTR_SYSTEM_PREFIX_LEN
))
1089 return generic_removexattr(dentry
, name
);
1091 return __ceph_removexattr(dentry
, name
);