Whamcloud - gitweb
4873b02b116a72a30c2c372d23e585300bdfdc4c
[fs/lustre-release.git] / lustre / mdt / mdt_internal.h
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_internal.h
37  *
38  * Lustre Metadata Target (mdt) request handler
39  *
40  * Author: Peter Braam <braam@clusterfs.com>
41  * Author: Andreas Dilger <adilger@clusterfs.com>
42  * Author: Phil Schwan <phil@clusterfs.com>
43  * Author: Mike Shaver <shaver@clusterfs.com>
44  * Author: Nikita Danilov <nikita@clusterfs.com>
45  * Author: Huang Hua <huanghua@clusterfs.com>
46  */
47
48 #ifndef _MDT_INTERNAL_H
49 #define _MDT_INTERNAL_H
50
51 #if defined(__KERNEL__)
52
53 #include <obd_class.h>
54 #include <lustre_net.h>
55 #include <lustre/lustre_idl.h>
56 #include <lustre_disk.h>
57 #include <lu_target.h>
58 #include <md_object.h>
59 #include <lustre_fid.h>
60 #include <lustre_fld.h>
61 #include <lustre_mdt.h>
62 #include <lustre_req_layout.h>
63 #include <lustre_sec.h>
64 #include <lvfs.h>
65 #include <lustre_idmap.h>
66 #include <lustre_eacl.h>
67 #include <lustre_quota.h>
68
69 /* check if request's xid is equal to last one or not*/
70 static inline int req_xid_is_last(struct ptlrpc_request *req)
71 {
72         struct lsd_client_data *lcd = req->rq_export->exp_target_data.ted_lcd;
73         return (req->rq_xid == lcd->lcd_last_xid ||
74                 req->rq_xid == lcd->lcd_last_close_xid);
75 }
76
77 struct mdt_object;
78 /* file data for open files on MDS */
79 struct mdt_file_data {
80         struct portals_handle mfd_handle; /* must be first */
81         int                   mfd_mode;   /* open mode provided by client */
82         cfs_list_t            mfd_list;   /* protected by med_open_lock */
83         __u64                 mfd_xid;    /* xid of the open request */
84         struct lustre_handle  mfd_old_handle; /* old handle in replay case */
85         struct mdt_object    *mfd_object; /* point to opened object */
86 };
87
88 /* mdt state flag bits */
89 #define MDT_FL_CFGLOG 0
90 #define MDT_FL_SYNCED 1
91
92 struct mdt_device {
93         /* super-class */
94         struct md_device           mdt_md_dev;
95         struct seq_server_site     mdt_seq_site;
96         struct ptlrpc_service     *mdt_regular_service;
97         struct ptlrpc_service     *mdt_readpage_service;
98         struct ptlrpc_service     *mdt_out_service;
99         struct ptlrpc_service     *mdt_setattr_service;
100         struct ptlrpc_service     *mdt_mdsc_service;
101         struct ptlrpc_service     *mdt_mdss_service;
102         struct ptlrpc_service     *mdt_dtss_service;
103         struct ptlrpc_service     *mdt_fld_service;
104         /* DLM name-space for meta-data locks maintained by this server */
105         struct ldlm_namespace     *mdt_namespace;
106         /* ptlrpc handle for MDS->client connections (for lock ASTs). */
107         struct ptlrpc_client      *mdt_ldlm_client;
108         /* underlying device */
109         struct obd_export         *mdt_child_exp;
110         struct md_device          *mdt_child;
111         struct dt_device          *mdt_bottom;
112         struct obd_export         *mdt_bottom_exp;
113         /** target device */
114         struct lu_target           mdt_lut;
115         /*
116          * Options bit-fields.
117          */
118         struct {
119                 unsigned int       mo_user_xattr:1,
120                                    mo_acl:1,
121                                    mo_compat_resname:1,
122                                    mo_mds_capa:1,
123                                    mo_oss_capa:1,
124                                    mo_cos:1;
125         } mdt_opts;
126         /* mdt state flags */
127         unsigned long              mdt_state;
128         /* lock to protect IOepoch */
129         spinlock_t                 mdt_ioepoch_lock;
130         __u64                      mdt_ioepoch;
131
132         /* transaction callbacks */
133         struct dt_txn_callback     mdt_txn_cb;
134
135         /* these values should be updated from lov if necessary.
136          * or should be placed somewhere else. */
137         int                        mdt_max_mdsize;
138         int                        mdt_max_cookiesize;
139
140         struct upcall_cache        *mdt_identity_cache;
141
142         /* sptlrpc rules */
143         rwlock_t                   mdt_sptlrpc_lock;
144         struct sptlrpc_rule_set    mdt_sptlrpc_rset;
145
146         /* capability keys */
147         unsigned long              mdt_capa_timeout;
148         __u32                      mdt_capa_alg;
149         struct dt_object          *mdt_ck_obj;
150         unsigned long              mdt_ck_timeout;
151         unsigned long              mdt_ck_expiry;
152         cfs_timer_t                mdt_ck_timer;
153         struct ptlrpc_thread       mdt_ck_thread;
154         struct lustre_capa_key     mdt_capa_keys[2];
155         unsigned int               mdt_capa_conf:1,
156                                    mdt_som_conf:1,
157                                    /* Enable remote dir on non-MDT0 */
158                                    mdt_enable_remote_dir:1;
159
160         gid_t                      mdt_enable_remote_dir_gid;
161         /* statfs optimization: we cache a bit  */
162         struct obd_statfs          mdt_osfs;
163         __u64                      mdt_osfs_age;
164         spinlock_t                 mdt_osfs_lock;
165
166         /* root squash */
167         uid_t                      mdt_squash_uid;
168         gid_t                      mdt_squash_gid;
169         cfs_list_t                 mdt_nosquash_nids;
170         char                      *mdt_nosquash_str;
171         int                        mdt_nosquash_strlen;
172         struct rw_semaphore        mdt_squash_sem;
173
174         int                        mdt_sec_level;
175         struct rename_stats        mdt_rename_stats;
176         struct lu_fid              mdt_md_root_fid;
177
178         /* connection to quota master */
179         struct obd_export         *mdt_qmt_exp;
180         /* quota master device associated with this MDT */
181         struct lu_device          *mdt_qmt_dev;
182 };
183
184 #define MDT_SERVICE_WATCHDOG_FACTOR     (2)
185 #define MDT_ROCOMPAT_SUPP       (OBD_ROCOMPAT_LOVOBJID)
186 #define MDT_INCOMPAT_SUPP       (OBD_INCOMPAT_MDT | OBD_INCOMPAT_COMMON_LR | \
187                                 OBD_INCOMPAT_FID | OBD_INCOMPAT_IAM_DIR | \
188                                 OBD_INCOMPAT_LMM_VER | OBD_INCOMPAT_MULTI_OI)
189 #define MDT_COS_DEFAULT         (0)
190
191 struct mdt_object {
192         struct lu_object_header mot_header;
193         struct md_object        mot_obj;
194         __u64                   mot_ioepoch;
195         __u64                   mot_flags;
196         int                     mot_ioepoch_count;
197         int                     mot_writecount;
198         /* Lock to protect object's IO epoch. */
199         struct mutex            mot_ioepoch_mutex;
200         /* Lock to protect create_data */
201         struct mutex            mot_lov_mutex;
202 };
203
204 enum mdt_object_flags {
205         /** SOM attributes are changed. */
206         MOF_SOM_CHANGE  = (1 << 0),
207         /**
208          * The SOM recovery state for mdt object.
209          * This state is an in-memory equivalent of an absent SOM EA, used
210          * instead of invalidating SOM EA while IOEpoch is still opened when
211          * a client eviction occurs or a client fails to obtain SOM attributes.
212          * It indicates that the last IOEpoch holder will need to obtain SOM
213          * attributes under [0;EOF] extent lock to flush all the client's
214          * cached of evicted from MDS clients (but not necessary evicted from
215          * OST) before taking ost attributes.
216          */
217         MOF_SOM_RECOV   = (1 << 1),
218         /** File has been just created. */
219         MOF_SOM_CREATED = (1 << 2),
220         /** lov object has been created. */
221         MOF_LOV_CREATED = (1 << 3),
222 };
223
224 struct mdt_lock_handle {
225         /* Lock type, reg for cross-ref use or pdo lock. */
226         mdl_type_t              mlh_type;
227
228         /* Regular lock */
229         struct lustre_handle    mlh_reg_lh;
230         ldlm_mode_t             mlh_reg_mode;
231
232         /* Pdirops lock */
233         struct lustre_handle    mlh_pdo_lh;
234         ldlm_mode_t             mlh_pdo_mode;
235         unsigned int            mlh_pdo_hash;
236
237         /* Remote regular lock */
238         struct lustre_handle    mlh_rreg_lh;
239         ldlm_mode_t          mlh_rreg_mode;
240 };
241
242 enum {
243         MDT_LH_PARENT, /* parent lockh */
244         MDT_LH_CHILD,  /* child lockh */
245         MDT_LH_OLD,    /* old lockh for rename */
246         MDT_LH_LAYOUT = MDT_LH_OLD, /* layout lock */
247         MDT_LH_NEW,    /* new lockh for rename */
248         MDT_LH_RMT,    /* used for return lh to caller */
249         MDT_LH_NR
250 };
251
252 enum {
253         MDT_LOCAL_LOCK,
254         MDT_CROSS_LOCK
255 };
256
257 struct mdt_reint_record {
258         mdt_reint_t             rr_opcode;
259         const struct lustre_handle *rr_handle;
260         const struct lu_fid    *rr_fid1;
261         const struct lu_fid    *rr_fid2;
262         const char             *rr_name;
263         int                     rr_namelen;
264         const char             *rr_tgt;
265         int                     rr_tgtlen;
266         const void             *rr_eadata;
267         int                     rr_eadatalen;
268         int                     rr_logcookielen;
269         const struct llog_cookie  *rr_logcookies;
270         __u32                   rr_flags;
271 };
272
273 enum mdt_reint_flag {
274         MRF_OPEN_TRUNC = 1 << 0,
275 };
276
277 struct mdt_thread_info;
278 struct tx_arg;
279 typedef int (*tx_exec_func_t)(const struct lu_env *, struct thandle *,
280                               struct tx_arg *);
281
282 struct tx_arg {
283         tx_exec_func_t          exec_fn;
284         tx_exec_func_t          undo_fn;
285         struct dt_object        *object;
286         char                    *file;
287         struct update_reply     *reply;
288         int                     line;
289         int                     index;
290         union {
291                 struct {
292                         const struct dt_rec     *rec;
293                         const struct dt_key     *key;
294                 } insert;
295                 struct {
296                 } ref;
297                 struct {
298                         struct lu_attr  attr;
299                 } attr_set;
300                 struct {
301                         struct lu_buf   buf;
302                         const char      *name;
303                         int             flags;
304                         __u32           csum;
305                 } xattr_set;
306                 struct {
307                         struct lu_attr                  attr;
308                         struct dt_allocation_hint       hint;
309                         struct dt_object_format         dof;
310                         struct lu_fid                   fid;
311                 } create;
312                 struct {
313                         struct lu_buf   buf;
314                         loff_t          pos;
315                 } write;
316                 struct {
317                         struct ost_body     *body;
318                 } destroy;
319         } u;
320 };
321
322 #define TX_MAX_OPS        10
323 struct thandle_exec_args {
324         struct thandle          *ta_handle;
325         struct dt_device        *ta_dev;
326         int                     ta_err;
327         struct tx_arg           ta_args[TX_MAX_OPS];
328         int                     ta_argno;   /* used args */
329 };
330
331 /*
332  * Common data shared by mdt-level handlers. This is allocated per-thread to
333  * reduce stack consumption.
334  */
335 struct mdt_thread_info {
336         /*
337          * XXX: Part One:
338          * The following members will be filled explicitly
339          * with specific data in mdt_thread_info_init().
340          */
341         /* TODO: move this into mdt_session_key(with LCT_SESSION), because
342          * request handling may migrate from one server thread to another.
343          */
344         struct req_capsule        *mti_pill;
345
346         /* although we have export in req, there are cases when it is not
347          * available, e.g. closing files upon export destroy */
348         struct obd_export          *mti_exp;
349         /*
350          * A couple of lock handles.
351          */
352         struct mdt_lock_handle     mti_lh[MDT_LH_NR];
353
354         struct mdt_device         *mti_mdt;
355         const struct lu_env       *mti_env;
356
357         /*
358          * Additional fail id that can be set by handler. Passed to
359          * target_send_reply().
360          */
361         int                        mti_fail_id;
362
363         /* transaction number of current request */
364         __u64                      mti_transno;
365
366
367         /*
368          * XXX: Part Two:
369          * The following members will be filled expilictly
370          * with zero in mdt_thread_info_init(). These members may be used
371          * by all requests.
372          */
373
374         /*
375          * Object attributes.
376          */
377         struct md_attr             mti_attr;
378         /*
379          * Body for "habeo corpus" operations.
380          */
381         const struct mdt_body     *mti_body;
382         /*
383          * Host object. This is released at the end of mdt_handler().
384          */
385         struct mdt_object         *mti_object;
386         /*
387          * Lock request for "habeo clavis" operations.
388          */
389         const struct ldlm_request *mti_dlm_req;
390
391         __u32                      mti_has_trans:1, /* has txn already? */
392                                    mti_cross_ref:1;
393
394         /* opdata for mdt_reint_open(), has the same as
395          * ldlm_reply:lock_policy_res1.  mdt_update_last_rcvd() stores this
396          * value onto disk for recovery when mdt_trans_stop_cb() is called.
397          */
398         __u64                      mti_opdata;
399
400         /*
401          * XXX: Part Three:
402          * The following members will be filled explicitly
403          * with zero in mdt_reint_unpack(), because they are only used
404          * by reint requests (including mdt_reint_open()).
405          */
406
407         /*
408          * reint record. contains information for reint operations.
409          */
410         struct mdt_reint_record    mti_rr;
411
412         /** md objects included in operation */
413         struct mdt_object         *mti_mos;
414         __u64                      mti_ver[PTLRPC_NUM_VERSIONS];
415         /*
416          * Operation specification (currently create and lookup)
417          */
418         struct md_op_spec          mti_spec;
419
420         /*
421          * XXX: Part Four:
422          * The following members will _NOT_ be initialized at all.
423          * DO NOT expect them to contain any valid value.
424          * They should be initialized explicitly by the user themselves.
425          */
426
427          /* XXX: If something is in a union, make sure they do not conflict */
428
429         struct lu_fid              mti_tmp_fid1;
430         struct lu_fid              mti_tmp_fid2;
431         ldlm_policy_data_t         mti_policy;    /* for mdt_object_lock() and
432                                                    * mdt_rename_lock() */
433         struct ldlm_res_id         mti_res_id;    /* for mdt_object_lock() and
434                                                      mdt_rename_lock()   */
435         union {
436                 struct obd_uuid    uuid[2];       /* for mdt_seq_init_cli()  */
437                 char               ns_name[48];   /* for mdt_init0()         */
438                 struct lustre_cfg_bufs bufs;      /* for mdt_stack_fini()    */
439                 struct obd_statfs  osfs;          /* for mdt_statfs()        */
440                 struct {
441                         /* for mdt_readpage()      */
442                         struct lu_rdpg     mti_rdpg;
443                         /* for mdt_sendpage()      */
444                         struct l_wait_info mti_wait_info;
445                 } rdpg;
446                 struct {
447                         struct md_attr attr;
448                         struct md_som_data data;
449                 } som;
450                 struct {
451                         struct dt_object_format mti_update_dof;
452                         struct update_reply     *mti_update_reply;
453                         struct update           *mti_update;
454                         int                     mti_update_reply_index;
455                         struct obdo             mti_obdo;
456                         struct dt_object        *mti_dt_object;
457                 } update;
458         } mti_u;
459
460         /* IO epoch related stuff. */
461         struct mdt_ioepoch        *mti_ioepoch;
462         __u64                      mti_replayepoch;
463
464         loff_t                     mti_off;
465         struct lu_buf              mti_buf;
466         struct lu_buf              mti_big_buf;
467         struct lustre_capa_key     mti_capa_key;
468
469         /* Ops object filename */
470         struct lu_name             mti_name;
471         /* per-thread values, can be re-used */
472         void                      *mti_big_lmm;
473         int                        mti_big_lmmsize;
474         /* big_lmm buffer was used and must be used in reply */
475         int                        mti_big_lmm_used;
476         /* should be enough to fit lustre_mdt_attrs */
477         char                       mti_xattr_buf[128];
478         struct thandle_exec_args   mti_handle;
479         struct ldlm_enqueue_info   mti_einfo;
480 };
481
482 /* ptlrpc request handler for MDT. All handlers are
483  * grouped into several slices - struct mdt_opc_slice,
484  * and stored in an array - mdt_handlers[].
485  */
486 struct mdt_handler {
487         /* The name of this handler. */
488         const char *mh_name;
489         /* Fail id for this handler, checked at the beginning of this handler*/
490         int      mh_fail_id;
491         /* Operation code for this handler */
492         __u32       mh_opc;
493         /* flags are listed in enum mdt_handler_flags below. */
494         __u32       mh_flags;
495         /* The actual handler function to execute. */
496         int (*mh_act)(struct mdt_thread_info *info);
497         /* Request format for this request. */
498         const struct req_format *mh_fmt;
499 };
500
501 enum mdt_handler_flags {
502         /*
503          * struct mdt_body is passed in the incoming message, and object
504          * identified by this fid exists on disk.
505          *
506          * "habeo corpus" == "I have a body"
507          */
508         HABEO_CORPUS = (1 << 0),
509         /*
510          * struct ldlm_request is passed in the incoming message.
511          *
512          * "habeo clavis" == "I have a key"
513          */
514         HABEO_CLAVIS = (1 << 1),
515         /*
516          * this request has fixed reply format, so that reply message can be
517          * packed by generic code.
518          *
519          * "habeo refero" == "I have a reply"
520          */
521         HABEO_REFERO = (1 << 2),
522         /*
523          * this request will modify something, so check whether the filesystem
524          * is readonly or not, then return -EROFS to client asap if necessary.
525          *
526          * "mutabor" == "I shall modify"
527          */
528         MUTABOR      = (1 << 3)
529 };
530
531 struct mdt_opc_slice {
532         __u32                   mos_opc_start;
533         int                     mos_opc_end;
534         struct mdt_handler      *mos_hs;
535 };
536
537 static inline const struct md_device_operations *
538 mdt_child_ops(struct mdt_device * m)
539 {
540         LASSERT(m->mdt_child);
541         return m->mdt_child->md_ops;
542 }
543
544 static inline struct md_object *mdt_object_child(struct mdt_object *o)
545 {
546         LASSERT(o);
547         return lu2md(lu_object_next(&o->mot_obj.mo_lu));
548 }
549
550 static inline struct ptlrpc_request *mdt_info_req(struct mdt_thread_info *info)
551 {
552          return info->mti_pill ? info->mti_pill->rc_req : NULL;
553 }
554
555 static inline int req_is_replay(struct ptlrpc_request *req)
556 {
557         LASSERT(req->rq_reqmsg);
558         return !!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY);
559 }
560
561 static inline __u64 mdt_conn_flags(struct mdt_thread_info *info)
562 {
563         LASSERT(info->mti_exp);
564         return exp_connect_flags(info->mti_exp);
565 }
566
567 static inline void mdt_object_get(const struct lu_env *env,
568                                   struct mdt_object *o)
569 {
570         ENTRY;
571         lu_object_get(&o->mot_obj.mo_lu);
572         EXIT;
573 }
574
575 static inline void mdt_object_put(const struct lu_env *env,
576                                   struct mdt_object *o)
577 {
578         ENTRY;
579         lu_object_put(env, &o->mot_obj.mo_lu);
580         EXIT;
581 }
582
583 static inline int mdt_object_exists(const struct mdt_object *o)
584 {
585         return lu_object_exists(&o->mot_obj.mo_lu);
586 }
587
588 static inline int mdt_object_remote(const struct mdt_object *o)
589 {
590         return lu_object_remote(&o->mot_obj.mo_lu);
591 }
592
593 static inline const struct lu_fid *mdt_object_fid(const struct mdt_object *o)
594 {
595         return lu_object_fid(&o->mot_obj.mo_lu);
596 }
597
598 static inline struct lu_site *mdt_lu_site(const struct mdt_device *mdt)
599 {
600         return mdt->mdt_md_dev.md_lu_dev.ld_site;
601 }
602
603 static inline struct seq_server_site *mdt_seq_site(struct mdt_device *mdt)
604 {
605         return &mdt->mdt_seq_site;
606 }
607
608 static inline void mdt_export_evict(struct obd_export *exp)
609 {
610         class_fail_export(exp);
611         class_export_put(exp);
612 }
613
614 /* Here we use LVB_TYPE to check dne client, because it is
615  * also landed on 2.4. */
616 static inline int mdt_is_dne_client(struct obd_export *exp)
617 {
618         return !!(exp_connect_flags(exp) & OBD_CONNECT_LVB_TYPE);
619 }
620
621 int mdt_get_disposition(struct ldlm_reply *rep, int flag);
622 void mdt_set_disposition(struct mdt_thread_info *info,
623                         struct ldlm_reply *rep, int flag);
624 void mdt_clear_disposition(struct mdt_thread_info *info,
625                         struct ldlm_reply *rep, int flag);
626
627 void mdt_lock_pdo_init(struct mdt_lock_handle *lh,
628                        ldlm_mode_t lm, const char *name,
629                        int namelen);
630
631 void mdt_lock_reg_init(struct mdt_lock_handle *lh,
632                        ldlm_mode_t lm);
633
634 int mdt_lock_setup(struct mdt_thread_info *info,
635                    struct mdt_object *o,
636                    struct mdt_lock_handle *lh);
637
638 int mdt_object_lock(struct mdt_thread_info *,
639                     struct mdt_object *,
640                     struct mdt_lock_handle *,
641                     __u64, int);
642
643 int mdt_object_lock_try(struct mdt_thread_info *,
644                         struct mdt_object *,
645                         struct mdt_lock_handle *,
646                         __u64, int);
647
648 void mdt_object_unlock(struct mdt_thread_info *,
649                        struct mdt_object *,
650                        struct mdt_lock_handle *,
651                        int decref);
652
653 struct mdt_object *mdt_object_new(const struct lu_env *,
654                                   struct mdt_device *,
655                                   const struct lu_fid *);
656 struct mdt_object *mdt_object_find(const struct lu_env *,
657                                    struct mdt_device *,
658                                    const struct lu_fid *);
659 struct mdt_object *mdt_object_find_lock(struct mdt_thread_info *,
660                                         const struct lu_fid *,
661                                         struct mdt_lock_handle *,
662                                         __u64);
663 void mdt_object_unlock_put(struct mdt_thread_info *,
664                            struct mdt_object *,
665                            struct mdt_lock_handle *,
666                            int decref);
667
668 void mdt_client_compatibility(struct mdt_thread_info *info);
669
670 int mdt_remote_object_lock(struct mdt_thread_info *mti,
671                            struct mdt_object *o, struct lustre_handle *lh,
672                            ldlm_mode_t mode, __u64 ibits);
673 int mdt_close_unpack(struct mdt_thread_info *info);
674 int mdt_reint_unpack(struct mdt_thread_info *info, __u32 op);
675 int mdt_reint_rec(struct mdt_thread_info *, struct mdt_lock_handle *);
676 void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b,
677                         const struct lu_attr *attr, const struct lu_fid *fid);
678
679 int mdt_getxattr(struct mdt_thread_info *info);
680 int mdt_reint_setxattr(struct mdt_thread_info *info,
681                        struct mdt_lock_handle *lh);
682
683 void mdt_lock_handle_init(struct mdt_lock_handle *lh);
684 void mdt_lock_handle_fini(struct mdt_lock_handle *lh);
685
686 void mdt_reconstruct(struct mdt_thread_info *, struct mdt_lock_handle *);
687 void mdt_reconstruct_generic(struct mdt_thread_info *mti,
688                              struct mdt_lock_handle *lhc);
689
690 extern void target_recovery_fini(struct obd_device *obd);
691 extern void target_recovery_init(struct lu_target *lut,
692                                  svc_handler_t handler);
693 int mdt_fs_setup(const struct lu_env *, struct mdt_device *,
694                  struct obd_device *, struct lustre_sb_info *lsi);
695 void mdt_fs_cleanup(const struct lu_env *, struct mdt_device *);
696
697 int mdt_export_stats_init(struct obd_device *obd,
698                           struct obd_export *exp,
699                           void *client_nid);
700
701 int mdt_pin(struct mdt_thread_info* info);
702
703 int mdt_lock_new_child(struct mdt_thread_info *info,
704                        struct mdt_object *o,
705                        struct mdt_lock_handle *child_lockh);
706
707 void mdt_mfd_set_mode(struct mdt_file_data *mfd,
708                       int mode);
709
710 int mdt_reint_open(struct mdt_thread_info *info,
711                    struct mdt_lock_handle *lhc);
712
713 struct mdt_file_data *mdt_handle2mfd(struct mdt_thread_info *,
714                                      const struct lustre_handle *);
715
716 enum {
717         MDT_IOEPOCH_CLOSED  = 0,
718         MDT_IOEPOCH_OPENED  = 1,
719         MDT_IOEPOCH_GETATTR = 2,
720 };
721
722 enum {
723         MDT_SOM_DISABLE = 0,
724         MDT_SOM_ENABLE  = 1,
725 };
726
727 int mdt_attr_get_complex(struct mdt_thread_info *info,
728                          struct mdt_object *o, struct md_attr *ma);
729 int mdt_ioepoch_open(struct mdt_thread_info *info, struct mdt_object *o,
730                      int created);
731 int mdt_object_is_som_enabled(struct mdt_object *mo);
732 int mdt_write_get(struct mdt_object *o);
733 void mdt_write_put(struct mdt_object *o);
734 int mdt_write_read(struct mdt_object *o);
735 struct mdt_file_data *mdt_mfd_new(void);
736 int mdt_mfd_close(struct mdt_thread_info *info, struct mdt_file_data *mfd);
737 void mdt_mfd_free(struct mdt_file_data *mfd);
738 int mdt_close(struct mdt_thread_info *info);
739 int mdt_attr_set(struct mdt_thread_info *info, struct mdt_object *mo,
740                  struct md_attr *ma, int flags);
741 int mdt_add_dirty_flag(struct mdt_thread_info *info, struct mdt_object *mo,
742                         struct md_attr *ma);
743 int mdt_done_writing(struct mdt_thread_info *info);
744 int mdt_fix_reply(struct mdt_thread_info *info);
745 int mdt_handle_last_unlink(struct mdt_thread_info *, struct mdt_object *,
746                            const struct md_attr *);
747 void mdt_reconstruct_open(struct mdt_thread_info *, struct mdt_lock_handle *);
748
749 struct lu_buf *mdt_buf(const struct lu_env *env, void *area, ssize_t len);
750 const struct lu_buf *mdt_buf_const(const struct lu_env *env,
751                                    const void *area, ssize_t len);
752
753 void mdt_dump_lmm(int level, const struct lov_mds_md *lmm);
754
755 int mdt_check_ucred(struct mdt_thread_info *);
756 int mdt_init_ucred(struct mdt_thread_info *, struct mdt_body *);
757 int mdt_init_ucred_reint(struct mdt_thread_info *);
758 void mdt_exit_ucred(struct mdt_thread_info *);
759 int mdt_version_get_check(struct mdt_thread_info *, struct mdt_object *, int);
760 void mdt_version_get_save(struct mdt_thread_info *, struct mdt_object *, int);
761 int mdt_version_get_check_save(struct mdt_thread_info *, struct mdt_object *,
762                                int);
763 int mdt_handle_common(struct ptlrpc_request *req,
764                       struct mdt_opc_slice *supported);
765 int mdt_connect(struct mdt_thread_info *info);
766 int mdt_disconnect(struct mdt_thread_info *info);
767 int mdt_set_info(struct mdt_thread_info *info);
768 int mdt_get_info(struct mdt_thread_info *info);
769 int mdt_getstatus(struct mdt_thread_info *info);
770 int mdt_getattr(struct mdt_thread_info *info);
771 int mdt_getattr_name(struct mdt_thread_info *info);
772 int mdt_statfs(struct mdt_thread_info *info);
773 int mdt_reint(struct mdt_thread_info *info);
774 int mdt_sync(struct mdt_thread_info *info);
775 int mdt_is_subdir(struct mdt_thread_info *info);
776 int mdt_obd_ping(struct mdt_thread_info *info);
777 int mdt_obd_log_cancel(struct mdt_thread_info *info);
778 int mdt_obd_qc_callback(struct mdt_thread_info *info);
779 int mdt_enqueue(struct mdt_thread_info *info);
780 int mdt_convert(struct mdt_thread_info *info);
781 int mdt_bl_callback(struct mdt_thread_info *info);
782 int mdt_cp_callback(struct mdt_thread_info *info);
783 int mdt_llog_create(struct mdt_thread_info *info);
784 int mdt_llog_destroy(struct mdt_thread_info *info);
785 int mdt_llog_read_header(struct mdt_thread_info *info);
786 int mdt_llog_next_block(struct mdt_thread_info *info);
787 int mdt_llog_prev_block(struct mdt_thread_info *info);
788 int mdt_sec_ctx_handle(struct mdt_thread_info *info);
789 int mdt_readpage(struct mdt_thread_info *info);
790 int mdt_obd_idx_read(struct mdt_thread_info *info);
791
792 extern struct mdt_opc_slice mdt_regular_handlers[];
793 extern struct mdt_opc_slice mdt_seq_handlers[];
794 extern struct mdt_opc_slice mdt_fld_handlers[];
795
796 int mdt_quotacheck(struct mdt_thread_info *info);
797 int mdt_quotactl(struct mdt_thread_info *info);
798 int mdt_quota_dqacq(struct mdt_thread_info *info);
799 int mdt_swap_layouts(struct mdt_thread_info *info);
800
801 extern struct lprocfs_vars lprocfs_mds_module_vars[];
802 extern struct lprocfs_vars lprocfs_mds_obd_vars[];
803
804 int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj,
805                      struct md_hsm *mh);
806
807 struct mdt_handler *mdt_handler_find(__u32 opc,
808                                      struct mdt_opc_slice *supported);
809 /* mdt_idmap.c */
810 int mdt_init_sec_level(struct mdt_thread_info *);
811 int mdt_init_idmap(struct mdt_thread_info *);
812 void mdt_cleanup_idmap(struct mdt_export_data *);
813 int mdt_handle_idmap(struct mdt_thread_info *);
814 int ptlrpc_user_desc_do_idmap(struct ptlrpc_request *,
815                               struct ptlrpc_user_desc *);
816 void mdt_body_reverse_idmap(struct mdt_thread_info *,
817                             struct mdt_body *);
818 int mdt_remote_perm_reverse_idmap(struct ptlrpc_request *,
819                                   struct mdt_remote_perm *);
820 int mdt_fix_attr_ucred(struct mdt_thread_info *, __u32);
821
822 static inline struct mdt_device *mdt_dev(struct lu_device *d)
823 {
824 //        LASSERT(lu_device_is_mdt(d));
825         return container_of0(d, struct mdt_device, mdt_md_dev.md_lu_dev);
826 }
827
828 static inline struct dt_object *mdt_obj2dt(struct mdt_object *mo)
829 {
830         struct lu_object *lo;
831         struct mdt_device *mdt = mdt_dev(mo->mot_obj.mo_lu.lo_dev);
832
833         lo = lu_object_locate(mo->mot_obj.mo_lu.lo_header,
834                               mdt->mdt_bottom->dd_lu_dev.ld_type);
835         return lu2dt(lo);
836 }
837
838 /* mdt/mdt_identity.c */
839 #define MDT_IDENTITY_UPCALL_PATH        "/usr/sbin/l_getidentity"
840
841 extern struct upcall_cache_ops mdt_identity_upcall_cache_ops;
842
843 struct md_identity *mdt_identity_get(struct upcall_cache *, __u32);
844
845 void mdt_identity_put(struct upcall_cache *, struct md_identity *);
846
847 void mdt_flush_identity(struct upcall_cache *, int);
848
849 __u32 mdt_identity_get_perm(struct md_identity *, __u32, lnet_nid_t);
850
851 int mdt_pack_remote_perm(struct mdt_thread_info *, struct mdt_object *, void *);
852
853 /* mdt/mdt_hsm.c */
854 int mdt_hsm_state_get(struct mdt_thread_info *info);
855 int mdt_hsm_state_set(struct mdt_thread_info *info);
856 int mdt_hsm_action(struct mdt_thread_info *info);
857 int mdt_hsm_progress(struct mdt_thread_info *info);
858 int mdt_hsm_ct_register(struct mdt_thread_info *info);
859 int mdt_hsm_ct_unregister(struct mdt_thread_info *info);
860 int mdt_hsm_request(struct mdt_thread_info *info);
861
862 extern struct lu_context_key       mdt_thread_key;
863 /* debug issues helper starts here*/
864 static inline int mdt_fail_write(const struct lu_env *env,
865                                  struct dt_device *dd, int id)
866 {
867         if (OBD_FAIL_CHECK_ORSET(id, OBD_FAIL_ONCE)) {
868                 CERROR(LUSTRE_MDT_NAME": cfs_fail_loc=%x, fail write ops\n",
869                        id);
870                 return dd->dd_ops->dt_ro(env, dd);
871                 /* We set FAIL_ONCE because we never "un-fail" a device */
872         }
873
874         return 0;
875 }
876
877 static inline struct mdt_export_data *mdt_req2med(struct ptlrpc_request *req)
878 {
879         return &req->rq_export->exp_mdt_data;
880 }
881
882 typedef void (*mdt_reconstruct_t)(struct mdt_thread_info *mti,
883                                   struct mdt_lock_handle *lhc);
884 static inline int mdt_check_resent(struct mdt_thread_info *info,
885                                    mdt_reconstruct_t reconstruct,
886                                    struct mdt_lock_handle *lhc)
887 {
888         struct ptlrpc_request *req = mdt_info_req(info);
889         ENTRY;
890
891         if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) {
892                 if (req_xid_is_last(req)) {
893                         reconstruct(info, lhc);
894                         RETURN(1);
895                 }
896                 DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")",
897                           req->rq_export->exp_target_data.ted_lcd->lcd_last_xid);
898         }
899         RETURN(0);
900 }
901
902 struct lu_ucred *mdt_ucred(const struct mdt_thread_info *info);
903 struct lu_ucred *mdt_ucred_check(const struct mdt_thread_info *info);
904
905 static inline int is_identity_get_disabled(struct upcall_cache *cache)
906 {
907         return cache ? (strcmp(cache->uc_upcall, "NONE") == 0) : 1;
908 }
909
910 int mdt_blocking_ast(struct ldlm_lock*, struct ldlm_lock_desc*, void*, int);
911
912 /* Issues dlm lock on passed @ns, @f stores it lock handle into @lh. */
913 static inline int mdt_fid_lock(struct ldlm_namespace *ns,
914                                struct lustre_handle *lh,
915                                ldlm_mode_t mode,
916                                ldlm_policy_data_t *policy,
917                                const struct ldlm_res_id *res_id,
918                                __u64 flags, const __u64 *client_cookie)
919 {
920         int rc;
921
922         LASSERT(ns != NULL);
923         LASSERT(lh != NULL);
924
925         rc = ldlm_cli_enqueue_local(ns, res_id, LDLM_IBITS, policy,
926                                     mode, &flags, mdt_blocking_ast,
927                                     ldlm_completion_ast, NULL, NULL, 0,
928                                     LVB_T_NONE, client_cookie, lh);
929         return rc == ELDLM_OK ? 0 : -EIO;
930 }
931
932 static inline void mdt_fid_unlock(struct lustre_handle *lh,
933                                   ldlm_mode_t mode)
934 {
935         ldlm_lock_decref(lh, mode);
936 }
937
938 extern mdl_mode_t mdt_mdl_lock_modes[];
939 extern ldlm_mode_t mdt_dlm_lock_modes[];
940
941 static inline mdl_mode_t mdt_dlm_mode2mdl_mode(ldlm_mode_t mode)
942 {
943         LASSERT(IS_PO2(mode));
944         return mdt_mdl_lock_modes[mode];
945 }
946
947 static inline ldlm_mode_t mdt_mdl_mode2dlm_mode(mdl_mode_t mode)
948 {
949         LASSERT(IS_PO2(mode));
950         return mdt_dlm_lock_modes[mode];
951 }
952
953 /* mdt_lvb.c */
954 extern struct ldlm_valblock_ops mdt_lvbo;
955
956 static inline struct lu_name *mdt_name(const struct lu_env *env,
957                                        char *name, int namelen)
958 {
959         struct lu_name *lname;
960         struct mdt_thread_info *mti;
961
962         LASSERT(namelen > 0);
963         /* trailing '\0' in buffer */
964         LASSERT(name[namelen] == '\0');
965
966         mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
967         lname = &mti->mti_name;
968         lname->ln_name = name;
969         lname->ln_namelen = namelen;
970         return lname;
971 }
972
973 static inline struct lu_name *mdt_name_copy(struct lu_name *tlname,
974                                             struct lu_name *slname)
975 {
976         LASSERT(tlname);
977         LASSERT(slname);
978
979         tlname->ln_name = slname->ln_name;
980         tlname->ln_namelen = slname->ln_namelen;
981         return tlname;
982 }
983
984 void mdt_enable_cos(struct mdt_device *, int);
985 int mdt_cos_is_enabled(struct mdt_device *);
986 int mdt_hsm_copytool_send(struct obd_export *exp);
987
988 /* lprocfs stuff */
989 enum {
990         LPROC_MDT_OPEN = 0,
991         LPROC_MDT_CLOSE,
992         LPROC_MDT_MKNOD,
993         LPROC_MDT_LINK,
994         LPROC_MDT_UNLINK,
995         LPROC_MDT_MKDIR,
996         LPROC_MDT_RMDIR,
997         LPROC_MDT_RENAME,
998         LPROC_MDT_GETATTR,
999         LPROC_MDT_SETATTR,
1000         LPROC_MDT_GETXATTR,
1001         LPROC_MDT_SETXATTR,
1002         LPROC_MDT_STATFS,
1003         LPROC_MDT_SYNC,
1004         LPROC_MDT_SAMEDIR_RENAME,
1005         LPROC_MDT_CROSSDIR_RENAME,
1006         LPROC_MDT_LAST,
1007 };
1008 void mdt_counter_incr(struct ptlrpc_request *req, int opcode);
1009 void mdt_stats_counter_init(struct lprocfs_stats *stats);
1010 void lprocfs_mdt_init_vars(struct lprocfs_static_vars *lvars);
1011 void lprocfs_mds_init_vars(struct lprocfs_static_vars *lvars);
1012 int mdt_procfs_init(struct mdt_device *mdt, const char *name);
1013 void mdt_procfs_fini(struct mdt_device *mdt);
1014 void mdt_rename_counter_tally(struct mdt_thread_info *info,
1015                               struct mdt_device *mdt,
1016                               struct ptlrpc_request *req,
1017                               struct mdt_object *src, struct mdt_object *tgt);
1018
1019 /* Capability */
1020 int mdt_ck_thread_start(struct mdt_device *mdt);
1021 void mdt_ck_thread_stop(struct mdt_device *mdt);
1022 void mdt_ck_timer_callback(unsigned long castmeharder);
1023 int mdt_capa_keys_init(const struct lu_env *env, struct mdt_device *mdt);
1024
1025 static inline void mdt_set_capainfo(struct mdt_thread_info *info, int offset,
1026                                     const struct lu_fid *fid,
1027                                     struct lustre_capa *capa)
1028 {
1029         struct md_capainfo *ci;
1030
1031         LASSERT(offset >= 0 && offset < MD_CAPAINFO_MAX);
1032         if (!info->mti_mdt->mdt_opts.mo_mds_capa ||
1033             !(exp_connect_flags(info->mti_exp) & OBD_CONNECT_MDS_CAPA))
1034                 return;
1035
1036         ci = md_capainfo(info->mti_env);
1037         LASSERT(ci);
1038         ci->mc_fid[offset]  = *fid;
1039         ci->mc_capa[offset] = capa;
1040 }
1041
1042 static inline void mdt_dump_capainfo(struct mdt_thread_info *info)
1043 {
1044         struct md_capainfo *ci = md_capainfo(info->mti_env);
1045         int i;
1046
1047         if (!ci)
1048                 return;
1049         for (i = 0; i < MD_CAPAINFO_MAX; i++) {
1050                 if (!ci->mc_capa[i]) {
1051                         CERROR("no capa for index %d "DFID"\n",
1052                                i, PFID(&ci->mc_fid[i]));
1053                         continue;
1054                 }
1055                 if (ci->mc_capa[i] == BYPASS_CAPA) {
1056                         CERROR("bypass for index %d "DFID"\n",
1057                                i, PFID(&ci->mc_fid[i]));
1058                         continue;
1059                 }
1060                 DEBUG_CAPA(D_ERROR, ci->mc_capa[i], "index %d", i);
1061         }
1062 }
1063
1064 static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt)
1065 {
1066         return mdt->mdt_md_dev.md_lu_dev.ld_obd;
1067 }
1068
1069 extern const struct lu_device_operations mdt_lu_ops;
1070
1071 static inline int lu_device_is_mdt(struct lu_device *d)
1072 {
1073         return ergo(d != NULL && d->ld_ops != NULL, d->ld_ops == &mdt_lu_ops);
1074 }
1075
1076 static inline struct mdt_device *lu2mdt_dev(struct lu_device *d)
1077 {
1078         LASSERTF(lu_device_is_mdt(d), "It is %s instead of MDT %p %p\n",
1079                  d->ld_type->ldt_name, d->ld_ops, &mdt_lu_ops);
1080         return container_of0(d, struct mdt_device, mdt_md_dev.md_lu_dev);
1081 }
1082
1083 static inline char *mdt_obd_name(struct mdt_device *mdt)
1084 {
1085         return mdt->mdt_md_dev.md_lu_dev.ld_obd->obd_name;
1086 }
1087
1088 int mds_mod_init(void);
1089 void mds_mod_exit(void);
1090
1091 /* Update handlers */
1092 int out_handle(struct mdt_thread_info *info);
1093
1094 #define out_tx_create(info, obj, attr, fid, dof, th, reply, idx) \
1095         __out_tx_create(info, obj, attr, fid, dof, th, reply, idx, \
1096                         __FILE__, __LINE__)
1097
1098 #define out_tx_attr_set(info, obj, attr, th, reply, idx) \
1099         __out_tx_attr_set(info, obj, attr, th, reply, idx, \
1100                           __FILE__, __LINE__)
1101
1102 #define out_tx_xattr_set(info, obj, buf, name, fl, th, reply, idx)      \
1103         __out_tx_xattr_set(info, obj, buf, name, fl, th, reply, idx,    \
1104                            __FILE__, __LINE__)
1105
1106 #define out_tx_ref_add(info, obj, th, reply, idx) \
1107         __out_tx_ref_add(info, obj, th, reply, idx, __FILE__, __LINE__)
1108
1109 #define out_tx_ref_del(info, obj, th, reply, idx) \
1110         __out_tx_ref_del(info, obj, th, reply, idx, __FILE__, __LINE__)
1111
1112 #define out_tx_index_insert(info, obj, th, name, fid, reply, idx) \
1113         __out_tx_index_insert(info, obj, th, name, fid, reply, idx, \
1114                               __FILE__, __LINE__)
1115
1116 #define out_tx_index_delete(info, obj, th, name, reply, idx) \
1117         __out_tx_index_delete(info, obj, th, name, reply, idx, \
1118                               __FILE__, __LINE__)
1119
1120 #define out_tx_destroy(info, obj, th, reply, idx) \
1121         __out_tx_destroy(info, obj, th, reply, idx, __FILE__, __LINE__)
1122
1123 #endif /* __KERNEL__ */
1124 #endif /* _MDT_H */