external/gpl2/lvm2/dist/daemons/clvmd/clvmd-command.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
   5  * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
   6  *
   7  * This file is part of LVM2.
   8  *
   9  * This copyrighted material is made available to anyone wishing to use,
  10  * modify, copy, or redistribute it subject to the terms and conditions
  11  * of the GNU General Public License v.2.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 /*
  19
  20   CLVMD Cluster LVM daemon command processor.
  21
  22   To add commands to the daemon simply add a processor in do_command and return
  23   and messages back in buf and the length in *retlen. The initial value of
  24   buflen is the maximum size of the buffer. if buf is not large enough then it
  25   may be reallocated by the functions in here to a suitable size bearing in
  26   mind that anything larger than the passed-in size will have to be returned
  27   using the system LV and so performance will suffer.
  28
  29   The status return will be negated and passed back to the originating node.
  30
  31   pre- and post- command routines are called only on the local node. The
  32   purpose is primarily to get and release locks, though the pre- routine should
  33   also do any other local setups required by the command (if any) and can
  34   return a failure code that prevents the command from being distributed around
  35   the cluster
  36
  37   The pre- and post- routines are run in their own thread so can block as long
  38   they like, do_command is run in the main clvmd thread so should not block for
  39   too long. If the pre-command returns an error code (!=0) then the command
  40   will not be propogated around the cluster but the post-command WILL be called
  41
  42   Also note that the pre and post routine are *always* called on the local
  43   node, even if the command to be executed was only requested to run on a
  44   remote node. It may peek inside the client structure to check the status of
  45   the command.
  46
  47   The clients of the daemon must, naturally, understand the return messages and
  48   codes.
  49
  50   Routines in here may only READ the values in the client structure passed in
  51   apart from client->private which they are free to do what they like with.
  52
  53 */
  54
  55 #define _GNU_SOURCE
  56 #define _FILE_OFFSET_BITS 64
  57
  58 #include <configure.h>
  59 #include <pthread.h>
  60 #include <sys/types.h>
  61 #include <sys/utsname.h>
  62 #include <sys/ioctl.h>
  63 #include <sys/socket.h>
  64 #include <sys/stat.h>
  65 #include <stdio.h>
  66 #include <stdlib.h>
  67 #include <stdint.h>
  68 #include <fcntl.h>
  69 #include <string.h>
  70 #include <stddef.h>
  71 #include <unistd.h>
  72 #include <errno.h>
  73 #include <libdevmapper.h>
  74 #include <libdlm.h>
  75
  76 #include "locking.h"
  77 #include "lvm-logging.h"
  78 #include "lvm-functions.h"
  79 #include "clvmd-comms.h"
  80 #include "clvm.h"
  81 #include "clvmd.h"
  82
  83 extern debug_t debug;
  84 extern struct cluster_ops *clops;
  85
  86 /* This is where all the real work happens:
  87    NOTE: client will be NULL when this is executed on a remote node */
  88 int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
  89                char **buf, int buflen, int *retlen)
  90 {
  91         char *args = msg->node + strlen(msg->node) + 1;
  92         int arglen = msglen - sizeof(struct clvm_header) - strlen(msg->node);
  93         int status = 0;
  94         char *lockname;
  95         const char *locktype;
  96         struct utsname nodeinfo;
  97         unsigned char lock_cmd;
  98         unsigned char lock_flags;
  99
 100         /* Do the command */
 101         switch (msg->cmd) {
 102                 /* Just a test message */
 103         case CLVMD_CMD_TEST:
 104                 if (arglen > buflen) {
 105                         char *new_buf;
 106                         buflen = arglen + 200;
 107                         new_buf = realloc(*buf, buflen);
 108                         if (new_buf == NULL) {
 109                                 status = errno;
 110                                 free (*buf);
 111                         }
 112                         *buf = new_buf;
 113                 }
 114                 if (*buf) {
 115                         uname(&nodeinfo);
 116                         *retlen = 1 + snprintf(*buf, buflen,
 117                                                "TEST from %s: %s v%s",
 118                                                nodeinfo.nodename, args,
 119                                                nodeinfo.release);
 120                 }
 121                 break;
 122
 123         case CLVMD_CMD_LOCK_VG:
 124                 lockname = &args[2];
 125                 /* Check to see if the VG is in use by LVM1 */
 126                 status = do_check_lvm1(lockname);
 127                 /* P_#global causes a full cache refresh */
 128                 if (!strcmp(lockname, "P_" VG_GLOBAL))
 129                         do_refresh_cache();
 130                 else
 131                         drop_metadata(lockname + 2);
 132
 133                 break;
 134
 135         case CLVMD_CMD_LOCK_LV:
 136                 /* This is the biggie */
 137                 lock_cmd = args[0] & 0x3F;
 138                 lock_flags = args[1];
 139                 lockname = &args[2];
 140                 status = do_lock_lv(lock_cmd, lock_flags, lockname);
 141                 /* Replace EIO with something less scary */
 142                 if (status == EIO) {
 143                         *retlen =
 144                             1 + snprintf(*buf, buflen, "%s",
 145                                          get_last_lvm_error());
 146                         return EIO;
 147                 }
 148                 break;
 149
 150         case CLVMD_CMD_LOCK_QUERY:
 151                 lockname = &args[2];
 152                 if (buflen < 3)
 153                         return EIO;
 154                 if ((locktype = do_lock_query(lockname)))
 155                         *retlen = 1 + snprintf(*buf, buflen, "%s", locktype);
 156                 break;
 157
 158         case CLVMD_CMD_REFRESH:
 159                 do_refresh_cache();
 160                 break;
 161
 162         case CLVMD_CMD_SET_DEBUG:
 163                 debug = args[0];
 164                 break;
 165
 166         case CLVMD_CMD_GET_CLUSTERNAME:
 167                 status = clops->get_cluster_name(*buf, buflen);
 168                 if (!status)
 169                         *retlen = strlen(*buf)+1;
 170                 break;
 171
 172         case CLVMD_CMD_VG_BACKUP:
 173                 /*
 174                  * Do not run backup on local node, caller should do that.
 175                  */
 176                 if (!client)
 177                         lvm_do_backup(&args[2]);
 178                 break;
 179
 180         default:
 181                 /* Won't get here because command is validated in pre_command */
 182                 break;
 183         }
 184
 185         /* Check the status of the command and return the error text */
 186         if (status) {
 187                 *retlen = 1 + snprintf(*buf, buflen, "%s", strerror(status));
 188         }
 189
 190         return status;
 191
 192 }
 193
 194 static int lock_vg(struct local_client *client)
 195 {
 196     struct dm_hash_table *lock_hash;
 197     struct clvm_header *header =
 198         (struct clvm_header *) client->bits.localsock.cmd;
 199     unsigned char lock_cmd;
 200     unsigned char lock_flags;
 201     char *args = header->node + strlen(header->node) + 1;
 202     int lkid;
 203     int status = 0;
 204     char *lockname;
 205
 206     /* Keep a track of VG locks in our own hash table. In current
 207        practice there should only ever be more than two VGs locked
 208        if a user tries to merge lots of them at once */
 209     if (client->bits.localsock.private) {
 210         lock_hash = (struct dm_hash_table *)client->bits.localsock.private;
 211     }
 212     else {
 213         lock_hash = dm_hash_create(3);
 214         if (!lock_hash)
 215             return ENOMEM;
 216         client->bits.localsock.private = (void *)lock_hash;
 217     }
 218
 219     lock_cmd = args[0] & 0x3F;
 220     lock_flags = args[1];
 221     lockname = &args[2];
 222     DEBUGLOG("doing PRE command LOCK_VG '%s' at %x (client=%p)\n", lockname, lock_cmd, client);
 223
 224     if (lock_cmd == LCK_UNLOCK) {
 225
 226         lkid = (int)(long)dm_hash_lookup(lock_hash, lockname);
 227         if (lkid == 0)
 228             return EINVAL;
 229
 230         status = sync_unlock(lockname, lkid);
 231         if (status)
 232             status = errno;
 233         else
 234             dm_hash_remove(lock_hash, lockname);
 235     }
 236     else {
 237         /* Read locks need to be PR; other modes get passed through */
 238         if ((lock_cmd & LCK_TYPE_MASK) == LCK_READ) {
 239             lock_cmd &= ~LCK_TYPE_MASK;
 240             lock_cmd |= LCK_PREAD;
 241         }
 242         status = sync_lock(lockname, (int)lock_cmd, (lock_flags & LCK_NONBLOCK) ? LKF_NOQUEUE : 0, &lkid);
 243         if (status)
 244             status = errno;
 245         else
 246             dm_hash_insert(lock_hash, lockname, (void *)(long)lkid);
 247     }
 248
 249     return status;
 250 }
 251
 252
 253 /* Pre-command is a good place to get locks that are needed only for the duration
 254    of the commands around the cluster (don't forget to free them in post-command),
 255    and to sanity check the command arguments */
 256 int do_pre_command(struct local_client *client)
 257 {
 258         struct clvm_header *header =
 259             (struct clvm_header *) client->bits.localsock.cmd;
 260         unsigned char lock_cmd;
 261         unsigned char lock_flags;
 262         char *args = header->node + strlen(header->node) + 1;
 263         int lockid;
 264         int status = 0;
 265         char *lockname;
 266
 267         switch (header->cmd) {
 268         case CLVMD_CMD_TEST:
 269                 status = sync_lock("CLVMD_TEST", LKM_EXMODE, 0, &lockid);
 270                 client->bits.localsock.private = (void *)(long)lockid;
 271                 break;
 272
 273         case CLVMD_CMD_LOCK_VG:
 274                 lockname = &args[2];
 275                 /* We take out a real lock unless LCK_CACHE was set */
 276                 if (!strncmp(lockname, "V_", 2) ||
 277                     !strncmp(lockname, "P_#", 3))
 278                         status = lock_vg(client);
 279                 break;
 280
 281         case CLVMD_CMD_LOCK_LV:
 282                 lock_cmd = args[0];
 283                 lock_flags = args[1];
 284                 lockname = &args[2];
 285                 status = pre_lock_lv(lock_cmd, lock_flags, lockname);
 286                 break;
 287
 288         case CLVMD_CMD_REFRESH:
 289         case CLVMD_CMD_GET_CLUSTERNAME:
 290         case CLVMD_CMD_SET_DEBUG:
 291         case CLVMD_CMD_VG_BACKUP:
 292         case CLVMD_CMD_LOCK_QUERY:
 293                 break;
 294
 295         default:
 296                 log_error("Unknown command %d received\n", header->cmd);
 297                 status = EINVAL;
 298         }
 299         return status;
 300 }
 301
 302 /* Note that the post-command routine is called even if the pre-command or the real command
 303    failed */
 304 int do_post_command(struct local_client *client)
 305 {
 306         struct clvm_header *header =
 307             (struct clvm_header *) client->bits.localsock.cmd;
 308         int status = 0;
 309         unsigned char lock_cmd;
 310         unsigned char lock_flags;
 311         char *args = header->node + strlen(header->node) + 1;
 312         char *lockname;
 313
 314         switch (header->cmd) {
 315         case CLVMD_CMD_TEST:
 316                 status =
 317                     sync_unlock("CLVMD_TEST", (int) (long) client->bits.localsock.private);
 318                 client->bits.localsock.private = 0;
 319                 break;
 320
 321         case CLVMD_CMD_LOCK_VG:
 322         case CLVMD_CMD_VG_BACKUP:
 323         case CLVMD_CMD_LOCK_QUERY:
 324                 /* Nothing to do here */
 325                 break;
 326
 327         case CLVMD_CMD_LOCK_LV:
 328                 lock_cmd = args[0];
 329                 lock_flags = args[1];
 330                 lockname = &args[2];
 331                 status = post_lock_lv(lock_cmd, lock_flags, lockname);
 332                 break;
 333         }
 334         return status;
 335 }
 336
 337
 338 /* Called when the client is about to be deleted */
 339 void cmd_client_cleanup(struct local_client *client)
 340 {
 341     if (client->bits.localsock.private) {
 342
 343         struct dm_hash_node *v;
 344         struct dm_hash_table *lock_hash =
 345             (struct dm_hash_table *)client->bits.localsock.private;
 346
 347         dm_hash_iterate(v, lock_hash) {
 348                 int lkid = (int)(long)dm_hash_get_data(lock_hash, v);
 349                 char *lockname = dm_hash_get_key(lock_hash, v);
 350
 351                 DEBUGLOG("cleanup: Unlocking lock %s %x\n", lockname, lkid);
 352                 sync_unlock(lockname, lkid);
 353         }
 354
 355         dm_hash_destroy(lock_hash);
 356         client->bits.localsock.private = 0;
 357     }
 358 }