2 * Copyright 6WIND S.A., 2014
4 * This work is licensed under the terms of the GNU GPL, version 2 or
5 * (at your option) any later version. See the COPYING file in the
8 #include "qemu-common.h"
9 #include "qemu/sockets.h"
12 #include <sys/types.h>
13 #include <sys/socket.h>
16 #include "ivshmem-server.h"
18 /* log a message on stdout if verbose=1 */
19 #define IVSHMEM_SERVER_DEBUG(server, fmt, ...) do { \
20 if ((server)->verbose) { \
21 printf(fmt, ## __VA_ARGS__); \
25 /** maximum size of a huge page, used by ivshmem_server_ftruncate() */
26 #define IVSHMEM_SERVER_MAX_HUGEPAGE_SIZE (1024 * 1024 * 1024)
28 /** default listen backlog (number of sockets not accepted) */
29 #define IVSHMEM_SERVER_LISTEN_BACKLOG 10
31 /* send message to a client unix socket */
33 ivshmem_server_send_one_msg(int sock_fd
, long peer_id
, int fd
)
40 char control
[CMSG_SPACE(sizeof(int))];
44 iov
[0].iov_base
= &peer_id
;
45 iov
[0].iov_len
= sizeof(peer_id
);
47 memset(&msg
, 0, sizeof(msg
));
51 /* if fd is specified, add it in a cmsg */
53 memset(&msg_control
, 0, sizeof(msg_control
));
54 msg
.msg_control
= &msg_control
;
55 msg
.msg_controllen
= sizeof(msg_control
);
56 cmsg
= CMSG_FIRSTHDR(&msg
);
57 cmsg
->cmsg_level
= SOL_SOCKET
;
58 cmsg
->cmsg_type
= SCM_RIGHTS
;
59 cmsg
->cmsg_len
= CMSG_LEN(sizeof(int));
60 memcpy(CMSG_DATA(cmsg
), &fd
, sizeof(fd
));
63 ret
= sendmsg(sock_fd
, &msg
, 0);
71 /* free a peer when the server advertises a disconnection or when the
74 ivshmem_server_free_peer(IvshmemServer
*server
, IvshmemServerPeer
*peer
)
77 IvshmemServerPeer
*other_peer
;
79 IVSHMEM_SERVER_DEBUG(server
, "free peer %ld\n", peer
->id
);
81 QTAILQ_REMOVE(&server
->peer_list
, peer
, next
);
83 /* advertise the deletion to other peers */
84 QTAILQ_FOREACH(other_peer
, &server
->peer_list
, next
) {
85 ivshmem_server_send_one_msg(other_peer
->sock_fd
, peer
->id
, -1);
88 for (vector
= 0; vector
< peer
->vectors_count
; vector
++) {
89 event_notifier_cleanup(&peer
->vectors
[vector
]);
95 /* send the peer id and the shm_fd just after a new client connection */
97 ivshmem_server_send_initial_info(IvshmemServer
*server
, IvshmemServerPeer
*peer
)
101 /* send the peer id to the client */
102 ret
= ivshmem_server_send_one_msg(peer
->sock_fd
, peer
->id
, -1);
104 IVSHMEM_SERVER_DEBUG(server
, "cannot send peer id: %s\n",
109 /* send the shm_fd */
110 ret
= ivshmem_server_send_one_msg(peer
->sock_fd
, -1, server
->shm_fd
);
112 IVSHMEM_SERVER_DEBUG(server
, "cannot send shm fd: %s\n",
120 /* handle message on listening unix socket (new client connection) */
122 ivshmem_server_handle_new_conn(IvshmemServer
*server
)
124 IvshmemServerPeer
*peer
, *other_peer
;
125 struct sockaddr_un unaddr
;
126 socklen_t unaddr_len
;
130 /* accept the incoming connection */
131 unaddr_len
= sizeof(unaddr
);
132 newfd
= qemu_accept(server
->sock_fd
,
133 (struct sockaddr
*)&unaddr
, &unaddr_len
);
136 IVSHMEM_SERVER_DEBUG(server
, "cannot accept() %s\n", strerror(errno
));
140 qemu_set_nonblock(newfd
);
141 IVSHMEM_SERVER_DEBUG(server
, "accept()=%d\n", newfd
);
143 /* allocate new structure for this peer */
144 peer
= g_malloc0(sizeof(*peer
));
145 peer
->sock_fd
= newfd
;
147 /* get an unused peer id */
148 /* XXX: this could use id allocation such as Linux IDA, or simply
150 for (i
= 0; i
< G_MAXUINT16
; i
++) {
151 if (ivshmem_server_search_peer(server
, server
->cur_id
) == NULL
) {
156 if (i
== G_MAXUINT16
) {
157 IVSHMEM_SERVER_DEBUG(server
, "cannot allocate new client id\n");
160 peer
->id
= server
->cur_id
++;
162 /* create eventfd, one per vector */
163 peer
->vectors_count
= server
->n_vectors
;
164 for (i
= 0; i
< peer
->vectors_count
; i
++) {
165 if (event_notifier_init(&peer
->vectors
[i
], FALSE
) < 0) {
166 IVSHMEM_SERVER_DEBUG(server
, "cannot create eventfd\n");
171 /* send peer id and shm fd */
172 if (ivshmem_server_send_initial_info(server
, peer
) < 0) {
173 IVSHMEM_SERVER_DEBUG(server
, "cannot send initial info\n");
177 /* advertise the new peer to others */
178 QTAILQ_FOREACH(other_peer
, &server
->peer_list
, next
) {
179 for (i
= 0; i
< peer
->vectors_count
; i
++) {
180 ivshmem_server_send_one_msg(other_peer
->sock_fd
, peer
->id
,
181 peer
->vectors
[i
].wfd
);
185 /* advertise the other peers to the new one */
186 QTAILQ_FOREACH(other_peer
, &server
->peer_list
, next
) {
187 for (i
= 0; i
< peer
->vectors_count
; i
++) {
188 ivshmem_server_send_one_msg(peer
->sock_fd
, other_peer
->id
,
189 other_peer
->vectors
[i
].wfd
);
193 /* advertise the new peer to itself */
194 for (i
= 0; i
< peer
->vectors_count
; i
++) {
195 ivshmem_server_send_one_msg(peer
->sock_fd
, peer
->id
,
196 event_notifier_get_fd(&peer
->vectors
[i
]));
199 QTAILQ_INSERT_TAIL(&server
->peer_list
, peer
, next
);
200 IVSHMEM_SERVER_DEBUG(server
, "new peer id = %ld\n",
206 event_notifier_cleanup(&peer
->vectors
[i
]);
213 /* Try to ftruncate a file to next power of 2 of shmsize.
214 * If it fails; all power of 2 above shmsize are tested until
215 * we reach the maximum huge page size. This is useful
216 * if the shm file is in a hugetlbfs that cannot be truncated to the
219 ivshmem_server_ftruncate(int fd
, unsigned shmsize
)
224 /* align shmsize to next power of 2 */
225 shmsize
= pow2ceil(shmsize
);
227 if (fstat(fd
, &mapstat
) != -1 && mapstat
.st_size
== shmsize
) {
231 while (shmsize
<= IVSHMEM_SERVER_MAX_HUGEPAGE_SIZE
) {
232 ret
= ftruncate(fd
, shmsize
);
242 /* Init a new ivshmem server */
244 ivshmem_server_init(IvshmemServer
*server
, const char *unix_sock_path
,
245 const char *shm_path
, size_t shm_size
, unsigned n_vectors
,
250 memset(server
, 0, sizeof(*server
));
251 server
->verbose
= verbose
;
253 ret
= snprintf(server
->unix_sock_path
, sizeof(server
->unix_sock_path
),
254 "%s", unix_sock_path
);
255 if (ret
< 0 || ret
>= sizeof(server
->unix_sock_path
)) {
256 IVSHMEM_SERVER_DEBUG(server
, "could not copy unix socket path\n");
259 ret
= snprintf(server
->shm_path
, sizeof(server
->shm_path
),
261 if (ret
< 0 || ret
>= sizeof(server
->shm_path
)) {
262 IVSHMEM_SERVER_DEBUG(server
, "could not copy shm path\n");
266 server
->shm_size
= shm_size
;
267 server
->n_vectors
= n_vectors
;
269 QTAILQ_INIT(&server
->peer_list
);
274 /* open shm, create and bind to the unix socket */
276 ivshmem_server_start(IvshmemServer
*server
)
278 struct sockaddr_un sun
;
279 int shm_fd
, sock_fd
, ret
;
282 shm_fd
= shm_open(server
->shm_path
, O_CREAT
|O_RDWR
, S_IRWXU
);
284 fprintf(stderr
, "cannot open shm file %s: %s\n", server
->shm_path
,
288 if (ivshmem_server_ftruncate(shm_fd
, server
->shm_size
) < 0) {
289 fprintf(stderr
, "ftruncate(%s) failed: %s\n", server
->shm_path
,
294 IVSHMEM_SERVER_DEBUG(server
, "create & bind socket %s\n",
295 server
->unix_sock_path
);
297 /* create the unix listening socket */
298 sock_fd
= socket(AF_UNIX
, SOCK_STREAM
, 0);
300 IVSHMEM_SERVER_DEBUG(server
, "cannot create socket: %s\n",
305 sun
.sun_family
= AF_UNIX
;
306 ret
= snprintf(sun
.sun_path
, sizeof(sun
.sun_path
), "%s",
307 server
->unix_sock_path
);
308 if (ret
< 0 || ret
>= sizeof(sun
.sun_path
)) {
309 IVSHMEM_SERVER_DEBUG(server
, "could not copy unix socket path\n");
312 if (bind(sock_fd
, (struct sockaddr
*)&sun
, sizeof(sun
)) < 0) {
313 IVSHMEM_SERVER_DEBUG(server
, "cannot connect to %s: %s\n", sun
.sun_path
,
318 if (listen(sock_fd
, IVSHMEM_SERVER_LISTEN_BACKLOG
) < 0) {
319 IVSHMEM_SERVER_DEBUG(server
, "listen() failed: %s\n", strerror(errno
));
323 server
->sock_fd
= sock_fd
;
324 server
->shm_fd
= shm_fd
;
335 /* close connections to clients, the unix socket and the shm fd */
337 ivshmem_server_close(IvshmemServer
*server
)
339 IvshmemServerPeer
*peer
, *npeer
;
341 IVSHMEM_SERVER_DEBUG(server
, "close server\n");
343 QTAILQ_FOREACH_SAFE(peer
, &server
->peer_list
, next
, npeer
) {
344 ivshmem_server_free_peer(server
, peer
);
347 unlink(server
->unix_sock_path
);
348 close(server
->sock_fd
);
349 close(server
->shm_fd
);
350 server
->sock_fd
= -1;
354 /* get the fd_set according to the unix socket and the peer list */
356 ivshmem_server_get_fds(const IvshmemServer
*server
, fd_set
*fds
, int *maxfd
)
358 IvshmemServerPeer
*peer
;
360 if (server
->sock_fd
== -1) {
364 FD_SET(server
->sock_fd
, fds
);
365 if (server
->sock_fd
>= *maxfd
) {
366 *maxfd
= server
->sock_fd
+ 1;
369 QTAILQ_FOREACH(peer
, &server
->peer_list
, next
) {
370 FD_SET(peer
->sock_fd
, fds
);
371 if (peer
->sock_fd
>= *maxfd
) {
372 *maxfd
= peer
->sock_fd
+ 1;
377 /* process incoming messages on the sockets in fd_set */
379 ivshmem_server_handle_fds(IvshmemServer
*server
, fd_set
*fds
, int maxfd
)
381 IvshmemServerPeer
*peer
, *peer_next
;
383 if (server
->sock_fd
< maxfd
&& FD_ISSET(server
->sock_fd
, fds
) &&
384 ivshmem_server_handle_new_conn(server
) < 0 && errno
!= EINTR
) {
385 IVSHMEM_SERVER_DEBUG(server
, "ivshmem_server_handle_new_conn() "
390 QTAILQ_FOREACH_SAFE(peer
, &server
->peer_list
, next
, peer_next
) {
391 /* any message from a peer socket result in a close() */
392 IVSHMEM_SERVER_DEBUG(server
, "peer->sock_fd=%d\n", peer
->sock_fd
);
393 if (peer
->sock_fd
< maxfd
&& FD_ISSET(peer
->sock_fd
, fds
)) {
394 ivshmem_server_free_peer(server
, peer
);
401 /* lookup peer from its id */
403 ivshmem_server_search_peer(IvshmemServer
*server
, long peer_id
)
405 IvshmemServerPeer
*peer
;
407 QTAILQ_FOREACH(peer
, &server
->peer_list
, next
) {
408 if (peer
->id
== peer_id
) {
415 /* dump our info, the list of peers their vectors on stdout */
417 ivshmem_server_dump(const IvshmemServer
*server
)
419 const IvshmemServerPeer
*peer
;
423 QTAILQ_FOREACH(peer
, &server
->peer_list
, next
) {
424 printf("peer_id = %ld\n", peer
->id
);
426 for (vector
= 0; vector
< peer
->vectors_count
; vector
++) {
427 printf(" vector %d is enabled (fd=%d)\n", vector
,
428 event_notifier_get_fd(&peer
->vectors
[vector
]));