* @{
*/
-
+#include <obd_support.h>
/*
* super-class definitions.
*/
unsigned ddp_block_shift;
mntopt_t ddp_mntopts;
unsigned ddp_max_ea_size;
- void *ddp_mnt; /* XXX: old code can retrieve mnt -bzzz */
int ddp_mount_type;
unsigned long long ddp_maxbytes;
/* percentage of available space to reserve for grant error margin */
#define MAX_COMMIT_CB_STR_LEN 32
struct dt_txn_commit_cb {
- cfs_list_t dcb_linkage;
- dt_cb_t dcb_func;
- __u32 dcb_magic;
- char dcb_name[MAX_COMMIT_CB_STR_LEN];
+ struct list_head dcb_linkage;
+ dt_cb_t dcb_func;
+ __u32 dcb_magic;
+ char dcb_name[MAX_COMMIT_CB_STR_LEN];
};
/**
*/
int (*dt_trans_start)(const struct lu_env *env,
struct dt_device *dev, struct thandle *th);
- /**
- * Finish previously started transaction.
- */
- int (*dt_trans_stop)(const struct lu_env *env,
- struct thandle *th);
+ /**
+ * Finish previously started transaction.
+ */
+ int (*dt_trans_stop)(const struct lu_env *env, struct dt_device *dev,
+ struct thandle *th);
/**
* Add commit callback to the transaction.
*/
*/
extern const struct dt_index_features dt_directory_features;
extern const struct dt_index_features dt_otable_features;
+extern const struct dt_index_features dt_lfsck_orphan_features;
extern const struct dt_index_features dt_lfsck_features;
/* index features supported by the accounting objects */
* It can contain any allocation hint in the future.
*/
struct dt_allocation_hint {
- struct dt_object *dah_parent;
- __u32 dah_mode;
+ struct dt_object *dah_parent;
+ const void *dah_eadata;
+ int dah_eadata_len;
+ __u32 dah_mode;
};
/**
typedef __u64 dt_obj_version_t;
+union ldlm_policy_data;
+
/**
* Per-dt-object operations.
*/
* lu_object_operations, but that would break existing symmetry.
*/
+ int (*do_declare_attr_get)(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lustre_capa *capa);
/**
* Return standard attributes.
*
const struct lu_attr *attr,
struct thandle *handle,
struct lustre_capa *capa);
+
+ int (*do_declare_xattr_get)(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lu_buf *buf,
+ const char *name,
+ struct lustre_capa *capa);
+
/**
* Return a value of an extended attribute.
*
* (2) The type of child is in \a child_mode.
* (3) The result hint is stored in \a ah;
*/
- void (*do_ah_init)(const struct lu_env *env,
- struct dt_allocation_hint *ah,
- struct dt_object *parent,
+ void (*do_ah_init)(const struct lu_env *env,
+ struct dt_allocation_hint *ah,
+ struct dt_object *parent,
struct dt_object *child,
- cfs_umode_t child_mode);
+ umode_t child_mode);
/**
* Create new object on this device.
*
int (*do_ref_del)(const struct lu_env *env,
struct dt_object *dt, struct thandle *th);
- struct obd_capa *(*do_capa_get)(const struct lu_env *env,
- struct dt_object *dt,
- struct lustre_capa *old,
- __u64 opc);
- int (*do_object_sync)(const struct lu_env *, struct dt_object *);
- /**
- * Get object info of next level. Currently, only get inode from osd.
- * This is only used by quota b=16542
- * precondition: dt_object_exists(dt);
- */
- int (*do_data_get)(const struct lu_env *env, struct dt_object *dt,
- void **data);
+ struct obd_capa *(*do_capa_get)(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lustre_capa *old,
+ __u64 opc);
+ int (*do_object_sync)(const struct lu_env *env, struct dt_object *obj,
+ __u64 start, __u64 end);
+ /**
+ * Get object info of next level. Currently, only get inode from osd.
+ * This is only used by quota b=16542
+ * precondition: dt_object_exists(dt);
+ */
+ int (*do_data_get)(const struct lu_env *env, struct dt_object *dt,
+ void **data);
/**
* Lock object.
int (*do_object_lock)(const struct lu_env *env, struct dt_object *dt,
struct lustre_handle *lh,
struct ldlm_enqueue_info *einfo,
- void *policy);
+ union ldlm_policy_data *policy);
+
+ int (*do_object_unlock)(const struct lu_env *env, struct dt_object *dt,
+ struct ldlm_enqueue_info *einfo,
+ union ldlm_policy_data *policy);
};
/**
ssize_t (*dbo_read)(const struct lu_env *env, struct dt_object *dt,
struct lu_buf *buf, loff_t *pos,
struct lustre_capa *capa);
- /**
- * precondition: dt_object_exists(dt);
- */
- ssize_t (*dbo_declare_write)(const struct lu_env *env,
- struct dt_object *dt,
- const loff_t size, loff_t pos,
- struct thandle *handle);
- ssize_t (*dbo_write)(const struct lu_env *env, struct dt_object *dt,
- const struct lu_buf *buf, loff_t *pos,
- struct thandle *handle, struct lustre_capa *capa,
- int ignore_quota);
+ /**
+ * precondition: dt_object_exists(dt);
+ */
+ ssize_t (*dbo_declare_write)(const struct lu_env *env,
+ struct dt_object *dt,
+ const struct lu_buf *buf, loff_t pos,
+ struct thandle *handle);
+ ssize_t (*dbo_write)(const struct lu_env *env, struct dt_object *dt,
+ const struct lu_buf *buf, loff_t *pos,
+ struct thandle *handle, struct lustre_capa *capa,
+ int ignore_quota);
/*
* methods for zero-copy IO
*/
const struct dt_it *di,
struct dt_rec *rec,
__u32 attr);
+ int (*rec_size)(const struct lu_env *env,
+ const struct dt_it *di,
+ __u32 attr);
__u64 (*store)(const struct lu_env *env,
const struct dt_it *di);
int (*load)(const struct lu_env *env,
enum dt_otable_it_valid {
DOIV_ERROR_HANDLE = 0x0001,
+ DOIV_DRYRUN = 0x0002,
};
enum dt_otable_it_flags {
/* There is up layer component uses the iteration. */
DOIF_OUTUSED = 0x0004,
+
+ /* Check only without repairing. */
+ DOIF_DRYRUN = 0x0008,
};
/* otable based iteration needs to use the common DT interation APIs.
* way, because callbacks are supposed to be added/deleted only during
* single-threaded start-up shut-down procedures.
*/
- cfs_list_t dd_txn_callbacks;
+ struct list_head dd_txn_callbacks;
+ unsigned int dd_record_fid_accessed:1;
};
int dt_device_init(struct dt_device *dev, struct lu_device_type *t);
*/
struct local_oid_storage {
/* all initialized llog systems on this node linked by this */
- cfs_list_t los_list;
+ struct list_head los_list;
/* how many handle's reference this los has */
- cfs_atomic_t los_refcount;
+ atomic_t los_refcount;
struct dt_device *los_dev;
struct dt_object *los_obj;
return container_of0(o, struct dt_object, do_lu);
}
+struct thandle_update {
+ /* In DNE, one transaction can be disassembled into
+ * updates on several different MDTs, and these updates
+ * will be attached to tu_remote_update_list per target.
+ * Only single thread will access the list, no need lock
+ */
+ struct list_head tu_remote_update_list;
+
+ /* sent after or before local transaction */
+ unsigned int tu_sent_after_local_trans:1,
+ tu_only_remote_trans:1;
+};
+
/**
* This is the general purpose transaction handle.
* 1. Transaction Life Cycle
/** the dt device on which the transactions are executed */
struct dt_device *th_dev;
+ atomic_t th_refc;
+ /* the size of transaction */
+ int th_alloc_size;
+
/** context for this transaction, tag is LCT_TX_HANDLE */
struct lu_context th_ctx;
/* local transation, no need to inform other layers */
unsigned int th_local:1;
- /* In DNE, one transaction can be disassemblied into
- * updates on several different MDTs, and these updates
- * will be attached to th_remote_update_list per target.
- * Only single thread will access the list, no need lock
- */
- cfs_list_t th_remote_update_list;
- struct update_request *th_current_request;
+ struct thandle_update *th_update;
};
+static inline void thandle_get(struct thandle *thandle)
+{
+ atomic_inc(&thandle->th_refc);
+}
+
+static inline void thandle_put(struct thandle *thandle)
+{
+ if (atomic_dec_and_test(&thandle->th_refc)) {
+ if (thandle->th_update != NULL)
+ OBD_FREE_PTR(thandle->th_update);
+ OBD_FREE(thandle, thandle->th_alloc_size);
+ }
+}
/**
* Transaction call-backs.
*
int (*dtc_txn_stop)(const struct lu_env *env,
struct thandle *txn, void *cookie);
void (*dtc_txn_commit)(struct thandle *txn, void *cookie);
- void *dtc_cookie;
- __u32 dtc_tag;
- cfs_list_t dtc_linkage;
+ void *dtc_cookie;
+ __u32 dtc_tag;
+ struct list_head dtc_linkage;
};
void dt_txn_callback_add(struct dt_device *dev, struct dt_txn_callback *cb);
struct dt_object *dt_locate_at(const struct lu_env *env,
struct dt_device *dev,
const struct lu_fid *fid,
- struct lu_device *top_dev);
+ struct lu_device *top_dev,
+ const struct lu_object_conf *conf);
+
static inline struct dt_object *
dt_locate(const struct lu_env *env, struct dt_device *dev,
const struct lu_fid *fid)
{
- return dt_locate_at(env, dev, fid, dev->dd_lu_dev.ld_site->ls_top_dev);
+ return dt_locate_at(env, dev, fid,
+ dev->dd_lu_dev.ld_site->ls_top_dev, NULL);
}
-
int local_oid_storage_init(const struct lu_env *env, struct dt_device *dev,
const struct lu_fid *first_fid,
struct local_oid_storage **los);
static inline int dt_object_lock(const struct lu_env *env,
struct dt_object *o, struct lustre_handle *lh,
struct ldlm_enqueue_info *einfo,
- void *policy)
+ union ldlm_policy_data *policy)
{
- LASSERT(o);
- LASSERT(o->do_ops);
- LASSERT(o->do_ops->do_object_lock);
+ LASSERT(o != NULL);
+ LASSERT(o->do_ops != NULL);
+ LASSERT(o->do_ops->do_object_lock != NULL);
return o->do_ops->do_object_lock(env, o, lh, einfo, policy);
}
+static inline int dt_object_unlock(const struct lu_env *env,
+ struct dt_object *o,
+ struct ldlm_enqueue_info *einfo,
+ union ldlm_policy_data *policy)
+{
+ LASSERT(o != NULL);
+ LASSERT(o->do_ops != NULL);
+ LASSERT(o->do_ops->do_object_unlock != NULL);
+ return o->do_ops->do_object_unlock(env, o, einfo, policy);
+}
+
int dt_lookup_dir(const struct lu_env *env, struct dt_object *dir,
const char *name, struct lu_fid *fid);
-static inline int dt_object_sync(const struct lu_env *env,
- struct dt_object *o)
+static inline int dt_object_sync(const struct lu_env *env, struct dt_object *o,
+ __u64 start, __u64 end)
{
- LASSERT(o);
- LASSERT(o->do_ops);
- LASSERT(o->do_ops->do_object_sync);
- return o->do_ops->do_object_sync(env, o);
+ LASSERT(o);
+ LASSERT(o->do_ops);
+ LASSERT(o->do_ops->do_object_sync);
+ return o->do_ops->do_object_sync(env, o, start, end);
}
int dt_declare_version_set(const struct lu_env *env, struct dt_object *o,
static inline int dt_trans_stop(const struct lu_env *env,
struct dt_device *d, struct thandle *th)
{
- LASSERT(d->dd_ops->dt_trans_stop);
- return d->dd_ops->dt_trans_stop(env, th);
+ LASSERT(d->dd_ops->dt_trans_stop);
+ return d->dd_ops->dt_trans_stop(env, d, th);
}
static inline int dt_trans_cb_add(struct thandle *th,
static inline int dt_declare_record_write(const struct lu_env *env,
- struct dt_object *dt,
- int size, loff_t pos,
- struct thandle *th)
+ struct dt_object *dt,
+ const struct lu_buf *buf,
+ loff_t pos,
+ struct thandle *th)
{
- int rc;
-
- LASSERTF(dt != NULL, "dt is NULL when we want to write record\n");
- LASSERT(th != NULL);
- LASSERT(dt->do_body_ops);
- LASSERT(dt->do_body_ops->dbo_declare_write);
- rc = dt->do_body_ops->dbo_declare_write(env, dt, size, pos, th);
- return rc;
+ int rc;
+
+ LASSERTF(dt != NULL, "dt is NULL when we want to write record\n");
+ LASSERT(th != NULL);
+ LASSERT(dt->do_body_ops);
+ LASSERT(dt->do_body_ops->dbo_declare_write);
+ rc = dt->do_body_ops->dbo_declare_write(env, dt, buf, pos, th);
+ return rc;
}
static inline int dt_declare_create(const struct lu_env *env,
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_declare_create);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_CREATE))
+ return cfs_fail_err;
+
return dt->do_ops->do_declare_create(env, dt, attr, hint, dof, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_create);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_CREATE))
+ return cfs_fail_err;
+
return dt->do_ops->do_create(env, dt, attr, hint, dof, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_declare_destroy);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_DESTROY))
+ return cfs_fail_err;
+
return dt->do_ops->do_declare_destroy(env, dt, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_destroy);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DESTROY))
+ return cfs_fail_err;
+
return dt->do_ops->do_destroy(env, dt, th);
}
return dt->do_ops->do_write_locked(env, dt);
}
+static inline int dt_declare_attr_get(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lustre_capa *capa)
+{
+ LASSERT(dt);
+ LASSERT(dt->do_ops);
+ LASSERT(dt->do_ops->do_declare_attr_get);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_ATTR_GET))
+ return cfs_fail_err;
+
+ return dt->do_ops->do_declare_attr_get(env, dt, capa);
+}
+
static inline int dt_attr_get(const struct lu_env *env, struct dt_object *dt,
struct lu_attr *la, void *arg)
{
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_attr_get);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_ATTR_GET))
+ return cfs_fail_err;
+
return dt->do_ops->do_attr_get(env, dt, la, arg);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_declare_attr_set);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_ATTR_SET))
+ return cfs_fail_err;
+
return dt->do_ops->do_declare_attr_set(env, dt, la, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_attr_set);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_ATTR_SET))
+ return cfs_fail_err;
+
return dt->do_ops->do_attr_set(env, dt, la, th, capa);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_declare_ref_add);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_REF_ADD))
+ return cfs_fail_err;
+
return dt->do_ops->do_declare_ref_add(env, dt, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_ref_add);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_REF_ADD))
+ return cfs_fail_err;
+
return dt->do_ops->do_ref_add(env, dt, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_declare_ref_del);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_REF_DEL))
+ return cfs_fail_err;
+
return dt->do_ops->do_declare_ref_del(env, dt, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_ref_del);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_REF_DEL))
+ return cfs_fail_err;
+
return dt->do_ops->do_ref_del(env, dt, th);
}
{
LASSERT(dt);
LASSERT(dt->do_ops);
- LASSERT(dt->do_ops->do_ref_del);
+ LASSERT(dt->do_ops->do_capa_get);
return dt->do_ops->do_capa_get(env, dt, old, opc);
}
static inline int dt_bufs_get(const struct lu_env *env, struct dt_object *d,
- struct niobuf_remote *rnb,
- struct niobuf_local *lnb, int rw,
- struct lustre_capa *capa)
+ struct niobuf_remote *rnb,
+ struct niobuf_local *lnb, int rw,
+ struct lustre_capa *capa)
{
- LASSERT(d);
- LASSERT(d->do_body_ops);
- LASSERT(d->do_body_ops->dbo_bufs_get);
- return d->do_body_ops->dbo_bufs_get(env, d, rnb->offset,
- rnb->len, lnb, rw, capa);
+ LASSERT(d);
+ LASSERT(d->do_body_ops);
+ LASSERT(d->do_body_ops->dbo_bufs_get);
+ return d->do_body_ops->dbo_bufs_get(env, d, rnb->rnb_offset,
+ rnb->rnb_len, lnb, rw, capa);
}
static inline int dt_bufs_put(const struct lu_env *env, struct dt_object *d,
LASSERT(dt);
LASSERT(dt->do_index_ops);
LASSERT(dt->do_index_ops->dio_declare_insert);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_INSERT))
+ return cfs_fail_err;
+
return dt->do_index_ops->dio_declare_insert(env, dt, rec, key, th);
}
LASSERT(dt);
LASSERT(dt->do_index_ops);
LASSERT(dt->do_index_ops->dio_insert);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_INSERT))
+ return cfs_fail_err;
+
return dt->do_index_ops->dio_insert(env, dt, rec, key, th,
capa, noquota);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_declare_xattr_del);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_XATTR_DEL))
+ return cfs_fail_err;
+
return dt->do_ops->do_declare_xattr_del(env, dt, name, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_xattr_del);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_DEL))
+ return cfs_fail_err;
+
return dt->do_ops->do_xattr_del(env, dt, name, th, capa);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_declare_xattr_set);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_XATTR_SET))
+ return cfs_fail_err;
+
return dt->do_ops->do_declare_xattr_set(env, dt, buf, name, fl, th);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_xattr_set);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_SET))
+ return cfs_fail_err;
+
return dt->do_ops->do_xattr_set(env, dt, buf, name, fl, th, capa);
}
+static inline int dt_declare_xattr_get(const struct lu_env *env,
+ struct dt_object *dt,
+ struct lu_buf *buf,
+ const char *name,
+ struct lustre_capa *capa)
+{
+ LASSERT(dt);
+ LASSERT(dt->do_ops);
+ LASSERT(dt->do_ops->do_declare_xattr_get);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_XATTR_GET))
+ return cfs_fail_err;
+
+ return dt->do_ops->do_declare_xattr_get(env, dt, buf, name, capa);
+}
+
static inline int dt_xattr_get(const struct lu_env *env,
struct dt_object *dt, struct lu_buf *buf,
const char *name, struct lustre_capa *capa)
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_xattr_get);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_GET))
+ return cfs_fail_err;
+
return dt->do_ops->do_xattr_get(env, dt, buf, name, capa);
}
LASSERT(dt);
LASSERT(dt->do_ops);
LASSERT(dt->do_ops->do_xattr_list);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_XATTR_LIST))
+ return cfs_fail_err;
+
return dt->do_ops->do_xattr_list(env, dt, buf, capa);
}
LASSERT(dt);
LASSERT(dt->do_index_ops);
LASSERT(dt->do_index_ops->dio_declare_delete);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DECLARE_DELETE))
+ return cfs_fail_err;
+
return dt->do_index_ops->dio_declare_delete(env, dt, key, th);
}
LASSERT(dt);
LASSERT(dt->do_index_ops);
LASSERT(dt->do_index_ops->dio_delete);
+
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_DELETE))
+ return cfs_fail_err;
+
return dt->do_index_ops->dio_delete(env, dt, key, th, capa);
}
LASSERT(dt->do_index_ops);
LASSERT(dt->do_index_ops->dio_lookup);
+ if (CFS_FAULT_CHECK(OBD_FAIL_DT_LOOKUP))
+ return cfs_fail_err;
+
ret = dt->do_index_ops->dio_lookup(env, dt, rec, key, capa);
if (ret > 0)
ret = 0;
struct dt_object *dfh_o;
};
+struct dt_insert_rec {
+ union {
+ const struct lu_fid *rec_fid;
+ void *rec_data;
+ };
+ union {
+ struct {
+ __u32 rec_type;
+ __u32 rec_padding;
+ };
+ __u64 rec_misc;
+ };
+};
+
struct dt_thread_info {
char dti_buf[DT_MAX_PATH];
struct dt_find_hint dti_dfh;
struct dt_object_format dti_dof;
struct lustre_mdt_attrs dti_lma;
struct lu_buf dti_lb;
+ struct lu_object_conf dti_conf;
loff_t dti_off;
+ struct dt_insert_rec dti_dt_rec;
};
extern struct lu_context_key dt_key;
void dt_global_fini(void);
# ifdef LPROCFS
+#ifndef HAVE_ONLY_PROCFS_SEQ
int lprocfs_dt_rd_blksize(char *page, char **start, off_t off,
int count, int *eof, void *data);
int lprocfs_dt_rd_kbytestotal(char *page, char **start, off_t off,
int count, int *eof, void *data);
int lprocfs_dt_rd_filesfree(char *page, char **start, off_t off,
int count, int *eof, void *data);
+#endif
+int lprocfs_dt_blksize_seq_show(struct seq_file *m, void *v);
+int lprocfs_dt_kbytestotal_seq_show(struct seq_file *m, void *v);
+int lprocfs_dt_kbytesfree_seq_show(struct seq_file *m, void *v);
+int lprocfs_dt_kbytesavail_seq_show(struct seq_file *m, void *v);
+int lprocfs_dt_filestotal_seq_show(struct seq_file *m, void *v);
+int lprocfs_dt_filesfree_seq_show(struct seq_file *m, void *v);
# endif /* LPROCFS */
#endif /* __LUSTRE_DT_OBJECT_H */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff