sys/vfs/hammer2/hammer2_iocom.c

   1 /*
   2  * Copyright (c) 2011-2018 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  * by Daniel Flores (GSOC 2013 - mentored by Matthew Dillon, compression)
   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 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/nlookup.h>
  39 #include <sys/vnode.h>
  40 #include <sys/mount.h>
  41 #include <sys/fcntl.h>
  42 #include <sys/buf.h>
  43 #include <sys/uuid.h>
  44 #include <sys/vfsops.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/socket.h>
  47 #include <sys/objcache.h>
  48
  49 #include <sys/proc.h>
  50 #include <sys/namei.h>
  51 #include <sys/mountctl.h>
  52 #include <sys/dirent.h>
  53 #include <sys/uio.h>
  54
  55 #include <sys/mutex.h>
  56 #include <sys/mutex2.h>
  57
  58 #include "hammer2.h"
  59 #include "hammer2_disk.h"
  60 #include "hammer2_mount.h"
  61
  62 static int hammer2_rcvdmsg(kdmsg_msg_t *msg);
  63 static void hammer2_autodmsg(kdmsg_msg_t *msg);
  64 static int hammer2_lnk_span_reply(kdmsg_state_t *state, kdmsg_msg_t *msg);
  65
  66 void
  67 hammer2_iocom_init(hammer2_dev_t *hmp)
  68 {
  69         /*
  70          * Automatic LNK_CONN
  71          * Automatic LNK_SPAN handling
  72          * No automatic LNK_SPAN generation (we generate multiple spans
  73          *                                   ourselves).
  74          */
  75         kdmsg_iocom_init(&hmp->iocom, hmp,
  76                          KDMSG_IOCOMF_AUTOCONN |
  77                          KDMSG_IOCOMF_AUTORXSPAN,
  78                          hmp->mchain, hammer2_rcvdmsg);
  79 }
  80
  81 void
  82 hammer2_iocom_uninit(hammer2_dev_t *hmp)
  83 {
  84         /* XXX chain depend deadlck? */
  85         if (hmp->iocom.mmsg)
  86                 kdmsg_iocom_uninit(&hmp->iocom);
  87 }
  88
  89 /*
  90  * Reconnect using the passed file pointer.  The caller must ref the
  91  * fp for us.
  92  */
  93 void
  94 hammer2_cluster_reconnect(hammer2_dev_t *hmp, struct file *fp)
  95 {
  96         /*
  97          * Closes old comm descriptor, kills threads, cleans up
  98          * states, then installs the new descriptor and creates
  99          * new threads.
 100          */
 101         kdmsg_iocom_reconnect(&hmp->iocom, fp, "hammer2");
 102
 103         /*
 104          * Setup LNK_CONN fields for autoinitiated state machine.  LNK_CONN
 105          * does not have to be unique.  peer_id can be used to filter incoming
 106          * LNK_SPANs automatically if desired (though we still need to check).
 107          * peer_label typically identifies who we are and is not a filter.
 108          *
 109          * Since we will be initiating multiple LNK_SPANs we cannot use
 110          * AUTOTXSPAN, but we do use AUTORXSPAN so kdmsg tracks received
 111          * LNK_SPANs, and we simply monitor those messages.
 112          */
 113         bzero(&hmp->iocom.auto_lnk_conn.peer_id,
 114               sizeof(hmp->iocom.auto_lnk_conn.peer_id));
 115         /* hmp->iocom.auto_lnk_conn.peer_id = hmp->voldata.fsid; */
 116         hmp->iocom.auto_lnk_conn.proto_version = DMSG_SPAN_PROTO_1;
 117 #if 0
 118         hmp->iocom.auto_lnk_conn.peer_type = hmp->voldata.peer_type;
 119 #endif
 120         hmp->iocom.auto_lnk_conn.peer_type = DMSG_PEER_HAMMER2;
 121
 122         /*
 123          * We just want to receive LNK_SPANs related to HAMMER2 matching
 124          * peer_id.
 125          */
 126         hmp->iocom.auto_lnk_conn.peer_mask = 1LLU << DMSG_PEER_HAMMER2;
 127
 128 #if 0
 129         switch (ipdata->meta.pfs_type) {
 130         case DMSG_PFSTYPE_CLIENT:
 131                 hmp->iocom.auto_lnk_conn.peer_mask &=
 132                                 ~(1LLU << DMSG_PFSTYPE_CLIENT);
 133                 break;
 134         default:
 135                 break;
 136         }
 137 #endif
 138
 139         bzero(&hmp->iocom.auto_lnk_conn.peer_label,
 140               sizeof(hmp->iocom.auto_lnk_conn.peer_label));
 141         ksnprintf(hmp->iocom.auto_lnk_conn.peer_label,
 142                   sizeof(hmp->iocom.auto_lnk_conn.peer_label),
 143                   "%s/%s",
 144                   hostname, "hammer2-mount");
 145         kdmsg_iocom_autoinitiate(&hmp->iocom, hammer2_autodmsg);
 146 }
 147
 148 static int
 149 hammer2_rcvdmsg(kdmsg_msg_t *msg)
 150 {
 151         kprintf("RCVMSG %08x\n", msg->tcmd);
 152
 153         switch(msg->tcmd) {
 154         case DMSG_DBG_SHELL:
 155                 /*
 156                  * (non-transaction)
 157                  * Execute shell command (not supported atm)
 158                  */
 159                 kdmsg_msg_result(msg, DMSG_ERR_NOSUPP);
 160                 break;
 161         case DMSG_DBG_SHELL | DMSGF_REPLY:
 162                 /*
 163                  * (non-transaction)
 164                  */
 165                 if (msg->aux_data) {
 166                         msg->aux_data[msg->aux_size - 1] = 0;
 167                         kprintf("HAMMER2 DBG: %s\n", msg->aux_data);
 168                 }
 169                 break;
 170         default:
 171                 /*
 172                  * Unsupported message received.  We only need to
 173                  * reply if it's a transaction in order to close our end.
 174                  * Ignore any one-way messages or any further messages
 175                  * associated with the transaction.
 176                  *
 177                  * NOTE: This case also includes DMSG_LNK_ERROR messages
 178                  *       which might be one-way, replying to those would
 179                  *       cause an infinite ping-pong.
 180                  */
 181                 if (msg->any.head.cmd & DMSGF_CREATE)
 182                         kdmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
 183                 break;
 184         }
 185         return(0);
 186 }
 187
 188 /*
 189  * This function is called after KDMSG has automatically handled processing
 190  * of a LNK layer message (typically CONN or SPAN).
 191  *
 192  * We trampoline off LNK_CONN (link level connection advertising the presence
 193  * of H2 partitions) to generate LNK_HAMMER2_VOLCONF's from the vol->copyinfo[]
 194  * array in the volume header, and to generate LNK_SPANs advertising all PFSs
 195  * available from that volume.  Currently the VOLCONFs go through the motions
 196  * but are otherwise ignored.
 197  *
 198  * We collect LNK_SPAN state for hammer2 peers and turn those into 'remote'
 199  * PFSs which look similar to local (direct storage) PFSs.  These PFSs are
 200  * merged with local PFSs and may be mounted locally or merged with other
 201  * elements that might or might not include local cluster components (local
 202  * PFSs).  If you wish to ensure that a mandatory PFS rendezvous is present
 203  * even without network connectivity you would normally just create a dummy
 204  * local PFS configured as PFSTYPE_CACHE (that can be small and ram-backed).
 205  *
 206  * Remote PFSs are object-based and operate using an (inode,key) DMSG API
 207  * instead of hammer2_chain's + direct I/O.  A high level XOP API is employed
 208  * to retain integrity across operations such as rename()s.
 209  */
 210 static void hammer2_update_spans(hammer2_dev_t *hmp, kdmsg_state_t *state);
 211
 212 static void
 213 hammer2_autodmsg(kdmsg_msg_t *msg)
 214 {
 215         hammer2_dev_t *hmp = msg->state->iocom->handle;
 216         int copyid;
 217
 218         switch(msg->tcmd) {
 219         case DMSG_LNK_CONN | DMSGF_CREATE:
 220         case DMSG_LNK_CONN | DMSGF_CREATE | DMSGF_DELETE:
 221         case DMSG_LNK_CONN | DMSGF_DELETE:
 222                 /*
 223                  * NOTE: kern_dmsg will automatically issue a result,
 224                  *       leaving the transaction open, for CREATEs,
 225                  *       and will automatically issue a terminating reply
 226                  *       for DELETEs.
 227                  */
 228                 break;
 229         case DMSG_LNK_CONN | DMSGF_CREATE | DMSGF_REPLY:
 230         case DMSG_LNK_CONN | DMSGF_CREATE | DMSGF_DELETE | DMSGF_REPLY:
 231                 /*
 232                  * Do a volume configuration dump when we receive a reply
 233                  * to our auto-CONN (typically leaving the transaction open).
 234                  */
 235                 if (msg->any.head.cmd & DMSGF_CREATE) {
 236                         kprintf("HAMMER2: VOLDATA DUMP\n");
 237
 238                         /*
 239                          * Dump the configuration stored in the volume header.
 240                          * This will typically be import/export access rights,
 241                          * master encryption keys (encrypted), etc.
 242                          */
 243                         hammer2_voldata_lock(hmp);
 244                         copyid = 0;
 245                         while (copyid < HAMMER2_COPYID_COUNT) {
 246                                 if (hmp->voldata.copyinfo[copyid].copyid)
 247                                         hammer2_volconf_update(hmp, copyid);
 248                                 ++copyid;
 249                         }
 250                         hammer2_voldata_unlock(hmp);
 251
 252                         kprintf("HAMMER2: INITIATE SPANs\n");
 253                         hammer2_update_spans(hmp, msg->state);
 254                 }
 255                 if ((msg->any.head.cmd & DMSGF_DELETE) &&
 256                     msg->state && (msg->state->txcmd & DMSGF_DELETE) == 0) {
 257                         kprintf("HAMMER2: CONN WAS TERMINATED\n");
 258                 }
 259                 break;
 260         case DMSG_LNK_SPAN | DMSGF_CREATE:
 261                 /*
 262                  * Monitor SPANs and issue a result, leaving the SPAN open
 263                  * if it is something we can use now or in the future.
 264                  */
 265                 if (msg->any.lnk_span.peer_type != DMSG_PEER_HAMMER2) {
 266                         kdmsg_msg_reply(msg, 0);
 267                         break;
 268                 }
 269                 if (msg->any.lnk_span.proto_version != DMSG_SPAN_PROTO_1) {
 270                         kdmsg_msg_reply(msg, 0);
 271                         break;
 272                 }
 273                 DMSG_TERMINATE_STRING(msg->any.lnk_span.peer_label);
 274                 if (hammer2_debug & 0x0100) {
 275                         kprintf("H2 +RXSPAN cmd=%08x (%-20s) cl=",
 276                                 msg->any.head.cmd,
 277                                 msg->any.lnk_span.peer_label);
 278                         printf_uuid(&msg->any.lnk_span.peer_id);
 279                         kprintf(" fs=");
 280                         printf_uuid(&msg->any.lnk_span.pfs_id);
 281                         kprintf(" type=%d\n", msg->any.lnk_span.pfs_type);
 282                 }
 283                 kdmsg_msg_result(msg, 0);
 284                 break;
 285         case DMSG_LNK_SPAN | DMSGF_DELETE:
 286                 /*
 287                  * NOTE: kern_dmsg will automatically reply to DELETEs.
 288                  */
 289                 if (hammer2_debug & 0x0100)
 290                         kprintf("H2 -RXSPAN\n");
 291                 break;
 292         default:
 293                 break;
 294         }
 295 }
 296
 297 /*
 298  * Update LNK_SPAN state
 299  */
 300 static void
 301 hammer2_update_spans(hammer2_dev_t *hmp, kdmsg_state_t *state)
 302 {
 303         const hammer2_inode_data_t *ripdata;
 304         hammer2_chain_t *parent;
 305         hammer2_chain_t *chain;
 306         hammer2_pfs_t *spmp;
 307         hammer2_key_t key_next;
 308         kdmsg_msg_t *rmsg;
 309         size_t name_len;
 310         int error;
 311
 312         /*
 313          * Lookup mount point under the media-localized super-root.
 314          *
 315          * cluster->pmp will incorrectly point to spmp and must be fixed
 316          * up later on.
 317          */
 318         spmp = hmp->spmp;
 319         hammer2_inode_lock(spmp->iroot, 0);
 320         error = 0;
 321
 322         parent = hammer2_inode_chain(spmp->iroot, 0, HAMMER2_RESOLVE_ALWAYS);
 323         chain = NULL;
 324         if (parent == NULL)
 325                 goto done;
 326         chain = hammer2_chain_lookup(&parent, &key_next,
 327                                      HAMMER2_KEY_MIN, HAMMER2_KEY_MAX,
 328                                      &error, 0);
 329         while (chain) {
 330                 if (chain->bref.type != HAMMER2_BREF_TYPE_INODE)
 331                         continue;
 332                 ripdata = &chain->data->ipdata;
 333 #if 0
 334                 kprintf("UPDATE SPANS: %s\n", ripdata->filename);
 335 #endif
 336
 337                 rmsg = kdmsg_msg_alloc(&hmp->iocom.state0,
 338                                        DMSG_LNK_SPAN | DMSGF_CREATE,
 339                                        hammer2_lnk_span_reply, NULL);
 340                 rmsg->any.lnk_span.peer_id = ripdata->meta.pfs_clid;
 341                 rmsg->any.lnk_span.pfs_id = ripdata->meta.pfs_fsid;
 342                 rmsg->any.lnk_span.pfs_type = ripdata->meta.pfs_type;
 343                 rmsg->any.lnk_span.peer_type = DMSG_PEER_HAMMER2;
 344                 rmsg->any.lnk_span.proto_version = DMSG_SPAN_PROTO_1;
 345                 name_len = ripdata->meta.name_len;
 346                 if (name_len >= sizeof(rmsg->any.lnk_span.peer_label))
 347                         name_len = sizeof(rmsg->any.lnk_span.peer_label) - 1;
 348                 bcopy(ripdata->filename,
 349                       rmsg->any.lnk_span.peer_label,
 350                       name_len);
 351
 352                 kdmsg_msg_write(rmsg);
 353
 354                 chain = hammer2_chain_next(&parent, chain, &key_next,
 355                                                key_next, HAMMER2_KEY_MAX,
 356                                                &error, 0);
 357         }
 358         hammer2_inode_unlock(spmp->iroot);
 359         /* XXX do something with error */
 360 done:
 361         if (chain) {
 362                 hammer2_chain_unlock(chain);
 363                 hammer2_chain_drop(chain);
 364         }
 365         if (parent) {
 366                 hammer2_chain_unlock(parent);
 367                 hammer2_chain_drop(parent);
 368         }
 369 }
 370
 371 static
 372 int
 373 hammer2_lnk_span_reply(kdmsg_state_t *state, kdmsg_msg_t *msg)
 374 {
 375         if ((state->txcmd & DMSGF_DELETE) == 0 &&
 376             (msg->any.head.cmd & DMSGF_DELETE)) {
 377                 kdmsg_msg_reply(msg, 0);
 378         }
 379         return 0;
 380 }
 381
 382 /*
 383  * Volume configuration updates are passed onto the userland service
 384  * daemon via the open LNK_CONN transaction.
 385  */
 386 void
 387 hammer2_volconf_update(hammer2_dev_t *hmp, int index)
 388 {
 389         kdmsg_msg_t *msg;
 390
 391         /* XXX interlock against connection state termination */
 392         kprintf("volconf update %p\n", hmp->iocom.conn_state);
 393         if (hmp->iocom.conn_state) {
 394                 kprintf("TRANSMIT VOLCONF VIA OPEN CONN TRANSACTION\n");
 395                 msg = kdmsg_msg_alloc(hmp->iocom.conn_state,
 396                                       DMSG_LNK_HAMMER2_VOLCONF,
 397                                       NULL, NULL);
 398                 H2_LNK_VOLCONF(msg)->copy = hmp->voldata.copyinfo[index];
 399                 H2_LNK_VOLCONF(msg)->mediaid = hmp->voldata.fsid;
 400                 H2_LNK_VOLCONF(msg)->index = index;
 401                 kdmsg_msg_write(msg);
 402         }
 403 }