X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmds%2Fmds_lov.c;h=40d477ddb27f93d1f295bf0ba8d72809f24cb0af;hb=c9a360f3334f20a956021b78e5379460645c75d0;hp=55782e542c8074c5f5c4f444c1f4c5a0da0774eb;hpb=113303973ec9f8484eb2355a1a6ef3c4c7fd6a56;p=fs%2Flustre-release.git diff --git a/lustre/mds/mds_lov.c b/lustre/mds/mds_lov.c index 55782e5..40d477d 100644 --- a/lustre/mds/mds_lov.c +++ b/lustre/mds/mds_lov.c @@ -1,34 +1,45 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * linux/mds/mds_lov.c - * Lustre Metadata Server (mds) handling of striped file data + * GPL HEADER START * - * Copyright (C) 2001-2003 Cluster File Systems, Inc. - * Author: Peter Braam + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * This file is part of the Lustre file system, http://www.lustre.org - * Lustre is a trademark of Cluster File Systems, Inc. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * You may have signed or agreed to another license before downloading - * this software. If so, you are bound by the terms and conditions - * of that agreement, and the following does not apply to you. See the - * LICENSE file included with this distribution for more information. + * This program 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 version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * If you did not agree to a different license, then this copy of Lustre - * is open source 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. + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf * - * In either case, 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 - * license text for more details. + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + * GPL HEADER END + */ +/* + * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/mds/mds_lov.c + * + * Lustre Metadata Server (mds) handling of striped file data + * + * Author: Peter Braam */ -#ifndef EXPORT_SYMTAB -# define EXPORT_SYMTAB -#endif #define DEBUG_SUBSYSTEM S_MDS #include @@ -38,136 +49,522 @@ #include #include #include +#include #include "mds_internal.h" -void mds_lov_update_objids(struct obd_device *obd, obd_id *ids) +static void mds_lov_dump_objids(const char *label, struct obd_device *obd) +{ + struct mds_obd *mds = &obd->u.mds; + unsigned int i=0, j; + + if ((libcfs_debug & D_INFO) == 0) + return; + + CDEBUG(D_INFO, "dump from %s\n", label); + if (mds->mds_lov_page_dirty == NULL) { + CERROR("NULL bitmap!\n"); + GOTO(skip_bitmap, i); + } + + for(i = 0; i < mds->mds_lov_page_dirty->size / BITS_PER_LONG + 1; i++) + CDEBUG(D_INFO, "%u - %lx\n", i, + mds->mds_lov_page_dirty->data[i]); +skip_bitmap: + if (mds->mds_lov_page_array == NULL) { + CERROR("not init page array!\n"); + GOTO(skip_array, i); + + } + for(i = 0;i < MDS_LOV_OBJID_PAGES_COUNT; i++) { + obd_id *data = mds->mds_lov_page_array[i]; + + if (data == NULL) + continue; + + for(j=0; j < OBJID_PER_PAGE(); j++) { + if (data[j] == 0) + continue; + CDEBUG(D_INFO,"objid page %u idx %u - "LPU64" \n", + i, j, data[j]); + } + } +skip_array: + EXIT; +} + +int mds_lov_init_objids(struct obd_device *obd) +{ + struct mds_obd *mds = &obd->u.mds; + int size = MDS_LOV_OBJID_PAGES_COUNT*sizeof(void *); + struct file *file; + int rc; + ENTRY; + + CLASSERT(((MDS_LOV_ALLOC_SIZE % sizeof(obd_id)) == 0)); + + mds->mds_lov_page_dirty = + CFS_ALLOCATE_BITMAP(MDS_LOV_OBJID_PAGES_COUNT); + if (mds->mds_lov_page_dirty == NULL) + RETURN(-ENOMEM); + + + OBD_ALLOC(mds->mds_lov_page_array, size); + if (mds->mds_lov_page_array == NULL) + GOTO(err_free_bitmap, rc = -ENOMEM); + + /* open and test the lov objd file */ + file = filp_open(LOV_OBJID, O_RDWR | O_CREAT, 0644); + if (IS_ERR(file)) { + rc = PTR_ERR(file); + CERROR("cannot open/create %s file: rc = %d\n", LOV_OBJID, rc); + GOTO(err_free, rc = PTR_ERR(file)); + } + if (!S_ISREG(file->f_dentry->d_inode->i_mode)) { + CERROR("%s is not a regular file!: mode = %o\n", LOV_OBJID, + file->f_dentry->d_inode->i_mode); + GOTO(err_open, rc = -ENOENT); + } + mds->mds_lov_objid_filp = file; + + RETURN (0); +err_open: + if (filp_close((struct file *)file, 0)) + CERROR("can't close %s after error\n", LOV_OBJID); +err_free: + OBD_FREE(mds->mds_lov_page_array, size); +err_free_bitmap: + CFS_FREE_BITMAP(mds->mds_lov_page_dirty); + + RETURN(rc); +} + +void mds_lov_destroy_objids(struct obd_device *obd) +{ + struct mds_obd *mds = &obd->u.mds; + int i, rc; + ENTRY; + + if (mds->mds_lov_page_array != NULL) { + for(i=0;imds_lov_page_array[i]; + if (data != NULL) + OBD_FREE(data, MDS_LOV_ALLOC_SIZE); + } + OBD_FREE(mds->mds_lov_page_array, + MDS_LOV_OBJID_PAGES_COUNT*sizeof(void *)); + } + + if (mds->mds_lov_objid_filp) { + rc = filp_close((struct file *)mds->mds_lov_objid_filp, NULL); + mds->mds_lov_objid_filp = NULL; + if (rc) + CERROR("%s file won't close, rc=%d\n", LOV_OBJID, rc); + } + + CFS_FREE_BITMAP(mds->mds_lov_page_dirty); + EXIT; +} + +/** + * currently exist two ways for know about ost count and max ost index. + * first - after ost is connected to mds and sync process finished + * second - get from lmm in recovery process, in case when mds not have configs, + * and ost isn't registered in mgs. + * + * \param mds pointer to mds structure + * \param index maxium ost index + * + * \retval -ENOMEM is not hame memory for new page + * \retval 0 is update passed + */ +static int mds_lov_update_max_ost(struct mds_obd *mds, obd_id index) +{ + __u32 page = index / OBJID_PER_PAGE(); + __u32 off = index % OBJID_PER_PAGE(); + obd_id *data = mds->mds_lov_page_array[page]; + + if (data == NULL) { + OBD_ALLOC(data, MDS_LOV_ALLOC_SIZE); + if (data == NULL) + RETURN(-ENOMEM); + + mds->mds_lov_page_array[page] = data; + } + + if (index > mds->mds_lov_objid_max_index) { + mds->mds_lov_objid_lastpage = page; + mds->mds_lov_objid_lastidx = off; + mds->mds_lov_objid_max_index = index; + } + + /* workaround - New target not in objids file; increase mdsize */ + /* ld_tgt_count is used as the max index everywhere, despite its name. */ + if (data[off] == 0) { + __u32 stripes; + + data[off] = 1; + mds->mds_lov_objid_count++; + stripes = min_t(__u32, LOV_MAX_STRIPE_COUNT, + mds->mds_lov_objid_count); + + mds->mds_max_mdsize = lov_mds_md_size(stripes, LOV_MAGIC_V3); + mds->mds_max_cookiesize = stripes * sizeof(struct llog_cookie); + + CDEBUG(D_CONFIG, "updated max_mdsize/max_cookiesize for %d" + " stripes: %d/%d\n", stripes, mds->mds_max_mdsize, + mds->mds_max_cookiesize); + } + + EXIT; + return 0; +} + +static int mds_lov_objinit(struct mds_obd *mds, __u32 index) +{ + __u32 page = index / OBJID_PER_PAGE(); + __u32 off = index % OBJID_PER_PAGE(); + obd_id *data = mds->mds_lov_page_array[page]; + + return (data[off] > 0); +} + +int mds_lov_prepare_objids(struct obd_device *obd, struct lov_mds_md *lmm) +{ + struct lov_ost_data_v1 *data; + __u32 count; + int rc = 0; + __u32 j; + + /* if we create file without objects - lmm is NULL */ + if (lmm == NULL) + return 0; + + switch (le32_to_cpu(lmm->lmm_magic)) { + case LOV_MAGIC_V1: + count = le32_to_cpu(((struct lov_mds_md_v1*)lmm)->lmm_stripe_count); + data = &(((struct lov_mds_md_v1*)lmm)->lmm_objects[0]); + break; + case LOV_MAGIC_V3: + count = le32_to_cpu(((struct lov_mds_md_v3*)lmm)->lmm_stripe_count); + data = &(((struct lov_mds_md_v3*)lmm)->lmm_objects[0]); + break; + default: + CERROR("Unknow lmm type %X!\n", le32_to_cpu(lmm->lmm_magic)); + RETURN(-EINVAL); + } + + + cfs_mutex_down(&obd->obd_dev_sem); + for (j = 0; j < count; j++) { + __u32 i = le32_to_cpu(data[j].l_ost_idx); + if (mds_lov_update_max_ost(&obd->u.mds, i)) { + rc = -ENOMEM; + break; + } + } + cfs_mutex_up(&obd->obd_dev_sem); + + RETURN(rc); +} +EXPORT_SYMBOL(mds_lov_prepare_objids); + +/* + * write llog orphan record about lost ost object, + * Special lsm is allocated with single stripe, caller should deallocated it + * after use + */ +static int mds_log_lost_precreated(struct obd_device *obd, + struct lov_stripe_md **lsmp, int *stripes, + obd_id id, obd_count count, int idx) +{ + struct lov_stripe_md *lsm = *lsmp; + int rc; + ENTRY; + + if (*lsmp == NULL) { + rc = obd_alloc_memmd(obd->u.mds.mds_lov_exp, &lsm); + if (rc < 0) + RETURN(rc); + /* need only one stripe, save old value */ + *stripes = lsm->lsm_stripe_count; + lsm->lsm_stripe_count = 1; + *lsmp = lsm; + } + + lsm->lsm_oinfo[0]->loi_id = id; + lsm->lsm_oinfo[0]->loi_seq = mdt_to_obd_objseq(obd->u.mds.mds_id); + lsm->lsm_oinfo[0]->loi_ost_idx = idx; + + rc = mds_log_op_orphan(obd, lsm, count); + RETURN(rc); +} + +void mds_lov_update_objids(struct obd_device *obd, struct lov_mds_md *lmm) { struct mds_obd *mds = &obd->u.mds; - int i; + int j; + struct lov_ost_data_v1 *obj; + struct lov_stripe_md *lsm = NULL; + int stripes = 0; + int count; ENTRY; - lock_kernel(); - for (i = 0; i < mds->mds_lov_desc.ld_tgt_count; i++) - if (ids[i] > (mds->mds_lov_objids)[i]) { - (mds->mds_lov_objids)[i] = ids[i]; - mds->mds_lov_objids_dirty = 1; + /* if we create file without objects - lmm is NULL */ + if (lmm == NULL) + return; + + switch (le32_to_cpu(lmm->lmm_magic)) { + case LOV_MAGIC_V1: + count = le32_to_cpu(((struct lov_mds_md_v1*)lmm)->lmm_stripe_count); + obj = ((struct lov_mds_md_v1*)lmm)->lmm_objects; + break; + case LOV_MAGIC_V3: + count = le32_to_cpu(((struct lov_mds_md_v3*)lmm)->lmm_stripe_count); + obj = ((struct lov_mds_md_v3*)lmm)->lmm_objects; + break; + default: + CERROR("Unknow lmm type %X !\n", + le32_to_cpu(lmm->lmm_magic)); + return; + } + + for (j = 0; j < count; j++) { + __u32 i = le32_to_cpu(obj[j].l_ost_idx); + obd_id id = le64_to_cpu(obj[j].l_object_id); + __u32 page = i / OBJID_PER_PAGE(); + __u32 idx = i % OBJID_PER_PAGE(); + obd_id *data; + + data = mds->mds_lov_page_array[page]; + + CDEBUG(D_INODE,"update last object for ost %u" + " - new "LPU64" old "LPU64"\n", i, id, data[idx]); + if (id > data[idx]) { + int lost = id - data[idx] - 1; + /* we might have lost precreated objects due to VBR */ + if (lost > 0 && obd->obd_recovering) { + CDEBUG(D_HA, "Gap in objids is %u\n", lost); + if (!obd->obd_version_recov) + CERROR("Unexpected gap in objids\n"); + /* lsm is allocated if NULL */ + mds_log_lost_precreated(obd, &lsm, &stripes, + data[idx]+1, lost, i); + } + data[idx] = id; + cfs_bitmap_set(mds->mds_lov_page_dirty, page); } - unlock_kernel(); + } + if (lsm) { + /* restore stripes number */ + lsm->lsm_stripe_count = stripes; + obd_free_memmd(mds->mds_lov_exp, &lsm); + } EXIT; + return; +} +EXPORT_SYMBOL(mds_lov_update_objids); + +static int mds_lov_update_from_read(struct mds_obd *mds, obd_id *data, + __u32 count) +{ + __u32 i; + __u32 stripes; + + for (i = 0; i < count; i++) { + if (data[i] == 0) + continue; + + mds->mds_lov_objid_count++; + } + + stripes = min_t(__u32, LOV_MAX_STRIPE_COUNT, + mds->mds_lov_objid_count); + + mds->mds_max_mdsize = lov_mds_md_size(stripes, LOV_MAGIC_V3); + mds->mds_max_cookiesize = stripes * sizeof(struct llog_cookie); + + CDEBUG(D_CONFIG, "updated max_mdsize/max_cookiesize for %d stripes: " + "%d/%d\n", stripes, mds->mds_max_mdsize, + mds->mds_max_cookiesize); + + EXIT; + return 0; } static int mds_lov_read_objids(struct obd_device *obd) { struct mds_obd *mds = &obd->u.mds; - obd_id *ids; loff_t off = 0; - int i, rc, size; + int i, rc = 0, count = 0, page = 0; + unsigned long size; ENTRY; - LASSERT(!mds->mds_lov_objids_size); - LASSERT(!mds->mds_lov_objids_dirty); - /* Read everything in the file, even if our current lov desc has fewer targets. Old targets not in the lov descriptor during mds setup may still have valid objids. */ - size = mds->mds_lov_objid_filp->f_dentry->d_inode->i_size; + size = i_size_read(mds->mds_lov_objid_filp->f_dentry->d_inode); if (size == 0) RETURN(0); - OBD_ALLOC(ids, size); - if (ids == NULL) - RETURN(-ENOMEM); - mds->mds_lov_objids = ids; - mds->mds_lov_objids_size = size; + page = (size + MDS_LOV_ALLOC_SIZE - 1) / MDS_LOV_ALLOC_SIZE; + CDEBUG(D_INFO, "file size %lu pages %d\n", size, page); + for (i = 0; i < page; i++) { + obd_id *data; + loff_t off_old = off; - rc = fsfilt_read_record(obd, mds->mds_lov_objid_filp, ids, size, &off); - if (rc < 0) { - CERROR("Error reading objids %d\n", rc); - RETURN(rc); - } + LASSERT(mds->mds_lov_page_array[i] == NULL); + OBD_ALLOC(mds->mds_lov_page_array[i], MDS_LOV_ALLOC_SIZE); + if (mds->mds_lov_page_array[i] == NULL) + GOTO(out, rc = -ENOMEM); + + data = mds->mds_lov_page_array[i]; - mds->mds_lov_objids_in_file = size / sizeof(*ids); + rc = fsfilt_read_record(obd, mds->mds_lov_objid_filp, data, + MDS_LOV_ALLOC_SIZE, &off); + if (rc < 0) { + CERROR("Error reading objids %d\n", rc); + GOTO(out, rc); + } + if (off == off_old) /* hole is read */ + off += MDS_LOV_ALLOC_SIZE; - for (i = 0; i < mds->mds_lov_objids_in_file; i++) { - CDEBUG(D_INFO, "read last object "LPU64" for idx %d\n", - mds->mds_lov_objids[i], i); + count = (off - off_old) / sizeof(obd_id); + if (mds_lov_update_from_read(mds, data, count)) { + CERROR("Can't update mds data\n"); + GOTO(out, rc = -EIO); + } } - RETURN(0); + mds->mds_lov_objid_lastpage = page - 1; + mds->mds_lov_objid_lastidx = count - 1; + + CDEBUG(D_INFO, "Read %u - %u %u objid\n", mds->mds_lov_objid_count, + mds->mds_lov_objid_lastpage, mds->mds_lov_objid_lastidx); +out: + mds_lov_dump_objids("read",obd); + + RETURN(rc); } int mds_lov_write_objids(struct obd_device *obd) { struct mds_obd *mds = &obd->u.mds; - loff_t off = 0; - int i, rc, tgts; + int i = 0, rc = 0; ENTRY; - if (!mds->mds_lov_objids_dirty) + if (cfs_bitmap_check_empty(mds->mds_lov_page_dirty)) RETURN(0); - tgts = max(mds->mds_lov_desc.ld_tgt_count, mds->mds_lov_objids_in_file); + mds_lov_dump_objids("write", obd); - if (!tgts) - RETURN(0); + cfs_foreach_bit(mds->mds_lov_page_dirty, i) { + obd_id *data = mds->mds_lov_page_array[i]; + unsigned int size = MDS_LOV_ALLOC_SIZE; + loff_t off = i * size; - for (i = 0; i < tgts; i++) - CDEBUG(D_INFO, "writing last object "LPU64" for idx %d\n", - mds->mds_lov_objids[i], i); + LASSERT(data != NULL); - rc = fsfilt_write_record(obd, mds->mds_lov_objid_filp, - mds->mds_lov_objids, tgts * sizeof(obd_id), - &off, 0); - if (rc >= 0) { - mds->mds_lov_objids_dirty = 0; - rc = 0; + if (!cfs_bitmap_test_and_clear(mds->mds_lov_page_dirty, i)) + continue; + + /* check for particaly filled last page */ + if (i == mds->mds_lov_objid_lastpage) + size = (mds->mds_lov_objid_lastidx+1) * sizeof(obd_id); + + CDEBUG(D_INFO, "write %lld - %u\n", off, size); + rc = fsfilt_write_record(obd, mds->mds_lov_objid_filp, data, + size, &off, 0); + if (rc < 0) { + cfs_bitmap_set(mds->mds_lov_page_dirty, i); + break; + } } + if (rc >= 0) + rc = 0; + + RETURN(rc); +} +EXPORT_SYMBOL(mds_lov_write_objids); + +static int mds_lov_get_objid(struct obd_device * obd, + obd_id idx) +{ + struct mds_obd *mds = &obd->u.mds; + struct obd_export *lov_exp = mds->mds_lov_exp; + unsigned int page; + unsigned int off; + obd_id *data; + __u32 size; + int rc = 0; + ENTRY; + + page = idx / OBJID_PER_PAGE(); + off = idx % OBJID_PER_PAGE(); + data = mds->mds_lov_page_array[page]; + + if (data[off] < 2) { + /* We never read this lastid; ask the osc */ + struct obd_id_info lastid; + + size = sizeof(lastid); + lastid.idx = idx; + lastid.data = &data[off]; + rc = obd_get_info(lov_exp, sizeof(KEY_LAST_ID), KEY_LAST_ID, + &size, &lastid, NULL); + if (rc) + GOTO(out, rc); + /* workaround for clean filter */ + if (data[off] == 0) + data[off] = 1; + + cfs_bitmap_set(mds->mds_lov_page_dirty, page); + } + CDEBUG(D_INFO, "idx "LPU64" - %p - %d/%d - "LPU64"\n", + idx, data, page, off, data[off]); +out: RETURN(rc); } int mds_lov_clear_orphans(struct mds_obd *mds, struct obd_uuid *ost_uuid) { int rc; - struct obdo oa; + struct obdo oa = { 0 }; struct obd_trans_info oti = {0}; struct lov_stripe_md *empty_ea = NULL; ENTRY; - LASSERT(mds->mds_lov_objids != NULL); + LASSERT(mds->mds_lov_page_array != NULL); /* This create will in fact either create or destroy: If the OST is * missing objects below this ID, they will be created. If it finds * objects above this ID, they will be removed. */ memset(&oa, 0, sizeof(oa)); - oa.o_valid = OBD_MD_FLFLAGS; oa.o_flags = OBD_FL_DELORPHAN; - if (ost_uuid != NULL) { - memcpy(&oa.o_inline, ost_uuid, sizeof(*ost_uuid)); - oa.o_valid |= OBD_MD_FLINLINE; - } - rc = obd_create(mds->mds_osc_exp, &oa, &empty_ea, &oti); + oa.o_seq = mdt_to_obd_objseq(mds->mds_id); + oa.o_valid = OBD_MD_FLFLAGS | OBD_MD_FLGROUP; + if (ost_uuid != NULL) + oti.oti_ost_uuid = ost_uuid; + + rc = obd_create(mds->mds_lov_exp, &oa, &empty_ea, &oti); RETURN(rc); } -/* update the LOV-OSC knowledge of the last used object id's */ -int mds_lov_set_nextid(struct obd_device *obd) +/* for one target */ +static int mds_lov_set_one_nextid(struct obd_device *obd, __u32 idx, obd_id *id) { struct mds_obd *mds = &obd->u.mds; int rc; + struct obd_id_info info; ENTRY; LASSERT(!obd->obd_recovering); - LASSERT(mds->mds_lov_objids != NULL); - - rc = obd_set_info_async(mds->mds_osc_exp, strlen(KEY_NEXT_ID), - KEY_NEXT_ID, - mds->mds_lov_desc.ld_tgt_count * - sizeof(*mds->mds_lov_objids), - mds->mds_lov_objids, NULL); - + info.idx = idx; + info.data = id; + rc = obd_set_info_async(mds->mds_lov_exp, sizeof(KEY_NEXT_ID), + KEY_NEXT_ID, sizeof(info), &info, NULL); if (rc) CERROR ("%s: mds_lov_set_nextid failed (%d)\n", obd->obd_name, rc); @@ -176,11 +573,12 @@ int mds_lov_set_nextid(struct obd_device *obd) } /* Update the lov desc for a new size lov. */ -static int mds_lov_update_desc(struct obd_device *obd, struct obd_export *lov) +static int mds_lov_update_desc(struct obd_device *obd, int idx, + struct obd_uuid *uuid) { struct mds_obd *mds = &obd->u.mds; struct lov_desc *ld; - __u32 size, stripes, valsize = sizeof(mds->mds_lov_desc); + __u32 valsize = sizeof(mds->mds_lov_desc); int rc = 0; ENTRY; @@ -188,118 +586,83 @@ static int mds_lov_update_desc(struct obd_device *obd, struct obd_export *lov) if (!ld) RETURN(-ENOMEM); - rc = obd_get_info(lov, strlen(KEY_LOVDESC) + 1, KEY_LOVDESC, - &valsize, ld); + rc = obd_get_info(mds->mds_lov_exp, sizeof(KEY_LOVDESC), KEY_LOVDESC, + &valsize, ld, NULL); if (rc) GOTO(out, rc); - /* The size of the LOV target table may have increased. */ - size = ld->ld_tgt_count * sizeof(obd_id); - if ((mds->mds_lov_objids_size == 0) || - (size > mds->mds_lov_objids_size)) { - obd_id *ids; - - /* add room by powers of 2 */ - size = 1; - while (size < ld->ld_tgt_count) - size = size << 1; - size = size * sizeof(obd_id); - - OBD_ALLOC(ids, size); - if (ids == NULL) - GOTO(out, rc = -ENOMEM); - memset(ids, 0, size); - if (mds->mds_lov_objids_size) { - obd_id *old_ids = mds->mds_lov_objids; - memcpy(ids, mds->mds_lov_objids, - mds->mds_lov_objids_size); - mds->mds_lov_objids = ids; - OBD_FREE(old_ids, mds->mds_lov_objids_size); - } - mds->mds_lov_objids = ids; - mds->mds_lov_objids_size = size; - } - /* Don't change the mds_lov_desc until the objids size matches the count (paranoia) */ mds->mds_lov_desc = *ld; - CDEBUG(D_CONFIG, "updated lov_desc, tgt_count: %d\n", - mds->mds_lov_desc.ld_tgt_count); + CDEBUG(D_CONFIG, "updated lov_desc, tgt_count: %d - idx %d / uuid %s\n", + mds->mds_lov_desc.ld_tgt_count, idx, uuid->uuid); - stripes = min_t(__u32, LOV_MAX_STRIPE_COUNT, - max(mds->mds_lov_desc.ld_tgt_count, - mds->mds_lov_objids_in_file)); - mds->mds_max_mdsize = lov_mds_md_size(stripes); - mds->mds_max_cookiesize = stripes * sizeof(struct llog_cookie); - CDEBUG(D_CONFIG, "updated max_mdsize/max_cookiesize for %d stripes: " - "%d/%d\n", mds->mds_max_mdsize, mds->mds_max_cookiesize, - stripes); + cfs_mutex_down(&obd->obd_dev_sem); + rc = mds_lov_update_max_ost(mds, idx); + cfs_mutex_up(&obd->obd_dev_sem); + if (rc != 0) + GOTO(out, rc ); + + /* If we added a target we have to reconnect the llogs */ + /* We only _need_ to do this at first add (idx), or the first time + after recovery. However, it should now be safe to call anytime. */ + rc = obd_llog_init(obd, &obd->obd_olg, obd, &idx); + if (rc) + GOTO(out, rc); out: OBD_FREE(ld, sizeof(*ld)); RETURN(rc); } - -#define MDSLOV_NO_INDEX -1 - /* Inform MDS about new/updated target */ static int mds_lov_update_mds(struct obd_device *obd, struct obd_device *watched, - __u32 idx, struct obd_uuid *uuid) + __u32 idx) { struct mds_obd *mds = &obd->u.mds; - int old_count; int rc = 0; + int page; + int off; + obd_id *data; ENTRY; - old_count = mds->mds_lov_desc.ld_tgt_count; - rc = mds_lov_update_desc(obd, mds->mds_osc_exp); - if (rc) - RETURN(rc); + LASSERT(mds_lov_objinit(mds, idx)); - CDEBUG(D_CONFIG, "idx=%d, recov=%d/%d, cnt=%d/%d\n", - idx, obd->obd_recovering, obd->obd_async_recov, old_count, + CDEBUG(D_CONFIG, "idx=%d, recov=%d/%d, cnt=%d\n", + idx, obd->obd_recovering, obd->obd_async_recov, mds->mds_lov_desc.ld_tgt_count); /* idx is set as data from lov_notify. */ - if (idx != MDSLOV_NO_INDEX && !obd->obd_recovering) { - if (idx >= mds->mds_lov_desc.ld_tgt_count) { - CERROR("index %d > count %d!\n", idx, - mds->mds_lov_desc.ld_tgt_count); - RETURN(-EINVAL); - } - - if (idx >= mds->mds_lov_objids_in_file) { - /* We never read this lastid; ask the osc */ - obd_id lastid; - __u32 size = sizeof(lastid); - rc = obd_get_info(watched->obd_self_export, - strlen("last_id"), - "last_id", &size, &lastid); - if (rc) - RETURN(rc); - mds->mds_lov_objids[idx] = lastid; - mds->mds_lov_objids_dirty = 1; - mds_lov_write_objids(obd); - } else { - /* We have read this lastid from disk; tell the osc. - Don't call this during recovery. */ - rc = mds_lov_set_nextid(obd); - } + if (obd->obd_recovering) + GOTO(out, rc); - CDEBUG(D_CONFIG, "last object "LPU64" from OST %d\n", - mds->mds_lov_objids[idx], idx); + if (idx >= mds->mds_lov_desc.ld_tgt_count) { + CERROR("index %d > count %d!\n", idx, + mds->mds_lov_desc.ld_tgt_count); + GOTO(out, rc = -EINVAL); } - /* If we added a target we have to reconnect the llogs */ - /* We only _need_ to do this at first add (idx), or the first time - after recovery. However, it should now be safe to call anytime. */ - CDEBUG(D_CONFIG, "reset llogs idx=%d\n", idx); - mutex_down(&obd->obd_dev_sem); - llog_cat_initialize(obd, mds->mds_lov_desc.ld_tgt_count, uuid); - mutex_up(&obd->obd_dev_sem); + rc = mds_lov_get_objid(obd, idx); + if (rc) + GOTO(out, rc); + + page = idx / OBJID_PER_PAGE(); + off = idx % OBJID_PER_PAGE(); + data = mds->mds_lov_page_array[page]; + /* We have read this lastid from disk; tell the osc. + Don't call this during recovery. */ + rc = mds_lov_set_one_nextid(obd, idx, &data[off]); + if (rc) { + CERROR("Failed to set next id, idx=%d rc=%d\n", idx,rc); + /* Don't abort the rest of the sync */ + rc = 0; + } else { + CDEBUG(D_CONFIG, "last object "LPU64" from OST %d rc=%d\n", + data[off], idx, rc); + } +out: RETURN(rc); } @@ -307,80 +670,71 @@ static int mds_lov_update_mds(struct obd_device *obd, int mds_lov_connect(struct obd_device *obd, char * lov_name) { struct mds_obd *mds = &obd->u.mds; - struct lustre_handle conn = {0,}; struct obd_connect_data *data; - int rc, i; + int rc; ENTRY; - if (IS_ERR(mds->mds_osc_obd)) - RETURN(PTR_ERR(mds->mds_osc_obd)); + if (IS_ERR(mds->mds_lov_obd)) + RETURN(PTR_ERR(mds->mds_lov_obd)); - if (mds->mds_osc_obd) + if (mds->mds_lov_obd) RETURN(0); - mds->mds_osc_obd = class_name2obd(lov_name); - if (!mds->mds_osc_obd) { + mds->mds_lov_obd = class_name2obd(lov_name); + if (!mds->mds_lov_obd) { CERROR("MDS cannot locate LOV %s\n", lov_name); - mds->mds_osc_obd = ERR_PTR(-ENOTCONN); + mds->mds_lov_obd = ERR_PTR(-ENOTCONN); RETURN(-ENOTCONN); } - OBD_ALLOC(data, sizeof(*data)); - if (data == NULL) - RETURN(-ENOMEM); - data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX | - OBD_CONNECT_REQPORTAL | OBD_CONNECT_QUOTA64; - data->ocd_version = LUSTRE_VERSION_CODE; - /* NB: lov_connect() needs to fill in .ocd_index for each OST */ - rc = obd_connect(&conn, mds->mds_osc_obd, &obd->obd_uuid, data); - OBD_FREE(data, sizeof(*data)); + cfs_mutex_down(&obd->obd_dev_sem); + rc = mds_lov_read_objids(obd); + cfs_mutex_up(&obd->obd_dev_sem); if (rc) { - CERROR("MDS cannot connect to LOV %s (%d)\n", lov_name, rc); - mds->mds_osc_obd = ERR_PTR(rc); - RETURN(rc); + CERROR("cannot read %s: rc = %d\n", "lov_objids", rc); + GOTO(err_exit, rc); } - mds->mds_osc_exp = class_conn2export(&conn); - rc = obd_register_observer(mds->mds_osc_obd, obd); + rc = obd_register_observer(mds->mds_lov_obd, obd); if (rc) { CERROR("MDS cannot register as observer of LOV %s (%d)\n", lov_name, rc); - GOTO(err_discon, rc); + GOTO(err_exit, rc); } - rc = mds_lov_read_objids(obd); - if (rc) { - CERROR("cannot read %s: rc = %d\n", "lov_objids", rc); - GOTO(err_reg, rc); - } + /* ask lov to generate OBD_NOTIFY_CREATE events for already registered + * targets */ + obd_notify(mds->mds_lov_obd, NULL, OBD_NOTIFY_CREATE, NULL); - rc = mds_lov_update_desc(obd, mds->mds_osc_exp); - if (rc) - GOTO(err_reg, rc); + mds->mds_lov_obd->u.lov.lov_sp_me = LUSTRE_SP_MDT; - /* tgt_count may be 0! */ - rc = llog_cat_initialize(obd, mds->mds_lov_desc.ld_tgt_count, NULL); + OBD_ALLOC(data, sizeof(*data)); + if (data == NULL) + GOTO(err_exit, rc = -ENOMEM); + + data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX | + OBD_CONNECT_REQPORTAL | OBD_CONNECT_QUOTA64 | + OBD_CONNECT_OSS_CAPA | OBD_CONNECT_FID | + OBD_CONNECT_BRW_SIZE | OBD_CONNECT_CKSUM | + OBD_CONNECT_CHANGE_QS | OBD_CONNECT_AT | + OBD_CONNECT_MDS | OBD_CONNECT_SKIP_ORPHAN | + OBD_CONNECT_SOM | OBD_CONNECT_FULL20; +#ifdef HAVE_LRU_RESIZE_SUPPORT + data->ocd_connect_flags |= OBD_CONNECT_LRU_RESIZE; +#endif + data->ocd_version = LUSTRE_VERSION_CODE; + data->ocd_group = mdt_to_obd_objseq(mds->mds_id); + /* send max bytes per rpc */ + data->ocd_brw_size = PTLRPC_MAX_BRW_PAGES << CFS_PAGE_SHIFT; + /* send the list of supported checksum types */ + data->ocd_cksum_types = OBD_CKSUM_ALL; + /* NB: lov_connect() needs to fill in .ocd_index for each OST */ + rc = obd_connect(NULL, &mds->mds_lov_exp, mds->mds_lov_obd, &obd->obd_uuid, data, NULL); + OBD_FREE(data, sizeof(*data)); if (rc) { - CERROR("failed to initialize catalog %d\n", rc); - GOTO(err_reg, rc); - } - - /* If we're mounting this code for the first time on an existing FS, - * we need to populate the objids array from the real OST values */ - if (mds->mds_lov_desc.ld_tgt_count > mds->mds_lov_objids_in_file) { - int size = sizeof(obd_id) * mds->mds_lov_desc.ld_tgt_count; - rc = obd_get_info(mds->mds_osc_exp, strlen("last_id"), - "last_id", &size, mds->mds_lov_objids); - if (!rc) { - for (i = 0; i < mds->mds_lov_desc.ld_tgt_count; i++) - CWARN("got last object "LPU64" from OST %d\n", - mds->mds_lov_objids[i], i); - mds->mds_lov_objids_dirty = 1; - rc = mds_lov_write_objids(obd); - if (rc) - CERROR("got last objids from OSTs, but error " - "writing objids file: %d\n", rc); - } + CERROR("MDS cannot connect to LOV %s (%d)\n", lov_name, rc); + mds->mds_lov_obd = ERR_PTR(rc); + RETURN(rc); } /* I want to see a callback happen when the OBD moves to a @@ -388,16 +742,15 @@ int mds_lov_connect(struct obd_device *obd, char * lov_name) * set_nextid(). The class driver can help us here, because * it can use the obd_recovering flag to determine when the * the OBD is full available. */ + /* MDD device will care about that if (!obd->obd_recovering) rc = mds_postrecov(obd); + */ RETURN(rc); -err_reg: - obd_register_observer(mds->mds_osc_obd, NULL); -err_discon: - obd_disconnect(mds->mds_osc_exp); - mds->mds_osc_exp = NULL; - mds->mds_osc_obd = ERR_PTR(rc); +err_exit: + mds->mds_lov_exp = NULL; + mds->mds_lov_obd = ERR_PTR(rc); RETURN(rc); } @@ -407,223 +760,56 @@ int mds_lov_disconnect(struct obd_device *obd) int rc = 0; ENTRY; - if (!IS_ERR(mds->mds_osc_obd) && mds->mds_osc_exp != NULL) { - obd_register_observer(mds->mds_osc_obd, NULL); + if (!IS_ERR(mds->mds_lov_obd) && mds->mds_lov_exp != NULL) { + obd_register_observer(mds->mds_lov_obd, NULL); /* The actual disconnect of the mds_lov will be called from * class_disconnect_exports from mds_lov_clean. So we have to * ensure that class_cleanup doesn't fail due to the extra ref * we're holding now. The mechanism to do that already exists - * the obd_force flag. We'll drop the final ref to the - * mds_osc_exp in mds_cleanup. */ - mds->mds_osc_obd->obd_force = 1; + * mds_lov_exp in mds_cleanup. */ + mds->mds_lov_obd->obd_force = 1; } RETURN(rc); } -int mds_iocontrol(unsigned int cmd, struct obd_export *exp, int len, - void *karg, void *uarg) +struct mds_lov_sync_info { + struct obd_device *mlsi_obd; /* the lov device to sync */ + struct obd_device *mlsi_watched; /* target osc */ + __u32 mlsi_index; /* index of target */ +}; + +static int mds_propagate_capa_keys(struct mds_obd *mds, struct obd_uuid *uuid) { - static struct obd_uuid cfg_uuid = { .uuid = "config_uuid" }; - struct obd_device *obd = exp->exp_obd; - struct mds_obd *mds = &obd->u.mds; - struct obd_ioctl_data *data = karg; - struct lvfs_run_ctxt saved; - int rc = 0; + struct mds_capa_info info = { .uuid = uuid }; + struct lustre_capa_key *key; + int i, rc = 0; ENTRY; - CDEBUG(D_IOCTL, "handling ioctl cmd %#x\n", cmd); - - switch (cmd) { - case OBD_IOC_RECORD: { - char *name = data->ioc_inlbuf1; - if (mds->mds_cfg_llh) - RETURN(-EBUSY); - - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - rc = llog_create(llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT), - &mds->mds_cfg_llh, NULL, name); - if (rc == 0) - llog_init_handle(mds->mds_cfg_llh, LLOG_F_IS_PLAIN, - &cfg_uuid); - else - mds->mds_cfg_llh = NULL; - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - - RETURN(rc); - } - - case OBD_IOC_ENDRECORD: { - if (!mds->mds_cfg_llh) - RETURN(-EBADF); - - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - rc = llog_close(mds->mds_cfg_llh); - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - - mds->mds_cfg_llh = NULL; - RETURN(rc); - } - - case OBD_IOC_CLEAR_LOG: { - char *name = data->ioc_inlbuf1; - if (mds->mds_cfg_llh) - RETURN(-EBUSY); - - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - rc = llog_create(llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT), - &mds->mds_cfg_llh, NULL, name); - if (rc == 0) { - llog_init_handle(mds->mds_cfg_llh, LLOG_F_IS_PLAIN, - NULL); - rc = llog_destroy(mds->mds_cfg_llh); - llog_free_handle(mds->mds_cfg_llh); - } - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - - mds->mds_cfg_llh = NULL; - RETURN(rc); - } - - case OBD_IOC_DORECORD: { - char *cfg_buf; - struct llog_rec_hdr rec; - if (!mds->mds_cfg_llh) - RETURN(-EBADF); - - rec.lrh_len = llog_data_len(data->ioc_plen1); + if (!mds->mds_capa_keys) + RETURN(0); - if (data->ioc_type == LUSTRE_CFG_TYPE) { - rec.lrh_type = OBD_CFG_REC; - } else { - CERROR("unknown cfg record type:%d \n", data->ioc_type); - RETURN(-EINVAL); - } + OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_SYNC_CAPA_SL, 5); + for (i = 0; i < 2; i++) { + key = &mds->mds_capa_keys[i]; + DEBUG_CAPA_KEY(D_SEC, key, "propagate"); - OBD_ALLOC(cfg_buf, data->ioc_plen1); - if (cfg_buf == NULL) - RETURN(-EINVAL); - rc = copy_from_user(cfg_buf, data->ioc_pbuf1, data->ioc_plen1); + info.capa = key; + rc = obd_set_info_async(mds->mds_lov_exp, sizeof(KEY_CAPA_KEY), + KEY_CAPA_KEY, sizeof(info), &info, NULL); if (rc) { - OBD_FREE(cfg_buf, data->ioc_plen1); + DEBUG_CAPA_KEY(D_ERROR, key, + "propagate failed (rc = %d) for", rc); RETURN(rc); } - - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - rc = llog_write_rec(mds->mds_cfg_llh, &rec, NULL, 0, - cfg_buf, -1); - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - - OBD_FREE(cfg_buf, data->ioc_plen1); - RETURN(rc); - } - - case OBD_IOC_PARSE: { - struct llog_ctxt *ctxt = - llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - rc = class_config_parse_llog(ctxt, data->ioc_inlbuf1, NULL); - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - if (rc) - RETURN(rc); - - RETURN(rc); - } - - case OBD_IOC_DUMP_LOG: { - struct llog_ctxt *ctxt = - llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - rc = class_config_dump_llog(ctxt, data->ioc_inlbuf1, NULL); - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); - if (rc) - RETURN(rc); - - RETURN(rc); - } - - case OBD_IOC_SYNC: { - CDEBUG(D_HA, "syncing mds %s\n", obd->obd_name); - rc = fsfilt_sync(obd, obd->u.obt.obt_sb); - RETURN(rc); - } - - case OBD_IOC_SET_READONLY: { - void *handle; - struct inode *inode = obd->u.obt.obt_sb->s_root->d_inode; - BDEVNAME_DECLARE_STORAGE(tmp); - CERROR("*** setting device %s read-only ***\n", - ll_bdevname(obd->u.obt.obt_sb, tmp)); - - handle = fsfilt_start(obd, inode, FSFILT_OP_MKNOD, NULL); - if (!IS_ERR(handle)) - rc = fsfilt_commit(obd, inode, handle, 1); - - CDEBUG(D_HA, "syncing mds %s\n", obd->obd_name); - rc = fsfilt_sync(obd, obd->u.obt.obt_sb); - - lvfs_set_rdonly(lvfs_sbdev(obd->u.obt.obt_sb)); - RETURN(0); - } - - case OBD_IOC_CATLOGLIST: { - int count = mds->mds_lov_desc.ld_tgt_count; - rc = llog_catalog_list(obd, count, data); - RETURN(rc); - } - case OBD_IOC_LLOG_CHECK: - case OBD_IOC_LLOG_CANCEL: - case OBD_IOC_LLOG_REMOVE: { - struct llog_ctxt *ctxt = - llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); - int rc2; - - obd_llog_finish(obd, mds->mds_lov_desc.ld_tgt_count); - push_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL); - rc = llog_ioctl(ctxt, cmd, data); - pop_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL); - llog_cat_initialize(obd, mds->mds_lov_desc.ld_tgt_count, NULL); - rc2 = obd_set_info_async(mds->mds_osc_exp, - strlen(KEY_MDS_CONN), KEY_MDS_CONN, - 0, NULL, NULL); - if (!rc) - rc = rc2; - RETURN(rc); - } - case OBD_IOC_LLOG_INFO: - case OBD_IOC_LLOG_PRINT: { - struct llog_ctxt *ctxt = - llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); - - push_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL); - rc = llog_ioctl(ctxt, cmd, data); - pop_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL); - RETURN(rc); - } - - case OBD_IOC_ABORT_RECOVERY: - CERROR("aborting recovery for device %s\n", obd->obd_name); - target_abort_recovery(obd); - RETURN(0); - - default: - CDEBUG(D_INFO, "unknown command %x\n", cmd); - RETURN(-EINVAL); - } RETURN(0); - } -struct mds_lov_sync_info { - struct obd_device *mlsi_obd; /* the lov device to sync */ - struct obd_device *mlsi_watched; /* target osc */ - __u32 mlsi_index; /* index of target */ -}; - /* We only sync one osc at a time, so that we don't have to hold any kind of lock on the whole mds_lov_desc, which may change (grow) as a result of mds_lov_add_ost. This also avoids any @@ -637,51 +823,88 @@ static int __mds_lov_synchronize(void *data) struct mds_obd *mds = &obd->u.mds; struct obd_uuid *uuid; __u32 idx = mlsi->mlsi_index; + struct mds_group_info mgi; + struct llog_ctxt *ctxt; int rc = 0; ENTRY; - OBD_FREE(mlsi, sizeof(*mlsi)); + OBD_FREE_PTR(mlsi); LASSERT(obd); LASSERT(watched); uuid = &watched->u.cli.cl_target_uuid; LASSERT(uuid); - rc = mds_lov_update_mds(obd, watched, idx, uuid); - if (rc != 0) + cfs_down_read(&mds->mds_notify_lock); + if (obd->obd_stopping || obd->obd_fail) + GOTO(out, rc = -ENODEV); + + OBD_RACE(OBD_FAIL_MDS_LOV_SYNC_RACE); + rc = mds_lov_update_mds(obd, watched, idx); + if (rc != 0) { + CERROR("%s failed at update_mds: %d\n", obd_uuid2str(uuid), rc); GOTO(out, rc); + } + mgi.group = mdt_to_obd_objseq(mds->mds_id); + mgi.uuid = uuid; - rc = obd_set_info_async(mds->mds_osc_exp, strlen(KEY_MDS_CONN), - KEY_MDS_CONN, 0, uuid, NULL); + rc = obd_set_info_async(mds->mds_lov_exp, sizeof(KEY_MDS_CONN), + KEY_MDS_CONN, sizeof(mgi), &mgi, NULL); if (rc != 0) GOTO(out, rc); + /* propagate capability keys */ + rc = mds_propagate_capa_keys(mds, uuid); + if (rc) + GOTO(out, rc); - rc = llog_connect(llog_get_context(obd, LLOG_MDS_OST_ORIG_CTXT), - mds->mds_lov_desc.ld_tgt_count, - NULL, NULL, uuid); + ctxt = llog_get_context(obd, LLOG_MDS_OST_ORIG_CTXT); + if (!ctxt) + GOTO(out, rc = -ENODEV); + OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_LLOG_SYNC_TIMEOUT, 60); + rc = llog_connect(ctxt, NULL, NULL, uuid); + llog_ctxt_put(ctxt); if (rc != 0) { - CERROR("%s: failed at llog_origin_connect: %d\n", - obd->obd_name, rc); + CERROR("%s failed at llog_origin_connect: %d\n", + obd_uuid2str(uuid), rc); GOTO(out, rc); } LCONSOLE_INFO("MDS %s: %s now active, resetting orphans\n", obd->obd_name, obd_uuid2str(uuid)); - if (obd->obd_stopping) - GOTO(out, rc = -ENODEV); - rc = mds_lov_clear_orphans(mds, uuid); if (rc != 0) { - CERROR("%s: failed at mds_lov_clear_orphans: %d\n", - obd->obd_name, rc); + CERROR("%s failed at mds_lov_clear_orphans: %d\n", + obd_uuid2str(uuid), rc); GOTO(out, rc); } +#ifdef HAVE_QUOTA_SUPPORT + if (obd->obd_upcall.onu_owner) { + /* + * This is a hack for mds_notify->mdd_notify. When the mds obd + * in mdd is removed, This hack should be removed. + */ + LASSERT(obd->obd_upcall.onu_upcall != NULL); + rc = obd->obd_upcall.onu_upcall(obd, NULL, OBD_NOTIFY_QUOTA, + obd->obd_upcall.onu_owner,NULL); + } +#endif EXIT; out: - class_decref(obd); + cfs_up_read(&mds->mds_notify_lock); + if (rc) { + /* Deactivate it for safety */ + CERROR("%s sync failed %d, deactivating\n", obd_uuid2str(uuid), + rc); + if (!obd->obd_stopping && mds->mds_lov_obd && + !mds->mds_lov_obd->obd_stopping && !watched->obd_stopping) + obd_notify(mds->mds_lov_obd, watched, + OBD_NOTIFY_INACTIVE, NULL); + } + + class_decref(obd, "mds_lov_synchronize", obd); return rc; } @@ -690,38 +913,32 @@ int mds_lov_synchronize(void *data) struct mds_lov_sync_info *mlsi = data; char name[20]; - if (mlsi->mlsi_index == MDSLOV_NO_INDEX) - /* There is still a watched target, - but we don't know its index */ - sprintf(name, "ll_sync_tgt"); - else - snprintf(name, sizeof(name), "ll_sync_%02u", mlsi->mlsi_index); - ptlrpc_daemonize(name); + snprintf(name, sizeof(name), "ll_sync_%02u", mlsi->mlsi_index); + cfs_daemonize_ctxt(name); RETURN(__mds_lov_synchronize(data)); } int mds_lov_start_synchronize(struct obd_device *obd, struct obd_device *watched, - void *data, int nonblock) + void *data, enum obd_notify_event ev) { struct mds_lov_sync_info *mlsi; int rc; - + struct obd_uuid *uuid; ENTRY; LASSERT(watched); + uuid = &watched->u.cli.cl_target_uuid; OBD_ALLOC(mlsi, sizeof(*mlsi)); if (mlsi == NULL) RETURN(-ENOMEM); + LASSERT(data); mlsi->mlsi_obd = obd; mlsi->mlsi_watched = watched; - if (data) - mlsi->mlsi_index = *(__u32 *)data; - else - mlsi->mlsi_index = MDSLOV_NO_INDEX; + mlsi->mlsi_index = *(__u32 *)data; /* Although class_export_get(obd->obd_self_export) would lock the MDS in place, since it's only a self-export @@ -731,16 +948,16 @@ int mds_lov_start_synchronize(struct obd_device *obd, still disconnected. Taking an obd reference insures that we don't disconnect the LOV. This of course means a cleanup won't finish for as long as the sync is blocking. */ - class_incref(obd); + class_incref(obd, "mds_lov_synchronize", obd); - if (nonblock) { + if (ev != OBD_NOTIFY_SYNC) { /* Synchronize in the background */ rc = cfs_kernel_thread(mds_lov_synchronize, mlsi, CLONE_VM | CLONE_FILES); if (rc < 0) { CERROR("%s: error starting mds_lov_synchronize: %d\n", obd->obd_name, rc); - class_decref(obd); + class_decref(obd, "mds_lov_synchronize", obd); } else { CDEBUG(D_HA, "%s: mds_lov_synchronize idx=%d " "thread=%d\n", obd->obd_name, @@ -757,27 +974,49 @@ int mds_lov_start_synchronize(struct obd_device *obd, int mds_notify(struct obd_device *obd, struct obd_device *watched, enum obd_notify_event ev, void *data) { + struct mds_obd *mds = &obd->u.mds; int rc = 0; ENTRY; + CDEBUG(D_CONFIG, "notify %s ev=%d\n", watched->obd_name, ev); + + if (strcmp(watched->obd_type->typ_name, LUSTRE_OSC_NAME) != 0) { + CERROR("unexpected notification of %s %s!\n", + watched->obd_type->typ_name, watched->obd_name); + RETURN(-EINVAL); + } + + /*XXX this notifies the MDD until lov handling use old mds code + * must non block! + */ + if (obd->obd_upcall.onu_owner) { + LASSERT(obd->obd_upcall.onu_upcall != NULL); + rc = obd->obd_upcall.onu_upcall(obd, NULL, ev, + obd->obd_upcall.onu_owner, + &mds->mds_obt.obt_mount_count); + } + switch (ev) { /* We only handle these: */ + case OBD_NOTIFY_CREATE: + CWARN("MDS %s: add target %s\n",obd->obd_name, + obd_uuid2str(&watched->u.cli.cl_target_uuid)); + /* We still have to fix the lov descriptor for ost's */ + LASSERT(data); + rc = mds_lov_update_desc(obd, *(__u32 *)data, + &watched->u.cli.cl_target_uuid); + RETURN(rc); case OBD_NOTIFY_ACTIVE: + /* lov want one or more _active_ targets for work */ + /* activate event should be pass lov idx as argument */ case OBD_NOTIFY_SYNC: case OBD_NOTIFY_SYNC_NONBLOCK: + /* sync event should be pass lov idx as argument */ break; default: RETURN(0); } - CDEBUG(D_CONFIG, "notify %s ev=%d\n", watched->obd_name, ev); - - if (strcmp(watched->obd_type->typ_name, LUSTRE_OSC_NAME) != 0) { - CERROR("unexpected notification of %s %s!\n", - watched->obd_type->typ_name, watched->obd_name); - RETURN(-EINVAL); - } - if (obd->obd_recovering) { CWARN("MDS %s: in recovery, not resetting orphans on %s\n", obd->obd_name, @@ -785,81 +1024,10 @@ int mds_notify(struct obd_device *obd, struct obd_device *watched, /* We still have to fix the lov descriptor for ost's added after the mdt in the config log. They didn't make it into mds_lov_connect. */ - rc = mds_lov_update_desc(obd, obd->u.mds.mds_osc_exp); - RETURN(rc); + rc = mds_lov_update_desc(obd, *(__u32 *)data, + &watched->u.cli.cl_target_uuid); + } else { + rc = mds_lov_start_synchronize(obd, watched, data, ev); } - - LASSERT(llog_get_context(obd, LLOG_MDS_OST_ORIG_CTXT) != NULL); - rc = mds_lov_start_synchronize(obd, watched, data, - !(ev == OBD_NOTIFY_SYNC)); - - lquota_recovery(mds_quota_interface_ref, obd); - RETURN(rc); } - -/* Convert the on-disk LOV EA structre. - * We always try to convert from an old LOV EA format to the common in-memory - * (lsm) format (obd_unpackmd() understands the old on-disk (lmm) format) and - * then convert back to the new on-disk format and save it back to disk - * (obd_packmd() only ever saves to the new on-disk format) so we don't have - * to convert it each time this inode is accessed. - * - * This function is a bit interesting in the error handling. We can safely - * ship the old lmm to the client in case of failure, since it uses the same - * obd_unpackmd() code and can do the conversion if the MDS fails for some - * reason. We will not delete the old lmm data until we have written the - * new format lmm data in fsfilt_set_md(). */ -int mds_convert_lov_ea(struct obd_device *obd, struct inode *inode, - struct lov_mds_md *lmm, int lmm_size) -{ - struct lov_stripe_md *lsm = NULL; - void *handle; - int rc, err; - ENTRY; - - if (le32_to_cpu(lmm->lmm_magic) == LOV_MAGIC || - le32_to_cpu(lmm->lmm_magic == LOV_MAGIC_JOIN)) - RETURN(0); - - CDEBUG(D_INODE, "converting LOV EA on %lu/%u from %#08x to %#08x\n", - inode->i_ino, inode->i_generation, le32_to_cpu(lmm->lmm_magic), - LOV_MAGIC); - - rc = obd_unpackmd(obd->u.mds.mds_osc_exp, &lsm, lmm, lmm_size); - if (rc < 0) - GOTO(conv_end, rc); - - rc = obd_packmd(obd->u.mds.mds_osc_exp, &lmm, lsm); - if (rc < 0) - GOTO(conv_free, rc); - lmm_size = rc; - - handle = fsfilt_start(obd, inode, FSFILT_OP_SETATTR, NULL); - if (IS_ERR(handle)) { - rc = PTR_ERR(handle); - GOTO(conv_free, rc); - } - - rc = fsfilt_set_md(obd, inode, handle, lmm, lmm_size, "lov"); - - err = fsfilt_commit(obd, inode, handle, 0); - if (!rc) - rc = err ? err : lmm_size; - GOTO(conv_free, rc); -conv_free: - obd_free_memmd(obd->u.mds.mds_osc_exp, &lsm); -conv_end: - return rc; -} - -void mds_objids_from_lmm(obd_id *ids, struct lov_mds_md *lmm, - struct lov_desc *desc) -{ - int i; - for (i = 0; i < le32_to_cpu(lmm->lmm_stripe_count); i++) { - ids[le32_to_cpu(lmm->lmm_objects[i].l_ost_idx)] = - le64_to_cpu(lmm->lmm_objects[i].l_object_id); - } -} -