cli->lcs_name);
/*
- * Asking client for new range, assign that range to ->seq_super and
+ * Asking client for new range, assign that range to ->seq_space and
* write seq state to backing store should be atomic.
*/
down(&seq->lss_sem);
* Get new range from controller only if super-sequence is not yet
* initialized from backing store or something else.
*/
- if (range_is_zero(&seq->lss_super)) {
+ if (range_is_zero(&seq->lss_space)) {
rc = seq_client_alloc_super(cli, env);
if (rc) {
up(&seq->lss_sem);
}
/* take super-seq from client seq mgr */
- LASSERT(range_is_sane(&cli->lcs_range));
+ LASSERT(range_is_sane(&cli->lcs_space));
- seq->lss_super = cli->lcs_range;
+ seq->lss_space = cli->lcs_space;
/* save init seq to backing store. */
rc = seq_store_write(seq, env);
CDEBUG(D_INFO|D_WARNING, "%s: Recovery finished. Recovered "
"space: "DRANGE"\n", seq->lss_name, PRANGE(space));
} else {
- if (range_space(space) < seq->lss_super_width) {
+ if (range_space(space) < seq->lss_width) {
CWARN("%s: Sequences space to be exhausted soon. "
"Only "LPU64" sequences left\n", seq->lss_name,
range_space(space));
seq->lss_name);
RETURN(-ENOSPC);
} else {
- range_alloc(out, space, seq->lss_super_width);
+ range_alloc(out, space, seq->lss_width);
}
}
struct lu_range *out,
const struct lu_env *env)
{
- struct lu_range *super = &seq->lss_super;
+ struct lu_range *space = &seq->lss_space;
int rc = 0;
ENTRY;
- LASSERT(range_is_sane(super));
+ LASSERT(range_is_sane(space));
/*
* This is recovery case. Adjust super range if input range looks like
"(last allocated) range "DRANGE"\n", seq->lss_name,
PRANGE(in));
- if (range_is_exhausted(super)) {
- LASSERT(in->lr_start > super->lr_start);
+ if (range_is_exhausted(space)) {
+ LASSERT(in->lr_start > space->lr_start);
/*
* Server cannot send empty range to client, this is why
* we check here that range from client is "newer" than
* exhausted super.
*/
- super->lr_start = in->lr_start;
+ space->lr_start = in->lr_start;
- super->lr_end = super->lr_start +
+ space->lr_end = space->lr_start +
LUSTRE_SEQ_SUPER_WIDTH;
} else {
/*
* Update super start by start from client's range. End
* should not be changed if range was not exhausted.
*/
- if (in->lr_start > super->lr_start)
- super->lr_start = in->lr_start;
+ if (in->lr_start > space->lr_start)
+ space->lr_start = in->lr_start;
}
*out = *in;
CDEBUG(D_INFO|D_WARNING, "%s: Recovery finished. Recovered "
- "super: "DRANGE"\n", seq->lss_name, PRANGE(super));
+ "super: "DRANGE"\n", seq->lss_name, PRANGE(space));
} else {
/*
* XXX: Avoid cascading RPCs using kind of async preallocation
* when meta-sequence is close to exhausting.
*/
- if (range_is_exhausted(super)) {
+ if (range_is_exhausted(space)) {
if (!seq->lss_cli) {
CERROR("%s: No sequence controller client "
"is setup\n", seq->lss_name);
}
/* Saving new range to allocation space. */
- *super = seq->lss_cli->lcs_range;
- LASSERT(range_is_sane(super));
+ *space = seq->lss_cli->lcs_space;
+ LASSERT(range_is_sane(space));
}
- range_alloc(out, super, seq->lss_meta_width);
+ range_alloc(out, space, seq->lss_width);
}
rc = seq_store_write(seq, env);
seq->lss_type = type;
sema_init(&seq->lss_sem, 1);
- seq->lss_super_width = LUSTRE_SEQ_SUPER_WIDTH;
- seq->lss_meta_width = LUSTRE_SEQ_META_WIDTH;
+ seq->lss_width = is_srv ?
+ LUSTRE_SEQ_META_WIDTH : LUSTRE_SEQ_SUPER_WIDTH;
snprintf(seq->lss_name, sizeof(seq->lss_name),
"%s-%s", (is_srv ? "srv" : "ctl"), prefix);
- seq->lss_space = LUSTRE_SEQ_SPACE_RANGE;
- seq->lss_super = LUSTRE_SEQ_ZERO_RANGE;
+ seq->lss_space = is_srv ?
+ LUSTRE_SEQ_ZERO_RANGE:
+ LUSTRE_SEQ_SPACE_RANGE;
rc = seq_store_init(seq, env, dev);
if (rc)
#include <linux/types.h>
#ifdef __KERNEL__
-struct seq_store_record {
- struct lu_range ssr_space;
- struct lu_range ssr_super;
-};
-
struct seq_thread_info {
struct txn_param sti_txn;
struct req_capsule sti_pill;
- struct seq_store_record sti_record;
+ struct lu_range sti_space;
int sti_rep_buf_size[REQ_MAX_FIELD_NR];
struct lu_buf sti_buf;
};
#include "fid_internal.h"
static int seq_client_rpc(struct lu_client_seq *seq,
- struct lu_range *range,
+ struct lu_range *space,
__u32 opc, const char *opcname)
{
int rc, size[3] = { sizeof(struct ptlrpc_body),
GOTO(out_req, rc);
out = req_capsule_server_get(&pill, &RMF_SEQ_RANGE);
- *range = *out;
+ *space = *out;
- if (!range_is_sane(range)) {
+ if (!range_is_sane(space)) {
CERROR("%s: Invalid range received from server: "
- DRANGE"\n", seq->lcs_name, PRANGE(range));
+ DRANGE"\n", seq->lcs_name, PRANGE(space));
GOTO(out_req, rc = -EINVAL);
}
- if (range_is_exhausted(range)) {
+ if (range_is_exhausted(space)) {
CERROR("%s: Range received from server is exhausted: "
- DRANGE"]\n", seq->lcs_name, PRANGE(range));
+ DRANGE"]\n", seq->lcs_name, PRANGE(space));
GOTO(out_req, rc = -EINVAL);
}
*in = *out;
CDEBUG(D_INFO, "%s: Allocated %s-sequence "DRANGE"]\n",
- seq->lcs_name, opcname, PRANGE(range));
+ seq->lcs_name, opcname, PRANGE(space));
EXIT;
out_req:
if (seq->lcs_srv) {
LASSERT(env != NULL);
rc = seq_server_alloc_super(seq->lcs_srv, NULL,
- &seq->lcs_range,
+ &seq->lcs_space,
env);
} else {
#endif
- rc = seq_client_rpc(seq, &seq->lcs_range,
+ rc = seq_client_rpc(seq, &seq->lcs_space,
SEQ_ALLOC_SUPER, "super");
#ifdef __KERNEL__
}
if (seq->lcs_srv) {
LASSERT(env != NULL);
rc = seq_server_alloc_meta(seq->lcs_srv, NULL,
- &seq->lcs_range,
+ &seq->lcs_space,
env);
} else {
#endif
- rc = seq_client_rpc(seq, &seq->lcs_range,
+ rc = seq_client_rpc(seq, &seq->lcs_space,
SEQ_ALLOC_META, "meta");
#ifdef __KERNEL__
}
int rc = 0;
ENTRY;
- LASSERT(range_is_sane(&seq->lcs_range));
+ LASSERT(range_is_sane(&seq->lcs_space));
- /* if we still have free sequences in meta-sequence we allocate new seq
- * from given range, if not - allocate new meta-sequence. */
- if (range_space(&seq->lcs_range) == 0) {
+ /*
+ * If we still have free sequences in meta-sequence we allocate new seq
+ * from given range, if not - allocate new meta-sequence.
+ */
+ if (range_space(&seq->lcs_space) == 0) {
rc = __seq_client_alloc_meta(seq, NULL);
if (rc) {
CERROR("%s: Can't allocate new meta-sequence, "
RETURN(rc);
} else {
CDEBUG(D_INFO|D_WARNING, "%s: New range - "DRANGE"\n",
- seq->lcs_name, PRANGE(&seq->lcs_range));
+ seq->lcs_name, PRANGE(&seq->lcs_space));
}
}
- LASSERT(range_space(&seq->lcs_range) > 0);
- *seqnr = seq->lcs_range.lr_start;
- seq->lcs_range.lr_start++;
+ LASSERT(range_space(&seq->lcs_space) > 0);
+ *seqnr = seq->lcs_space.lr_start;
+ seq->lcs_space.lr_start++;
CDEBUG(D_INFO, "%s: Allocated sequence ["LPX64"]\n",
seq->lcs_name, *seqnr);
seq->lcs_srv = srv;
seq->lcs_type = type;
fid_zero(&seq->lcs_fid);
- range_zero(&seq->lcs_range);
+ range_zero(&seq->lcs_space);
sema_init(&seq->lcs_sem, 1);
seq->lcs_width = LUSTRE_SEQ_MAX_WIDTH;
SEQ_TXN_STORE_CREDITS = 20
};
-static struct lu_buf *seq_record_buf(struct seq_thread_info *info)
+static struct lu_buf *seq_store_buf(struct seq_thread_info *info)
{
struct lu_buf *buf;
buf = &info->sti_buf;
- buf->lb_buf = &info->sti_record;
- buf->lb_len = sizeof(info->sti_record);
+ buf->lb_buf = &info->sti_space;
+ buf->lb_len = sizeof(info->sti_space);
return buf;
}
-/* this function implies that caller takes care about locking */
+/* This function implies that caller takes care about locking. */
int seq_store_write(struct lu_server_seq *seq,
const struct lu_env *env)
{
info = lu_context_key_get(&env->le_ctx, &seq_thread_key);
LASSERT(info != NULL);
- /* stub here, will fix it later */
+ /* Stub here, will fix it later. */
info->sti_txn.tp_credits = SEQ_TXN_STORE_CREDITS;
th = dt_dev->dd_ops->dt_trans_start(env, dt_dev, &info->sti_txn);
if (!IS_ERR(th)) {
- /* store ranges in le format */
- range_cpu_to_le(&info->sti_record.ssr_space, &seq->lss_space);
- range_cpu_to_le(&info->sti_record.ssr_super, &seq->lss_super);
+ /* Store ranges in le format. */
+ range_cpu_to_le(&info->sti_space, &seq->lss_space);
rc = dt_obj->do_body_ops->dbo_write(env, dt_obj,
- seq_record_buf(info),
+ seq_store_buf(info),
&pos, th, BYPASS_CAPA);
- if (rc == sizeof(info->sti_record)) {
- struct lu_range *r = (seq->lss_type == LUSTRE_SEQ_SERVER ?
- &seq->lss_super : &seq->lss_space);
-
+ if (rc == sizeof(info->sti_space)) {
CDEBUG(D_INFO|D_WARNING, "%s: Space - "DRANGE"\n",
- seq->lss_name, PRANGE(r));
+ seq->lss_name, PRANGE(&seq->lss_space));
rc = 0;
} else if (rc >= 0) {
rc = -EIO;
RETURN(rc);
}
-/* this function implies that caller takes care about locking or locking is not
- * needed (init time). */
+/*
+ * This function implies that caller takes care about locking or locking is not
+ * needed (init time).
+ */
int seq_store_read(struct lu_server_seq *seq,
const struct lu_env *env)
{
info = lu_context_key_get(&env->le_ctx, &seq_thread_key);
LASSERT(info != NULL);
- rc = dt_obj->do_body_ops->dbo_read(env, dt_obj,
- seq_record_buf(info), &pos,
- BYPASS_CAPA);
-
- if (rc == sizeof(info->sti_record)) {
- struct lu_range *r = (seq->lss_type == LUSTRE_SEQ_SERVER ?
- &seq->lss_super : &seq->lss_space);
-
- range_le_to_cpu(&seq->lss_space, &info->sti_record.ssr_space);
- range_le_to_cpu(&seq->lss_super, &info->sti_record.ssr_super);
+ rc = dt_obj->do_body_ops->dbo_read(env, dt_obj, seq_store_buf(info),
+ &pos, BYPASS_CAPA);
+ if (rc == sizeof(info->sti_space)) {
+ range_le_to_cpu(&seq->lss_space, &info->sti_space);
CDEBUG(D_INFO|D_WARNING, "%s: Space - "DRANGE"\n",
- seq->lss_name, PRANGE(r));
+ seq->lss_name, PRANGE(&seq->lss_space));
rc = 0;
} else if (rc == 0) {
rc = -ENODATA;
} else if (rc >= 0) {
CERROR("%s: Read only %d bytes of %d\n", seq->lss_name,
- rc, sizeof(info->sti_record));
+ rc, sizeof(info->sti_space));
rc = -EIO;
}
RETURN(0);
}
-/*
- * Server side procfs stuff.
- */
static int
seq_proc_read_common(char *page, char **start, off_t off,
int count, int *eof, void *data,
ENTRY;
*eof = 1;
- rc = snprintf(page, count, DRANGE"]\n",
- PRANGE(range));
+ rc = snprintf(page, count, "[%Lx - %Lx]\n",
+ PRANGE(range));
RETURN(rc);
}
+/*
+ * Server side procfs stuff.
+ */
static int
-seq_proc_write_space(struct file *file, const char *buffer,
- unsigned long count, void *data)
+seq_server_proc_write_space(struct file *file, const char *buffer,
+ unsigned long count, void *data)
{
struct lu_server_seq *seq = (struct lu_server_seq *)data;
int rc;
}
static int
-seq_proc_read_space(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+seq_server_proc_read_space(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
struct lu_server_seq *seq = (struct lu_server_seq *)data;
int rc;
}
static int
-seq_proc_write_super(struct file *file, const char *buffer,
- unsigned long count, void *data)
-{
- struct lu_server_seq *seq = (struct lu_server_seq *)data;
- int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
-
- down(&seq->lss_sem);
- rc = seq_proc_write_common(file, buffer, count,
- data, &seq->lss_super);
-
- if (rc == 0) {
- CDEBUG(D_WARNING, "%s: Super has changed to "
- DRANGE"\n", seq->lss_name, PRANGE(&seq->lss_super));
- }
-
- up(&seq->lss_sem);
-
- RETURN(count);
-}
-
-static int
-seq_proc_read_super(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct lu_server_seq *seq = (struct lu_server_seq *)data;
- int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
-
- down(&seq->lss_sem);
- rc = seq_proc_read_common(page, start, off, count, eof,
- data, &seq->lss_super);
- up(&seq->lss_sem);
-
- RETURN(rc);
-}
-
-static int
-seq_proc_read_controller(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+seq_server_proc_read_server(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
struct lu_server_seq *seq = (struct lu_server_seq *)data;
int rc;
}
static int
-seq_proc_write_super_width(struct file *file, const char *buffer,
- unsigned long count, void *data)
+seq_server_proc_write_width(struct file *file, const char *buffer,
+ unsigned long count, void *data)
{
struct lu_server_seq *seq = (struct lu_server_seq *)data;
int rc, val;
if (rc)
RETURN(rc);
- seq->lss_super_width = val;
+ seq->lss_width = val;
if (rc == 0) {
- CDEBUG(D_WARNING, "%s: Super width has changed to "
- LPU64"\n", seq->lss_name, seq->lss_super_width);
+ CDEBUG(D_WARNING, "%s: Allocation unit has changed to "
+ LPU64"\n", seq->lss_name, seq->lss_width);
}
up(&seq->lss_sem);
}
static int
-seq_proc_read_super_width(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+seq_server_proc_read_width(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
struct lu_server_seq *seq = (struct lu_server_seq *)data;
int rc;
LASSERT(seq != NULL);
down(&seq->lss_sem);
- rc = snprintf(page, count, LPU64"\n", seq->lss_super_width);
+ rc = snprintf(page, count, LPU64"\n", seq->lss_width);
up(&seq->lss_sem);
RETURN(rc);
}
+/* Client side procfs stuff */
static int
-seq_proc_write_meta_width(struct file *file, const char *buffer,
- unsigned long count, void *data)
-{
- struct lu_server_seq *seq = (struct lu_server_seq *)data;
- int rc, val;
- ENTRY;
-
- LASSERT(seq != NULL);
-
- down(&seq->lss_sem);
-
- rc = lprocfs_write_helper(buffer, count, &val);
- if (rc)
- RETURN(rc);
-
- if (val <= seq->lss_super_width) {
- seq->lss_meta_width = val;
-
- if (rc == 0) {
- CDEBUG(D_WARNING, "%s: Meta width has changed to "
- LPU64"\n", seq->lss_name, seq->lss_meta_width);
- }
- }
-
- up(&seq->lss_sem);
- RETURN(count);
-}
-
-static int
-seq_proc_read_meta_width(char *page, char **start, off_t off,
- int count, int *eof, void *data)
-{
- struct lu_server_seq *seq = (struct lu_server_seq *)data;
- int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
-
- down(&seq->lss_sem);
- rc = snprintf(page, count, LPU64"\n", seq->lss_meta_width);
- up(&seq->lss_sem);
-
- RETURN(rc);
-}
-
-/* client side procfs stuff */
-static int
-seq_proc_write_range(struct file *file, const char *buffer,
- unsigned long count, void *data)
+seq_client_proc_write_space(struct file *file, const char *buffer,
+ unsigned long count, void *data)
{
struct lu_client_seq *seq = (struct lu_client_seq *)data;
int rc;
down(&seq->lcs_sem);
rc = seq_proc_write_common(file, buffer, count,
- data, &seq->lcs_range);
+ data, &seq->lcs_space);
if (rc == 0) {
- CDEBUG(D_WARNING, "%s: Range has changed to "
- DRANGE"\n", seq->lcs_name, PRANGE(&seq->lcs_range));
+ CDEBUG(D_WARNING, "%s: Sequences space has "
+ "changed to "DRANGE"\n", seq->lcs_name,
+ PRANGE(&seq->lcs_space));
}
up(&seq->lcs_sem);
}
static int
-seq_proc_read_range(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+seq_client_proc_read_space(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
struct lu_client_seq *seq = (struct lu_client_seq *)data;
int rc;
down(&seq->lcs_sem);
rc = seq_proc_read_common(page, start, off, count, eof,
- data, &seq->lcs_range);
+ data, &seq->lcs_space);
up(&seq->lcs_sem);
RETURN(rc);
}
static int
-seq_proc_write_seq_width(struct file *file, const char *buffer,
- unsigned long count, void *data)
+seq_client_proc_write_width(struct file *file, const char *buffer,
+ unsigned long count, void *data)
{
struct lu_client_seq *seq = (struct lu_client_seq *)data;
int rc, val;
seq->lcs_width = val;
if (rc == 0) {
- CDEBUG(D_WARNING, "%s: Sequence width "
- "has changed to "LPU64"\n",
- seq->lcs_name, seq->lcs_width);
+ CDEBUG(D_WARNING, "%s: Allocation unit has changed to "
+ ""LPU64"\n", seq->lcs_name, seq->lcs_width);
}
}
}
static int
-seq_proc_read_seq_width(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+seq_client_proc_read_width(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
struct lu_client_seq *seq = (struct lu_client_seq *)data;
int rc;
}
static int
-seq_proc_read_next_fid(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+seq_client_proc_read_next_fid(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
struct lu_client_seq *seq = (struct lu_client_seq *)data;
int rc;
}
static int
-seq_proc_read_server(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+seq_client_proc_read_server(char *page, char **start, off_t off,
+ int count, int *eof, void *data)
{
struct lu_client_seq *seq = (struct lu_client_seq *)data;
struct client_obd *cli = &seq->lcs_exp->exp_obd->u.cli;
}
struct lprocfs_vars seq_server_proc_list[] = {
- { "space", seq_proc_read_space, seq_proc_write_space, NULL },
- { "super", seq_proc_read_super, seq_proc_write_super, NULL },
- { "controller", seq_proc_read_controller, NULL, NULL },
- { "super_width", seq_proc_read_super_width, seq_proc_write_super_width, NULL },
- { "meta_width", seq_proc_read_meta_width, seq_proc_write_meta_width, NULL },
+ { "space", seq_server_proc_read_space, seq_server_proc_write_space, NULL },
+ { "width", seq_server_proc_read_width, seq_server_proc_write_width, NULL },
+ { "server", seq_server_proc_read_server, NULL, NULL },
{ NULL }};
struct lprocfs_vars seq_client_proc_list[] = {
- { "range", seq_proc_read_range, seq_proc_write_range, NULL },
- { "server", seq_proc_read_server, NULL, NULL },
- { "next_fid" , seq_proc_read_next_fid, NULL, NULL },
- { "seq_width", seq_proc_read_seq_width, seq_proc_write_seq_width, NULL },
+ { "space", seq_client_proc_read_space, seq_client_proc_write_space, NULL },
+ { "width", seq_client_proc_read_width, seq_client_proc_write_width, NULL },
+ { "server", seq_client_proc_read_server, NULL, NULL },
+ { "next_fid", seq_client_proc_read_next_fid, NULL, NULL },
{ NULL }};
#endif
struct lu_site;
struct lu_context;
-/* whole sequences space range and zero range definitions */
+/* Whole sequences space range and zero range definitions */
extern const struct lu_range LUSTRE_SEQ_SPACE_RANGE;
extern const struct lu_range LUSTRE_SEQ_ZERO_RANGE;
extern const struct lu_fid LUSTRE_BFL_FID;
enum {
- /* this is how may FIDs may be allocated in one sequence. 16384 for now */
+ /*
+ * This is how may FIDs may be allocated in one sequence. 16384 for
+ * now.
+ */
LUSTRE_SEQ_MAX_WIDTH = 0x0000000000004000ULL,
- /* how many sequences may be allocate for meta-sequence (this is 128
- * sequences). */
+ /*
+ * How many sequences may be allocate for meta-sequence (this is 128
+ * sequences).
+ */
LUSTRE_SEQ_META_WIDTH = 0x0000000000000080ULL,
- /* this is how many sequences may be in one super-sequence allocated to
- * MDTs. */
+ /*
+ * This is how many sequences may be in one super-sequence allocated to
+ * MDTs.
+ */
LUSTRE_SEQ_SUPER_WIDTH = (LUSTRE_SEQ_META_WIDTH * LUSTRE_SEQ_META_WIDTH)
};
struct lu_server_seq;
-/* client sequence manager interface */
+/* Client sequence manager interface. */
struct lu_client_seq {
/* sequence-controller export. */
struct obd_export *lcs_exp;
struct semaphore lcs_sem;
- /* range of allowed for allocation sequeces. When using lu_client_seq on
+ /*
+ * Range of allowed for allocation sequeces. When using lu_client_seq on
* clients, this contains meta-sequence range. And for servers this
- * contains super-sequence range. */
- struct lu_range lcs_range;
+ * contains super-sequence range.
+ */
+ struct lu_range lcs_space;
- /* seq related proc */
+ /* Seq related proc */
cfs_proc_dir_entry_t *lcs_proc_dir;
- /* this holds last allocated fid in last obtained seq */
+ /* This holds last allocated fid in last obtained seq */
struct lu_fid lcs_fid;
/* LUSTRE_SEQ_METADATA or LUSTRE_SEQ_DATA */
enum lu_cli_type lcs_type;
- /* service uuid, passed from MDT + seq name to form unique seq name to
- * use it with procfs. */
+ /*
+ * Service uuid, passed from MDT + seq name to form unique seq name to
+ * use it with procfs.
+ */
char lcs_name[80];
- /* sequence width, that is how many objects may be allocated in one
- * sequence. Default value for it is LUSTRE_SEQ_MAX_WIDTH. */
+ /*
+ * Sequence width, that is how many objects may be allocated in one
+ * sequence. Default value for it is LUSTRE_SEQ_MAX_WIDTH.
+ */
__u64 lcs_width;
/* seq-server for direct talking */
/* server sequence manager interface */
struct lu_server_seq {
- /* available sequence space */
+ /* Available sequences space */
struct lu_range lss_space;
- /* super-sequence range, all super-sequences for other servers are
- * allocated from it. */
- struct lu_range lss_super;
-
- /* device for server side seq manager needs (saving sequences to backing
- * store). */
+ /*
+ * Device for server side seq manager needs (saving sequences to backing
+ * store).
+ */
struct dt_device *lss_dev;
/* /seq file object device */
struct dt_object *lss_obj;
- /* seq related proc */
+ /* Seq related proc */
cfs_proc_dir_entry_t *lss_proc_dir;
/* LUSTRE_SEQ_SERVER or LUSTRE_SEQ_CONTROLLER */
enum lu_mgr_type lss_type;
- /* client interafce to request controller */
+ /* Client interafce to request controller */
struct lu_client_seq *lss_cli;
- /* semaphore for protecting allocation */
+ /* Semaphore for protecting allocation */
struct semaphore lss_sem;
- /* service uuid, passed from MDT + seq name to form unique seq name to
- * use it with procfs. */
+ /*
+ * Service uuid, passed from MDT + seq name to form unique seq name to
+ * use it with procfs.
+ */
char lss_name[80];
- /* allocation chunks for super and meta sequences. Default values are
- * LUSTRE_SEQ_SUPER_WIDTH and LUSTRE_SEQ_META_WIDTH. */
- __u64 lss_super_width;
- __u64 lss_meta_width;
+ /*
+ * Allocation chunks for super and meta sequences. Default values are
+ * LUSTRE_SEQ_SUPER_WIDTH and LUSTRE_SEQ_META_WIDTH.
+ */
+ __u64 lss_width;
};
int seq_query(struct com_thread_info *info);
{
local mds=$1
local width=$2
- local file=`ls /proc/fs/lustre/seq/cli-srv-$mds-mdc-*/seq_width`
+ local file=`ls /proc/fs/lustre/seq/cli-srv-$mds-mdc-*/width`
echo $width > $file
}
seq_get_width()
{
local mds=$1
- local file=`ls /proc/fs/lustre/seq/cli-srv-$mds-mdc-*/seq_width`
+ local file=`ls /proc/fs/lustre/seq/cli-srv-$mds-mdc-*/width`
cat $file
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff