自学教程：C++ sockfd_put函数代码示例

static void ncp_put_super(struct super_block *sb){	struct ncp_server *server = NCP_SBP(sb);	ncp_lock_server(server);	ncp_disconnect(server);	ncp_unlock_server(server);	ncp_stop_tasks(server);	mutex_destroy(&server->rcv.creq_mutex);	mutex_destroy(&server->root_setup_lock);	mutex_destroy(&server->mutex);	if (server->info_sock)		sockfd_put(server->info_sock);	sockfd_put(server->ncp_sock);	kill_pid(server->m.wdog_pid, SIGTERM, 1);	put_pid(server->m.wdog_pid);	bdi_destroy(&server->bdi);	kfree(server->priv.data);	kfree(server->auth.object_name);	vfree(server->rxbuf);	vfree(server->txbuf);	vfree(server->packet);	call_rcu(&server->rcu, delayed_free);}

asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,				char __user *optval, int __user *optlen){	int err;	struct socket *sock = sockfd_lookup(fd, &err);	if (sock) {		err = security_socket_getsockopt(sock, level, optname);		if (err) {			sockfd_put(sock);			return err;		}		if (level == SOL_SOCKET)			err = compat_sock_getsockopt(sock, level,					optname, optval, optlen);		else if (sock->ops->compat_getsockopt)			err = sock->ops->compat_getsockopt(sock, level,					optname, optval, optlen);		else			err = sock->ops->getsockopt(sock, level,					optname, optval, optlen);		sockfd_put(sock);	}	return err;}

static long vhost_net_reset_owner(struct vhost_net *n){	struct socket *tx_sock = NULL;	struct socket *rx_sock = NULL;	long err;	struct vhost_memory *memory;	mutex_lock(&n->dev.mutex);	err = vhost_dev_check_owner(&n->dev);	if (err)		goto done;	memory = vhost_dev_reset_owner_prepare();	if (!memory) {		err = -ENOMEM;		goto done;	}	vhost_net_stop(n, &tx_sock, &rx_sock);	vhost_net_flush(n);	vhost_dev_reset_owner(&n->dev, memory);	vhost_net_vq_reset(n);done:	mutex_unlock(&n->dev.mutex);	if (tx_sock)		sockfd_put(tx_sock);	if (rx_sock)		sockfd_put(rx_sock);	return err;}

static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req,        bool reserved){    struct nbd_cmd *cmd = blk_mq_rq_to_pdu(req);    struct nbd_device *nbd = cmd->nbd;    struct socket *sock = NULL;    spin_lock(&nbd->sock_lock);    set_bit(NBD_TIMEDOUT, &nbd->runtime_flags);    if (nbd->sock) {        sock = nbd->sock;        get_file(sock->file);    }    spin_unlock(&nbd->sock_lock);    if (sock) {        kernel_sock_shutdown(sock, SHUT_RDWR);        sockfd_put(sock);    }    req->errors++;    dev_err(nbd_to_dev(nbd), "Connection timed out, shutting down connection/n");    return BLK_EH_HANDLED;}

