]>
git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - drivers/staging/lustre/lustre/llite/xattr.c
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
38 #include <linux/sched.h>
40 #include <linux/selinux.h>
42 #define DEBUG_SUBSYSTEM S_LLITE
44 #include "../include/obd_support.h"
45 #include "../include/lustre_lite.h"
46 #include "../include/lustre_dlm.h"
47 #include "../include/lustre_ver.h"
48 #include "../include/lustre_eacl.h"
50 #include "llite_internal.h"
52 #define XATTR_USER_T (1)
53 #define XATTR_TRUSTED_T (2)
54 #define XATTR_SECURITY_T (3)
55 #define XATTR_ACL_ACCESS_T (4)
56 #define XATTR_ACL_DEFAULT_T (5)
57 #define XATTR_LUSTRE_T (6)
58 #define XATTR_OTHER_T (7)
61 int get_xattr_type(const char *name
)
63 if (!strcmp(name
, POSIX_ACL_XATTR_ACCESS
))
64 return XATTR_ACL_ACCESS_T
;
66 if (!strcmp(name
, POSIX_ACL_XATTR_DEFAULT
))
67 return XATTR_ACL_DEFAULT_T
;
69 if (!strncmp(name
, XATTR_USER_PREFIX
,
70 sizeof(XATTR_USER_PREFIX
) - 1))
73 if (!strncmp(name
, XATTR_TRUSTED_PREFIX
,
74 sizeof(XATTR_TRUSTED_PREFIX
) - 1))
75 return XATTR_TRUSTED_T
;
77 if (!strncmp(name
, XATTR_SECURITY_PREFIX
,
78 sizeof(XATTR_SECURITY_PREFIX
) - 1))
79 return XATTR_SECURITY_T
;
81 if (!strncmp(name
, XATTR_LUSTRE_PREFIX
,
82 sizeof(XATTR_LUSTRE_PREFIX
) - 1))
83 return XATTR_LUSTRE_T
;
89 int xattr_type_filter(struct ll_sb_info
*sbi
, int xattr_type
)
91 if ((xattr_type
== XATTR_ACL_ACCESS_T
||
92 xattr_type
== XATTR_ACL_DEFAULT_T
) &&
93 !(sbi
->ll_flags
& LL_SBI_ACL
))
96 if (xattr_type
== XATTR_USER_T
&& !(sbi
->ll_flags
& LL_SBI_USER_XATTR
))
98 if (xattr_type
== XATTR_TRUSTED_T
&& !capable(CFS_CAP_SYS_ADMIN
))
100 if (xattr_type
== XATTR_OTHER_T
)
107 int ll_setxattr_common(struct inode
*inode
, const char *name
,
108 const void *value
, size_t size
,
109 int flags
, __u64 valid
)
111 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
112 struct ptlrpc_request
*req
= NULL
;
115 #ifdef CONFIG_FS_POSIX_ACL
116 struct rmtacl_ctl_entry
*rce
= NULL
;
117 posix_acl_xattr_header
*new_value
= NULL
;
118 ext_acl_xattr_header
*acl
= NULL
;
120 const char *pv
= value
;
122 xattr_type
= get_xattr_type(name
);
123 rc
= xattr_type_filter(sbi
, xattr_type
);
127 if ((xattr_type
== XATTR_ACL_ACCESS_T
||
128 xattr_type
== XATTR_ACL_DEFAULT_T
) &&
129 !inode_owner_or_capable(inode
))
132 /* b10667: ignore lustre special xattr for now */
133 if ((xattr_type
== XATTR_TRUSTED_T
&& strcmp(name
, "trusted.lov") == 0) ||
134 (xattr_type
== XATTR_LUSTRE_T
&& strcmp(name
, "lustre.lov") == 0))
137 /* b15587: ignore security.capability xattr for now */
138 if ((xattr_type
== XATTR_SECURITY_T
&&
139 strcmp(name
, "security.capability") == 0))
142 /* LU-549: Disable security.selinux when selinux is disabled */
143 if (xattr_type
== XATTR_SECURITY_T
&& !selinux_is_enabled() &&
144 strcmp(name
, "security.selinux") == 0)
147 #ifdef CONFIG_FS_POSIX_ACL
148 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
&&
149 (xattr_type
== XATTR_ACL_ACCESS_T
||
150 xattr_type
== XATTR_ACL_DEFAULT_T
)) {
151 rce
= rct_search(&sbi
->ll_rct
, current_pid());
153 (rce
->rce_ops
!= RMT_LSETFACL
&&
154 rce
->rce_ops
!= RMT_RSETFACL
))
157 if (rce
->rce_ops
== RMT_LSETFACL
) {
158 struct eacl_entry
*ee
;
160 ee
= et_search_del(&sbi
->ll_et
, current_pid(),
161 ll_inode2fid(inode
), xattr_type
);
163 if (valid
& OBD_MD_FLXATTR
) {
164 acl
= lustre_acl_xattr_merge2ext(
165 (posix_acl_xattr_header
*)value
,
171 size
= CFS_ACL_XATTR_SIZE(\
172 le32_to_cpu(acl
->a_count
), \
174 pv
= (const char *)acl
;
177 } else if (rce
->rce_ops
== RMT_RSETFACL
) {
178 size
= lustre_posix_acl_xattr_filter(
179 (posix_acl_xattr_header
*)value
,
181 if (unlikely(size
< 0))
184 pv
= (const char *)new_value
;
188 valid
|= rce_ops2valid(rce
->rce_ops
);
191 oc
= ll_mdscapa_get(inode
);
192 rc
= md_setxattr(sbi
->ll_md_exp
, ll_inode2fid(inode
), oc
,
193 valid
, name
, pv
, size
, 0, flags
,
194 ll_i2suppgid(inode
), &req
);
196 #ifdef CONFIG_FS_POSIX_ACL
197 if (new_value
!= NULL
)
198 lustre_posix_acl_xattr_free(new_value
, size
);
200 lustre_ext_acl_xattr_free(acl
);
203 if (rc
== -EOPNOTSUPP
&& xattr_type
== XATTR_USER_T
) {
204 LCONSOLE_INFO("Disabling user_xattr feature because "
205 "it is not supported on the server\n");
206 sbi
->ll_flags
&= ~LL_SBI_USER_XATTR
;
211 ptlrpc_req_finished(req
);
215 int ll_setxattr(struct dentry
*dentry
, const char *name
,
216 const void *value
, size_t size
, int flags
)
218 struct inode
*inode
= dentry
->d_inode
;
223 CDEBUG(D_VFSTRACE
, "VFS Op:inode=%lu/%u(%p), xattr %s\n",
224 inode
->i_ino
, inode
->i_generation
, inode
, name
);
226 ll_stats_ops_tally(ll_i2sbi(inode
), LPROC_LL_SETXATTR
, 1);
228 if ((strncmp(name
, XATTR_TRUSTED_PREFIX
,
229 sizeof(XATTR_TRUSTED_PREFIX
) - 1) == 0 &&
230 strcmp(name
+ sizeof(XATTR_TRUSTED_PREFIX
) - 1, "lov") == 0) ||
231 (strncmp(name
, XATTR_LUSTRE_PREFIX
,
232 sizeof(XATTR_LUSTRE_PREFIX
) - 1) == 0 &&
233 strcmp(name
+ sizeof(XATTR_LUSTRE_PREFIX
) - 1, "lov") == 0)) {
234 struct lov_user_md
*lump
= (struct lov_user_md
*)value
;
237 /* Attributes that are saved via getxattr will always have
238 * the stripe_offset as 0. Instead, the MDS should be
239 * allowed to pick the starting OST index. b=17846 */
240 if (lump
!= NULL
&& lump
->lmm_stripe_offset
== 0)
241 lump
->lmm_stripe_offset
= -1;
243 if (lump
!= NULL
&& S_ISREG(inode
->i_mode
)) {
244 int flags
= FMODE_WRITE
;
245 int lum_size
= (lump
->lmm_magic
== LOV_USER_MAGIC_V1
) ?
246 sizeof(*lump
) : sizeof(struct lov_user_md_v3
);
248 rc
= ll_lov_setstripe_ea_info(inode
, dentry
, flags
, lump
,
250 /* b10667: rc always be 0 here for now */
252 } else if (S_ISDIR(inode
->i_mode
)) {
253 rc
= ll_dir_setstripe(inode
, lump
, 0);
258 } else if (strcmp(name
, XATTR_NAME_LMA
) == 0 ||
259 strcmp(name
, XATTR_NAME_LINK
) == 0)
262 return ll_setxattr_common(inode
, name
, value
, size
, flags
,
266 int ll_removexattr(struct dentry
*dentry
, const char *name
)
268 struct inode
*inode
= dentry
->d_inode
;
273 CDEBUG(D_VFSTRACE
, "VFS Op:inode=%lu/%u(%p), xattr %s\n",
274 inode
->i_ino
, inode
->i_generation
, inode
, name
);
276 ll_stats_ops_tally(ll_i2sbi(inode
), LPROC_LL_REMOVEXATTR
, 1);
277 return ll_setxattr_common(inode
, name
, NULL
, 0, 0,
282 int ll_getxattr_common(struct inode
*inode
, const char *name
,
283 void *buffer
, size_t size
, __u64 valid
)
285 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
286 struct ptlrpc_request
*req
= NULL
;
287 struct mdt_body
*body
;
291 struct rmtacl_ctl_entry
*rce
= NULL
;
292 struct ll_inode_info
*lli
= ll_i2info(inode
);
294 CDEBUG(D_VFSTRACE
, "VFS Op:inode=%lu/%u(%p)\n",
295 inode
->i_ino
, inode
->i_generation
, inode
);
297 /* listxattr have slightly different behavior from of ext3:
298 * without 'user_xattr' ext3 will list all xattr names but
299 * filtered out "^user..*"; we list them all for simplicity.
302 xattr_type
= XATTR_OTHER_T
;
306 xattr_type
= get_xattr_type(name
);
307 rc
= xattr_type_filter(sbi
, xattr_type
);
311 /* b15587: ignore security.capability xattr for now */
312 if ((xattr_type
== XATTR_SECURITY_T
&&
313 strcmp(name
, "security.capability") == 0))
316 /* LU-549: Disable security.selinux when selinux is disabled */
317 if (xattr_type
== XATTR_SECURITY_T
&& !selinux_is_enabled() &&
318 strcmp(name
, "security.selinux") == 0)
321 #ifdef CONFIG_FS_POSIX_ACL
322 if (sbi
->ll_flags
& LL_SBI_RMT_CLIENT
&&
323 (xattr_type
== XATTR_ACL_ACCESS_T
||
324 xattr_type
== XATTR_ACL_DEFAULT_T
)) {
325 rce
= rct_search(&sbi
->ll_rct
, current_pid());
327 (rce
->rce_ops
!= RMT_LSETFACL
&&
328 rce
->rce_ops
!= RMT_LGETFACL
&&
329 rce
->rce_ops
!= RMT_RSETFACL
&&
330 rce
->rce_ops
!= RMT_RGETFACL
))
334 /* posix acl is under protection of LOOKUP lock. when calling to this,
335 * we just have path resolution to the target inode, so we have great
336 * chance that cached ACL is uptodate.
338 if (xattr_type
== XATTR_ACL_ACCESS_T
&&
339 !(sbi
->ll_flags
& LL_SBI_RMT_CLIENT
)) {
341 struct posix_acl
*acl
;
343 spin_lock(&lli
->lli_lock
);
344 acl
= posix_acl_dup(lli
->lli_posix_acl
);
345 spin_unlock(&lli
->lli_lock
);
350 rc
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
351 posix_acl_release(acl
);
354 if (xattr_type
== XATTR_ACL_DEFAULT_T
&& !S_ISDIR(inode
->i_mode
))
359 if (sbi
->ll_xattr_cache_enabled
&& xattr_type
!= XATTR_ACL_ACCESS_T
) {
360 rc
= ll_xattr_cache_get(inode
, name
, buffer
, size
, valid
);
362 goto getxattr_nocache
;
366 /* Add "system.posix_acl_access" to the list */
367 if (lli
->lli_posix_acl
!= NULL
&& valid
& OBD_MD_FLXATTRLS
) {
369 rc
+= sizeof(XATTR_NAME_ACL_ACCESS
);
370 } else if (size
- rc
>= sizeof(XATTR_NAME_ACL_ACCESS
)) {
371 memcpy(buffer
+ rc
, XATTR_NAME_ACL_ACCESS
,
372 sizeof(XATTR_NAME_ACL_ACCESS
));
373 rc
+= sizeof(XATTR_NAME_ACL_ACCESS
);
381 oc
= ll_mdscapa_get(inode
);
382 rc
= md_getxattr(sbi
->ll_md_exp
, ll_inode2fid(inode
), oc
,
383 valid
| (rce
? rce_ops2valid(rce
->rce_ops
) : 0),
384 name
, NULL
, 0, size
, 0, &req
);
390 body
= req_capsule_server_get(&req
->rq_pill
, &RMF_MDT_BODY
);
393 /* only detect the xattr size */
395 rc
= body
->eadatasize
;
399 if (size
< body
->eadatasize
) {
400 CERROR("server bug: replied size %u > %u\n",
401 body
->eadatasize
, (int)size
);
406 if (body
->eadatasize
== 0) {
411 /* do not need swab xattr data */
412 xdata
= req_capsule_server_sized_get(&req
->rq_pill
, &RMF_EADATA
,
419 memcpy(buffer
, xdata
, body
->eadatasize
);
420 rc
= body
->eadatasize
;
423 #ifdef CONFIG_FS_POSIX_ACL
424 if (rce
&& rce
->rce_ops
== RMT_LSETFACL
) {
425 ext_acl_xattr_header
*acl
;
427 acl
= lustre_posix_acl_xattr_2ext(
428 (posix_acl_xattr_header
*)buffer
, rc
);
434 rc
= ee_add(&sbi
->ll_et
, current_pid(), ll_inode2fid(inode
),
436 if (unlikely(rc
< 0)) {
437 lustre_ext_acl_xattr_free(acl
);
444 if (rc
== -EOPNOTSUPP
&& xattr_type
== XATTR_USER_T
) {
446 "%s: disabling user_xattr feature because it is not supported on the server: rc = %d\n",
447 ll_get_fsname(inode
->i_sb
, NULL
, 0), rc
);
448 sbi
->ll_flags
&= ~LL_SBI_USER_XATTR
;
451 ptlrpc_req_finished(req
);
455 ssize_t
ll_getxattr(struct dentry
*dentry
, const char *name
,
456 void *buffer
, size_t size
)
458 struct inode
*inode
= dentry
->d_inode
;
463 CDEBUG(D_VFSTRACE
, "VFS Op:inode=%lu/%u(%p), xattr %s\n",
464 inode
->i_ino
, inode
->i_generation
, inode
, name
);
466 ll_stats_ops_tally(ll_i2sbi(inode
), LPROC_LL_GETXATTR
, 1);
468 if ((strncmp(name
, XATTR_TRUSTED_PREFIX
,
469 sizeof(XATTR_TRUSTED_PREFIX
) - 1) == 0 &&
470 strcmp(name
+ sizeof(XATTR_TRUSTED_PREFIX
) - 1, "lov") == 0) ||
471 (strncmp(name
, XATTR_LUSTRE_PREFIX
,
472 sizeof(XATTR_LUSTRE_PREFIX
) - 1) == 0 &&
473 strcmp(name
+ sizeof(XATTR_LUSTRE_PREFIX
) - 1, "lov") == 0)) {
474 struct lov_stripe_md
*lsm
;
475 struct lov_user_md
*lump
;
476 struct lov_mds_md
*lmm
= NULL
;
477 struct ptlrpc_request
*request
= NULL
;
478 int rc
= 0, lmmsize
= 0;
480 if (!S_ISREG(inode
->i_mode
) && !S_ISDIR(inode
->i_mode
))
483 if (size
== 0 && S_ISDIR(inode
->i_mode
)) {
484 /* XXX directory EA is fix for now, optimize to save
486 rc
= sizeof(struct lov_user_md
);
490 lsm
= ccc_inode_lsm_get(inode
);
492 if (S_ISDIR(inode
->i_mode
)) {
493 rc
= ll_dir_getstripe(inode
, &lmm
,
499 /* LSM is present already after lookup/getattr call.
500 * we need to grab layout lock once it is implemented */
501 rc
= obd_packmd(ll_i2dtexp(inode
), &lmm
, lsm
);
504 ccc_inode_lsm_put(inode
, lsm
);
510 /* used to call ll_get_max_mdsize() forward to get
511 * the maximum buffer size, while some apps (such as
512 * rsync 3.0.x) care much about the exact xattr value
518 if (size
< lmmsize
) {
519 CERROR("server bug: replied size %d > %d for %pd (%s)\n",
520 lmmsize
, (int)size
, dentry
, name
);
525 lump
= (struct lov_user_md
*)buffer
;
526 memcpy(lump
, lmm
, lmmsize
);
527 /* do not return layout gen for getxattr otherwise it would
528 * confuse tar --xattr by recognizing layout gen as stripe
529 * offset when the file is restored. See LU-2809. */
530 lump
->lmm_layout_gen
= 0;
535 ptlrpc_req_finished(request
);
537 obd_free_diskmd(ll_i2dtexp(inode
), &lmm
);
541 return ll_getxattr_common(inode
, name
, buffer
, size
, OBD_MD_FLXATTR
);
544 ssize_t
ll_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
546 struct inode
*inode
= dentry
->d_inode
;
548 struct lov_mds_md
*lmm
= NULL
;
549 struct ptlrpc_request
*request
= NULL
;
554 CDEBUG(D_VFSTRACE
, "VFS Op:inode=%lu/%u(%p)\n",
555 inode
->i_ino
, inode
->i_generation
, inode
);
557 ll_stats_ops_tally(ll_i2sbi(inode
), LPROC_LL_LISTXATTR
, 1);
559 rc
= ll_getxattr_common(inode
, NULL
, buffer
, size
, OBD_MD_FLXATTRLS
);
563 if (buffer
!= NULL
) {
564 struct ll_sb_info
*sbi
= ll_i2sbi(inode
);
565 char *xattr_name
= buffer
;
569 xlen
= strnlen(xattr_name
, rem
- 1) + 1;
571 if (xattr_type_filter(sbi
,
572 get_xattr_type(xattr_name
)) == 0) {
573 /* skip OK xattr type
579 /* move up remaining xattrs in buffer
580 * removing the xattr that is not OK
582 memmove(xattr_name
, xattr_name
+ xlen
, rem
);
586 if (S_ISREG(inode
->i_mode
)) {
587 if (!ll_i2info(inode
)->lli_has_smd
)
589 } else if (S_ISDIR(inode
->i_mode
)) {
590 rc2
= ll_dir_getstripe(inode
, &lmm
, &lmmsize
, &request
);
596 } else if (S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
)) {
597 const int prefix_len
= sizeof(XATTR_LUSTRE_PREFIX
) - 1;
598 const size_t name_len
= sizeof("lov") - 1;
599 const size_t total_len
= prefix_len
+ name_len
+ 1;
601 if (((rc
+ total_len
) > size
) && (buffer
!= NULL
)) {
602 ptlrpc_req_finished(request
);
606 if (buffer
!= NULL
) {
608 memcpy(buffer
, XATTR_LUSTRE_PREFIX
, prefix_len
);
609 memcpy(buffer
+ prefix_len
, "lov", name_len
);
610 buffer
[prefix_len
+ name_len
] = '\0';
615 ptlrpc_req_finished(request
);