lustre/cmm/cmm_internal.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/cmm/cmm_internal.h
   5  *  Lustre Cluster Metadata Manager (cmm)
   6  *
   7  *  Copyright (C) 2006 Cluster File Systems, Inc.
   8  *   Author: Mike Pershin <tappro@clusterfs.com>
   9  *
  10  *   This file is part of the Lustre file system, http://www.lustre.org
  11  *   Lustre is a trademark of Cluster File Systems, Inc.
  12  *
  13  *   You may have signed or agreed to another license before downloading
  14  *   this software.  If so, you are bound by the terms and conditions
  15  *   of that agreement, and the following does not apply to you.  See the
  16  *   LICENSE file included with this distribution for more information.
  17  *
  18  *   If you did not agree to a different license, then this copy of Lustre
  19  *   is open source software; you can redistribute it and/or modify it
  20  *   under the terms of version 2 of the GNU General Public License as
  21  *   published by the Free Software Foundation.
  22  *
  23  *   In either case, Lustre is distributed in the hope that it will be
  24  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  25  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *   license text for more details.
  27  */
  28
  29 #ifndef _CMM_INTERNAL_H
  30 #define _CMM_INTERNAL_H
  31
  32 #if defined(__KERNEL__)
  33
  34 #include <obd.h>
  35 #include <lustre_fld.h>
  36 #include <md_object.h>
  37 #include <linux/lustre_acl.h>
  38
  39
  40 struct cmm_device {
  41         struct md_device        cmm_md_dev;
  42         /* device flags, taken from enum cmm_flags */
  43         __u32                   cmm_flags;
  44         /* underlaying device in MDS stack, usually MDD */
  45         struct md_device       *cmm_child;
  46         /* FLD client to talk to FLD */
  47         struct lu_client_fld   *cmm_fld;
  48         /* other MD servers in cluster */
  49         mdsno_t                 cmm_local_num;
  50         __u32                   cmm_tgt_count;
  51         struct list_head        cmm_targets;
  52         spinlock_t              cmm_tgt_guard;
  53         cfs_proc_dir_entry_t   *cmm_proc_entry;
  54         struct lprocfs_stats   *cmm_stats;
  55 };
  56
  57 enum cmm_flags {
  58         /*
  59          * Device initialization complete.
  60          */
  61         CMM_INITIALIZED = 1 << 0
  62 };
  63
  64 static inline struct md_device_operations *cmm_child_ops(struct cmm_device *d)
  65 {
  66         return (d->cmm_child->md_ops);
  67 }
  68
  69 static inline struct cmm_device *md2cmm_dev(struct md_device *m)
  70 {
  71         return container_of0(m, struct cmm_device, cmm_md_dev);
  72 }
  73
  74 static inline struct cmm_device *lu2cmm_dev(struct lu_device *d)
  75 {
  76         return container_of0(d, struct cmm_device, cmm_md_dev.md_lu_dev);
  77 }
  78
  79 static inline struct lu_device *cmm2lu_dev(struct cmm_device *d)
  80 {
  81         return (&d->cmm_md_dev.md_lu_dev);
  82 }
  83
  84 #ifdef HAVE_SPLIT_SUPPORT
  85 enum cmm_split_state {
  86         CMM_SPLIT_UNKNOWN,
  87         CMM_SPLIT_NONE,
  88         CMM_SPLIT_NEEDED,
  89         CMM_SPLIT_DONE,
  90         CMM_SPLIT_DENIED
  91 };
  92 #endif
  93
  94 struct cmm_object {
  95         struct md_object cmo_obj;
  96 };
  97
  98 /* local CMM object */
  99 struct cml_object {
 100         struct cmm_object    cmm_obj;
 101 #ifdef HAVE_SPLIT_SUPPORT
 102         /* split state of object (for dirs only)*/
 103         enum cmm_split_state clo_split;
 104 #endif
 105 };
 106
 107 /* remote CMM object */
 108 struct cmr_object {
 109         struct cmm_object cmm_obj;
 110         /* mds number where object is placed */
 111         mdsno_t           cmo_num;
 112 };
 113
 114 enum {
 115         CMM_SPLIT_PAGE_COUNT = 1
 116 };
 117
 118 struct cmm_thread_info {
 119         struct md_attr        cmi_ma;
 120         struct lu_buf         cmi_buf;
 121         struct lu_fid         cmi_fid; /* used for le/cpu conversions */
 122         struct lu_rdpg        cmi_rdpg;
 123         /* pointers to pages for readpage. */
 124         struct page          *cmi_pages[CMM_SPLIT_PAGE_COUNT];
 125         struct md_op_spec     cmi_spec;
 126         struct lmv_stripe_md  cmi_lmv;
 127         char                  cmi_xattr_buf[LUSTRE_POSIX_ACL_MAX_SIZE];
 128
 129         /* Ops object filename */
 130         struct lu_name        cti_name;
 131 };
 132
 133 static inline struct cmm_device *cmm_obj2dev(struct cmm_object *c)
 134 {
 135         return (md2cmm_dev(md_obj2dev(&c->cmo_obj)));
 136 }
 137
 138 static inline struct cmm_object *lu2cmm_obj(struct lu_object *o)
 139 {
 140         //LASSERT(lu_device_is_cmm(o->lo_dev));
 141         return container_of0(o, struct cmm_object, cmo_obj.mo_lu);
 142 }
 143
 144 /* get cmm object from md_object */
 145 static inline struct cmm_object *md2cmm_obj(struct md_object *o)
 146 {
 147         return container_of0(o, struct cmm_object, cmo_obj);
 148 }
 149 /* get lower-layer object */
 150 static inline struct md_object *cmm2child_obj(struct cmm_object *o)
 151 {
 152         return (o ? lu2md(lu_object_next(&o->cmo_obj.mo_lu)) : NULL);
 153 }
 154
 155 static inline struct lu_fid* cmm2fid(struct cmm_object *obj)
 156 {
 157        return &(obj->cmo_obj.mo_lu.lo_header->loh_fid);
 158 }
 159
 160 struct cmm_thread_info *cmm_env_info(const struct lu_env *env);
 161
 162 /* cmm_object.c */
 163 struct lu_object *cmm_object_alloc(const struct lu_env *env,
 164                                    const struct lu_object_header *hdr,
 165                                    struct lu_device *);
 166
 167 /*
 168  * local CMM object operations. cml_...
 169  */
 170 static inline struct cml_object *lu2cml_obj(struct lu_object *o)
 171 {
 172         return container_of0(o, struct cml_object, cmm_obj.cmo_obj.mo_lu);
 173 }
 174 static inline struct cml_object *md2cml_obj(struct md_object *mo)
 175 {
 176         return container_of0(mo, struct cml_object, cmm_obj.cmo_obj);
 177 }
 178 static inline struct cml_object *cmm2cml_obj(struct cmm_object *co)
 179 {
 180         return container_of0(co, struct cml_object, cmm_obj);
 181 }
 182
 183 int cmm_upcall(const struct lu_env *env, struct md_device *md,
 184                enum md_upcall_event ev);
 185
 186 #ifdef HAVE_SPLIT_SUPPORT
 187
 188 #define CMM_MD_SIZE(stripes)  (sizeof(struct lmv_stripe_md) +  \
 189                                (stripes) * sizeof(struct lu_fid))
 190
 191 /* cmm_split.c */
 192 static inline struct lu_buf *cmm_buf_get(const struct lu_env *env,
 193                                          void *area, ssize_t len)
 194 {
 195         struct lu_buf *buf;
 196
 197         buf = &cmm_env_info(env)->cmi_buf;
 198         buf->lb_buf = area;
 199         buf->lb_len = len;
 200         return buf;
 201 }
 202
 203 int cmm_split_check(const struct lu_env *env, struct md_object *mp,
 204                     const char *name);
 205
 206 int cmm_split_expect(const struct lu_env *env, struct md_object *mo,
 207                      struct md_attr *ma, int *split);
 208
 209 int cmm_split_dir(const struct lu_env *env, struct md_object *mo);
 210
 211 int cmm_split_access(const struct lu_env *env, struct md_object *mo,
 212                      mdl_mode_t lm);
 213 #endif
 214
 215 int cmm_fld_lookup(struct cmm_device *cm, const struct lu_fid *fid,
 216                    mdsno_t *mds, const struct lu_env *env);
 217
 218 int cmm_procfs_init(struct cmm_device *cmm, const char *name);
 219 int cmm_procfs_fini(struct cmm_device *cmm);
 220
 221 void cmm_lprocfs_time_start(const struct lu_env *env);
 222 void cmm_lprocfs_time_end(const struct lu_env *env, struct cmm_device *cmm,
 223                           int idx);
 224
 225 enum {
 226         LPROC_CMM_SPLIT_CHECK,
 227         LPROC_CMM_SPLIT,
 228         LPROC_CMM_LOOKUP,
 229         LPROC_CMM_CREATE,
 230         LPROC_CMM_NR
 231 };
 232
 233 #endif /* __KERNEL__ */
 234 #endif /* _CMM_INTERNAL_H */
 235