1 /* 2 * Copyright (c) 2011-2015 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 tag off the LNK_CONN to trigger our LNK_VOLCONF messages which 193 * advertises all available hammer2 super-root volumes. 194 * 195 * We collect span state 196 */ 197 static void hammer2_update_spans(hammer2_dev_t *hmp, kdmsg_state_t *state); 198 199 static void 200 hammer2_autodmsg(kdmsg_msg_t *msg) 201 { 202 hammer2_dev_t *hmp = msg->state->iocom->handle; 203 int copyid; 204 205 switch(msg->tcmd) { 206 case DMSG_LNK_CONN | DMSGF_CREATE: 207 case DMSG_LNK_CONN | DMSGF_CREATE | DMSGF_DELETE: 208 case DMSG_LNK_CONN | DMSGF_DELETE: 209 /* 210 * NOTE: kern_dmsg will automatically issue a result, 211 * leaving the transaction open, for CREATEs, 212 * and will automatically issue a terminating reply 213 * for DELETEs. 214 */ 215 break; 216 case DMSG_LNK_CONN | DMSGF_CREATE | DMSGF_REPLY: 217 case DMSG_LNK_CONN | DMSGF_CREATE | DMSGF_DELETE | DMSGF_REPLY: 218 /* 219 * Do a volume configuration dump when we receive a reply 220 * to our auto-CONN (typically leaving the transaction open). 221 */ 222 if (msg->any.head.cmd & DMSGF_CREATE) { 223 kprintf("HAMMER2: VOLDATA DUMP\n"); 224 225 /* 226 * Dump the configuration stored in the volume header. 227 * This will typically be import/export access rights, 228 * master encryption keys (encrypted), etc. 229 */ 230 hammer2_voldata_lock(hmp); 231 copyid = 0; 232 while (copyid < HAMMER2_COPYID_COUNT) { 233 if (hmp->voldata.copyinfo[copyid].copyid) 234 hammer2_volconf_update(hmp, copyid); 235 ++copyid; 236 } 237 hammer2_voldata_unlock(hmp); 238 239 kprintf("HAMMER2: INITIATE SPANs\n"); 240 hammer2_update_spans(hmp, msg->state); 241 } 242 if ((msg->any.head.cmd & DMSGF_DELETE) && 243 msg->state && (msg->state->txcmd & DMSGF_DELETE) == 0) { 244 kprintf("HAMMER2: CONN WAS TERMINATED\n"); 245 } 246 break; 247 case DMSG_LNK_SPAN | DMSGF_CREATE: 248 /* 249 * Monitor SPANs and issue a result, leaving the SPAN open 250 * if it is something we can use now or in the future. 251 */ 252 if (msg->any.lnk_span.peer_type != DMSG_PEER_HAMMER2) { 253 kdmsg_msg_reply(msg, 0); 254 break; 255 } 256 if (msg->any.lnk_span.proto_version != DMSG_SPAN_PROTO_1) { 257 kdmsg_msg_reply(msg, 0); 258 break; 259 } 260 DMSG_TERMINATE_STRING(msg->any.lnk_span.peer_label); 261 kprintf("H2 +RXSPAN cmd=%08x (%-20s) cl=", 262 msg->any.head.cmd, msg->any.lnk_span.peer_label); 263 printf_uuid(&msg->any.lnk_span.peer_id); 264 kprintf(" fs="); 265 printf_uuid(&msg->any.lnk_span.pfs_id); 266 kprintf(" type=%d\n", msg->any.lnk_span.pfs_type); 267 kdmsg_msg_result(msg, 0); 268 break; 269 case DMSG_LNK_SPAN | DMSGF_DELETE: 270 /* 271 * NOTE: kern_dmsg will automatically reply to DELETEs. 272 */ 273 kprintf("H2 -RXSPAN\n"); 274 break; 275 default: 276 break; 277 } 278 } 279 280 /* 281 * Update LNK_SPAN state 282 */ 283 static void 284 hammer2_update_spans(hammer2_dev_t *hmp, kdmsg_state_t *state) 285 { 286 const hammer2_inode_data_t *ripdata; 287 hammer2_chain_t *parent; 288 hammer2_chain_t *chain; 289 hammer2_pfs_t *spmp; 290 hammer2_key_t key_next; 291 kdmsg_msg_t *rmsg; 292 size_t name_len; 293 int cache_index = -1; 294 295 /* 296 * Lookup mount point under the media-localized super-root. 297 * 298 * cluster->pmp will incorrectly point to spmp and must be fixed 299 * up later on. 300 */ 301 spmp = hmp->spmp; 302 hammer2_inode_lock(spmp->iroot, 0); 303 304 parent = hammer2_inode_chain(spmp->iroot, 0, HAMMER2_RESOLVE_ALWAYS); 305 chain = NULL; 306 if (parent == NULL) 307 goto done; 308 chain = hammer2_chain_lookup(&parent, &key_next, 309 HAMMER2_KEY_MIN, HAMMER2_KEY_MAX, 310 &cache_index, 311 0); 312 while (chain) { 313 if (chain->bref.type != HAMMER2_BREF_TYPE_INODE) 314 continue; 315 ripdata = &chain->data->ipdata; 316 kprintf("UPDATE SPANS: %s\n", ripdata->filename); 317 318 rmsg = kdmsg_msg_alloc(&hmp->iocom.state0, 319 DMSG_LNK_SPAN | DMSGF_CREATE, 320 hammer2_lnk_span_reply, NULL); 321 rmsg->any.lnk_span.peer_id = ripdata->meta.pfs_clid; 322 rmsg->any.lnk_span.pfs_id = ripdata->meta.pfs_fsid; 323 rmsg->any.lnk_span.pfs_type = ripdata->meta.pfs_type; 324 rmsg->any.lnk_span.peer_type = DMSG_PEER_HAMMER2; 325 rmsg->any.lnk_span.proto_version = DMSG_SPAN_PROTO_1; 326 name_len = ripdata->meta.name_len; 327 if (name_len >= sizeof(rmsg->any.lnk_span.peer_label)) 328 name_len = sizeof(rmsg->any.lnk_span.peer_label) - 1; 329 bcopy(ripdata->filename, 330 rmsg->any.lnk_span.peer_label, 331 name_len); 332 333 kdmsg_msg_write(rmsg); 334 335 chain = hammer2_chain_next(&parent, chain, &key_next, 336 key_next, HAMMER2_KEY_MAX, 337 &cache_index, 338 0); 339 } 340 hammer2_inode_unlock(spmp->iroot); 341 done: 342 if (chain) { 343 hammer2_chain_unlock(chain); 344 hammer2_chain_drop(chain); 345 } 346 if (parent) { 347 hammer2_chain_unlock(parent); 348 hammer2_chain_drop(parent); 349 } 350 } 351 352 static 353 int 354 hammer2_lnk_span_reply(kdmsg_state_t *state, kdmsg_msg_t *msg) 355 { 356 if ((state->txcmd & DMSGF_DELETE) == 0 && 357 (msg->any.head.cmd & DMSGF_DELETE)) { 358 kdmsg_msg_reply(msg, 0); 359 } 360 return 0; 361 } 362 363 /* 364 * Volume configuration updates are passed onto the userland service 365 * daemon via the open LNK_CONN transaction. 366 */ 367 void 368 hammer2_volconf_update(hammer2_dev_t *hmp, int index) 369 { 370 kdmsg_msg_t *msg; 371 372 /* XXX interlock against connection state termination */ 373 kprintf("volconf update %p\n", hmp->iocom.conn_state); 374 if (hmp->iocom.conn_state) { 375 kprintf("TRANSMIT VOLCONF VIA OPEN CONN TRANSACTION\n"); 376 msg = kdmsg_msg_alloc(hmp->iocom.conn_state, 377 DMSG_LNK_HAMMER2_VOLCONF, 378 NULL, NULL); 379 H2_LNK_VOLCONF(msg)->copy = hmp->voldata.copyinfo[index]; 380 H2_LNK_VOLCONF(msg)->mediaid = hmp->voldata.fsid; 381 H2_LNK_VOLCONF(msg)->index = index; 382 kdmsg_msg_write(msg); 383 } 384 } 385