Whamcloud - gitweb
Branch HEAD
[fs/lustre-release.git] / 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         struct list_head 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 struct list_head g_uuid_list;
59 static spinlock_t       g_uuid_lock;
60
61 void class_init_uuidlist(void)
62 {
63         CFS_INIT_LIST_HEAD(&g_uuid_list);
64         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         struct list_head *tmp;
76
77         spin_lock (&g_uuid_lock);
78
79         list_for_each(tmp, &g_uuid_list) {
80                 struct uuid_nid_data *data =
81                         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                         spin_unlock (&g_uuid_lock);
88                         return 0;
89                 }
90         }
91
92         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         spin_lock (&g_uuid_lock);
124
125         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                 list_add(&data->un_list, &g_uuid_list);
135         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         spin_lock (&g_uuid_lock);
156         if (uuid == NULL) {
157                 list_splice_init(&g_uuid_list, &deathrow);
158                 found = 1;
159         } else {
160                 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                                 list_move(&data->un_list, &deathrow);
167                         found = 1;
168                         break;
169                 }
170         }
171         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 (!list_empty(&deathrow)) {
180                 data = list_entry(deathrow.next, struct uuid_nid_data, un_list);
181                 list_del(&data->un_list);
182
183                 CDEBUG(D_INFO, "del uuid %s %s\n", data->un_uuid,
184                        libcfs_nid2str(data->un_nid));
185
186                 OBD_FREE(data->un_uuid, strlen(data->un_uuid) + 1);
187                 OBD_FREE(data, sizeof(*data));
188         }
189
190         return 0;
191 }