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