]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - fs/xfs/support/uuid.c
Merge master.kernel.org:/pub/scm/linux/kernel/git/sam/kbuild
[linux-2.6-omap-h63xx.git] / fs / xfs / support / uuid.c
1 /*
2  * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include <xfs.h>
19
20 static mutex_t  uuid_monitor;
21 static int      uuid_table_size;
22 static uuid_t   *uuid_table;
23
24 /* IRIX interpretation of an uuid_t */
25 typedef struct {
26         __be32  uu_timelow;
27         __be16  uu_timemid;
28         __be16  uu_timehi;
29         __be16  uu_clockseq;
30         __be16  uu_node[3];
31 } xfs_uu_t;
32
33 /*
34  * uuid_getnodeuniq - obtain the node unique fields of a UUID.
35  *
36  * This is not in any way a standard or condoned UUID function;
37  * it just something that's needed for user-level file handles.
38  */
39 void
40 uuid_getnodeuniq(uuid_t *uuid, int fsid [2])
41 {
42         xfs_uu_t *uup = (xfs_uu_t *)uuid;
43
44         fsid[0] = (be16_to_cpu(uup->uu_clockseq) << 16) |
45                    be16_to_cpu(uup->uu_timemid);
46         fsid[1] = be32_to_cpu(uup->uu_timelow);
47 }
48
49 void
50 uuid_create_nil(uuid_t *uuid)
51 {
52         memset(uuid, 0, sizeof(*uuid));
53 }
54
55 int
56 uuid_is_nil(uuid_t *uuid)
57 {
58         int     i;
59         char    *cp = (char *)uuid;
60
61         if (uuid == NULL)
62                 return 0;
63         /* implied check of version number here... */
64         for (i = 0; i < sizeof *uuid; i++)
65                 if (*cp++) return 0;    /* not nil */
66         return 1;       /* is nil */
67 }
68
69 int
70 uuid_equal(uuid_t *uuid1, uuid_t *uuid2)
71 {
72         return memcmp(uuid1, uuid2, sizeof(uuid_t)) ? 0 : 1;
73 }
74
75 /*
76  * Given a 128-bit uuid, return a 64-bit value by adding the top and bottom
77  * 64-bit words.  NOTE: This function can not be changed EVER.  Although
78  * brain-dead, some applications depend on this 64-bit value remaining
79  * persistent.  Specifically, DMI vendors store the value as a persistent
80  * filehandle.
81  */
82 __uint64_t
83 uuid_hash64(uuid_t *uuid)
84 {
85         __uint64_t      *sp = (__uint64_t *)uuid;
86
87         return sp[0] + sp[1];
88 }
89
90 int
91 uuid_table_insert(uuid_t *uuid)
92 {
93         int     i, hole;
94
95         mutex_lock(&uuid_monitor);
96         for (i = 0, hole = -1; i < uuid_table_size; i++) {
97                 if (uuid_is_nil(&uuid_table[i])) {
98                         hole = i;
99                         continue;
100                 }
101                 if (uuid_equal(uuid, &uuid_table[i])) {
102                         mutex_unlock(&uuid_monitor);
103                         return 0;
104                 }
105         }
106         if (hole < 0) {
107                 uuid_table = kmem_realloc(uuid_table,
108                         (uuid_table_size + 1) * sizeof(*uuid_table),
109                         uuid_table_size  * sizeof(*uuid_table),
110                         KM_SLEEP);
111                 hole = uuid_table_size++;
112         }
113         uuid_table[hole] = *uuid;
114         mutex_unlock(&uuid_monitor);
115         return 1;
116 }
117
118 void
119 uuid_table_remove(uuid_t *uuid)
120 {
121         int     i;
122
123         mutex_lock(&uuid_monitor);
124         for (i = 0; i < uuid_table_size; i++) {
125                 if (uuid_is_nil(&uuid_table[i]))
126                         continue;
127                 if (!uuid_equal(uuid, &uuid_table[i]))
128                         continue;
129                 uuid_create_nil(&uuid_table[i]);
130                 break;
131         }
132         ASSERT(i < uuid_table_size);
133         mutex_unlock(&uuid_monitor);
134 }
135
136 void
137 uuid_init(void)
138 {
139         mutex_init(&uuid_monitor);
140 }