sbin/hammer2/hammer2.h

   1 /*
   2  * Copyright (c) 2011-2012 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@dragonflybsd.org>
   6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 /*
  37  * Rollup headers for hammer2 utility
  38  */
  39 #include <sys/types.h>
  40 #include <sys/uio.h>
  41 #include <sys/mount.h>
  42 #include <sys/file.h>
  43 #include <sys/socket.h>
  44 #include <sys/time.h>
  45 #include <sys/wait.h>
  46 #include <sys/tty.h>
  47 #include <sys/endian.h>
  48
  49 #include <netinet/in.h>
  50 #include <netinet/tcp.h>
  51 #include <arpa/inet.h>
  52 #include <netdb.h>
  53
  54 #include <vfs/hammer2/hammer2_disk.h>
  55 #include <vfs/hammer2/hammer2_mount.h>
  56 #include <vfs/hammer2/hammer2_ioctl.h>
  57 #include <vfs/hammer2/hammer2_network.h>
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <stdarg.h>
  62 #include <stddef.h>
  63
  64 #include <errno.h>
  65 #include <fcntl.h>
  66 #include <signal.h>
  67 #include <string.h>
  68 #include <unistd.h>
  69 #include <ctype.h>
  70 #include <uuid.h>
  71 #include <assert.h>
  72 #include <pthread.h>
  73 #include <poll.h>
  74
  75 #include <libutil.h>
  76
  77 #include "network.h"
  78
  79 #define HAMMER2_DEFAULT_DIR     "/etc/hammer2"
  80 #define HAMMER2_PATH_REMOTE     HAMMER2_DEFAULT_DIR "/remote"
  81
  82 struct hammer2_idmap {
  83         struct hammer2_idmap *next;
  84         uint32_t ran_beg;       /* inclusive */
  85         uint32_t ran_end;       /* inclusive */
  86 };
  87
  88 typedef struct hammer2_idmap hammer2_idmap_t;
  89
  90 extern int DebugOpt;
  91 extern int VerboseOpt;
  92 extern int QuietOpt;
  93 extern int NormalExit;
  94
  95 /*
  96  * Hammer2 command APIs
  97  */
  98 int hammer2_ioctl_handle(const char *sel_path);
  99 void hammer2_demon(void *(*func)(void *), void *arg);
 100
 101 int cmd_remote_connect(const char *sel_path, const char *url);
 102 int cmd_remote_disconnect(const char *sel_path, const char *url);
 103 int cmd_remote_status(const char *sel_path, int all_opt);
 104
 105 int cmd_pfs_getid(const char *sel_path, const char *name, int privateid);
 106 int cmd_pfs_list(const char *sel_path);
 107 int cmd_pfs_create(const char *sel_path, const char *name,
 108                         uint8_t pfs_type, const char *uuid_str);
 109 int cmd_pfs_delete(const char *sel_path, const char *name);
 110
 111 int cmd_service(void);
 112 int cmd_stat(int ac, const char **av);
 113 int cmd_leaf(const char *sel_path);
 114 int cmd_shell(const char *hostname);
 115 int cmd_debugspan(const char *hostname);
 116 int cmd_show(const char *devpath);
 117 int cmd_rsainit(const char *dir_path);
 118 int cmd_rsaenc(const char **keys, int nkeys);
 119 int cmd_rsadec(const char **keys, int nkeys);
 120
 121 /*
 122  * Msg support functions
 123  */
 124 void hammer2_bswap_head(hammer2_msg_hdr_t *head);
 125 void hammer2_ioq_init(hammer2_iocom_t *iocom, hammer2_ioq_t *ioq);
 126 void hammer2_ioq_done(hammer2_iocom_t *iocom, hammer2_ioq_t *ioq);
 127 void hammer2_iocom_init(hammer2_iocom_t *iocom, int sock_fd, int alt_fd,
 128                         void (*state_func)(hammer2_iocom_t *),
 129                         void (*rcvmsg_func)(hammer2_iocom_t *, hammer2_msg_t *),
 130                         void (*altmsg_func)(hammer2_iocom_t *));
 131 void hammer2_iocom_restate(hammer2_iocom_t *iocom,
 132                         void (*state_func)(hammer2_iocom_t *),
 133                         void (*rcvmsg_func)(hammer2_iocom_t *, hammer2_msg_t *),
 134                         void (*altmsg_func)(hammer2_iocom_t *));
 135 void hammer2_iocom_done(hammer2_iocom_t *iocom);
 136 hammer2_msg_t *hammer2_msg_alloc(hammer2_iocom_t *iocom, size_t aux_size,
 137                         uint32_t cmd);
 138 void hammer2_msg_reply(hammer2_iocom_t *iocom, hammer2_msg_t *msg,
 139                         uint32_t error);
 140 void hammer2_msg_result(hammer2_iocom_t *iocom, hammer2_msg_t *msg,
 141                         uint32_t error);
 142 void hammer2_state_reply(hammer2_state_t *state, uint32_t error);
 143
 144 void hammer2_msg_free(hammer2_iocom_t *iocom, hammer2_msg_t *msg);
 145
 146 void hammer2_iocom_core(hammer2_iocom_t *iocom);
 147 hammer2_msg_t *hammer2_ioq_read(hammer2_iocom_t *iocom);
 148 void hammer2_msg_write(hammer2_iocom_t *iocom, hammer2_msg_t *msg,
 149                         void (*func)(hammer2_state_t *, hammer2_msg_t *),
 150                         void *data, hammer2_state_t **statep);
 151
 152 void hammer2_iocom_drain(hammer2_iocom_t *iocom);
 153 void hammer2_iocom_flush1(hammer2_iocom_t *iocom);
 154 void hammer2_iocom_flush2(hammer2_iocom_t *iocom);
 155
 156 void hammer2_state_cleanuprx(hammer2_iocom_t *iocom, hammer2_msg_t *msg);
 157 void hammer2_state_free(hammer2_state_t *state);
 158
 159 /*
 160  * Msg protocol functions
 161  */
 162 void hammer2_msg_lnk(hammer2_iocom_t *iocom, hammer2_msg_t *msg);
 163 void hammer2_msg_dbg(hammer2_iocom_t *iocom, hammer2_msg_t *msg);
 164
 165 /*
 166  * Crypto functions
 167  */
 168 void hammer2_crypto_setup(void);
 169 void hammer2_crypto_negotiate(hammer2_iocom_t *iocom);
 170 void hammer2_crypto_decrypt(hammer2_iocom_t *iocom, hammer2_ioq_t *ioq);
 171 void hammer2_crypto_decrypt_aux(hammer2_iocom_t *iocom, hammer2_ioq_t *ioq,
 172                         hammer2_msg_t *msg, int already);
 173 int hammer2_crypto_encrypt(hammer2_iocom_t *iocom, hammer2_ioq_t *ioq,
 174                         struct iovec *iov, int n, size_t *nmaxp);
 175 void hammer2_crypto_encrypt_wrote(hammer2_iocom_t *iocom, hammer2_ioq_t *ioq,
 176                         int nact);
 177
 178 /*
 179  * Misc functions
 180  */
 181 const char *hammer2_time64_to_str(uint64_t htime64, char **strp);
 182 const char *hammer2_uuid_to_str(uuid_t *uuid, char **strp);
 183 const char *hammer2_iptype_to_str(uint8_t type);
 184 const char *hammer2_pfstype_to_str(uint8_t type);
 185 const char *sizetostr(hammer2_off_t size);
 186 int hammer2_connect(const char *hostname);
 187
 188 void *master_service(void *data);
 189
 190 void hammer2_msg_debug(hammer2_iocom_t *iocom, hammer2_msg_t *msg);
 191 void iocom_printf(hammer2_iocom_t *iocom, uint32_t cmd, const char *ctl, ...);
 192 void *hammer2_alloc(size_t bytes);
 193 void hammer2_free(void *ptr);