2c6bfff441efedeae786a666062821d1da64ec2a
[dragonfly.git] / sys / kern / subr_diskiocom.c
1 /*
2  * Copyright (c) 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@backplane.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
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
16  *    distribution.
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.
20  *
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
32  * SUCH DAMAGE.
33  */
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/proc.h>
38 #include <sys/sysctl.h>
39 #include <sys/buf.h>
40 #include <sys/conf.h>
41 #include <sys/disklabel.h>
42 #include <sys/disklabel32.h>
43 #include <sys/disklabel64.h>
44 #include <sys/diskslice.h>
45 #include <sys/diskmbr.h>
46 #include <sys/disk.h>
47 #include <sys/malloc.h>
48 #include <sys/device.h>
49 #include <sys/devfs.h>
50 #include <sys/thread.h>
51 #include <sys/queue.h>
52 #include <sys/lock.h>
53 #include <sys/uuid.h>
54
55 #include <sys/dmsg.h>
56
57 #include <sys/buf2.h>
58 #include <sys/mplock2.h>
59 #include <sys/msgport2.h>
60 #include <sys/thread2.h>
61
62 static MALLOC_DEFINE(M_DMSG_DISK, "dmsg_disk", "disk dmsg");
63
64 static int disk_iocom_reconnect(struct disk *dp, struct file *fp);
65 static int disk_msg_conn_reply(kdmsg_state_t *state, kdmsg_msg_t *msg);
66 static int disk_msg_span_reply(kdmsg_state_t *state, kdmsg_msg_t *msg);
67
68 void
69 disk_iocom_init(struct disk *dp)
70 {
71         kdmsg_iocom_init(&dp->d_iocom, dp, M_DMSG_DISK,
72                          disk_lnk_rcvmsg,
73                          disk_dbg_rcvmsg,
74                          disk_adhoc_input);
75 }
76
77 void
78 disk_iocom_update(struct disk *dp)
79 {
80 }
81
82 void
83 disk_iocom_uninit(struct disk *dp)
84 {
85         kdmsg_iocom_uninit(&dp->d_iocom);
86 }
87
88 int
89 disk_iocom_ioctl(struct disk *dp, int cmd, void *data)
90 {
91         struct file *fp;
92         struct disk_ioc_recluster *recl;
93         int error;
94
95         switch(cmd) {
96         case DIOCRECLUSTER:
97                 recl = data;
98                 fp = holdfp(curproc->p_fd, recl->fd, -1);
99                 if (fp) {
100                         error = disk_iocom_reconnect(dp, fp);
101                 } else {
102                         error = EINVAL;
103                 }
104                 break;
105         default:
106                 error = EOPNOTSUPP;
107                 break;
108         }
109         return error;
110 }
111
112 static
113 int
114 disk_iocom_reconnect(struct disk *dp, struct file *fp)
115 {
116         kdmsg_msg_t *msg;
117         char devname[64];
118
119         ksnprintf(devname, sizeof(devname), "%s%d",
120                   dev_dname(dp->d_rawdev), dkunit(dp->d_rawdev));
121
122         kdmsg_iocom_reconnect(&dp->d_iocom, fp, devname);
123
124         msg = kdmsg_msg_alloc(&dp->d_iocom.router, DMSG_LNK_CONN | DMSGF_CREATE,
125                               disk_msg_conn_reply, dp);
126         msg->any.lnk_conn.pfs_type = 0;
127         msg->any.lnk_conn.proto_version = DMSG_SPAN_PROTO_1;
128         msg->any.lnk_conn.peer_type = DMSG_PEER_BLOCK;
129         msg->any.lnk_conn.peer_mask = 1LLU << DMSG_PEER_BLOCK;
130
131         ksnprintf(msg->any.lnk_conn.label, sizeof(msg->any.lnk_conn.label),
132                   "%s/%s", hostname, devname);
133         dp->d_iocom.conn_state = msg->state;
134         kdmsg_msg_write(msg);
135
136         return (0);
137 }
138
139 /*
140  * Received reply to our LNK_CONN transaction, indicating LNK_SPAN support.
141  * Issue LNK_SPAN.
142  */
143 static
144 int
145 disk_msg_conn_reply(kdmsg_state_t *state, kdmsg_msg_t *msg)
146 {
147         struct disk *dp = state->any.any;
148         kdmsg_msg_t *rmsg;
149
150         if (msg->any.head.cmd & DMSGF_CREATE) {
151                 kprintf("DISK LNK_CONN received reply\n");
152                 rmsg = kdmsg_msg_alloc(&dp->d_iocom.router,
153                                        DMSG_LNK_SPAN | DMSGF_CREATE,
154                                        disk_msg_span_reply, dp);
155                 rmsg->any.lnk_span.pfs_type = 0;
156                 rmsg->any.lnk_span.proto_version = DMSG_SPAN_PROTO_1;
157                 rmsg->any.lnk_span.peer_type = DMSG_PEER_BLOCK;
158
159                 ksnprintf(rmsg->any.lnk_span.label,
160                           sizeof(rmsg->any.lnk_span.label),
161                           "%s/%s%d",
162                           hostname,
163                           dev_dname(dp->d_rawdev),
164                           dkunit(dp->d_rawdev));
165                 kdmsg_msg_write(rmsg);
166         }
167         if ((state->txcmd & DMSGF_DELETE) == 0 &&
168             (msg->any.head.cmd & DMSGF_DELETE)) {
169                 kprintf("DISK LNK_CONN terminated by remote\n");
170                 dp->d_iocom.conn_state = NULL;
171                 kdmsg_msg_reply(msg, 0);
172         }
173         return(0);
174 }
175
176 /*
177  * Reply to our LNK_SPAN.  The transaction is left open.
178  */
179 static
180 int
181 disk_msg_span_reply(kdmsg_state_t *state, kdmsg_msg_t *msg)
182 {
183         /*struct disk *dp = state->any.any;*/
184
185         kprintf("DISK LNK_SPAN reply received\n");
186         if ((state->txcmd & DMSGF_DELETE) == 0 &&
187             (msg->any.head.cmd & DMSGF_DELETE)) {
188                 kdmsg_msg_reply(msg, 0);
189         }
190         return (0);
191 }
192
193 int
194 disk_lnk_rcvmsg(kdmsg_msg_t *msg)
195 {
196         /*struct disk *dp = msg->router->iocom->handle;*/
197
198         switch(msg->any.head.cmd & DMSGF_TRANSMASK) {
199         case DMSG_LNK_CONN | DMSGF_CREATE:
200                 /*
201                  * reply & leave trans open
202                  */
203                 kprintf("DISK CONN RECEIVE - (just ignore it)\n");
204                 kdmsg_msg_result(msg, 0);
205                 break;
206         case DMSG_LNK_SPAN | DMSGF_CREATE:
207                 kprintf("DISK SPAN RECEIVE - ADDED FROM CLUSTER\n");
208                 break;
209         case DMSG_LNK_SPAN | DMSGF_DELETE:
210                 kprintf("DISK SPAN RECEIVE - DELETED FROM CLUSTER\n");
211                 break;
212         default:
213                 break;
214         }
215         return (0);
216 }
217
218 int
219 disk_dbg_rcvmsg(kdmsg_msg_t *msg)
220 {
221         /*struct disk *dp = msg->router->iocom->handle;*/
222
223         switch(msg->any.head.cmd & DMSGF_CMDSWMASK) {
224         case DMSG_DBG_SHELL:
225                 /*
226                  * Execute shell command (not supported atm)
227                  */
228                 kdmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
229                 break;
230         case DMSG_DBG_SHELL | DMSGF_REPLY:
231                 if (msg->aux_data) {
232                         msg->aux_data[msg->aux_size - 1] = 0;
233                         kprintf("DEBUGMSG: %s\n", msg->aux_data);
234                 }
235                 break;
236         default:
237                 kdmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
238                 break;
239         }
240         return (0);
241 }
242
243 int
244 disk_adhoc_input(kdmsg_msg_t *msg)
245 {
246         struct disk *dp = msg->router->iocom->handle;
247
248         kprintf("DISK ADHOC INPUT %s%d\n",
249                 dev_dname(dp->d_rawdev), dkunit(dp->d_rawdev));
250
251         return (0);
252 }