X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flustre_peer.c;h=16b50f9377a207c20aeb46877b9feb1a3c295ca5;hp=016354c7d9a5642d137097d6533cbcfd6a695630;hb=16321de596f6395153be6cbb6192250516963077;hpb=040033cef24c5aca2967daf2da7a862abcd074cf diff --git a/lustre/obdclass/lustre_peer.c b/lustre/obdclass/lustre_peer.c index 016354c..16b50f9 100644 --- a/lustre/obdclass/lustre_peer.c +++ b/lustre/obdclass/lustre_peer.c @@ -1,179 +1,247 @@ -/* -*- 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 Lustre, http://www.lustre.org. + * 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. * - * 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. + * 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). * - * 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 + * version 2 along with this program; If not, see + * http://www.gnu.org/licenses/gpl-2.0.html * - * 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. + * GPL HEADER END + */ +/* + * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. * + * Copyright (c) 2011, 2017, Intel Corporation. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ */ #define DEBUG_SUBSYSTEM S_RPC -#ifdef __KERNEL__ -# include -# include -# include -#else -# include -#endif -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include struct uuid_nid_data { - struct list_head head; - ptl_nid_t nid; - char *uuid; - __u32 nal; - ptl_handle_ni_t ni; + struct list_head un_list; + struct obd_uuid un_uuid; + int un_nid_count; + lnet_nid_t un_nids[MTI_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 LIST_HEAD(g_uuid_list); +static DEFINE_SPINLOCK(g_uuid_lock); -void class_init_uuidlist(void) +int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index) { - INIT_LIST_HEAD(&g_uuid_list); - spin_lock_init(&g_uuid_lock); + 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); -void class_exit_uuidlist(void) +/* 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 list_head *tmp, *n; - - /* Module going => sole user => don't need to lock g_uuid_list */ - list_for_each_safe(tmp, n, &g_uuid_list) { - struct uuid_nid_data *data = - list_entry(tmp, struct uuid_nid_data, head); - - PORTAL_FREE(data->uuid, strlen(data->uuid) + 1); - PORTAL_FREE(data, sizeof(*data)); - } + struct uuid_nid_data *data, *entry; + int found = 0; + int rc; + + LASSERT(nid != 0); /* valid newconfig NID is never zero */ + + if (strlen(uuid) > UUID_MAX - 1) + return -EOVERFLOW; + + OBD_ALLOC_PTR(data); + if (data == NULL) + return -ENOMEM; + + obd_str2uuid(&data->un_uuid, uuid); + data->un_nids[0] = nid; + data->un_nid_count = 1; + + 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; + + 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 < MTI_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) { + CDEBUG(D_INFO, "found uuid %s %s cnt=%d\n", uuid, + libcfs_nid2str(nid), entry->un_nid_count); + rc = LNetAddPeer(entry->un_nids, entry->un_nid_count); + CDEBUG(D_INFO, "Add peer %s rc = %d\n", + libcfs_nid2str(data->un_nids[0]), rc); + OBD_FREE(data, sizeof(*data)); + } else { + CDEBUG(D_INFO, "add uuid %s %s\n", uuid, libcfs_nid2str(nid)); + rc = LNetAddPeer(data->un_nids, data->un_nid_count); + CDEBUG(D_INFO, "Add peer %s rc = %d\n", + libcfs_nid2str(data->un_nids[0]), rc); + } + + return 0; } +EXPORT_SYMBOL(class_add_uuid); -int lustre_uuid_to_peer(char *uuid, struct lustre_peer *peer) +/* Delete the nids for one uuid if specified, otherwise delete all */ +int class_del_uuid(const char *uuid) { - 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, head); - - if (strcmp(data->uuid, uuid) == 0) { - peer->peer_nid = data->nid; - peer->peer_ni = data->ni; - - spin_unlock (&g_uuid_lock); - return 0; - } - } - - spin_unlock (&g_uuid_lock); - return -1; + struct uuid_nid_data *data; + 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 ((data = list_first_entry_or_null(&deathrow, struct uuid_nid_data, + un_list)) != NULL) { + 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; } -int class_add_uuid(char *uuid, __u64 nid, __u32 nal) +int class_add_nids_to_uuid(struct obd_uuid *uuid, lnet_nid_t *nids, + int nid_count) { - const ptl_handle_ni_t *nip; - struct uuid_nid_data *data; - int rc; - int nob = strnlen (uuid, PAGE_SIZE) + 1; - - if (nob > PAGE_SIZE) - return -EINVAL; - - nip = kportal_get_ni (nal); - if (nip == NULL) { - CERROR("get_ni failed: is the NAL module loaded?\n"); - return -EIO; - } - - rc = -ENOMEM; - PORTAL_ALLOC(data, sizeof(*data)); - if (data == NULL) - goto fail_0; - - PORTAL_ALLOC(data->uuid, nob); - if (data == NULL) - goto fail_1; - - memcpy(data->uuid, uuid, nob); - data->nid = nid; - data->nal = nal; - data->ni = *nip; - - spin_lock (&g_uuid_lock); - - list_add(&data->head, &g_uuid_list); - - spin_unlock (&g_uuid_lock); - - return 0; - - fail_1: - PORTAL_FREE (data, sizeof (*data)); - fail_0: - kportal_put_ni (nal); - return (rc); + struct uuid_nid_data *entry; + int i, rc; + bool matched = false; + + ENTRY; + + if (nid_count >= MTI_NIDS_MAX) { + CDEBUG(D_NET, "too many NIDs (%d) for UUID '%s'\n", + nid_count, obd_uuid2str(uuid)); + return -ENOSPC; + } + + spin_lock(&g_uuid_lock); + list_for_each_entry(entry, &g_uuid_list, un_list) { + CDEBUG(D_NET, "Comparing %s with %s\n", + obd_uuid2str(uuid), obd_uuid2str(&entry->un_uuid)); + + if (!obd_uuid_equals(&entry->un_uuid, uuid)) + continue; + + matched = true; + CDEBUG(D_NET, "Updating UUID '%s'\n", obd_uuid2str(uuid)); + for (i = 0; i < nid_count; i++) + entry->un_nids[i] = nids[i]; + entry->un_nid_count = nid_count; + break; + } + spin_unlock(&g_uuid_lock); + if (matched) { + rc = LNetAddPeer(entry->un_nids, entry->un_nid_count); + CDEBUG(D_INFO, "Add peer %s rc = %d\n", + libcfs_nid2str(entry->un_nids[0]), rc); + } + + RETURN(0); } +EXPORT_SYMBOL(class_add_nids_to_uuid); -/* delete only one entry if uuid is specified, otherwise delete all */ -int class_del_uuid (char *uuid) +/* check if @nid exists in nid list of @uuid */ +int class_check_uuid(struct obd_uuid *uuid, __u64 nid) { - struct list_head deathrow; - struct list_head *tmp; - struct list_head *n; - struct uuid_nid_data *data; - - INIT_LIST_HEAD (&deathrow); - - spin_lock (&g_uuid_lock); - - list_for_each_safe(tmp, n, &g_uuid_list) { - data = list_entry(tmp, struct uuid_nid_data, head); - - if (uuid == NULL || strcmp(data->uuid, uuid) == 0) { - list_del (&data->head); - list_add (&data->head, &deathrow); - if (uuid) - break; - } - } - - spin_unlock (&g_uuid_lock); - - if (list_empty (&deathrow)) - return -EINVAL; - - do { - data = list_entry(deathrow.next, struct uuid_nid_data, head); - - list_del (&data->head); - - kportal_put_ni (data->nal); - PORTAL_FREE(data->uuid, strlen(data->uuid) + 1); - PORTAL_FREE(data, sizeof(*data)); - } while (!list_empty (&deathrow)); - - return 0; + struct uuid_nid_data *entry; + int found = 0; + + ENTRY; + + CDEBUG(D_INFO, "check if uuid %s has %s.\n", + obd_uuid2str(uuid), libcfs_nid2str(nid)); + + spin_lock(&g_uuid_lock); + list_for_each_entry(entry, &g_uuid_list, un_list) { + int i; + + if (!obd_uuid_equals(&entry->un_uuid, uuid)) + continue; + + /* 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; + } + spin_unlock(&g_uuid_lock); + RETURN(found); } +EXPORT_SYMBOL(class_check_uuid);