/* Helper function for nl_dump_next(). */
static int
nl_dump_recv(struct nl_dump *dump)
{
struct nlmsghdr *nlmsghdr;
int retval;
retval = nl_sock_recv__(dump->sock, &dump->buffer, true);
if (retval) {
return retval == EINTR ? EAGAIN : retval;
}
nlmsghdr = nl_msg_nlmsghdr(&dump->buffer);
if (dump->seq != nlmsghdr->nlmsg_seq) {
VLOG_DBG_RL(&rl, "ignoring seq %#"PRIx32" != expected %#"PRIx32,
nlmsghdr->nlmsg_seq, dump->seq);
return EAGAIN;
}
if (nl_msg_nlmsgerr(&dump->buffer, &retval)) {
VLOG_INFO_RL(&rl, "netlink dump request error (%s)",
ovs_strerror(retval));
return retval && retval != EAGAIN ? retval : EPROTO;
}
return 0;
}
/* Tries to receive a Netlink message from the kernel on 'sock' into 'buf'. If
* 'wait' is true, waits for a message to be ready. Otherwise, fails with
* EAGAIN if the 'sock' receive buffer is empty.
*
* The caller must have initialized 'buf' with an allocation of at least
* NLMSG_HDRLEN bytes. For best performance, the caller should allocate enough
* space for a "typical" message.
*
* On success, returns 0 and replaces 'buf''s previous content by the received
* message. This function expands 'buf''s allocated memory, as necessary, to
* hold the actual size of the received message.
*
* On failure, returns a positive errno value and clears 'buf' to zero length.
* 'buf' retains its previous memory allocation.
*
* Regardless of success or failure, this function resets 'buf''s headroom to
* 0. */
int
nl_sock_recv(struct nl_sock *sock, struct ofpbuf *buf, bool wait)
{
int error = nl_sock_cow__(sock);
if (error) {
return error;
}
return nl_sock_recv__(sock, buf, wait);
}
static int
nl_sock_transact_multiple__(struct nl_sock *sock,
struct nl_transaction **transactions, size_t n,
size_t *done)
{
uint64_t tmp_reply_stub[1024 / 8];
struct nl_transaction tmp_txn;
struct ofpbuf tmp_reply;
uint32_t base_seq;
struct iovec iovs[MAX_IOVS];
struct msghdr msg;
int error;
int i;
base_seq = nl_sock_allocate_seq(sock, n);
*done = 0;
for (i = 0; i < n; i++) {
struct nl_transaction *txn = transactions[i];
struct nlmsghdr *nlmsg = nl_msg_nlmsghdr(txn->request);
nlmsg->nlmsg_len = txn->request->size;
nlmsg->nlmsg_seq = base_seq + i;
nlmsg->nlmsg_pid = sock->pid;
iovs[i].iov_base = txn->request->data;
iovs[i].iov_len = txn->request->size;
}
memset(&msg, 0, sizeof msg);
msg.msg_iov = iovs;
msg.msg_iovlen = n;
do {
error = sendmsg(sock->fd, &msg, 0) < 0 ? errno : 0;
} while (error == EINTR);
for (i = 0; i < n; i++) {
struct nl_transaction *txn = transactions[i];
log_nlmsg(__func__, error, txn->request->data, txn->request->size,
sock->protocol);
}
if (!error) {
COVERAGE_ADD(netlink_sent, n);
}
if (error) {
return error;
}
ofpbuf_use_stub(&tmp_reply, tmp_reply_stub, sizeof tmp_reply_stub);
tmp_txn.request = NULL;
tmp_txn.reply = &tmp_reply;
tmp_txn.error = 0;
while (n > 0) {
struct nl_transaction *buf_txn, *txn;
uint32_t seq;
/* Find a transaction whose buffer we can use for receiving a reply.
* If no such transaction is left, use tmp_txn. */
buf_txn = &tmp_txn;
for (i = 0; i < n; i++) {
if (transactions[i]->reply) {
buf_txn = transactions[i];
break;
}
}
/* Receive a reply. */
error = nl_sock_recv__(sock, buf_txn->reply, false);
if (error) {
if (error == EAGAIN) {
nl_sock_record_errors__(transactions, n, 0);
*done += n;
error = 0;
}
break;
}
/* Match the reply up with a transaction. */
seq = nl_msg_nlmsghdr(buf_txn->reply)->nlmsg_seq;
if (seq < base_seq || seq >= base_seq + n) {
VLOG_DBG_RL(&rl, "ignoring unexpected seq %#"PRIx32, seq);
continue;
}
i = seq - base_seq;
txn = transactions[i];
/* Fill in the results for 'txn'. */
if (nl_msg_nlmsgerr(buf_txn->reply, &txn->error)) {
if (txn->reply) {
ofpbuf_clear(txn->reply);
}
if (txn->error) {
VLOG_DBG_RL(&rl, "received NAK error=%d (%s)",
error, ovs_strerror(txn->error));
}
} else {
txn->error = 0;
if (txn->reply && txn != buf_txn) {
/* Swap buffers. */
struct ofpbuf *reply = buf_txn->reply;
buf_txn->reply = txn->reply;
txn->reply = reply;
}
}
/* Fill in the results for transactions before 'txn'. (We have to do
* this after the results for 'txn' itself because of the buffer swap
* above.) */
nl_sock_record_errors__(transactions, i, 0);
/* Advance. */
*done += i + 1;
transactions += i + 1;
n -= i + 1;
base_seq += i + 1;
}
ofpbuf_uninit(&tmp_reply);
return error;
}
/* Tries to receive a Netlink message from the kernel on 'sock' into 'buf'. If
* 'wait' is true, waits for a message to be ready. Otherwise, fails with
* EAGAIN if the 'sock' receive buffer is empty.
*
* The caller must have initialized 'buf' with an allocation of at least
* NLMSG_HDRLEN bytes. For best performance, the caller should allocate enough
* space for a "typical" message.
*
* On success, returns 0 and replaces 'buf''s previous content by the received
* message. This function expands 'buf''s allocated memory, as necessary, to
* hold the actual size of the received message.
*
* On failure, returns a positive errno value and clears 'buf' to zero length.
* 'buf' retains its previous memory allocation.
*
* Regardless of success or failure, this function resets 'buf''s headroom to
* 0. */
int
nl_sock_recv(struct nl_sock *sock, struct ofpbuf *buf, bool wait)
{
return nl_sock_recv__(sock, buf, wait);
}