* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, Intel Corporation.
+ * Copyright (c) 2012, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
read_lock(&ofd->ofd_seq_list_lock);
cfs_list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
- if (oseq->os_seq == seq) {
+ if (ostid_seq(&oseq->os_oi) == seq) {
cfs_atomic_inc(&oseq->os_refc);
read_unlock(&ofd->ofd_seq_list_lock);
return oseq;
write_lock(&ofd->ofd_seq_list_lock);
cfs_list_for_each_entry(os, &ofd->ofd_seq_list, os_list) {
- if (os->os_seq == new_seq->os_seq) {
+ if (ostid_seq(&os->os_oi) == ostid_seq(&new_seq->os_oi)) {
cfs_atomic_inc(&os->os_refc);
write_unlock(&ofd->ofd_seq_list_lock);
/* The seq has not been added to the list */
}
cfs_atomic_inc(&new_seq->os_refc);
cfs_list_add_tail(&new_seq->os_list, &ofd->ofd_seq_list);
+ ofd->ofd_seq_count++;
write_unlock(&ofd->ofd_seq_list_lock);
return new_seq;
}
obd_id id;
spin_lock(&oseq->os_last_oid_lock);
- id = oseq->os_last_oid;
+ id = ostid_id(&oseq->os_oi);
spin_unlock(&oseq->os_last_oid_lock);
return id;
void ofd_seq_last_oid_set(struct ofd_seq *oseq, obd_id id)
{
spin_lock(&oseq->os_last_oid_lock);
- if (likely(oseq->os_last_oid < id))
- oseq->os_last_oid = id;
+ if (likely(ostid_id(&oseq->os_oi) < id))
+ ostid_set_id(&oseq->os_oi, id);
spin_unlock(&oseq->os_last_oid_lock);
}
ENTRY;
+ tmp = cpu_to_le64(ofd_seq_last_oid(oseq));
+
info->fti_buf.lb_buf = &tmp;
info->fti_buf.lb_len = sizeof(tmp);
info->fti_off = 0;
- CDEBUG(D_INODE, "%s: write last_objid for seq "LPX64" : "LPX64"\n",
- ofd_name(ofd), oseq->os_seq, ofd_seq_last_oid(oseq));
-
- tmp = cpu_to_le64(ofd_seq_last_oid(oseq));
-
rc = ofd_record_write(env, ofd, oseq->os_lastid_obj, &info->fti_buf,
&info->fti_off);
+
+ CDEBUG(D_INODE, "%s: write last_objid "DOSTID": rc = %d\n",
+ ofd_name(ofd), POSTID(&oseq->os_oi), rc);
+
RETURN(rc);
}
-static int ofd_seq_count_write(const struct lu_env *env, struct ofd_device *ofd)
+static void ofd_deregister_seq_exp(struct ofd_device *ofd)
{
- struct ofd_thread_info *info = ofd_info(env);
- obd_seq tmp;
- int rc;
+ struct seq_server_site *ss = &ofd->ofd_seq_site;
- ENTRY;
+ if (ss->ss_client_seq != NULL) {
+ lustre_deregister_lwp_item(&ss->ss_client_seq->lcs_exp);
+ ss->ss_client_seq->lcs_exp = NULL;
+ }
- info->fti_buf.lb_buf = &tmp;
- info->fti_buf.lb_len = sizeof(tmp);
- info->fti_off = 0;
+ if (ss->ss_server_fld != NULL) {
+ lustre_deregister_lwp_item(&ss->ss_server_fld->lsf_control_exp);
+ ss->ss_server_fld->lsf_control_exp = NULL;
+ }
+}
- tmp = cpu_to_le32(ofd->ofd_seq_count);
+static int ofd_fld_fini(const struct lu_env *env,
+ struct ofd_device *ofd)
+{
+ struct seq_server_site *ss = &ofd->ofd_seq_site;
+ ENTRY;
- rc = ofd_record_write(env, ofd, ofd->ofd_seq_count_file,
- &info->fti_buf, &info->fti_off);
+ if (ss && ss->ss_server_fld) {
+ fld_server_fini(env, ss->ss_server_fld);
+ OBD_FREE_PTR(ss->ss_server_fld);
+ ss->ss_server_fld = NULL;
+ }
- RETURN(rc);
+ RETURN(0);
}
void ofd_seqs_fini(const struct lu_env *env, struct ofd_device *ofd)
struct ofd_seq *oseq;
struct ofd_seq *tmp;
cfs_list_t dispose;
+ int rc;
+
+ ofd_deregister_seq_exp(ofd);
+
+ rc = ofd_fid_fini(env, ofd);
+ if (rc != 0)
+ CERROR("%s: fid fini error: rc = %d\n", ofd_name(ofd), rc);
+
+ rc = ofd_fld_fini(env, ofd);
+ if (rc != 0)
+ CERROR("%s: fld fini error: rc = %d\n", ofd_name(ofd), rc);
CFS_INIT_LIST_HEAD(&dispose);
write_lock(&ofd->ofd_seq_list_lock);
return;
}
+/**
+ *
+ * \retval the seq with seq number or errno (never NULL)
+ */
struct ofd_seq *ofd_seq_load(const struct lu_env *env, struct ofd_device *ofd,
obd_seq seq)
{
if (oseq == NULL)
RETURN(ERR_PTR(-ENOMEM));
- lu_local_obj_fid(&info->fti_fid, OFD_GROUP0_LAST_OID + seq);
-
+ lu_last_id_fid(&info->fti_fid, seq);
memset(&info->fti_attr, 0, sizeof(info->fti_attr));
info->fti_attr.la_valid = LA_MODE;
info->fti_attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
CFS_INIT_LIST_HEAD(&oseq->os_list);
mutex_init(&oseq->os_create_lock);
spin_lock_init(&oseq->os_last_oid_lock);
- oseq->os_seq = seq;
+ ostid_set_seq(&oseq->os_oi, seq);
cfs_atomic_set(&oseq->os_refc, 1);
if (info->fti_attr.la_size == 0) {
/* object is just created, initialize last id */
- oseq->os_last_oid = OFD_INIT_OBJID;
+ ofd_seq_last_oid_set(oseq, OFD_INIT_OBJID);
ofd_seq_last_oid_write(env, ofd, oseq);
- ofd_seq_count_write(env, ofd);
} else if (info->fti_attr.la_size == sizeof(lastid)) {
info->fti_off = 0;
info->fti_buf.lb_buf = &lastid;
ofd_name(ofd), rc);
GOTO(cleanup, rc);
}
- oseq->os_last_oid = le64_to_cpu(lastid);
+ ofd_seq_last_oid_set(oseq, le64_to_cpu(lastid));
} else {
CERROR("%s: corrupted size "LPU64" LAST_ID of seq "LPX64"\n",
ofd_name(ofd), (__u64)info->fti_attr.la_size, seq);
}
oseq = ofd_seq_add(env, ofd, oseq);
- RETURN(oseq);
+ RETURN((oseq != NULL) ? oseq : ERR_PTR(-ENOENT));
cleanup:
ofd_seq_put(env, oseq);
return ERR_PTR(rc);
}
-/* object sequence management */
-int ofd_seqs_init(const struct lu_env *env, struct ofd_device *ofd)
+static int ofd_fld_init(const struct lu_env *env, const char *uuid,
+ struct ofd_device *ofd)
{
- struct ofd_thread_info *info = ofd_info(env);
- unsigned long seq_count_size;
- obd_seq seq_count;
- int rc = 0;
- int i;
-
+ struct seq_server_site *ss = &ofd->ofd_seq_site;
+ int rc;
ENTRY;
- rwlock_init(&ofd->ofd_seq_list_lock);
- CFS_INIT_LIST_HEAD(&ofd->ofd_seq_list);
+ OBD_ALLOC_PTR(ss->ss_server_fld);
+ if (ss->ss_server_fld == NULL)
+ RETURN(rc = -ENOMEM);
- rc = dt_attr_get(env, ofd->ofd_seq_count_file,
- &info->fti_attr, BYPASS_CAPA);
- if (rc)
- GOTO(cleanup, rc);
+ rc = fld_server_init(env, ss->ss_server_fld, ofd->ofd_osd, uuid,
+ ss->ss_node_id, LU_SEQ_RANGE_OST);
+ if (rc) {
+ OBD_FREE_PTR(ss->ss_server_fld);
+ ss->ss_server_fld = NULL;
+ RETURN(rc);
+ }
+ RETURN(0);
+}
- seq_count_size = (unsigned long)info->fti_attr.la_size;
+static int ofd_register_seq_exp(struct ofd_device *ofd)
+{
+ struct seq_server_site *ss = &ofd->ofd_seq_site;
+ char *lwp_name = NULL;
+ int rc;
+
+ OBD_ALLOC(lwp_name, MAX_OBD_NAME);
+ if (lwp_name == NULL)
+ GOTO(out_free, rc = -ENOMEM);
+
+ rc = tgt_name2lwpname(ofd_name(ofd), lwp_name);
+ if (rc != 0)
+ GOTO(out_free, rc);
+
+ rc = lustre_register_lwp_item(lwp_name, &ss->ss_client_seq->lcs_exp,
+ NULL, NULL);
+ if (rc != 0)
+ GOTO(out_free, rc);
+
+ rc = lustre_register_lwp_item(lwp_name,
+ &ss->ss_server_fld->lsf_control_exp,
+ NULL, NULL);
+ if (rc != 0) {
+ lustre_deregister_lwp_item(&ss->ss_client_seq->lcs_exp);
+ ss->ss_client_seq->lcs_exp = NULL;
+ GOTO(out_free, rc);
+ }
+out_free:
+ if (lwp_name != NULL)
+ OBD_FREE(lwp_name, MAX_OBD_NAME);
- if (seq_count_size == sizeof(seq_count)) {
- info->fti_off = 0;
- info->fti_buf.lb_buf = &seq_count;
- info->fti_buf.lb_len = sizeof(seq_count);
+ return rc;
+}
- rc = dt_record_read(env, ofd->ofd_seq_count_file,
- &info->fti_buf, &info->fti_off);
- if (rc) {
- CERROR("%s: can't read LAST_GROUP: rc = %d\n",
- ofd_name(ofd), rc);
- GOTO(cleanup, rc);
- }
+/* object sequence management */
+int ofd_seqs_init(const struct lu_env *env, struct ofd_device *ofd)
+{
+ int rc;
- ofd->ofd_seq_count = le64_to_cpu(seq_count);
- } else if (seq_count_size == 0) {
- ofd->ofd_seq_count = 0;
- } else {
- CERROR("%s: seqs file is corrupted? size = %lu\n",
- ofd_name(ofd), seq_count_size);
- GOTO(cleanup, rc = -EIO);
+ rc = ofd_fid_init(env, ofd);
+ if (rc != 0) {
+ CERROR("%s: fid init error: rc = %d\n", ofd_name(ofd), rc);
+ return rc;
}
- for (i = 0; i <= ofd->ofd_seq_count; i++) {
- struct ofd_seq *oseq;
+ rc = ofd_fld_init(env, ofd_name(ofd), ofd);
+ if (rc) {
+ CERROR("%s: Can't init fld, rc %d\n", ofd_name(ofd), rc);
+ return rc;
+ }
- oseq = ofd_seq_load(env, ofd, i);
- if (IS_ERR(oseq)) {
- CERROR("%s: can't load seq %d: rc = %d\n",
- ofd_name(ofd), i, rc);
- /* Clean all previously set seqs */
- ofd_seqs_fini(env, ofd);
- GOTO(cleanup, rc);
- } else {
- ofd_seq_put(env, oseq);
- }
+ rc = ofd_register_seq_exp(ofd);
+ if (rc) {
+ CERROR("%s: Can't init seq exp, rc %d\n", ofd_name(ofd), rc);
+ return rc;
}
- CDEBUG(D_OTHER, "%s: %u seqs initialized\n", ofd_name(ofd),
- ofd->ofd_seq_count + 1);
-cleanup:
- RETURN(rc);
+ rwlock_init(&ofd->ofd_seq_list_lock);
+ CFS_INIT_LIST_HEAD(&ofd->ofd_seq_list);
+ ofd->ofd_seq_count = 0;
+ return rc;
}
int ofd_clients_data_init(const struct lu_env *env, struct ofd_device *ofd,
struct ofd_thread_info *info = ofd_info(env);
struct lr_server_data *lsd = &ofd->ofd_lut.lut_lsd;
struct obd_device *obd = ofd_obd(ofd);
- unsigned long last_rcvd_size;
- int rc;
+ unsigned long last_rcvd_size;
+ __u32 index;
+ int rc;
rc = dt_attr_get(env, ofd->ofd_lut.lut_last_rcvd, &info->fti_attr,
BYPASS_CAPA);
CLASSERT (offsetof(struct lr_server_data, lsd_padding) +
sizeof(lsd->lsd_padding) == LR_SERVER_SIZE);
+ rc = server_name2index(obd->obd_name, &index, NULL);
+ if (rc < 0) {
+ CERROR("%s: Can not get index from obd_name: rc = %d\n",
+ obd->obd_name, rc);
+ RETURN(rc);
+ }
+
if (last_rcvd_size == 0) {
LCONSOLE_WARN("%s: new disk, initializing\n", obd->obd_name);
lsd->lsd_client_size = LR_CLIENT_SIZE;
lsd->lsd_subdir_count = FILTER_SUBDIR_COUNT;
lsd->lsd_feature_incompat = OBD_INCOMPAT_OST;
+ lsd->lsd_osd_index = index;
} else {
rc = tgt_server_data_read(env, &ofd->ofd_lut);
if (rc) {
obd->obd_uuid.uuid, lsd->lsd_uuid);
GOTO(err_fsd, rc = -EINVAL);
}
+
+ if (lsd->lsd_osd_index == 0) {
+ lsd->lsd_osd_index = index;
+ } else if (lsd->lsd_osd_index != index) {
+ LCONSOLE_ERROR("%s: index %d in last rcvd is different"
+ " with the index %d in config log."
+ " It might be disk corruption!\n",
+ obd->obd_name, lsd->lsd_osd_index,
+ index);
+ GOTO(err_fsd, rc = -EINVAL);
+ }
}
lsd->lsd_mount_count++;
ofd->ofd_health_check_file = fo;
- lu_local_obj_fid(&info->fti_fid, OFD_LAST_GROUP_OID);
- memset(&info->fti_attr, 0, sizeof(info->fti_attr));
- info->fti_attr.la_valid = LA_MODE;
- info->fti_attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
- info->fti_dof.dof_type = dt_mode_to_dft(S_IFREG);
-
- fo = dt_find_or_create(env, ofd->ofd_osd, &info->fti_fid,
- &info->fti_dof, &info->fti_attr);
- if (IS_ERR(fo))
- GOTO(out_hc, rc = PTR_ERR(fo));
-
- ofd->ofd_seq_count_file = fo;
-
rc = ofd_seqs_init(env, ofd);
if (rc)
- GOTO(out_lg, rc);
+ GOTO(out_hc, rc);
RETURN(0);
-out_lg:
- lu_object_put(env, &ofd->ofd_seq_count_file->do_lu);
out_hc:
lu_object_put(env, &ofd->ofd_health_check_file->do_lu);
out:
/* Remove transaction callback */
dt_txn_callback_del(ofd->ofd_osd, &ofd->ofd_txn_cb);
- if (ofd->ofd_seq_count_file) {
- lu_object_put(env, &ofd->ofd_seq_count_file->do_lu);
- ofd->ofd_seq_count_file = NULL;
- }
-
if (ofd->ofd_health_check_file) {
lu_object_put(env, &ofd->ofd_health_check_file->do_lu);
ofd->ofd_health_check_file = NULL;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff