[ceph.git] / ceph / src / seastar / include / seastar / net / arp.hh

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  You may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/*
 * Copyright (C) 2014 Cloudius Systems, Ltd.
 *
 */

#pragma once

#include <seastar/net/net.hh>
#include <seastar/core/reactor.hh>
#include <seastar/core/byteorder.hh>
#include <seastar/net/ethernet.hh>
#include <unordered_map>

namespace seastar {

namespace net {

class arp;
class arp_for_protocol;
template <typename L3>
class arp_for;

class arp_for_protocol {
protected:
    arp& _arp;
    uint16_t _proto_num;
public:
    arp_for_protocol(arp& a, uint16_t proto_num);
    virtual ~arp_for_protocol();
    virtual future<> received(packet p) = 0;
    virtual bool forward(forward_hash& out_hash_data, packet& p, size_t off) { return false; }
};

class arp {
    interface* _netif;
    l3_protocol _proto;
    std::unordered_map<uint16_t, arp_for_protocol*> _arp_for_protocol;
    circular_buffer<l3_protocol::l3packet> _packetq;
private:
    struct arp_hdr {
        uint16_t htype;
        uint16_t ptype;

        static arp_hdr read(const char* p) {
            arp_hdr ah;
            ah.htype = consume_be<uint16_t>(p);
            ah.ptype = consume_be<uint16_t>(p);
            return ah;
        }
        static constexpr size_t size() { return 4; }
    };
public:
    explicit arp(interface* netif);
    void add(uint16_t proto_num, arp_for_protocol* afp);
    void del(uint16_t proto_num);
private:
    ethernet_address l2self() { return _netif->hw_address(); }
    future<> process_packet(packet p, ethernet_address from);
    bool forward(forward_hash& out_hash_data, packet& p, size_t off);
    compat::optional<l3_protocol::l3packet> get_packet();
    template <class l3_proto>
    friend class arp_for;
};

template <typename L3>
class arp_for : public arp_for_protocol {
public:
    using l2addr = ethernet_address;
    using l3addr = typename L3::address_type;
private:
    static constexpr auto max_waiters = 512;
    enum oper {
        op_request = 1,
        op_reply = 2,
    };
    struct arp_hdr {
        uint16_t htype;
        uint16_t ptype;
        uint8_t hlen;
        uint8_t plen;
        uint16_t oper;
        l2addr sender_hwaddr;
        l3addr sender_paddr;
        l2addr target_hwaddr;
        l3addr target_paddr;

