X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flustre_peer.c;h=c5102502d632fdb58d27da9452d33565d5121939;hb=6299d78713ef2b6f69f6dd046256aa91a85147a8;hp=fdeef9667a6de299558e5342d74cf7ca371e5c50;hpb=c1f6b32958c799412c830f35f8d16ed7275407ea;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/lustre_peer.c b/lustre/obdclass/lustre_peer.c index fdeef96..c510250 100644 --- a/lustre/obdclass/lustre_peer.c +++ b/lustre/obdclass/lustre_peer.c @@ -1,33 +1,41 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: +/* + * GPL HEADER START * - * Copyright (c) 2002, 2003 Cluster File Systems, Inc. + * 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) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. + * + * Copyright (c) 2011, 2012, Intel Corporation. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. */ #define DEBUG_SUBSYSTEM S_RPC -#ifndef __KERNEL__ -# include -#endif #include #include #include @@ -36,21 +44,23 @@ #include #include +#define NIDS_MAX 32 + struct uuid_nid_data { - struct list_head un_list; - lnet_nid_t un_nid; - char *un_uuid; - int un_count; /* nid/uuid pair refcount */ + struct list_head un_list; + struct obd_uuid un_uuid; + int un_nid_count; + lnet_nid_t un_nids[NIDS_MAX]; }; /* FIXME: This should probably become more elegant than a global linked list */ -static struct list_head g_uuid_list; -static spinlock_t g_uuid_lock; +static struct list_head g_uuid_list; +static spinlock_t g_uuid_lock; void class_init_uuidlist(void) { - CFS_INIT_LIST_HEAD(&g_uuid_list); - spin_lock_init(&g_uuid_lock); + INIT_LIST_HEAD(&g_uuid_list); + spin_lock_init(&g_uuid_lock); } void class_exit_uuidlist(void) @@ -61,72 +71,71 @@ void class_exit_uuidlist(void) int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index) { - struct list_head *tmp; - - spin_lock (&g_uuid_lock); - - list_for_each(tmp, &g_uuid_list) { - struct uuid_nid_data *data = - list_entry(tmp, struct uuid_nid_data, un_list); - - if (!strcmp(data->un_uuid, uuid) && - index-- == 0) { - *peer_nid = data->un_nid; - - spin_unlock (&g_uuid_lock); - return 0; - } - } - - spin_unlock (&g_uuid_lock); - return -ENOENT; + struct uuid_nid_data *data; + struct obd_uuid tmp; + int rc = -ENOENT; + + obd_str2uuid(&tmp, uuid); + spin_lock(&g_uuid_lock); + list_for_each_entry(data, &g_uuid_list, un_list) { + if (obd_uuid_equals(&data->un_uuid, &tmp)) { + if (index >= data->un_nid_count) + break; + + rc = 0; + *peer_nid = data->un_nids[index]; + break; + } + } + spin_unlock(&g_uuid_lock); + return rc; } +EXPORT_SYMBOL(lustre_uuid_to_peer); /* Add a nid to a niduuid. Multiple nids can be added to a single uuid; LNET will choose the best one. */ int class_add_uuid(const char *uuid, __u64 nid) { struct uuid_nid_data *data, *entry; - int nob = strnlen (uuid, CFS_PAGE_SIZE) + 1; int found = 0; LASSERT(nid != 0); /* valid newconfig NID is never zero */ - if (nob > CFS_PAGE_SIZE) - return -EINVAL; + if (strlen(uuid) > UUID_MAX - 1) + return -EOVERFLOW; - OBD_ALLOC(data, sizeof(*data)); + OBD_ALLOC_PTR(data); if (data == NULL) return -ENOMEM; - OBD_ALLOC(data->un_uuid, nob); - if (data == NULL) { - OBD_FREE(data, sizeof(*data)); - return -ENOMEM; - } - - memcpy(data->un_uuid, uuid, nob); - data->un_nid = nid; - data->un_count = 1; + obd_str2uuid(&data->un_uuid, uuid); + data->un_nids[0] = nid; + data->un_nid_count = 1; - spin_lock (&g_uuid_lock); + spin_lock(&g_uuid_lock); + list_for_each_entry(entry, &g_uuid_list, un_list) { + if (obd_uuid_equals(&entry->un_uuid, &data->un_uuid)) { + int i; - list_for_each_entry(entry, &g_uuid_list, un_list) { - if (entry->un_nid == nid && - (strcmp(entry->un_uuid, uuid) == 0)) { - found++; - entry->un_count++; + found = 1; + for (i = 0; i < entry->un_nid_count; i++) + if (nid == entry->un_nids[i]) + break; + + if (i == entry->un_nid_count) { + LASSERT(entry->un_nid_count < NIDS_MAX); + entry->un_nids[entry->un_nid_count++] = nid; + } break; } } - if (!found) - list_add(&data->un_list, &g_uuid_list); - spin_unlock (&g_uuid_lock); + if (!found) + list_add(&data->un_list, &g_uuid_list); + spin_unlock(&g_uuid_lock); if (found) { - CDEBUG(D_INFO, "found uuid %s %s cnt=%d\n", uuid, - libcfs_nid2str(nid), entry->un_count); - OBD_FREE(data->un_uuid, nob); + CDEBUG(D_INFO, "found uuid %s %s cnt=%d\n", uuid, + libcfs_nid2str(nid), entry->un_nid_count); OBD_FREE(data, sizeof(*data)); } else { CDEBUG(D_INFO, "add uuid %s %s\n", uuid, libcfs_nid2str(nid)); @@ -137,44 +146,73 @@ int class_add_uuid(const char *uuid, __u64 nid) /* Delete the nids for one uuid if specified, otherwise delete all */ int class_del_uuid(const char *uuid) { - CFS_LIST_HEAD(deathrow); - struct uuid_nid_data *data; - int found = 0; + struct uuid_nid_data *data; + struct list_head deathrow; + + INIT_LIST_HEAD(&deathrow); + + spin_lock(&g_uuid_lock); + if (uuid != NULL) { + struct obd_uuid tmp; + + obd_str2uuid(&tmp, uuid); + list_for_each_entry(data, &g_uuid_list, un_list) { + if (obd_uuid_equals(&data->un_uuid, &tmp)) { + list_move(&data->un_list, &deathrow); + break; + } + } + } else + list_splice_init(&g_uuid_list, &deathrow); + spin_unlock(&g_uuid_lock); + + if (uuid != NULL && list_empty(&deathrow)) { + CDEBUG(D_INFO, "Try to delete a non-existent uuid %s\n", uuid); + return -EINVAL; + } + + while (!list_empty(&deathrow)) { + data = list_entry(deathrow.next, struct uuid_nid_data, + un_list); + list_del(&data->un_list); + + CDEBUG(D_INFO, "del uuid %s %s/%d\n", + obd_uuid2str(&data->un_uuid), + libcfs_nid2str(data->un_nids[0]), + data->un_nid_count); + + OBD_FREE(data, sizeof(*data)); + } + return 0; +} - spin_lock (&g_uuid_lock); - if (uuid == NULL) { - list_splice_init(&g_uuid_list, &deathrow); - found = 1; - } else { - list_for_each_entry(data, &g_uuid_list, un_list) { - if (strcmp(data->un_uuid, uuid)) - continue; - --data->un_count; - LASSERT(data->un_count >= 0); - if (data->un_count == 0) - list_move(&data->un_list, &deathrow); - found = 1; - break; - } - } - spin_unlock (&g_uuid_lock); +/* check if @nid exists in nid list of @uuid */ +int class_check_uuid(struct obd_uuid *uuid, __u64 nid) +{ + struct uuid_nid_data *entry; + int found = 0; + ENTRY; - if (!found) { - if (uuid) - CERROR("Try to delete a non-existent uuid %s\n", uuid); - return -EINVAL; - } + CDEBUG(D_INFO, "check if uuid %s has %s.\n", + obd_uuid2str(uuid), libcfs_nid2str(nid)); - while (!list_empty(&deathrow)) { - data = list_entry(deathrow.next, struct uuid_nid_data, un_list); - list_del(&data->un_list); + spin_lock(&g_uuid_lock); + list_for_each_entry(entry, &g_uuid_list, un_list) { + int i; - CDEBUG(D_INFO, "del uuid %s %s\n", data->un_uuid, - libcfs_nid2str(data->un_nid)); + if (!obd_uuid_equals(&entry->un_uuid, uuid)) + continue; - OBD_FREE(data->un_uuid, strlen(data->un_uuid) + 1); - OBD_FREE(data, sizeof(*data)); + /* found the uuid, check if it has @nid */ + for (i = 0; i < entry->un_nid_count; i++) { + if (entry->un_nids[i] == nid) { + found = 1; + break; + } + } + break; } - - return 0; + spin_unlock(&g_uuid_lock); + RETURN(found); } +EXPORT_SYMBOL(class_check_uuid);