1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/ceph/ceph_debug.h>
3 #include <linux/ceph/pagelist.h>
6 #include "mds_client.h"
8 #include <linux/ceph/decode.h>
10 #include <linux/xattr.h>
11 #include <linux/security.h>
12 #include <linux/posix_acl_xattr.h>
13 #include <linux/slab.h>
15 #define XATTR_CEPH_PREFIX "ceph."
16 #define XATTR_CEPH_PREFIX_LEN (sizeof (XATTR_CEPH_PREFIX) - 1)
18 static int __remove_xattr(struct ceph_inode_info
*ci
,
19 struct ceph_inode_xattr
*xattr
);
21 static bool ceph_is_valid_xattr(const char *name
)
23 return !strncmp(name
, XATTR_CEPH_PREFIX
, XATTR_CEPH_PREFIX_LEN
) ||
24 !strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
) ||
25 !strncmp(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
);
29 * These define virtual xattrs exposing the recursive directory
30 * statistics and layout metadata.
34 size_t name_size
; /* strlen(name) + 1 (for '\0') */
35 ssize_t (*getxattr_cb
)(struct ceph_inode_info
*ci
, char *val
,
37 bool (*exists_cb
)(struct ceph_inode_info
*ci
);
41 #define VXATTR_FLAG_READONLY (1<<0)
42 #define VXATTR_FLAG_HIDDEN (1<<1)
43 #define VXATTR_FLAG_RSTAT (1<<2)
47 static bool ceph_vxattrcb_layout_exists(struct ceph_inode_info
*ci
)
49 struct ceph_file_layout
*fl
= &ci
->i_layout
;
50 return (fl
->stripe_unit
> 0 || fl
->stripe_count
> 0 ||
51 fl
->object_size
> 0 || fl
->pool_id
>= 0 ||
52 rcu_dereference_raw(fl
->pool_ns
) != NULL
);
55 static ssize_t
ceph_vxattrcb_layout(struct ceph_inode_info
*ci
, char *val
,
58 struct ceph_fs_client
*fsc
= ceph_sb_to_client(ci
->vfs_inode
.i_sb
);
59 struct ceph_osd_client
*osdc
= &fsc
->client
->osdc
;
60 struct ceph_string
*pool_ns
;
61 s64 pool
= ci
->i_layout
.pool_id
;
62 const char *pool_name
;
63 const char *ns_field
= " pool_namespace=";
65 size_t len
, total_len
= 0;
68 pool_ns
= ceph_try_get_string(ci
->i_layout
.pool_ns
);
70 dout("ceph_vxattrcb_layout %p\n", &ci
->vfs_inode
);
71 down_read(&osdc
->lock
);
72 pool_name
= ceph_pg_pool_name_by_id(osdc
->osdmap
, pool
);
74 len
= snprintf(buf
, sizeof(buf
),
75 "stripe_unit=%u stripe_count=%u object_size=%u pool=",
76 ci
->i_layout
.stripe_unit
, ci
->i_layout
.stripe_count
,
77 ci
->i_layout
.object_size
);
78 total_len
= len
+ strlen(pool_name
);
80 len
= snprintf(buf
, sizeof(buf
),
81 "stripe_unit=%u stripe_count=%u object_size=%u pool=%lld",
82 ci
->i_layout
.stripe_unit
, ci
->i_layout
.stripe_count
,
83 ci
->i_layout
.object_size
, pool
);
88 total_len
+= strlen(ns_field
) + pool_ns
->len
;
91 if (size
>= total_len
) {
92 memcpy(val
, buf
, len
);
95 len
= strlen(pool_name
);
96 memcpy(val
+ ret
, pool_name
, len
);
100 len
= strlen(ns_field
);
101 memcpy(val
+ ret
, ns_field
, len
);
103 memcpy(val
+ ret
, pool_ns
->str
, pool_ns
->len
);
107 up_read(&osdc
->lock
);
108 ceph_put_string(pool_ns
);
113 * The convention with strings in xattrs is that they should not be NULL
114 * terminated, since we're returning the length with them. snprintf always
115 * NULL terminates however, so call it on a temporary buffer and then memcpy
116 * the result into place.
118 static int ceph_fmt_xattr(char *val
, size_t size
, const char *fmt
, ...)
122 char buf
[96]; /* NB: reevaluate size if new vxattrs are added */
125 ret
= vsnprintf(buf
, size
? sizeof(buf
) : 0, fmt
, args
);
129 if (size
&& ret
+ 1 > sizeof(buf
)) {
130 WARN_ONCE(true, "Returned length too big (%d)", ret
);
135 memcpy(val
, buf
, ret
);
139 static ssize_t
ceph_vxattrcb_layout_stripe_unit(struct ceph_inode_info
*ci
,
140 char *val
, size_t size
)
142 return ceph_fmt_xattr(val
, size
, "%u", ci
->i_layout
.stripe_unit
);
145 static ssize_t
ceph_vxattrcb_layout_stripe_count(struct ceph_inode_info
*ci
,
146 char *val
, size_t size
)
148 return ceph_fmt_xattr(val
, size
, "%u", ci
->i_layout
.stripe_count
);
151 static ssize_t
ceph_vxattrcb_layout_object_size(struct ceph_inode_info
*ci
,
152 char *val
, size_t size
)
154 return ceph_fmt_xattr(val
, size
, "%u", ci
->i_layout
.object_size
);
157 static ssize_t
ceph_vxattrcb_layout_pool(struct ceph_inode_info
*ci
,
158 char *val
, size_t size
)
161 struct ceph_fs_client
*fsc
= ceph_sb_to_client(ci
->vfs_inode
.i_sb
);
162 struct ceph_osd_client
*osdc
= &fsc
->client
->osdc
;
163 s64 pool
= ci
->i_layout
.pool_id
;
164 const char *pool_name
;
166 down_read(&osdc
->lock
);
167 pool_name
= ceph_pg_pool_name_by_id(osdc
->osdmap
, pool
);
169 ret
= strlen(pool_name
);
171 memcpy(val
, pool_name
, ret
);
173 ret
= ceph_fmt_xattr(val
, size
, "%lld", pool
);
175 up_read(&osdc
->lock
);
179 static ssize_t
ceph_vxattrcb_layout_pool_namespace(struct ceph_inode_info
*ci
,
180 char *val
, size_t size
)
183 struct ceph_string
*ns
= ceph_try_get_string(ci
->i_layout
.pool_ns
);
188 memcpy(val
, ns
->str
, ret
);
196 static ssize_t
ceph_vxattrcb_dir_entries(struct ceph_inode_info
*ci
, char *val
,
199 return ceph_fmt_xattr(val
, size
, "%lld", ci
->i_files
+ ci
->i_subdirs
);
202 static ssize_t
ceph_vxattrcb_dir_files(struct ceph_inode_info
*ci
, char *val
,
205 return ceph_fmt_xattr(val
, size
, "%lld", ci
->i_files
);
208 static ssize_t
ceph_vxattrcb_dir_subdirs(struct ceph_inode_info
*ci
, char *val
,
211 return ceph_fmt_xattr(val
, size
, "%lld", ci
->i_subdirs
);
214 static ssize_t
ceph_vxattrcb_dir_rentries(struct ceph_inode_info
*ci
, char *val
,
217 return ceph_fmt_xattr(val
, size
, "%lld",
218 ci
->i_rfiles
+ ci
->i_rsubdirs
);
221 static ssize_t
ceph_vxattrcb_dir_rfiles(struct ceph_inode_info
*ci
, char *val
,
224 return ceph_fmt_xattr(val
, size
, "%lld", ci
->i_rfiles
);
227 static ssize_t
ceph_vxattrcb_dir_rsubdirs(struct ceph_inode_info
*ci
, char *val
,
230 return ceph_fmt_xattr(val
, size
, "%lld", ci
->i_rsubdirs
);
233 static ssize_t
ceph_vxattrcb_dir_rbytes(struct ceph_inode_info
*ci
, char *val
,
236 return ceph_fmt_xattr(val
, size
, "%lld", ci
->i_rbytes
);
239 static ssize_t
ceph_vxattrcb_dir_rctime(struct ceph_inode_info
*ci
, char *val
,
242 return ceph_fmt_xattr(val
, size
, "%lld.%09ld", ci
->i_rctime
.tv_sec
,
243 ci
->i_rctime
.tv_nsec
);
247 static bool ceph_vxattrcb_dir_pin_exists(struct ceph_inode_info
*ci
)
249 return ci
->i_dir_pin
!= -ENODATA
;
252 static ssize_t
ceph_vxattrcb_dir_pin(struct ceph_inode_info
*ci
, char *val
,
255 return ceph_fmt_xattr(val
, size
, "%d", (int)ci
->i_dir_pin
);
259 static bool ceph_vxattrcb_quota_exists(struct ceph_inode_info
*ci
)
262 spin_lock(&ci
->i_ceph_lock
);
263 if ((ci
->i_max_files
|| ci
->i_max_bytes
) &&
264 ci
->i_vino
.snap
== CEPH_NOSNAP
&&
266 ci
->i_snap_realm
->ino
== ci
->i_vino
.ino
)
268 spin_unlock(&ci
->i_ceph_lock
);
272 static ssize_t
ceph_vxattrcb_quota(struct ceph_inode_info
*ci
, char *val
,
275 return ceph_fmt_xattr(val
, size
, "max_bytes=%llu max_files=%llu",
276 ci
->i_max_bytes
, ci
->i_max_files
);
279 static ssize_t
ceph_vxattrcb_quota_max_bytes(struct ceph_inode_info
*ci
,
280 char *val
, size_t size
)
282 return ceph_fmt_xattr(val
, size
, "%llu", ci
->i_max_bytes
);
285 static ssize_t
ceph_vxattrcb_quota_max_files(struct ceph_inode_info
*ci
,
286 char *val
, size_t size
)
288 return ceph_fmt_xattr(val
, size
, "%llu", ci
->i_max_files
);
292 static bool ceph_vxattrcb_snap_btime_exists(struct ceph_inode_info
*ci
)
294 return (ci
->i_snap_btime
.tv_sec
!= 0 || ci
->i_snap_btime
.tv_nsec
!= 0);
297 static ssize_t
ceph_vxattrcb_snap_btime(struct ceph_inode_info
*ci
, char *val
,
300 return ceph_fmt_xattr(val
, size
, "%lld.%09ld", ci
->i_snap_btime
.tv_sec
,
301 ci
->i_snap_btime
.tv_nsec
);
304 #define CEPH_XATTR_NAME(_type, _name) XATTR_CEPH_PREFIX #_type "." #_name
305 #define CEPH_XATTR_NAME2(_type, _name, _name2) \
306 XATTR_CEPH_PREFIX #_type "." #_name "." #_name2
308 #define XATTR_NAME_CEPH(_type, _name, _flags) \
310 .name = CEPH_XATTR_NAME(_type, _name), \
311 .name_size = sizeof (CEPH_XATTR_NAME(_type, _name)), \
312 .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
314 .flags = (VXATTR_FLAG_READONLY | _flags), \
316 #define XATTR_RSTAT_FIELD(_type, _name) \
317 XATTR_NAME_CEPH(_type, _name, VXATTR_FLAG_RSTAT)
318 #define XATTR_LAYOUT_FIELD(_type, _name, _field) \
320 .name = CEPH_XATTR_NAME2(_type, _name, _field), \
321 .name_size = sizeof (CEPH_XATTR_NAME2(_type, _name, _field)), \
322 .getxattr_cb = ceph_vxattrcb_ ## _name ## _ ## _field, \
323 .exists_cb = ceph_vxattrcb_layout_exists, \
324 .flags = VXATTR_FLAG_HIDDEN, \
326 #define XATTR_QUOTA_FIELD(_type, _name) \
328 .name = CEPH_XATTR_NAME(_type, _name), \
329 .name_size = sizeof(CEPH_XATTR_NAME(_type, _name)), \
330 .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
331 .exists_cb = ceph_vxattrcb_quota_exists, \
332 .flags = VXATTR_FLAG_HIDDEN, \
335 static struct ceph_vxattr ceph_dir_vxattrs
[] = {
337 .name
= "ceph.dir.layout",
338 .name_size
= sizeof("ceph.dir.layout"),
339 .getxattr_cb
= ceph_vxattrcb_layout
,
340 .exists_cb
= ceph_vxattrcb_layout_exists
,
341 .flags
= VXATTR_FLAG_HIDDEN
,
343 XATTR_LAYOUT_FIELD(dir
, layout
, stripe_unit
),
344 XATTR_LAYOUT_FIELD(dir
, layout
, stripe_count
),
345 XATTR_LAYOUT_FIELD(dir
, layout
, object_size
),
346 XATTR_LAYOUT_FIELD(dir
, layout
, pool
),
347 XATTR_LAYOUT_FIELD(dir
, layout
, pool_namespace
),
348 XATTR_NAME_CEPH(dir
, entries
, 0),
349 XATTR_NAME_CEPH(dir
, files
, 0),
350 XATTR_NAME_CEPH(dir
, subdirs
, 0),
351 XATTR_RSTAT_FIELD(dir
, rentries
),
352 XATTR_RSTAT_FIELD(dir
, rfiles
),
353 XATTR_RSTAT_FIELD(dir
, rsubdirs
),
354 XATTR_RSTAT_FIELD(dir
, rbytes
),
355 XATTR_RSTAT_FIELD(dir
, rctime
),
357 .name
= "ceph.dir.pin",
358 .name_size
= sizeof("ceph.dir.pin"),
359 .getxattr_cb
= ceph_vxattrcb_dir_pin
,
360 .exists_cb
= ceph_vxattrcb_dir_pin_exists
,
361 .flags
= VXATTR_FLAG_HIDDEN
,
364 .name
= "ceph.quota",
365 .name_size
= sizeof("ceph.quota"),
366 .getxattr_cb
= ceph_vxattrcb_quota
,
367 .exists_cb
= ceph_vxattrcb_quota_exists
,
368 .flags
= VXATTR_FLAG_HIDDEN
,
370 XATTR_QUOTA_FIELD(quota
, max_bytes
),
371 XATTR_QUOTA_FIELD(quota
, max_files
),
373 .name
= "ceph.snap.btime",
374 .name_size
= sizeof("ceph.snap.btime"),
375 .getxattr_cb
= ceph_vxattrcb_snap_btime
,
376 .exists_cb
= ceph_vxattrcb_snap_btime_exists
,
377 .flags
= VXATTR_FLAG_READONLY
,
379 { .name
= NULL
, 0 } /* Required table terminator */
384 static struct ceph_vxattr ceph_file_vxattrs
[] = {
386 .name
= "ceph.file.layout",
387 .name_size
= sizeof("ceph.file.layout"),
388 .getxattr_cb
= ceph_vxattrcb_layout
,
389 .exists_cb
= ceph_vxattrcb_layout_exists
,
390 .flags
= VXATTR_FLAG_HIDDEN
,
392 XATTR_LAYOUT_FIELD(file
, layout
, stripe_unit
),
393 XATTR_LAYOUT_FIELD(file
, layout
, stripe_count
),
394 XATTR_LAYOUT_FIELD(file
, layout
, object_size
),
395 XATTR_LAYOUT_FIELD(file
, layout
, pool
),
396 XATTR_LAYOUT_FIELD(file
, layout
, pool_namespace
),
398 .name
= "ceph.snap.btime",
399 .name_size
= sizeof("ceph.snap.btime"),
400 .getxattr_cb
= ceph_vxattrcb_snap_btime
,
401 .exists_cb
= ceph_vxattrcb_snap_btime_exists
,
402 .flags
= VXATTR_FLAG_READONLY
,
404 { .name
= NULL
, 0 } /* Required table terminator */
407 static struct ceph_vxattr
*ceph_inode_vxattrs(struct inode
*inode
)
409 if (S_ISDIR(inode
->i_mode
))
410 return ceph_dir_vxattrs
;
411 else if (S_ISREG(inode
->i_mode
))
412 return ceph_file_vxattrs
;
416 static struct ceph_vxattr
*ceph_match_vxattr(struct inode
*inode
,
419 struct ceph_vxattr
*vxattr
= ceph_inode_vxattrs(inode
);
422 while (vxattr
->name
) {
423 if (!strcmp(vxattr
->name
, name
))
432 static int __set_xattr(struct ceph_inode_info
*ci
,
433 const char *name
, int name_len
,
434 const char *val
, int val_len
,
435 int flags
, int update_xattr
,
436 struct ceph_inode_xattr
**newxattr
)
439 struct rb_node
*parent
= NULL
;
440 struct ceph_inode_xattr
*xattr
= NULL
;
444 p
= &ci
->i_xattrs
.index
.rb_node
;
447 xattr
= rb_entry(parent
, struct ceph_inode_xattr
, node
);
448 c
= strncmp(name
, xattr
->name
, min(name_len
, xattr
->name_len
));
454 if (name_len
== xattr
->name_len
)
456 else if (name_len
< xattr
->name_len
)
467 if (xattr
&& (flags
& XATTR_CREATE
))
469 else if (!xattr
&& (flags
& XATTR_REPLACE
))
477 if (update_xattr
< 0) {
479 __remove_xattr(ci
, xattr
);
490 xattr
->name_len
= name_len
;
491 xattr
->should_free_name
= update_xattr
;
493 ci
->i_xattrs
.count
++;
494 dout("__set_xattr count=%d\n", ci
->i_xattrs
.count
);
498 if (xattr
->should_free_val
)
499 kfree((void *)xattr
->val
);
505 ci
->i_xattrs
.names_size
-= xattr
->name_len
;
506 ci
->i_xattrs
.vals_size
-= xattr
->val_len
;
508 ci
->i_xattrs
.names_size
+= name_len
;
509 ci
->i_xattrs
.vals_size
+= val_len
;
515 xattr
->val_len
= val_len
;
516 xattr
->dirty
= update_xattr
;
517 xattr
->should_free_val
= (val
&& update_xattr
);
520 rb_link_node(&xattr
->node
, parent
, p
);
521 rb_insert_color(&xattr
->node
, &ci
->i_xattrs
.index
);
522 dout("__set_xattr_val p=%p\n", p
);
525 dout("__set_xattr_val added %llx.%llx xattr %p %.*s=%.*s\n",
526 ceph_vinop(&ci
->vfs_inode
), xattr
, name_len
, name
, val_len
, val
);
531 static struct ceph_inode_xattr
*__get_xattr(struct ceph_inode_info
*ci
,
535 struct rb_node
*parent
= NULL
;
536 struct ceph_inode_xattr
*xattr
= NULL
;
537 int name_len
= strlen(name
);
540 p
= &ci
->i_xattrs
.index
.rb_node
;
543 xattr
= rb_entry(parent
, struct ceph_inode_xattr
, node
);
544 c
= strncmp(name
, xattr
->name
, xattr
->name_len
);
545 if (c
== 0 && name_len
> xattr
->name_len
)
552 dout("__get_xattr %s: found %.*s\n", name
,
553 xattr
->val_len
, xattr
->val
);
558 dout("__get_xattr %s: not found\n", name
);
563 static void __free_xattr(struct ceph_inode_xattr
*xattr
)
567 if (xattr
->should_free_name
)
568 kfree((void *)xattr
->name
);
569 if (xattr
->should_free_val
)
570 kfree((void *)xattr
->val
);
575 static int __remove_xattr(struct ceph_inode_info
*ci
,
576 struct ceph_inode_xattr
*xattr
)
581 rb_erase(&xattr
->node
, &ci
->i_xattrs
.index
);
583 if (xattr
->should_free_name
)
584 kfree((void *)xattr
->name
);
585 if (xattr
->should_free_val
)
586 kfree((void *)xattr
->val
);
588 ci
->i_xattrs
.names_size
-= xattr
->name_len
;
589 ci
->i_xattrs
.vals_size
-= xattr
->val_len
;
590 ci
->i_xattrs
.count
--;
596 static char *__copy_xattr_names(struct ceph_inode_info
*ci
,
600 struct ceph_inode_xattr
*xattr
= NULL
;
602 p
= rb_first(&ci
->i_xattrs
.index
);
603 dout("__copy_xattr_names count=%d\n", ci
->i_xattrs
.count
);
606 xattr
= rb_entry(p
, struct ceph_inode_xattr
, node
);
607 memcpy(dest
, xattr
->name
, xattr
->name_len
);
608 dest
[xattr
->name_len
] = '\0';
610 dout("dest=%s %p (%s) (%d/%d)\n", dest
, xattr
, xattr
->name
,
611 xattr
->name_len
, ci
->i_xattrs
.names_size
);
613 dest
+= xattr
->name_len
+ 1;
620 void __ceph_destroy_xattrs(struct ceph_inode_info
*ci
)
622 struct rb_node
*p
, *tmp
;
623 struct ceph_inode_xattr
*xattr
= NULL
;
625 p
= rb_first(&ci
->i_xattrs
.index
);
627 dout("__ceph_destroy_xattrs p=%p\n", p
);
630 xattr
= rb_entry(p
, struct ceph_inode_xattr
, node
);
633 dout("__ceph_destroy_xattrs next p=%p (%.*s)\n", p
,
634 xattr
->name_len
, xattr
->name
);
635 rb_erase(tmp
, &ci
->i_xattrs
.index
);
640 ci
->i_xattrs
.names_size
= 0;
641 ci
->i_xattrs
.vals_size
= 0;
642 ci
->i_xattrs
.index_version
= 0;
643 ci
->i_xattrs
.count
= 0;
644 ci
->i_xattrs
.index
= RB_ROOT
;
647 static int __build_xattrs(struct inode
*inode
)
648 __releases(ci
->i_ceph_lock
)
649 __acquires(ci
->i_ceph_lock
)
655 const char *name
, *val
;
656 struct ceph_inode_info
*ci
= ceph_inode(inode
);
658 struct ceph_inode_xattr
**xattrs
= NULL
;
662 dout("__build_xattrs() len=%d\n",
663 ci
->i_xattrs
.blob
? (int)ci
->i_xattrs
.blob
->vec
.iov_len
: 0);
665 if (ci
->i_xattrs
.index_version
>= ci
->i_xattrs
.version
)
666 return 0; /* already built */
668 __ceph_destroy_xattrs(ci
);
671 /* updated internal xattr rb tree */
672 if (ci
->i_xattrs
.blob
&& ci
->i_xattrs
.blob
->vec
.iov_len
> 4) {
673 p
= ci
->i_xattrs
.blob
->vec
.iov_base
;
674 end
= p
+ ci
->i_xattrs
.blob
->vec
.iov_len
;
675 ceph_decode_32_safe(&p
, end
, numattr
, bad
);
676 xattr_version
= ci
->i_xattrs
.version
;
677 spin_unlock(&ci
->i_ceph_lock
);
679 xattrs
= kcalloc(numattr
, sizeof(struct ceph_inode_xattr
*),
685 for (i
= 0; i
< numattr
; i
++) {
686 xattrs
[i
] = kmalloc(sizeof(struct ceph_inode_xattr
),
692 spin_lock(&ci
->i_ceph_lock
);
693 if (ci
->i_xattrs
.version
!= xattr_version
) {
694 /* lost a race, retry */
695 for (i
= 0; i
< numattr
; i
++)
703 ceph_decode_32_safe(&p
, end
, len
, bad
);
707 ceph_decode_32_safe(&p
, end
, len
, bad
);
711 err
= __set_xattr(ci
, name
, namelen
, val
, len
,
712 0, 0, &xattrs
[numattr
]);
719 ci
->i_xattrs
.index_version
= ci
->i_xattrs
.version
;
720 ci
->i_xattrs
.dirty
= false;
724 spin_lock(&ci
->i_ceph_lock
);
727 for (i
= 0; i
< numattr
; i
++)
731 ci
->i_xattrs
.names_size
= 0;
735 static int __get_required_blob_size(struct ceph_inode_info
*ci
, int name_size
,
739 * 4 bytes for the length, and additional 4 bytes per each xattr name,
740 * 4 bytes per each value
742 int size
= 4 + ci
->i_xattrs
.count
*(4 + 4) +
743 ci
->i_xattrs
.names_size
+
744 ci
->i_xattrs
.vals_size
;
745 dout("__get_required_blob_size c=%d names.size=%d vals.size=%d\n",
746 ci
->i_xattrs
.count
, ci
->i_xattrs
.names_size
,
747 ci
->i_xattrs
.vals_size
);
750 size
+= 4 + 4 + name_size
+ val_size
;
756 * If there are dirty xattrs, reencode xattrs into the prealloc_blob
757 * and swap into place. It returns the old i_xattrs.blob (or NULL) so
758 * that it can be freed by the caller as the i_ceph_lock is likely to be
761 struct ceph_buffer
*__ceph_build_xattrs_blob(struct ceph_inode_info
*ci
)
764 struct ceph_inode_xattr
*xattr
= NULL
;
765 struct ceph_buffer
*old_blob
= NULL
;
768 dout("__build_xattrs_blob %p\n", &ci
->vfs_inode
);
769 if (ci
->i_xattrs
.dirty
) {
770 int need
= __get_required_blob_size(ci
, 0, 0);
772 BUG_ON(need
> ci
->i_xattrs
.prealloc_blob
->alloc_len
);
774 p
= rb_first(&ci
->i_xattrs
.index
);
775 dest
= ci
->i_xattrs
.prealloc_blob
->vec
.iov_base
;
777 ceph_encode_32(&dest
, ci
->i_xattrs
.count
);
779 xattr
= rb_entry(p
, struct ceph_inode_xattr
, node
);
781 ceph_encode_32(&dest
, xattr
->name_len
);
782 memcpy(dest
, xattr
->name
, xattr
->name_len
);
783 dest
+= xattr
->name_len
;
784 ceph_encode_32(&dest
, xattr
->val_len
);
785 memcpy(dest
, xattr
->val
, xattr
->val_len
);
786 dest
+= xattr
->val_len
;
791 /* adjust buffer len; it may be larger than we need */
792 ci
->i_xattrs
.prealloc_blob
->vec
.iov_len
=
793 dest
- ci
->i_xattrs
.prealloc_blob
->vec
.iov_base
;
795 if (ci
->i_xattrs
.blob
)
796 old_blob
= ci
->i_xattrs
.blob
;
797 ci
->i_xattrs
.blob
= ci
->i_xattrs
.prealloc_blob
;
798 ci
->i_xattrs
.prealloc_blob
= NULL
;
799 ci
->i_xattrs
.dirty
= false;
800 ci
->i_xattrs
.version
++;
806 static inline int __get_request_mask(struct inode
*in
) {
807 struct ceph_mds_request
*req
= current
->journal_info
;
809 if (req
&& req
->r_target_inode
== in
) {
810 if (req
->r_op
== CEPH_MDS_OP_LOOKUP
||
811 req
->r_op
== CEPH_MDS_OP_LOOKUPINO
||
812 req
->r_op
== CEPH_MDS_OP_LOOKUPPARENT
||
813 req
->r_op
== CEPH_MDS_OP_GETATTR
) {
814 mask
= le32_to_cpu(req
->r_args
.getattr
.mask
);
815 } else if (req
->r_op
== CEPH_MDS_OP_OPEN
||
816 req
->r_op
== CEPH_MDS_OP_CREATE
) {
817 mask
= le32_to_cpu(req
->r_args
.open
.mask
);
823 ssize_t
__ceph_getxattr(struct inode
*inode
, const char *name
, void *value
,
826 struct ceph_inode_info
*ci
= ceph_inode(inode
);
827 struct ceph_inode_xattr
*xattr
;
828 struct ceph_vxattr
*vxattr
= NULL
;
832 /* let's see if a virtual xattr was requested */
833 vxattr
= ceph_match_vxattr(inode
, name
);
836 if (vxattr
->flags
& VXATTR_FLAG_RSTAT
)
837 mask
|= CEPH_STAT_RSTAT
;
838 err
= ceph_do_getattr(inode
, mask
, true);
842 if (!(vxattr
->exists_cb
&& !vxattr
->exists_cb(ci
))) {
843 err
= vxattr
->getxattr_cb(ci
, value
, size
);
844 if (size
&& size
< err
)
850 req_mask
= __get_request_mask(inode
);
852 spin_lock(&ci
->i_ceph_lock
);
853 dout("getxattr %p ver=%lld index_ver=%lld\n", inode
,
854 ci
->i_xattrs
.version
, ci
->i_xattrs
.index_version
);
856 if (ci
->i_xattrs
.version
== 0 ||
857 !((req_mask
& CEPH_CAP_XATTR_SHARED
) ||
858 __ceph_caps_issued_mask(ci
, CEPH_CAP_XATTR_SHARED
, 1))) {
859 spin_unlock(&ci
->i_ceph_lock
);
861 /* security module gets xattr while filling trace */
862 if (current
->journal_info
) {
863 pr_warn_ratelimited("sync getxattr %p "
864 "during filling trace\n", inode
);
868 /* get xattrs from mds (if we don't already have them) */
869 err
= ceph_do_getattr(inode
, CEPH_STAT_CAP_XATTR
, true);
872 spin_lock(&ci
->i_ceph_lock
);
875 err
= __build_xattrs(inode
);
879 err
= -ENODATA
; /* == ENOATTR */
880 xattr
= __get_xattr(ci
, name
);
885 if (size
&& size
< xattr
->val_len
)
888 err
= xattr
->val_len
;
892 memcpy(value
, xattr
->val
, xattr
->val_len
);
894 if (current
->journal_info
&&
895 !strncmp(name
, XATTR_SECURITY_PREFIX
, XATTR_SECURITY_PREFIX_LEN
))
896 ci
->i_ceph_flags
|= CEPH_I_SEC_INITED
;
898 spin_unlock(&ci
->i_ceph_lock
);
902 ssize_t
ceph_listxattr(struct dentry
*dentry
, char *names
, size_t size
)
904 struct inode
*inode
= d_inode(dentry
);
905 struct ceph_inode_info
*ci
= ceph_inode(inode
);
906 struct ceph_vxattr
*vxattrs
= ceph_inode_vxattrs(inode
);
907 bool len_only
= (size
== 0);
912 spin_lock(&ci
->i_ceph_lock
);
913 dout("listxattr %p ver=%lld index_ver=%lld\n", inode
,
914 ci
->i_xattrs
.version
, ci
->i_xattrs
.index_version
);
916 if (ci
->i_xattrs
.version
== 0 ||
917 !__ceph_caps_issued_mask(ci
, CEPH_CAP_XATTR_SHARED
, 1)) {
918 spin_unlock(&ci
->i_ceph_lock
);
919 err
= ceph_do_getattr(inode
, CEPH_STAT_CAP_XATTR
, true);
922 spin_lock(&ci
->i_ceph_lock
);
925 err
= __build_xattrs(inode
);
929 /* add 1 byte for each xattr due to the null termination */
930 namelen
= ci
->i_xattrs
.names_size
+ ci
->i_xattrs
.count
;
932 if (namelen
> size
) {
936 names
= __copy_xattr_names(ci
, names
);
941 /* virtual xattr names, too */
943 for (i
= 0; vxattrs
[i
].name
; i
++) {
946 if (vxattrs
[i
].flags
& VXATTR_FLAG_HIDDEN
)
948 if (vxattrs
[i
].exists_cb
&& !vxattrs
[i
].exists_cb(ci
))
951 this_len
= strlen(vxattrs
[i
].name
) + 1;
956 if (this_len
> size
) {
961 memcpy(names
, vxattrs
[i
].name
, this_len
);
968 spin_unlock(&ci
->i_ceph_lock
);
972 static int ceph_sync_setxattr(struct inode
*inode
, const char *name
,
973 const char *value
, size_t size
, int flags
)
975 struct ceph_fs_client
*fsc
= ceph_sb_to_client(inode
->i_sb
);
976 struct ceph_inode_info
*ci
= ceph_inode(inode
);
977 struct ceph_mds_request
*req
;
978 struct ceph_mds_client
*mdsc
= fsc
->mdsc
;
979 struct ceph_pagelist
*pagelist
= NULL
;
980 int op
= CEPH_MDS_OP_SETXATTR
;
984 /* copy value into pagelist */
985 pagelist
= ceph_pagelist_alloc(GFP_NOFS
);
989 err
= ceph_pagelist_append(pagelist
, value
, size
);
993 if (flags
& CEPH_XATTR_REPLACE
)
994 op
= CEPH_MDS_OP_RMXATTR
;
996 flags
|= CEPH_XATTR_REMOVE
;
999 dout("setxattr value=%.*s\n", (int)size
, value
);
1002 req
= ceph_mdsc_create_request(mdsc
, op
, USE_AUTH_MDS
);
1008 req
->r_path2
= kstrdup(name
, GFP_NOFS
);
1009 if (!req
->r_path2
) {
1010 ceph_mdsc_put_request(req
);
1015 if (op
== CEPH_MDS_OP_SETXATTR
) {
1016 req
->r_args
.setxattr
.flags
= cpu_to_le32(flags
);
1017 req
->r_pagelist
= pagelist
;
1021 req
->r_inode
= inode
;
1023 req
->r_num_caps
= 1;
1024 req
->r_inode_drop
= CEPH_CAP_XATTR_SHARED
;
1026 dout("xattr.ver (before): %lld\n", ci
->i_xattrs
.version
);
1027 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
1028 ceph_mdsc_put_request(req
);
1029 dout("xattr.ver (after): %lld\n", ci
->i_xattrs
.version
);
1033 ceph_pagelist_release(pagelist
);
1037 int __ceph_setxattr(struct inode
*inode
, const char *name
,
1038 const void *value
, size_t size
, int flags
)
1040 struct ceph_vxattr
*vxattr
;
1041 struct ceph_inode_info
*ci
= ceph_inode(inode
);
1042 struct ceph_mds_client
*mdsc
= ceph_sb_to_client(inode
->i_sb
)->mdsc
;
1043 struct ceph_cap_flush
*prealloc_cf
= NULL
;
1044 struct ceph_buffer
*old_blob
= NULL
;
1048 int name_len
= strlen(name
);
1050 char *newname
= NULL
;
1051 char *newval
= NULL
;
1052 struct ceph_inode_xattr
*xattr
= NULL
;
1053 int required_blob_size
;
1054 bool check_realm
= false;
1055 bool lock_snap_rwsem
= false;
1057 if (ceph_snap(inode
) != CEPH_NOSNAP
)
1060 vxattr
= ceph_match_vxattr(inode
, name
);
1062 if (vxattr
->flags
& VXATTR_FLAG_READONLY
)
1064 if (value
&& !strncmp(vxattr
->name
, "ceph.quota", 10))
1068 /* pass any unhandled ceph.* xattrs through to the MDS */
1069 if (!strncmp(name
, XATTR_CEPH_PREFIX
, XATTR_CEPH_PREFIX_LEN
))
1070 goto do_sync_unlocked
;
1072 /* preallocate memory for xattr name, value, index node */
1074 newname
= kmemdup(name
, name_len
+ 1, GFP_NOFS
);
1079 newval
= kmemdup(value
, val_len
, GFP_NOFS
);
1084 xattr
= kmalloc(sizeof(struct ceph_inode_xattr
), GFP_NOFS
);
1088 prealloc_cf
= ceph_alloc_cap_flush();
1092 spin_lock(&ci
->i_ceph_lock
);
1094 issued
= __ceph_caps_issued(ci
, NULL
);
1095 if (ci
->i_xattrs
.version
== 0 || !(issued
& CEPH_CAP_XATTR_EXCL
))
1098 if (!lock_snap_rwsem
&& !ci
->i_head_snapc
) {
1099 lock_snap_rwsem
= true;
1100 if (!down_read_trylock(&mdsc
->snap_rwsem
)) {
1101 spin_unlock(&ci
->i_ceph_lock
);
1102 down_read(&mdsc
->snap_rwsem
);
1103 spin_lock(&ci
->i_ceph_lock
);
1108 dout("setxattr %p issued %s\n", inode
, ceph_cap_string(issued
));
1109 __build_xattrs(inode
);
1111 required_blob_size
= __get_required_blob_size(ci
, name_len
, val_len
);
1113 if (!ci
->i_xattrs
.prealloc_blob
||
1114 required_blob_size
> ci
->i_xattrs
.prealloc_blob
->alloc_len
) {
1115 struct ceph_buffer
*blob
;
1117 spin_unlock(&ci
->i_ceph_lock
);
1118 ceph_buffer_put(old_blob
); /* Shouldn't be required */
1119 dout(" pre-allocating new blob size=%d\n", required_blob_size
);
1120 blob
= ceph_buffer_new(required_blob_size
, GFP_NOFS
);
1122 goto do_sync_unlocked
;
1123 spin_lock(&ci
->i_ceph_lock
);
1124 /* prealloc_blob can't be released while holding i_ceph_lock */
1125 if (ci
->i_xattrs
.prealloc_blob
)
1126 old_blob
= ci
->i_xattrs
.prealloc_blob
;
1127 ci
->i_xattrs
.prealloc_blob
= blob
;
1131 err
= __set_xattr(ci
, newname
, name_len
, newval
, val_len
,
1132 flags
, value
? 1 : -1, &xattr
);
1135 dirty
= __ceph_mark_dirty_caps(ci
, CEPH_CAP_XATTR_EXCL
,
1137 ci
->i_xattrs
.dirty
= true;
1138 inode
->i_ctime
= current_time(inode
);
1141 spin_unlock(&ci
->i_ceph_lock
);
1142 ceph_buffer_put(old_blob
);
1143 if (lock_snap_rwsem
)
1144 up_read(&mdsc
->snap_rwsem
);
1146 __mark_inode_dirty(inode
, dirty
);
1147 ceph_free_cap_flush(prealloc_cf
);
1151 spin_unlock(&ci
->i_ceph_lock
);
1153 if (lock_snap_rwsem
)
1154 up_read(&mdsc
->snap_rwsem
);
1156 /* security module set xattr while filling trace */
1157 if (current
->journal_info
) {
1158 pr_warn_ratelimited("sync setxattr %p "
1159 "during filling trace\n", inode
);
1162 err
= ceph_sync_setxattr(inode
, name
, value
, size
, flags
);
1163 if (err
>= 0 && check_realm
) {
1164 /* check if snaprealm was created for quota inode */
1165 spin_lock(&ci
->i_ceph_lock
);
1166 if ((ci
->i_max_files
|| ci
->i_max_bytes
) &&
1167 !(ci
->i_snap_realm
&&
1168 ci
->i_snap_realm
->ino
== ci
->i_vino
.ino
))
1170 spin_unlock(&ci
->i_ceph_lock
);
1174 ceph_free_cap_flush(prealloc_cf
);
1181 static int ceph_get_xattr_handler(const struct xattr_handler
*handler
,
1182 struct dentry
*dentry
, struct inode
*inode
,
1183 const char *name
, void *value
, size_t size
)
1185 if (!ceph_is_valid_xattr(name
))
1187 return __ceph_getxattr(inode
, name
, value
, size
);
1190 static int ceph_set_xattr_handler(const struct xattr_handler
*handler
,
1191 struct dentry
*unused
, struct inode
*inode
,
1192 const char *name
, const void *value
,
1193 size_t size
, int flags
)
1195 if (!ceph_is_valid_xattr(name
))
1197 return __ceph_setxattr(inode
, name
, value
, size
, flags
);
1200 static const struct xattr_handler ceph_other_xattr_handler
= {
1201 .prefix
= "", /* match any name => handlers called with full name */
1202 .get
= ceph_get_xattr_handler
,
1203 .set
= ceph_set_xattr_handler
,
1206 #ifdef CONFIG_SECURITY
1207 bool ceph_security_xattr_wanted(struct inode
*in
)
1209 return in
->i_security
!= NULL
;
1212 bool ceph_security_xattr_deadlock(struct inode
*in
)
1214 struct ceph_inode_info
*ci
;
1216 if (!in
->i_security
)
1218 ci
= ceph_inode(in
);
1219 spin_lock(&ci
->i_ceph_lock
);
1220 ret
= !(ci
->i_ceph_flags
& CEPH_I_SEC_INITED
) &&
1221 !(ci
->i_xattrs
.version
> 0 &&
1222 __ceph_caps_issued_mask(ci
, CEPH_CAP_XATTR_SHARED
, 0));
1223 spin_unlock(&ci
->i_ceph_lock
);
1227 #ifdef CONFIG_CEPH_FS_SECURITY_LABEL
1228 int ceph_security_init_secctx(struct dentry
*dentry
, umode_t mode
,
1229 struct ceph_acl_sec_ctx
*as_ctx
)
1231 struct ceph_pagelist
*pagelist
= as_ctx
->pagelist
;
1236 err
= security_dentry_init_security(dentry
, mode
, &dentry
->d_name
,
1238 &as_ctx
->sec_ctxlen
);
1240 WARN_ON_ONCE(err
!= -EOPNOTSUPP
);
1241 err
= 0; /* do nothing */
1247 pagelist
= ceph_pagelist_alloc(GFP_KERNEL
);
1250 err
= ceph_pagelist_reserve(pagelist
, PAGE_SIZE
);
1253 ceph_pagelist_encode_32(pagelist
, 1);
1257 * FIXME: Make security_dentry_init_security() generic. Currently
1258 * It only supports single security module and only selinux has
1259 * dentry_init_security hook.
1261 name
= XATTR_NAME_SELINUX
;
1262 name_len
= strlen(name
);
1263 err
= ceph_pagelist_reserve(pagelist
,
1264 4 * 2 + name_len
+ as_ctx
->sec_ctxlen
);
1268 if (as_ctx
->pagelist
) {
1269 /* update count of KV pairs */
1270 BUG_ON(pagelist
->length
<= sizeof(__le32
));
1271 if (list_is_singular(&pagelist
->head
)) {
1272 le32_add_cpu((__le32
*)pagelist
->mapped_tail
, 1);
1274 struct page
*page
= list_first_entry(&pagelist
->head
,
1276 void *addr
= kmap_atomic(page
);
1277 le32_add_cpu((__le32
*)addr
, 1);
1278 kunmap_atomic(addr
);
1281 as_ctx
->pagelist
= pagelist
;
1284 ceph_pagelist_encode_32(pagelist
, name_len
);
1285 ceph_pagelist_append(pagelist
, name
, name_len
);
1287 ceph_pagelist_encode_32(pagelist
, as_ctx
->sec_ctxlen
);
1288 ceph_pagelist_append(pagelist
, as_ctx
->sec_ctx
, as_ctx
->sec_ctxlen
);
1292 if (pagelist
&& !as_ctx
->pagelist
)
1293 ceph_pagelist_release(pagelist
);
1297 void ceph_security_invalidate_secctx(struct inode
*inode
)
1299 security_inode_invalidate_secctx(inode
);
1302 static int ceph_xattr_set_security_label(const struct xattr_handler
*handler
,
1303 struct dentry
*unused
, struct inode
*inode
,
1304 const char *key
, const void *buf
,
1305 size_t buflen
, int flags
)
1307 if (security_ismaclabel(key
)) {
1308 const char *name
= xattr_full_name(handler
, key
);
1309 return __ceph_setxattr(inode
, name
, buf
, buflen
, flags
);
1314 static int ceph_xattr_get_security_label(const struct xattr_handler
*handler
,
1315 struct dentry
*unused
, struct inode
*inode
,
1316 const char *key
, void *buf
, size_t buflen
)
1318 if (security_ismaclabel(key
)) {
1319 const char *name
= xattr_full_name(handler
, key
);
1320 return __ceph_getxattr(inode
, name
, buf
, buflen
);
1325 static const struct xattr_handler ceph_security_label_handler
= {
1326 .prefix
= XATTR_SECURITY_PREFIX
,
1327 .get
= ceph_xattr_get_security_label
,
1328 .set
= ceph_xattr_set_security_label
,
1333 void ceph_release_acl_sec_ctx(struct ceph_acl_sec_ctx
*as_ctx
)
1335 #ifdef CONFIG_CEPH_FS_POSIX_ACL
1336 posix_acl_release(as_ctx
->acl
);
1337 posix_acl_release(as_ctx
->default_acl
);
1339 #ifdef CONFIG_CEPH_FS_SECURITY_LABEL
1340 security_release_secctx(as_ctx
->sec_ctx
, as_ctx
->sec_ctxlen
);
1342 if (as_ctx
->pagelist
)
1343 ceph_pagelist_release(as_ctx
->pagelist
);
1347 * List of handlers for synthetic system.* attributes. Other
1348 * attributes are handled directly.
1350 const struct xattr_handler
*ceph_xattr_handlers
[] = {
1351 #ifdef CONFIG_CEPH_FS_POSIX_ACL
1352 &posix_acl_access_xattr_handler
,
1353 &posix_acl_default_xattr_handler
,
1355 #ifdef CONFIG_CEPH_FS_SECURITY_LABEL
1356 &ceph_security_label_handler
,
1358 &ceph_other_xattr_handler
,