Whamcloud - gitweb
LU-4840 lfs: Use file lease to implement migration
[fs/lustre-release.git] / lustre / mdc / mdc_lib.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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2014, 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
37 #define DEBUG_SUBSYSTEM S_MDC
38 #include <linux/user_namespace.h>
39 #ifdef HAVE_UIDGID_HEADER
40 # include <linux/uidgid.h>
41 #endif
42 #include <lustre_net.h>
43 #include <lustre/lustre_idl.h>
44 #include <obd_class.h>
45 #include <obd.h>
46 #include <cl_object.h>
47 #include "mdc_internal.h"
48
49
50 static void __mdc_pack_body(struct mdt_body *b, __u32 suppgid)
51 {
52         LASSERT (b != NULL);
53
54         b->mbo_suppgid = suppgid;
55         b->mbo_uid = from_kuid(&init_user_ns, current_uid());
56         b->mbo_gid = from_kgid(&init_user_ns, current_gid());
57         b->mbo_fsuid = from_kuid(&init_user_ns, current_fsuid());
58         b->mbo_fsgid = from_kgid(&init_user_ns, current_fsgid());
59         b->mbo_capability = cfs_curproc_cap_pack();
60 }
61
62 void mdc_pack_capa(struct ptlrpc_request *req, const struct req_msg_field *field,
63                    struct obd_capa *oc)
64 {
65         struct req_capsule *pill = &req->rq_pill;
66         struct lustre_capa *c;
67
68         if (oc == NULL) {
69                 LASSERT(req_capsule_get_size(pill, field, RCL_CLIENT) == 0);
70                 return;
71         }
72
73         c = req_capsule_client_get(pill, field);
74         LASSERT(c != NULL);
75         capa_cpy(c, oc);
76         DEBUG_CAPA(D_SEC, c, "pack");
77 }
78
79 void mdc_swap_layouts_pack(struct ptlrpc_request *req,
80                            struct md_op_data *op_data)
81 {
82         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
83                                                     &RMF_MDT_BODY);
84
85         __mdc_pack_body(b, op_data->op_suppgids[0]);
86         b->mbo_fid1 = op_data->op_fid1;
87         b->mbo_fid2 = op_data->op_fid2;
88         b->mbo_valid |= OBD_MD_FLID;
89
90         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
91         mdc_pack_capa(req, &RMF_CAPA2, op_data->op_capa2);
92 }
93
94 void mdc_pack_body(struct ptlrpc_request *req,
95                    const struct lu_fid *fid, struct obd_capa *oc,
96                    __u64 valid, size_t ea_size, __u32 suppgid, __u32 flags)
97 {
98         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
99                                                     &RMF_MDT_BODY);
100         LASSERT(b != NULL);
101         b->mbo_valid = valid;
102         b->mbo_eadatasize = ea_size;
103         b->mbo_flags = flags;
104         __mdc_pack_body(b, suppgid);
105         if (fid) {
106                 b->mbo_fid1 = *fid;
107                 b->mbo_valid |= OBD_MD_FLID;
108                 mdc_pack_capa(req, &RMF_CAPA1, oc);
109         }
110 }
111
112 /**
113  * Pack a name (path component) into a request
114  *
115  * \param[in]   req             request
116  * \param[in]   field           request field (usually RMF_NAME)
117  * \param[in]   name            path component
118  * \param[in]   name_len        length of path component
119  *
120  * \a field must be present in \a req and of size \a name_len + 1.
121  *
122  * \a name must be '\0' terminated of length \a name_len and represent
123  * a single path component (not contain '/').
124  */
125 static void mdc_pack_name(struct ptlrpc_request *req,
126                           const struct req_msg_field *field,
127                           const char *name, size_t name_len)
128 {
129         char *buf;
130         size_t buf_size;
131         size_t cpy_len;
132
133         buf = req_capsule_client_get(&req->rq_pill, field);
134         buf_size = req_capsule_get_size(&req->rq_pill, field, RCL_CLIENT);
135
136         LASSERT(name != NULL && name_len != 0 &&
137                 buf != NULL && buf_size == name_len + 1);
138
139         cpy_len = strlcpy(buf, name, buf_size);
140
141         LASSERT(cpy_len == name_len && lu_name_is_valid_2(buf, cpy_len));
142 }
143
144 void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, size_t size,
145                       const struct lu_fid *fid, struct obd_capa *oc)
146 {
147         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
148                                                     &RMF_MDT_BODY);
149         b->mbo_fid1 = *fid;
150         b->mbo_valid |= OBD_MD_FLID;
151         b->mbo_size = pgoff;                   /* !! */
152         b->mbo_nlink = size;                    /* !! */
153         __mdc_pack_body(b, -1);
154         b->mbo_mode = LUDA_FID | LUDA_TYPE;
155
156         mdc_pack_capa(req, &RMF_CAPA1, oc);
157 }
158
159 /* packing of MDS records */
160 void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
161                      const void *data, size_t datalen, umode_t mode,
162                      uid_t uid, gid_t gid, cfs_cap_t cap_effective, __u64 rdev)
163 {
164         struct mdt_rec_create   *rec;
165         char                    *tmp;
166         __u64                    flags;
167
168         CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create));
169         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
170
171
172         rec->cr_opcode   = REINT_CREATE;
173         rec->cr_fsuid    = uid;
174         rec->cr_fsgid    = gid;
175         rec->cr_cap      = cap_effective;
176         rec->cr_fid1     = op_data->op_fid1;
177         rec->cr_fid2     = op_data->op_fid2;
178         rec->cr_mode     = mode;
179         rec->cr_rdev     = rdev;
180         rec->cr_time     = op_data->op_mod_time;
181         rec->cr_suppgid1 = op_data->op_suppgids[0];
182         rec->cr_suppgid2 = op_data->op_suppgids[1];
183         flags = 0;
184         if (op_data->op_bias & MDS_CREATE_VOLATILE)
185                 flags |= MDS_OPEN_VOLATILE;
186         set_mrc_cr_flags(rec, flags);
187         rec->cr_bias     = op_data->op_bias;
188         rec->cr_umask    = current_umask();
189
190         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
191
192         mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
193         if (data) {
194                 tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
195                 memcpy(tmp, data, datalen);
196         }
197 }
198
199 static inline __u64 mds_pack_open_flags(__u64 flags)
200 {
201         __u64 cr_flags = (flags & (FMODE_READ | FMODE_WRITE |
202                                    MDS_OPEN_FL_INTERNAL));
203
204         if (flags & O_CREAT)
205                 cr_flags |= MDS_OPEN_CREAT;
206         if (flags & O_EXCL)
207                 cr_flags |= MDS_OPEN_EXCL;
208         if (flags & O_TRUNC)
209                 cr_flags |= MDS_OPEN_TRUNC;
210         if (flags & O_APPEND)
211                 cr_flags |= MDS_OPEN_APPEND;
212         if (flags & O_SYNC)
213                 cr_flags |= MDS_OPEN_SYNC;
214         if (flags & O_DIRECTORY)
215                 cr_flags |= MDS_OPEN_DIRECTORY;
216 #ifdef FMODE_EXEC
217         if (flags & FMODE_EXEC)
218                 cr_flags |= MDS_FMODE_EXEC;
219 #endif
220         if (cl_is_lov_delay_create(flags))
221                 cr_flags |= MDS_OPEN_DELAY_CREATE;
222
223         if (flags & O_NONBLOCK)
224                 cr_flags |= MDS_OPEN_NORESTORE;
225
226         return cr_flags;
227 }
228
229 /* packing of MDS records */
230 void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
231                    umode_t mode, __u64 rdev, __u64 flags, const void *lmm,
232                    size_t lmmlen)
233 {
234         struct mdt_rec_create *rec;
235         char *tmp;
236         __u64 cr_flags;
237
238         CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create));
239         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
240
241         /* XXX do something about time, uid, gid */
242         rec->cr_opcode = REINT_OPEN;
243         rec->cr_fsuid   = from_kuid(&init_user_ns, current_fsuid());
244         rec->cr_fsgid   = from_kgid(&init_user_ns, current_fsgid());
245         rec->cr_cap    = cfs_curproc_cap_pack();
246         rec->cr_mode   = mode;
247         cr_flags        = mds_pack_open_flags(flags);
248         rec->cr_rdev   = rdev;
249         rec->cr_umask  = current_umask();
250         if (op_data != NULL) {
251                 rec->cr_fid1       = op_data->op_fid1;
252                 rec->cr_fid2       = op_data->op_fid2;
253                 rec->cr_time       = op_data->op_mod_time;
254                 rec->cr_suppgid1   = op_data->op_suppgids[0];
255                 rec->cr_suppgid2   = op_data->op_suppgids[1];
256                 rec->cr_bias       = op_data->op_bias;
257                 rec->cr_old_handle = op_data->op_handle;
258
259                 mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
260                 /* the next buffer is child capa, which is used for replay,
261                  * will be packed from the data in reply message. */
262
263                 if (op_data->op_name) {
264                         mdc_pack_name(req, &RMF_NAME, op_data->op_name,
265                                       op_data->op_namelen);
266
267                         if (op_data->op_bias & MDS_CREATE_VOLATILE)
268                                 cr_flags |= MDS_OPEN_VOLATILE;
269                 }
270         }
271
272         if (lmm) {
273                 cr_flags |= MDS_OPEN_HAS_EA;
274                 tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
275                 memcpy(tmp, lmm, lmmlen);
276         }
277         set_mrc_cr_flags(rec, cr_flags);
278 }
279
280 static inline __u64 attr_pack(unsigned int ia_valid) {
281         __u64 sa_valid = 0;
282
283         if (ia_valid & ATTR_MODE)
284                 sa_valid |= MDS_ATTR_MODE;
285         if (ia_valid & ATTR_UID)
286                 sa_valid |= MDS_ATTR_UID;
287         if (ia_valid & ATTR_GID)
288                 sa_valid |= MDS_ATTR_GID;
289         if (ia_valid & ATTR_SIZE)
290                 sa_valid |= MDS_ATTR_SIZE;
291         if (ia_valid & ATTR_ATIME)
292                 sa_valid |= MDS_ATTR_ATIME;
293         if (ia_valid & ATTR_MTIME)
294                 sa_valid |= MDS_ATTR_MTIME;
295         if (ia_valid & ATTR_CTIME)
296                 sa_valid |= MDS_ATTR_CTIME;
297         if (ia_valid & ATTR_ATIME_SET)
298                 sa_valid |= MDS_ATTR_ATIME_SET;
299         if (ia_valid & ATTR_MTIME_SET)
300                 sa_valid |= MDS_ATTR_MTIME_SET;
301         if (ia_valid & ATTR_FORCE)
302                 sa_valid |= MDS_ATTR_FORCE;
303         if (ia_valid & ATTR_ATTR_FLAG)
304                 sa_valid |= MDS_ATTR_ATTR_FLAG;
305         if (ia_valid & ATTR_KILL_SUID)
306                 sa_valid |=  MDS_ATTR_KILL_SUID;
307         if (ia_valid & ATTR_KILL_SGID)
308                 sa_valid |= MDS_ATTR_KILL_SGID;
309         if (ia_valid & ATTR_CTIME_SET)
310                 sa_valid |= MDS_ATTR_CTIME_SET;
311         if (ia_valid & ATTR_FROM_OPEN)
312                 sa_valid |= MDS_ATTR_FROM_OPEN;
313         if (ia_valid & ATTR_BLOCKS)
314                 sa_valid |= MDS_ATTR_BLOCKS;
315         if (ia_valid & MDS_OPEN_OWNEROVERRIDE)
316                 /* NFSD hack (see bug 5781) */
317                 sa_valid |= MDS_OPEN_OWNEROVERRIDE;
318         return sa_valid;
319 }
320
321 static void mdc_setattr_pack_rec(struct mdt_rec_setattr *rec,
322                                  struct md_op_data *op_data)
323 {
324         rec->sa_opcode  = REINT_SETATTR;
325         rec->sa_fsuid   = from_kuid(&init_user_ns, current_fsuid());
326         rec->sa_fsgid   = from_kgid(&init_user_ns, current_fsgid());
327         rec->sa_cap     = cfs_curproc_cap_pack();
328         rec->sa_suppgid = -1;
329
330         rec->sa_fid    = op_data->op_fid1;
331         rec->sa_valid  = attr_pack(op_data->op_attr.ia_valid);
332         rec->sa_mode   = op_data->op_attr.ia_mode;
333         rec->sa_uid    = from_kuid(&init_user_ns, op_data->op_attr.ia_uid);
334         rec->sa_gid    = from_kgid(&init_user_ns, op_data->op_attr.ia_gid);
335         rec->sa_size   = op_data->op_attr.ia_size;
336         rec->sa_blocks = op_data->op_attr_blocks;
337         rec->sa_atime  = LTIME_S(op_data->op_attr.ia_atime);
338         rec->sa_mtime  = LTIME_S(op_data->op_attr.ia_mtime);
339         rec->sa_ctime  = LTIME_S(op_data->op_attr.ia_ctime);
340         rec->sa_attr_flags = op_data->op_attr_flags;
341         if ((op_data->op_attr.ia_valid & ATTR_GID) &&
342              in_group_p(op_data->op_attr.ia_gid))
343                 rec->sa_suppgid =
344                         from_kgid(&init_user_ns, op_data->op_attr.ia_gid);
345         else
346                 rec->sa_suppgid = op_data->op_suppgids[0];
347
348         rec->sa_bias = op_data->op_bias;
349 }
350
351 static void mdc_ioepoch_pack(struct mdt_ioepoch *epoch,
352                              struct md_op_data *op_data)
353 {
354         epoch->mio_handle = op_data->op_handle;
355         epoch->mio_unused1 = 0;
356         epoch->mio_unused2 = 0;
357         epoch->mio_padding = 0;
358 }
359
360 void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
361                       void *ea, size_t ealen)
362 {
363         struct mdt_rec_setattr *rec;
364         struct lov_user_md *lum = NULL;
365
366         CLASSERT(sizeof(struct mdt_rec_reint) ==sizeof(struct mdt_rec_setattr));
367         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
368         mdc_setattr_pack_rec(rec, op_data);
369
370         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
371
372         if (ealen == 0)
373                 return;
374
375         lum = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
376         if (ea == NULL) { /* Remove LOV EA */
377                 lum->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V1);
378                 lum->lmm_stripe_size = 0;
379                 lum->lmm_stripe_count = 0;
380                 lum->lmm_stripe_offset = (typeof(lum->lmm_stripe_offset))(-1);
381         } else {
382                 memcpy(lum, ea, ealen);
383         }
384 }
385
386 void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
387 {
388         struct mdt_rec_unlink *rec;
389
390         CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_unlink));
391         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
392         LASSERT(rec != NULL);
393
394         rec->ul_opcode  = op_data->op_cli_flags & CLI_RM_ENTRY ?
395                                         REINT_RMENTRY : REINT_UNLINK;
396         rec->ul_fsuid   = op_data->op_fsuid;
397         rec->ul_fsgid   = op_data->op_fsgid;
398         rec->ul_cap     = op_data->op_cap;
399         rec->ul_mode    = op_data->op_mode;
400         rec->ul_suppgid1= op_data->op_suppgids[0];
401         rec->ul_suppgid2= -1;
402         rec->ul_fid1    = op_data->op_fid1;
403         rec->ul_fid2    = op_data->op_fid2;
404         rec->ul_time    = op_data->op_mod_time;
405         rec->ul_bias    = op_data->op_bias;
406
407         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
408
409         mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
410 }
411
412 void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
413 {
414         struct mdt_rec_link *rec;
415
416         CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_link));
417         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
418         LASSERT (rec != NULL);
419
420         rec->lk_opcode   = REINT_LINK;
421         rec->lk_fsuid    = op_data->op_fsuid;//current->fsuid;
422         rec->lk_fsgid    = op_data->op_fsgid;//current->fsgid;
423         rec->lk_cap      = op_data->op_cap;//current->cap_effective;
424         rec->lk_suppgid1 = op_data->op_suppgids[0];
425         rec->lk_suppgid2 = op_data->op_suppgids[1];
426         rec->lk_fid1     = op_data->op_fid1;
427         rec->lk_fid2     = op_data->op_fid2;
428         rec->lk_time     = op_data->op_mod_time;
429         rec->lk_bias     = op_data->op_bias;
430
431         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
432         mdc_pack_capa(req, &RMF_CAPA2, op_data->op_capa2);
433
434         mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
435 }
436
437 void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
438                      const char *old, size_t oldlen,
439                      const char *new, size_t newlen)
440 {
441         struct mdt_rec_rename *rec;
442
443         CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_rename));
444         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
445
446         /* XXX do something about time, uid, gid */
447         rec->rn_opcode  = op_data->op_cli_flags & CLI_MIGRATE ?
448                                         REINT_MIGRATE : REINT_RENAME;
449         rec->rn_fsuid    = op_data->op_fsuid;
450         rec->rn_fsgid    = op_data->op_fsgid;
451         rec->rn_cap      = op_data->op_cap;
452         rec->rn_suppgid1 = op_data->op_suppgids[0];
453         rec->rn_suppgid2 = op_data->op_suppgids[1];
454         rec->rn_fid1     = op_data->op_fid1;
455         rec->rn_fid2     = op_data->op_fid2;
456         rec->rn_time     = op_data->op_mod_time;
457         rec->rn_mode     = op_data->op_mode;
458         rec->rn_bias     = op_data->op_bias;
459
460         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
461         mdc_pack_capa(req, &RMF_CAPA2, op_data->op_capa2);
462
463         mdc_pack_name(req, &RMF_NAME, old, oldlen);
464
465         if (new != NULL)
466                 mdc_pack_name(req, &RMF_SYMTGT, new, newlen);
467 }
468
469 void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, __u32 flags,
470                       struct md_op_data *op_data, size_t ea_size)
471 {
472         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
473                                                     &RMF_MDT_BODY);
474
475         b->mbo_valid = valid;
476         if (op_data->op_bias & MDS_CHECK_SPLIT)
477                 b->mbo_valid |= OBD_MD_FLCKSPLIT;
478         if (op_data->op_bias & MDS_CROSS_REF)
479                 b->mbo_valid |= OBD_MD_FLCROSSREF;
480         b->mbo_eadatasize = ea_size;
481         b->mbo_flags = flags;
482         __mdc_pack_body(b, op_data->op_suppgids[0]);
483
484         b->mbo_fid1 = op_data->op_fid1;
485         b->mbo_fid2 = op_data->op_fid2;
486         b->mbo_valid |= OBD_MD_FLID;
487
488         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
489
490         if (op_data->op_name != NULL)
491                 mdc_pack_name(req, &RMF_NAME, op_data->op_name,
492                               op_data->op_namelen);
493 }
494
495 static void mdc_intent_close_pack(struct ptlrpc_request *req,
496                                   struct md_op_data *op_data)
497 {
498         struct close_data       *data;
499         struct ldlm_lock        *lock;
500         enum mds_op_bias         bias = op_data->op_bias;
501
502         if (!(bias & (MDS_HSM_RELEASE | MDS_CLOSE_LAYOUT_SWAP)))
503                 return;
504
505         data = req_capsule_client_get(&req->rq_pill, &RMF_CLOSE_DATA);
506         LASSERT(data != NULL);
507
508         lock = ldlm_handle2lock(&op_data->op_lease_handle);
509         if (lock != NULL) {
510                 data->cd_handle = lock->l_remote_handle;
511                 LDLM_LOCK_PUT(lock);
512         }
513         ldlm_cli_cancel(&op_data->op_lease_handle, LCF_LOCAL);
514
515         data->cd_data_version = op_data->op_data_version;
516         data->cd_fid = op_data->op_fid2;
517 }
518
519 void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
520 {
521         struct mdt_ioepoch *epoch;
522         struct mdt_rec_setattr *rec;
523
524         epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
525         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
526
527         mdc_setattr_pack_rec(rec, op_data);
528         mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
529         mdc_ioepoch_pack(epoch, op_data);
530         mdc_intent_close_pack(req, op_data);
531 }