        static arp_hdr read(const char* p) {
            arp_hdr ah;
            ah.htype = consume_be<uint16_t>(p);
            ah.ptype = consume_be<uint16_t>(p);
            ah.hlen = consume_be<uint8_t>(p);
            ah.plen = consume_be<uint8_t>(p);
            ah.oper = consume_be<uint16_t>(p);
            ah.sender_hwaddr = l2addr::consume(p);
            ah.sender_paddr = l3addr::consume(p);
            ah.target_hwaddr = l2addr::consume(p);
            ah.target_paddr = l3addr::consume(p);
            return ah;
        }
        void write(char* p) const {
            produce_be<uint16_t>(p, htype);
            produce_be<uint16_t>(p, ptype);
            produce_be<uint8_t>(p, hlen);
            produce_be<uint8_t>(p, plen);
            produce_be<uint16_t>(p, oper);
            sender_hwaddr.produce(p);
            sender_paddr.produce(p);
            target_hwaddr.produce(p);
            target_paddr.produce(p);
        }
        static constexpr size_t size() {
            return 8 + 2 * (l2addr::size() + l3addr::size());
        }
    };
    struct resolution {
        std::vector<promise<l2addr>> _waiters;
        timer<> _timeout_timer;
    };
private:
    l3addr _l3self = L3::broadcast_address();
    std::unordered_map<l3addr, l2addr> _table;
    std::unordered_map<l3addr, resolution> _in_progress;
private:
    packet make_query_packet(l3addr paddr);
    virtual future<> received(packet p) override;
    future<> handle_request(arp_hdr* ah);
    l2addr l2self() { return _arp.l2self(); }
    void send(l2addr to, packet p);
public:
    future<> send_query(const l3addr& paddr);
    explicit arp_for(arp& a) : arp_for_protocol(a, L3::arp_protocol_type()) {
        _table[L3::broadcast_address()] = ethernet::broadcast_address();
    }
    future<ethernet_address> lookup(const l3addr& addr);
    void learn(l2addr l2, l3addr l3);
    void run();
    void set_self_addr(l3addr addr) {
        _table.erase(_l3self);
        _table[addr] = l2self();
        _l3self = addr;
    }
    friend class arp;
};

template <typename L3>
packet
arp_for<L3>::make_query_packet(l3addr paddr) {
    arp_hdr hdr;
    hdr.htype = ethernet::arp_hardware_type();
    hdr.ptype = L3::arp_protocol_type();
    hdr.hlen = sizeof(l2addr);
    hdr.plen = sizeof(l3addr);
    hdr.oper = op_request;
    hdr.sender_hwaddr = l2self();
    hdr.sender_paddr = _l3self;
    hdr.target_hwaddr = ethernet::broadcast_address();
    hdr.target_paddr = paddr;
    auto p = packet();
    p.prepend_uninitialized_header(hdr.size());
    hdr.write(p.get_header(0, hdr.size()));
    return p;
}

template <typename L3>
void arp_for<L3>::send(l2addr to, packet p) {
    _arp._packetq.push_back(l3_protocol::l3packet{eth_protocol_num::arp, to, std::move(p)});
}

template <typename L3>
future<>
arp_for<L3>::send_query(const l3addr& paddr) {
    send(ethernet::broadcast_address(), make_query_packet(paddr));
    return make_ready_future<>();
}

class arp_error : public std::runtime_error {
public:
    arp_error(const std::string& msg) : std::runtime_error(msg) {}
};

class arp_timeout_error : public arp_error {
public:
    arp_timeout_error() : arp_error("ARP timeout") {}
};

class arp_queue_full_error : public arp_error {
public:
    arp_queue_full_error() : arp_error("ARP waiter's queue is full") {}
};

template <typename L3>
future<ethernet_address>
arp_for<L3>::lookup(const l3addr& paddr) {
    auto i = _table.find(paddr);
    if (i != _table.end()) {
        return make_ready_future<ethernet_address>(i->second);
    }
    auto j = _in_progress.find(paddr);
    auto first_request = j == _in_progress.end();
    auto& res = first_request ? _in_progress[paddr] : j->second;

    if (first_request) {
        res._timeout_timer.set_callback([paddr, this, &res] {
            // FIXME: future is discarded
            (void)send_query(paddr);
            for (auto& w : res._waiters) {
                w.set_exception(arp_timeout_error());
            }
            res._waiters.clear();
        });
        res._timeout_timer.arm_periodic(std::chrono::seconds(1));
        // FIXME: future is discarded
        (void)send_query(paddr);
    }

    if (res._waiters.size() >= max_waiters) {
        return make_exception_future<ethernet_address>(arp_queue_full_error());
    }

    res._waiters.emplace_back();
    return res._waiters.back().get_future();
}

template <typename L3>
void
arp_for<L3>::learn(l2addr hwaddr, l3addr paddr) {
    _table[paddr] = hwaddr;
    auto i = _in_progress.find(paddr);
    if (i != _in_progress.end()) {
        auto& res = i->second;
        res._timeout_timer.cancel();
        for (auto &&pr : res._waiters) {
            pr.set_value(hwaddr);
        }
        _in_progress.erase(i);
    }
}

template <typename L3>
future<>
arp_for<L3>::received(packet p) {
    auto ah = p.get_header(0, arp_hdr::size());
    if (!ah) {
        return make_ready_future<>();
    }
    auto h = arp_hdr::read(ah);
    if (h.hlen != sizeof(l2addr) || h.plen != sizeof(l3addr)) {
        return make_ready_future<>();
    }
    switch (h.oper) {
    case op_request:
        return handle_request(&h);
    case op_reply:
        arp_learn(h.sender_hwaddr, h.sender_paddr);
        return make_ready_future<>();
    default:
        return make_ready_future<>();
    }
}

template <typename L3>
future<>
arp_for<L3>::handle_request(arp_hdr* ah) {
    if (ah->target_paddr == _l3self
            && _l3self != L3::broadcast_address()) {
        ah->oper = op_reply;
        ah->target_hwaddr = ah->sender_hwaddr;
        ah->target_paddr = ah->sender_paddr;
        ah->sender_hwaddr = l2self();
        ah->sender_paddr = _l3self;
        auto p = packet();
        ah->write(p.prepend_uninitialized_header(ah->size()));
        send(ah->target_hwaddr, std::move(p));
    }
    return make_ready_future<>();
}

}

}
Commit	Line	Data
11fdf7f2 TL	1	/*
	2	* This file is open source software, licensed to you under the terms
	3	* of the Apache License, Version 2.0 (the "License"). See the NOTICE file
	4	* distributed with this work for additional information regarding copyright
	5	* ownership. You may not use this file except in compliance with the License.
	6	*
	7	* You may obtain a copy of the License at
	8	*
	9	* http://www.apache.org/licenses/LICENSE-2.0
	10	*
	11	* Unless required by applicable law or agreed to in writing,
	12	* software distributed under the License is distributed on an
	13	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	14	* KIND, either express or implied. See the License for the
	15	* specific language governing permissions and limitations
	16	* under the License.
	17	*/
	18	/*
	19	* Copyright (C) 2014 Cloudius Systems, Ltd.
	20	*
	21	*/
	22
	23	#pragma once
	24
	25	#include <seastar/net/net.hh>
	26	#include <seastar/core/reactor.hh>
	27	#include <seastar/core/byteorder.hh>
	28	#include <seastar/net/ethernet.hh>
