1
2
3
4
5
6
7#include <errno.h>
8#include <string.h>
9#include <unistd.h>
10#include <sys/socket.h>
11#include <sys/uio.h>
12#include <sys/un.h>
13#include "kern_constants.h"
14#include "mconsole.h"
15#include "user.h"
16
17static struct mconsole_command commands[] = {
18
19
20
21
22
23
24 { "version", mconsole_version, MCONSOLE_PROC },
25 { "halt", mconsole_halt, MCONSOLE_PROC },
26 { "reboot", mconsole_reboot, MCONSOLE_PROC },
27 { "config", mconsole_config, MCONSOLE_PROC },
28 { "remove", mconsole_remove, MCONSOLE_PROC },
29 { "sysrq", mconsole_sysrq, MCONSOLE_INTR },
30 { "help", mconsole_help, MCONSOLE_INTR },
31 { "cad", mconsole_cad, MCONSOLE_INTR },
32 { "stop", mconsole_stop, MCONSOLE_PROC },
33 { "go", mconsole_go, MCONSOLE_INTR },
34 { "log", mconsole_log, MCONSOLE_INTR },
35 { "proc", mconsole_proc, MCONSOLE_PROC },
36 { "stack", mconsole_stack, MCONSOLE_INTR },
37};
38
39
40char mconsole_socket_name[256];
41
42int mconsole_reply_v0(struct mc_request *req, char *reply)
43{
44 struct iovec iov;
45 struct msghdr msg;
46
47 iov.iov_base = reply;
48 iov.iov_len = strlen(reply);
49
50 msg.msg_name = &(req->origin);
51 msg.msg_namelen = req->originlen;
52 msg.msg_iov = &iov;
53 msg.msg_iovlen = 1;
54 msg.msg_control = NULL;
55 msg.msg_controllen = 0;
56 msg.msg_flags = 0;
57
58 return sendmsg(req->originating_fd, &msg, 0);
59}
60
61static struct mconsole_command *mconsole_parse(struct mc_request *req)
62{
63 struct mconsole_command *cmd;
64 int i;
65
66 for (i = 0; i < ARRAY_SIZE(commands); i++) {
67 cmd = &commands[i];
68 if (!strncmp(req->request.data, cmd->command,
69 strlen(cmd->command))) {
70 return cmd;
71 }
72 }
73 return NULL;
74}
75
76#define MIN(a,b) ((a)<(b) ? (a):(b))
77
78#define STRINGX(x) #x
79#define STRING(x) STRINGX(x)
80
81int mconsole_get_request(int fd, struct mc_request *req)
82{
83 int len;
84
85 req->originlen = sizeof(req->origin);
86 req->len = recvfrom(fd, &req->request, sizeof(req->request),
87 MSG_DONTWAIT, (struct sockaddr *) req->origin,
88 &req->originlen);
89 if (req->len < 0)
90 return 0;
91
92 req->originating_fd = fd;
93
94 if (req->request.magic != MCONSOLE_MAGIC) {
95
96 len = MIN(sizeof(req->request.data) - 1,
97 strlen((char *) &req->request));
98 memmove(req->request.data, &req->request, len);
99 req->request.data[len] = '\0';
100
101 req->request.magic = MCONSOLE_MAGIC;
102 req->request.version = 0;
103 req->request.len = len;
104
105 mconsole_reply_v0(req, "ERR Version 0 mconsole clients are "
106 "not supported by this driver");
107 return 0;
108 }
109
110 if (req->request.len >= MCONSOLE_MAX_DATA) {
111 mconsole_reply(req, "Request too large", 1, 0);
112 return 0;
113 }
114 if (req->request.version != MCONSOLE_VERSION) {
115 mconsole_reply(req, "This driver only supports version "
116 STRING(MCONSOLE_VERSION) " clients", 1, 0);
117 }
118
119 req->request.data[req->request.len] = '\0';
120 req->cmd = mconsole_parse(req);
121 if (req->cmd == NULL) {
122 mconsole_reply(req, "Unknown command", 1, 0);
123 return 0;
124 }
125
126 return 1;
127}
128
129int mconsole_reply_len(struct mc_request *req, const char *str, int total,
130 int err, int more)
131{
132
133
134
135
136
137 struct mconsole_reply reply;
138 int len, n;
139
140 do {
141 reply.err = err;
142
143
144 err = 0;
145
146 len = MIN(total, MCONSOLE_MAX_DATA - 1);
147
148 if (len == total) reply.more = more;
149 else reply.more = 1;
150
151 memcpy(reply.data, str, len);
152 reply.data[len] = '\0';
153 total -= len;
154 str += len;
155 reply.len = len + 1;
156
157 len = sizeof(reply) + reply.len - sizeof(reply.data);
158
159 n = sendto(req->originating_fd, &reply, len, 0,
160 (struct sockaddr *) req->origin, req->originlen);
161
162 if (n < 0)
163 return -errno;
164 } while (total > 0);
165 return 0;
166}
167
168int mconsole_reply(struct mc_request *req, const char *str, int err, int more)
169{
170 return mconsole_reply_len(req, str, strlen(str), err, more);
171}
172
173
174int mconsole_unlink_socket(void)
175{
176 unlink(mconsole_socket_name);
177 return 0;
178}
179
180static int notify_sock = -1;
181
182int mconsole_notify(char *sock_name, int type, const void *data, int len)
183{
184 struct sockaddr_un target;
185 struct mconsole_notify packet;
186 int n, err = 0;
187
188 lock_notify();
189 if (notify_sock < 0) {
190 notify_sock = socket(PF_UNIX, SOCK_DGRAM, 0);
191 if (notify_sock < 0) {
192 err = -errno;
193 printk(UM_KERN_ERR "mconsole_notify - socket failed, "
194 "errno = %d\n", errno);
195 }
196 }
197 unlock_notify();
198
199 if (err)
200 return err;
201
202 target.sun_family = AF_UNIX;
203 strcpy(target.sun_path, sock_name);
204
205 packet.magic = MCONSOLE_MAGIC;
206 packet.version = MCONSOLE_VERSION;
207 packet.type = type;
208 len = (len > sizeof(packet.data)) ? sizeof(packet.data) : len;
209 packet.len = len;
210 memcpy(packet.data, data, len);
211
212 err = 0;
213 len = sizeof(packet) + packet.len - sizeof(packet.data);
214 n = sendto(notify_sock, &packet, len, 0, (struct sockaddr *) &target,
215 sizeof(target));
216 if (n < 0) {
217 err = -errno;
218 printk(UM_KERN_ERR "mconsole_notify - sendto failed, "
219 "errno = %d\n", errno);
220 }
221 return err;
222}
223