/** Handle some skbs on a varp socket (if any). * * @param fd socket file descriptor * @param n maximum number of skbs to handle * @return number of skbs handled */static int handle_varp_sock(int fd, int n){    int ret = 0;    int err = 0;    struct sk_buff *skb;    struct socket *sock = NULL;    sock = sockfd_lookup(fd, &err);    if (!sock){        wprintf("> no sock for fd=%d/n", fd);        goto exit;    }    for( ; ret < n; ret++){        if(!sock->sk) break;        skb = skb_dequeue(&sock->sk->sk_receive_queue);        if(!skb) break;        // Call the skb destructor so it isn't charged to the socket anymore.        // An skb from a socket receive queue is charged to the socket        // by skb_set_owner_r() until its destructor is called.        // If the destructor is not called the socket will run out of        // receive queue space and be unable to accept incoming skbs.        // The destructor used is sock_rfree(), see 'include/net/sock.h'.        // Other destructors: sock_wfree, sk_stream_rfree.        skb_orphan(skb);        handle_varp_skb(skb);    }    sockfd_put(sock);  exit:    dprintf("< ret=%d/n", ret);    return ret;}

static struct socket *get_raw_socket(int fd){	struct {		struct sockaddr_ll sa;		char  buf[MAX_ADDR_LEN];	} uaddr;	int uaddr_len = sizeof uaddr, r;	struct socket *sock = sockfd_lookup(fd, &r);	if (!sock)		return ERR_PTR(-ENOTSOCK);	/* Parameter checking */	if (sock->sk->sk_type != SOCK_RAW) {		r = -ESOCKTNOSUPPORT;		goto err;	}	r = sock->ops->getname(sock, (struct sockaddr *)&uaddr.sa,			       &uaddr_len, 0);	if (r)		goto err;	if (uaddr.sa.sll_family != AF_PACKET) {		r = -EPFNOSUPPORT;		goto err;	}	return sock;err:	sockfd_put(sock);	return ERR_PTR(r);}

void usnic_transport_put_socket(struct socket *sock){	char buf[100];	usnic_transport_sock_to_str(buf, sizeof(buf), sock);	usnic_dbg("Put sock %s/n", buf);	sockfd_put(sock);}

static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg){	void __user *argp = (void __user *) arg;	struct hidp_connadd_req ca;	struct hidp_conndel_req cd;	struct hidp_connlist_req cl;	struct hidp_conninfo ci;	struct socket *csock;	struct socket *isock;	int err;	BT_DBG("cmd %x arg %lx", cmd, arg);	switch (cmd) {	case HIDPCONNADD:		if (!capable(CAP_NET_ADMIN))			return -EACCES;		if (copy_from_user(&ca, argp, sizeof(ca)))			return -EFAULT;		csock = sockfd_lookup(ca.ctrl_sock, &err);		if (!csock)			return err;		isock = sockfd_lookup(ca.intr_sock, &err);		if (!isock) {			sockfd_put(csock);			return err;		}<<<<<<< HEAD		if (csock->sk->sk_state != BT_CONNECTED ||				isock->sk->sk_state != BT_CONNECTED) {=======		if (csock->sk->sk_state != BT_CONNECTED || isock->sk->sk_state != BT_CONNECTED) {>>>>>>> 296c66da8a02d52243f45b80521febece5ed498a			sockfd_put(csock);			sockfd_put(isock);			return -EBADFD;		}

/** Remove a wait queue from a socket. * * @param fd socket file descriptor * @param waitq queue * @return 0 on success, error code otherwise */int sock_remove_wait_queue(int fd, wait_queue_t *waitq){    int err = -EINVAL;    struct socket *sock = NULL;    if(fd < 0) goto exit;    sock = sockfd_lookup(fd, &err);    if (!sock) goto exit;    remove_wait_queue(sock->sk->sk_sleep, waitq);    sockfd_put(sock);    err = 0;  exit:    return err;}

/** Set the data ready callback on a socket. */int sock_set_callback(int fd){    int err = -EINVAL;    struct socket *sock = NULL;    if(fd < 0) goto exit;    sock = sockfd_lookup(fd, &err);    if (!sock) goto exit;    sock->sk->sk_data_ready = sock_data_ready;    sockfd_put(sock);    err = 0;  exit:    return err;}

static int vhost_net_release(struct inode *inode, struct file *f){	struct vhost_net *n = f->private_data;	struct socket *tx_sock;	struct socket *rx_sock;	vhost_net_stop(n, &tx_sock, &rx_sock);	vhost_net_flush(n);	vhost_dev_stop(&n->dev);	vhost_dev_cleanup(&n->dev, false);	vhost_net_vq_reset(n);	if (tx_sock)		sockfd_put(tx_sock);	if (rx_sock)		sockfd_put(rx_sock);	/* Make sure no callbacks are outstanding */	synchronize_rcu_bh();	/* We do an extra flush before freeing memory,	 * since jobs can re-queue themselves. */	vhost_net_flush(n);	kfree(n->dev.vqs);	kvfree(n);	return 0;}

/* * Forcibly shutdown the socket causing all listeners to error */static void sock_shutdown(struct nbd_device *nbd){	spin_lock_irq(&nbd->sock_lock);	if (!nbd->sock) {		spin_unlock_irq(&nbd->sock_lock);		return;	}	dev_warn(disk_to_dev(nbd->disk), "shutting down socket/n");	kernel_sock_shutdown(nbd->sock, SHUT_RDWR);	sockfd_put(nbd->sock);	nbd->sock = NULL;	spin_unlock_irq(&nbd->sock_lock);	del_timer(&nbd->timeout_timer);}

static int p9_socket_open(struct p9_transport *trans, struct socket *csocket){	int fd, ret;	csocket->sk->sk_allocation = GFP_NOIO;	fd = sock_map_fd(csocket);	if (fd < 0) {		P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd/n");		return fd;	}	ret = p9_fd_open(trans, fd, fd);	if (ret < 0) {		P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to open fd/n");		sockfd_put(csocket);		return ret;	}	((struct p9_trans_fd *)trans->priv)->rd->f_flags |= O_NONBLOCK;	return 0;}

/* * Convert a connection tuple into our tuple representation and copy it to * targetbuf */u16 fd_to_socktuple(int fd,	struct sockaddr *usrsockaddr,	int ulen,	bool use_userdata,	bool is_inbound,	char *targetbuf,	u16 targetbufsize){	struct socket *sock;	int err = 0;	sa_family_t family;	struct unix_sock *us;	char *us_name;	struct sock *speer;	u32 sip;	u32 dip;	u8 *sip6;	u8 *dip6;	u16 sport;	u16 dport;	struct sockaddr_in *usrsockaddr_in;	struct sockaddr_in6 *usrsockaddr_in6;	struct sockaddr_un *usrsockaddr_un;	u16 size;	char *dest;	struct sockaddr_storage sock_address;	struct sockaddr_storage peer_address;	int sock_address_len;	int peer_address_len;	/*	 * Get the socket from the fd	 * NOTE: sockfd_lookup() locks the socket, so we don't need to worry when we dig in it	 */	sock = sockfd_lookup(fd, &err);	if (unlikely(!sock || !(sock->sk))) {		/*		 * This usually happens if the call failed without being able to establish a connection,		 * i.e. if it didn't return something like SE_EINPROGRESS.		 */		if (sock)			sockfd_put(sock);		return 0;	}	err = sock->ops->getname(sock, (struct sockaddr *)&sock_address, &sock_address_len, 0);	ASSERT(err == 0);	family = sock->sk->sk_family;	/*	 * Extract and pack the info, based on the family	 */	switch (family) {	case AF_INET:		if (!use_userdata) {			err = sock->ops->getname(sock, (struct sockaddr *)&peer_address, &peer_address_len, 1);			ASSERT(err == 0);			if (is_inbound) {				sip = ((struct sockaddr_in *) &peer_address)->sin_addr.s_addr;				sport = ntohs(((struct sockaddr_in *) &peer_address)->sin_port);				dip = ((struct sockaddr_in *) &sock_address)->sin_addr.s_addr;				dport = ntohs(((struct sockaddr_in *) &sock_address)->sin_port);			} else {				sip = ((struct sockaddr_in *) &sock_address)->sin_addr.s_addr;				sport = ntohs(((struct sockaddr_in *) &sock_address)->sin_port);				dip = ((struct sockaddr_in *) &peer_address)->sin_addr.s_addr;				dport = ntohs(((struct sockaddr_in *) &peer_address)->sin_port);			}		} else {			/*			 * Map the user-provided address to a sockaddr_in			 */			usrsockaddr_in = (struct sockaddr_in *)usrsockaddr;			if (is_inbound) {				sip = usrsockaddr_in->sin_addr.s_addr;				sport = ntohs(usrsockaddr_in->sin_port);				dip = ((struct sockaddr_in *) &sock_address)->sin_addr.s_addr;				dport = ntohs(((struct sockaddr_in *) &sock_address)->sin_port);			} else {				sip = ((struct sockaddr_in *) &sock_address)->sin_addr.s_addr;				sport = ntohs(((struct sockaddr_in *) &sock_address)->sin_port);				dip = usrsockaddr_in->sin_addr.s_addr;				dport = ntohs(usrsockaddr_in->sin_port);			}		}		/*		 * Pack the tuple info in the temporary buffer		 */		size = 1 + 4 + 4 + 2 + 2; /* family + sip + dip + sport + dport */		*targetbuf = socket_family_to_scap(family);//.........这里部分代码省略.........

static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg){	struct bnep_connlist_req cl;	struct bnep_connadd_req  ca;	struct bnep_conndel_req  cd;	struct bnep_conninfo ci;	struct socket *nsock;	void __user *argp = (void __user *)arg;	int err;	BT_DBG("cmd %x arg %lx", cmd, arg);	switch (cmd) {	case BNEPCONNADD:		if (!capable(CAP_NET_ADMIN))			return -EPERM;		if (copy_from_user(&ca, argp, sizeof(ca)))			return -EFAULT;		nsock = sockfd_lookup(ca.sock, &err);		if (!nsock)			return err;		if (nsock->sk->sk_state != BT_CONNECTED) {			sockfd_put(nsock);			return -EBADFD;		}		ca.device[sizeof(ca.device)-1] = 0;		err = bnep_add_connection(&ca, nsock);		if (!err) {			if (copy_to_user(argp, &ca, sizeof(ca)))				err = -EFAULT;		} else			sockfd_put(nsock);		return err;	case BNEPCONNDEL:		if (!capable(CAP_NET_ADMIN))			return -EPERM;		if (copy_from_user(&cd, argp, sizeof(cd)))			return -EFAULT;		return bnep_del_connection(&cd);	case BNEPGETCONNLIST:		if (copy_from_user(&cl, argp, sizeof(cl)))			return -EFAULT;		if (cl.cnum <= 0)			return -EINVAL;		err = bnep_get_connlist(&cl);		if (!err && copy_to_user(argp, &cl, sizeof(cl)))			return -EFAULT;		return err;	case BNEPGETCONNINFO:		if (copy_from_user(&ci, argp, sizeof(ci)))			return -EFAULT;		err = bnep_get_conninfo(&ci);		if (!err && copy_to_user(argp, &ci, sizeof(ci)))			return -EFAULT;		return err;	default:		return -EINVAL;	}	return 0;}

static int hidp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg){	void __user *argp = compat_ptr(arg);	int err;	if (cmd == HIDPGETCONNLIST) {		struct hidp_connlist_req cl;		u32 __user *p = argp;		u32 uci;		if (get_user(cl.cnum, p) || get_user(uci, p + 1))			return -EFAULT;		cl.ci = compat_ptr(uci);		if (cl.cnum <= 0)			return -EINVAL;		err = hidp_get_connlist(&cl);		if (!err && put_user(cl.cnum, p))			err = -EFAULT;		return err;	} else if (cmd == HIDPCONNADD) {		struct compat_hidp_connadd_req ca32;		struct hidp_connadd_req ca;		struct socket *csock;		struct socket *isock;		if (!capable(CAP_NET_ADMIN))			return -EPERM;		if (copy_from_user(&ca32, (void __user *) arg, sizeof(ca32)))			return -EFAULT;		ca.ctrl_sock = ca32.ctrl_sock;		ca.intr_sock = ca32.intr_sock;		ca.parser = ca32.parser;		ca.rd_size = ca32.rd_size;		ca.rd_data = compat_ptr(ca32.rd_data);		ca.country = ca32.country;		ca.subclass = ca32.subclass;		ca.vendor = ca32.vendor;		ca.product = ca32.product;		ca.version = ca32.version;		ca.flags = ca32.flags;		ca.idle_to = ca32.idle_to;		memcpy(ca.name, ca32.name, 128);		csock = sockfd_lookup(ca.ctrl_sock, &err);		if (!csock)			return err;		isock = sockfd_lookup(ca.intr_sock, &err);		if (!isock) {			sockfd_put(csock);			return err;		}		err = hidp_connection_add(&ca, csock, isock);		if (!err && copy_to_user(argp, &ca32, sizeof(ca32)))			err = -EFAULT;		sockfd_put(csock);		sockfd_put(isock);		return err;	}	return hidp_sock_ioctl(sock, cmd, arg);}

/* * To start a new USB/IP attachment, a userland program needs to setup a TCP * connection and then write its socket descriptor with remote device * information into this sysfs file. * * A remote device is virtually attached to the root-hub port of @rhport with * @speed. @devid is embedded into a request to specify the remote device in a * server host. * * write() returns 0 on success, else negative errno. */static ssize_t store_attach(struct device *dev, struct device_attribute *attr,			    const char *buf, size_t count){	struct socket *socket;	int sockfd = 0;	__u32 port = 0, pdev_nr = 0, rhport = 0, devid = 0, speed = 0;	struct usb_hcd *hcd;	struct vhci_hcd *vhci_hcd;	struct vhci_device *vdev;	struct vhci *vhci;	int err;	unsigned long flags;	/*	 * @rhport: port number of vhci_hcd	 * @sockfd: socket descriptor of an established TCP connection	 * @devid: unique device identifier in a remote host	 * @speed: usb device speed in a remote host	 */	if (sscanf(buf, "%u %u %u %u", &port, &sockfd, &devid, &speed) != 4)		return -EINVAL;	pdev_nr = port_to_pdev_nr(port);	rhport = port_to_rhport(port);	usbip_dbg_vhci_sysfs("port(%u) pdev(%d) rhport(%u)/n",			     port, pdev_nr, rhport);	usbip_dbg_vhci_sysfs("sockfd(%u) devid(%u) speed(%u)/n",			     sockfd, devid, speed);	/* check received parameters */	if (!valid_args(pdev_nr, rhport, speed))		return -EINVAL;	hcd = platform_get_drvdata(vhcis[pdev_nr].pdev);	if (hcd == NULL) {		dev_err(dev, "port %d is not ready/n", port);		return -EAGAIN;	}	vhci_hcd = hcd_to_vhci_hcd(hcd);	vhci = vhci_hcd->vhci;	if (speed == USB_SPEED_SUPER)		vdev = &vhci->vhci_hcd_ss->vdev[rhport];	else		vdev = &vhci->vhci_hcd_hs->vdev[rhport];	/* Extract socket from fd. */	socket = sockfd_lookup(sockfd, &err);	if (!socket)		return -EINVAL;	/* now need lock until setting vdev status as used */	/* begin a lock */	spin_lock_irqsave(&vhci->lock, flags);	spin_lock(&vdev->ud.lock);	if (vdev->ud.status != VDEV_ST_NULL) {		/* end of the lock */		spin_unlock(&vdev->ud.lock);		spin_unlock_irqrestore(&vhci->lock, flags);		sockfd_put(socket);		dev_err(dev, "port %d already used/n", rhport);		return -EINVAL;	}	dev_info(dev, "pdev(%u) rhport(%u) sockfd(%d)/n",		 pdev_nr, rhport, sockfd);	dev_info(dev, "devid(%u) speed(%u) speed_str(%s)/n",		 devid, speed, usb_speed_string(speed));	vdev->devid         = devid;	vdev->speed         = speed;	vdev->ud.tcp_socket = socket;	vdev->ud.status     = VDEV_ST_NOTASSIGNED;	spin_unlock(&vdev->ud.lock);	spin_unlock_irqrestore(&vhci->lock, flags);	/* end the lock */	vdev->ud.tcp_rx = kthread_get_run(vhci_rx_loop, &vdev->ud, "vhci_rx");	vdev->ud.tcp_tx = kthread_get_run(vhci_tx_loop, &vdev->ud, "vhci_tx");	rh_port_connect(vdev, speed);	return count;//.........这里部分代码省略.........

//.........这里部分代码省略.........	tcp_conn->rx_hash = &tcp_sw_conn->rx_hash;	return cls_conn;free_tx_tfm:	crypto_free_hash(tcp_sw_conn->tx_hash.tfm);free_conn:	iscsi_conn_printk(KERN_ERR, conn,			  "Could not create connection due to crc32c "			  "loading error. Make sure the crc32c "			  "module is built as a module or into the "			  "kernel/n");	iscsi_tcp_conn_teardown(cls_conn);	return NULL;}static void iscsi_sw_tcp_release_conn(struct iscsi_conn *conn){	struct iscsi_session *session = conn->session;	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;	struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;	struct socket *sock = tcp_sw_conn->sock;	if (!sock)		return;	sock_hold(sock->sk);	iscsi_sw_tcp_conn_restore_callbacks(tcp_sw_conn);	sock_put(sock->sk);	spin_lock_bh(&session->lock);	tcp_sw_conn->sock = NULL;	spin_unlock_bh(&session->lock);	sockfd_put(sock);}static void iscsi_sw_tcp_conn_destroy(struct iscsi_cls_conn *cls_conn){	struct iscsi_conn *conn = cls_conn->dd_data;	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;	struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;	iscsi_sw_tcp_release_conn(conn);	if (tcp_sw_conn->tx_hash.tfm)		crypto_free_hash(tcp_sw_conn->tx_hash.tfm);	if (tcp_sw_conn->rx_hash.tfm)		crypto_free_hash(tcp_sw_conn->rx_hash.tfm);	iscsi_tcp_conn_teardown(cls_conn);}static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag){	struct iscsi_conn *conn = cls_conn->dd_data;	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;	struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;	/* userspace may have goofed up and not bound us */	if (!tcp_sw_conn->sock)		return;	/*	 * Make sure our recv side is stopped.	 * Older tools called conn stop before ep_disconnect	 * so IO could still be coming in.	 */

/* * To start a new USB/IP attachment, a userland program needs to setup a TCP * connection and then write its socket descriptor with remote device * information into this sysfs file. * * A remote device is virtually attached to the root-hub port of @rhport with * @speed. @devid is embedded into a request to specify the remote device in a * server host. * * write() returns 0 on success, else negative errno. */static ssize_t store_attach(struct device *dev, struct device_attribute *attr,			    const char *buf, size_t count){	struct vhci_device *vdev;	struct socket *socket;	int sockfd = 0;	__u32 rhport = 0, devid = 0, speed = 0;	int err;	/*	 * @rhport: port number of vhci_hcd	 * @sockfd: socket descriptor of an established TCP connection	 * @devid: unique device identifier in a remote host	 * @speed: usb device speed in a remote host	 */	if (sscanf(buf, "%u %u %u %u", &rhport, &sockfd, &devid, &speed) != 4)		return -EINVAL;	usbip_dbg_vhci_sysfs("rhport(%u) sockfd(%u) devid(%u) speed(%u)/n",			     rhport, sockfd, devid, speed);	/* check received parameters */	if (valid_args(rhport, speed) < 0)		return -EINVAL;	/* Extract socket from fd. */	socket = sockfd_lookup(sockfd, &err);	if (!socket)		return -EINVAL;	/* now need lock until setting vdev status as used */	/* begin a lock */	spin_lock(&the_controller->lock);	vdev = port_to_vdev(rhport);	spin_lock(&vdev->ud.lock);	if (vdev->ud.status != VDEV_ST_NULL) {		/* end of the lock */		spin_unlock(&vdev->ud.lock);		spin_unlock(&the_controller->lock);		sockfd_put(socket);		dev_err(dev, "port %d already used/n", rhport);		return -EINVAL;	}	dev_info(dev,		 "rhport(%u) sockfd(%d) devid(%u) speed(%u) speed_str(%s)/n",		 rhport, sockfd, devid, speed, usb_speed_string(speed));	vdev->devid         = devid;	vdev->speed         = speed;	vdev->ud.tcp_socket = socket;	vdev->ud.status     = VDEV_ST_NOTASSIGNED;	spin_unlock(&vdev->ud.lock);	spin_unlock(&the_controller->lock);	/* end the lock */	vdev->ud.tcp_rx = kthread_get_run(vhci_rx_loop, &vdev->ud, "vhci_rx");	vdev->ud.tcp_tx = kthread_get_run(vhci_tx_loop, &vdev->ud, "vhci_tx");	rh_port_connect(rhport, speed);	return count;}

//.........这里部分代码省略.........	tcp_conn->rx_hash = &tcp_sw_conn->rx_hash;	return cls_conn;free_tx_tfm:	crypto_free_hash(tcp_sw_conn->tx_hash.tfm);free_conn:	iscsi_conn_printk(KERN_ERR, conn,			  "Could not create connection due to crc32c "			  "loading error. Make sure the crc32c "			  "module is built as a module or into the "			  "kernel/n");	iscsi_tcp_conn_teardown(cls_conn);	return NULL;}static void iscsi_sw_tcp_release_conn(struct iscsi_conn *conn){	struct iscsi_session *session = conn->session;	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;	struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;	struct socket *sock = tcp_sw_conn->sock;	if (!sock)		return;	sock_hold(sock->sk);	iscsi_sw_tcp_conn_restore_callbacks(conn);	sock_put(sock->sk);	spin_lock_bh(&session->frwd_lock);	tcp_sw_conn->sock = NULL;	spin_unlock_bh(&session->frwd_lock);	sockfd_put(sock);}static void iscsi_sw_tcp_conn_destroy(struct iscsi_cls_conn *cls_conn){	struct iscsi_conn *conn = cls_conn->dd_data;	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;	struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;	iscsi_sw_tcp_release_conn(conn);	if (tcp_sw_conn->tx_hash.tfm)		crypto_free_hash(tcp_sw_conn->tx_hash.tfm);	if (tcp_sw_conn->rx_hash.tfm)		crypto_free_hash(tcp_sw_conn->rx_hash.tfm);	iscsi_tcp_conn_teardown(cls_conn);}static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag){	struct iscsi_conn *conn = cls_conn->dd_data;	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;	struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;	struct socket *sock = tcp_sw_conn->sock;	/* userspace may have goofed up and not bound us */	if (!sock)		return;	sock->sk->sk_err = EIO;	wake_up_interruptible(sk_sleep(sock->sk));

static long vhost_net_set_backend(struct vhost_net *n, unsigned index, int fd){	struct socket *sock, *oldsock;	struct vhost_virtqueue *vq;	struct vhost_net_virtqueue *nvq;	struct vhost_net_ubuf_ref *ubufs, *oldubufs = NULL;	int r;	mutex_lock(&n->dev.mutex);	r = vhost_dev_check_owner(&n->dev);	if (r)		goto err;	if (index >= VHOST_NET_VQ_MAX) {		r = -ENOBUFS;		goto err;	}	vq = &n->vqs[index].vq;	nvq = &n->vqs[index];	mutex_lock(&vq->mutex);	/* Verify that ring has been setup correctly. */	if (!vhost_vq_access_ok(vq)) {		r = -EFAULT;		goto err_vq;	}	sock = get_socket(fd);	if (IS_ERR(sock)) {		r = PTR_ERR(sock);		goto err_vq;	}	/* start polling new socket */	oldsock = vq->private_data;	if (sock != oldsock) {		ubufs = vhost_net_ubuf_alloc(vq,					     sock && vhost_sock_zcopy(sock));		if (IS_ERR(ubufs)) {			r = PTR_ERR(ubufs);			goto err_ubufs;		}		vhost_net_disable_vq(n, vq);		vq->private_data = sock;		r = vhost_init_used(vq);		if (r)			goto err_used;		r = vhost_net_enable_vq(n, vq);		if (r)			goto err_used;		oldubufs = nvq->ubufs;		nvq->ubufs = ubufs;		n->tx_packets = 0;		n->tx_zcopy_err = 0;		n->tx_flush = false;	}	mutex_unlock(&vq->mutex);	if (oldubufs) {		vhost_net_ubuf_put_wait_and_free(oldubufs);		mutex_lock(&vq->mutex);		vhost_zerocopy_signal_used(n, vq);		mutex_unlock(&vq->mutex);	}	if (oldsock) {		vhost_net_flush_vq(n, index);		sockfd_put(oldsock);	}	mutex_unlock(&n->dev.mutex);	return 0;err_used:	vq->private_data = oldsock;	vhost_net_enable_vq(n, vq);	if (ubufs)		vhost_net_ubuf_put_wait_and_free(ubufs);err_ubufs:	sockfd_put(sock);err_vq:	mutex_unlock(&vq->mutex);err:	mutex_unlock(&n->dev.mutex);	return r;}

inline u32 compute_snaplen(struct event_filler_arguments *args, char *buf, u32 lookahead_size){	u32 res = args->consumer->snaplen;	int err;	struct socket *sock;	sa_family_t family;	struct sockaddr_storage sock_address;	struct sockaddr_storage peer_address;	int sock_address_len;	int peer_address_len;	u16 sport, dport;/*	if (args->event_type == PPME_SYSCALL_WRITE_X) {#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)		struct fd f = fdget(args->fd);		if (f.file && f.file->f_op) {			if (THIS_MODULE == f.file->f_op->owner) {				res = RW_SNAPLEN_EVENT;				fdput(f);				return res;			}			fdput(f);		}#else		struct file* file = fget(args->fd);		if (file && file->f_op) {			if (THIS_MODULE == file->f_op->owner) {				res = RW_SNAPLEN_EVENT;				fput(file);				return res;			}			fput(file);		}#endif	}*/	if (!args->consumer->do_dynamic_snaplen)		return res;	sock = sockfd_lookup(args->fd, &err);	if (sock) {		if (sock->sk) {			err = sock->ops->getname(sock, (struct sockaddr *)&sock_address, &sock_address_len, 0);			if (err == 0) {				err = sock->ops->getname(sock, (struct sockaddr *)&peer_address, &peer_address_len, 1);				if (err == 0) {					family = sock->sk->sk_family;					if (family == AF_INET) {						sport = ntohs(((struct sockaddr_in *) &sock_address)->sin_port);						dport = ntohs(((struct sockaddr_in *) &peer_address)->sin_port);					} else if (family == AF_INET6) {						sport = ntohs(((struct sockaddr_in6 *) &sock_address)->sin6_port);						dport = ntohs(((struct sockaddr_in6 *) &peer_address)->sin6_port);					} else {						sport = 0;						dport = 0;					}					if (sport == PPM_PORT_MYSQL || dport == PPM_PORT_MYSQL) {						if (lookahead_size >= 5) {							if (buf[0] == 3 || buf[1] == 3 || buf[2] == 3 || buf[3] == 3 || buf[4] == 3) {								sockfd_put(sock);								return 2000;							} else if (buf[2] == 0 && buf[3] == 0) {								sockfd_put(sock);								return 2000;							}						}					} else if (sport == PPM_PORT_POSTGRES || dport == PPM_PORT_POSTGRES) {						if (lookahead_size >= 2) {							if ((buf[0] == 'Q' && buf[1] == 0) || /* SimpleQuery command */								(buf[0] == 'P' && buf[1] == 0) || /* Prepare statement commmand */								(buf[4] == 0 && buf[5] == 3 && buf[6] == 0) || /* startup command */								(buf[0] == 'E' && buf[1] == 0) /* error or execute command */							) {								sockfd_put(sock);								return 2000;							}						}					} else if ((lookahead_size >= 4 && buf[1] == 0 && buf[2] == 0 && buf[2] == 0) || /* matches command */								(lookahead_size >= 16 && (*(int32_t *)(buf+12) == 1 || /* matches header */									*(int32_t *)(buf+12) == 2001 ||									*(int32_t *)(buf+12) == 2002 ||									*(int32_t *)(buf+12) == 2003 ||									*(int32_t *)(buf+12) == 2004 ||									*(int32_t *)(buf+12) == 2005 ||									*(int32_t *)(buf+12) == 2006 ||									*(int32_t *)(buf+12) == 2007)							   )							) {//.........这里部分代码省略.........

static intMksckPageDescToFd(struct socket *sock,		  struct msghdr *msg,		  Mksck_PageDesc *pd,		  uint32 pages){	int retval;	int newfd;	struct socket *newsock;	struct sock *newsk;	struct sock *sk = sock->sk;	struct MksckPageDescInfo **pmpdi, *mpdi;	lock_sock(sk);	if (sk->sk_user_data) {		struct MksckPageDescInfo *mpdi2;				newfd = *((int *)sk->sk_user_data);				newsock = sockfd_lookup(newfd, &retval);		if (!newsock) {			retval = -EINVAL;			goto endProcessingReleaseSock;		}		newsk = newsock->sk;		lock_sock(newsk);		sockfd_put(newsock);		if (((struct sock *)newsk->sk_user_data) != sk) {			retval = -EINVAL;			release_sock(newsk);			goto endProcessingReleaseSock;		}		mpdi = kmalloc(sizeof(struct MksckPageDescInfo) +			       pages*sizeof(Mksck_PageDesc), GFP_KERNEL);		if (!mpdi) {			retval = -ENOMEM;			release_sock(newsk);			goto endProcessingReleaseSock;		}		retval = put_cmsg(msg, SOL_DECNET, 0, sizeof(int), &newfd);		if (retval < 0)			goto endProcessingKFreeReleaseSock;		release_sock(sk);		mpdi2 = (struct MksckPageDescInfo *)newsk->sk_protinfo;		while (mpdi2->next)			mpdi2 = mpdi2->next;		pmpdi = &(mpdi2->next);	} else {		retval = sock_create(sk->sk_family, sock->type, 0, &newsock);		if (retval < 0)			goto endProcessingReleaseSock;		newsk = newsock->sk;		lock_sock(newsk);		newsk->sk_destruct = &MksckPageDescSkDestruct;		newsk->sk_user_data = sk;		sock_hold(sk); 		newsock->ops = &mksckPageDescOps;		mpdi = kmalloc(sizeof(struct MksckPageDescInfo) +			       pages*sizeof(Mksck_PageDesc), GFP_KERNEL);		if (!mpdi) {			retval = -ENOMEM;			goto endProcessingFreeNewSock;		}		sk->sk_user_data = sock_kmalloc(sk, sizeof(int), GFP_KERNEL);		if (sk->sk_user_data == NULL) {			retval = -ENOMEM;			goto endProcessingKFreeAndNewSock;		}		newfd = sock_map_fd(newsock, O_CLOEXEC);		if (newfd < 0) {			retval = newfd;			sock_kfree_s(sk, sk->sk_user_data, sizeof(int));			sk->sk_user_data = NULL;			goto endProcessingKFreeAndNewSock;		}		retval = put_cmsg(msg, SOL_DECNET, 0, sizeof(int), &newfd);		if (retval < 0) {			sock_kfree_s(sk, sk->sk_user_data, sizeof(int));			sk->sk_user_data = NULL;			kfree(mpdi);			release_sock(newsk);			sockfd_put(newsock);			sock_release(newsock);			put_unused_fd(newfd);//.........这里部分代码省略.........

//.........这里部分代码省略.........	ncp_lock_server(server);	error = ncp_connect(server);	ncp_unlock_server(server);	if (error < 0)		goto out_rxbuf;	ncp_dbg(1, "NCP_SBP(sb) = %p/n", NCP_SBP(sb));	error = -EMSGSIZE;	/* -EREMOTESIDEINCOMPATIBLE */#ifdef CONFIG_NCPFS_PACKET_SIGNING	if (ncp_negotiate_size_and_options(server, default_bufsize,		NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)	{		if (options != NCP_DEFAULT_OPTIONS)		{			if (ncp_negotiate_size_and_options(server, 				default_bufsize,				options & 2, 				&(server->buffer_size), &options) != 0)							{				goto out_disconnect;			}		}		ncp_lock_server(server);		if (options & 2)			server->sign_wanted = 1;		ncp_unlock_server(server);	}	else #endif	/* CONFIG_NCPFS_PACKET_SIGNING */	if (ncp_negotiate_buffersize(server, default_bufsize,  				     &(server->buffer_size)) != 0)		goto out_disconnect;	ncp_dbg(1, "bufsize = %d/n", server->buffer_size);	memset(&finfo, 0, sizeof(finfo));	finfo.i.attributes	= aDIR;	finfo.i.dataStreamSize	= 0;	/* ignored */	finfo.i.dirEntNum	= 0;	finfo.i.DosDirNum	= 0;#ifdef CONFIG_NCPFS_SMALLDOS	finfo.i.NSCreator	= NW_NS_DOS;#endif	finfo.volume		= NCP_NUMBER_OF_VOLUMES;	/* set dates of mountpoint to Jan 1, 1986; 00:00 */	finfo.i.creationTime	= finfo.i.modifyTime				= cpu_to_le16(0x0000);	finfo.i.creationDate	= finfo.i.modifyDate				= finfo.i.lastAccessDate				= cpu_to_le16(0x0C21);	finfo.i.nameLen		= 0;	finfo.i.entryName[0]	= '/0';	finfo.opened		= 0;	finfo.ino		= 2;	/* tradition */	server->name_space[finfo.volume] = NW_NS_DOS;	error = -ENOMEM;        root_inode = ncp_iget(sb, &finfo);        if (!root_inode)		goto out_disconnect;	ncp_dbg(1, "root vol=%d/n", NCP_FINFO(root_inode)->volNumber);	sb->s_root = d_make_root(root_inode);        if (!sb->s_root)		goto out_disconnect;	return 0;out_disconnect:	ncp_lock_server(server);	ncp_disconnect(server);	ncp_unlock_server(server);out_rxbuf:	ncp_stop_tasks(server);	vfree(server->rxbuf);out_txbuf:	vfree(server->txbuf);out_packet:	vfree(server->packet);out_nls:#ifdef CONFIG_NCPFS_NLS	unload_nls(server->nls_io);	unload_nls(server->nls_vol);#endif	mutex_destroy(&server->rcv.creq_mutex);	mutex_destroy(&server->root_setup_lock);	mutex_destroy(&server->mutex);out_fput2:	if (server->info_sock)		sockfd_put(server->info_sock);out_bdi:	bdi_destroy(&server->bdi);out_fput:	sockfd_put(sock);out:	put_pid(data.wdog_pid);	sb->s_fs_info = NULL;	kfree(server);	return error;}

static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg){    void __user *argp = (void __user *) arg;    struct hidp_connadd_req ca;    struct hidp_conndel_req cd;    struct hidp_connlist_req cl;    struct hidp_conninfo ci;    struct socket *csock;    struct socket *isock;    int err;    BT_DBG("cmd %x arg %lx", cmd, arg);    switch (cmd) {    case HIDPCONNADD:        if (!capable(CAP_NET_ADMIN))            return -EPERM;        if (copy_from_user(&ca, argp, sizeof(ca)))            return -EFAULT;        csock = sockfd_lookup(ca.ctrl_sock, &err);        if (!csock)            return err;        isock = sockfd_lookup(ca.intr_sock, &err);        if (!isock) {            sockfd_put(csock);            return err;        }        err = hidp_connection_add(&ca, csock, isock);        if (!err && copy_to_user(argp, &ca, sizeof(ca)))            err = -EFAULT;        sockfd_put(csock);        sockfd_put(isock);        return err;    case HIDPCONNDEL:        if (!capable(CAP_NET_ADMIN))            return -EPERM;        if (copy_from_user(&cd, argp, sizeof(cd)))            return -EFAULT;        return hidp_connection_del(&cd);    case HIDPGETCONNLIST:        if (copy_from_user(&cl, argp, sizeof(cl)))            return -EFAULT;        if (cl.cnum <= 0)            return -EINVAL;        err = hidp_get_connlist(&cl);        if (!err && copy_to_user(argp, &cl, sizeof(cl)))            return -EFAULT;        return err;    case HIDPGETCONNINFO:        if (copy_from_user(&ci, argp, sizeof(ci)))            return -EFAULT;        err = hidp_get_conninfo(&ci);        if (!err && copy_to_user(argp, &ci, sizeof(ci)))            return -EFAULT;        return err;    }    return -EINVAL;}