Whamcloud - gitweb
LU-4353 strncmp: Replace incorrect strncmp()s with strcmp()
[fs/lustre-release.git] / lustre / mdt / mdt_xattr.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
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.
9  *
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).
15  *
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
19  *
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
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2013, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/mdt/mdt_xattr.c
37  *
38  * Lustre Metadata Target (mdt) extended attributes management.
39  *
40  * Author: Peter Braam <braam@clusterfs.com>
41  * Author: Andreas Dilger <adilger@clusterfs.com>
42  * Author: Phil Schwan <phil@clusterfs.com>
43  * Author: Huang Hua <huanghua@clusterfs.com>
44  */
45
46 #define DEBUG_SUBSYSTEM S_MDS
47
48 #include <lustre_acl.h>
49 #include "mdt_internal.h"
50
51
52 /* return EADATA length to the caller. negative value means error */
53 static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
54 {
55         struct req_capsule     *pill = info->mti_pill ;
56         struct ptlrpc_request  *req = mdt_info_req(info);
57         char                   *xattr_name;
58         __u64                   valid;
59         static const char       user_string[] = "user.";
60         int                     size, rc;
61         ENTRY;
62
63         if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
64                 RETURN(-ENOMEM);
65
66         valid = info->mti_body->valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
67
68         /* Determine how many bytes we need */
69         if (valid == OBD_MD_FLXATTR) {
70                 xattr_name = req_capsule_client_get(pill, &RMF_NAME);
71                 if (!xattr_name)
72                         RETURN(-EFAULT);
73
74                 if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR) &&
75                     !strncmp(xattr_name, user_string, sizeof(user_string) - 1))
76                         RETURN(-EOPNOTSUPP);
77
78                 size = mo_xattr_get(info->mti_env,
79                                     mdt_object_child(info->mti_object),
80                                     &LU_BUF_NULL, xattr_name);
81         } else if (valid == OBD_MD_FLXATTRLS) {
82                 size = mo_xattr_list(info->mti_env,
83                                      mdt_object_child(info->mti_object),
84                                      &LU_BUF_NULL);
85         } else if (valid == OBD_MD_FLXATTRALL) {
86                 /* N.B. eadatasize = 0 is not valid for FLXATTRALL */
87                 /* We could calculate accurate sizes, but this would
88                  * introduce a lot of overhead, let's do it later... */
89                 size = info->mti_body->eadatasize;
90                 req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size);
91                 req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size);
92         } else {
93                 CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid);
94                 RETURN(-EINVAL);
95         }
96
97         if (size == -ENODATA) {
98                 size = 0;
99         } else if (size < 0) {
100                 CERROR("Error geting EA size: %d\n", size);
101                 RETURN(size);
102         }
103
104         if (info->mti_body->eadatasize != 0 &&
105             info->mti_body->eadatasize < size)
106                 RETURN(-ERANGE);
107
108         req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
109                              info->mti_body->eadatasize == 0 ? 0 : size);
110         rc = req_capsule_server_pack(pill);
111         if (rc) {
112                 LASSERT(rc < 0);
113                 RETURN(rc);
114         }
115
116         RETURN(size);
117 }
118
119 static int
120 mdt_getxattr_one(struct mdt_thread_info *info,
121                 char *xattr_name, struct md_object *next,
122                 struct lu_buf *buf, struct mdt_export_data *med,
123                 struct lu_ucred *uc)
124 {
125         __u32 remote = exp_connect_rmtclient(info->mti_exp);
126         int flags = CFS_IC_NOTHING, rc;
127
128         ENTRY;
129
130         CDEBUG(D_INODE, "getxattr %s\n", xattr_name);
131
132         rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
133         if (rc < 0) {
134                 CERROR("getxattr failed: %d\n", rc);
135                 GOTO(out, rc);
136         }
137
138         if (info->mti_body->valid &
139             (OBD_MD_FLRMTLSETFACL | OBD_MD_FLRMTLGETFACL))
140                 flags = CFS_IC_ALL;
141         else if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL)
142                 flags = CFS_IC_MAPPED;
143
144         if (rc > 0 && flags != CFS_IC_NOTHING) {
145                 int rc1;
146
147                 if (unlikely(!remote))
148                         GOTO(out, rc = -EINVAL);
149
150                 rc1 = lustre_posix_acl_xattr_id2client(uc,
151                                 med->med_idmap,
152                                 (posix_acl_xattr_header *)(buf->lb_buf),
153                                 rc, flags);
154                 if (unlikely(rc1 < 0))
155                         rc = rc1;
156         }
157
158 out:
159         return rc;
160 }
161
162 static int mdt_getxattr_all(struct mdt_thread_info *info,
163                             struct mdt_body *reqbody, struct mdt_body *repbody,
164                             struct lu_buf *buf, struct md_object *next)
165 {
166         const struct lu_env *env = info->mti_env;
167         struct ptlrpc_request *req = mdt_info_req(info);
168         struct mdt_export_data *med = mdt_req2med(req);
169         struct lu_ucred        *uc  = mdt_ucred(info);
170         char *v, *b, *eadatahead, *eadatatail;
171         __u32 *sizes;
172         int eadatasize, eavallen = 0, eavallens = 0, rc;
173
174         ENTRY;
175
176         /*
177          * The format of the pill is the following:
178          * EADATA:      attr1\0attr2\0...attrn\0
179          * EAVALS:      val1val2...valn
180          * EAVALS_LENS: 4,4,...4
181          */
182
183         eadatahead = buf->lb_buf;
184
185         /* Fill out EADATA first */
186         eadatasize = mo_xattr_list(env, next, buf);
187         if (eadatasize < 0)
188                 GOTO(out, rc = eadatasize);
189
190         eadatatail = eadatahead + eadatasize;
191
192         v = req_capsule_server_get(info->mti_pill, &RMF_EAVALS);
193         sizes = req_capsule_server_get(info->mti_pill, &RMF_EAVALS_LENS);
194
195         /* Fill out EAVALS and EAVALS_LENS */
196         for (b = eadatahead; b < eadatatail; b += strlen(b) + 1, v += rc) {
197                 buf->lb_buf = v;
198                 buf->lb_len = reqbody->eadatasize - eavallen;
199                 rc = mdt_getxattr_one(info, b, next, buf, med, uc);
200                 if (rc < 0)
201                         GOTO(out, rc);
202
203                 sizes[eavallens] = rc;
204                 eavallens++;
205                 eavallen += rc;
206         }
207
208         repbody->aclsize = eavallen;
209         repbody->max_mdsize = eavallens;
210
211         req_capsule_shrink(info->mti_pill, &RMF_EAVALS, eavallen, RCL_SERVER);
212         req_capsule_shrink(info->mti_pill, &RMF_EAVALS_LENS,
213                            eavallens * sizeof(__u32), RCL_SERVER);
214         req_capsule_shrink(info->mti_pill, &RMF_EADATA, eadatasize, RCL_SERVER);
215
216         GOTO(out, rc = eadatasize);
217 out:
218         return rc;
219 }
220
221 int mdt_getxattr(struct mdt_thread_info *info)
222 {
223         struct ptlrpc_request  *req = mdt_info_req(info);
224         struct mdt_export_data *med = mdt_req2med(req);
225         struct lu_ucred        *uc  = lu_ucred(info->mti_env);
226         struct mdt_body        *reqbody;
227         struct mdt_body        *repbody = NULL;
228         struct md_object       *next;
229         struct lu_buf          *buf;
230         __u32                   remote = exp_connect_rmtclient(info->mti_exp);
231         __u32                   perm;
232         int                     easize, rc;
233         obd_valid               valid;
234         ENTRY;
235
236         LASSERT(info->mti_object != NULL);
237         LASSERT(lu_object_assert_exists(&info->mti_object->mot_obj));
238
239         CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->fid1));
240
241         reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
242         if (reqbody == NULL)
243                 RETURN(err_serious(-EFAULT));
244
245         rc = mdt_init_ucred(info, reqbody);
246         if (rc)
247                 RETURN(err_serious(rc));
248
249         next = mdt_object_child(info->mti_object);
250
251         if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL) {
252                 if (unlikely(!remote))
253                         GOTO(out, rc = err_serious(-EINVAL));
254
255                 perm = mdt_identity_get_perm(uc->uc_identity, remote,
256                                              req->rq_peer.nid);
257                 if (!(perm & CFS_RMTACL_PERM))
258                         GOTO(out, rc = err_serious(-EPERM));
259
260                 rc = mo_permission(info->mti_env, NULL, next, NULL,
261                                    MAY_RGETFACL);
262                 if (rc)
263                         GOTO(out, rc = err_serious(rc));
264         }
265
266         easize = mdt_getxattr_pack_reply(info);
267         if (easize < 0)
268                 GOTO(out, rc = err_serious(easize));
269
270         repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
271         LASSERT(repbody != NULL);
272
273         /* No need further getxattr. */
274         if (easize == 0 || reqbody->eadatasize == 0)
275                 GOTO(out, rc = easize);
276
277         buf = &info->mti_buf;
278         buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA);
279         buf->lb_len = easize;
280
281         valid = info->mti_body->valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
282
283         if (valid == OBD_MD_FLXATTR) {
284                 char *xattr_name = req_capsule_client_get(info->mti_pill,
285                                                           &RMF_NAME);
286                 rc = mdt_getxattr_one(info, xattr_name, next, buf, med, uc);
287         } else if (valid == OBD_MD_FLXATTRLS) {
288                 CDEBUG(D_INODE, "listxattr\n");
289
290                 rc = mo_xattr_list(info->mti_env, next, buf);
291                 if (rc < 0)
292                         CDEBUG(D_INFO, "listxattr failed: %d\n", rc);
293         } else if (valid == OBD_MD_FLXATTRALL) {
294                 rc = mdt_getxattr_all(info, reqbody, repbody,
295                                       buf, next);
296         } else
297                 LBUG();
298
299         EXIT;
300 out:
301         if (rc >= 0) {
302                 mdt_counter_incr(req, LPROC_MDT_GETXATTR);
303                 repbody->eadatasize = rc;
304                 rc = 0;
305         }
306         mdt_exit_ucred(info);
307         return rc;
308 }
309
310 static int mdt_rmtlsetfacl(struct mdt_thread_info *info,
311                            struct md_object *next,
312                            const char *xattr_name,
313                            ext_acl_xattr_header *header,
314                            posix_acl_xattr_header **out)
315 {
316         struct ptlrpc_request  *req = mdt_info_req(info);
317         struct mdt_export_data *med = mdt_req2med(req);
318         struct lu_ucred        *uc = mdt_ucred(info);
319         struct lu_buf          *buf = &info->mti_buf;
320         int                     rc;
321         ENTRY;
322
323         rc = lustre_ext_acl_xattr_id2server(uc, med->med_idmap, header);
324         if (rc)
325                 RETURN(rc);
326
327         rc = mo_xattr_get(info->mti_env, next, &LU_BUF_NULL, xattr_name);
328         if (rc == -ENODATA)
329                 rc = 0;
330         else if (rc < 0)
331                 RETURN(rc);
332
333         buf->lb_len = rc;
334         if (buf->lb_len > 0) {
335                 OBD_ALLOC_LARGE(buf->lb_buf, buf->lb_len);
336                 if (unlikely(buf->lb_buf == NULL))
337                         RETURN(-ENOMEM);
338
339                 rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
340                 if (rc < 0) {
341                         CERROR("getxattr failed: %d\n", rc);
342                         GOTO(_out, rc);
343                 }
344         } else
345                 buf->lb_buf = NULL;
346
347         rc = lustre_acl_xattr_merge2posix((posix_acl_xattr_header *)(buf->lb_buf),
348                                           buf->lb_len, header, out);
349         EXIT;
350
351 _out:
352         if (rc <= 0 && buf->lb_buf != NULL)
353                 OBD_FREE_LARGE(buf->lb_buf, buf->lb_len);
354         return rc;
355 }
356
357 int mdt_reint_setxattr(struct mdt_thread_info *info,
358                        struct mdt_lock_handle *unused)
359 {
360         struct ptlrpc_request   *req = mdt_info_req(info);
361         struct lu_ucred         *uc  = lu_ucred(info->mti_env);
362         struct mdt_lock_handle  *lh;
363         const struct lu_env     *env  = info->mti_env;
364         struct lu_buf           *buf  = &info->mti_buf;
365         struct mdt_reint_record *rr   = &info->mti_rr;
366         struct md_attr          *ma = &info->mti_attr;
367         struct lu_attr          *attr = &info->mti_attr.ma_attr;
368         struct mdt_object       *obj;
369         struct md_object        *child;
370         __u64                    valid = attr->la_valid;
371         const char              *xattr_name = rr->rr_name.ln_name;
372         int                      xattr_len = rr->rr_eadatalen;
373         __u64                    lockpart;
374         int                      rc;
375         posix_acl_xattr_header  *new_xattr = NULL;
376         __u32                    remote = exp_connect_rmtclient(info->mti_exp);
377         __u32                    perm;
378         ENTRY;
379
380         CDEBUG(D_INODE, "setxattr for "DFID"\n", PFID(rr->rr_fid1));
381
382         if (info->mti_dlm_req)
383                 ldlm_request_cancel(req, info->mti_dlm_req, 0);
384
385         if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
386                 RETURN(err_serious(-ENOMEM));
387
388         CDEBUG(D_INODE, "%s xattr %s\n",
389                valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name);
390
391         rc = mdt_init_ucred_reint(info);
392         if (rc != 0)
393                 RETURN(rc);
394
395         if (valid & OBD_MD_FLRMTRSETFACL) {
396                 if (unlikely(!remote))
397                         GOTO(out, rc = err_serious(-EINVAL));
398
399                 perm = mdt_identity_get_perm(uc->uc_identity, remote,
400                                              req->rq_peer.nid);
401                 if (!(perm & CFS_RMTACL_PERM))
402                         GOTO(out, rc = err_serious(-EPERM));
403         }
404
405         if (strncmp(xattr_name, XATTR_USER_PREFIX,
406                     sizeof(XATTR_USER_PREFIX) - 1) == 0) {
407                 if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR))
408                         GOTO(out, rc = -EOPNOTSUPP);
409         } else if (strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
410                     sizeof(XATTR_TRUSTED_PREFIX) - 1) == 0) {
411
412                 if (!md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN))
413                         GOTO(out, rc = -EPERM);
414
415                 if (strcmp(xattr_name, XATTR_NAME_LOV) == 0 ||
416                     strcmp(xattr_name, XATTR_NAME_LMA) == 0 ||
417                     strcmp(xattr_name, XATTR_NAME_LMV) == 0 ||
418                     strcmp(xattr_name, XATTR_NAME_LINK) == 0 ||
419                     strcmp(xattr_name, XATTR_NAME_FID) == 0 ||
420                     strcmp(xattr_name, XATTR_NAME_VERSION) == 0 ||
421                     strcmp(xattr_name, XATTR_NAME_SOM) == 0 ||
422                     strcmp(xattr_name, XATTR_NAME_HSM) == 0 ||
423                     strcmp(xattr_name, XATTR_NAME_LFSCK_NAMESPACE) == 0)
424                         GOTO(out, rc = 0);
425         } else if ((valid & OBD_MD_FLXATTR) &&
426                    (strcmp(xattr_name, XATTR_NAME_ACL_ACCESS) == 0 ||
427                     strcmp(xattr_name, XATTR_NAME_ACL_DEFAULT) == 0)) {
428                 /* currently lustre limit acl access size */
429                 if (xattr_len > LUSTRE_POSIX_ACL_MAX_SIZE)
430                         GOTO(out, rc = -ERANGE);
431         }
432
433         lockpart = MDS_INODELOCK_UPDATE;
434         /* Revoke all clients' lookup lock, since the access
435          * permissions for this inode is changed when ACL_ACCESS is
436          * set. This isn't needed for ACL_DEFAULT, since that does
437          * not change the access permissions of this inode, nor any
438          * other existing inodes. It is setting the ACLs inherited
439          * by new directories/files at create time. */
440         /* We need revoke both LOOKUP|PERM lock here, see mdt_attr_set. */
441         if (!strcmp(xattr_name, XATTR_NAME_ACL_ACCESS))
442                 lockpart |= MDS_INODELOCK_PERM | MDS_INODELOCK_LOOKUP;
443         /* We need to take the lock on behalf of old clients so that newer
444          * clients flush their xattr caches */
445         else
446                 lockpart |= MDS_INODELOCK_XATTR;
447
448         lh = &info->mti_lh[MDT_LH_PARENT];
449         /* ACLs were sent to clients under LCK_CR locks, so taking LCK_EX
450          * to cancel them. */
451         mdt_lock_reg_init(lh, LCK_EX);
452         obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart);
453         if (IS_ERR(obj))
454                 GOTO(out, rc =  PTR_ERR(obj));
455
456         tgt_vbr_obj_set(env, mdt_obj2dt(obj));
457         rc = mdt_version_get_check_save(info, obj, 0);
458         if (rc)
459                 GOTO(out_unlock, rc);
460
461         if (unlikely(!(valid & OBD_MD_FLCTIME))) {
462                 /* This isn't strictly an error, but all current clients
463                  * should set OBD_MD_FLCTIME when setting attributes. */
464                 CWARN("%s: client miss to set OBD_MD_FLCTIME when "
465                       "setxattr %s: [object "DFID"] [valid "LPU64"]\n",
466                       mdt_obd_name(info->mti_mdt), xattr_name,
467                       PFID(rr->rr_fid1), valid);
468                 attr->la_ctime = cfs_time_current_sec();
469         }
470         attr->la_valid = LA_CTIME;
471         child = mdt_object_child(obj);
472         if (valid & OBD_MD_FLXATTR) {
473                 char *xattr = (void *)rr->rr_eadata;
474
475                 if (xattr_len > 0) {
476                         int flags = 0;
477
478                         if (valid & OBD_MD_FLRMTLSETFACL) {
479                                 if (unlikely(!remote))
480                                         GOTO(out_unlock, rc = -EINVAL);
481
482                                 xattr_len = mdt_rmtlsetfacl(info, child,
483                                                 xattr_name,
484                                                 (ext_acl_xattr_header *)xattr,
485                                                 &new_xattr);
486                                 if (xattr_len < 0)
487                                         GOTO(out_unlock, rc = xattr_len);
488
489                                 xattr = (char *)new_xattr;
490                         }
491
492                         if (attr->la_flags & XATTR_REPLACE)
493                                 flags |= LU_XATTR_REPLACE;
494
495                         if (attr->la_flags & XATTR_CREATE)
496                                 flags |= LU_XATTR_CREATE;
497
498                         mdt_fail_write(env, info->mti_mdt->mdt_bottom,
499                                        OBD_FAIL_MDS_SETXATTR_WRITE);
500
501                         buf->lb_buf = xattr;
502                         buf->lb_len = xattr_len;
503                         rc = mo_xattr_set(env, child, buf, xattr_name, flags);
504                         /* update ctime after xattr changed */
505                         if (rc == 0) {
506                                 ma->ma_attr_flags |= MDS_PERM_BYPASS;
507                                 mo_attr_set(env, child, ma);
508                         }
509                 }
510         } else if (valid & OBD_MD_FLXATTRRM) {
511                 rc = mo_xattr_del(env, child, xattr_name);
512                 /* update ctime after xattr changed */
513                 if (rc == 0) {
514                         ma->ma_attr_flags |= MDS_PERM_BYPASS;
515                         mo_attr_set(env, child, ma);
516                 }
517         } else {
518                 CDEBUG(D_INFO, "valid bits: "LPX64"\n", valid);
519                 rc = -EINVAL;
520         }
521         if (rc == 0)
522                 mdt_counter_incr(req, LPROC_MDT_SETXATTR);
523
524         EXIT;
525 out_unlock:
526         mdt_object_unlock_put(info, obj, lh, rc);
527         if (unlikely(new_xattr != NULL))
528                 lustre_posix_acl_xattr_free(new_xattr, xattr_len);
529 out:
530         mdt_exit_ucred(info);
531         return rc;
532 }