Lines Matching refs:xprt
18 #include <linux/sunrpc/xprt.h>
29 static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt);
33 static void svc_delete_xprt(struct svc_xprt *xprt);
55 * The XPT_BUSY bit in xprt->xpt_flags prevents a transport being
144 struct svc_xprt *xprt =
146 struct module *owner = xprt->xpt_class->xcl_owner;
147 if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags))
148 svcauth_unix_info_release(xprt);
149 put_cred(xprt->xpt_cred);
150 put_net(xprt->xpt_net);
152 if (xprt->xpt_bc_xprt)
153 xprt_put(xprt->xpt_bc_xprt);
154 if (xprt->xpt_bc_xps)
155 xprt_switch_put(xprt->xpt_bc_xps);
156 trace_svc_xprt_free(xprt);
157 xprt->xpt_ops->xpo_free(xprt);
161 void svc_xprt_put(struct svc_xprt *xprt)
163 kref_put(&xprt->xpt_ref, svc_xprt_free);
172 struct svc_xprt *xprt, struct svc_serv *serv)
174 memset(xprt, 0, sizeof(*xprt));
175 xprt->xpt_class = xcl;
176 xprt->xpt_ops = xcl->xcl_ops;
177 kref_init(&xprt->xpt_ref);
178 xprt->xpt_server = serv;
179 INIT_LIST_HEAD(&xprt->xpt_list);
180 INIT_LIST_HEAD(&xprt->xpt_ready);
181 INIT_LIST_HEAD(&xprt->xpt_deferred);
182 INIT_LIST_HEAD(&xprt->xpt_users);
183 mutex_init(&xprt->xpt_mutex);
184 spin_lock_init(&xprt->xpt_lock);
185 set_bit(XPT_BUSY, &xprt->xpt_flags);
186 xprt->xpt_net = get_net(net);
187 strcpy(xprt->xpt_remotebuf, "uninitialized");
210 struct svc_xprt *xprt;
229 xprt = xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
230 if (IS_ERR(xprt))
232 xcl->xcl_name, sap, xprt);
233 return xprt;
244 static void svc_xprt_received(struct svc_xprt *xprt)
246 if (!test_bit(XPT_BUSY, &xprt->xpt_flags)) {
247 WARN_ONCE(1, "xprt=0x%p already busy!", xprt);
251 /* As soon as we clear busy, the xprt could be closed and
254 svc_xprt_get(xprt);
256 clear_bit(XPT_BUSY, &xprt->xpt_flags);
257 xprt->xpt_server->sv_ops->svo_enqueue_xprt(xprt);
258 svc_xprt_put(xprt);
323 * Copy the local and remote xprt addresses to the rqstp structure
325 void svc_xprt_copy_addrs(struct svc_rqst *rqstp, struct svc_xprt *xprt)
327 memcpy(&rqstp->rq_addr, &xprt->xpt_remote, xprt->xpt_remotelen);
328 rqstp->rq_addrlen = xprt->xpt_remotelen;
334 memcpy(&rqstp->rq_daddr, &xprt->xpt_local, xprt->xpt_locallen);
335 rqstp->rq_daddrlen = xprt->xpt_locallen;
352 static bool svc_xprt_slots_in_range(struct svc_xprt *xprt)
355 int nrqsts = atomic_read(&xprt->xpt_nr_rqsts);
360 static bool svc_xprt_reserve_slot(struct svc_rqst *rqstp, struct svc_xprt *xprt)
363 if (!svc_xprt_slots_in_range(xprt))
365 atomic_inc(&xprt->xpt_nr_rqsts);
373 struct svc_xprt *xprt = rqstp->rq_xprt;
375 atomic_dec(&xprt->xpt_nr_rqsts);
377 svc_xprt_enqueue(xprt);
381 static bool svc_xprt_ready(struct svc_xprt *xprt)
394 xpt_flags = READ_ONCE(xprt->xpt_flags);
399 if (xprt->xpt_ops->xpo_has_wspace(xprt) &&
400 svc_xprt_slots_in_range(xprt))
402 trace_svc_xprt_no_write_space(xprt);
408 void svc_xprt_do_enqueue(struct svc_xprt *xprt)
414 if (!svc_xprt_ready(xprt))
422 if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
426 pool = svc_pool_for_cpu(xprt->xpt_server, cpu);
431 list_add_tail(&xprt->xpt_ready, &pool->sp_sockets);
435 /* find a thread for this xprt */
450 trace_svc_xprt_do_enqueue(xprt, rqstp);
459 void svc_xprt_enqueue(struct svc_xprt *xprt)
461 if (test_bit(XPT_BUSY, &xprt->xpt_flags))
463 xprt->xpt_server->sv_ops->svo_enqueue_xprt(xprt);
472 struct svc_xprt *xprt = NULL;
479 xprt = list_first_entry(&pool->sp_sockets,
481 list_del_init(&xprt->xpt_ready);
482 svc_xprt_get(xprt);
486 return xprt;
501 struct svc_xprt *xprt = rqstp->rq_xprt;
505 if (xprt && space < rqstp->rq_reserved) {
506 atomic_sub((rqstp->rq_reserved - space), &xprt->xpt_reserved);
509 svc_xprt_enqueue(xprt);
516 struct svc_xprt *xprt = rqstp->rq_xprt;
518 xprt->xpt_ops->xpo_release_rqst(rqstp);
541 svc_xprt_put(xprt);
545 * Some svc_serv's will have occasional work to do, even when a xprt is not
615 struct svc_xprt *xprt = NULL;
627 xprt = list_entry(serv->sv_tempsocks.prev,
630 set_bit(XPT_CLOSE, &xprt->xpt_flags);
631 svc_xprt_get(xprt);
635 if (xprt) {
636 svc_xprt_enqueue(xprt);
637 svc_xprt_put(xprt);
779 static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
784 if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
785 if (test_and_clear_bit(XPT_KILL_TEMP, &xprt->xpt_flags))
786 xprt->xpt_ops->xpo_kill_temp_xprt(xprt);
787 svc_delete_xprt(xprt);
788 /* Leave XPT_BUSY set on the dead xprt: */
791 if (test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
797 __module_get(xprt->xpt_class->xcl_owner);
798 svc_check_conn_limits(xprt->xpt_server);
799 newxpt = xprt->xpt_ops->xpo_accept(xprt);
801 newxpt->xpt_cred = get_cred(xprt->xpt_cred);
805 module_put(xprt->xpt_class->xcl_owner);
806 } else if (svc_xprt_reserve_slot(rqstp, xprt)) {
809 rqstp, rqstp->rq_pool->sp_id, xprt,
810 kref_read(&xprt->xpt_ref));
811 rqstp->rq_deferred = svc_deferred_dequeue(xprt);
815 len = xprt->xpt_ops->xpo_recvfrom(rqstp);
820 atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
823 svc_xprt_received(xprt);
825 trace_svc_handle_xprt(xprt, len);
836 struct svc_xprt *xprt = NULL;
850 xprt = svc_get_next_xprt(rqstp, timeout);
851 if (IS_ERR(xprt)) {
852 err = PTR_ERR(xprt);
856 len = svc_handle_xprt(rqstp, xprt);
863 clear_bit(XPT_OLD, &xprt->xpt_flags);
865 xprt->xpt_ops->xpo_secure_port(rqstp);
896 struct svc_xprt *xprt;
900 xprt = rqstp->rq_xprt;
901 if (!xprt)
912 len = xprt->xpt_ops->xpo_sendto(rqstp);
930 struct svc_xprt *xprt;
943 xprt = list_entry(le, struct svc_xprt, xpt_list);
947 if (!test_and_set_bit(XPT_OLD, &xprt->xpt_flags))
949 if (kref_read(&xprt->xpt_ref) > 1 ||
950 test_bit(XPT_BUSY, &xprt->xpt_flags))
953 set_bit(XPT_CLOSE, &xprt->xpt_flags);
954 dprintk("queuing xprt %p for closing\n", xprt);
957 svc_xprt_enqueue(xprt);
972 struct svc_xprt *xprt;
978 xprt = list_entry(le, struct svc_xprt, xpt_list);
980 &xprt->xpt_local)) {
981 dprintk("svc_age_temp_xprts_now: found %p\n", xprt);
990 xprt = list_entry(le, struct svc_xprt, xpt_list);
991 set_bit(XPT_CLOSE, &xprt->xpt_flags);
992 set_bit(XPT_KILL_TEMP, &xprt->xpt_flags);
993 dprintk("svc_age_temp_xprts_now: queuing xprt %p for closing\n",
994 xprt);
995 svc_xprt_enqueue(xprt);
1000 static void call_xpt_users(struct svc_xprt *xprt)
1004 spin_lock(&xprt->xpt_lock);
1005 while (!list_empty(&xprt->xpt_users)) {
1006 u = list_first_entry(&xprt->xpt_users, struct svc_xpt_user, list);
1010 spin_unlock(&xprt->xpt_lock);
1016 static void svc_delete_xprt(struct svc_xprt *xprt)
1018 struct svc_serv *serv = xprt->xpt_server;
1021 if (test_and_set_bit(XPT_DEAD, &xprt->xpt_flags))
1024 trace_svc_xprt_detach(xprt);
1025 xprt->xpt_ops->xpo_detach(xprt);
1026 if (xprt->xpt_bc_xprt)
1027 xprt->xpt_bc_xprt->ops->close(xprt->xpt_bc_xprt);
1030 list_del_init(&xprt->xpt_list);
1031 WARN_ON_ONCE(!list_empty(&xprt->xpt_ready));
1032 if (test_bit(XPT_TEMP, &xprt->xpt_flags))
1036 while ((dr = svc_deferred_dequeue(xprt)) != NULL)
1039 call_xpt_users(xprt);
1040 svc_xprt_put(xprt);
1043 void svc_close_xprt(struct svc_xprt *xprt)
1045 trace_svc_xprt_close(xprt);
1046 set_bit(XPT_CLOSE, &xprt->xpt_flags);
1047 if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
1056 svc_delete_xprt(xprt);
1062 struct svc_xprt *xprt;
1066 list_for_each_entry(xprt, xprt_list, xpt_list) {
1067 if (xprt->xpt_net != net)
1070 set_bit(XPT_CLOSE, &xprt->xpt_flags);
1071 svc_xprt_enqueue(xprt);
1080 struct svc_xprt *xprt;
1088 list_for_each_entry_safe(xprt, tmp, &pool->sp_sockets, xpt_ready) {
1089 if (xprt->xpt_net != net)
1091 list_del_init(&xprt->xpt_ready);
1093 return xprt;
1102 struct svc_xprt *xprt;
1104 while ((xprt = svc_dequeue_net(serv, net))) {
1105 set_bit(XPT_CLOSE, &xprt->xpt_flags);
1106 svc_delete_xprt(xprt);
1142 struct svc_xprt *xprt = dr->xprt;
1144 spin_lock(&xprt->xpt_lock);
1145 set_bit(XPT_DEFERRED, &xprt->xpt_flags);
1146 if (too_many || test_bit(XPT_DEAD, &xprt->xpt_flags)) {
1147 spin_unlock(&xprt->xpt_lock);
1149 svc_xprt_put(xprt);
1153 dr->xprt = NULL;
1154 list_add(&dr->handle.recent, &xprt->xpt_deferred);
1155 spin_unlock(&xprt->xpt_lock);
1157 svc_xprt_enqueue(xprt);
1158 svc_xprt_put(xprt);
1165 * <xprt-header><rpc-header><rpc-pagelist><rpc-tail>
1167 * This code can only handle requests that consist of an xprt-header
1204 dr->xprt = rqstp->rq_xprt;
1238 static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt)
1242 if (!test_bit(XPT_DEFERRED, &xprt->xpt_flags))
1244 spin_lock(&xprt->xpt_lock);
1245 if (!list_empty(&xprt->xpt_deferred)) {
1246 dr = list_entry(xprt->xpt_deferred.next,
1251 clear_bit(XPT_DEFERRED, &xprt->xpt_flags);
1252 spin_unlock(&xprt->xpt_lock);
1276 struct svc_xprt *xprt;
1284 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
1285 if (xprt->xpt_net != net)
1287 if (strcmp(xprt->xpt_class->xcl_name, xcl_name))
1289 if (af != AF_UNSPEC && af != xprt->xpt_local.ss_family)
1291 if (port != 0 && port != svc_xprt_local_port(xprt))
1293 found = xprt;
1294 svc_xprt_get(xprt);
1302 static int svc_one_xprt_name(const struct svc_xprt *xprt,
1308 xprt->xpt_class->xcl_name,
1309 svc_xprt_local_port(xprt));
1329 struct svc_xprt *xprt;
1341 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
1342 len = svc_one_xprt_name(xprt, pos, buflen - totlen);