void print_connections() {
struct connection *node = connection_tbl[0]->next;
// get the current position
FILE *file = fopen("connections.out","w");
fflush(file);
if (fgetpos(file,&pos) == -1)
{
fprintf(file,"Unable to refresh screen\n");
fclose(file);
}
fprintf(file,"------------------------\n");
fprintf(file,"Printing Connection Info\n");
fprintf(file,"------------------------\n");
fprintf(file,"Connection: FD \t STAT \t APPID \n");
while(node->next != NULL) {
fprintf(file,"Connection: %d \t %s \t %d \n", node->sockfd, convert_status(node->status), node->app_guid);
node = node->next;
}
fprintf(file, "------------------------\n");
if (fsetpos(file,&pos) == -1)
{
fprintf(file,"Unable to refresh screen\n");
fclose(file);
}
fclose(file);
}
nfsstat3 set_fattr(nfs_fh3 object, const sattr3 *attrs) {
nfsstat3 status = NFS3_OK;
int error = 0;
const char *path = NULL;
const kfsfilesystem_t *filesystem = get_filesystem(object, &path, NULL);
if (filesystem) {
dlog("\t%s (path, setattr)", path);
// check for resize
if (status == NFS3_OK && attrs->size.set_it) {
if (!filesystem->truncate(path, attrs->size.set_size3_u.size, &error, filesystem->context)) {
status = convert_status(error, NFS3ERR_NOENT); // truncate failed
}
}
// check for mode change
if (status == NFS3_OK && attrs->mode.set_it) {
kfsmode_t mode = 0;
if (attrs->mode.set_mode3_u.mode & NFS_IRUSR) { mode |= KFS_IRUSR; }
if (attrs->mode.set_mode3_u.mode & NFS_IWUSR) { mode |= KFS_IWUSR; }
if (attrs->mode.set_mode3_u.mode & NFS_IXUSR) { mode |= KFS_IXUSR; }
if (attrs->mode.set_mode3_u.mode & NFS_IRGRP) { mode |= KFS_IRGRP; }
if (attrs->mode.set_mode3_u.mode & NFS_IWGRP) { mode |= KFS_IWGRP; }
if (attrs->mode.set_mode3_u.mode & NFS_IXGRP) { mode |= KFS_IXGRP; }
if (attrs->mode.set_mode3_u.mode & NFS_IROTH) { mode |= KFS_IROTH; }
if (attrs->mode.set_mode3_u.mode & NFS_IWOTH) { mode |= KFS_IWOTH; }
if (attrs->mode.set_mode3_u.mode & NFS_IXOTH) { mode |= KFS_IXOTH; }
if (!filesystem->chmod(path, mode, &error, filesystem->context)) {
status = convert_status(error, NFS3ERR_NOENT); // chmod failed
}
}
// set times
if (status == NFS3_OK && (attrs->atime.set_it || attrs->mtime.set_it)) {
kfstime_t *atime = attrs->atime.set_it ? &(kfstime_t){
.sec = attrs->atime.set_atime_u.atime.seconds,
.nsec = attrs->atime.set_atime_u.atime.nseconds
} : NULL;
kfstime_t *mtime = attrs->mtime.set_it ? &(kfstime_t){
.sec = attrs->mtime.set_mtime_u.mtime.seconds,
.nsec = attrs->mtime.set_mtime_u.mtime.nseconds
} : NULL;
nfsstat3 get_fattr(nfs_fh3 object, fattr3 *result) {
nfsstat3 status = NFS3_OK;
uint64_t identifier = 0;
int error = 0;
const char *path = NULL;
const kfsfilesystem_t *filesystem = get_filesystem(object, &path, &identifier);
if (filesystem) {
dlog("\t%s (path, getattr)", path);
kfsstat_t sbuf = {};
if (filesystem->stat(path, &sbuf, &error, filesystem->context)) {
*result = (fattr3){};
if (0) {}
else if (sbuf.type == KFS_REG) { result->type = NF3REG; }
else if (sbuf.type == KFS_DIR) { result->type = NF3DIR; }
else if (sbuf.type == KFS_BLK) { result->type = NF3BLK; }
else if (sbuf.type == KFS_CHR) { result->type = NF3CHR; }
else if (sbuf.type == KFS_LNK) { result->type = NF3LNK; }
else if (sbuf.type == KFS_SOCK) { result->type = NF3SOCK; }
else if (sbuf.type == KFS_FIFO) { result->type = NF3FIFO; }
if (sbuf.mode & KFS_IRUSR) { result->mode |= NFS_IRUSR; }
if (sbuf.mode & KFS_IWUSR) { result->mode |= NFS_IWUSR; }
if (sbuf.mode & KFS_IXUSR) { result->mode |= NFS_IXUSR; }
if (sbuf.mode & KFS_IRGRP) { result->mode |= NFS_IRGRP; }
if (sbuf.mode & KFS_IWGRP) { result->mode |= NFS_IWGRP; }
if (sbuf.mode & KFS_IXGRP) { result->mode |= NFS_IXGRP; }
if (sbuf.mode & KFS_IROTH) { result->mode |= NFS_IROTH; }
if (sbuf.mode & KFS_IWOTH) { result->mode |= NFS_IWOTH; }
if (sbuf.mode & KFS_IXOTH) { result->mode |= NFS_IXOTH; }
result->nlink = 1;
result->uid = getuid();
result->gid = getgid();
result->size = sbuf.size;
result->used = sbuf.used;
result->rdev = (specdata3){ 0, 0 };
result->fsid = 0;
result->fileid = kfs_fileid(identifier, path);
result->atime = (nfstime3){ sbuf.atime.sec, sbuf.atime.nsec };
result->mtime = (nfstime3){ sbuf.mtime.sec, sbuf.mtime.nsec };
result->ctime = (nfstime3){ sbuf.ctime.sec, sbuf.ctime.nsec };
} else { // stat failed
status = convert_status(error, NFS3ERR_NOENT);
}
} else { // no filesystem
status = NFS3ERR_BADHANDLE;
}
return status;
}
static int
xspi_ioctl(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg)
{
struct xspi_instance *dev = filp->private_data;
/* paranoia check */
if (!dev)
return -ENODEV;
switch (cmd) {
case XSPI_IOC_GETSLAVESELECT:
{
int i;
i = ffs(XSpi_GetSlaveSelect(&dev->Spi)) - 1;
return put_user(i, (int *) arg); /* -1 means nothing selected */
}
break;
case XSPI_IOC_SETSLAVESELECT:
{
int i;
int retval;
if (get_user(i, (int *) arg) != 0)
return -EFAULT;
if (i < -1 || i > 31)
return -EINVAL;
/* Lock the device. */
if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
if (i == -1)
retval =
convert_status(XSpi_SetSlaveSelect
(&dev->Spi, 0));
else
retval =
convert_status(XSpi_SetSlaveSelect
(&dev->Spi, (u32) 1 << i));
/* Unlock the device. */
up(&dev->sem);
return retval;
}
break;
case XSPI_IOC_GETOPTS:
{
struct xspi_ioc_options xspi_opts;
u32 xspi_options;
xspi_options = XSpi_GetOptions(&dev->Spi);
memset(&xspi_opts, 0, sizeof (xspi_opts));
if (dev->Spi.HasFifos)
xspi_opts.has_fifo = 1;
if (xspi_options & XSP_CLK_ACTIVE_LOW_OPTION)
xspi_opts.clk_level = 1;
if (xspi_options & XSP_CLK_PHASE_1_OPTION)
xspi_opts.clk_phase = 1;
if (xspi_options & XSP_LOOPBACK_OPTION)
xspi_opts.loopback = 1;
xspi_opts.slave_selects = dev->Spi.NumSlaveBits;
return put_user(xspi_opts,
(struct xspi_ioc_options *) arg);
}
break;
case XSPI_IOC_SETOPTS:
{
struct xspi_ioc_options xspi_opts;
u32 xspi_options;
int retval;
if (copy_from_user(&xspi_opts,
(struct xspi_ioc_options *) arg,
sizeof (struct xspi_ioc_options)) !=
0)
return -EFAULT;
/* Lock the device. */
if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
/* Read current settings and set the changeable ones. */
xspi_options = XSpi_GetOptions(&dev->Spi)
& ~XSPI_CHANGEABLE_OPTIONS;
if (xspi_opts.clk_level != 0)
xspi_options |= XSP_CLK_ACTIVE_LOW_OPTION;
if (xspi_opts.clk_phase != 0)
xspi_options |= XSP_CLK_PHASE_1_OPTION;
if (xspi_opts.loopback != 0)
xspi_options |= XSP_LOOPBACK_OPTION;
retval =
convert_status(XSpi_SetOptions
(&dev->Spi, xspi_options));
/* Unlock the device. */
up(&dev->sem);
return retval;
}
break;
case XSPI_IOC_TRANSFER:
{
struct xspi_ioc_transfer_data trans_data;
int retval;
if (copy_from_user(&trans_data,
(struct xspi_ioc_transfer_data *)
arg,
sizeof (struct
xspi_ioc_transfer_data)) !=
0)
return -EFAULT;
/* Transfer the data. */
retval = xspi_transfer(dev, trans_data.write_buf,
trans_data.read_buf,
trans_data.count,
trans_data.slave_index);
if (retval > 0)
return 0;
else
return retval;
}
break;
default:
return -ENOTTY; /* redundant */
} /* switch(cmd) */
return -ENOTTY;
}
/*
* To be called from xspi_ioctl(), xspi_read(), and xspi_write().
*
* xspi_ioctl() uses both wr_buf and rd_buf.
* xspi_read() doesn't care of what is sent, and sets wr_buf to NULL.
* xspi_write() doesn't care of what it receives, and sets rd_buf to NULL.
*
* Set slave_ind to negative value if the currently selected SPI slave
* device is to be used.
*
* Returns the number of bytes transferred (0 or positive value)
* or error code (negative value).
*/
static int xspi_transfer(struct xspi_instance *dev, const char *wr_buf,
char *rd_buf, int count, int slave_ind)
{
int retval;
unsigned char *tmp_buf;
if (count <= 0)
return 0;
/* Limit the count value to the small enough one.
This prevents a denial-of-service attack by using huge count values
thus making everything to be swapped out to free the space
for this huge buffer */
if (count > 8192)
count = 8192;
/* Allocate buffer in the kernel space (it is first filled with
the data to send, then these data are overwritten with the
received data) */
tmp_buf = kmalloc(count, GFP_KERNEL);
if (tmp_buf == NULL)
return -ENOMEM;
/* Fill the buffer with data to send */
if (wr_buf == NULL) {
/* zero the buffer not to expose the kernel data */
memset(tmp_buf, 0, count);
} else {
if (copy_from_user(tmp_buf, wr_buf, count) != 0) {
kfree(tmp_buf);
return -EFAULT;
}
}
/* Lock the device */
if (down_interruptible(&dev->sem)) {
kfree(tmp_buf);
return -ERESTARTSYS;
}
/* The while cycle below never loops - this is just a convenient
way to handle the errors */
while (TRUE) {
/* Select the proper slave if requested to do so */
if (slave_ind >= 0) {
retval =
convert_status(XSpi_SetSlaveSelect
(&dev->Spi,
0x00000001 << slave_ind));
if (retval != 0)
break;
}
/* Initiate transfer */
dev->completion_status = 0;
retval = convert_status(XSpi_Transfer(&dev->Spi, tmp_buf,
(rd_buf ==
NULL) ? NULL : tmp_buf,
count));
if (retval != 0)
break;
/* Put the process to sleep */
if (wait_event_interruptible(dev->waitq,
dev->completion_status != 0) !=
0) {
/* ... woken up by the signal */
retval = -ERESTARTSYS;
break;
}
/* ... woken up by the transfer completed interrupt */
if (dev->completion_status != XST_SPI_TRANSFER_DONE) {
retval = -EIO;
break;
}
/* Copy the received data to user if rd_buf != NULL */
if (rd_buf != NULL &&
copy_to_user(rd_buf, tmp_buf, dev->tx_count) != 0) {
retval = -EFAULT;
break;
}
retval = dev->tx_count;
break;
} /* while(TRUE) */
/* Unlock the device, free the buffer and return */
up(&dev->sem);
kfree(tmp_buf);
return retval;
}
