Whamcloud - gitweb
bc677599e6425bf98c3e57d85a3fcb5d0369241a
[fs/lustre-release.git] / lustre / include / md_object.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Extention of lu_object.h for metadata objects
5  *
6  *  Copyright (C) 2006 Cluster File Systems, Inc.
7  *
8  *   This file is part of Lustre, http://www.lustre.org.
9  *
10  *   Lustre is free software; you can redistribute it and/or
11  *   modify it under the terms of version 2 of the GNU General Public
12  *   License as published by the Free Software Foundation.
13  *
14  *   Lustre is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   along with Lustre; if not, write to the Free Software
21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  */
24
25 #ifndef _LUSTRE_MD_OBJECT_H
26 #define _LUSTRE_MD_OBJECT_H
27
28 /*
29  * Sub-class of lu_object with methods common for "meta-data" objects in MDT
30  * stack.
31  *
32  * Meta-data objects implement namespace operations: you can link, unlink
33  * them, and treat them as directories.
34  *
35  * Examples: mdt, cmm, and mdt are implementations of md interface.
36  */
37
38
39 /*
40  * super-class definitions.
41  */
42 #include <lu_object.h>
43 #include <lvfs.h>
44
45 struct md_device;
46 struct md_device_operations;
47 struct md_object;
48
49
50 enum {
51         UCRED_INVALID   = -1,
52         UCRED_INIT      = 0,
53         UCRED_OLD       = 1,
54         UCRED_NEW       = 2
55 };
56
57 struct md_ucred {
58         __u32               mu_valid;
59         __u32                   mu_o_uid;
60         __u32                   mu_o_gid;
61         __u32                   mu_o_fsuid;
62         __u32                   mu_o_fsgid;
63         __u32                   mu_uid;
64         __u32                   mu_gid;
65         __u32                   mu_fsuid;
66         __u32                   mu_fsgid;
67         __u32                   mu_suppgids[2];
68         __u32                   mu_cap;
69         __u32                   mu_umask;
70         struct group_info      *mu_ginfo;
71         struct md_identity *mu_identity;
72 };
73
74 #define MD_CAPAINFO_MAX 5
75
76 /* there are at most 5 fids in one operation, see rename, NOTE the last one
77  * is a temporary one used for is_subdir() */
78 struct md_capainfo {
79         const struct lu_fid    *mc_fid[MD_CAPAINFO_MAX];
80         struct lustre_capa     *mc_capa[MD_CAPAINFO_MAX];
81 };
82
83 /*
84  * Implemented in mdd/mdd_handler.c.
85  *
86  * XXX should be moved into separate .h/.c together with all md security
87  * related definitions.
88  */
89 struct md_ucred *md_ucred(const struct lu_env *env);
90 struct md_capainfo *md_capainfo(const struct lu_env *env);
91
92 /* metadata attributes */
93 enum ma_valid {
94         MA_INODE     = (1 << 0),
95         MA_LOV       = (1 << 1),
96         MA_COOKIE    = (1 << 2),
97         MA_FLAGS     = (1 << 3),
98         MA_LMV       = (1 << 4),
99         MA_ACL_DEF   = (1 << 5),
100         MA_LOV_DEF   = (1 << 6)
101 };
102
103 typedef enum {
104         MDL_MINMODE  = 0,
105         MDL_EX       = 1,
106         MDL_PW       = 2,
107         MDL_PR       = 4,
108         MDL_CW       = 8,
109         MDL_CR       = 16,
110         MDL_NL       = 32,
111         MDL_GROUP    = 64,
112         MDL_MAXMODE
113 } mdl_mode_t;
114
115 typedef enum {
116         MDT_NUL_LOCK = 0,
117         MDT_REG_LOCK = (1 << 0),
118         MDT_PDO_LOCK = (1 << 1)
119 } mdl_type_t;
120
121 struct md_attr {
122         __u64                   ma_valid;
123         __u64                   ma_need;
124         __u64                   ma_attr_flags;
125         struct lu_attr          ma_attr;
126         struct lov_mds_md      *ma_lmm;
127         int                     ma_lmm_size;
128         struct lmv_stripe_md   *ma_lmv;
129         int                     ma_lmv_size;
130         void                   *ma_acl;
131         int                     ma_acl_size;
132         struct llog_cookie     *ma_cookie;
133         int                     ma_cookie_size;
134         struct lustre_capa     *ma_capa;
135 };
136
137 /* Additional parameters for create */
138 struct md_op_spec {
139         union {
140                 /* symlink target */
141                 const char               *sp_symname;
142                 /* parent FID for cross-ref mkdir */
143                 const struct lu_fid      *sp_pfid;
144                 /* eadata for regular files */
145                 struct md_spec_reg {
146                         /* lov objs exist already */
147                         const struct lu_fid   *fid;
148                         int no_lov_create;
149                         const void *eadata;
150                         int  eadatalen;
151                 } sp_ea;
152         } u;
153         
154         /* Create flag from client: such as MDS_OPEN_CREAT, and others. */
155         __u32      sp_cr_flags;
156
157         /* Should mdd do lookup sanity check or not. */
158         int        sp_cr_lookup;
159
160         /* Current lock mode for parent dir where create is performing. */
161         mdl_mode_t sp_cr_mode;
162
163         /* Check for split */
164         int        sp_ck_split;
165 };
166
167 /*
168  * Operations implemented for each md object (both directory and leaf).
169  */
170 struct md_object_operations {
171         int (*moo_permission)(const struct lu_env *env,
172                               struct md_object *pobj, struct md_object *cobj,
173                               struct md_attr *attr, int mask);
174
175         int (*moo_attr_get)(const struct lu_env *env, struct md_object *obj,
176                             struct md_attr *attr);
177
178         int (*moo_attr_set)(const struct lu_env *env, struct md_object *obj,
179                             const struct md_attr *attr);
180
181         int (*moo_xattr_get)(const struct lu_env *env, struct md_object *obj,
182                              struct lu_buf *buf, const char *name);
183
184         int (*moo_xattr_list)(const struct lu_env *env, struct md_object *obj,
185                               struct lu_buf *buf);
186
187         int (*moo_xattr_set)(const struct lu_env *env, struct md_object *obj,
188                              const struct lu_buf *buf, const char *name,
189                              int fl, const struct lu_attr *la);
190
191         int (*moo_xattr_del)(const struct lu_env *env, struct md_object *obj,
192                              const char *name, const struct lu_attr *la);
193
194         int (*moo_readpage)(const struct lu_env *env, struct md_object *obj,
195                             const struct lu_rdpg *rdpg);
196
197         int (*moo_readlink)(const struct lu_env *env, struct md_object *obj,
198                             struct lu_buf *buf);
199
200         /* part of cross-ref operation */
201         int (*moo_object_create)(const struct lu_env *env,
202                                  struct md_object *obj,
203                                  const struct md_op_spec *spec,
204                                  struct md_attr *ma);
205
206         int (*moo_ref_add)(const struct lu_env *env,
207                            struct md_object *obj,
208                            const struct md_attr *ma);
209
210         int (*moo_ref_del)(const struct lu_env *env,
211                            struct md_object *obj,
212                            struct md_attr *ma);
213
214         int (*moo_open)(const struct lu_env *env,
215                         struct md_object *obj, int flag);
216
217         int (*moo_close)(const struct lu_env *env, struct md_object *obj,
218                          struct md_attr *ma);
219         
220         int (*moo_capa_get)(const struct lu_env *, struct md_object *,
221                             struct lustre_capa *, int renewal);
222 };
223
224 /*
225  * Operations implemented for each directory object.
226  */
227 struct md_dir_operations {
228         int (*mdo_is_subdir) (const struct lu_env *env, struct md_object *obj,
229                               const struct lu_fid *fid, struct lu_fid *sfid);
230
231         int (*mdo_lookup)(const struct lu_env *env, struct md_object *obj,
232                           const struct lu_name *lname, struct lu_fid *fid,
233                           struct md_op_spec *spec);
234
235         mdl_mode_t (*mdo_lock_mode)(const struct lu_env *env,
236                                     struct md_object *obj,
237                                     mdl_mode_t mode);
238
239         int (*mdo_create)(const struct lu_env *env, struct md_object *pobj,
240                           const struct lu_name *lname, struct md_object *child,
241                           struct md_op_spec *spec,
242                           struct md_attr *ma);
243
244         /* This method is used for creating data object for this meta object*/
245         int (*mdo_create_data)(const struct lu_env *env, struct md_object *p,
246                                struct md_object *o,
247                                const struct md_op_spec *spec,
248                                struct md_attr *ma);
249
250         int (*mdo_rename)(const struct lu_env *env, struct md_object *spobj,
251                           struct md_object *tpobj, const struct lu_fid *lf,
252                           const struct lu_name *lsname, struct md_object *tobj,
253                           const struct lu_name *ltname, struct md_attr *ma);
254
255         int (*mdo_link)(const struct lu_env *env, struct md_object *tgt_obj,
256                         struct md_object *src_obj, const struct lu_name *lname,
257                         struct md_attr *ma);
258
259         int (*mdo_unlink)(const struct lu_env *env, struct md_object *pobj,
260                           struct md_object *cobj, const struct lu_name *lname,
261                           struct md_attr *ma);
262
263         /* partial ops for cross-ref case */
264         int (*mdo_name_insert)(const struct lu_env *env,
265                                struct md_object *obj,
266                                const struct lu_name *lname,
267                                const struct lu_fid *fid,
268                                const struct md_attr *ma);
269
270         int (*mdo_name_remove)(const struct lu_env *env,
271                                struct md_object *obj,
272                                const struct lu_name *lname,
273                                const struct md_attr *ma);
274
275         int (*mdo_rename_tgt)(const struct lu_env *env, struct md_object *pobj,
276                               struct md_object *tobj, const struct lu_fid *fid,
277                               const struct lu_name *lname, struct md_attr *ma);
278 };
279
280 struct md_device_operations {
281         /* meta-data device related handlers. */
282         int (*mdo_root_get)(const struct lu_env *env, struct md_device *m,
283                             struct lu_fid *f);
284
285         int (*mdo_maxsize_get)(const struct lu_env *env, struct md_device *m,
286                                int *md_size, int *cookie_size);
287
288         int (*mdo_statfs)(const struct lu_env *env, struct md_device *m,
289                           struct kstatfs *sfs);
290
291         int (*mdo_init_capa_ctxt)(const struct lu_env *env, struct md_device *m,
292                                   int mode, unsigned long timeout, __u32 alg,
293                                   struct lustre_capa_key *keys);
294
295         int (*mdo_update_capa_key)(const struct lu_env *env,
296                                    struct md_device *m,
297                                    struct lustre_capa_key *key);
298 };
299
300 enum md_upcall_event {
301         /*sync the md layer*/
302         MD_LOV_SYNC = (1 << 0),
303         MD_NO_TRANS = (1 << 1), /* Just for split, no need trans, for replay */
304         MD_LOV_CONFIG = (1 << 2)
305 };
306
307 struct md_upcall {
308         /* this lock protects upcall using against its removal
309          * read lock is for usage the upcall, write - for init/fini */
310         struct rw_semaphore     mu_upcall_sem;
311         /* device to call, upper layer normally */
312         struct md_device       *mu_upcall_dev;
313         /* upcall function */
314         int (*mu_upcall)(const struct lu_env *env, struct md_device *md,
315                          enum md_upcall_event ev);
316 };
317
318 struct md_device {
319         struct lu_device             md_lu_dev;
320         struct md_device_operations *md_ops;
321         struct md_upcall             md_upcall;
322 };
323
324 static inline void md_upcall_init(struct md_device *m, void *upcl)
325 {
326         init_rwsem(&m->md_upcall.mu_upcall_sem);
327         m->md_upcall.mu_upcall_dev = NULL;
328         m->md_upcall.mu_upcall = upcl;
329 }
330
331 static inline void md_upcall_dev_set(struct md_device *m, struct md_device *up)
332 {
333         down_write(&m->md_upcall.mu_upcall_sem);
334         m->md_upcall.mu_upcall_dev = up;
335         up_write(&m->md_upcall.mu_upcall_sem);
336 }
337
338 static inline void md_upcall_fini(struct md_device *m)
339 {
340         down_write(&m->md_upcall.mu_upcall_sem);
341         m->md_upcall.mu_upcall_dev = NULL;
342         m->md_upcall.mu_upcall = NULL;
343         up_write(&m->md_upcall.mu_upcall_sem);
344 }
345
346 static inline int md_do_upcall(const struct lu_env *env, struct md_device *m,
347                                enum md_upcall_event ev)
348 {
349         int rc = 0;
350         down_read(&m->md_upcall.mu_upcall_sem);
351         if (m->md_upcall.mu_upcall_dev != NULL &&
352             m->md_upcall.mu_upcall_dev->md_upcall.mu_upcall != NULL) {
353                 rc = m->md_upcall.mu_upcall_dev->md_upcall.mu_upcall(env,
354                                               m->md_upcall.mu_upcall_dev, ev);
355         }
356         up_read(&m->md_upcall.mu_upcall_sem);
357         return rc;
358 }
359
360 struct md_object {
361         struct lu_object             mo_lu;
362         struct md_object_operations *mo_ops;
363         struct md_dir_operations    *mo_dir_ops;
364 };
365
366 static inline int lu_device_is_md(const struct lu_device *d)
367 {
368         return ergo(d != NULL, d->ld_type->ldt_tags & LU_DEVICE_MD);
369 }
370
371 static inline struct md_device *lu2md_dev(const struct lu_device *d)
372 {
373         LASSERT(lu_device_is_md(d));
374         return container_of0(d, struct md_device, md_lu_dev);
375 }
376
377 static inline struct lu_device *md2lu_dev(struct md_device *d)
378 {
379         return &d->md_lu_dev;
380 }
381
382 static inline struct md_object *lu2md(const struct lu_object *o)
383 {
384         LASSERT(lu_device_is_md(o->lo_dev));
385         return container_of0(o, struct md_object, mo_lu);
386 }
387
388 static inline struct md_object *md_object_next(const struct md_object *obj)
389 {
390         return (obj ? lu2md(lu_object_next(&obj->mo_lu)) : NULL);
391 }
392
393 static inline struct md_device *md_obj2dev(const struct md_object *o)
394 {
395         LASSERT(lu_device_is_md(o->mo_lu.lo_dev));
396         return container_of0(o->mo_lu.lo_dev, struct md_device, md_lu_dev);
397 }
398
399 static inline int md_device_init(struct md_device *md, struct lu_device_type *t)
400 {
401         return lu_device_init(&md->md_lu_dev, t);
402 }
403
404 static inline void md_device_fini(struct md_device *md)
405 {
406         lu_device_fini(&md->md_lu_dev);
407 }
408
409 /* md operations */
410 static inline int mo_permission(const struct lu_env *env,
411                                 struct md_object *p,
412                                 struct md_object *c,
413                                 struct md_attr *at,
414                                 int mask)
415 {
416         LASSERT(c->mo_ops->moo_permission);
417         return c->mo_ops->moo_permission(env, p, c, at, mask);
418 }
419
420 static inline int mo_attr_get(const struct lu_env *env,
421                               struct md_object *m,
422                               struct md_attr *at)
423 {
424         LASSERT(m->mo_ops->moo_attr_get);
425         return m->mo_ops->moo_attr_get(env, m, at);
426 }
427
428 static inline int mo_readlink(const struct lu_env *env,
429                               struct md_object *m,
430                               struct lu_buf *buf)
431 {
432         LASSERT(m->mo_ops->moo_readlink);
433         return m->mo_ops->moo_readlink(env, m, buf);
434 }
435
436 static inline int mo_attr_set(const struct lu_env *env,
437                               struct md_object *m,
438                               const struct md_attr *at)
439 {
440         LASSERT(m->mo_ops->moo_attr_set);
441         return m->mo_ops->moo_attr_set(env, m, at);
442 }
443
444 static inline int mo_xattr_get(const struct lu_env *env,
445                                struct md_object *m,
446                                struct lu_buf *buf,
447                                const char *name)
448 {
449         LASSERT(m->mo_ops->moo_xattr_get);
450         return m->mo_ops->moo_xattr_get(env, m, buf, name);
451 }
452
453 static inline int mo_xattr_del(const struct lu_env *env,
454                                struct md_object *m,
455                                const char *name,
456                                const struct lu_attr *la)
457 {
458         LASSERT(m->mo_ops->moo_xattr_del);
459         return m->mo_ops->moo_xattr_del(env, m, name, la);
460 }
461
462 static inline int mo_xattr_set(const struct lu_env *env,
463                                struct md_object *m,
464                                const struct lu_buf *buf,
465                                const char *name,
466                                int flags,
467                                const struct lu_attr *la)
468 {
469         LASSERT(m->mo_ops->moo_xattr_set);
470         return m->mo_ops->moo_xattr_set(env, m, buf, name, flags, la);
471 }
472
473 static inline int mo_xattr_list(const struct lu_env *env,
474                                 struct md_object *m,
475                                 struct lu_buf *buf)
476 {
477         LASSERT(m->mo_ops->moo_xattr_list);
478         return m->mo_ops->moo_xattr_list(env, m, buf);
479 }
480
481 static inline int mo_open(const struct lu_env *env,
482                           struct md_object *m,
483                           int flags)
484 {
485         LASSERT(m->mo_ops->moo_open);
486         return m->mo_ops->moo_open(env, m, flags);
487 }
488
489 static inline int mo_close(const struct lu_env *env,
490                            struct md_object *m,
491                            struct md_attr *ma)
492 {
493         LASSERT(m->mo_ops->moo_close);
494         return m->mo_ops->moo_close(env, m, ma);
495 }
496
497 static inline int mo_readpage(const struct lu_env *env,
498                               struct md_object *m,
499                               const struct lu_rdpg *rdpg)
500 {
501         LASSERT(m->mo_ops->moo_readpage);
502         return m->mo_ops->moo_readpage(env, m, rdpg);
503 }
504
505 static inline int mo_object_create(const struct lu_env *env,
506                                    struct md_object *m,
507                                    const struct md_op_spec *spc,
508                                    struct md_attr *at)
509 {
510         LASSERT(m->mo_ops->moo_object_create);
511         return m->mo_ops->moo_object_create(env, m, spc, at);
512 }
513
514 static inline int mo_ref_add(const struct lu_env *env,
515                              struct md_object *m,
516                              const struct md_attr *ma)
517 {
518         LASSERT(m->mo_ops->moo_ref_add);
519         return m->mo_ops->moo_ref_add(env, m, ma);
520 }
521
522 static inline int mo_ref_del(const struct lu_env *env,
523                              struct md_object *m,
524                              struct md_attr *ma)
525 {
526         LASSERT(m->mo_ops->moo_ref_del);
527         return m->mo_ops->moo_ref_del(env, m, ma);
528 }
529
530 static inline int mo_capa_get(const struct lu_env *env,
531                               struct md_object *m,
532                               struct lustre_capa *c,
533                               int renewal)
534 {
535         LASSERT(m->mo_ops->moo_capa_get);
536         return m->mo_ops->moo_capa_get(env, m, c, renewal);
537 }
538
539 static inline int mdo_lookup(const struct lu_env *env,
540                              struct md_object *p,
541                              const struct lu_name *lname,
542                              struct lu_fid *f,
543                              struct md_op_spec *spec)
544 {
545         LASSERT(p->mo_dir_ops->mdo_lookup);
546         return p->mo_dir_ops->mdo_lookup(env, p, lname, f, spec);
547 }
548
549 static inline mdl_mode_t mdo_lock_mode(const struct lu_env *env,
550                                        struct md_object *mo,
551                                        mdl_mode_t lm)
552 {
553         if (mo->mo_dir_ops->mdo_lock_mode == NULL)
554                 return MDL_MINMODE;
555         return mo->mo_dir_ops->mdo_lock_mode(env, mo, lm);
556 }
557
558 static inline int mdo_create(const struct lu_env *env,
559                              struct md_object *p,
560                              const struct lu_name *lchild_name,
561                              struct md_object *c,
562                              struct md_op_spec *spc,
563                              struct md_attr *at)
564 {
565         LASSERT(c->mo_dir_ops->mdo_create);
566         return c->mo_dir_ops->mdo_create(env, p, lchild_name, c, spc, at);
567 }
568
569 static inline int mdo_create_data(const struct lu_env *env,
570                                   struct md_object *p,
571                                   struct md_object *c,
572                                   const struct md_op_spec *spec,
573                                   struct md_attr *ma)
574 {
575         LASSERT(c->mo_dir_ops->mdo_create_data);
576         return c->mo_dir_ops->mdo_create_data(env, p, c, spec, ma);
577 }
578
579 static inline int mdo_rename(const struct lu_env *env,
580                              struct md_object *sp,
581                              struct md_object *tp,
582                              const struct lu_fid *lf,
583                              const struct lu_name *lsname,
584                              struct md_object *t,
585                              const struct lu_name *ltname,
586                              struct md_attr *ma)
587 {
588         LASSERT(tp->mo_dir_ops->mdo_rename);
589         return tp->mo_dir_ops->mdo_rename(env, sp, tp, lf, lsname, t, ltname,
590                                           ma);
591 }
592
593 static inline int mdo_is_subdir(const struct lu_env *env,
594                                 struct md_object *mo,
595                                 const struct lu_fid *fid,
596                                 struct lu_fid *sfid)
597 {
598         LASSERT(mo->mo_dir_ops->mdo_is_subdir);
599         return mo->mo_dir_ops->mdo_is_subdir(env, mo, fid, sfid);
600 }
601
602 static inline int mdo_link(const struct lu_env *env,
603                            struct md_object *p,
604                            struct md_object *s,
605                            const struct lu_name *lname,
606                            struct md_attr *ma)
607 {
608         LASSERT(s->mo_dir_ops->mdo_link);
609         return s->mo_dir_ops->mdo_link(env, p, s, lname, ma);
610 }
611
612 static inline int mdo_unlink(const struct lu_env *env,
613                              struct md_object *p,
614                              struct md_object *c,
615                              const struct lu_name *lname,
616                              struct md_attr *ma)
617 {
618         LASSERT(c->mo_dir_ops->mdo_unlink);
619         return c->mo_dir_ops->mdo_unlink(env, p, c, lname, ma);
620 }
621
622 static inline int mdo_name_insert(const struct lu_env *env,
623                                   struct md_object *p,
624                                   const struct lu_name *lname,
625                                   const struct lu_fid *f,
626                                   const struct md_attr *ma)
627 {
628         LASSERT(p->mo_dir_ops->mdo_name_insert);
629         return p->mo_dir_ops->mdo_name_insert(env, p, lname, f, ma);
630 }
631
632 static inline int mdo_name_remove(const struct lu_env *env,
633                                   struct md_object *p,
634                                   const struct lu_name *lname,
635                                   const struct md_attr *ma)
636 {
637         LASSERT(p->mo_dir_ops->mdo_name_remove);
638         return p->mo_dir_ops->mdo_name_remove(env, p, lname, ma);
639 }
640
641 static inline int mdo_rename_tgt(const struct lu_env *env,
642                                  struct md_object *p,
643                                  struct md_object *t,
644                                  const struct lu_fid *lf,
645                                  const struct lu_name *lname,
646                                  struct md_attr *ma)
647 {
648         if (t) {
649                 LASSERT(t->mo_dir_ops->mdo_rename_tgt);
650                 return t->mo_dir_ops->mdo_rename_tgt(env, p, t, lf, lname, ma);
651         } else {
652                 LASSERT(p->mo_dir_ops->mdo_rename_tgt);
653                 return p->mo_dir_ops->mdo_rename_tgt(env, p, t, lf, lname, ma);
654         }
655 }
656
657 #endif /* _LINUX_MD_OBJECT_H */