2 * Copyright (c) 2011-2014 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@dragonflybsd.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 #ifndef _SYS_MALLOC_H_
39 #include <sys/malloc.h>
44 #ifndef _SYS_THREAD_H_
45 #include <sys/thread.h>
52 * Mesh network protocol structures.
56 * The mesh is constructed via point-to-point streaming links with varying
57 * levels of interconnectedness, forming a graph. Leafs of the graph are
58 * typically kernel devices (xdisk) or VFSs (HAMMER2). Internal nodes are
59 * usually (user level) hammer2 service demons.
61 * Upon connecting and after authentication, a LNK_CONN transaction is opened
62 * to configure the link. The SPAN protocol is then typically run over the
63 * open LNK_CONN transaction.
65 * Terminating the LNK_CONN transaction terminates everything running over it
66 * (typically open LNK_SPAN transactions), which in turn terminates everything
67 * running over the LNK_SPANs.
71 * The SPAN protocol runs over an open LNK_CONN transaction and is used to
72 * advertise any number of services. For example, each PFS under a HAMMER2
73 * mount will be advertised as an open LNK_SPAN transaction.
75 * Any network node on the graph running multiple connections is capable
76 * of relaying LNK_SPANs from any connection to any other connection. This
77 * is typically done by the user-level hammer2 service demon, and typically
78 * not done by kernel devices or VFSs (though these entities must be able
79 * to manage multiple LNK_SPANs since they might advertise or need to talk
80 * to multiple services).
82 * Relaying is not necessarily trivial as it requires internal nodes to
83 * track two open transactions (on the two iocom interfaces) and translate
84 * the msgid and circuit. In addition, the relay may have to track multiple
85 * SPANs from the same iocom or from multiple iocoms which represent the same
86 * end-point and must select the best end-point, must send notifications when
87 * a better path is available, and must allow (when connectivity is still
88 * present) any existing, open, stacked sub-transactions to complete before
89 * terminating the less efficient SPAN.
91 * Relaying is optional. It is perfectly acceptable for the hammer2 service
92 * to plug a received socket descriptor directly into the appropriate kernel
95 * STACKED TRANSACTIONS
97 * Message transactions can be stacked. That is, you can initiate a DMSG
98 * transaction relative to another open transaction. sub-transactions can
99 * be initiate without waiting for the parent transaction to complete its
102 * This is done by entering the open transaction's msgid as the circuit field
103 * in the new transaction (typically by populating msg->parent). The
104 * transaction tracking structure will be referenced and will track the
105 * sub-transaction. Note that msgids must still be unique on an
106 * iocom-by-iocom basis.
108 * MESSAGE TRANSACTIONAL STATES
110 * Message transactions are handled by the CREATE, DELETE, REPLY, ABORT, and
111 * CREPLY flags. Message state is typically recorded at the end points and
112 * will be maintained (preventing reuse of the transaction id) until a DELETE
113 * is both sent and received.
115 * One-way messages such as those used for debug commands are not recorded
116 * and do not require any transactional state. These are sent without
117 * the CREATE, DELETE, or ABORT flags set. ABORT is not supported for
118 * one-off messages. The REPLY bit can be used to distinguish between
119 * command and status if desired.
121 * Transactional messages are messages which require a reply to be
122 * returned. These messages can also consist of multiple message elements
123 * for the command or reply or both (or neither). The command message
124 * sequence sets CREATE on the first message and DELETE on the last message.
125 * A single message command sets both (CREATE|DELETE). The reply message
126 * sequence works the same way but of course also sets the REPLY bit.
128 * Tansactional messages can be aborted by sending a message element
129 * with the ABORT flag set. This flag can be combined with either or both
130 * the CREATE and DELETE flags. When combined with the CREATE flag the
131 * command is treated as non-blocking but still executes. Whem combined
132 * with the DELETE flag no additional message elements are required.
134 * Transactions are terminated by sending a message with DELETE set.
135 * Transactions must be CREATEd and DELETEd in both directions. If a
136 * transaction is governing stacked sub-transactions the sub-transactions
137 * are automatically terminated before the governing transaction is terminated.
138 * Terminates are handled by simulating a received DELETE and expecting the
139 * normal function callback and state machine to (ultimately) issue a
140 * terminating (DELETE) response.
142 * Transactions can operate in full-duplex as both sides are fully open
143 * (i.e. CREATE sent, CREATE|REPLY returned, DELETE not sent by anyone).
144 * Additional commands can be initiated from either side of the transaction.
146 * ABORT SPECIAL CASE - Mid-stream aborts. A mid-stream abort can be sent
147 * when supported by the sender by sending an ABORT message with neither
148 * CREATE or DELETE set. This effectively turns the message into a
149 * non-blocking message (but depending on what is being represented can also
150 * cut short prior data elements in the stream).
152 * ABORT SPECIAL CASE - Abort-after-DELETE. Transactional messages have to be
153 * abortable if the stream/pipe/whatever is lost. In this situation any
154 * forwarding relay needs to unconditionally abort commands and replies that
155 * are still active. This is done by sending an ABORT|DELETE even in
156 * situations where a DELETE has already been sent in that direction. This
157 * is done, for example, when links are in a half-closed state. In this
158 * situation it is possible for the abort request to race a transition to the
159 * fully closed state. ABORT|DELETE messages which race the fully closed
160 * state are expected to be discarded by the other end.
164 * All base and extended message headers are 64-byte aligned, and all
165 * transports must support extended message headers up to DMSG_HDR_MAX.
166 * Currently we allow extended message headers up to 2048 bytes. Note
167 * that the extended header size is encoded in the 'cmd' field of the header.
169 * Any in-band data is padded to a 64-byte alignment and placed directly
170 * after the extended header (after the higher-level cmd/rep structure).
171 * The actual unaligned size of the in-band data is encoded in the aux_bytes
172 * field in this case. Maximum data sizes are negotiated during registration.
174 * Auxillary data can be in-band or out-of-band. In-band data sets aux_descr
175 * equal to 0. Any out-of-band data must be negotiated by the SPAN protocol.
177 * Auxillary data, whether in-band or out-of-band, must be at-least 64-byte
178 * aligned. The aux_bytes field contains the actual byte-granular length
179 * and not the aligned length. The crc is against the aligned length (so
180 * a faster crc algorithm can be used, theoretically).
182 * hdr_crc is calculated over the entire, ALIGNED extended header. For
183 * the purposes of calculating the crc, the hdr_crc field is 0. That is,
184 * if calculating the crc in HW a 32-bit '0' must be inserted in place of
185 * the hdr_crc field when reading the entire header and compared at the
186 * end (but the actual hdr_crc must be left intact in memory). A simple
187 * counter to replace the field going into the CRC generator does the job
188 * in HW. The CRC endian is based on the magic number field and may have
189 * to be byte-swapped, too (which is also easy to do in HW).
191 * aux_crc is calculated over the entire, ALIGNED auxillary data.
193 * SHARED MEMORY IMPLEMENTATIONS
195 * Shared-memory implementations typically use a pipe to transmit the extended
196 * message header and shared memory to store any auxilary data. Auxillary
197 * data in one-way (non-transactional) messages is typically required to be
198 * inline. CRCs are still recommended and required at the beginning, but
199 * may be negotiated away later.
203 * dmsg_hdr must be 64 bytes
206 uint16_t magic; /* 00 sanity, synchro, endian */
207 uint16_t reserved02; /* 02 */
208 uint32_t salt; /* 04 random salt helps w/crypto */
210 uint64_t msgid; /* 08 message transaction id */
211 uint64_t circuit; /* 10 circuit id or 0 */
212 uint64_t reserved18; /* 18 */
214 uint32_t cmd; /* 20 flags | cmd | hdr_size / ALIGN */
215 uint32_t aux_crc; /* 24 auxillary data crc */
216 uint32_t aux_bytes; /* 28 auxillary data length (bytes) */
217 uint32_t error; /* 2C error code or 0 */
218 uint64_t aux_descr; /* 30 negotiated OOB data descr */
219 uint32_t reserved38; /* 38 */
220 uint32_t hdr_crc; /* 3C (aligned) extended header crc */
223 typedef struct dmsg_hdr dmsg_hdr_t;
225 #define DMSG_HDR_MAGIC 0x4832
226 #define DMSG_HDR_MAGIC_REV 0x3248
227 #define DMSG_HDR_CRCOFF offsetof(dmsg_hdr_t, salt)
228 #define DMSG_HDR_CRCBYTES (sizeof(dmsg_hdr_t) - DMSG_HDR_CRCOFF)
231 * Administrative protocol limits.
233 * NOTE: A dmsg header must completely fit in the (fifo) buffer, but
234 * dmsg aux data does not have to completely fit. The dmsg
235 * structure allows headers up to 255*64 = 16320 bytes. There
236 * is no real limit on the aux_data other than what we deem
237 * reasonable and defenseable (i.e. not run processes or the
238 * kernel out of memory). But it should be able to handle at
239 * least MAXPHYS bytes which is typically 128KB or 256KB.
241 #define DMSG_HDR_MAX 2048 /* <= 8192 */
242 #define DMSG_AUX_MAX (1024*1024) /* <= 1MB */
243 #define DMSG_BUF_SIZE (DMSG_HDR_MAX * 4)
244 #define DMSG_BUF_MASK (DMSG_BUF_SIZE - 1)
247 * The message (cmd) field also encodes various flags and the total size
248 * of the message header. This allows the protocol processors to validate
249 * persistency and structural settings for every command simply by
250 * switch()ing on the (cmd) field.
252 #define DMSGF_CREATE 0x80000000U /* msg start */
253 #define DMSGF_DELETE 0x40000000U /* msg end */
254 #define DMSGF_REPLY 0x20000000U /* reply path */
255 #define DMSGF_ABORT 0x10000000U /* abort req */
256 #define DMSGF_REVTRANS 0x08000000U /* opposite direction msgid */
257 #define DMSGF_REVCIRC 0x04000000U /* opposite direction circuit */
258 #define DMSGF_FLAG1 0x02000000U
259 #define DMSGF_FLAG0 0x01000000U
261 #define DMSGF_FLAGS 0xFF000000U /* all flags */
262 #define DMSGF_PROTOS 0x00F00000U /* all protos */
263 #define DMSGF_CMDS 0x000FFF00U /* all cmds */
264 #define DMSGF_SIZE 0x000000FFU /* N*32 */
267 * XXX Future, flag that an in-line (not part of a CREATE/DELETE) command
268 * expects some sort of acknowledgement. Allows protocol mismatches to
271 #define DMSGF_CMDF_EXPECT_ACK 0x00080000U /* in-line command no-ack */
273 #define DMSGF_CMDSWMASK (DMSGF_CMDS | \
278 #define DMSGF_BASECMDMASK (DMSGF_CMDS | \
282 #define DMSGF_TRANSMASK (DMSGF_CMDS | \
289 #define DMSGF_BASEFLAGS (DMSGF_CREATE | DMSGF_DELETE | DMSGF_REPLY)
291 #define DMSG_PROTO_LNK 0x00000000U
292 #define DMSG_PROTO_DBG 0x00100000U
293 #define DMSG_PROTO_HM2 0x00200000U
294 #define DMSG_PROTO_XX3 0x00300000U
295 #define DMSG_PROTO_XX4 0x00400000U
296 #define DMSG_PROTO_BLK 0x00500000U
297 #define DMSG_PROTO_VOP 0x00600000U
300 * Message command constructors, sans flags
302 #define DMSG_ALIGN 64
303 #define DMSG_ALIGNMASK (DMSG_ALIGN - 1)
304 #define DMSG_DOALIGN(bytes) (((bytes) + DMSG_ALIGNMASK) & \
307 #define DMSG_HDR_ENCODE(elm) (((uint32_t)sizeof(struct elm) + \
311 #define DMSG_LNK(cmd, elm) (DMSG_PROTO_LNK | \
313 DMSG_HDR_ENCODE(elm))
315 #define DMSG_DBG(cmd, elm) (DMSG_PROTO_DBG | \
317 DMSG_HDR_ENCODE(elm))
319 #define DMSG_HM2(cmd, elm) (DMSG_PROTO_HM2 | \
321 DMSG_HDR_ENCODE(elm))
323 #define DMSG_BLK(cmd, elm) (DMSG_PROTO_BLK | \
325 DMSG_HDR_ENCODE(elm))
327 #define DMSG_VOP(cmd, elm) (DMSG_PROTO_VOP | \
329 DMSG_HDR_ENCODE(elm))
332 * Link layer ops basically talk to just the other side of a direct
335 * LNK_PAD - One-way message on circuit 0, ignored by target. Used to
336 * pad message buffers on shared-memory transports. Not
337 * typically used with TCP.
339 * LNK_PING - One-way message on circuit-0, keep-alive, run by both sides
340 * typically 1/sec on idle link, link is lost after 10 seconds
343 * LNK_AUTH - Authenticate the connection, negotiate administrative
344 * rights & encryption, protocol class, etc. Only PAD and
345 * AUTH messages (not even PING) are accepted until
346 * authentication is complete. This message also identifies
349 * LNK_CONN - Enable the SPAN protocol on circuit-0, possibly also
350 * installing a PFS filter (by cluster id, unique id, and/or
353 * LNK_SPAN - A SPAN transaction typically on iocom->state0 enables
354 * messages to be relayed to/from a particular cluster node.
355 * SPANs are received, sorted, aggregated, filtered, and
356 * retransmitted back out across all applicable connections.
358 * The leaf protocol also uses this to make a PFS available
359 * to the cluster (e.g. on-mount).
361 #define DMSG_LNK_PAD DMSG_LNK(0x000, dmsg_hdr)
362 #define DMSG_LNK_PING DMSG_LNK(0x001, dmsg_hdr)
363 #define DMSG_LNK_AUTH DMSG_LNK(0x010, dmsg_lnk_auth)
364 #define DMSG_LNK_CONN DMSG_LNK(0x011, dmsg_lnk_conn)
365 #define DMSG_LNK_SPAN DMSG_LNK(0x012, dmsg_lnk_span)
366 #define DMSG_LNK_ERROR DMSG_LNK(0xFFF, dmsg_hdr)
369 * Reserved command codes for third party subsystems. Structure size is
370 * not known here so do not try to construct the full DMSG_LNK_ define.
372 #define DMSG_LNK_CMD_HAMMER2_VOLCONF 0x20
374 #define DMSG_LABEL_SIZE 128 /* fixed at 128, do not change */
377 * LNK_AUTH - Authentication (often omitted)
379 struct dmsg_lnk_auth {
385 * LNK_CONN - Register connection info for SPAN protocol
386 * (transaction, left open, iocom->state0 only).
388 * LNK_CONN identifies a streaming connection into the cluster and serves
389 * to identify, enable, and specify filters for the SPAN protocol.
391 * peer_mask serves to filter the SPANs we receive by peer_type. A cluster
392 * controller typically sets this to (uint64_t)-1, indicating that it wants
393 * everything. A block devfs interface might set it to 1 << DMSG_PEER_DISK,
394 * and a hammer2 mount might set it to 1 << DMSG_PEER_HAMMER2.
396 * mediaid allows multiple (e.g. HAMMER2) connections belonging to the same
397 * media to transmit duplicative LNK_VOLCONF updates without causing
398 * confusion in the cluster controller.
400 * pfs_clid, pfs_fsid, pfs_type, and label are peer-specific and must be
401 * left empty (zero-fill) if not supported by a particular peer.
403 * DMSG_PEER_CLUSTER filter: none
404 * DMSG_PEER_BLOCK filter: label
405 * DMSG_PEER_HAMMER2 filter: pfs_clid if not empty, and label
407 struct dmsg_lnk_conn {
409 uuid_t mediaid; /* media configuration id */
410 uuid_t pfs_clid; /* rendezvous pfs uuid */
411 uuid_t pfs_fsid; /* unique pfs uuid */
412 uint64_t peer_mask; /* PEER mask for SPAN filtering */
413 uint8_t peer_type; /* see DMSG_PEER_xxx */
414 uint8_t pfs_type; /* pfs type */
415 uint16_t proto_version; /* high level protocol support */
416 uint32_t status; /* status flags */
417 uint32_t rnss; /* node's generated rnss */
418 uint8_t reserved02[8];
419 uint32_t reserved03[12];
420 uint64_t pfs_mask; /* PFS mask for SPAN filtering */
421 char cl_label[DMSG_LABEL_SIZE]; /* cluster label */
422 char fs_label[DMSG_LABEL_SIZE]; /* PFS label */
425 typedef struct dmsg_lnk_conn dmsg_lnk_conn_t;
428 * PFSTYPEs 0-15 used by sys/dmsg.h 16-31 reserved by hammer2.
430 #define DMSG_PFSTYPE_NONE 0
431 #define DMSG_PFSTYPE_ADMIN 1
432 #define DMSG_PFSTYPE_CLIENT 2
433 #define DMSG_PFSTYPE_SERVER 3
434 #define DMSG_PFSTYPE_MAX 32
436 #define DMSG_PEER_NONE 0
437 #define DMSG_PEER_CLUSTER 1 /* a cluster controller */
438 #define DMSG_PEER_BLOCK 2 /* block devices */
439 #define DMSG_PEER_HAMMER2 3 /* hammer2-mounted volumes */
442 * Structures embedded in LNK_SPAN
444 struct dmsg_media_block {
445 uint64_t bytes; /* media size in bytes */
446 uint32_t blksize; /* media block size */
449 typedef struct dmsg_media_block dmsg_media_block_t;
452 * LNK_SPAN - Initiate or relay a SPAN
453 * (transaction, left open, typically only on iocom->state0)
455 * This message registers an end-point with the other end of the connection,
456 * telling the other end who we are and what we can provide or intend to
457 * consume. Multiple registrations can be maintained as open transactions
458 * with each one specifying a unique end-point.
460 * Registrations are sent from {source}=S {1...n} to {target}=0 and maintained
461 * as open transactions. Registrations are also received and maintains as
462 * open transactions, creating a matrix of linkid's.
464 * While these transactions are open additional transactions can be executed
465 * between any two linkid's {source}=S (registrations we sent) to {target}=T
466 * (registrations we received).
468 * Closure of any registration transaction will automatically abort any open
469 * transactions using the related linkids. Closure can be initiated
470 * voluntarily from either side with either end issuing a DELETE, or they
473 * Status updates are performed via the open transaction.
477 * A registration identifies a node and its various PFS parameters including
478 * the PFS_TYPE. For example, a diskless HAMMER2 client typically identifies
479 * itself as PFSTYPE_CLIENT.
481 * Any node may serve as a cluster controller, aggregating and passing
482 * on received registrations, but end-points do not have to implement this
483 * ability. Most end-points typically implement a single client-style or
484 * server-style PFS_TYPE and rendezvous at a cluster controller.
486 * The cluster controller does not aggregate/pass-on all received
487 * registrations. It typically filters what gets passed on based on what it
488 * receives, passing on only the best candidates.
490 * If a symmetric spanning tree is desired additional candidates whos
491 * {dist, rnss} fields match the last best candidate must also be propagated.
492 * This feature is not currently enabled.
494 * STATUS UPDATES: Status updates use the same structure but typically
495 * only contain incremental changes to e.g. pfs_type, with
496 * a text description sent as out-of-band data.
498 struct dmsg_lnk_span {
500 uuid_t pfs_clid; /* rendezvous pfs uuid */
501 uuid_t pfs_fsid; /* unique pfs id (differentiate node) */
502 uint8_t pfs_type; /* PFS type */
503 uint8_t peer_type; /* PEER type */
504 uint16_t proto_version; /* high level protocol support */
505 uint32_t status; /* status flags */
506 uint8_t reserved02[8];
507 uint32_t dist; /* span distance */
508 uint32_t rnss; /* random number sub-sort */
510 uint32_t reserved03[14];
511 dmsg_media_block_t block;
515 * NOTE: for PEER_HAMMER2 cl_label is typically empty and fs_label
516 * is the superroot directory name.
518 * for PEER_BLOCK cl_label is typically host/device and
519 * fs_label is typically the serial number string.
521 char cl_label[DMSG_LABEL_SIZE]; /* cluster label */
522 char fs_label[DMSG_LABEL_SIZE]; /* PFS label */
525 typedef struct dmsg_lnk_span dmsg_lnk_span_t;
527 #define DMSG_SPAN_PROTO_1 1
530 * Debug layer ops operate on any link
532 * SHELL - Persist stream, access the debug shell on the target
533 * registration. Multiple shells can be operational.
535 #define DMSG_DBG_SHELL DMSG_DBG(0x001, dmsg_dbg_shell)
537 struct dmsg_dbg_shell {
540 typedef struct dmsg_dbg_shell dmsg_dbg_shell_t;
543 * Hammer2 layer ops (low-level chain manipulation used by cluster code)
545 * HM2_OPENPFS - Attach a PFS
546 * HM2_FLUSHPFS - Flush a PFS
548 * HM2_LOOKUP - Lookup chain (parent-relative transaction)
549 * (can request multiple chains)
550 * HM2_NEXT - Lookup next chain (parent-relative transaction)
551 * (can request multiple chains)
552 * HM2_LOCK - [Re]lock a chain (chain-relative) (non-recursive)
553 * HM2_UNLOCK - Unlock a chain (chain-relative) (non-recursive)
554 * HM2_RESIZE - Resize a chain (chain-relative)
555 * HM2_MODIFY - Modify a chain (chain-relative)
556 * HM2_CREATE - Create a chain (parent-relative)
557 * HM2_DUPLICATE- Duplicate a chain (target-parent-relative)
558 * HM2_DELDUP - Delete-Duplicate a chain (chain-relative)
559 * HM2_DELETE - Delete a chain (chain-relative)
560 * HM2_SNAPSHOT - Create a snapshot (snapshot-root-relative, w/clid override)
562 #define DMSG_HM2_OPENPFS DMSG_HM2(0x001, dmsg_hm2_openpfs)
565 * DMSG_PROTO_BLK Protocol
567 * BLK_OPEN - Open device. This transaction must be left open for the
568 * duration and the returned keyid passed in all associated
569 * BLK commands. Multiple OPENs can be issued within the
572 * BLK_CLOSE - Close device. This can be used to close one of the opens
573 * within a BLK_OPEN transaction. It may NOT initiate a
574 * transaction. Note that a termination of the transaction
575 * (e.g. with LNK_ERROR or BLK_ERROR) closes all active OPENs
576 * for that transaction. XXX not well defined atm.
578 * BLK_READ - Strategy read. Not typically streaming.
580 * BLK_WRITE - Strategy write. Not typically streaming.
582 * BLK_FLUSH - Strategy flush. Not typically streaming.
584 * BLK_FREEBLKS - Strategy freeblks. Not typically streaming.
586 #define DMSG_BLK_OPEN DMSG_BLK(0x001, dmsg_blk_open)
587 #define DMSG_BLK_CLOSE DMSG_BLK(0x002, dmsg_blk_open)
588 #define DMSG_BLK_READ DMSG_BLK(0x003, dmsg_blk_read)
589 #define DMSG_BLK_WRITE DMSG_BLK(0x004, dmsg_blk_write)
590 #define DMSG_BLK_FLUSH DMSG_BLK(0x005, dmsg_blk_flush)
591 #define DMSG_BLK_FREEBLKS DMSG_BLK(0x006, dmsg_blk_freeblks)
592 #define DMSG_BLK_ERROR DMSG_BLK(0xFFF, dmsg_blk_error)
594 struct dmsg_blk_open {
600 #define DMSG_BLKOPEN_RD 0x0001
601 #define DMSG_BLKOPEN_WR 0x0002
604 * DMSG_LNK_ERROR is returned for simple results,
605 * DMSG_BLK_ERROR is returned for extended results.
607 struct dmsg_blk_error {
615 struct dmsg_blk_read {
625 struct dmsg_blk_write {
635 struct dmsg_blk_flush {
645 struct dmsg_blk_freeblks {
655 typedef struct dmsg_blk_open dmsg_blk_open_t;
656 typedef struct dmsg_blk_read dmsg_blk_read_t;
657 typedef struct dmsg_blk_write dmsg_blk_write_t;
658 typedef struct dmsg_blk_flush dmsg_blk_flush_t;
659 typedef struct dmsg_blk_freeblks dmsg_blk_freeblks_t;
660 typedef struct dmsg_blk_error dmsg_blk_error_t;
663 * NOTE!!!! ALL EXTENDED HEADER STRUCTURES MUST BE 64-BYTE ALIGNED!!!
665 * General message errors
667 * 0x00 - 0x1F Local iocomm errors
668 * 0x20 - 0x2F Global errors
670 #define DMSG_ERR_NOSUPP 0x20
671 #define DMSG_ERR_LOSTLINK 0x21
672 #define DMSG_ERR_IO 0x22 /* generic */
673 #define DMSG_ERR_PARAM 0x23 /* generic */
674 #define DMSG_ERR_CANTCIRC 0x24 /* (typically means lost span) */
677 char buf[DMSG_HDR_MAX];
680 dmsg_lnk_conn_t lnk_conn;
681 dmsg_lnk_span_t lnk_span;
683 dmsg_blk_open_t blk_open;
684 dmsg_blk_error_t blk_error;
685 dmsg_blk_read_t blk_read;
686 dmsg_blk_write_t blk_write;
687 dmsg_blk_flush_t blk_flush;
688 dmsg_blk_freeblks_t blk_freeblks;
691 typedef union dmsg_any dmsg_any_t;
694 * Kernel iocom structures and prototypes for kern/kern_dmsg.c
696 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
698 struct hammer2_mount;
706 * msg_ctl flags (atomic)
708 #define KDMSG_CLUSTERCTL_UNUSED01 0x00000001
709 #define KDMSG_CLUSTERCTL_KILLRX 0x00000002 /* staged helper exit */
710 #define KDMSG_CLUSTERCTL_KILLTX 0x00000004 /* staged helper exit */
711 #define KDMSG_CLUSTERCTL_SLEEPING 0x00000008 /* interlocked w/msglk */
714 * Transactional state structure, representing an open transaction. The
715 * transaction might represent a cache state (and thus have a chain
716 * association), or a VOP op, LNK_SPAN, or other things.
718 TAILQ_HEAD(kdmsg_state_list, kdmsg_state);
721 RB_ENTRY(kdmsg_state) rbnode; /* indexed by msgid */
722 struct kdmsg_state_list subq; /* active stacked states */
723 TAILQ_ENTRY(kdmsg_state) entry; /* on parent subq */
724 TAILQ_ENTRY(kdmsg_state) user_entry; /* available to devices */
725 struct kdmsg_iocom *iocom;
726 struct kdmsg_state *parent;
727 uint32_t icmd; /* record cmd creating state */
728 uint32_t txcmd; /* mostly for CMDF flags */
729 uint32_t rxcmd; /* mostly for CMDF flags */
730 uint64_t msgid; /* {parent,msgid} uniq */
733 void *chain; /* (caller's state) */
734 int (*func)(struct kdmsg_state *, struct kdmsg_msg *);
737 struct hammer2_mount *hmp;
738 struct xa_softc *xa_sc;
742 #define KDMSG_STATE_INSERTED 0x0001
743 #define KDMSG_STATE_DYNAMIC 0x0002
744 #define KDMSG_STATE_DELPEND 0x0004 /* transmit delete pending */
745 #define KDMSG_STATE_ABORTING 0x0008 /* avoids recursive abort */
746 #define KDMSG_STATE_OPPOSITE 0x0010 /* opposite direction */
747 #define KDMSG_STATE_DYING 0x0020 /* indicates circuit failure */
748 #define KDMSG_STATE_INTERLOCK 0x0040
749 #define KDMSG_STATE_SIGNAL 0x0080
752 TAILQ_ENTRY(kdmsg_msg) qentry; /* serialized queue */
753 struct kdmsg_state *state;
758 uint32_t tcmd; /* outer transaction cmd */
759 dmsg_any_t any; /* variable sized */
765 struct kdmsg_iocom *iocom;
768 #define KDMSG_FLAG_AUXALLOC 0x0001
770 typedef struct kdmsg_link kdmsg_link_t;
771 typedef struct kdmsg_state kdmsg_state_t;
772 typedef struct kdmsg_msg kdmsg_msg_t;
773 typedef struct kdmsg_data kdmsg_data_t;
775 struct kdmsg_state_tree;
776 int kdmsg_state_cmp(kdmsg_state_t *state1, kdmsg_state_t *state2);
777 RB_HEAD(kdmsg_state_tree, kdmsg_state);
778 RB_PROTOTYPE(kdmsg_state_tree, kdmsg_state, rbnode, kdmsg_state_cmp);
781 * Structure embedded in e.g. mount, master control structure for
782 * DMSG stream handling.
785 struct malloc_type *mmsg;
786 struct file *msg_fp; /* cluster pipe->userland */
787 thread_t msgrd_td; /* cluster thread */
788 thread_t msgwr_td; /* cluster thread */
789 int msg_ctl; /* wakeup flags */
790 int msg_seq; /* cluster msg sequence id */
792 struct lock msglk; /* lockmgr lock */
793 TAILQ_HEAD(, kdmsg_msg) msgq; /* transmit queue */
795 void (*auto_callback)(kdmsg_msg_t *);
796 int (*rcvmsg)(kdmsg_msg_t *);
797 void (*exit_func)(struct kdmsg_iocom *);
798 struct kdmsg_state state0; /* root state for stacking */
799 struct kdmsg_state *conn_state; /* active LNK_CONN state */
800 struct kdmsg_state *freerd_state; /* allocation cache */
801 struct kdmsg_state *freewr_state; /* allocation cache */
802 struct kdmsg_state_tree staterd_tree; /* active messages */
803 struct kdmsg_state_tree statewr_tree; /* active messages */
804 dmsg_lnk_conn_t auto_lnk_conn;
805 dmsg_lnk_span_t auto_lnk_span;
808 typedef struct kdmsg_iocom kdmsg_iocom_t;
810 #define KDMSG_IOCOMF_AUTOCONN 0x0001 /* handle RX/TX LNK_CONN */
811 #define KDMSG_IOCOMF_AUTORXSPAN 0x0002 /* handle RX LNK_SPAN */
812 #define KDMSG_IOCOMF_AUTOTXSPAN 0x0008 /* handle TX LNK_SPAN */
813 #define KDMSG_IOCOMF_EXITNOACC 0x8000 /* cannot accept writes */
815 #define KDMSG_IOCOMF_AUTOANY (KDMSG_IOCOMF_AUTOCONN | \
816 KDMSG_IOCOMF_AUTORXSPAN | \
817 KDMSG_IOCOMF_AUTOTXSPAN)
819 uint32_t kdmsg_icrc32(const void *buf, size_t size);
820 uint32_t kdmsg_icrc32c(const void *buf, size_t size, uint32_t crc);
825 void kdmsg_iocom_init(kdmsg_iocom_t *iocom, void *handle, u_int32_t flags,
826 struct malloc_type *mmsg,
827 int (*rcvmsg)(kdmsg_msg_t *msg));
828 void kdmsg_iocom_reconnect(kdmsg_iocom_t *iocom, struct file *fp,
829 const char *subsysname);
830 void kdmsg_iocom_autoinitiate(kdmsg_iocom_t *iocom,
831 void (*conn_callback)(kdmsg_msg_t *msg));
832 void kdmsg_iocom_uninit(kdmsg_iocom_t *iocom);
833 void kdmsg_drain_msgq(kdmsg_iocom_t *iocom);
835 void kdmsg_msg_free(kdmsg_msg_t *msg);
836 kdmsg_msg_t *kdmsg_msg_alloc(kdmsg_state_t *state, uint32_t cmd,
837 int (*func)(kdmsg_state_t *, kdmsg_msg_t *),
839 void kdmsg_msg_write(kdmsg_msg_t *msg);
840 void kdmsg_msg_reply(kdmsg_msg_t *msg, uint32_t error);
841 void kdmsg_msg_result(kdmsg_msg_t *msg, uint32_t error);
842 void kdmsg_state_reply(kdmsg_state_t *state, uint32_t error);
843 void kdmsg_state_result(kdmsg_state_t *state, uint32_t error);
844 void kdmsg_detach_aux_data(kdmsg_msg_t *msg, kdmsg_data_t *data);
845 void kdmsg_free_aux_data(kdmsg_data_t *data);