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 DEFINE_MUTEX(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 }