11fdf7f2 TL	29	#include <unordered_map>
	30
	31	namespace seastar {
	32
	33	namespace net {
	34
	35	class arp;
	36	class arp_for_protocol;
	37	template <typename L3>
	38	class arp_for;
	39
	40	class arp_for_protocol {
	41	protected:
	42	arp& _arp;
	43	uint16_t _proto_num;
	44	public:
	45	arp_for_protocol(arp& a, uint16_t proto_num);
	46	virtual ~arp_for_protocol();
	47	virtual future<> received(packet p) = 0;
	48	virtual bool forward(forward_hash& out_hash_data, packet& p, size_t off) { return false; }
	49	};
	50
	51	class arp {
	52	interface* _netif;
	53	l3_protocol _proto;
11fdf7f2 TL	54	std::unordered_map<uint16_t, arp_for_protocol*> _arp_for_protocol;
	55	circular_buffer<l3_protocol::l3packet> _packetq;
	56	private:
	57	struct arp_hdr {
	58	uint16_t htype;
	59	uint16_t ptype;
	60
	61	static arp_hdr read(const char* p) {
	62	arp_hdr ah;
	63	ah.htype = consume_be<uint16_t>(p);
	64	ah.ptype = consume_be<uint16_t>(p);
	65	return ah;
	66	}
	67	static constexpr size_t size() { return 4; }
	68	};
	69	public:
	70	explicit arp(interface* netif);
	71	void add(uint16_t proto_num, arp_for_protocol* afp);
	72	void del(uint16_t proto_num);
	73	private:
	74	ethernet_address l2self() { return _netif->hw_address(); }
	75	future<> process_packet(packet p, ethernet_address from);
	76	bool forward(forward_hash& out_hash_data, packet& p, size_t off);
	77	compat::optional<l3_protocol::l3packet> get_packet();
	78	template <class l3_proto>
	79	friend class arp_for;
	80	};
	81
	82	template <typename L3>
	83	class arp_for : public arp_for_protocol {
	84	public:
	85	using l2addr = ethernet_address;
	86	using l3addr = typename L3::address_type;
	87	private:
	88	static constexpr auto max_waiters = 512;
	89	enum oper {
	90	op_request = 1,
	91	op_reply = 2,
	92	};
	93	struct arp_hdr {
	94	uint16_t htype;
	95	uint16_t ptype;
	96	uint8_t hlen;
	97	uint8_t plen;
	98	uint16_t oper;
	99	l2addr sender_hwaddr;
	100	l3addr sender_paddr;
	101	l2addr target_hwaddr;
	102	l3addr target_paddr;
	103
	104	static arp_hdr read(const char* p) {
	105	arp_hdr ah;
	106	ah.htype = consume_be<uint16_t>(p);
	107	ah.ptype = consume_be<uint16_t>(p);
	108	ah.hlen = consume_be<uint8_t>(p);
	109	ah.plen = consume_be<uint8_t>(p);
	110	ah.oper = consume_be<uint16_t>(p);
	111	ah.sender_hwaddr = l2addr::consume(p);
	112	ah.sender_paddr = l3addr::consume(p);
	113	ah.target_hwaddr = l2addr::consume(p);
	114	ah.target_paddr = l3addr::consume(p);
	115	return ah;
	116	}
	117	void write(char* p) const {
118	produce_be<uint16_t>(p, htype);
119	produce_be<uint16_t>(p, ptype);
120	produce_be<uint8_t>(p, hlen);
121	produce_be<uint8_t>(p, plen);
122	produce_be<uint16_t>(p, oper);
123	sender_hwaddr.produce(p);
124	sender_paddr.produce(p);
125	target_hwaddr.produce(p);
126	target_paddr.produce(p);
127	}
128	static constexpr size_t size() {
129	return 8 + 2 * (l2addr::size() + l3addr::size());
130	}
131	};
132	struct resolution {
133	std::vector<promise<l2addr>> _waiters;
134	timer<> _timeout_timer;
135	};
136	private:
137	l3addr _l3self = L3::broadcast_address();
138	std::unordered_map<l3addr, l2addr> _table;
139	std::unordered_map<l3addr, resolution> _in_progress;
140	private:
141	packet make_query_packet(l3addr paddr);
142	virtual future<> received(packet p) override;
143	future<> handle_request(arp_hdr* ah);
144	l2addr l2self() { return _arp.l2self(); }
145	void send(l2addr to, packet p);
146	public:
147	future<> send_query(const l3addr& paddr);
148	explicit arp_for(arp& a) : arp_for_protocol(a, L3::arp_protocol_type()) {
149	_table[L3::broadcast_address()] = ethernet::broadcast_address();
150	}
151	future<ethernet_address> lookup(const l3addr& addr);
152	void learn(l2addr l2, l3addr l3);
153	void run();
154	void set_self_addr(l3addr addr) {
155	_table.erase(_l3self);
156	_table[addr] = l2self();
157	_l3self = addr;
158	}
159	friend class arp;
160	};
161
162	template <typename L3>
163	packet
164	arp_for<L3>::make_query_packet(l3addr paddr) {
165	arp_hdr hdr;
166	hdr.htype = ethernet::arp_hardware_type();
167	hdr.ptype = L3::arp_protocol_type();
168	hdr.hlen = sizeof(l2addr);
169	hdr.plen = sizeof(l3addr);
170	hdr.oper = op_request;
171	hdr.sender_hwaddr = l2self();
172	hdr.sender_paddr = _l3self;
173	hdr.target_hwaddr = ethernet::broadcast_address();
174	hdr.target_paddr = paddr;
175	auto p = packet();
176	p.prepend_uninitialized_header(hdr.size());
177	hdr.write(p.get_header(0, hdr.size()));
178	return p;
179	}
180
181	template <typename L3>
182	void arp_for<L3>::send(l2addr to, packet p) {
183	_arp._packetq.push_back(l3_protocol::l3packet{eth_protocol_num::arp, to, std::move(p)});
184	}
185
186	template <typename L3>
187	future<>
188	arp_for<L3>::send_query(const l3addr& paddr) {
189	send(ethernet::broadcast_address(), make_query_packet(paddr));
190	return make_ready_future<>();
191	}
192
193	class arp_error : public std::runtime_error {
194	public:
195	arp_error(const std::string& msg) : std::runtime_error(msg) {}
196	};
197
198	class arp_timeout_error : public arp_error {
199	public:
200	arp_timeout_error() : arp_error("ARP timeout") {}
201	};
202
203	class arp_queue_full_error : public arp_error {
204	public:
205	arp_queue_full_error() : arp_error("ARP waiter's queue is full") {}
206	};
207
208	template <typename L3>
209	future<ethernet_address>
210	arp_for<L3>::lookup(const l3addr& paddr) {
211	auto i = _table.find(paddr);
212	if (i != _table.end()) {
213	return make_ready_future<ethernet_address>(i->second);
214	}
215	auto j = _in_progress.find(paddr);
216	auto first_request = j == _in_progress.end();
217	auto& res = first_request ? _in_progress[paddr] : j->second;
218
219	if (first_request) {
220	res._timeout_timer.set_callback([paddr, this, &res] {
9f95a23c TL	221	// FIXME: future is discarded
9f95a23c TL	222	(void)send_query(paddr);
11fdf7f2 TL	223	for (auto& w : res._waiters) {
	224	w.set_exception(arp_timeout_error());
	225	}
	226	res._waiters.clear();
	227	});
	228	res._timeout_timer.arm_periodic(std::chrono::seconds(1));
9f95a23c TL	229	// FIXME: future is discarded
9f95a23c TL	230	(void)send_query(paddr);
11fdf7f2 TL	231	}
	232
	233	if (res._waiters.size() >= max_waiters) {
	234	return make_exception_future<ethernet_address>(arp_queue_full_error());
	235	}
	236
	237	res._waiters.emplace_back();
	238	return res._waiters.back().get_future();
	239	}
	240
	241	template <typename L3>
	242	void
	243	arp_for<L3>::learn(l2addr hwaddr, l3addr paddr) {
	244	_table[paddr] = hwaddr;
	245	auto i = _in_progress.find(paddr);
	246	if (i != _in_progress.end()) {
	247	auto& res = i->second;
	248	res._timeout_timer.cancel();
	249	for (auto &&pr : res._waiters) {
	250	pr.set_value(hwaddr);
	251	}
	252	_in_progress.erase(i);
	253	}
	254	}
	255
	256	template <typename L3>
	257	future<>
	258	arp_for<L3>::received(packet p) {
	259	auto ah = p.get_header(0, arp_hdr::size());
	260	if (!ah) {
	261	return make_ready_future<>();
	262	}
	263	auto h = arp_hdr::read(ah);
	264	if (h.hlen != sizeof(l2addr) \|\| h.plen != sizeof(l3addr)) {
	265	return make_ready_future<>();
	266	}
	267	switch (h.oper) {
	268	case op_request:
	269	return handle_request(&h);
	270	case op_reply:
	271	arp_learn(h.sender_hwaddr, h.sender_paddr);
	272	return make_ready_future<>();
	273	default:
	274	return make_ready_future<>();
	275	}
	276	}
	277
	278	template <typename L3>
	279	future<>
	280	arp_for<L3>::handle_request(arp_hdr* ah) {
	281	if (ah->target_paddr == _l3self
	282	&& _l3self != L3::broadcast_address()) {
	283	ah->oper = op_reply;
	284	ah->target_hwaddr = ah->sender_hwaddr;
	285	ah->target_paddr = ah->sender_paddr;
	286	ah->sender_hwaddr = l2self();
	287	ah->sender_paddr = _l3self;
	288	auto p = packet();
	289	ah->write(p.prepend_uninitialized_header(ah->size()));
	290	send(ah->target_hwaddr, std::move(p));
	291	}
	292	return make_ready_future<>();
	293	}
	294
295	}
296
297	}