/*
   * Intel MIC Platform Software Stack (MPSS)
   *
   * Copyright(c) 2014 Intel Corporation.
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License, version 2, as
   * published by the Free Software Foundation.
   *
   * 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.
   *
   * Intel SCIF driver.
   *
   */
  #include "scif_main.h"
  
  static int scif_fdopen(struct inode *inode, struct file *f)
  {
  	struct scif_endpt *priv = scif_open();
  
  	if (!priv)
  		return -ENOMEM;
  	f->private_data = priv;
  	return 0;
  }
  
  static int scif_fdclose(struct inode *inode, struct file *f)
  {
  	struct scif_endpt *priv = f->private_data;
  
  	return scif_close(priv);
  }
  
  static int scif_fdmmap(struct file *f, struct vm_area_struct *vma)
  {
  	struct scif_endpt *priv = f->private_data;
  
  	return scif_mmap(vma, priv);
  }
  
  static unsigned int scif_fdpoll(struct file *f, poll_table *wait)
  {
  	struct scif_endpt *priv = f->private_data;
  
  	return __scif_pollfd(f, wait, priv);
  }
  
  static int scif_fdflush(struct file *f, fl_owner_t id)
  {
  	struct scif_endpt *ep = f->private_data;
  
  	spin_lock(&ep->lock);
  	/*
  	 * The listening endpoint stashes the open file information before
  	 * waiting for incoming connections. The release callback would never be
  	 * called if the application closed the endpoint, while waiting for
  	 * incoming connections from a separate thread since the file descriptor
  	 * reference count is bumped up in the accept IOCTL. Call the flush
  	 * routine if the id matches the endpoint open file information so that
  	 * the listening endpoint can be woken up and the fd released.
  	 */
  	if (ep->files == id)
  		__scif_flush(ep);
  	spin_unlock(&ep->lock);
  	return 0;
  }
  
  static __always_inline void scif_err_debug(int err, const char *str)
  {
  	/*
  	 * ENOTCONN is a common uninteresting error which is
  	 * flooding debug messages to the console unnecessarily.
  	 */
  	if (err < 0 && err != -ENOTCONN)
  		dev_dbg(scif_info.mdev.this_device, "%s err %d
  ", str, err);
  }
  
  static long scif_fdioctl(struct file *f, unsigned int cmd, unsigned long arg)
  {
  	struct scif_endpt *priv = f->private_data;
  	void __user *argp = (void __user *)arg;
  	int err = 0;
  	struct scifioctl_msg request;
  	bool non_block = false;
  
  	non_block = !!(f->f_flags & O_NONBLOCK);
  
  	switch (cmd) {
  	case SCIF_BIND:
  	{
  		int pn;
  
  		if (copy_from_user(&pn, argp, sizeof(pn)))
  			return -EFAULT;
  
  		pn = scif_bind(priv, pn);
  		if (pn < 0)
  			return pn;
  
  		if (copy_to_user(argp, &pn, sizeof(pn)))
  			return -EFAULT;
  
  		return 0;
  	}
  	case SCIF_LISTEN:
  		return scif_listen(priv, arg);
  	case SCIF_CONNECT:
  	{
  		struct scifioctl_connect req;
  		struct scif_endpt *ep = (struct scif_endpt *)priv;
  
  		if (copy_from_user(&req, argp, sizeof(req)))
  			return -EFAULT;
  
  		err = __scif_connect(priv, &req.peer, non_block);
  		if (err < 0)
  			return err;
  
  		req.self.node = ep->port.node;
  		req.self.port = ep->port.port;
  
  		if (copy_to_user(argp, &req, sizeof(req)))
  			return -EFAULT;
  
  		return 0;
  	}
  	/*
  	 * Accept is done in two halves.  The request ioctl does the basic
  	 * functionality of accepting the request and returning the information
  	 * about it including the internal ID of the end point.  The register
  	 * is done with the internal ID on a new file descriptor opened by the
  	 * requesting process.
  	 */
  	case SCIF_ACCEPTREQ:
  	{
  		struct scifioctl_accept request;
  		scif_epd_t *ep = (scif_epd_t *)&request.endpt;
  
  		if (copy_from_user(&request, argp, sizeof(request)))
  			return -EFAULT;
  
  		err = scif_accept(priv, &request.peer, ep, request.flags);
  		if (err < 0)
  			return err;
  
  		if (copy_to_user(argp, &request, sizeof(request))) {
  			scif_close(*ep);
  			return -EFAULT;
  		}
  		/*
  		 * Add to the list of user mode eps where the second half
  		 * of the accept is not yet completed.
  		 */
  		mutex_lock(&scif_info.eplock);
  		list_add_tail(&((*ep)->miacceptlist), &scif_info.uaccept);
  		list_add_tail(&((*ep)->liacceptlist), &priv->li_accept);
  		(*ep)->listenep = priv;
  		priv->acceptcnt++;
  		mutex_unlock(&scif_info.eplock);
  
  		return 0;
  	}
  	case SCIF_ACCEPTREG:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scif_endpt *newep;
  		struct scif_endpt *lisep;
  		struct scif_endpt *fep = NULL;
  		struct scif_endpt *tmpep;
  		struct list_head *pos, *tmpq;
  
  		/* Finally replace the pointer to the accepted endpoint */
  		if (copy_from_user(&newep, argp, sizeof(void *)))
  			return -EFAULT;
  
  		/* Remove form the user accept queue */
  		mutex_lock(&scif_info.eplock);
  		list_for_each_safe(pos, tmpq, &scif_info.uaccept) {
  			tmpep = list_entry(pos,
  					   struct scif_endpt, miacceptlist);
  			if (tmpep == newep) {
  				list_del(pos);
  				fep = tmpep;
  				break;
  			}
  		}
  
  		if (!fep) {
  			mutex_unlock(&scif_info.eplock);
  			return -ENOENT;
  		}
  
  		lisep = newep->listenep;
  		list_for_each_safe(pos, tmpq, &lisep->li_accept) {
  			tmpep = list_entry(pos,
  					   struct scif_endpt, liacceptlist);
  			if (tmpep == newep) {
  				list_del(pos);
  				lisep->acceptcnt--;
  				break;
  			}
  		}
  
  		mutex_unlock(&scif_info.eplock);
  
  		/* Free the resources automatically created from the open. */
  		scif_anon_inode_fput(priv);
  		scif_teardown_ep(priv);
  		scif_add_epd_to_zombie_list(priv, !SCIF_EPLOCK_HELD);
  		f->private_data = newep;
  		return 0;
  	}
  	case SCIF_SEND:
  	{
  		struct scif_endpt *priv = f->private_data;
  
  		if (copy_from_user(&request, argp,
  				   sizeof(struct scifioctl_msg))) {
  			err = -EFAULT;
  			goto send_err;
  		}
  		err = scif_user_send(priv, (void __user *)request.msg,
  				     request.len, request.flags);
  		if (err < 0)
  			goto send_err;
  		if (copy_to_user(&
  				 ((struct scifioctl_msg __user *)argp)->out_len,
  				 &err, sizeof(err))) {
  			err = -EFAULT;
  			goto send_err;
  		}
  		err = 0;
  send_err:
  		scif_err_debug(err, "scif_send");
  		return err;
  	}
  	case SCIF_RECV:
  	{
  		struct scif_endpt *priv = f->private_data;
  
  		if (copy_from_user(&request, argp,
  				   sizeof(struct scifioctl_msg))) {
  			err = -EFAULT;
  			goto recv_err;
  		}
  
  		err = scif_user_recv(priv, (void __user *)request.msg,
  				     request.len, request.flags);
  		if (err < 0)
  			goto recv_err;
  
  		if (copy_to_user(&
  				 ((struct scifioctl_msg __user *)argp)->out_len,
  			&err, sizeof(err))) {
  			err = -EFAULT;
  			goto recv_err;
  		}
  		err = 0;
  recv_err:
  		scif_err_debug(err, "scif_recv");
  		return err;
  	}
  	case SCIF_GET_NODEIDS:
  	{
  		struct scifioctl_node_ids node_ids;
  		int entries;
  		u16 *nodes;
  		void __user *unodes, *uself;
  		u16 self;
  
  		if (copy_from_user(&node_ids, argp, sizeof(node_ids))) {
  			err = -EFAULT;
  			goto getnodes_err2;
  		}
  
  		entries = min_t(int, scif_info.maxid, node_ids.len);
  		nodes = kmalloc_array(entries, sizeof(u16), GFP_KERNEL);
  		if (entries && !nodes) {
  			err = -ENOMEM;
  			goto getnodes_err2;
  		}
  		node_ids.len = scif_get_node_ids(nodes, entries, &self);
  
  		unodes = (void __user *)node_ids.nodes;
  		if (copy_to_user(unodes, nodes, sizeof(u16) * entries)) {
  			err = -EFAULT;
  			goto getnodes_err1;
  		}
  
  		uself = (void __user *)node_ids.self;
  		if (copy_to_user(uself, &self, sizeof(u16))) {
  			err = -EFAULT;
  			goto getnodes_err1;
  		}
  
  		if (copy_to_user(argp, &node_ids, sizeof(node_ids))) {
  			err = -EFAULT;
  			goto getnodes_err1;
  		}
  getnodes_err1:
  		kfree(nodes);
  getnodes_err2:
  		return err;
  	}
  	case SCIF_REG:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_reg reg;
  		off_t ret;
  
  		if (copy_from_user(&reg, argp, sizeof(reg))) {
  			err = -EFAULT;
  			goto reg_err;
  		}
  		if (reg.flags & SCIF_MAP_KERNEL) {
  			err = -EINVAL;
  			goto reg_err;
  		}
  		ret = scif_register(priv, (void *)reg.addr, reg.len,
  				    reg.offset, reg.prot, reg.flags);
  		if (ret < 0) {
  			err = (int)ret;
  			goto reg_err;
  		}
  
  		if (copy_to_user(&((struct scifioctl_reg __user *)argp)
  				 ->out_offset, &ret, sizeof(reg.out_offset))) {
  			err = -EFAULT;
  			goto reg_err;
  		}
  		err = 0;
  reg_err:
  		scif_err_debug(err, "scif_register");
  		return err;
  	}
  	case SCIF_UNREG:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_unreg unreg;
  
  		if (copy_from_user(&unreg, argp, sizeof(unreg))) {
  			err = -EFAULT;
  			goto unreg_err;
  		}
  		err = scif_unregister(priv, unreg.offset, unreg.len);
  unreg_err:
  		scif_err_debug(err, "scif_unregister");
  		return err;
  	}
  	case SCIF_READFROM:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_copy copy;
  
  		if (copy_from_user(&copy, argp, sizeof(copy))) {
  			err = -EFAULT;
  			goto readfrom_err;
  		}
  		err = scif_readfrom(priv, copy.loffset, copy.len, copy.roffset,
  				    copy.flags);
  readfrom_err:
  		scif_err_debug(err, "scif_readfrom");
  		return err;
  	}
  	case SCIF_WRITETO:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_copy copy;
  
  		if (copy_from_user(&copy, argp, sizeof(copy))) {
  			err = -EFAULT;
  			goto writeto_err;
  		}
  		err = scif_writeto(priv, copy.loffset, copy.len, copy.roffset,
  				   copy.flags);
  writeto_err:
  		scif_err_debug(err, "scif_writeto");
  		return err;
  	}
  	case SCIF_VREADFROM:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_copy copy;
  
  		if (copy_from_user(&copy, argp, sizeof(copy))) {
  			err = -EFAULT;
  			goto vreadfrom_err;
  		}
  		err = scif_vreadfrom(priv, (void __force *)copy.addr, copy.len,
  				     copy.roffset, copy.flags);
  vreadfrom_err:
  		scif_err_debug(err, "scif_vreadfrom");
  		return err;
  	}
  	case SCIF_VWRITETO:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_copy copy;
  
  		if (copy_from_user(&copy, argp, sizeof(copy))) {
  			err = -EFAULT;
  			goto vwriteto_err;
  		}
  		err = scif_vwriteto(priv, (void __force *)copy.addr, copy.len,
  				    copy.roffset, copy.flags);
  vwriteto_err:
  		scif_err_debug(err, "scif_vwriteto");
  		return err;
  	}
  	case SCIF_FENCE_MARK:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_fence_mark mark;
  		int tmp_mark = 0;
  
  		if (copy_from_user(&mark, argp, sizeof(mark))) {
  			err = -EFAULT;
  			goto fence_mark_err;
  		}
  		err = scif_fence_mark(priv, mark.flags, &tmp_mark);
  		if (err)
  			goto fence_mark_err;
  		if (copy_to_user((void __user *)mark.mark, &tmp_mark,
  				 sizeof(tmp_mark))) {
  			err = -EFAULT;
  			goto fence_mark_err;
  		}
  fence_mark_err:
  		scif_err_debug(err, "scif_fence_mark");
  		return err;
  	}
  	case SCIF_FENCE_WAIT:
  	{
  		struct scif_endpt *priv = f->private_data;
  
  		err = scif_fence_wait(priv, arg);
  		scif_err_debug(err, "scif_fence_wait");
  		return err;
  	}
  	case SCIF_FENCE_SIGNAL:
  	{
  		struct scif_endpt *priv = f->private_data;
  		struct scifioctl_fence_signal signal;
  
  		if (copy_from_user(&signal, argp, sizeof(signal))) {
  			err = -EFAULT;
  			goto fence_signal_err;
  		}
  
  		err = scif_fence_signal(priv, signal.loff, signal.lval,
  					signal.roff, signal.rval, signal.flags);
  fence_signal_err:
  		scif_err_debug(err, "scif_fence_signal");
  		return err;
  	}
  	}
  	return -EINVAL;
  }
  
  const struct file_operations scif_fops = {
  	.open = scif_fdopen,
  	.release = scif_fdclose,
  	.unlocked_ioctl = scif_fdioctl,
  	.mmap = scif_fdmmap,
  	.poll = scif_fdpoll,
  	.flush = scif_fdflush,
  	.owner = THIS_MODULE,
  };