lustre/obdclass/lustre_peer.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #define DEBUG_SUBSYSTEM S_RPC
  38
  39 #ifndef __KERNEL__
  40 # include <liblustre.h>
  41 #endif
  42 #include <obd.h>
  43 #include <obd_support.h>
  44 #include <obd_class.h>
  45 #include <lustre_lib.h>
  46 #include <lustre_ha.h>
  47 #include <lustre_net.h>
  48 #include <lprocfs_status.h>
  49
  50 struct uuid_nid_data {
  51         cfs_list_t       un_list;
  52         lnet_nid_t       un_nid;
  53         char            *un_uuid;
  54         int              un_count;  /* nid/uuid pair refcount */
  55 };
  56
  57 /* FIXME: This should probably become more elegant than a global linked list */
  58 static cfs_list_t           g_uuid_list;
  59 static cfs_spinlock_t       g_uuid_lock;
  60
  61 void class_init_uuidlist(void)
  62 {
  63         CFS_INIT_LIST_HEAD(&g_uuid_list);
  64         cfs_spin_lock_init(&g_uuid_lock);
  65 }
  66
  67 void class_exit_uuidlist(void)
  68 {
  69         /* delete all */
  70         class_del_uuid(NULL);
  71 }
  72
  73 int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index)
  74 {
  75         cfs_list_t *tmp;
  76
  77         cfs_spin_lock (&g_uuid_lock);
  78
  79         cfs_list_for_each(tmp, &g_uuid_list) {
  80                 struct uuid_nid_data *data =
  81                         cfs_list_entry(tmp, struct uuid_nid_data, un_list);
  82
  83                 if (!strcmp(data->un_uuid, uuid) &&
  84                     index-- == 0) {
  85                         *peer_nid = data->un_nid;
  86
  87                         cfs_spin_unlock (&g_uuid_lock);
  88                         return 0;
  89                 }
  90         }
  91
  92         cfs_spin_unlock (&g_uuid_lock);
  93         return -ENOENT;
  94 }
  95
  96 /* Add a nid to a niduuid.  Multiple nids can be added to a single uuid;
  97    LNET will choose the best one. */
  98 int class_add_uuid(const char *uuid, __u64 nid)
  99 {
 100         struct uuid_nid_data *data, *entry;
 101         int nob = strnlen (uuid, CFS_PAGE_SIZE) + 1;
 102         int found = 0;
 103
 104         LASSERT(nid != 0);  /* valid newconfig NID is never zero */
 105
 106         if (nob > CFS_PAGE_SIZE)
 107                 return -EINVAL;
 108
 109         OBD_ALLOC(data, sizeof(*data));
 110         if (data == NULL)
 111                 return -ENOMEM;
 112
 113         OBD_ALLOC(data->un_uuid, nob);
 114         if (data == NULL) {
 115                 OBD_FREE(data, sizeof(*data));
 116                 return -ENOMEM;
 117         }
 118
 119         memcpy(data->un_uuid, uuid, nob);
 120         data->un_nid = nid;
 121         data->un_count = 1;
 122
 123         cfs_spin_lock (&g_uuid_lock);
 124
 125         cfs_list_for_each_entry(entry, &g_uuid_list, un_list) {
 126                 if (entry->un_nid == nid &&
 127                     (strcmp(entry->un_uuid, uuid) == 0)) {
 128                         found++;
 129                         entry->un_count++;
 130                         break;
 131                 }
 132         }
 133         if (!found)
 134                 cfs_list_add(&data->un_list, &g_uuid_list);
 135         cfs_spin_unlock (&g_uuid_lock);
 136
 137         if (found) {
 138                 CDEBUG(D_INFO, "found uuid %s %s cnt=%d\n", uuid,
 139                        libcfs_nid2str(nid), entry->un_count);
 140                 OBD_FREE(data->un_uuid, nob);
 141                 OBD_FREE(data, sizeof(*data));
 142         } else {
 143                 CDEBUG(D_INFO, "add uuid %s %s\n", uuid, libcfs_nid2str(nid));
 144         }
 145         return 0;
 146 }
 147
 148 /* Delete the nids for one uuid if specified, otherwise delete all */
 149 int class_del_uuid(const char *uuid)
 150 {
 151         CFS_LIST_HEAD(deathrow);
 152         struct uuid_nid_data *data;
 153         int found = 0;
 154
 155         cfs_spin_lock (&g_uuid_lock);
 156         if (uuid == NULL) {
 157                 cfs_list_splice_init(&g_uuid_list, &deathrow);
 158                 found = 1;
 159         } else {
 160                 cfs_list_for_each_entry(data, &g_uuid_list, un_list) {
 161                         if (strcmp(data->un_uuid, uuid))
 162                                 continue;
 163                         --data->un_count;
 164                         LASSERT(data->un_count >= 0);
 165                         if (data->un_count == 0)
 166                                 cfs_list_move(&data->un_list, &deathrow);
 167                         found = 1;
 168                         break;
 169                 }
 170         }
 171         cfs_spin_unlock (&g_uuid_lock);
 172
 173         if (!found) {
 174                 if (uuid)
 175                         CERROR("Try to delete a non-existent uuid %s\n", uuid);
 176                 return -EINVAL;
 177         }
 178
 179         while (!cfs_list_empty(&deathrow)) {
 180                 data = cfs_list_entry(deathrow.next, struct uuid_nid_data,
 181                                       un_list);
 182                 cfs_list_del(&data->un_list);
 183
 184                 CDEBUG(D_INFO, "del uuid %s %s\n", data->un_uuid,
 185                        libcfs_nid2str(data->un_nid));
 186
 187                 OBD_FREE(data->un_uuid, strlen(data->un_uuid) + 1);
 188                 OBD_FREE(data, sizeof(*data));
 189         }
 190
 191         return 0;
 192 }