Whamcloud - gitweb
LU-909 osd: changes to osd api
[fs/lustre-release.git] / lustre / mdt / mdt_internal.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
30  * Use is subject to license terms.
31  *
32  * Copyright (c) 2011 Whamcloud, Inc.
33  *
34  */
35 /*
36  * This file is part of Lustre, http://www.lustre.org/
37  * Lustre is a trademark of Sun Microsystems, Inc.
38  *
39  * lustre/mdt/mdt_internal.h
40  *
41  * Lustre Metadata Target (mdt) request handler
42  *
43  * Author: Peter Braam <braam@clusterfs.com>
44  * Author: Andreas Dilger <adilger@clusterfs.com>
45  * Author: Phil Schwan <phil@clusterfs.com>
46  * Author: Mike Shaver <shaver@clusterfs.com>
47  * Author: Nikita Danilov <nikita@clusterfs.com>
48  * Author: Huang Hua <huanghua@clusterfs.com>
49  */
50
51 #ifndef _MDT_INTERNAL_H
52 #define _MDT_INTERNAL_H
53
54 #if defined(__KERNEL__)
55
56 /*
57  * struct ptlrpc_client
58  */
59 #include <lustre_net.h>
60 #include <obd.h>
61 /*
62  * struct obd_connect_data
63  * struct lustre_handle
64  */
65 #include <lustre/lustre_idl.h>
66 #include <lustre_disk.h>
67 #include <lu_target.h>
68 #include <md_object.h>
69 #include <lustre_fid.h>
70 #include <lustre_fld.h>
71 #include <lustre_req_layout.h>
72 #include <lustre_sec.h>
73 #include <lvfs.h>
74 #include <lustre_idmap.h>
75 #include <lustre_eacl.h>
76 #include <lustre_fsfilt.h>
77
78 /* check if request's xid is equal to last one or not*/
79 static inline int req_xid_is_last(struct ptlrpc_request *req)
80 {
81         struct lsd_client_data *lcd = req->rq_export->exp_target_data.ted_lcd;
82         return (req->rq_xid == lcd->lcd_last_xid ||
83                 req->rq_xid == lcd->lcd_last_close_xid);
84 }
85
86 struct mdt_object;
87 /* file data for open files on MDS */
88 struct mdt_file_data {
89         struct portals_handle mfd_handle; /* must be first */
90         cfs_list_t            mfd_list;   /* protected by med_open_lock */
91         __u64                 mfd_xid;    /* xid of the open request */
92         struct lustre_handle  mfd_old_handle; /* old handle in replay case */
93         int                   mfd_mode;   /* open mode provided by client */
94         struct mdt_object    *mfd_object; /* point to opened object */
95 };
96
97 /* mdt state flag bits */
98 #define MDT_FL_CFGLOG 0
99 #define MDT_FL_SYNCED 1
100
101 struct mdt_device {
102         /* super-class */
103         struct md_device           mdt_md_dev;
104         struct ptlrpc_service     *mdt_regular_service;
105         struct ptlrpc_service     *mdt_readpage_service;
106         struct ptlrpc_service     *mdt_xmds_service;
107         struct ptlrpc_service     *mdt_setattr_service;
108         struct ptlrpc_service     *mdt_mdsc_service;
109         struct ptlrpc_service     *mdt_mdss_service;
110         struct ptlrpc_service     *mdt_dtss_service;
111         struct ptlrpc_service     *mdt_fld_service;
112         /* DLM name-space for meta-data locks maintained by this server */
113         struct ldlm_namespace     *mdt_namespace;
114         /* ptlrpc handle for MDS->client connections (for lock ASTs). */
115         struct ptlrpc_client      *mdt_ldlm_client;
116         /* underlying device */
117         struct md_device          *mdt_child;
118         struct dt_device          *mdt_bottom;
119         /** target device */
120         struct lu_target           mdt_lut;
121         /*
122          * Options bit-fields.
123          */
124         struct {
125                 signed int         mo_user_xattr :1,
126                                    mo_acl        :1,
127                                    mo_compat_resname:1,
128                                    mo_mds_capa   :1,
129                                    mo_oss_capa   :1,
130                                    mo_cos        :1;
131         } mdt_opts;
132         /* mdt state flags */
133         unsigned long              mdt_state;
134         /* lock to protect IOepoch */
135         cfs_spinlock_t             mdt_ioepoch_lock;
136         __u64                      mdt_ioepoch;
137
138         /* transaction callbacks */
139         struct dt_txn_callback     mdt_txn_cb;
140
141         /* these values should be updated from lov if necessary.
142          * or should be placed somewhere else. */
143         int                        mdt_max_mdsize;
144         int                        mdt_max_cookiesize;
145
146         struct upcall_cache        *mdt_identity_cache;
147
148         /* sptlrpc rules */
149         cfs_rwlock_t               mdt_sptlrpc_lock;
150         struct sptlrpc_rule_set    mdt_sptlrpc_rset;
151
152         /* capability keys */
153         unsigned long              mdt_capa_timeout;
154         __u32                      mdt_capa_alg;
155         struct dt_object          *mdt_ck_obj;
156         unsigned long              mdt_ck_timeout;
157         unsigned long              mdt_ck_expiry;
158         cfs_timer_t                mdt_ck_timer;
159         struct ptlrpc_thread       mdt_ck_thread;
160         struct lustre_capa_key     mdt_capa_keys[2];
161         unsigned int               mdt_capa_conf:1,
162                                    mdt_som_conf:1;
163
164         /* root squash */
165         uid_t                      mdt_squash_uid;
166         gid_t                      mdt_squash_gid;
167         cfs_list_t                 mdt_nosquash_nids;
168         char                      *mdt_nosquash_str;
169         int                        mdt_nosquash_strlen;
170         cfs_rw_semaphore_t         mdt_squash_sem;
171
172         cfs_proc_dir_entry_t      *mdt_proc_entry;
173         struct lprocfs_stats      *mdt_stats;
174         int                        mdt_sec_level;
175 };
176
177 #define MDT_SERVICE_WATCHDOG_FACTOR     (2)
178 #define MDT_ROCOMPAT_SUPP       (OBD_ROCOMPAT_LOVOBJID)
179 #define MDT_INCOMPAT_SUPP       (OBD_INCOMPAT_MDT | OBD_INCOMPAT_COMMON_LR | \
180                                  OBD_INCOMPAT_FID | OBD_INCOMPAT_IAM_DIR)
181 #define MDT_COS_DEFAULT         (0)
182
183 struct mdt_object {
184         struct lu_object_header mot_header;
185         struct md_object        mot_obj;
186         __u64                   mot_ioepoch;
187         __u64                   mot_flags;
188         int                     mot_ioepoch_count;
189         int                     mot_writecount;
190         /* Lock to protect object's IO epoch. */
191         cfs_semaphore_t         mot_ioepoch_sem;
192         /* Lock to protect create_data */
193         cfs_semaphore_t         mot_lov_sem;
194 };
195
196 enum mdt_object_flags {
197         /** SOM attributes are changed. */
198         MOF_SOM_CHANGE  = (1 << 0),
199         /**
200          * The SOM recovery state for mdt object.
201          * This state is an in-memory equivalent of an absent SOM EA, used
202          * instead of invalidating SOM EA while IOEpoch is still opened when
203          * a client eviction occurs or a client fails to obtain SOM attributes.
204          * It indicates that the last IOEpoch holder will need to obtain SOM
205          * attributes under [0;EOF] extent lock to flush all the client's
206          * cached of evicted from MDS clients (but not necessary evicted from
207          * OST) before taking ost attributes.
208          */
209         MOF_SOM_RECOV   = (1 << 1),
210         /** File has been just created. */
211         MOF_SOM_CREATED = (1 << 2),
212         /** lov object has been created. */
213         MOF_LOV_CREATED = (1 << 3),
214 };
215
216 struct mdt_lock_handle {
217         /* Lock type, reg for cross-ref use or pdo lock. */
218         mdl_type_t              mlh_type;
219
220         /* Regular lock */
221         struct lustre_handle    mlh_reg_lh;
222         ldlm_mode_t             mlh_reg_mode;
223
224         /* Pdirops lock */
225         struct lustre_handle    mlh_pdo_lh;
226         ldlm_mode_t             mlh_pdo_mode;
227         unsigned int            mlh_pdo_hash;
228 };
229
230 enum {
231         MDT_LH_PARENT, /* parent lockh */
232         MDT_LH_CHILD,  /* child lockh */
233         MDT_LH_OLD,    /* old lockh for rename */
234         MDT_LH_NEW,    /* new lockh for rename */
235         MDT_LH_RMT,    /* used for return lh to caller */
236         MDT_LH_NR
237 };
238
239 enum {
240         MDT_LOCAL_LOCK,
241         MDT_CROSS_LOCK
242 };
243
244 struct mdt_reint_record {
245         mdt_reint_t             rr_opcode;
246         const struct lustre_handle *rr_handle;
247         const struct lu_fid    *rr_fid1;
248         const struct lu_fid    *rr_fid2;
249         const char             *rr_name;
250         int                     rr_namelen;
251         const char             *rr_tgt;
252         int                     rr_tgtlen;
253         const void             *rr_eadata;
254         int                     rr_eadatalen;
255         int                     rr_logcookielen;
256         const struct llog_cookie  *rr_logcookies;
257         __u32                   rr_flags;
258 };
259
260 enum mdt_reint_flag {
261         MRF_OPEN_TRUNC = 1 << 0,
262 };
263
264 /*
265  * Common data shared by mdt-level handlers. This is allocated per-thread to
266  * reduce stack consumption.
267  */
268 struct mdt_thread_info {
269         /*
270          * XXX: Part One:
271          * The following members will be filled explicitly
272          * with specific data in mdt_thread_info_init().
273          */
274         /* TODO: move this into mdt_session_key(with LCT_SESSION), because
275          * request handling may migrate from one server thread to another.
276          */
277         struct req_capsule        *mti_pill;
278
279         /* although we have export in req, there are cases when it is not
280          * available, e.g. closing files upon export destroy */
281         struct obd_export          *mti_exp;
282         /*
283          * A couple of lock handles.
284          */
285         struct mdt_lock_handle     mti_lh[MDT_LH_NR];
286
287         struct mdt_device         *mti_mdt;
288         const struct lu_env       *mti_env;
289
290         /*
291          * Additional fail id that can be set by handler. Passed to
292          * target_send_reply().
293          */
294         int                        mti_fail_id;
295
296         /* transaction number of current request */
297         __u64                      mti_transno;
298
299
300         /*
301          * XXX: Part Two:
302          * The following members will be filled expilictly
303          * with zero in mdt_thread_info_init(). These members may be used
304          * by all requests.
305          */
306
307         /*
308          * Object attributes.
309          */
310         struct md_attr             mti_attr;
311         /*
312          * Body for "habeo corpus" operations.
313          */
314         const struct mdt_body     *mti_body;
315         /*
316          * Host object. This is released at the end of mdt_handler().
317          */
318         struct mdt_object         *mti_object;
319         /*
320          * Lock request for "habeo clavis" operations.
321          */
322         const struct ldlm_request *mti_dlm_req;
323
324         __u32                      mti_has_trans:1, /* has txn already? */
325                                    mti_no_need_trans:1,
326                                    mti_cross_ref:1;
327
328         /* opdata for mdt_reint_open(), has the same as
329          * ldlm_reply:lock_policy_res1.  mdt_update_last_rcvd() stores this
330          * value onto disk for recovery when mdt_trans_stop_cb() is called.
331          */
332         __u64                      mti_opdata;
333
334         /*
335          * XXX: Part Three:
336          * The following members will be filled explicitly
337          * with zero in mdt_reint_unpack(), because they are only used
338          * by reint requests (including mdt_reint_open()).
339          */
340
341         /*
342          * reint record. contains information for reint operations.
343          */
344         struct mdt_reint_record    mti_rr;
345
346         /** md objects included in operation */
347         struct mdt_object         *mti_mos;
348         __u64                      mti_ver[PTLRPC_NUM_VERSIONS];
349         /*
350          * Operation specification (currently create and lookup)
351          */
352         struct md_op_spec          mti_spec;
353
354         /*
355          * XXX: Part Four:
356          * The following members will _NOT_ be initialized at all.
357          * DO NOT expect them to contain any valid value.
358          * They should be initialized explicitly by the user themselves.
359          */
360
361          /* XXX: If something is in a union, make sure they do not conflict */
362
363         struct lu_fid              mti_tmp_fid1;
364         struct lu_fid              mti_tmp_fid2;
365         ldlm_policy_data_t         mti_policy;    /* for mdt_object_lock() and
366                                                    * mdt_rename_lock() */
367         struct ldlm_res_id         mti_res_id;    /* for mdt_object_lock() and
368                                                      mdt_rename_lock()   */
369         union {
370                 struct obd_uuid    uuid[2];       /* for mdt_seq_init_cli()  */
371                 char               ns_name[48];   /* for mdt_init0()         */
372                 struct lustre_cfg_bufs bufs;      /* for mdt_stack_fini()    */
373                 cfs_kstatfs_t      ksfs;          /* for mdt_statfs()        */
374                 struct {
375                         /* for mdt_readpage()      */
376                         struct lu_rdpg     mti_rdpg;
377                         /* for mdt_sendpage()      */
378                         struct l_wait_info mti_wait_info;
379                 } rdpg;
380                 struct {
381                         struct md_attr attr;
382                         struct md_som_data data;
383                 } som;
384         } mti_u;
385
386         /* IO epoch related stuff. */
387         struct mdt_ioepoch        *mti_ioepoch;
388         __u64                      mti_replayepoch;
389
390         /* server and client data buffers */
391         struct lr_server_data      mti_lsd;
392         struct lsd_client_data     mti_lcd;
393         loff_t                     mti_off;
394         struct lu_buf              mti_buf;
395         struct lustre_capa_key     mti_capa_key;
396
397         /* Ops object filename */
398         struct lu_name             mti_name;
399         struct md_attr             mti_tmp_attr;
400 };
401
402 typedef void (*mdt_cb_t)(const struct mdt_device *mdt, __u64 transno,
403                          void *data, int err);
404 struct mdt_commit_cb {
405         mdt_cb_t  mdt_cb_func;
406         void     *mdt_cb_data;
407 };
408
409 enum mdt_txn_op {
410         MDT_TXN_CAPA_KEYS_WRITE_OP,
411         MDT_TXN_LAST_RCVD_WRITE_OP,
412 };
413
414 static inline const struct md_device_operations *
415 mdt_child_ops(struct mdt_device * m)
416 {
417         LASSERT(m->mdt_child);
418         return m->mdt_child->md_ops;
419 }
420
421 static inline struct md_object *mdt_object_child(struct mdt_object *o)
422 {
423         LASSERT(o);
424         return lu2md(lu_object_next(&o->mot_obj.mo_lu));
425 }
426
427 static inline struct ptlrpc_request *mdt_info_req(struct mdt_thread_info *info)
428 {
429          return info->mti_pill ? info->mti_pill->rc_req : NULL;
430 }
431
432 static inline int req_is_replay(struct ptlrpc_request *req)
433 {
434         LASSERT(req->rq_reqmsg);
435         return !!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY);
436 }
437
438 static inline __u64 mdt_conn_flags(struct mdt_thread_info *info)
439 {
440         LASSERT(info->mti_exp);
441         return info->mti_exp->exp_connect_flags;
442 }
443
444 static inline void mdt_object_get(const struct lu_env *env,
445                                   struct mdt_object *o)
446 {
447         ENTRY;
448         lu_object_get(&o->mot_obj.mo_lu);
449         EXIT;
450 }
451
452 static inline void mdt_object_put(const struct lu_env *env,
453                                   struct mdt_object *o)
454 {
455         ENTRY;
456         lu_object_put(env, &o->mot_obj.mo_lu);
457         EXIT;
458 }
459
460 static inline int mdt_object_exists(const struct mdt_object *o)
461 {
462         return lu_object_exists(&o->mot_obj.mo_lu);
463 }
464
465 static inline const struct lu_fid *mdt_object_fid(struct mdt_object *o)
466 {
467         return lu_object_fid(&o->mot_obj.mo_lu);
468 }
469
470 static inline struct lu_site *mdt_lu_site(const struct mdt_device *mdt)
471 {
472         return mdt->mdt_md_dev.md_lu_dev.ld_site;
473 }
474
475 static inline struct md_site *mdt_md_site(const struct mdt_device *mdt)
476 {
477         return lu_site2md(mdt_lu_site(mdt));
478 }
479
480 static inline void mdt_export_evict(struct obd_export *exp)
481 {
482         class_fail_export(exp);
483         class_export_put(exp);
484 }
485
486 int mdt_get_disposition(struct ldlm_reply *rep, int flag);
487 void mdt_set_disposition(struct mdt_thread_info *info,
488                         struct ldlm_reply *rep, int flag);
489 void mdt_clear_disposition(struct mdt_thread_info *info,
490                         struct ldlm_reply *rep, int flag);
491
492 void mdt_lock_pdo_init(struct mdt_lock_handle *lh,
493                        ldlm_mode_t lm, const char *name,
494                        int namelen);
495
496 void mdt_lock_reg_init(struct mdt_lock_handle *lh,
497                        ldlm_mode_t lm);
498
499 int mdt_lock_setup(struct mdt_thread_info *info,
500                    struct mdt_object *o,
501                    struct mdt_lock_handle *lh);
502
503 int mdt_object_lock(struct mdt_thread_info *,
504                     struct mdt_object *,
505                     struct mdt_lock_handle *,
506                     __u64, int);
507
508 void mdt_object_unlock(struct mdt_thread_info *,
509                        struct mdt_object *,
510                        struct mdt_lock_handle *,
511                        int decref);
512
513 struct mdt_object *mdt_object_find(const struct lu_env *,
514                                    struct mdt_device *,
515                                    const struct lu_fid *);
516 struct mdt_object *mdt_object_find_lock(struct mdt_thread_info *,
517                                         const struct lu_fid *,
518                                         struct mdt_lock_handle *,
519                                         __u64);
520 void mdt_object_unlock_put(struct mdt_thread_info *,
521                            struct mdt_object *,
522                            struct mdt_lock_handle *,
523                            int decref);
524
525 int mdt_close_unpack(struct mdt_thread_info *info);
526 int mdt_reint_unpack(struct mdt_thread_info *info, __u32 op);
527 int mdt_reint_rec(struct mdt_thread_info *, struct mdt_lock_handle *);
528 void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b,
529                         const struct lu_attr *attr, const struct lu_fid *fid);
530
531 int mdt_getxattr(struct mdt_thread_info *info);
532 int mdt_reint_setxattr(struct mdt_thread_info *info,
533                        struct mdt_lock_handle *lh);
534
535 void mdt_lock_handle_init(struct mdt_lock_handle *lh);
536 void mdt_lock_handle_fini(struct mdt_lock_handle *lh);
537
538 void mdt_reconstruct(struct mdt_thread_info *, struct mdt_lock_handle *);
539 void mdt_reconstruct_generic(struct mdt_thread_info *mti,
540                              struct mdt_lock_handle *lhc);
541
542 extern void target_recovery_fini(struct obd_device *obd);
543 extern void target_recovery_init(struct lu_target *lut,
544                                  svc_handler_t handler);
545 int mdt_fs_setup(const struct lu_env *, struct mdt_device *,
546                  struct obd_device *, struct lustre_sb_info *lsi);
547 void mdt_fs_cleanup(const struct lu_env *, struct mdt_device *);
548
549 int mdt_client_del(const struct lu_env *env,
550                     struct mdt_device *mdt);
551 int mdt_client_add(const struct lu_env *env,
552                    struct mdt_device *mdt,
553                    int cl_idx);
554 int mdt_client_new(const struct lu_env *env,
555                    struct mdt_device *mdt);
556
557 int mdt_export_stats_init(struct obd_device *obd,
558                           struct obd_export *exp,
559                           void *client_nid);
560
561 int mdt_pin(struct mdt_thread_info* info);
562
563 int mdt_lock_new_child(struct mdt_thread_info *info,
564                        struct mdt_object *o,
565                        struct mdt_lock_handle *child_lockh);
566
567 void mdt_mfd_set_mode(struct mdt_file_data *mfd,
568                       int mode);
569
570 int mdt_reint_open(struct mdt_thread_info *info,
571                    struct mdt_lock_handle *lhc);
572
573 struct mdt_file_data *mdt_handle2mfd(struct mdt_thread_info *,
574                                      const struct lustre_handle *);
575
576 enum {
577         MDT_IOEPOCH_CLOSED  = 0,
578         MDT_IOEPOCH_OPENED  = 1,
579         MDT_IOEPOCH_GETATTR = 2,
580 };
581
582 enum {
583         MDT_SOM_DISABLE = 0,
584         MDT_SOM_ENABLE  = 1,
585 };
586
587 int mdt_ioepoch_open(struct mdt_thread_info *info, struct mdt_object *o,
588                      int created);
589 int mdt_object_is_som_enabled(struct mdt_object *mo);
590 int mdt_write_get(struct mdt_object *o);
591 void mdt_write_put(struct mdt_object *o);
592 int mdt_write_read(struct mdt_object *o);
593 struct mdt_file_data *mdt_mfd_new(void);
594 int mdt_mfd_close(struct mdt_thread_info *info, struct mdt_file_data *mfd);
595 void mdt_mfd_free(struct mdt_file_data *mfd);
596 int mdt_close(struct mdt_thread_info *info);
597 int mdt_attr_set(struct mdt_thread_info *info, struct mdt_object *mo,
598                  struct md_attr *ma, int flags);
599 int mdt_done_writing(struct mdt_thread_info *info);
600 void mdt_shrink_reply(struct mdt_thread_info *info);
601 int mdt_handle_last_unlink(struct mdt_thread_info *, struct mdt_object *,
602                            const struct md_attr *);
603 void mdt_reconstruct_open(struct mdt_thread_info *, struct mdt_lock_handle *);
604
605 struct thandle *mdt_trans_create(const struct lu_env *env,
606                                  struct mdt_device *mdt);
607 int mdt_trans_start(const struct lu_env *env, struct mdt_device *mdt,
608                     struct thandle *th);
609 void mdt_trans_stop(const struct lu_env *env,
610                     struct mdt_device *mdt, struct thandle *th);
611 int mdt_record_write(const struct lu_env *env,
612                      struct dt_object *dt, const struct lu_buf *buf,
613                      loff_t *pos, struct thandle *th);
614 int mdt_record_read(const struct lu_env *env,
615                     struct dt_object *dt, struct lu_buf *buf, loff_t *pos);
616
617 struct lu_buf *mdt_buf(const struct lu_env *env, void *area, ssize_t len);
618 const struct lu_buf *mdt_buf_const(const struct lu_env *env,
619                                    const void *area, ssize_t len);
620
621 void mdt_dump_lmm(int level, const struct lov_mds_md *lmm);
622
623 int mdt_check_ucred(struct mdt_thread_info *);
624 int mdt_init_ucred(struct mdt_thread_info *, struct mdt_body *);
625 int mdt_init_ucred_reint(struct mdt_thread_info *);
626 void mdt_exit_ucred(struct mdt_thread_info *);
627 int mdt_version_get_check(struct mdt_thread_info *, struct mdt_object *, int);
628 void mdt_version_get_save(struct mdt_thread_info *, struct mdt_object *, int);
629 int mdt_version_get_check_save(struct mdt_thread_info *, struct mdt_object *,
630                                int);
631
632 /* mdt_idmap.c */
633 int mdt_init_sec_level(struct mdt_thread_info *);
634 int mdt_init_idmap(struct mdt_thread_info *);
635 void mdt_cleanup_idmap(struct mdt_export_data *);
636 int mdt_handle_idmap(struct mdt_thread_info *);
637 int ptlrpc_user_desc_do_idmap(struct ptlrpc_request *,
638                               struct ptlrpc_user_desc *);
639 void mdt_body_reverse_idmap(struct mdt_thread_info *,
640                             struct mdt_body *);
641 int mdt_remote_perm_reverse_idmap(struct ptlrpc_request *,
642                                   struct mdt_remote_perm *);
643 int mdt_fix_attr_ucred(struct mdt_thread_info *, __u32);
644
645 static inline struct mdt_device *mdt_dev(struct lu_device *d)
646 {
647 //        LASSERT(lu_device_is_mdt(d));
648         return container_of0(d, struct mdt_device, mdt_md_dev.md_lu_dev);
649 }
650
651 static inline struct dt_object *mdt_obj2dt(struct mdt_object *mo)
652 {
653         struct lu_object *lo;
654         struct mdt_device *mdt = mdt_dev(mo->mot_obj.mo_lu.lo_dev);
655
656         lo = lu_object_locate(mo->mot_obj.mo_lu.lo_header,
657                               mdt->mdt_bottom->dd_lu_dev.ld_type);
658         return lu2dt(lo);
659 }
660
661 /* mdt/mdt_identity.c */
662 #define MDT_IDENTITY_UPCALL_PATH        "/usr/sbin/l_getidentity"
663
664 extern struct upcall_cache_ops mdt_identity_upcall_cache_ops;
665
666 struct md_identity *mdt_identity_get(struct upcall_cache *, __u32);
667
668 void mdt_identity_put(struct upcall_cache *, struct md_identity *);
669
670 void mdt_flush_identity(struct upcall_cache *, int);
671
672 __u32 mdt_identity_get_perm(struct md_identity *, __u32, lnet_nid_t);
673
674 int mdt_pack_remote_perm(struct mdt_thread_info *, struct mdt_object *, void *);
675
676 extern struct lu_context_key       mdt_thread_key;
677 /* debug issues helper starts here*/
678 static inline void mdt_fail_write(const struct lu_env *env,
679                                   struct dt_device *dd, int id)
680 {
681         if (OBD_FAIL_CHECK_ORSET(id, OBD_FAIL_ONCE)) {
682                 CERROR(LUSTRE_MDT_NAME": cfs_fail_loc=%x, fail write ops\n",
683                        id);
684                 dd->dd_ops->dt_ro(env, dd);
685                 /* We set FAIL_ONCE because we never "un-fail" a device */
686         }
687 }
688
689 static inline struct mdt_export_data *mdt_req2med(struct ptlrpc_request *req)
690 {
691         return &req->rq_export->exp_mdt_data;
692 }
693
694 typedef void (*mdt_reconstruct_t)(struct mdt_thread_info *mti,
695                                   struct mdt_lock_handle *lhc);
696 static inline int mdt_check_resent(struct mdt_thread_info *info,
697                                    mdt_reconstruct_t reconstruct,
698                                    struct mdt_lock_handle *lhc)
699 {
700         struct ptlrpc_request *req = mdt_info_req(info);
701         ENTRY;
702
703         if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) {
704                 if (req_xid_is_last(req)) {
705                         reconstruct(info, lhc);
706                         RETURN(1);
707                 }
708                 DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")",
709                           req->rq_export->exp_target_data.ted_lcd->lcd_last_xid);
710         }
711         RETURN(0);
712 }
713
714 struct md_ucred *mdt_ucred(const struct mdt_thread_info *info);
715
716 static inline int is_identity_get_disabled(struct upcall_cache *cache)
717 {
718         return cache ? (strcmp(cache->uc_upcall, "NONE") == 0) : 1;
719 }
720
721 int mdt_blocking_ast(struct ldlm_lock*, struct ldlm_lock_desc*, void*, int);
722
723 /* Issues dlm lock on passed @ns, @f stores it lock handle into @lh. */
724 static inline int mdt_fid_lock(struct ldlm_namespace *ns,
725                                struct lustre_handle *lh,
726                                ldlm_mode_t mode,
727                                ldlm_policy_data_t *policy,
728                                const struct ldlm_res_id *res_id,
729                                int flags, const __u64 *client_cookie)
730 {
731         int rc;
732
733         LASSERT(ns != NULL);
734         LASSERT(lh != NULL);
735
736         rc = ldlm_cli_enqueue_local(ns, res_id, LDLM_IBITS, policy,
737                                     mode, &flags, mdt_blocking_ast,
738                                     ldlm_completion_ast, NULL, NULL, 0,
739                                     client_cookie, lh);
740         return rc == ELDLM_OK ? 0 : -EIO;
741 }
742
743 static inline void mdt_fid_unlock(struct lustre_handle *lh,
744                                   ldlm_mode_t mode)
745 {
746         ldlm_lock_decref(lh, mode);
747 }
748
749 extern mdl_mode_t mdt_mdl_lock_modes[];
750 extern ldlm_mode_t mdt_dlm_lock_modes[];
751
752 static inline mdl_mode_t mdt_dlm_mode2mdl_mode(ldlm_mode_t mode)
753 {
754         LASSERT(IS_PO2(mode));
755         return mdt_mdl_lock_modes[mode];
756 }
757
758 static inline ldlm_mode_t mdt_mdl_mode2dlm_mode(mdl_mode_t mode)
759 {
760         LASSERT(IS_PO2(mode));
761         return mdt_dlm_lock_modes[mode];
762 }
763
764 static inline struct lu_name *mdt_name(const struct lu_env *env,
765                                        char *name, int namelen)
766 {
767         struct lu_name *lname;
768         struct mdt_thread_info *mti;
769
770         LASSERT(namelen > 0);
771         /* trailing '\0' in buffer */
772         LASSERT(name[namelen] == '\0');
773
774         mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
775         lname = &mti->mti_name;
776         lname->ln_name = name;
777         lname->ln_namelen = namelen;
778         return lname;
779 }
780
781 static inline struct lu_name *mdt_name_copy(struct lu_name *tlname,
782                                             struct lu_name *slname)
783 {
784         LASSERT(tlname);
785         LASSERT(slname);
786
787         tlname->ln_name = slname->ln_name;
788         tlname->ln_namelen = slname->ln_namelen;
789         return tlname;
790 }
791
792 void mdt_enable_cos(struct mdt_device *, int);
793 int mdt_cos_is_enabled(struct mdt_device *);
794 int mdt_hsm_copytool_send(struct obd_export *exp);
795
796 /* lprocfs stuff */
797 enum {
798         LPROC_MDT_OPEN = 0,
799         LPROC_MDT_CLOSE,
800         LPROC_MDT_MKNOD,
801         LPROC_MDT_LINK,
802         LPROC_MDT_UNLINK,
803         LPROC_MDT_MKDIR,
804         LPROC_MDT_RMDIR,
805         LPROC_MDT_RENAME,
806         LPROC_MDT_GETATTR,
807         LPROC_MDT_SETATTR,
808         LPROC_MDT_GETXATTR,
809         LPROC_MDT_SETXATTR,
810         LPROC_MDT_STATFS,
811         LPROC_MDT_SYNC,
812         LPROC_MDT_LAST,
813 };
814 void mdt_counter_incr(struct obd_export *exp, int opcode);
815 void mdt_stats_counter_init(struct lprocfs_stats *stats);
816 void lprocfs_mdt_init_vars(struct lprocfs_static_vars *lvars);
817 int mdt_procfs_init(struct mdt_device *mdt, const char *name);
818 int mdt_procfs_fini(struct mdt_device *mdt);
819
820 void mdt_time_start(const struct mdt_thread_info *info);
821 void mdt_time_end(const struct mdt_thread_info *info, int idx);
822
823 /* Capability */
824 int mdt_ck_thread_start(struct mdt_device *mdt);
825 void mdt_ck_thread_stop(struct mdt_device *mdt);
826 void mdt_ck_timer_callback(unsigned long castmeharder);
827 int mdt_capa_keys_init(const struct lu_env *env, struct mdt_device *mdt);
828
829 static inline void mdt_set_capainfo(struct mdt_thread_info *info, int offset,
830                                     const struct lu_fid *fid,
831                                     struct lustre_capa *capa)
832 {
833         struct md_capainfo *ci;
834
835         LASSERT(offset >= 0 && offset <= MD_CAPAINFO_MAX);
836         if (!info->mti_mdt->mdt_opts.mo_mds_capa ||
837             !(info->mti_exp->exp_connect_flags & OBD_CONNECT_MDS_CAPA))
838                 return;
839
840         ci = md_capainfo(info->mti_env);
841         LASSERT(ci);
842         ci->mc_fid[offset]  = fid;
843         ci->mc_capa[offset] = capa;
844 }
845
846 static inline void mdt_dump_capainfo(struct mdt_thread_info *info)
847 {
848         struct md_capainfo *ci = md_capainfo(info->mti_env);
849         int i;
850
851         if (!ci)
852                 return;
853         for (i = 0; i < MD_CAPAINFO_MAX; i++) {
854                 if (!ci->mc_fid[i])
855                         continue;
856                 if (!ci->mc_capa[i]) {
857                         CERROR("no capa for index %d "DFID"\n",
858                                i, PFID(ci->mc_fid[i]));
859                         continue;
860                 }
861                 if (ci->mc_capa[i] == BYPASS_CAPA) {
862                         CERROR("bypass for index %d "DFID"\n",
863                                i, PFID(ci->mc_fid[i]));
864                         continue;
865                 }
866                 DEBUG_CAPA(D_ERROR, ci->mc_capa[i], "index %d", i);
867         }
868 }
869
870 static inline struct obd_device *mdt2obd_dev(const struct mdt_device *mdt)
871 {
872         return mdt->mdt_md_dev.md_lu_dev.ld_obd;
873 }
874 #endif /* __KERNEL__ */
875 #endif /* _MDT_H */