cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

daemon_user.c (4379B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
      4 * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and
      5 * James Leu (jleu@mindspring.net).
      6 * Copyright (C) 2001 by various other people who didn't put their name here.
      7 */
      8
      9#include <stdint.h>
     10#include <string.h>
     11#include <unistd.h>
     12#include <errno.h>
     13#include <sys/types.h>
     14#include <sys/socket.h>
     15#include <sys/time.h>
     16#include <sys/un.h>
     17#include "daemon.h"
     18#include <net_user.h>
     19#include <os.h>
     20#include <um_malloc.h>
     21
     22enum request_type { REQ_NEW_CONTROL };
     23
     24#define SWITCH_MAGIC 0xfeedface
     25
     26struct request_v3 {
     27	uint32_t magic;
     28	uint32_t version;
     29	enum request_type type;
     30	struct sockaddr_un sock;
     31};
     32
     33static struct sockaddr_un *new_addr(void *name, int len)
     34{
     35	struct sockaddr_un *sun;
     36
     37	sun = uml_kmalloc(sizeof(struct sockaddr_un), UM_GFP_KERNEL);
     38	if (sun == NULL) {
     39		printk(UM_KERN_ERR "new_addr: allocation of sockaddr_un "
     40		       "failed\n");
     41		return NULL;
     42	}
     43	sun->sun_family = AF_UNIX;
     44	memcpy(sun->sun_path, name, len);
     45	return sun;
     46}
     47
     48static int connect_to_switch(struct daemon_data *pri)
     49{
     50	struct sockaddr_un *ctl_addr = pri->ctl_addr;
     51	struct sockaddr_un *local_addr = pri->local_addr;
     52	struct sockaddr_un *sun;
     53	struct request_v3 req;
     54	int fd, n, err;
     55
     56	pri->control = socket(AF_UNIX, SOCK_STREAM, 0);
     57	if (pri->control < 0) {
     58		err = -errno;
     59		printk(UM_KERN_ERR "daemon_open : control socket failed, "
     60		       "errno = %d\n", -err);
     61		return err;
     62	}
     63
     64	if (connect(pri->control, (struct sockaddr *) ctl_addr,
     65		   sizeof(*ctl_addr)) < 0) {
     66		err = -errno;
     67		printk(UM_KERN_ERR "daemon_open : control connect failed, "
     68		       "errno = %d\n", -err);
     69		goto out;
     70	}
     71
     72	fd = socket(AF_UNIX, SOCK_DGRAM, 0);
     73	if (fd < 0) {
     74		err = -errno;
     75		printk(UM_KERN_ERR "daemon_open : data socket failed, "
     76		       "errno = %d\n", -err);
     77		goto out;
     78	}
     79	if (bind(fd, (struct sockaddr *) local_addr, sizeof(*local_addr)) < 0) {
     80		err = -errno;
     81		printk(UM_KERN_ERR "daemon_open : data bind failed, "
     82		       "errno = %d\n", -err);
     83		goto out_close;
     84	}
     85
     86	sun = uml_kmalloc(sizeof(struct sockaddr_un), UM_GFP_KERNEL);
     87	if (sun == NULL) {
     88		printk(UM_KERN_ERR "new_addr: allocation of sockaddr_un "
     89		       "failed\n");
     90		err = -ENOMEM;
     91		goto out_close;
     92	}
     93
     94	req.magic = SWITCH_MAGIC;
     95	req.version = SWITCH_VERSION;
     96	req.type = REQ_NEW_CONTROL;
     97	req.sock = *local_addr;
     98	n = write(pri->control, &req, sizeof(req));
     99	if (n != sizeof(req)) {
    100		printk(UM_KERN_ERR "daemon_open : control setup request "
    101		       "failed, err = %d\n", -errno);
    102		err = -ENOTCONN;
    103		goto out_free;
    104	}
    105
    106	n = read(pri->control, sun, sizeof(*sun));
    107	if (n != sizeof(*sun)) {
    108		printk(UM_KERN_ERR "daemon_open : read of data socket failed, "
    109		       "err = %d\n", -errno);
    110		err = -ENOTCONN;
    111		goto out_free;
    112	}
    113
    114	pri->data_addr = sun;
    115	return fd;
    116
    117 out_free:
    118	kfree(sun);
    119 out_close:
    120	close(fd);
    121 out:
    122	close(pri->control);
    123	return err;
    124}
    125
    126static int daemon_user_init(void *data, void *dev)
    127{
    128	struct daemon_data *pri = data;
    129	struct timeval tv;
    130	struct {
    131		char zero;
    132		int pid;
    133		int usecs;
    134	} name;
    135
    136	if (!strcmp(pri->sock_type, "unix"))
    137		pri->ctl_addr = new_addr(pri->ctl_sock,
    138					 strlen(pri->ctl_sock) + 1);
    139	name.zero = 0;
    140	name.pid = os_getpid();
    141	gettimeofday(&tv, NULL);
    142	name.usecs = tv.tv_usec;
    143	pri->local_addr = new_addr(&name, sizeof(name));
    144	pri->dev = dev;
    145	pri->fd = connect_to_switch(pri);
    146	if (pri->fd < 0) {
    147		kfree(pri->local_addr);
    148		pri->local_addr = NULL;
    149		return pri->fd;
    150	}
    151
    152	return 0;
    153}
    154
    155static int daemon_open(void *data)
    156{
    157	struct daemon_data *pri = data;
    158	return pri->fd;
    159}
    160
    161static void daemon_remove(void *data)
    162{
    163	struct daemon_data *pri = data;
    164
    165	close(pri->fd);
    166	pri->fd = -1;
    167	close(pri->control);
    168	pri->control = -1;
    169
    170	kfree(pri->data_addr);
    171	pri->data_addr = NULL;
    172	kfree(pri->ctl_addr);
    173	pri->ctl_addr = NULL;
    174	kfree(pri->local_addr);
    175	pri->local_addr = NULL;
    176}
    177
    178int daemon_user_write(int fd, void *buf, int len, struct daemon_data *pri)
    179{
    180	struct sockaddr_un *data_addr = pri->data_addr;
    181
    182	return net_sendto(fd, buf, len, data_addr, sizeof(*data_addr));
    183}
    184
    185const struct net_user_info daemon_user_info = {
    186	.init		= daemon_user_init,
    187	.open		= daemon_open,
    188	.close	 	= NULL,
    189	.remove	 	= daemon_remove,
    190	.add_address	= NULL,
    191	.delete_address = NULL,
    192	.mtu		= ETH_MAX_PACKET,
    193	.max_packet	= ETH_MAX_PACKET + ETH_HEADER_OTHER,
    194};