6db4831e98
Android 14
625 lines
16 KiB
C
625 lines
16 KiB
C
/*
|
|
* Copyright (C) 2012-2019 Samsung Electronics, Inc.
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include <linux/anon_inodes.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/init.h>
|
|
#include <linux/ioctl.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/list.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/module.h>
|
|
#include <linux/printk.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/socket.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include "tz_common.h"
|
|
#include "tzdev_internal.h"
|
|
#include "core/cdev.h"
|
|
#include "core/iwio.h"
|
|
#include "core/iwsock.h"
|
|
#include "core/log.h"
|
|
#include "core/mem.h"
|
|
#include "core/subsystem.h"
|
|
#include "core/sysdep.h"
|
|
#include "lib/circ_buf.h"
|
|
#include "lib/circ_buf_packet.h"
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Aleksandr Aleksandrov");
|
|
MODULE_DESCRIPTION("Trustzone file system driver");
|
|
|
|
#define LOG_KTHREAD "TZ_FSDEV_TH"
|
|
#define NWFS_CMD_SOCK "socket://nwfs_iwd"
|
|
#define SESSION_BUF_PAGES 5
|
|
|
|
#define TZ_FSDEV_IOC_MAGIC 'f'
|
|
#define TZ_FSDEV_INIT _IO(TZ_FSDEV_IOC_MAGIC, 0)
|
|
#define TZ_FSDEV_ACCEPT _IO(TZ_FSDEV_IOC_MAGIC, 1)
|
|
#define TZ_FSDEV_GET_CMD _IOW(TZ_FSDEV_IOC_MAGIC, 2, struct tz_fsdev_packet)
|
|
#define TZ_FSDEV_REPLY _IOR(TZ_FSDEV_IOC_MAGIC, 3, struct tz_fsdev_reply)
|
|
#define TZ_FSDEV_CREATE_SESSION_BUF _IOR(TZ_FSDEV_IOC_MAGIC, 4, uint32_t)
|
|
#define TZ_FSDEV_FREE_SESSION_BUF _IO(TZ_FSDEV_IOC_MAGIC, 5)
|
|
#define TZ_FSDEV_GET_WP_CMD _IOW(TZ_FSDEV_IOC_MAGIC, 6, struct tz_fsdev_packet)
|
|
#define TZ_FSDEV_REPLY_WP_CMD _IOR(TZ_FSDEV_IOC_MAGIC, 7, struct tz_fsdev_wp_reply)
|
|
#ifdef CONFIG_COMPAT
|
|
#define COMPAT_TZ_FSDEV_REPLY_WP_CMD _IOR(TZ_FSDEV_IOC_MAGIC, 7, struct compat_tz_fsdev_wp_reply)
|
|
#endif
|
|
|
|
enum {
|
|
NWFS_CMD_OPEN_FILE,
|
|
NWFS_CMD_CLOSE_FILE,
|
|
NWFS_CMD_READ_FILE,
|
|
NWFS_CMD_READ_FILE_CONTINUE,
|
|
NWFS_CMD_WRITE_FILE,
|
|
NWFS_CMD_MKDIR,
|
|
NWFS_CMD_RMDIR,
|
|
NWFS_CMD_CLOSEDIR,
|
|
NWFS_CMD_READDIR,
|
|
NWFS_CMD_LSEEK_FILE,
|
|
NWFS_CMD_UNLINK_FILE,
|
|
NWFS_CMD_FSTAT_FILE,
|
|
NWFS_CMD_TRUNCATE_FILE,
|
|
NWFS_CMD_RENAME_FILE,
|
|
NWFS_CMD_ALLOC_BUF,
|
|
NWFS_CMD_FREE_BUF,
|
|
NWFS_CMD_CNT,
|
|
};
|
|
|
|
#define BUF_CONTAINS_PFN (1 << 1)
|
|
|
|
struct tz_fsdev_reply {
|
|
uint32_t session_id;
|
|
pid_t pid;
|
|
} __packed;
|
|
|
|
struct tz_fsdev_child_exit {
|
|
pid_t pid;
|
|
int32_t status;
|
|
} __packed;
|
|
|
|
/* fsdev <--> SK NWFS driver */
|
|
struct tz_fsdev_packet {
|
|
uint32_t cmd;
|
|
uint32_t ret;
|
|
uint32_t packet_size;
|
|
uint32_t flags;
|
|
char buf[];
|
|
} __packed;
|
|
|
|
struct tz_fsdev_data {
|
|
struct tz_uuid uuid;
|
|
struct tz_fsdev_packet packet;
|
|
} __packed;
|
|
|
|
struct tz_fsdev_wp_reply {
|
|
uint32_t ret;
|
|
uint32_t size;
|
|
uint32_t flags;
|
|
void *buf;
|
|
} __packed;
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
struct compat_tz_fsdev_wp_reply {
|
|
uint32_t ret;
|
|
uint32_t size;
|
|
uint32_t flags;
|
|
uint32_t buf;
|
|
} __packed;
|
|
#endif /* CONFIG_COMPAT */
|
|
|
|
struct tz_fsdev_ubuf_pin_info {
|
|
struct page **pages;
|
|
unsigned long nr_pages;
|
|
struct mm_struct *mm;
|
|
sk_pfn_t *pfns;
|
|
};
|
|
|
|
struct tz_fsdev_accept_data {
|
|
uint32_t fd;
|
|
uint32_t buf_size;
|
|
};
|
|
|
|
struct tz_fsdev_session_ctx {
|
|
struct tz_fsdev_packet *session_buf;
|
|
unsigned int session_buf_size;
|
|
struct tz_fsdev_ubuf_pin_info pin_info;
|
|
struct sock_desc *sd;
|
|
};
|
|
|
|
static struct tz_fsdev_session_ctx *nwfs_daemon_ctx;
|
|
struct sock_desc *fsdev_sock;
|
|
|
|
static int tz_fsdev_open(struct inode *inode, struct file *filp)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static struct tz_fsdev_session_ctx *create_session_ctx(void)
|
|
{
|
|
struct tz_fsdev_session_ctx *session_ctx;
|
|
|
|
session_ctx = kzalloc(sizeof(struct tz_fsdev_session_ctx), GFP_KERNEL);
|
|
if (!session_ctx)
|
|
return NULL;
|
|
|
|
return session_ctx;
|
|
}
|
|
|
|
static void tz_fsdev_free_pfns(struct tz_fsdev_ubuf_pin_info *pin_info)
|
|
{
|
|
if (pin_info->pfns) {
|
|
tzdev_put_user_pages(pin_info->pages, pin_info->nr_pages);
|
|
tzdev_decrease_pinned_vm(pin_info->mm, pin_info->nr_pages);
|
|
mmput(pin_info->mm);
|
|
kfree(pin_info->pfns);
|
|
kfree(pin_info->pages);
|
|
}
|
|
}
|
|
|
|
static void release_session_ctx(struct tz_fsdev_session_ctx *session_ctx)
|
|
{
|
|
if (!session_ctx)
|
|
return;
|
|
tz_fsdev_free_pfns(&session_ctx->pin_info);
|
|
tz_iwsock_release(session_ctx->sd);
|
|
kfree(session_ctx->session_buf);
|
|
kfree(session_ctx);
|
|
}
|
|
|
|
static int tz_fsdev_get_pfns_and_pin(void *buf, unsigned int size,
|
|
struct tz_fsdev_ubuf_pin_info *pin_info)
|
|
{
|
|
int ret;
|
|
struct mm_struct *mm;
|
|
struct task_struct *task;
|
|
struct page **pages;
|
|
sk_pfn_t *pfns;
|
|
unsigned long nr_pages;
|
|
unsigned int i;
|
|
unsigned long start, end;
|
|
|
|
if (!size)
|
|
return -EINVAL;
|
|
start = (unsigned long)buf >> PAGE_SHIFT;
|
|
end = ((unsigned long)buf + size + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
|
nr_pages = end - start;
|
|
|
|
task = current;
|
|
mm = get_task_mm(task);
|
|
if (!mm)
|
|
return -ESRCH;
|
|
|
|
pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
|
|
if (ZERO_OR_NULL_PTR(pages)) {
|
|
ret = -ENOMEM;
|
|
goto out_mm;
|
|
}
|
|
|
|
pfns = kmalloc(nr_pages * sizeof(sk_pfn_t), GFP_KERNEL);
|
|
if (ZERO_OR_NULL_PTR(pfns)) {
|
|
ret = -ENOMEM;
|
|
goto out_pages;
|
|
}
|
|
|
|
/*
|
|
* Holding 'mm->mmap_sem' is required to synchronize users who try to register same pages simultaneously.
|
|
* Migration is impossible without synchronization due to page refcount holding by both users.
|
|
*/
|
|
down_write(&mm->mmap_sem);
|
|
ret = tzdev_get_user_pages(task, mm, (unsigned long __user)buf,
|
|
nr_pages, 1, 0, pages, NULL);
|
|
if (ret) {
|
|
log_error(tzdev_nwfs, "Failed to pin user pages (%d)\n", ret);
|
|
goto out_pfns;
|
|
}
|
|
|
|
#if defined(CONFIG_TZDEV_PAGE_MIGRATION)
|
|
/*
|
|
* In case of enabled migration it is possible that userspace pages
|
|
* will be migrated from current physical page to some other
|
|
* To avoid fails of CMA migrations we have to move pages to other
|
|
* region which can not be inside any CMA region. This is done by
|
|
* allocations with GFP_KERNEL flag to point UNMOVABLE memblock
|
|
* to be used for such allocations.
|
|
*/
|
|
ret = tzdev_migrate_pages(task, mm, (unsigned long __user)buf, nr_pages,
|
|
1, 0, pages);
|
|
if (ret < 0) {
|
|
log_error(tzdev_nwfs, "Failed to migrate CMA pages (%d)\n", ret);
|
|
goto out_pin;
|
|
}
|
|
#endif /* CONFIG_TZDEV_PAGE_MIGRATION */
|
|
up_write(&mm->mmap_sem);
|
|
|
|
for (i = 0; i < nr_pages; i++)
|
|
pfns[i] = page_to_pfn(pages[i]);
|
|
|
|
pin_info->pages = pages;
|
|
pin_info->nr_pages = nr_pages;
|
|
pin_info->mm = mm;
|
|
pin_info->pfns = pfns;
|
|
|
|
return 0;
|
|
|
|
#if defined(CONFIG_TZDEV_PAGE_MIGRATION)
|
|
out_pin:
|
|
tzdev_put_user_pages(pages, nr_pages);
|
|
tzdev_decrease_pinned_vm(mm, nr_pages);
|
|
#endif /* CONFIG_TZDEV_PAGE_MIGRATION */
|
|
|
|
out_pfns:
|
|
up_write(&mm->mmap_sem);
|
|
kfree(pfns);
|
|
out_pages:
|
|
kfree(pages);
|
|
out_mm:
|
|
mmput(mm);
|
|
|
|
pin_info->pages = NULL;
|
|
pin_info->nr_pages = 0;
|
|
pin_info->mm = NULL;
|
|
pin_info->pfns = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int tz_fsdev_short_reply(struct tz_fsdev_wp_reply *wp_reply,
|
|
struct tz_fsdev_session_ctx *session_ctx)
|
|
{
|
|
struct tz_fsdev_packet *packet = session_ctx->session_buf;
|
|
int ret;
|
|
|
|
packet->packet_size = wp_reply->size + sizeof(struct tz_fsdev_packet);
|
|
|
|
if (copy_from_user(packet->buf, wp_reply->buf, wp_reply->size))
|
|
return -EFAULT;
|
|
|
|
packet->flags = 0;
|
|
ret = tz_iwsock_write(session_ctx->sd, packet, packet->packet_size, 0);
|
|
if (ret < 0) {
|
|
log_error(tzdev_nwfs, "Failed iwsock write (%d)\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int tz_fsdev_reply(struct tz_fsdev_wp_reply *wp_reply, struct tz_fsdev_session_ctx *session_ctx)
|
|
{
|
|
struct tz_fsdev_packet *packet = session_ctx->session_buf;
|
|
const unsigned int packet_header_size = sizeof(struct tz_fsdev_packet);
|
|
unsigned int size = wp_reply->size;
|
|
int pfn_count, max_pfn_count, total_pfn_count;
|
|
sk_pfn_t *pfns;
|
|
int ret = 0;
|
|
|
|
if (session_ctx->pin_info.pfns) {
|
|
log_debug(tzdev_nwfs, "Free pfns\n");
|
|
tz_fsdev_free_pfns(&session_ctx->pin_info);
|
|
}
|
|
|
|
packet->flags = wp_reply->flags;
|
|
if (tz_fsdev_get_pfns_and_pin(wp_reply->buf, size, &session_ctx->pin_info)) {
|
|
packet->ret = -ENOMEM;
|
|
ret = tz_iwsock_write(session_ctx->sd, packet, packet_header_size, 0);
|
|
if (ret < 0) {
|
|
log_error(tzdev_nwfs, "Failed iwsock write (%d)\n", ret);
|
|
return ret;
|
|
}
|
|
return -ENOMEM;
|
|
}
|
|
pfns = session_ctx->pin_info.pfns;
|
|
total_pfn_count = DIV_ROUND_UP(size, PAGE_SIZE);
|
|
max_pfn_count = (session_ctx->session_buf_size - packet_header_size) / sizeof(sk_pfn_t);
|
|
do {
|
|
packet->flags |= BUF_CONTAINS_PFN;
|
|
packet->ret = wp_reply->ret;
|
|
pfn_count = total_pfn_count >= max_pfn_count ? max_pfn_count : total_pfn_count;
|
|
packet->packet_size = pfn_count * sizeof(sk_pfn_t) + packet_header_size;
|
|
memcpy(packet->buf, pfns, pfn_count * sizeof(sk_pfn_t));
|
|
ret = tz_iwsock_write(session_ctx->sd, packet, packet->packet_size, 0);
|
|
if (ret < 0) {
|
|
log_error(tzdev_nwfs, "Failed iwsock write (%d)\n", ret);
|
|
return ret;
|
|
}
|
|
pfns += pfn_count;
|
|
total_pfn_count -= pfn_count;
|
|
if (total_pfn_count) {
|
|
ret = tz_iwsock_read(session_ctx->sd, packet,
|
|
session_ctx->session_buf_size, 0);
|
|
if (ret < 0) {
|
|
log_error(tzdev_nwfs, "Failed iwsock read (%d)\n", ret);
|
|
return ret;
|
|
}
|
|
if (ret == 0) {
|
|
log_error(tzdev_nwfs, LOG_KTHREAD "NWFS socket is unxpectedly closed.\n");
|
|
return -ENODEV;
|
|
}
|
|
if (packet->cmd != NWFS_CMD_READ_FILE_CONTINUE)
|
|
return -EINVAL;
|
|
}
|
|
} while (total_pfn_count);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int tz_fsdev_reply_wp_command(struct file *file, struct tz_fsdev_wp_reply *wp_reply)
|
|
{
|
|
struct tz_fsdev_session_ctx *session_ctx = file->private_data;
|
|
struct tz_fsdev_packet *packet = session_ctx->session_buf;
|
|
const int packet_header_size = sizeof(struct tz_fsdev_packet);
|
|
int ret;
|
|
|
|
packet->ret = wp_reply->ret;
|
|
if (wp_reply->ret < 0) {
|
|
ret = tz_iwsock_write(session_ctx->sd, packet, packet_header_size, 0);
|
|
if (ret < 0)
|
|
log_error(tzdev_nwfs, "Failed iwsock write (%d)\n", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
if (wp_reply->size <= (session_ctx->session_buf_size - packet_header_size))
|
|
return tz_fsdev_short_reply(wp_reply, session_ctx);
|
|
else
|
|
return tz_fsdev_reply(wp_reply, session_ctx);
|
|
}
|
|
|
|
static int tz_fsdev_release(struct inode *inode, struct file *filp)
|
|
{
|
|
if (filp->private_data)
|
|
tz_iwsock_release(filp->private_data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int tz_fsdev_wp_release(struct inode *inode, struct file *filp)
|
|
{
|
|
release_session_ctx(filp->private_data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int tz_fsdev_get_wp_command(struct file *file, void __user *ubuf)
|
|
{
|
|
struct tz_fsdev_session_ctx *session_ctx = file->private_data;
|
|
struct tz_fsdev_packet *packet = session_ctx->session_buf;
|
|
ssize_t read_cnt;
|
|
struct tz_msghdr msg;
|
|
struct tz_cmsghdr_cred msg_cred;
|
|
struct tz_fsdev_data *data = ubuf;
|
|
|
|
msg.msgbuf = (char *)packet;
|
|
msg.msglen = session_ctx->session_buf_size;
|
|
msg.msg_control = (char *)&msg_cred;
|
|
msg.msg_controllen = sizeof(msg_cred);
|
|
msg.msg_flags = 1;
|
|
read_cnt = tz_iwsock_read_msg(session_ctx->sd, &msg, 1);
|
|
if (read_cnt < 0) {
|
|
log_error(tzdev_nwfs, "tz_iwsock_read ERROR. read_cnt = %d\n", (int)read_cnt);
|
|
return read_cnt;
|
|
}
|
|
|
|
if (read_cnt < sizeof(struct tz_fsdev_packet)) {
|
|
if (read_cnt == 0) {
|
|
log_error(tzdev_nwfs, LOG_KTHREAD "NWFS socket is unxpectedly closed. NWFS is stopped.\n");
|
|
return -ENODEV;
|
|
}
|
|
log_error(tzdev_nwfs, LOG_KTHREAD "read incorrect command.\n");
|
|
return -EPIPE;
|
|
}
|
|
if (read_cnt != packet->packet_size || packet->cmd > NWFS_CMD_CNT) {
|
|
log_error(tzdev_nwfs, LOG_KTHREAD "Wrong command:read_cnt = %d, packet->cmd = %d\n", (int)read_cnt, packet->cmd);
|
|
return -EPIPE;
|
|
}
|
|
if (copy_to_user(&data->packet, packet, packet->packet_size))
|
|
return -EFAULT;
|
|
|
|
if (copy_to_user(&data->uuid, &msg_cred.cred.uuid, sizeof(struct tz_uuid)))
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
static long compat_tz_fsdev_wp_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct tz_fsdev_wp_reply wp_reply;
|
|
struct compat_tz_fsdev_wp_reply compat_wp_reply;
|
|
|
|
switch (cmd) {
|
|
case TZ_FSDEV_GET_WP_CMD:
|
|
return tz_fsdev_get_wp_command(file, compat_ptr(arg));
|
|
case COMPAT_TZ_FSDEV_REPLY_WP_CMD:
|
|
if (copy_from_user(&compat_wp_reply, compat_ptr(arg),
|
|
sizeof(struct compat_tz_fsdev_wp_reply)))
|
|
return -EFAULT;
|
|
wp_reply.ret = compat_wp_reply.ret;
|
|
wp_reply.size = compat_wp_reply.size;
|
|
wp_reply.flags = compat_wp_reply.flags;
|
|
wp_reply.buf = compat_ptr(compat_wp_reply.buf);
|
|
|
|
return tz_fsdev_reply_wp_command(file, &wp_reply);
|
|
default:
|
|
log_error(tzdev_nwfs, "Unexpected command %d from %ld pid\n", cmd, arg);
|
|
return -ENOTTY;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif /* CONFIG_COMPAT */
|
|
|
|
static long tz_fsdev_wp_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct tz_fsdev_wp_reply wp_reply;
|
|
|
|
switch (cmd) {
|
|
case TZ_FSDEV_GET_WP_CMD:
|
|
return tz_fsdev_get_wp_command(file, (void __user *)arg);
|
|
case TZ_FSDEV_REPLY_WP_CMD:
|
|
if (copy_from_user(&wp_reply, (struct tz_fsdev_wp_reply __user *)arg,
|
|
sizeof(struct tz_fsdev_wp_reply)))
|
|
return -EFAULT;
|
|
|
|
return tz_fsdev_reply_wp_command(file, &wp_reply);
|
|
default:
|
|
log_error(tzdev_nwfs, "Unexpected command %d from %ld pid\n", cmd, arg);
|
|
return -ENOTTY;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations tz_fsdev_wp_fops = {
|
|
.owner = THIS_MODULE,
|
|
.unlocked_ioctl = tz_fsdev_wp_unlocked_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = compat_tz_fsdev_wp_unlocked_ioctl,
|
|
#endif /* CONFIG_COMPAT */
|
|
.release = tz_fsdev_wp_release,
|
|
};
|
|
|
|
static long tz_fsdev_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
int ret;
|
|
pid_t cur_pid = current->pid;
|
|
struct tz_fsdev_session_ctx *session_ctx;
|
|
struct sock_desc *fsdev_sock;
|
|
int optval, optlen;
|
|
struct tz_fsdev_accept_data accept_data;
|
|
|
|
switch (cmd) {
|
|
case TZ_FSDEV_INIT:
|
|
fsdev_sock = tz_iwsock_socket(1, TZ_INTERRUPTIBLE);
|
|
if (IS_ERR_OR_NULL(fsdev_sock)) {
|
|
log_error(tzdev_nwfs, "init socket ERROR = %ld\n", PTR_ERR(fsdev_sock));
|
|
return PTR_ERR(fsdev_sock);
|
|
}
|
|
|
|
ret = tz_iwsock_listen(fsdev_sock, NWFS_CMD_SOCK);
|
|
if (ret) {
|
|
log_error(tzdev_nwfs, "listen socket ERROR = %d\n", ret);
|
|
tz_iwsock_release(fsdev_sock);
|
|
return ret;
|
|
}
|
|
|
|
file->private_data = fsdev_sock;
|
|
break;
|
|
case TZ_FSDEV_ACCEPT:
|
|
if (!file->private_data) {
|
|
log_error(tzdev_nwfs, "Socket is not created\n");
|
|
return -EINVAL;
|
|
}
|
|
session_ctx = create_session_ctx();
|
|
if (!session_ctx) {
|
|
log_error(tzdev_nwfs, "Failed to allocate session context\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
session_ctx->sd = tz_iwsock_accept(file->private_data);
|
|
if (IS_ERR_OR_NULL(session_ctx->sd)) {
|
|
ret = PTR_ERR(session_ctx->sd);
|
|
goto free_session_ctx;
|
|
}
|
|
|
|
/* Due to socket implementation specific we can't get socket buffer size by using
|
|
* socket API. Socket buffer size is bigger than the size that was set in SWD due to
|
|
* additional internal socket data.
|
|
*/
|
|
tz_iwsock_getsockopt(session_ctx->sd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen);
|
|
|
|
session_ctx->session_buf_size = accept_data.buf_size = round_down(optval, PAGE_SIZE);
|
|
session_ctx->session_buf = kmalloc(session_ctx->session_buf_size, GFP_KERNEL);
|
|
if (!session_ctx) {
|
|
log_error(tzdev_nwfs, "Failed to allocate session buffer\n");
|
|
ret = -ENOMEM;
|
|
goto release_socket;
|
|
}
|
|
accept_data.fd = anon_inode_getfd("[nwfsdev-wp]", &tz_fsdev_wp_fops, session_ctx,
|
|
O_CLOEXEC);
|
|
if (accept_data.fd < 0) {
|
|
log_error(tzdev_nwfs, "Failed to get new anon inode fd, ret=%d\n", accept_data.fd);
|
|
ret = accept_data.fd;
|
|
goto free_session_buf;
|
|
}
|
|
|
|
if (copy_to_user((void *)arg, &accept_data, sizeof(struct tz_fsdev_accept_data))) {
|
|
ret = -EFAULT;
|
|
goto free_session_buf;
|
|
}
|
|
return 0;
|
|
|
|
free_session_buf:
|
|
kfree(session_ctx->session_buf);
|
|
session_ctx->session_buf_size = 0;
|
|
release_socket:
|
|
tz_iwsock_release(session_ctx->sd);
|
|
free_session_ctx:
|
|
kfree(session_ctx);
|
|
return ret;
|
|
default:
|
|
log_error(tzdev_nwfs, "Unexpected command %d from %d pid\n", cmd, cur_pid);
|
|
return -ENOTTY;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations tz_fsdev_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = tz_fsdev_open,
|
|
.unlocked_ioctl = tz_fsdev_unlocked_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = tz_fsdev_unlocked_ioctl,
|
|
#endif /* CONFIG_COMPAT */
|
|
.release = tz_fsdev_release,
|
|
};
|
|
|
|
static struct tz_cdev tz_fsdev_cdev = {
|
|
.name = "nwfsdev",
|
|
.fops = &tz_fsdev_fops,
|
|
.owner = THIS_MODULE,
|
|
};
|
|
|
|
int tz_fsdev_init(void)
|
|
{
|
|
int rc;
|
|
|
|
rc = tz_cdev_register(&tz_fsdev_cdev);
|
|
if (rc)
|
|
return rc;
|
|
|
|
nwfs_daemon_ctx = create_session_ctx();
|
|
if (!nwfs_daemon_ctx) {
|
|
tz_cdev_unregister(&tz_fsdev_cdev);
|
|
log_error(tzdev_nwfs, "NWFS Daemon context is not created. NWFS dev is not initialized\n");
|
|
return -EFAULT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void tz_fsdev_exit(void)
|
|
{
|
|
tz_cdev_unregister(&tz_fsdev_cdev);
|
|
release_session_ctx(nwfs_daemon_ctx);
|
|
}
|
|
|
|
tzdev_initcall(tz_fsdev_init);
|
|
tzdev_exitcall(tz_fsdev_exit);
|