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  * 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  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  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/cmm/cmm_internal.h
  37  *
  38  * Lustre Cluster Metadata Manager (cmm)
  39  *
  40  * Author: Mike Pershin <tappro@clusterfs.com>
  41  */
  42
  43 #ifndef _CMM_INTERNAL_H
  44 #define _CMM_INTERNAL_H
  45
  46 #if defined(__KERNEL__)
  47
  48 #include <obd.h>
  49 #include <lustre_fld.h>
  50 #include <md_object.h>
  51 #include <lustre_acl.h>
  52
  53
  54 struct cmm_device {
  55         struct md_device        cmm_md_dev;
  56         /* device flags, taken from enum cmm_flags */
  57         __u32                   cmm_flags;
  58         /* underlaying device in MDS stack, usually MDD */
  59         struct md_device       *cmm_child;
  60         /* FLD client to talk to FLD */
  61         struct lu_client_fld   *cmm_fld;
  62         /* other MD servers in cluster */
  63         mdsno_t                 cmm_local_num;
  64         __u32                   cmm_tgt_count;
  65         struct list_head        cmm_targets;
  66         spinlock_t              cmm_tgt_guard;
  67         cfs_proc_dir_entry_t   *cmm_proc_entry;
  68         struct lprocfs_stats   *cmm_stats;
  69 };
  70
  71 enum cmm_flags {
  72         /*
  73          * Device initialization complete.
  74          */
  75         CMM_INITIALIZED = 1 << 0
  76 };
  77
  78 static inline const struct md_device_operations *
  79 cmm_child_ops(struct cmm_device *d)
  80 {
  81         return d->cmm_child->md_ops;
  82 }
  83
  84 static inline struct cmm_device *md2cmm_dev(struct md_device *m)
  85 {
  86         return container_of0(m, struct cmm_device, cmm_md_dev);
  87 }
  88
  89 static inline struct cmm_device *lu2cmm_dev(struct lu_device *d)
  90 {
  91         return container_of0(d, struct cmm_device, cmm_md_dev.md_lu_dev);
  92 }
  93
  94 static inline struct lu_device *cmm2lu_dev(struct cmm_device *d)
  95 {
  96         return (&d->cmm_md_dev.md_lu_dev);
  97 }
  98
  99 #ifdef HAVE_SPLIT_SUPPORT
 100 enum cmm_split_state {
 101         CMM_SPLIT_UNKNOWN,
 102         CMM_SPLIT_NONE,
 103         CMM_SPLIT_NEEDED,
 104         CMM_SPLIT_DONE,
 105         CMM_SPLIT_DENIED
 106 };
 107 #endif
 108
 109 struct cmm_object {
 110         struct md_object cmo_obj;
 111 };
 112
 113 /* local CMM object */
 114 struct cml_object {
 115         struct cmm_object    cmm_obj;
 116 #ifdef HAVE_SPLIT_SUPPORT
 117         /* split state of object (for dirs only)*/
 118         enum cmm_split_state clo_split;
 119 #endif
 120 };
 121
 122 /* remote CMM object */
 123 struct cmr_object {
 124         struct cmm_object cmm_obj;
 125         /* mds number where object is placed */
 126         mdsno_t           cmo_num;
 127 };
 128
 129 enum {
 130         CMM_SPLIT_PAGE_COUNT = 1
 131 };
 132
 133 struct cmm_thread_info {
 134         struct md_attr        cmi_ma;
 135         struct lu_buf         cmi_buf;
 136         struct lu_fid         cmi_fid; /* used for le/cpu conversions */
 137         struct lu_rdpg        cmi_rdpg;
 138         /* pointers to pages for readpage. */
 139         struct page          *cmi_pages[CMM_SPLIT_PAGE_COUNT];
 140         struct md_op_spec     cmi_spec;
 141         struct lmv_stripe_md  cmi_lmv;
 142         char                  cmi_xattr_buf[LUSTRE_POSIX_ACL_MAX_SIZE];
 143
 144         /* Ops object filename */
 145         struct lu_name        cti_name;
 146 };
 147
 148 static inline struct cmm_device *cmm_obj2dev(struct cmm_object *c)
 149 {
 150         return (md2cmm_dev(md_obj2dev(&c->cmo_obj)));
 151 }
 152
 153 static inline struct cmm_object *lu2cmm_obj(struct lu_object *o)
 154 {
 155         //LASSERT(lu_device_is_cmm(o->lo_dev));
 156         return container_of0(o, struct cmm_object, cmo_obj.mo_lu);
 157 }
 158
 159 /* get cmm object from md_object */
 160 static inline struct cmm_object *md2cmm_obj(struct md_object *o)
 161 {
 162         return container_of0(o, struct cmm_object, cmo_obj);
 163 }
 164 /* get lower-layer object */
 165 static inline struct md_object *cmm2child_obj(struct cmm_object *o)
 166 {
 167         return (o ? lu2md(lu_object_next(&o->cmo_obj.mo_lu)) : NULL);
 168 }
 169
 170 static inline struct lu_fid* cmm2fid(struct cmm_object *obj)
 171 {
 172        return &(obj->cmo_obj.mo_lu.lo_header->loh_fid);
 173 }
 174
 175 struct cmm_thread_info *cmm_env_info(const struct lu_env *env);
 176
 177 /* cmm_object.c */
 178 struct lu_object *cmm_object_alloc(const struct lu_env *env,
 179                                    const struct lu_object_header *hdr,
 180                                    struct lu_device *);
 181
 182 /*
 183  * local CMM object operations. cml_...
 184  */
 185 static inline struct cml_object *lu2cml_obj(struct lu_object *o)
 186 {
 187         return container_of0(o, struct cml_object, cmm_obj.cmo_obj.mo_lu);
 188 }
 189 static inline struct cml_object *md2cml_obj(struct md_object *mo)
 190 {
 191         return container_of0(mo, struct cml_object, cmm_obj.cmo_obj);
 192 }
 193 static inline struct cml_object *cmm2cml_obj(struct cmm_object *co)
 194 {
 195         return container_of0(co, struct cml_object, cmm_obj);
 196 }
 197
 198 int cmm_upcall(const struct lu_env *env, struct md_device *md,
 199                enum md_upcall_event ev, void *data);
 200
 201 #ifdef HAVE_SPLIT_SUPPORT
 202
 203 #define CMM_MD_SIZE(stripes)  (sizeof(struct lmv_stripe_md) +  \
 204                                (stripes) * sizeof(struct lu_fid))
 205
 206 /* cmm_split.c */
 207 static inline struct lu_buf *cmm_buf_get(const struct lu_env *env,
 208                                          void *area, ssize_t len)
 209 {
 210         struct lu_buf *buf;
 211
 212         buf = &cmm_env_info(env)->cmi_buf;
 213         buf->lb_buf = area;
 214         buf->lb_len = len;
 215         return buf;
 216 }
 217
 218 int cmm_split_check(const struct lu_env *env, struct md_object *mp,
 219                     const char *name);
 220
 221 int cmm_split_expect(const struct lu_env *env, struct md_object *mo,
 222                      struct md_attr *ma, int *split);
 223
 224 int cmm_split_dir(const struct lu_env *env, struct md_object *mo);
 225
 226 int cmm_split_access(const struct lu_env *env, struct md_object *mo,
 227                      mdl_mode_t lm);
 228 #endif
 229
 230 int cmm_fld_lookup(struct cmm_device *cm, const struct lu_fid *fid,
 231                    mdsno_t *mds, const struct lu_env *env);
 232
 233 int cmm_procfs_init(struct cmm_device *cmm, const char *name);
 234 int cmm_procfs_fini(struct cmm_device *cmm);
 235
 236 void cmm_lprocfs_time_start(const struct lu_env *env);
 237 void cmm_lprocfs_time_end(const struct lu_env *env, struct cmm_device *cmm,
 238                           int idx);
 239
 240 enum {
 241         LPROC_CMM_SPLIT_CHECK,
 242         LPROC_CMM_SPLIT,
 243         LPROC_CMM_LOOKUP,
 244         LPROC_CMM_CREATE,
 245         LPROC_CMM_NR
 246 };
 247
 248 #endif /* __KERNEL__ */
 249 #endif /* _CMM_INTERNAL_H */