/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- * linux/mds/mds_fs.c
- *
+ * mds/mds_fs.c
* Lustre Metadata Server (MDS) filesystem interface code
*
- * Copyright (C) 2002 Cluster File Systems, Inc.
+ * Copyright (C) 2002, 2003 Cluster File Systems, Inc.
+ * Author: Andreas Dilger <adilger@clusterfs.com>
+ *
+ * This file is part of Lustre, http://www.lustre.org.
*
- * This code is issued under the GNU General Public License.
- * See the file COPYING in this distribution
+ * Lustre is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
*
- * by Andreas Dilger <adilger@clusterfs.com>
+ * Lustre is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
*
+ * You should have received a copy of the GNU General Public License
+ * along with Lustre; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define EXPORT_SYMTAB
#include <linux/module.h>
#include <linux/kmod.h>
+#include <linux/version.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#include <linux/mount.h>
+#endif
#include <linux/lustre_mds.h>
#include <linux/obd_class.h>
#include <linux/obd_support.h>
push_ctxt(&saved, &mds->mds_ctxt, NULL);
written = lustre_fwrite(mds->mds_rcvd_filp,
- (char *)med->med_mcd,
- sizeof(*med->med_mcd), &off);
+ (char *)med->med_mcd,
+ sizeof(*med->med_mcd), &off);
pop_ctxt(&saved, &mds->mds_ctxt, NULL);
if (written != sizeof(*med->med_mcd)) {
RETURN(written);
RETURN(-EIO);
}
+ CDEBUG(D_INFO, "wrote client mcd at off %u (len %u)\n",
+ MDS_LR_CLIENT + (cl_off * MDS_LR_SIZE),
+ (unsigned int)sizeof(*med->med_mcd));
}
return 0;
}
if (!med->med_mcd)
RETURN(0);
- CDEBUG(D_INFO, "freeing client at offset %d with UUID '%s'\n",
- med->med_off, med->med_mcd->mcd_uuid);
+ off = MDS_LR_CLIENT + (med->med_off * MDS_LR_SIZE);
+
+ CDEBUG(D_INFO, "freeing client at offset %u (%lld)with UUID '%s'\n",
+ med->med_off, off, med->med_mcd->mcd_uuid);
if (!test_and_clear_bit(med->med_off, last_rcvd_slots)) {
- CERROR("MDS client %d: bit already clear in bitmap!!\n",
+ CERROR("MDS client %u: bit already clear in bitmap!!\n",
med->med_off);
LBUG();
}
- off = med->med_off;
-
memset(&zero_mcd, 0, sizeof zero_mcd);
push_ctxt(&saved, &mds->mds_ctxt, NULL);
written = lustre_fwrite(mds->mds_rcvd_filp, (const char *)&zero_mcd,
- sizeof zero_mcd, &off);
+ sizeof(zero_mcd), &off);
pop_ctxt(&saved, &mds->mds_ctxt, NULL);
- if (written != sizeof zero_mcd) {
+ if (written != sizeof(zero_mcd)) {
CERROR("error zeroing out client %s off %d in %s: %d\n",
med->med_mcd->mcd_uuid, med->med_off, LAST_RCVD,
written);
- LBUG();
} else {
CDEBUG(D_INFO, "zeroed out disconnecting client %s at off %d\n",
med->med_mcd->mcd_uuid, med->med_off);
struct mds_client_data *mcd = NULL;
loff_t off = 0;
int cl_off;
- int max_off = f->f_dentry->d_inode->i_size / sizeof(*mcd);
- __u64 last_rcvd = 0;
+ unsigned long last_rcvd_size = f->f_dentry->d_inode->i_size;
+ __u64 last_transno = 0;
__u64 last_mount;
int rc = 0;
if (rc != sizeof(*msd)) {
CERROR("error reading MDS %s: rc = %d\n", LAST_RCVD, rc);
- if (rc > 0) {
+ if (rc > 0)
rc = -EIO;
- }
GOTO(err_msd, rc);
}
+ CDEBUG(D_INODE, "last_rcvd has size %lu (msd + %lu clients)\n",
+ last_rcvd_size, (last_rcvd_size - MDS_LR_CLIENT)/MDS_LR_SIZE);
+
/*
- * When we do a clean MDS shutdown, we save the last_rcvd into
- * the header. If we find clients with higher last_rcvd values
- * then those clients may need recovery done.
+ * When we do a clean MDS shutdown, we save the last_transno into
+ * the header.
*/
- last_rcvd = le64_to_cpu(msd->msd_last_rcvd);
- mds->mds_last_rcvd = last_rcvd;
- CDEBUG(D_INODE, "got %Lu for server last_rcvd value\n",
- (unsigned long long)last_rcvd);
+ last_transno = le64_to_cpu(msd->msd_last_transno);
+ mds->mds_last_transno = last_transno;
+ CDEBUG(D_INODE, "got "LPU64" for server last_rcvd value\n",
+ last_transno);
last_mount = le64_to_cpu(msd->msd_mount_count);
mds->mds_mount_count = last_mount;
- CDEBUG(D_INODE, "got %Lu for server last_mount value\n",
- (unsigned long long)last_mount);
+ CDEBUG(D_INODE, "got "LPU64" for server last_mount value\n",last_mount);
- for (off = MDS_LR_CLIENT, cl_off = 0;
- off < max_off;
- off += MDS_LR_SIZE, cl_off++) {
+ /* off is adjusted by lustre_fread, so we don't adjust it in the loop */
+ for (off = MDS_LR_CLIENT, cl_off = 0; off < last_rcvd_size; cl_off++) {
int mount_age;
if (!mcd) {
if (rc != sizeof(*mcd)) {
CERROR("error reading MDS %s offset %d: rc = %d\n",
LAST_RCVD, cl_off, rc);
- if (rc > 0)
+ if (rc > 0) /* XXX fatal error or just abort reading? */
rc = -EIO;
break;
}
continue;
}
- last_rcvd = le64_to_cpu(mcd->mcd_last_rcvd);
+ last_transno = le64_to_cpu(mcd->mcd_last_transno);
- /* The exports are cleaned up by mds_disconnect, so they
- * need to be set up like real exports also.
+ /* These exports are cleaned up by mds_disconnect(), so they
+ * need to be set up like real exports as mds_connect() does.
*/
mount_age = last_mount - le64_to_cpu(mcd->mcd_mount_count);
- if (last_rcvd && mount_age < MDS_MOUNT_RECOV) {
+ if (mount_age < MDS_MOUNT_RECOV) {
struct obd_export *exp = class_new_export(obddev);
struct mds_export_data *med;
break;
}
+ memcpy(&exp->exp_client_uuid.uuid, mcd->mcd_uuid,
+ sizeof exp->exp_client_uuid.uuid);
med = &exp->exp_mds_data;
med->med_mcd = mcd;
mds_client_add(mds, med, cl_off);
- /* XXX put this in a helper if it gets more complex */
+ /* create helper if export init gets more complex */
INIT_LIST_HEAD(&med->med_open_head);
spin_lock_init(&med->med_open_lock);
mcd = NULL;
- mds->mds_recoverable_clients++;
- MOD_INC_USE_COUNT;
+ obddev->obd_recoverable_clients++;
} else {
CDEBUG(D_INFO,
"discarded client %d, UUID '%s', count %Ld\n",
(long long)le64_to_cpu(mcd->mcd_mount_count));
}
- if (last_rcvd > mds->mds_last_rcvd) {
- CDEBUG(D_OTHER,
- "client at offset %d has last_rcvd = %Lu\n",
- cl_off, (unsigned long long)last_rcvd);
- mds->mds_last_rcvd = last_rcvd;
- }
+ CDEBUG(D_OTHER, "client at offset %d has last_rcvd = %Lu\n",
+ cl_off, (unsigned long long)last_transno);
+
+ if (last_transno > mds->mds_last_transno)
+ mds->mds_last_transno = last_transno;
}
- mds->mds_last_committed = mds->mds_last_rcvd;
- if (mds->mds_recoverable_clients) {
- CERROR("need recovery: %d recoverable clients, last_rcvd %Lu\n",
- mds->mds_recoverable_clients, mds->mds_last_rcvd);
+ obddev->obd_last_committed = mds->mds_last_transno;
+ if (obddev->obd_recoverable_clients) {
+ CERROR("RECOVERY: %d recoverable clients, last_transno "
+ LPU64"\n",
+ obddev->obd_recoverable_clients, mds->mds_last_transno);
+ obddev->obd_next_recovery_transno = obddev->obd_last_committed
+ + 1;
+ obddev->obd_flags |= OBD_RECOVERING;
}
if (mcd)
if (!S_ISREG(f->f_dentry->d_inode->i_mode)) {
CERROR("%s is not a regular file!: mode = %o\n", LAST_RCVD,
f->f_dentry->d_inode->i_mode);
- GOTO(err_pop, rc = -ENOENT);
+ GOTO(err_filp, rc = -ENOENT);
}
rc = fsfilt_journal_data(obddev, f);
RETURN(mds_fs_prep(obddev));
}
-void mds_fs_cleanup(struct obd_device *obddev)
+int mds_fs_cleanup(struct obd_device *obddev)
{
struct mds_obd *mds = &obddev->u.mds;
+ struct obd_run_ctxt saved;
+ int rc = 0;
class_disconnect_all(obddev); /* this cleans up client info too */
mds_server_free_data(mds);
+
+ push_ctxt(&saved, &mds->mds_ctxt, NULL);
+ if (mds->mds_rcvd_filp) {
+ rc = filp_close(mds->mds_rcvd_filp, 0);
+ mds->mds_rcvd_filp = NULL;
+
+ if (rc)
+ CERROR("last_rcvd file won't close, rc=%d\n", rc);
+ }
+ pop_ctxt(&saved, &mds->mds_ctxt, NULL);
+
+ return rc;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff