/* * This file is part of the Distributed Network Block Device 3 * * Copyright(c) 2019 Frederic Robra * Parts copyright 2011-2012 Johann Latocha * * This file may be licensed under the terms of of the * GNU General Public License Version 2 (the ``GPL''). * * Software distributed under the License is distributed * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either * express or implied. See the GPL for the specific language * governing rights and limitations. * * You should have received a copy of the GPL along with this * program. If not, go to http://www.gnu.org/licenses/gpl.html * or write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * */ #ifndef DNBD_H_ #define DNBD_H_ #include #include #include #include #define KERNEL_MODULE #include "types.h" #include "serialize.h" /** * factor to which the next server is choosen or the same */ #define RTT_FACTOR(rtt) (((rtt) * 3) / 2) /** * turn on/off debug information (1/0) */ #define DEBUG 1 /** * turn on/off file and line information (1/0) */ #define DEBUG_FILE 1 //TODO test with ip tables regel. jedes x paket an port 58007 zerstoeren // iptables -A OUTPUT -p tcp -m statistic --mode random --probability 0.1 -j REJECT --reject-with tcp-reset //TODO setup mit 2 vms eine langsam eine schnell tc (traffic control) // -> geschwindigkkeit sollte in Richtung schnellen VM gehen mit 2 Queues extern struct workqueue_struct *dnbd3_wq; /** * struct dnbd3_server - defining a server for dnbd3 * @host: host of this server * @rtts: last four round trip time measurements in microseconds * @protocol_version: dnbd3 protocol version of this server * @failures: how many times the server was unreachable */ struct dnbd3_server { dnbd3_host_t host; uint64_t rtts[4]; uint64_t avg_rtt; uint16_t protocol_version; uint16_t failures; }; /** * struct dnbd3_sock - defining a socket for dnbd3 * @sock_nr: nr of this socket * @device: the dnbd3_device this socket belongs to * @server: the server this socket is connected to, 'NULL' if not connected * @tx_lock: mutex to lock when sending * @sock: the socket, 'NULL' if not connected * @panic: 'true' if it is not possible to send or receive * @cookie: is incremented for every send, used to find the mq request in the * receiver * @keepalive_worker: worker to send a keepalive package * @receive_worker: worker to handle the incoming packages * @pending: the pending request which is going to be send */ struct dnbd3_sock { uint8_t sock_nr; struct dnbd3_device *device; struct dnbd3_server *server; struct mutex tx_lock; struct socket *sock; // bool panic; uint32_t cookie; struct work_struct keepalive_worker; struct work_struct receive_worker; struct request *pending; }; /** * struct dnbd3_device - defining a dnbd3 device * @minor: minor number of this device * @tag_set: the blk mq tag set * @list: list of previous and next dnbd3_device * @disk: the gendisk * @kobj: the kobject * @device_lock: mutex to lock when device changes * @socks: array of dnbd3_sock to connect to * @imgname: the connected image name * @initial_server: the server which was configured with ioctl, will not be * overriden * @alt_servers: array of alternative servers * @new_servers_num: number of new alternative servers that are waiting to be * copied to above array * @new_servers: pending new alternative servers * @update_available: 'true' if the rid has changes * @use_server_provided_alts: 'true' if the alt_servers array is upated by the * alternatives provided by the server * @rid: the revision ID * @reported_size: the size of the image * @panic_worker: worker to handle panics and to connect if all connections are * down * @discovery_worker: worker to update the alt_servers, make rtt meassurement * and reconnect to better servers * @discovery_count: counter for the discovery worker * @timer: timer to start the appropriate workers * @timer_count: counter for the timer */ struct dnbd3_device { int minor; struct blk_mq_tag_set tag_set; struct list_head list; struct gendisk *disk; struct kobject kobj; struct mutex device_lock; bool connected; uint8_t number_connections; struct dnbd3_sock *socks; char *imgname; struct dnbd3_server initial_server; struct dnbd3_server alt_servers[NUMBER_SERVERS];//TODO just add server to list do not remove int new_servers_num; dnbd3_server_entry_t new_servers[NUMBER_SERVERS]; bool update_available; bool use_server_provided_alts; uint16_t rid; uint64_t reported_size; struct work_struct panic_worker; struct work_struct discovery_worker; uint8_t discovery_count; struct timer_list timer; uint8_t timer_count; }; /** * struct dnbd3_cmd - defines a mq cmd for dnbd3 * @dnbd3: the dnbd3 device this command belongs to * @lock: mutex to lock the cmd * @cookie: the cookie of the command, this is set by the socket when sending * @status: the status of the command * @requed: 'true' if the command is requed */ struct dnbd3_cmd { struct dnbd3_device *dnbd3; struct mutex lock; uint32_t cookie; uint32_t index; bool requed; }; #define dnbd3_set_rtt_unreachable(server) \ (server)->rtts[0] = (server)->rtts[1] = (server)->rtts[2] \ = (server)->rtts[3] = (server)->avg_rtt = \ RTT_UNREACHABLE; #define dnbd3_set_rtt_unknown(server) \ (server)->rtts[0] = (server)->rtts[1] = (server)->rtts[2] \ = (server)->rtts[3] = 0;\ (server)->avg_rtt = RTT_UNKNOWN; /** * macros for logging * levels: * - debug * - info * - warn * - error * methods: * (fmt,...) * print fmt * _dev(dev, fmt,...) * print fmt, adds device information to the log * _sock(sock, fmt,...) * print fmt, adds sock and device information to log * _server(dev, server, fmt,...) * print fmt, adds device and appends server information to the log * DEBUG - 1/0 switch all debug messages on * DEBUG_FILE - 1/0 switch on file and line number information */ #if IS_ENABLED(DEBUG_FILE) #define __print(level, fmt,...) \ printk(level "%s:%d " fmt "\n", __FILE__, __LINE__, ## __VA_ARGS__) #else #define __print(level, fmt,...) \ printk(level fmt "\n", ## __VA_ARGS__) #endif #define __print_sock(level, sock, fmt, ...) \ do { \ if ((sock)->server->host.type == HOST_IP4) { \ __print( \ level, \ "dnbd%d/%d %pI4:%d: " fmt, \ (sock)->device->minor, \ (sock)->sock_nr, \ (sock)->server->host.addr, \ (sock)->server->host.port, \ ## __VA_ARGS__); \ } else { \ __print( \ level, \ "dnbd%d/%d %pI6:%d: " fmt, \ (sock)->device->minor, \ (sock)->sock_nr, \ (sock)->server->host.addr, \ (sock)->server->host.port, \ ## __VA_ARGS__); \ } \ } while (0) #define __print_server(level, dev, server, fmt, ...) \ do { \ if ((server)->host.type == HOST_IP4) { \ __print( \ level, \ "dnbd%d: " fmt " %pI4:%d", \ (dev)->minor, \ ## __VA_ARGS__, \ (server)->host.addr, \ (server)->host.port); \ } else { \ __print( \ level, \ "dnbd%d: " fmt " %pI6:%d", \ (dev)->minor, \ ## __VA_ARGS__, \ (server)->host.addr, \ (server)->host.port); \ } \ } while (0) #if IS_ENABLED(DEBUG) #define debug(fmt, ...) \ __print(KERN_DEBUG, "dnbd: " fmt, ## __VA_ARGS__) #define debug_dev(dev, fmt, ...) \ __print(KERN_DEBUG, "dnbd%d: " fmt, (dev)->minor, ## __VA_ARGS__) #define debug_sock(sock, fmt, ...) \ __print_sock(KERN_DEBUG, sock, fmt, ## __VA_ARGS__) #define debug_server(dev, server, fmt, ...) \ __print_server(KERN_DEBUG, dev, server, fmt, ## __VA_ARGS__) #else #define debug(fmt, ...) #define debug_dev(dev, fmt, ...) #define debug_sock(sock, fmt, ...) #define debug_server(dev, server, fmt, ...) #endif #define info(fmt, ...) \ __print(KERN_INFO, "dnbd: " fmt, ## __VA_ARGS__) #define info_dev(dev, fmt, ...) \ __print(KERN_INFO, "dnbd%d: " fmt, (dev)->minor, ## __VA_ARGS__) #define info_sock(sock, fmt, ...) \ __print_sock(KERN_INFO, sock, fmt, ## __VA_ARGS__) #define info_server(dev, server, fmt, ...) \ __print_server(KERN_INFO, dev, server, fmt, ## __VA_ARGS__) #define warn(fmt, ...) \ __print(KERN_WARNING, "dnbd: " fmt, ## __VA_ARGS__) #define warn_dev(dev, fmt, ...) \ __print(KERN_WARNING, "dnbd%d: " fmt, (dev)->minor, ## __VA_ARGS__) #define warn_sock(sock, fmt, ...) \ __print_sock(KERN_WARNING, sock, fmt, ## __VA_ARGS__) #define warn_server(dev, server, fmt, ...) \ __print_server(KERN_WARNING, dev, server, fmt, ## __VA_ARGS__) #define error(fmt, ...) \ __print(KERN_ERR, "dnbd: " fmt, ## __VA_ARGS__) #define error_dev(dev, fmt, ...) \ __print(KERN_ERR, "dnbd%d: " fmt, (dev)->minor, ## __VA_ARGS__) #define error_sock(sock, fmt, ...) \ __print_sock(KERN_ERR, sock, fmt, ## __VA_ARGS__) #define error_server(dev, server, fmt, ...) \ __print_server(KERN_ERR, dev, server, fmt, ## __VA_ARGS__) #endif /* DNBD_H_ */