sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
6c339daa86
nuttx/fs/rpmsgfs/rpmsgfs_server.c
chenrun1 d65f8bd4c1 filelock:Move filelock call to ioctl 
Forward the implementation originally placed in fcntl to ioctl. in order
to achieve cross-core.

Signed-off-by: chenrun1 <chenrun1@xiaomi.com>
2024-08-18 19:56:49 +08:00

985 lines
29 KiB
C
Raw Blame History

/****************************************************************************
* fs/rpmsgfs/rpmsgfs_server.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>
#include <nuttx/kmalloc.h>
#include <nuttx/mutex.h>
#include <nuttx/fs/fs.h>
#include <nuttx/rptun/openamp.h>
#include "rpmsgfs.h"
/****************************************************************************
* Private Types
****************************************************************************/
struct rpmsgfs_server_s
{
struct rpmsg_endpoint ept;
FAR struct file **files;
FAR void **dirs;
int file_rows;
int dir_nums;
mutex_t lock;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int rpmsgfs_open_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_close_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_read_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_write_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_lseek_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_ioctl_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_sync_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_dup_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_fstat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_ftruncate_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_opendir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_readdir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_rewinddir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_closedir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_statfs_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_unlink_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_mkdir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_rmdir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_rename_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_stat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_fchstat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgfs_chstat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static bool rpmsgfs_ns_match(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest);
static void rpmsgfs_ns_bind(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest);
static void rpmsgfs_ns_unbind(FAR struct rpmsg_endpoint *ept);
static int rpmsgfs_ept_cb(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src,
FAR void *priv);
/****************************************************************************
* Private Data
****************************************************************************/
static const rpmsg_ept_cb g_rpmsgfs_handler[] =
{
[RPMSGFS_OPEN] = rpmsgfs_open_handler,
[RPMSGFS_CLOSE] = rpmsgfs_close_handler,
[RPMSGFS_READ] = rpmsgfs_read_handler,
[RPMSGFS_WRITE] = rpmsgfs_write_handler,
[RPMSGFS_LSEEK] = rpmsgfs_lseek_handler,
[RPMSGFS_IOCTL] = rpmsgfs_ioctl_handler,
[RPMSGFS_SYNC] = rpmsgfs_sync_handler,
[RPMSGFS_DUP] = rpmsgfs_dup_handler,
[RPMSGFS_FSTAT] = rpmsgfs_fstat_handler,
[RPMSGFS_FTRUNCATE] = rpmsgfs_ftruncate_handler,
[RPMSGFS_OPENDIR] = rpmsgfs_opendir_handler,
[RPMSGFS_READDIR] = rpmsgfs_readdir_handler,
[RPMSGFS_REWINDDIR] = rpmsgfs_rewinddir_handler,
[RPMSGFS_CLOSEDIR] = rpmsgfs_closedir_handler,
[RPMSGFS_STATFS] = rpmsgfs_statfs_handler,
[RPMSGFS_UNLINK] = rpmsgfs_unlink_handler,
[RPMSGFS_MKDIR] = rpmsgfs_mkdir_handler,
[RPMSGFS_RMDIR] = rpmsgfs_rmdir_handler,
[RPMSGFS_RENAME] = rpmsgfs_rename_handler,
[RPMSGFS_STAT] = rpmsgfs_stat_handler,
[RPMSGFS_FCHSTAT] = rpmsgfs_fchstat_handler,
[RPMSGFS_CHSTAT] = rpmsgfs_chstat_handler,
};
/****************************************************************************
* Private Functions
****************************************************************************/
static int rpmsgfs_attach_file(FAR struct rpmsgfs_server_s *priv,
FAR struct file *filep)
{
FAR struct file **tmp;
int ret;
int i;
int j;
nxmutex_lock(&priv->lock);
for (i = 0; i < priv->file_rows; i++)
{
for (j = 0; j < CONFIG_NFILE_DESCRIPTORS_PER_BLOCK; j++)
{
if (priv->files[i][j].f_inode == NULL)
{
memcpy(&priv->files[i][j], filep, sizeof(*filep));
ret = i * CONFIG_NFILE_DESCRIPTORS_PER_BLOCK + j;
goto out;
}
}
}
tmp = kmm_realloc(priv->files, sizeof(FAR struct file *) * (i + 1));
DEBUGASSERT(tmp);
if (tmp == NULL)
{
ret = -ENFILE;
goto out;
}
tmp[i] = kmm_zalloc(sizeof(struct file) *
CONFIG_NFILE_DESCRIPTORS_PER_BLOCK);
DEBUGASSERT(tmp[i]);
if (tmp[i] == NULL)
{
kmm_free(tmp);
ret = -ENFILE;
goto out;
}
priv->files = tmp;
priv->file_rows++;
memcpy(&priv->files[i][0], filep, sizeof(*filep));
ret = i * CONFIG_NFILE_DESCRIPTORS_PER_BLOCK;
out:
nxmutex_unlock(&priv->lock);
return ret;
}
static int rpmsgfs_detach_file(FAR struct rpmsgfs_server_s *priv,
int fd, FAR struct file *filep)
{
struct file *tfilep;
if (fd < 0 || fd >= priv->file_rows * CONFIG_NFILE_DESCRIPTORS_PER_BLOCK)
{
return -EBADF;
}
nxmutex_lock(&priv->lock);
tfilep = &priv->files[fd / CONFIG_NFILE_DESCRIPTORS_PER_BLOCK]
[fd % CONFIG_NFILE_DESCRIPTORS_PER_BLOCK];
memcpy(filep, tfilep, sizeof(*filep));
memset(tfilep, 0, sizeof(*tfilep));
nxmutex_unlock(&priv->lock);
return 0;
}
static FAR struct file *rpmsgfs_get_file(
FAR struct rpmsgfs_server_s *priv,
int fd)
{
FAR struct file *filep;
if (fd < 0 || fd >= priv->file_rows * CONFIG_NFILE_DESCRIPTORS_PER_BLOCK)
{
return NULL;
}
nxmutex_lock(&priv->lock);
filep = &priv->files[fd / CONFIG_NFILE_DESCRIPTORS_PER_BLOCK]
[fd % CONFIG_NFILE_DESCRIPTORS_PER_BLOCK];
nxmutex_unlock(&priv->lock);
return filep;
}
static int rpmsgfs_attach_dir(FAR struct rpmsgfs_server_s *priv,
FAR void *dir)
{
FAR void **tmp;
int i;
nxmutex_lock(&priv->lock);
for (i = 1; i < priv->dir_nums; i++)
{
if (priv->dirs[i] == NULL)
{
priv->dirs[i] = dir;
nxmutex_unlock(&priv->lock);
return i;
}
}
tmp = kmm_realloc(priv->dirs, sizeof(FAR void *) *
(priv->dir_nums + CONFIG_NFILE_DESCRIPTORS_PER_BLOCK));
DEBUGASSERT(tmp);
if (tmp == NULL)
{
nxmutex_unlock(&priv->lock);
return -ENOMEM;
}
memset(&tmp[priv->dir_nums], 0, sizeof(FAR void *) *
CONFIG_NFILE_DESCRIPTORS_PER_BLOCK);
priv->dirs = tmp;
priv->dir_nums += CONFIG_NFILE_DESCRIPTORS_PER_BLOCK;
priv->dirs[i] = dir;
nxmutex_unlock(&priv->lock);
return i;
}
static void *rpmsgfs_detach_dir(FAR struct rpmsgfs_server_s *priv,
int fd)
{
FAR void *dir = NULL;
if (fd >= 1 && fd < priv->dir_nums)
{
nxmutex_lock(&priv->lock);
dir = priv->dirs[fd];
priv->dirs[fd] = NULL;
nxmutex_unlock(&priv->lock);
}
return dir;
}
static FAR void *rpmsgfs_get_dir(
FAR struct rpmsgfs_server_s *priv,
int fd)
{
FAR void *dir = NULL;
if (fd >= 1 && fd < priv->dir_nums)
{
nxmutex_lock(&priv->lock);
dir = priv->dirs[fd];
nxmutex_unlock(&priv->lock);
}
return dir;
}
static int rpmsgfs_open_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_open_s *msg = data;
struct file file;
int ret;
ret = file_open(&file, msg->pathname, msg->flags, msg->mode);
if (ret >= 0)
{
ret = rpmsgfs_attach_file(priv, &file);
if (ret < 0)
{
file_close(&file);
}
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_close_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_close_s *msg = data;
struct file file;
int ret;
ret = rpmsgfs_detach_file(priv, msg->fd, &file);
if (ret >= 0)
{
ret = file_close(&file);
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_read_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_read_s *msg = data;
FAR struct rpmsgfs_read_s *rsp;
FAR struct file *filep;
int ret = -ENOENT;
size_t read = 0;
uint32_t space;
filep = rpmsgfs_get_file(priv, msg->fd);
while (read < msg->count)
{
rsp = rpmsg_get_tx_payload_buffer(ept, &space, true);
if (rsp == NULL)
{
return -ENOMEM;
}
*rsp = *msg;
space -= sizeof(*msg);
if (space > msg->count - read)
{
space = msg->count - read;
}
if (filep != NULL)
{
ret = file_read(filep, rsp->buf, space);
}
rsp->header.result = ret;
rpmsg_send_nocopy(ept, rsp, (ret < 0 ? 0 : ret) + sizeof(*rsp));
if (ret <= 0)
{
break;
}
read += ret;
}
return 0;
}
static int rpmsgfs_write_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_write_s *msg = data;
FAR struct file *filep;
int ret = -ENOENT;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
size_t written = 0;
while (written < msg->count)
{
ret = file_write(filep, msg->buf + written, msg->count - written);
if (ret < 0)
{
break;
}
written += ret;
}
}
if (msg->header.cookie != 0)
{
msg->header.result = ret;
rpmsg_send(ept, msg, sizeof(*msg));
}
return 0;
}
static int rpmsgfs_lseek_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_lseek_s *msg = data;
FAR struct file *filep;
int ret = -ENOENT;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
ret = file_seek(filep, msg->offset, msg->whence);
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_ioctl_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_ioctl_s *msg = data;
FAR struct file *filep;
int ret = -ENOENT;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
ret = file_ioctl(filep, msg->request, msg->arglen > 0 ?
(unsigned long)msg->buf : msg->arg);
}
msg->header.result = ret;
return rpmsg_send(ept, msg, len);
}
static int rpmsgfs_sync_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_sync_s *msg = data;
FAR struct file *filep;
int ret = -ENOENT;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
ret = file_fsync(filep);
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_dup_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_dup_s *msg = data;
FAR struct file *filep;
struct file newfile;
int ret = -ENOENT;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
ret = file_dup2(filep, &newfile);
if (ret >= 0)
{
ret = rpmsgfs_attach_file(priv, &newfile);
if (ret < 0)
{
file_close(&newfile);
}
}
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_fstat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_fstat_s *msg = data;
FAR struct file *filep;
int ret = -ENOENT;
struct stat buf;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
ret = file_fstat(filep, &buf);
if (ret >= 0)
{
msg->buf.dev = buf.st_dev;
msg->buf.ino = buf.st_ino;
msg->buf.mode = buf.st_mode;
msg->buf.nlink = buf.st_nlink;
msg->buf.uid = buf.st_uid;
msg->buf.gid = buf.st_gid;
msg->buf.rdev = buf.st_rdev;
msg->buf.size = buf.st_size;
msg->buf.atim_sec = buf.st_atim.tv_sec;
msg->buf.atim_nsec = buf.st_atim.tv_nsec;
msg->buf.mtim_sec = buf.st_mtim.tv_sec;
msg->buf.mtim_nsec = buf.st_mtim.tv_nsec;
msg->buf.ctim_sec = buf.st_ctim.tv_sec;
msg->buf.ctim_nsec = buf.st_ctim.tv_nsec;
msg->buf.blksize = buf.st_blksize;
msg->buf.blocks = buf.st_blocks;
}
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_ftruncate_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_ftruncate_s *msg = data;
FAR struct file *filep;
int ret = -ENOENT;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
ret = file_truncate(filep, msg->length);
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_opendir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_opendir_s *msg = data;
FAR void *dir;
int ret = -ENOENT;
dir = opendir(msg->pathname);
if (dir)
{
ret = rpmsgfs_attach_dir(priv, dir);
if (ret < 0)
{
closedir(dir);
}
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_readdir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_readdir_s *msg = data;
FAR struct dirent *entry;
int ret = -ENOENT;
FAR void *dir;
size_t size;
dir = rpmsgfs_get_dir(priv, msg->fd);
if (dir)
{
entry = readdir(dir);
if (entry)
{
size = MIN(rpmsg_get_tx_buffer_size(ept->rdev),
rpmsg_get_rx_buffer_size(ept->rdev));
size = MIN(size - len, strlen(entry->d_name) + 1);
msg->type = entry->d_type;
strlcpy(msg->name, entry->d_name, size);
len += size;
ret = 0;
}
}
msg->header.result = ret;
return rpmsg_send(ept, msg, len);
}
static int rpmsgfs_rewinddir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_rewinddir_s *msg = data;
int ret = -ENOENT;
FAR void *dir;
dir = rpmsgfs_get_dir(priv, msg->fd);
if (dir)
{
rewinddir(dir);
ret = 0;
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_closedir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_closedir_s *msg = data;
int ret = -ENOENT;
FAR void *dir;
dir = rpmsgfs_detach_dir(priv, msg->fd);
if (dir)
{
ret = closedir(dir) ? -get_errno() : 0;
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_statfs_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_statfs_s *msg = data;
struct statfs buf;
int ret;
ret = statfs(msg->pathname, &buf);
if (ret)
{
ret = -get_errno();
}
else
{
msg->type = buf.f_type;
msg->namelen = buf.f_namelen;
msg->bsize = buf.f_bsize;
msg->blocks = buf.f_blocks;
msg->bfree = buf.f_bfree;
msg->bavail = buf.f_bavail;
msg->files = buf.f_files;
msg->ffree = buf.f_ffree;
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_unlink_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_unlink_s *msg = data;
msg->header.result = nx_unlink(msg->pathname);
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_mkdir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_mkdir_s *msg = data;
int ret;
ret = mkdir(msg->pathname, msg->mode);
msg->header.result = ret ? -get_errno() : 0;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_rmdir_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_rmdir_s *msg = data;
int ret;
ret = rmdir(msg->pathname);
msg->header.result = ret ? -get_errno() : 0;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_rename_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_rename_s *msg = data;
FAR char *newpath;
size_t oldlen;
int ret;
oldlen = (strlen(msg->pathname) + 1 + 0x7) & ~0x7;
newpath = msg->pathname + oldlen;
ret = rename(msg->pathname, newpath);
msg->header.result = ret ? -get_errno() : 0;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_stat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_stat_s *msg = data;
struct stat buf;
int ret;
ret = nx_stat(msg->pathname, &buf, 1);
if (ret >= 0)
{
msg->buf.dev = buf.st_dev;
msg->buf.ino = buf.st_ino;
msg->buf.mode = buf.st_mode;
msg->buf.nlink = buf.st_nlink;
msg->buf.uid = buf.st_uid;
msg->buf.gid = buf.st_gid;
msg->buf.rdev = buf.st_rdev;
msg->buf.size = buf.st_size;
msg->buf.atim_sec = buf.st_atim.tv_sec;
msg->buf.atim_nsec = buf.st_atim.tv_nsec;
msg->buf.mtim_sec = buf.st_mtim.tv_sec;
msg->buf.mtim_nsec = buf.st_mtim.tv_nsec;
msg->buf.ctim_sec = buf.st_ctim.tv_sec;
msg->buf.ctim_nsec = buf.st_ctim.tv_nsec;
msg->buf.blksize = buf.st_blksize;
msg->buf.blocks = buf.st_blocks;
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_fchstat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_fchstat_s *msg = data;
FAR struct file *filep;
int ret = -ENOENT;
struct stat buf;
filep = rpmsgfs_get_file(priv, msg->fd);
if (filep != NULL)
{
buf.st_dev = msg->buf.dev;
buf.st_ino = msg->buf.ino;
buf.st_mode = msg->buf.mode;
buf.st_nlink = msg->buf.nlink ;
buf.st_uid = msg->buf.uid ;
buf.st_gid = msg->buf.gid;
buf.st_rdev = msg->buf.rdev;
buf.st_size = msg->buf.size;
buf.st_atim.tv_sec = msg->buf.atim_sec;
buf.st_atim.tv_nsec = msg->buf.atim_nsec;
buf.st_mtim.tv_sec = msg->buf.mtim_sec;
buf.st_mtim.tv_nsec = msg->buf.mtim_nsec;
buf.st_ctim.tv_sec = msg->buf.ctim_sec;
buf.st_ctim.tv_nsec = msg->buf.ctim_nsec;
buf.st_blksize = msg->buf.blksize;
buf.st_blocks = msg->buf.blocks;
ret = file_fchstat(filep, &buf, msg->flags);
}
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static int rpmsgfs_chstat_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgfs_chstat_s *msg = data;
struct timespec times[2];
int ret = 0;
if (msg->flags & CH_STAT_MODE)
{
ret = chmod(msg->pathname, msg->buf.mode);
if (ret < 0)
{
ret = -get_errno();
goto out;
}
}
if (msg->flags & (CH_STAT_UID | CH_STAT_GID))
{
ret = chown(msg->pathname, msg->buf.uid, msg->buf.gid);
if (ret < 0)
{
ret = -get_errno();
goto out;
}
}
if (msg->flags & (CH_STAT_ATIME | CH_STAT_MTIME))
{
if (msg->flags & CH_STAT_ATIME)
{
times[0].tv_sec = msg->buf.atim_sec;
times[0].tv_nsec = msg->buf.atim_nsec;
}
else
{
times[0].tv_sec = 0;
times[0].tv_nsec = UTIME_OMIT;
}
if (msg->flags & CH_STAT_MTIME)
{
times[1].tv_sec = msg->buf.mtim_sec;
times[1].tv_nsec = msg->buf.mtim_nsec;
}
else
{
times[1].tv_sec = 0;
times[1].tv_nsec = UTIME_OMIT;
}
ret = utimens(msg->pathname, times);
if (ret < 0)
{
ret = -get_errno();
goto out;
}
}
out:
msg->header.result = ret;
return rpmsg_send(ept, msg, sizeof(*msg));
}
static bool rpmsgfs_ns_match(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest)
{
return !strncmp(name, RPMSGFS_NAME_PREFIX, strlen(RPMSGFS_NAME_PREFIX));
}
static void rpmsgfs_ns_bind(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest)
{
FAR struct rpmsgfs_server_s *priv;
int ret;
priv = kmm_zalloc(sizeof(*priv));
if (!priv)
{
return;
}
priv->ept.priv = priv;
nxmutex_init(&priv->lock);
ret = rpmsg_create_ept(&priv->ept, rdev, name,
RPMSG_ADDR_ANY, dest,
rpmsgfs_ept_cb, rpmsgfs_ns_unbind);
if (ret)
{
nxmutex_destroy(&priv->lock);
kmm_free(priv);
}
}
static void rpmsgfs_ns_unbind(FAR struct rpmsg_endpoint *ept)
{
FAR struct rpmsgfs_server_s *priv = ept->priv;
int i;
int j;
for (i = 0; i < priv->file_rows; i++)
{
for (j = 0; j < CONFIG_NFILE_DESCRIPTORS_PER_BLOCK; j++)
{
if (priv->files[i][j].f_inode)
{
file_close(&priv->files[i][j]);
}
}
kmm_free(priv->files[i]);
}
for (i = 0; i < priv->dir_nums; i++)
{
if (priv->dirs[i])
{
closedir(priv->dirs[i]);
}
}
rpmsg_destroy_ept(&priv->ept);
nxmutex_destroy(&priv->lock);
kmm_free(priv->files);
kmm_free(priv->dirs);
kmm_free(priv);
}
static int rpmsgfs_ept_cb(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src,
FAR void *priv)
{
struct rpmsgfs_header_s *header = data;
uint32_t command = header->command;
if (command < nitems(g_rpmsgfs_handler))
{
return g_rpmsgfs_handler[command](ept, data, len, src, priv);
}
return -EINVAL;
}
int rpmsgfs_server_init(void)
{
return rpmsg_register_callback(NULL,
NULL,
NULL,
rpmsgfs_ns_match,
rpmsgfs_ns_bind);
}
Reference in New Issue View Git Blame Copy Permalink