Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) | |
cb8fa61c | 3 | * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
1da177e4 LT |
4 | * Licensed under the GPL |
5 | */ | |
6 | ||
1da177e4 | 7 | #include <errno.h> |
cb8fa61c JD |
8 | #include <string.h> |
9 | #include <unistd.h> | |
1da177e4 | 10 | #include <sys/socket.h> |
1da177e4 LT |
11 | #include <sys/uio.h> |
12 | #include <sys/un.h> | |
cb8fa61c | 13 | #include "kern_constants.h" |
1da177e4 | 14 | #include "mconsole.h" |
cb8fa61c | 15 | #include "user.h" |
1da177e4 LT |
16 | |
17 | static struct mconsole_command commands[] = { | |
cb8fa61c JD |
18 | /* |
19 | * With uts namespaces, uts information becomes process-specific, so | |
2d77f6fc JD |
20 | * we need a process context. If we try handling this in interrupt |
21 | * context, we may hit an exiting process without a valid uts | |
22 | * namespace. | |
23 | */ | |
24 | { "version", mconsole_version, MCONSOLE_PROC }, | |
1da177e4 LT |
25 | { "halt", mconsole_halt, MCONSOLE_PROC }, |
26 | { "reboot", mconsole_reboot, MCONSOLE_PROC }, | |
27 | { "config", mconsole_config, MCONSOLE_PROC }, | |
28 | { "remove", mconsole_remove, MCONSOLE_PROC }, | |
bd948057 | 29 | { "sysrq", mconsole_sysrq, MCONSOLE_INTR }, |
1da177e4 LT |
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 }, | |
cb8fa61c | 36 | { "stack", mconsole_stack, MCONSOLE_INTR }, |
1da177e4 LT |
37 | }; |
38 | ||
39 | /* Initialized in mconsole_init, which is an initcall */ | |
40 | char mconsole_socket_name[256]; | |
41 | ||
42 | int mconsole_reply_v0(struct mc_request *req, char *reply) | |
43 | { | |
cb8fa61c JD |
44 | struct iovec iov; |
45 | struct msghdr msg; | |
1da177e4 | 46 | |
cb8fa61c JD |
47 | iov.iov_base = reply; |
48 | iov.iov_len = strlen(reply); | |
1da177e4 | 49 | |
cb8fa61c JD |
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; | |
1da177e4 | 57 | |
cb8fa61c | 58 | return sendmsg(req->originating_fd, &msg, 0); |
1da177e4 LT |
59 | } |
60 | ||
61 | static struct mconsole_command *mconsole_parse(struct mc_request *req) | |
62 | { | |
63 | struct mconsole_command *cmd; | |
64 | int i; | |
65 | ||
cb8fa61c | 66 | for (i = 0; i < ARRAY_SIZE(commands); i++) { |
1da177e4 | 67 | cmd = &commands[i]; |
cb8fa61c JD |
68 | if (!strncmp(req->request.data, cmd->command, |
69 | strlen(cmd->command))) { | |
91b165c0 | 70 | return cmd; |
1da177e4 LT |
71 | } |
72 | } | |
91b165c0 | 73 | return NULL; |
1da177e4 LT |
74 | } |
75 | ||
76 | #define MIN(a,b) ((a)<(b) ? (a):(b)) | |
77 | ||
78 | #define STRINGX(x) #x | |
79 | #define STRING(x) STRINGX(x) | |
80 | ||
81 | int mconsole_get_request(int fd, struct mc_request *req) | |
82 | { | |
83 | int len; | |
84 | ||
85 | req->originlen = sizeof(req->origin); | |
7b5cc6ee KS |
86 | req->len = recvfrom(fd, &req->request, sizeof(req->request), 0, |
87 | (struct sockaddr *) req->origin, &req->originlen); | |
1da177e4 LT |
88 | if (req->len < 0) |
89 | return 0; | |
90 | ||
91 | req->originating_fd = fd; | |
92 | ||
cb8fa61c | 93 | if (req->request.magic != MCONSOLE_MAGIC) { |
1da177e4 | 94 | /* Unversioned request */ |
cb8fa61c | 95 | len = MIN(sizeof(req->request.data) - 1, |
1da177e4 LT |
96 | strlen((char *) &req->request)); |
97 | memmove(req->request.data, &req->request, len); | |
98 | req->request.data[len] = '\0'; | |
99 | ||
100 | req->request.magic = MCONSOLE_MAGIC; | |
101 | req->request.version = 0; | |
102 | req->request.len = len; | |
103 | ||
104 | mconsole_reply_v0(req, "ERR Version 0 mconsole clients are " | |
105 | "not supported by this driver"); | |
cb8fa61c | 106 | return 0; |
1da177e4 LT |
107 | } |
108 | ||
cb8fa61c | 109 | if (req->request.len >= MCONSOLE_MAX_DATA) { |
1da177e4 | 110 | mconsole_reply(req, "Request too large", 1, 0); |
cb8fa61c | 111 | return 0; |
1da177e4 | 112 | } |
cb8fa61c JD |
113 | if (req->request.version != MCONSOLE_VERSION) { |
114 | mconsole_reply(req, "This driver only supports version " | |
115 | STRING(MCONSOLE_VERSION) " clients", 1, 0); | |
1da177e4 | 116 | } |
cb8fa61c | 117 | |
1da177e4 LT |
118 | req->request.data[req->request.len] = '\0'; |
119 | req->cmd = mconsole_parse(req); | |
cb8fa61c | 120 | if (req->cmd == NULL) { |
1da177e4 | 121 | mconsole_reply(req, "Unknown command", 1, 0); |
cb8fa61c | 122 | return 0; |
1da177e4 LT |
123 | } |
124 | ||
cb8fa61c | 125 | return 1; |
1da177e4 LT |
126 | } |
127 | ||
7b033e1f JD |
128 | int mconsole_reply_len(struct mc_request *req, const char *str, int total, |
129 | int err, int more) | |
1da177e4 | 130 | { |
cb8fa61c JD |
131 | /* |
132 | * XXX This is a stack consumption problem. It'd be nice to | |
f92afe56 JD |
133 | * make it global and serialize access to it, but there are a |
134 | * ton of callers to this function. | |
135 | */ | |
1da177e4 | 136 | struct mconsole_reply reply; |
7b033e1f | 137 | int len, n; |
1da177e4 | 138 | |
1da177e4 LT |
139 | do { |
140 | reply.err = err; | |
141 | ||
142 | /* err can only be true on the first packet */ | |
143 | err = 0; | |
144 | ||
145 | len = MIN(total, MCONSOLE_MAX_DATA - 1); | |
146 | ||
cb8fa61c | 147 | if (len == total) reply.more = more; |
1da177e4 LT |
148 | else reply.more = 1; |
149 | ||
150 | memcpy(reply.data, str, len); | |
151 | reply.data[len] = '\0'; | |
152 | total -= len; | |
153 | str += len; | |
154 | reply.len = len + 1; | |
155 | ||
156 | len = sizeof(reply) + reply.len - sizeof(reply.data); | |
157 | ||
158 | n = sendto(req->originating_fd, &reply, len, 0, | |
159 | (struct sockaddr *) req->origin, req->originlen); | |
160 | ||
cb8fa61c JD |
161 | if (n < 0) |
162 | return -errno; | |
163 | } while (total > 0); | |
164 | return 0; | |
1da177e4 LT |
165 | } |
166 | ||
7b033e1f JD |
167 | int mconsole_reply(struct mc_request *req, const char *str, int err, int more) |
168 | { | |
169 | return mconsole_reply_len(req, str, strlen(str), err, more); | |
170 | } | |
171 | ||
172 | ||
1da177e4 LT |
173 | int mconsole_unlink_socket(void) |
174 | { | |
175 | unlink(mconsole_socket_name); | |
176 | return 0; | |
177 | } | |
178 | ||
179 | static int notify_sock = -1; | |
180 | ||
181 | int mconsole_notify(char *sock_name, int type, const void *data, int len) | |
182 | { | |
183 | struct sockaddr_un target; | |
184 | struct mconsole_notify packet; | |
185 | int n, err = 0; | |
186 | ||
187 | lock_notify(); | |
cb8fa61c | 188 | if (notify_sock < 0) { |
1da177e4 | 189 | notify_sock = socket(PF_UNIX, SOCK_DGRAM, 0); |
cb8fa61c | 190 | if (notify_sock < 0) { |
1da177e4 | 191 | err = -errno; |
cb8fa61c JD |
192 | printk(UM_KERN_ERR "mconsole_notify - socket failed, " |
193 | "errno = %d\n", errno); | |
1da177e4 LT |
194 | } |
195 | } | |
196 | unlock_notify(); | |
cb8fa61c JD |
197 | |
198 | if (err) | |
199 | return err; | |
1da177e4 LT |
200 | |
201 | target.sun_family = AF_UNIX; | |
202 | strcpy(target.sun_path, sock_name); | |
203 | ||
204 | packet.magic = MCONSOLE_MAGIC; | |
205 | packet.version = MCONSOLE_VERSION; | |
206 | packet.type = type; | |
207 | len = (len > sizeof(packet.data)) ? sizeof(packet.data) : len; | |
208 | packet.len = len; | |
209 | memcpy(packet.data, data, len); | |
210 | ||
211 | err = 0; | |
212 | len = sizeof(packet) + packet.len - sizeof(packet.data); | |
cb8fa61c | 213 | n = sendto(notify_sock, &packet, len, 0, (struct sockaddr *) &target, |
1da177e4 | 214 | sizeof(target)); |
cb8fa61c | 215 | if (n < 0) { |
1da177e4 | 216 | err = -errno; |
cb8fa61c JD |
217 | printk(UM_KERN_ERR "mconsole_notify - sendto failed, " |
218 | "errno = %d\n", errno); | |
1da177e4 | 219 | } |
cb8fa61c | 220 | return err; |
1da177e4 | 221 | } |