Whamcloud - gitweb
Branch HEAD
[fs/lustre-release.git] / lustre / mdt / mdt_xattr.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
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 #ifndef EXPORT_SYMTAB
47 # define EXPORT_SYMTAB
48 #endif
49 #define DEBUG_SUBSYSTEM S_MDS
50
51 /* prerequisite for linux/xattr.h */
52 #include <linux/types.h>
53 /* prerequisite for linux/xattr.h */
54 #include <linux/fs.h>
55 /* XATTR_{REPLACE,CREATE} */
56 #include <linux/xattr.h>
57
58 #include "mdt_internal.h"
59
60
61 /* return EADATA length to the caller. negative value means error */
62 static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
63 {
64         struct req_capsule     *pill = info->mti_pill ;
65         struct ptlrpc_request  *req = mdt_info_req(info);
66         char                   *xattr_name;
67         __u64                   valid = info->mti_body->valid;
68         static const char       user_string[] = "user.";
69         int                     size, rc;
70         ENTRY;
71         
72         if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
73                 RETURN(-ENOMEM);
74
75         /* Determine how many bytes we need */
76         if (valid & OBD_MD_FLXATTR) {
77                 xattr_name = req_capsule_client_get(pill, &RMF_NAME);
78                 if (!xattr_name)
79                         RETURN(-EFAULT);
80
81                 if (!(req->rq_export->exp_connect_flags & OBD_CONNECT_XATTR) &&
82                     !strncmp(xattr_name, user_string, sizeof(user_string) - 1))
83                         RETURN(-EOPNOTSUPP);
84                 
85                 size = mo_xattr_get(info->mti_env,
86                                     mdt_object_child(info->mti_object),
87                                     &LU_BUF_NULL, xattr_name);
88         } else if (valid & OBD_MD_FLXATTRLS) {
89                 size = mo_xattr_list(info->mti_env,
90                                      mdt_object_child(info->mti_object),
91                                      &LU_BUF_NULL);
92         } else {
93                 CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid);
94                 RETURN(-EINVAL);
95         }
96
97         if (size < 0) {
98                 if (size == -ENODATA)
99                         size = 0;
100                 else if (size != -EOPNOTSUPP) {
101                         CDEBUG(D_INFO, "Error geting EA size: %d\n", size);
102                         RETURN(size);
103                 }
104         }
105
106         if (info->mti_body->eadatasize != 0 &&
107             info->mti_body->eadatasize < size)
108                 RETURN(-ERANGE);
109
110         req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
111                              min_t(int, size, info->mti_body->eadatasize));
112
113         rc = req_capsule_server_pack(pill);
114         if (rc) {
115                 LASSERT(rc < 0);
116                 RETURN(rc);
117         }
118
119         RETURN(size);
120 }
121
122 int mdt_getxattr(struct mdt_thread_info *info)
123 {
124         struct ptlrpc_request  *req = mdt_info_req(info);
125         struct mdt_export_data *med = mdt_req2med(req);
126         struct md_ucred        *uc  = mdt_ucred(info);
127         struct mdt_body        *reqbody;
128         struct mdt_body        *repbody = NULL;
129         struct md_object       *next;
130         struct lu_buf          *buf;
131         __u32                   remote = exp_connect_rmtclient(info->mti_exp);
132         __u32                   perm;
133         int                     easize, rc;
134         ENTRY;
135
136         LASSERT(info->mti_object != NULL);
137         LASSERT(lu_object_assert_exists(&info->mti_object->mot_obj.mo_lu));
138
139         CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->fid1));
140
141         reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
142         if (reqbody == NULL)
143                 RETURN(err_serious(-EFAULT));
144
145         rc = mdt_init_ucred(info, reqbody);
146         if (rc)
147                 RETURN(err_serious(rc));
148
149         next = mdt_object_child(info->mti_object);
150
151         if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL) {
152                 if (unlikely(!remote))
153                         GOTO(out, rc = err_serious(-EINVAL));
154
155                 perm = mdt_identity_get_perm(uc->mu_identity, remote,
156                                              req->rq_peer.nid);
157                 if (!(perm & CFS_RMTACL_PERM))
158                         GOTO(out, rc = err_serious(-EPERM));
159
160                 rc = mo_permission(info->mti_env, NULL, next, NULL,
161                                    MAY_RGETFACL);
162                 if (rc)
163                         GOTO(out, rc = err_serious(rc));
164         }
165
166         easize = mdt_getxattr_pack_reply(info);
167         if (easize < 0)
168                 GOTO(out, rc = err_serious(easize));
169
170         repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
171         LASSERT(repbody != NULL);
172
173         /* No need further getxattr. */
174         if (easize == 0 || reqbody->eadatasize == 0)
175                 GOTO(out, rc = easize);
176
177         buf = &info->mti_buf;
178         buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA);
179         buf->lb_len = easize;
180
181         if (info->mti_body->valid & OBD_MD_FLXATTR) {
182                 int flags = CFS_IC_NOTHING;
183                 char *xattr_name = req_capsule_client_get(info->mti_pill,
184                                                           &RMF_NAME);
185                 CDEBUG(D_INODE, "getxattr %s\n", xattr_name);
186
187                 rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
188                 if (rc < 0) {
189                         CERROR("getxattr failed: %d\n", rc);
190                         GOTO(out, rc);
191                 }
192
193                 if (info->mti_body->valid &
194                     (OBD_MD_FLRMTLSETFACL | OBD_MD_FLRMTLGETFACL))
195                         flags = CFS_IC_ALL;
196                 else if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL)
197                         flags = CFS_IC_MAPPED;
198
199                 if (rc > 0 && flags != CFS_IC_NOTHING) {
200                         int rc1;
201
202                         if (unlikely(!remote))
203                                 GOTO(out, rc = -EINVAL);
204
205                         rc1 = lustre_posix_acl_xattr_id2client(uc,
206                                         med->med_idmap,
207                                         (posix_acl_xattr_header *)(buf->lb_buf),
208                                         rc, flags);
209                         if (unlikely(rc1 < 0))
210                                 rc = rc1;
211                 }
212         } else if (info->mti_body->valid & OBD_MD_FLXATTRLS) {
213                 CDEBUG(D_INODE, "listxattr\n");
214
215                 rc = mo_xattr_list(info->mti_env, next, buf);
216                 if (rc < 0)
217                         CDEBUG(D_INFO, "listxattr failed: %d\n", rc);
218         } else
219                 LBUG();
220
221         EXIT;
222 out:
223         if (rc >= 0) {
224                 repbody->eadatasize = rc;
225                 rc = 0;
226         }
227         mdt_exit_ucred(info);
228         return rc;
229 }
230
231 static int mdt_rmtlsetfacl(struct mdt_thread_info *info,
232                            struct md_object *next,
233                            const char *xattr_name,
234                            ext_acl_xattr_header *header,
235                            posix_acl_xattr_header **out)
236 {
237         struct ptlrpc_request  *req = mdt_info_req(info);
238         struct mdt_export_data *med = mdt_req2med(req);
239         struct md_ucred        *uc = mdt_ucred(info);
240         struct lu_buf          *buf = &info->mti_buf;
241         int                     rc;
242         ENTRY;
243
244         rc = lustre_ext_acl_xattr_id2server(uc, med->med_idmap, header);
245         if (rc)
246                 RETURN(rc);
247  
248         rc = mo_xattr_get(info->mti_env, next, &LU_BUF_NULL, xattr_name);
249         if (rc == -ENODATA)
250                 rc = 0;
251         else if (rc < 0)
252                 RETURN(rc);
253
254         buf->lb_len = rc;
255         if (buf->lb_len > 0) {
256                 OBD_ALLOC(buf->lb_buf, buf->lb_len);
257                 if (unlikely(buf->lb_buf == NULL))
258                         RETURN(-ENOMEM);
259
260                 rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
261                 if (rc < 0) {
262                         CERROR("getxattr failed: %d\n", rc);
263                         GOTO(_out, rc);
264                 }
265         } else
266                 buf->lb_buf = NULL;
267
268         rc = lustre_acl_xattr_merge2posix((posix_acl_xattr_header *)(buf->lb_buf),
269                                           buf->lb_len, header, out);
270         EXIT;
271
272 _out:
273         if (rc <= 0 && buf->lb_buf != NULL)
274                 OBD_FREE(buf->lb_buf, buf->lb_len);
275         return rc;
276 }
277
278 int mdt_reint_setxattr(struct mdt_thread_info *info,
279                        struct mdt_lock_handle *unused)
280 {
281         struct ptlrpc_request   *req = mdt_info_req(info);
282         struct md_ucred         *uc  = mdt_ucred(info);
283         const char               user_string[] = "user.";
284         const char               trust_string[] = "trusted.";
285         struct mdt_lock_handle  *lh;
286         struct req_capsule      *pill = info->mti_pill;
287         const struct lu_env     *env  = info->mti_env;
288         struct lu_buf           *buf  = &info->mti_buf;
289         struct mdt_reint_record *rr   = &info->mti_rr;
290         struct md_attr          *ma = &info->mti_attr;
291         struct lu_attr          *attr = &info->mti_attr.ma_attr;
292         struct mdt_object       *obj; 
293         struct md_object        *child;
294         __u64                    valid = attr->la_valid;
295         const char              *xattr_name;
296         int                      xattr_len = 0;
297         __u64                    lockpart;
298         int                      rc;
299         posix_acl_xattr_header  *new_xattr = NULL;
300         __u32                    remote = exp_connect_rmtclient(info->mti_exp);
301         __u32                    perm;
302         ENTRY;
303
304         CDEBUG(D_INODE, "setxattr for "DFID"\n", PFID(rr->rr_fid1));
305
306         if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
307                 RETURN(err_serious(-ENOMEM));
308
309         xattr_name = rr->rr_name;
310
311         CDEBUG(D_INODE, "%s xattr %s\n",
312                valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name);
313
314         rc = mdt_init_ucred_reint(info);
315         if (rc != 0)
316                 RETURN(rc);
317
318         if (valid & OBD_MD_FLRMTRSETFACL) {
319                 if (unlikely(!remote))
320                         GOTO(out, rc = err_serious(-EINVAL));
321
322                 perm = mdt_identity_get_perm(uc->mu_identity, remote,
323                                              req->rq_peer.nid);
324                 if (!(perm & CFS_RMTACL_PERM))
325                         GOTO(out, rc = err_serious(-EPERM));
326         }
327
328         /* various sanity check for xattr name */
329         xattr_name = req_capsule_client_get(pill, &RMF_NAME);
330         if (!xattr_name)
331                 GOTO(out, rc = err_serious(-EFAULT));
332
333         if (strncmp(xattr_name, trust_string, sizeof(trust_string) - 1) == 0) {
334                 if (strcmp(xattr_name + 8, XATTR_NAME_LOV) == 0)
335                         GOTO(out, rc = -EACCES);
336         }
337
338         if (!(req->rq_export->exp_connect_flags & OBD_CONNECT_XATTR) &&
339             (strncmp(xattr_name, user_string, sizeof(user_string) - 1) == 0)) {
340                 GOTO(out, rc = -EOPNOTSUPP);
341         }
342
343         lockpart = MDS_INODELOCK_UPDATE;
344         if (!strcmp(xattr_name, XATTR_NAME_ACL_ACCESS))
345                 lockpart |= MDS_INODELOCK_LOOKUP;
346
347         lh = &info->mti_lh[MDT_LH_PARENT];
348         mdt_lock_reg_init(lh, LCK_PW);
349         obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart);
350         if (IS_ERR(obj))
351                 GOTO(out, rc =  PTR_ERR(obj));
352
353         if (unlikely(!(valid & OBD_MD_FLCTIME))) {
354                 CWARN("client miss to set OBD_MD_FLCTIME when "
355                       "setxattr: [object "DFID"] [valid %llu]\n",
356                       PFID(rr->rr_fid1), valid);
357                 attr->la_ctime = cfs_time_current_sec();
358         }
359         attr->la_valid = LA_CTIME;
360         child = mdt_object_child(obj);
361         if (valid & OBD_MD_FLXATTR) {
362                 char * xattr;
363
364                 if (!req_capsule_field_present(pill, &RMF_EADATA, RCL_CLIENT)) {
365                         CDEBUG(D_INFO, "no xattr data supplied\n");
366                         GOTO(out_unlock, rc = -EFAULT);
367                 }
368
369                 xattr_len = req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT);
370                 if (xattr_len) {
371                         int flags = 0;
372
373                         xattr = req_capsule_client_get(pill, &RMF_EADATA);
374
375                         if (valid & OBD_MD_FLRMTLSETFACL) {
376                                 if (unlikely(!remote))
377                                         GOTO(out_unlock, rc = -EINVAL);
378
379                                 xattr_len = mdt_rmtlsetfacl(info, child,
380                                                 xattr_name,
381                                                 (ext_acl_xattr_header *)xattr,
382                                                 &new_xattr);
383                                 if (xattr_len < 0)
384                                         GOTO(out_unlock, rc = xattr_len);
385
386                                 xattr = (char *)new_xattr;
387                         }
388
389                         if (attr->la_flags & XATTR_REPLACE)
390                                 flags |= LU_XATTR_REPLACE;
391
392                         if (attr->la_flags & XATTR_CREATE)
393                                 flags |= LU_XATTR_CREATE;
394
395                         mdt_fail_write(env, info->mti_mdt->mdt_bottom,
396                                        OBD_FAIL_MDS_SETXATTR_WRITE);
397
398                         buf->lb_buf = xattr;
399                         buf->lb_len = xattr_len;
400                         rc = mo_xattr_set(env, child, buf, xattr_name, flags);
401                         /* update ctime after xattr changed */
402                         if (rc == 0) {
403                                 ma->ma_attr_flags |= MDS_PERM_BYPASS;
404                                 mo_attr_set(env, child, ma);
405                         }
406                 }
407         } else if (valid & OBD_MD_FLXATTRRM) {
408                 rc = mo_xattr_del(env, child, xattr_name);
409                 /* update ctime after xattr changed */
410                 if (rc == 0) {
411                         ma->ma_attr_flags |= MDS_PERM_BYPASS;
412                         mo_attr_set(env, child, ma);
413                 }
414         } else {
415                 CDEBUG(D_INFO, "valid bits: "LPX64"\n", valid);
416                 rc = -EINVAL;
417         }
418         EXIT;
419 out_unlock:
420         mdt_object_unlock_put(info, obj, lh, rc);
421         if (unlikely(new_xattr != NULL))
422                 lustre_posix_acl_xattr_free(new_xattr, xattr_len);
423 out:
424         mdt_exit_ucred(info);
425         return rc;
426 }